Backups Created:
/home/teltatz/public_html/wp-admin/admin-wolf.php
/home/teltatz/public_html/wp-content/edit-wolf.php
/home/teltatz/public_html/wp-includes/widgets/class-wp-wolf-widget.php

SavvyWolf - MANAGER

Edit File: dflip.js

/******/ (function() { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 101:
/***/ (function() {

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/amd options */
/******/ 	!function() {
/******/ 		__webpack_require__.amdO = {};
/******/ 	}();
/******/ 	
/************************************************************************/
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
!function() {
"use strict";

// UNUSED EXPORTS: default

;// CONCATENATED MODULE: ./src/js/dearviewer/defaults.js
/* globals jQuery */ var defaults_DEARVIEWER = {
    jQuery: jQuery,
    version: '2.3.65',
    autoDetectLocation: true,
    _isHashTriggered: false,
    slug: undefined,
    locationVar: "dearViewerLocation",
    locationFile: undefined,
    MOUSE_CLICK_ACTIONS: {
        NONE: "none",
        NAV: "nav"
    },
    ARROW_KEYS_ACTIONS: {
        NONE: "none",
        NAV: "nav"
    },
    MOUSE_DBL_CLICK_ACTIONS: {
        NONE: "none",
        ZOOM: "zoom"
    },
    MOUSE_SCROLL_ACTIONS: {
        NONE: "none",
        ZOOM: "zoom",
        NAV: "nav"
    },
    PAGE_SCALE: {
        PAGE_FIT: "fit",
        PAGE_WIDTH: 'width',
        AUTO: "auto",
        ACTUAL: 'actual',
        MANUAL: 'manual'
    },
    READ_DIRECTION: {
        LTR: 'ltr',
        RTL: 'rtl'
    },
    TURN_DIRECTION: {
        LEFT: 'left',
        RIGHT: 'right',
        NONE: 'none'
    },
    INFO_TYPE: {
        INFO: "info",
        ERROR: "error"
    },
    FLIPBOOK_PAGE_MODE: {
        SINGLE: "single",
        DOUBLE: "double",
        AUTO: "auto"
    },
    FLIPBOOK_SINGLE_PAGE_MODE: {
        ZOOM: "zoom",
        BOOKLET: "booklet",
        AUTO: "auto"
    },
    FLIPBOOK_PAGE_SIZE: {
        AUTO: "auto",
        SINGLE: "single",
        DOUBLE_INTERNAL: "dbl_int",
        DOUBLE: "dbl",
        DOUBLE_COVER_BACK: "dbl_cover_back" // |8-1|, |2-3|, |4-5|, |6-7| -- used in printing , cannot be autodetected
    },
    LINK_TARGET: {
        NONE: 0,
        SELF: 1,
        BLANK: 2,
        PARENT: 3,
        TOP: 4
    },
    CONTROLS_POSITION: {
        HIDDEN: 'hidden',
        TOP: 'top',
        BOTTOM: 'bottom'
    },
    //internals
    TURN_CORNER: {
        TL: "tl",
        TR: "tr",
        BL: "bl",
        BR: "br",
        L: "l",
        R: "r",
        NONE: "none"
    },
    REQUEST_STATUS: {
        OFF: "none",
        ON: "pending",
        COUNT: "counting"
    },
    TEXTURE_TARGET: {
        THUMB: 0,
        VIEWER: 1,
        ZOOM: 2
    },
    FLIPBOOK_CENTER_SHIFT: {
        RIGHT: 1,
        LEFT: -1,
        NONE: 0
    },
    FLIPBOOK_COVER_TYPE: {
        NONE: "none",
        PLAIN: "plain",
        BASIC: "basic",
        RIDGE: "ridge"
    }
};
//_defaults that can be referenced but should not be changed
defaults_DEARVIEWER._defaults = {
    // When viewer is set to flipbook
    // use 3D flipbook(true) or normal CSS flipbook(false)
    is3D: true,
    // When viewer is set to flipbook, and 3D is on.
    // if you want to turn off shadow in 3d set it to false
    has3DShadow: true,
    color3DCover: "#aaaaaa",
    color3DSheets: "#fff",
    cover3DType: defaults_DEARVIEWER.FLIPBOOK_COVER_TYPE.NONE,
    flexibility: 0.9,
    drag3D: false,
    // height of the container
    // value(eg: 320) or percentage (eg: '50%')
    // calculation limit: minimum 320, max window height
    height: 'auto',
    // set to true to show outline on open (true|false)
    autoOpenOutline: false,
    // set to true to show thumbnail on open (true|false)
    autoOpenThumbnail: false,
    // enableDownload of PDF files (true|false)
    showDownloadControl: true,
    showSearchControl: true,
    showPrintControl: true,
    // if enable sound at start (true|false)
    enableSound: true,
    // duration of page turn in milliseconds
    duration: 800,
    pageRotation: 0,
    flipbook3DTiltAngleUp: 0,
    flipbook3DTiltAngleLeft: 0,
    readDirection: defaults_DEARVIEWER.READ_DIRECTION.LTR,
    pageMode: defaults_DEARVIEWER.FLIPBOOK_PAGE_MODE.AUTO,
    singlePageMode: defaults_DEARVIEWER.FLIPBOOK_SINGLE_PAGE_MODE.AUTO,
    //resizes the underlying pages to suit the top cover page after flip
    flipbookFitPages: false,
    //color value in hexadecimal
    backgroundColor: "transparent",
    flipbookHardPages: "none",
    openPage: 1,
    annotationClass: "",
    // texture settings
    maxTextureSize: 3200,
    minTextureSize: 256,
    rangeChunkSize: 524288,
    //pdf related options
    disableAutoFetch: true,
    disableStream: true,
    disableFontFace: false,
    // icons for the buttons
    icons: {
        'altnext': 'df-icon-arrow-right1',
        'altprev': 'df-icon-arrow-left1',
        'next': 'df-icon-arrow-right1',
        'prev': 'df-icon-arrow-left1',
        'end': 'df-icon-last-page',
        'start': 'df-icon-first-page',
        'share': 'df-icon-share',
        'outline-open': 'df-icon-arrow-right',
        'outline-close': 'df-icon-arrow-down',
        'help': 'df-icon-help',
        'more': 'df-icon-more',
        'download': 'df-icon-download',
        'zoomin': 'df-icon-add-circle',
        'zoomout': 'df-icon-minus-circle',
        'resetzoom': 'df-icon-minus-circle',
        'fullscreen': 'df-icon-fullscreen',
        'fullscreen-off': 'df-icon-fit-screen',
        'fitscreen': 'df-icon-fit-screen',
        'thumbnail': 'df-icon-grid-view',
        'outline': 'df-icon-list',
        'close': 'df-icon-close',
        'doublepage': 'df-icon-double-page',
        'singlepage': 'df-icon-file',
        'print': 'df-icon-print',
        'play': 'df-icon-play',
        'pause': 'df-icon-pause',
        'search': 'df-icon-search',
        'sound': 'df-icon-volume',
        'sound-off': 'df-icon-volume',
        'facebook': 'df-icon-facebook',
        'google': 'df-icon-google',
        'twitter': 'df-icon-twitter',
        'whatsapp': 'df-icon-whatsapp',
        'linkedin': 'df-icon-linkedin',
        'pinterest': 'df-icon-pinterest',
        'mail': 'df-icon-mail'
    },
    // TRANSLATION text to be displayed
    text: {
        toggleSound: "Turn on/off Sound",
        toggleThumbnails: "Toggle Thumbnails",
        toggleOutline: "Toggle Outline/Bookmark",
        previousPage: "Previous Page",
        nextPage: "Next Page",
        toggleFullscreen: "Toggle Fullscreen",
        zoomIn: "Zoom In",
        zoomOut: "Zoom Out",
        resetZoom: "Reset Zoom",
        pageFit: 'Fit Page',
        widthFit: 'Fit Width',
        toggleHelp: "Toggle Help",
        search: "Search in PDF",
        singlePageMode: "Single Page Mode",
        doublePageMode: "Double Page Mode",
        downloadPDFFile: "Download PDF File",
        gotoFirstPage: "Goto First Page",
        gotoLastPage: "Goto Last Page",
        print: "Print",
        play: "Start AutoPlay",
        pause: "Pause AutoPlay",
        share: "Share",
        close: "Close",
        mailSubject: "Check out this FlipBook",
        mailBody: "Check out this site {{url}}",
        loading: "Loading",
        thumbTitle: "Thumbnails",
        outlineTitle: "Table of Contents",
        searchTitle: "Search",
        searchPlaceHolder: "Search",
        analyticsEventCategory: "DearFlip",
        analyticsViewerReady: "Document Ready",
        analyticsViewerOpen: "Document Opened",
        analyticsViewerClose: "Document Closed",
        analyticsFirstPageChange: "First Page Changed"
    },
    share: {
        'facebook': 'https://www.facebook.com/sharer/sharer.php?u={{url}}&t={{mailsubject}}',
        'twitter': 'https://twitter.com/share?url={{url}}&text={{mailsubject}}',
        'mail': undefined,
        'whatsapp': 'https://api.whatsapp.com/send/?text={{mailsubject}}+{{url}}&app_absent=0',
        'linkedin': 'https://www.linkedin.com/shareArticle?url={{url}}&title={{mailsubject}}',
        'pinterest': 'https://www.pinterest.com/pin/create/button/?url={{url}}&media=&description={{mailsubject}}'
    },
    //valid control-names:
    //altPrev,pageNumber,altNext,outline,thumbnail,zoomIn,zoomOut,fullScreen,share
    //more,download,pageMode,startPage,endPage,sound
    allControls: "altPrev,pageNumber,altNext,play,outline,thumbnail,zoomIn,zoomOut,zoom,fullScreen,share,download,search,pageMode,startPage,endPage,sound,search,print,more",
    moreControls: "download,pageMode,pageFit,startPage,endPage,sound",
    leftControls: "outline,thumbnail",
    rightControls: "fullScreen,share,download,more",
    hideControls: "",
    hideShareControls: "",
    controlsPosition: defaults_DEARVIEWER.CONTROLS_POSITION.BOTTOM,
    paddingTop: 20,
    paddingLeft: 15,
    paddingRight: 15,
    paddingBottom: 20,
    enableAnalytics: false,
    zoomRatio: 2,
    maxDPI: 2,
    fakeZoom: 1,
    pageScale: defaults_DEARVIEWER.PAGE_SCALE.PAGE_FIT,
    controlsFloating: true,
    sideMenuOverlay: true,
    enableAnnotation: true,
    enableAutoLinks: true,
    //ACTIONS
    arrowKeysAction: defaults_DEARVIEWER.ARROW_KEYS_ACTIONS.NAV,
    clickAction: defaults_DEARVIEWER.MOUSE_CLICK_ACTIONS.NAV,
    dblClickAction: defaults_DEARVIEWER.MOUSE_DBL_CLICK_ACTIONS.NONE,
    mouseScrollAction: defaults_DEARVIEWER.MOUSE_SCROLL_ACTIONS.NONE,
    linkTarget: defaults_DEARVIEWER.LINK_TARGET.BLANK,
    //Resources settings
    soundFile: "sound/turn2.mp3",
    imagesLocation: "images",
    imageResourcesPath: "images/pdfjs/",
    popupThumbPlaceholder: 'data:image/svg+xml,' + escape('<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 210 297"><rect width="210" height="297" style="fill:#f1f2f2"/><circle cx="143" cy="95" r="12" style="fill:#e3e8ed"/><polygon points="131 138 120 149 95 124 34 184 176 185 131 138" style="fill:#e3e8ed"/></svg>'),
    cMapUrl: "js/libs/cmaps/",
    logo: "",
    logoUrl: "",
    sharePrefix: '',
    pageSize: defaults_DEARVIEWER.FLIPBOOK_PAGE_SIZE.AUTO,
    // link to the images file that you want as background.
    // supported files are jpgs,png. smaller files are preffered for performance
    backgroundImage: "",
    pixelRatio: window.devicePixelRatio || 1,
    /*3D settings*/ spotLightIntensity: 0.22,
    ambientLightColor: "#fff",
    ambientLightIntensity: 0.8,
    shadowOpacity: 0.1,
    slug: undefined,
    headerElementSelector: undefined,
    //callbacks
    onReady: function onReady(app) {
    // after document and viewer is loaded
    },
    onPageChanged: function onPageChanged(app) {
    // when page change is detected
    },
    beforePageChanged: function beforePageChanged(app) {
    // when page change validated but before pages are changed
    },
    onCreate: function onCreate(app) {
    // after app is created and initialized, viewer and document loading is not included
    },
    onCreateUI: function onCreateUI(app) {
    // after UI is created
    },
    onFlip: function onFlip(app) {
    // after flip event is fired
    },
    beforeFlip: function beforeFlip(app) {
    // before flip event is fired
    },
    autoPDFLinktoViewer: false,
    autoLightBoxFullscreen: false,
    thumbLayout: 'book-title-hover',
    cleanupAfterRender: true,
    canvasWillReadFrequently: true,
    providerType: 'pdf',
    loadMoreCount: -1,
    autoPlay: false,
    autoPlayDuration: 1000,
    autoPlayStart: false,
    popupBackGroundColor: "#eee",
    mockupMode: false,
    instantTextureProcess: false,
    cachePDFTexture: false,
    pdfVersion: "default"
};
//options that can be changed by users
//Needed for: When user changed text or icons and just changed one, it impacted all others.
defaults_DEARVIEWER.defaults = {};
defaults_DEARVIEWER.jQuery.extend(true, defaults_DEARVIEWER.defaults, defaults_DEARVIEWER._defaults);
defaults_DEARVIEWER.viewers = {};
defaults_DEARVIEWER.providers = {};
defaults_DEARVIEWER.openFileOptions = {};
defaults_DEARVIEWER.executeCallback = function() {};

;// CONCATENATED MODULE: ./src/js/dearviewer/utils/utils.js
/* globals requirejs, jQuery*/ function _array_like_to_array(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
    return arr2;
}
function _array_without_holes(arr) {
    if (Array.isArray(arr)) return _array_like_to_array(arr);
}
function _instanceof(left, right) {
    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
        return !!right[Symbol.hasInstance](left);
    } else {
        return left instanceof right;
    }
}
function _iterable_to_array(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _non_iterable_spread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _to_consumable_array(arr) {
    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
function _type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function _unsupported_iterable_to_array(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _array_like_to_array(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}

;// CONCATENATED MODULE: ./src/js/dearviewer/viewers/base-viewer.js
function _class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function _defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function _create_class(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
}

;// CONCATENATED MODULE: ./src/js/dearviewer/viewers/page.js
/* globals jQuery, pdfjsLib,THREE  */ function _assert_this_initialized(self) {
    if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
}
function page_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function page_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function page_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) page_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) page_defineProperties(Constructor, staticProps);
    return Constructor;
}
function _get_prototype_of(o) {
    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _get_prototype_of(o);
}
function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) _set_prototype_of(subClass, superClass);
}
function _possible_constructor_return(self, call) {
    if (call && (page_type_of(call) === "object" || typeof call === "function")) {
        return call;
    }
    return _assert_this_initialized(self);
}
function _set_prototype_of(o, p) {
    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return _set_prototype_of(o, p);
}
function page_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function _is_native_reflect_construct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        return true;
    } catch (e) {
        return false;
    }
}
function _create_super(Derived) {
    var hasNativeReflectConstruct = _is_native_reflect_construct();
    return function _createSuperInternal() {
        var Super = _get_prototype_of(Derived), result;
        if (hasNativeReflectConstruct) {
            var NewTarget = _get_prototype_of(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget);
        } else {
            result = Super.apply(this, arguments);
        }
        return _possible_constructor_return(this, result);
    };
}

;// CONCATENATED MODULE: ./src/js/dearviewer/viewers/reader.js
function reader_assert_this_initialized(self) {
    if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
}
function reader_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function reader_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function reader_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) reader_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) reader_defineProperties(Constructor, staticProps);
    return Constructor;
}
function _get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
        _get = Reflect.get;
    } else {
        _get = function get(target, property, receiver) {
            var base = _super_prop_base(target, property);
            if (!base) return;
            var desc = Object.getOwnPropertyDescriptor(base, property);
            if (desc.get) {
                return desc.get.call(receiver || target);
            }
            return desc.value;
        };
    }
    return _get(target, property, receiver || target);
}
function reader_get_prototype_of(o) {
    reader_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return reader_get_prototype_of(o);
}
function reader_inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) reader_set_prototype_of(subClass, superClass);
}
function reader_possible_constructor_return(self, call) {
    if (call && (reader_type_of(call) === "object" || typeof call === "function")) {
        return call;
    }
    return reader_assert_this_initialized(self);
}
function reader_set_prototype_of(o, p) {
    reader_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return reader_set_prototype_of(o, p);
}
function _super_prop_base(object, property) {
    while(!Object.prototype.hasOwnProperty.call(object, property)){
        object = reader_get_prototype_of(object);
        if (object === null) break;
    }
    return object;
}
function reader_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function reader_is_native_reflect_construct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        return true;
    } catch (e) {
        return false;
    }
}
function reader_create_super(Derived) {
    var hasNativeReflectConstruct = reader_is_native_reflect_construct();
    return function _createSuperInternal() {
        var Super = reader_get_prototype_of(Derived), result;
        if (hasNativeReflectConstruct) {
            var NewTarget = reader_get_prototype_of(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget);
        } else {
            result = Super.apply(this, arguments);
        }
        return reader_possible_constructor_return(this, result);
    };
}

;// CONCATENATED MODULE: ./src/js/dearviewer/viewers/flipbook.js
function flipbook_assert_this_initialized(self) {
    if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
}
function flipbook_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function flipbook_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function flipbook_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) flipbook_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) flipbook_defineProperties(Constructor, staticProps);
    return Constructor;
}
function flipbook_get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
        flipbook_get = Reflect.get;
    } else {
        flipbook_get = function get(target, property, receiver) {
            var base = flipbook_super_prop_base(target, property);
            if (!base) return;
            var desc = Object.getOwnPropertyDescriptor(base, property);
            if (desc.get) {
                return desc.get.call(receiver || target);
            }
            return desc.value;
        };
    }
    return flipbook_get(target, property, receiver || target);
}
function flipbook_get_prototype_of(o) {
    flipbook_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return flipbook_get_prototype_of(o);
}
function flipbook_inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) flipbook_set_prototype_of(subClass, superClass);
}
function flipbook_possible_constructor_return(self, call) {
    if (call && (flipbook_type_of(call) === "object" || typeof call === "function")) {
        return call;
    }
    return flipbook_assert_this_initialized(self);
}
function flipbook_set_prototype_of(o, p) {
    flipbook_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return flipbook_set_prototype_of(o, p);
}
function flipbook_super_prop_base(object, property) {
    while(!Object.prototype.hasOwnProperty.call(object, property)){
        object = flipbook_get_prototype_of(object);
        if (object === null) break;
    }
    return object;
}
function flipbook_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function flipbook_is_native_reflect_construct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        return true;
    } catch (e) {
        return false;
    }
}
function flipbook_create_super(Derived) {
    var hasNativeReflectConstruct = flipbook_is_native_reflect_construct();
    return function _createSuperInternal() {
        var Super = flipbook_get_prototype_of(Derived), result;
        if (hasNativeReflectConstruct) {
            var NewTarget = flipbook_get_prototype_of(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget);
        } else {
            result = Super.apply(this, arguments);
        }
        return flipbook_possible_constructor_return(this, result);
    };
}

;// CONCATENATED MODULE: ./src/js/dearviewer/viewers/flipbook-2d.js
/*Stage collects events and passed to respective implementation*/ function flipbook_2d_assert_this_initialized(self) {
    if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
}
function flipbook_2d_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function flipbook_2d_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function flipbook_2d_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) flipbook_2d_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) flipbook_2d_defineProperties(Constructor, staticProps);
    return Constructor;
}
function flipbook_2d_get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
        flipbook_2d_get = Reflect.get;
    } else {
        flipbook_2d_get = function get(target, property, receiver) {
            var base = flipbook_2d_super_prop_base(target, property);
            if (!base) return;
            var desc = Object.getOwnPropertyDescriptor(base, property);
            if (desc.get) {
                return desc.get.call(receiver || target);
            }
            return desc.value;
        };
    }
    return flipbook_2d_get(target, property, receiver || target);
}
function flipbook_2d_get_prototype_of(o) {
    flipbook_2d_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return flipbook_2d_get_prototype_of(o);
}
function flipbook_2d_inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) flipbook_2d_set_prototype_of(subClass, superClass);
}
function flipbook_2d_possible_constructor_return(self, call) {
    if (call && (flipbook_2d_type_of(call) === "object" || typeof call === "function")) {
        return call;
    }
    return flipbook_2d_assert_this_initialized(self);
}
function flipbook_2d_set_prototype_of(o, p) {
    flipbook_2d_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return flipbook_2d_set_prototype_of(o, p);
}
function flipbook_2d_super_prop_base(object, property) {
    while(!Object.prototype.hasOwnProperty.call(object, property)){
        object = flipbook_2d_get_prototype_of(object);
        if (object === null) break;
    }
    return object;
}
function flipbook_2d_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function flipbook_2d_is_native_reflect_construct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        return true;
    } catch (e) {
        return false;
    }
}
function flipbook_2d_create_super(Derived) {
    var hasNativeReflectConstruct = flipbook_2d_is_native_reflect_construct();
    return function _createSuperInternal() {
        var Super = flipbook_2d_get_prototype_of(Derived), result;
        if (hasNativeReflectConstruct) {
            var NewTarget = flipbook_2d_get_prototype_of(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget);
        } else {
            result = Super.apply(this, arguments);
        }
        return flipbook_2d_possible_constructor_return(this, result);
    };
}

;// CONCATENATED MODULE: ./src/js/dearviewer/viewers/slider.js
function slider_assert_this_initialized(self) {
    if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
}
function slider_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function slider_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function slider_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) slider_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) slider_defineProperties(Constructor, staticProps);
    return Constructor;
}
function slider_get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
        slider_get = Reflect.get;
    } else {
        slider_get = function get(target, property, receiver) {
            var base = slider_super_prop_base(target, property);
            if (!base) return;
            var desc = Object.getOwnPropertyDescriptor(base, property);
            if (desc.get) {
                return desc.get.call(receiver || target);
            }
            return desc.value;
        };
    }
    return slider_get(target, property, receiver || target);
}
function slider_get_prototype_of(o) {
    slider_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return slider_get_prototype_of(o);
}
function slider_inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) slider_set_prototype_of(subClass, superClass);
}
function slider_possible_constructor_return(self, call) {
    if (call && (slider_type_of(call) === "object" || typeof call === "function")) {
        return call;
    }
    return slider_assert_this_initialized(self);
}
function slider_set_prototype_of(o, p) {
    slider_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return slider_set_prototype_of(o, p);
}
function slider_super_prop_base(object, property) {
    while(!Object.prototype.hasOwnProperty.call(object, property)){
        object = slider_get_prototype_of(object);
        if (object === null) break;
    }
    return object;
}
function slider_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function slider_is_native_reflect_construct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        return true;
    } catch (e) {
        return false;
    }
}
function slider_create_super(Derived) {
    var hasNativeReflectConstruct = slider_is_native_reflect_construct();
    return function _createSuperInternal() {
        var Super = slider_get_prototype_of(Derived), result;
        if (hasNativeReflectConstruct) {
            var NewTarget = slider_get_prototype_of(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget);
        } else {
            result = Super.apply(this, arguments);
        }
        return slider_possible_constructor_return(this, result);
    };
}

;// CONCATENATED MODULE: ./src/js/dearviewer/viewers/mockup.js
function mockup_assert_this_initialized(self) {
    if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
}
function mockup_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function mockup_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function mockup_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) mockup_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) mockup_defineProperties(Constructor, staticProps);
    return Constructor;
}
function mockup_get_prototype_of(o) {
    mockup_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return mockup_get_prototype_of(o);
}
function mockup_inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) mockup_set_prototype_of(subClass, superClass);
}
function mockup_instanceof(left, right) {
    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
        return !!right[Symbol.hasInstance](left);
    } else {
        return left instanceof right;
    }
}
function mockup_possible_constructor_return(self, call) {
    if (call && (mockup_type_of(call) === "object" || typeof call === "function")) {
        return call;
    }
    return mockup_assert_this_initialized(self);
}
function mockup_set_prototype_of(o, p) {
    mockup_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return mockup_set_prototype_of(o, p);
}
function mockup_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function mockup_is_native_reflect_construct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        return true;
    } catch (e) {
        return false;
    }
}
function mockup_create_super(Derived) {
    var hasNativeReflectConstruct = mockup_is_native_reflect_construct();
    return function _createSuperInternal() {
        var Super = mockup_get_prototype_of(Derived), result;
        if (hasNativeReflectConstruct) {
            var NewTarget = mockup_get_prototype_of(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget);
        } else {
            result = Super.apply(this, arguments);
        }
        return mockup_possible_constructor_return(this, result);
    };
}

;// CONCATENATED MODULE: ./src/js/dearviewer/viewers/flipbook-3d.js
/* globals jQuery, pdfjsLib,THREE  */ function flipbook_3d_assert_this_initialized(self) {
    if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
}
function flipbook_3d_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function flipbook_3d_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function flipbook_3d_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) flipbook_3d_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) flipbook_3d_defineProperties(Constructor, staticProps);
    return Constructor;
}
function flipbook_3d_get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
        flipbook_3d_get = Reflect.get;
    } else {
        flipbook_3d_get = function get(target, property, receiver) {
            var base = flipbook_3d_super_prop_base(target, property);
            if (!base) return;
            var desc = Object.getOwnPropertyDescriptor(base, property);
            if (desc.get) {
                return desc.get.call(receiver || target);
            }
            return desc.value;
        };
    }
    return flipbook_3d_get(target, property, receiver || target);
}
function flipbook_3d_get_prototype_of(o) {
    flipbook_3d_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return flipbook_3d_get_prototype_of(o);
}
function flipbook_3d_inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) flipbook_3d_set_prototype_of(subClass, superClass);
}
function flipbook_3d_possible_constructor_return(self, call) {
    if (call && (flipbook_3d_type_of(call) === "object" || typeof call === "function")) {
        return call;
    }
    return flipbook_3d_assert_this_initialized(self);
}
function flipbook_3d_set_prototype_of(o, p) {
    flipbook_3d_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return flipbook_3d_set_prototype_of(o, p);
}
function flipbook_3d_super_prop_base(object, property) {
    while(!Object.prototype.hasOwnProperty.call(object, property)){
        object = flipbook_3d_get_prototype_of(object);
        if (object === null) break;
    }
    return object;
}
function flipbook_3d_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function flipbook_3d_is_native_reflect_construct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        return true;
    } catch (e) {
        return false;
    }
}
function flipbook_3d_create_super(Derived) {
    var hasNativeReflectConstruct = flipbook_3d_is_native_reflect_construct();
    return function _createSuperInternal() {
        var Super = flipbook_3d_get_prototype_of(Derived), result;
        if (hasNativeReflectConstruct) {
            var NewTarget = flipbook_3d_get_prototype_of(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget);
        } else {
            result = Super.apply(this, arguments);
        }
        return flipbook_3d_possible_constructor_return(this, result);
    };
}

let material = new THREE.LineBasicMaterial({color: 0x00ff00});

let geometry = new THREE.Geometry();
        geometry.vertices.push(
          pointsFront[0][0], pointsFront[0][1], pointsFront[0][2], pointsFront[0][3]
        );

sheet.handlesf = new THREE.Line(geometry, material);
        sheet.element.add(sheet.handlesf);

}
      else {
        let hvs = sheet.handlesf.geometry.vertices;
        for (let hcount = 0; hcount < hvs.length; hcount++) {
          hvs[hcount] = pointsFront[0][hcount];
        }
        sheet.handlesf.geometry.verticesNeedUpdate = true;
      }
      if (sheet.handlesb === void 0) {

let material = new THREE.LineBasicMaterial({color: 0x0000ff});

let geometry = new THREE.Geometry();
        geometry.vertices.push(
          pointsBack[0][0], pointsBack[0][1], pointsBack[0][2], pointsBack[0][3]
        );

sheet.handlesb = new THREE.Line(geometry, material);
        sheet.element.add(sheet.handlesb);

}
      else {
        let hvs = sheet.handlesb.geometry.vertices;
        for (let hcount = 0; hcount < hvs.length; hcount++) {
          hvs[hcount] = pointsBack[0][hcount];
        }
        sheet.handlesb.geometry.verticesNeedUpdate = true;
      }
    }

*/ var bodyG = sheet.element.geometry;
                if (bodyG.attributes !== void 0) {
                    //5 segments have 56 vertices
                    /*
      * 5 segments have 56 vertices
      * 8 are side vertices
      * remaining 48 in 4 faces
      * each 12 vertices
      *rowvertices = segments + 1
      * 1,7   -   2,8   -   3,9   -   4,10  -   5,11  -   6,12    x + rowvertices*0 + count, x + rowvertices*1 + count
      * 13,19 -   14,20 -   15,21 -   16,22 -   17,23 -   18,24   x + rowvertices*2 + 1, x + rowvertices*3 + 1
      * 25,31 -   26,32 -   27,33 -   28,34 -   29,35 -   30,36
      * 37,43 -   38,44 -   39,45 -   40,46 -   41,47 -   42,48
      *
      * */ var positions = bodyG.attributes.position;
                    var uvs = bodyG.attributes.uv;
                    var rowVertices = segments + 1;
                    var offset = 8;
                    //region basic side vertices
                    //Update the geometry based on angles
                    positions.setZ(0, verticesFront[0][segments].z);
                    positions.setZ(2, verticesFront[0][segments].z);
                    positions.setX(0, verticesFront[0][segments].x);
                    positions.setX(2, verticesFront[0][segments].x);
                    // verts[0].z = verts[2].z = verticesFront[0][segments].z;
                    // verts[0].x = verts[2].x = verticesFront[0][segments].x;
                    positions.setZ(1, verticesBack[0][segments].z);
                    positions.setZ(3, verticesBack[0][segments].z);
                    positions.setX(1, verticesBack[0][segments].x);
                    positions.setX(3, verticesBack[0][segments].x);
                    // verts[1].z = verts[3].z = verticesBack[0][segments].z;
                    // verts[1].x = verts[3].x = verticesBack[0][segments].x;
                    positions.setZ(5, verticesFront[0][0].z);
                    positions.setZ(7, verticesFront[0][0].z);
                    positions.setX(5, verticesFront[0][0].x);
                    positions.setX(7, verticesFront[0][0].x);
                    // verts[5].z = verts[7].z = verticesFront[0][0].z;
                    // verts[5].x = verts[7].x = verticesFront[0][0].x;
                    positions.setZ(4, verticesBack[0][0].z);
                    positions.setZ(6, verticesBack[0][0].z);
                    positions.setX(4, verticesBack[0][0].x);
                    positions.setX(6, verticesBack[0][0].x);
                    // verts[4].z = verts[6].z = verticesBack[0][0].z;
                    // verts[4].x = verts[6].x = verticesBack[0][0].x;
                    //endregion
                    for(var fold = 0; fold < foldCount; fold++){
                        for(var count = 0; count < rowVertices; count++){
                            positions.setZ(offset + rowVertices * 0 + count, verticesFront[0][count].z);
                            positions.setX(offset + rowVertices * 0 + count, verticesFront[0][count].x);
                            positions.setZ(offset + rowVertices * 1 + count, verticesBack[0][count].z);
                            positions.setX(offset + rowVertices * 1 + count, verticesBack[0][count].x);
                            positions.setZ(offset + rowVertices * 2 + count, verticesFront[0][count].z);
                            positions.setX(offset + rowVertices * 2 + count, verticesFront[0][count].x);
                            positions.setZ(offset + rowVertices * 3 + count, verticesBack[0][count].z);
                            positions.setX(offset + rowVertices * 3 + count, verticesBack[0][count].x);
                            positions.setZ(offset + rowVertices * 4 + count, verticesFront[0][count].z);
                            positions.setX(offset + rowVertices * 4 + count, verticesFront[0][count].x);
                            positions.setZ(offset + rowVertices * 5 + count, verticesFront[0][count].z);
                            positions.setX(offset + rowVertices * 5 + count, verticesFront[0][count].x);
                            uvs.setX(offset + rowVertices * 4 + count, distances[count] / sum);
                            uvs.setX(offset + rowVertices * 5 + count, distances[count] / sum);
                            positions.setZ(offset + rowVertices * 6 + count, verticesBack[0][segments - count].z);
                            positions.setX(offset + rowVertices * 6 + count, verticesBack[0][segments - count].x);
                            positions.setZ(offset + rowVertices * 7 + count, verticesBack[0][segments - count].z);
                            positions.setX(offset + rowVertices * 7 + count, verticesBack[0][segments - count].x);
                            uvs.setX(offset + rowVertices * 6 + count, 1 - distances[segments - count] / sum);
                            uvs.setX(offset + rowVertices * 7 + count, 1 - distances[segments - count] / sum);
                        // verts[offset].z = verts[offset + rowVertices * 3].z = verticesBack[0][count].z;
                        // verts[offset].x = verts[offset + rowVertices * 3].x = verticesBack[0][count].x;
                        // verts[offset + rowVertices].z = verts[offset + rowVertices * 2].z = verticesFront[0][count].z;
                        // verts[offset + rowVertices].x = verts[offset + rowVertices * 2].x = verticesFront[0][count].x;
                        // offset++;
                        }
                    }
                    bodyG.computeBoundingBox();
                    sheet.element.scale.x = curveWidth * foldCount / sum;
                    // sheet.element.scale.z = sheet.element.scale.x;//1 + (Math.cos(pointAngleB) * sheet.element.scale.x / sheet.element.scale.x);
                    bodyG.computeBoundingSphere();
                    positions.needsUpdate = true;
                    uvs.needsUpdate = true;
                    bodyG.computeVertexNormals();
                } else {
                    var verts = bodyG.vertices;
                    var rowVertices1 = segments - 1;
                    var offset1 = 8;
                    //Update the geometry based on angles
                    verts[0].z = verts[2].z = verticesFront[0][segments].z;
                    verts[0].x = verts[2].x = verticesFront[0][segments].x;
                    verts[1].z = verts[3].z = verticesBack[0][segments].z;
                    verts[1].x = verts[3].x = verticesBack[0][segments].x;
                    verts[5].z = verts[7].z = verticesFront[0][0].z;
                    verts[5].x = verts[7].x = verticesFront[0][0].x;
                    verts[4].z = verts[6].z = verticesBack[0][0].z;
                    verts[4].x = verts[6].x = verticesBack[0][0].x;
                    for(var fold1 = 0; fold1 < foldCount; fold1++){
                        for(var count1 = 1; count1 < segments; count1++){
                            verts[offset1].z = verts[offset1 + rowVertices1 * 3].z = verticesBack[0][count1].z;
                            verts[offset1].x = verts[offset1 + rowVertices1 * 3].x = verticesBack[0][count1].x;
                            verts[offset1 + rowVertices1].z = verts[offset1 + rowVertices1 * 2].z = verticesFront[0][count1].z;
                            verts[offset1 + rowVertices1].x = verts[offset1 + rowVertices1 * 2].x = verticesFront[0][count1].x;
                            offset1++;
                        }
                    }
                    var uvs1 = bodyG.faceVertexUvs[0];
                    var faces = bodyG.faces;
                    var uvIndexFront = 0;
                    for(var count2 = 0; count2 < uvs1.length; count2++){
                        if (faces[count2].materialIndex === MOCKUP.MATERIAL_FACE.BACK) {
                            var dist = distances[uvIndexFront] / sum;
                            if (count2 % 2 === 0) {
                                uvs1[count2][0].x = uvs1[count2][1].x = uvs1[count2 + 1][0].x = dist;
                                uvIndexFront++;
                            } else {
                                uvs1[count2 - 1][2].x = uvs1[count2][1].x = uvs1[count2][2].x = dist;
                            }
                        } else if (faces[count2].materialIndex === MOCKUP.MATERIAL_FACE.FRONT) {
                            var dist1 = 1 - distances[uvIndexFront] / sum;
                            //console.log(dist);
                            if (count2 % 2 === 0) {
                                uvs1[count2][0].x = uvs1[count2][1].x = uvs1[count2 + 1][0].x = dist1;
                                uvIndexFront--;
                            } else {
                                uvs1[count2 - 1][2].x = uvs1[count2][1].x = uvs1[count2][2].x = dist1;
                            }
                        }
                    }
                    bodyG.computeBoundingBox();
                    sheet.element.scale.x = curveWidth * foldCount / sum;
                    // sheet.element.scale.z = sheet.element.scale.x;//1 + (Math.cos(pointAngleB) * sheet.element.scale.x / sheet.element.scale.x);
                    bodyG.computeBoundingSphere();
                    bodyG.verticesNeedUpdate = true;
                    bodyG.computeFaceNormals();
                    bodyG.computeVertexNormals();
                    bodyG.uvsNeedUpdate = true;
                    bodyG.normalsNeedUpdate = true;
                }
                curvesFront.forEach(function(curveF) {
                    curveF = null;
                });
                curvesBack.forEach(function(curveB) {
                    curveB = null;
                });
                verticesBack.forEach(function(vertexB) {
                    vertexB = null;
                });
                verticesFront.forEach(function(vertexF) {
                    vertexF = null;
                });
            }
        },
        {
            key: "flip",
            value: function flip(oldAngle, newAngle) {
                var sheet = this;
                var isBooklet = sheet.viewer.isBooklet;
                //https://github.com/deepak-ghimire/dearviewer/issues/494
                if (sheet.isCover === true) {
                    if (oldAngle === 0) oldAngle = sheet.viewer.flexibility * 2.5;
                    if (oldAngle === 180) oldAngle = oldAngle - sheet.viewer.flexibility * 2.5;
                }
                var diff = newAngle - oldAngle; //170 -5 == 165 :  5-170 = -165
                var isRight = oldAngle > 90;
                var isRTL = sheet.viewer.isRTL;
                var pageNumber = isRight ? sheet.backPage.pageNumber : sheet.frontPage.pageNumber;
                var viewport = this.viewer.getViewPort(pageNumber);
                if (viewport) viewport = flipbook_3d_utils.contain(viewport.width, viewport.height, sheet.viewer.availablePageWidth(), sheet.viewer.availablePageHeight());
                var coverAdjustmentWidth = -(sheet.viewer.has3DCover && sheet.viewer.isClosedPage() ? sheet.viewer.coverExtraWidth : 0), coverAdjustmentHeight = -(sheet.viewer.has3DCover && sheet.viewer.isClosedPage() ? sheet.viewer.coverExtraHeight : 0);
                sheet.init = {
                    angle: oldAngle,
                    height: isRight ? sheet.viewer.rightSheetHeight : sheet.viewer.leftSheetHeight,
                    width: isRight ? sheet.viewer.rightSheetWidth : sheet.viewer.leftSheetWidth,
                    index: isRight && !isRTL || !isRight && isRTL ? 1 : 0,
                    _index: 0
                };
                sheet.first = {
                    angle: oldAngle + diff / 4,
                    index: isRight && !isRTL || !isRight && isRTL ? 1 : 0.25
                };
                sheet.mid = {
                    angle: oldAngle + diff * 2 / 4,
                    index: isRight && !isRTL || !isRight && isRTL ? 0.5 : 0.5
                };
                sheet.mid2 = {
                    angle: oldAngle + diff * 3 / 4,
                    index: isRight && !isRTL || !isRight && isRTL ? 0.25 : 1
                };
                sheet.end = {
                    angle: newAngle,
                    index: isRight && !isRTL || !isRight && isRTL ? 0 : 1,
                    height: coverAdjustmentHeight + (viewport ? viewport.height : sheet.height),
                    width: coverAdjustmentWidth + (viewport ? viewport.width : sheet.width)
                };
                //console.log(sheet.init, sheet.first, sheet.mid, sheet.end);
                sheet.isFlipping = true;
                var update = function update(tween) {
                    sheet.sheetAngle = tween.angle;
                    sheet.curveAngle = sheet.isHard ? tween.angle : flipbook_3d_utils.getCurveAngle(isRight, tween.angle);
                    if (sheet.isHard === true) {
                        sheet.flexibility = 0;
                        if (sheet.isCover) {
                            sheet.viewer.flipCover(sheet);
                        }
                    } else {
                        sheet.flexibility = tween.angle < 90 ? sheet.leftFlexibility : sheet.rightFlexibility;
                    }
                    sheet.element.position.z = (tween.angle < 90 ? sheet.leftPos : sheet.rightPos) + sheet.depth;
                    if (isBooklet) {
                        sheet.element.material[5].opacity = sheet.element.material[4].opacity = tween.index;
                        sheet.element.castShadow = isRight && !isRTL || !isRight && isRTL ? tween.index > 0.5 : tween.index > 0.5;
                    }
                    sheet.height = tween.height;
                    sheet.width = tween.width;
                    sheet.updateAngle(true);
                };
                if (isBooklet && (!isRight && !isRTL || isRight && isRTL)) {
                    sheet.element.material[5].opacity = sheet.element.material[4].opacity = 0;
                    sheet.element.castShadow = false;
                }
                sheet.currentTween = new TWEEN.Tween(sheet.init).to({
                    angle: [
                        sheet.first.angle,
                        sheet.mid.angle,
                        sheet.mid2.angle,
                        sheet.end.angle
                    ],
                    index: [
                        sheet.first.index,
                        sheet.mid.index,
                        sheet.mid2.index,
                        sheet.end.index
                    ],
                    _index: 1,
                    height: sheet.end.height,
                    width: sheet.end.width
                }, sheet.viewer.app.options.duration * Math.abs(diff) / 180).onUpdate(function(event) {
                    update(this, event);
                }).easing(TWEEN.Easing.Sinusoidal.Out).onStop(function() {
                    sheet.currentTween = null;
                    sheet.isFlipping = false;
                    if (sheet.isCover) {
                        sheet.viewer.leftCover.isFlipping = false;
                        sheet.viewer.rightCover.isFlipping = false;
                    }
                    sheet.element.material[5].opacity = sheet.element.material[4].opacity = 1;
                }).onComplete(function() {
                    sheet.updateAngle();
                    sheet.element.material[5].opacity = sheet.element.material[4].opacity = 1;
                    sheet.element.castShadow = true;
                    sheet.isFlipping = false;
                    if (sheet.isCover) {
                        sheet.viewer.leftCover.isFlipping = false;
                        sheet.viewer.rightCover.isFlipping = false;
                    }
                    sheet.side = sheet.targetSide;
                    sheet.viewer.onFlip();
                    sheet.viewer.afterFlip();
                    sheet.currentTween = null;
                    if (sheet.viewer && sheet.viewer.requestRefresh) sheet.viewer.requestRefresh();
                }).start();
                //calling instantly will fix the render and postioning update issue
                //https://github.com/deepak-ghimire/dearviewer/issues/494
                sheet.currentTween.update(window.performance.now());
            }
        }
    ]);
    return BookSheet3D;
}(BookSheet);
var FlipBook3D = /*#__PURE__*/ function(BaseFlipBookViewer) {
    "use strict";
    flipbook_3d_inherits(FlipBook3D, BaseFlipBookViewer);
    var _super = flipbook_3d_create_super(FlipBook3D);
    function FlipBook3D(options, appContext) {
        flipbook_3d_class_call_check(this, FlipBook3D);
        var _this;
        options.viewerClass = "df-flipbook-3d";
        _this = _super.call(this, options, appContext);
        _this.pageOffset = 5; //space between pages in spiral book
        _this.spiralCount = 20;
        var _options_groundDistance;
        _this.groundDistance = (_options_groundDistance = options.groundDistance) !== null && _options_groundDistance !== void 0 ? _options_groundDistance : 2; //relative sizing distance of ground from book when cover is closed.
        _this.hasSpiral = options.hasSpiral === "true" || options.hasSpiral === true;
        var _options_flexibility;
        _this.flexibility = flipbook_3d_utils.limitAt((_options_flexibility = options.flexibility) !== null && _options_flexibility !== void 0 ? _options_flexibility : 0.9, 0, 10);
        if (_this.hasSpiral) {
            _this.flexibility = 0;
        }
        if (_this.flexibility === 0) options.sheetSegments = 8;
        _this.drag3D = flipbook_3d_utils.isTrue(options.drag3D);
        var _options_texturePowerOfTwo;
        //if it's mobile do not use power of two to save, overhead and device resources
        _this.texturePowerOfTwo = flipbook_3d_utils.isMobile ? false : (_options_texturePowerOfTwo = options.texturePowerOfTwo) !== null && _options_texturePowerOfTwo !== void 0 ? _options_texturePowerOfTwo : true;
        var _this_app_options_color3DSheets;
        _this.color3DSheets = (_this_app_options_color3DSheets = _this.app.options.color3DSheets) !== null && _this_app_options_color3DSheets !== void 0 ? _this_app_options_color3DSheets : 'white';
        _this.midPosition = 0;
        _this.initMOCKUP(function() {
            appContext._viewerPrepared();
        });
        return _this;
    }
    flipbook_3d_create_class(FlipBook3D, [
        {
            key: "initMOCKUP",
            value: function initMOCKUP(callback) {
                var app = this.app;
                if (typeof THREE === "undefined") {
                    app.updateInfo(app.options.text.loading + " WEBGL 3D ...");
                    if (typeof window.define === 'function' && window.define.amd && window.requirejs) {
                        window.requirejs.config({
                            "paths": {
                                "three": app.options.threejsSrc.replace(".js", "")
                            },
                            shim: {
                                'three': {
                                    exports: 'THREE'
                                }
                            }
                        });
                        window.require([
                            'three'
                        ], function(THREE1) {
                            window.THREE = THREE1;
                            MOCKUP.init();
                            if (typeof callback === "function") callback();
                            return THREE1;
                        });
                    } else if (typeof window.define === 'function' && window.define.amd) {
                        window.require([
                            "three",
                            app.options.threejsSrc.replace(".js", "")
                        ], function(ready) {
                            ready(function() {
                                MOCKUP.init();
                                if (typeof callback === "function") callback();
                            });
                        });
                    } else {
                        flipbook_3d_utils.getScript(app.options.threejsSrc + "?ver=" + flipbook_3d_DV.version, function() {
                            MOCKUP.init();
                            if (typeof callback === "function") callback();
                        }, function() {
                            app.updateInfo("Unable to load THREE.js...");
                        });
                    }
                } else {
                    MOCKUP.init();
                    if (typeof callback === "function") callback();
                }
            }
        },
        {
            key: "init",
            value: function init() {
                var app = this.app;
                flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "init", this).call(this);
                var _pageRatio = app.provider.defaultPage.pageRatio;
                this.pageScaleX = 1;
                this.initDepth();
                this.initStage();
                this.initPages();
                this.initEvents();
                this.render(); //until render is called none of the css pages are added.
            }
        },
        {
            key: "updatePageMode",
            value: function updatePageMode() {
                flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "updatePageMode", this).call(this);
                var app = this.app;
                this.has3DCover = app.options.cover3DType !== defaults_DEARVIEWER.FLIPBOOK_COVER_TYPE.NONE && app.pageCount > 7 && !this.isBooklet;
                if (this.has3DCover && app.options.flipbookHardPages === "none") {
                    app.options.flipbookHardPages = "cover";
                }
            }
        },
        {
            key: "initDepth",
            value: function initDepth() {
                var _this_app_options_sheetDepth;
                this.sheetDepth = this.pageScaleX * ((_this_app_options_sheetDepth = this.app.options.sheetDepth) !== null && _this_app_options_sheetDepth !== void 0 ? _this_app_options_sheetDepth : 0.5);
                var _this_app_options_sheetSegments;
                this.sheetSegments = (_this_app_options_sheetSegments = this.app.options.sheetSegments) !== null && _this_app_options_sheetSegments !== void 0 ? _this_app_options_sheetSegments : 20;
                this.coverDepth = 2 * this.sheetDepth;
                this.sheetsDepth = Math.min(10, this.app.pageCount / 4) * this.sheetDepth;
            }
        },
        {
            key: "initStage",
            value: function initStage() {
                var viewer = this;
                var stage = viewer.stage = new MOCKUP.Stage({
                    pixelRatio: viewer.app.options.pixelRatio
                });
                var canvas = stage.canvas = jQuery(stage.renderer.domElement).addClass("df-3dcanvas");
                canvas.appendTo(this.element);
                stage.camera.position.set(0, 0, 600);
                stage.camera.lookAt(new THREE.Vector3(0, 0, 0));
                viewer.camera = stage.camera;
                //shadows are zigzag due to shadow camera position
                stage.spotLight.position.set(-220, 220, 550);
                stage.spotLight.castShadow = flipbook_3d_utils.isMobile ? false : viewer.app.options.has3DShadow;
                if (stage.spotLight.shadow) {
                    stage.spotLight.shadow.bias = -0.005; //-0.0035 has artifacts in smaller size;
                }
                // stage.spotLight.intensity = 0.22;
                stage.ambientLight.color = new THREE.Color("#fff");
                stage.ambientLight.intensity = 0.82;
                var material = new THREE.ShadowMaterial();
                material.opacity = viewer.app.options.shadowOpacity;
                stage.ground.oldMaterial = stage.ground.material;
                stage.ground.material = material;
                stage.ground.position.z = this.has3DCover ? -6 : -4;
                stage.selectiveRendering = true;
                var cssRenderer = stage.cssRenderer = new THREE.CSS3DRenderer();
                jQuery(cssRenderer.domElement).css({
                    position: "absolute",
                    top: 0,
                    pointerEvents: "none"
                }).addClass("df-3dcanvas df-csscanvas");
                viewer.element[0].appendChild(cssRenderer.domElement);
                stage.cssScene = new THREE.Scene();
                viewer.wrapper.remove();
                viewer.wrapper = new THREE.Group();
                viewer.stage.add(viewer.wrapper);
                viewer.wrapper.add(stage.ground);
                viewer.bookWrapper = new THREE.Group();
                viewer.bookWrapper.name = "bookwrapper";
                // stage.bookWrapper.add(stage.camera);
                viewer.wrapper.add(viewer.bookWrapper);
                viewer.bookHelper = stage.bookHelper = new THREE.BoxHelper(viewer.bookWrapper, 0xffff00);
                stage.add(viewer.bookHelper);
                viewer.bookHelper.visible = false;
                viewer.cameraWrapper = new THREE.Group();
                viewer.cameraWrapper.add(stage.camera);
                stage.add(viewer.cameraWrapper);
                // viewer.wrapper.add(stage.spotLight);
                viewer.app.renderRequestStatus = flipbook_3d_DV.REQUEST_STATUS.ON;
            }
        },
        {
            key: "initPages",
            value: function initPages() {
                var options = {
                    parent3D: this.bookWrapper,
                    viewer: this,
                    segments: this.sheetSegments,
                    depth: this.sheetDepth,
                    flexibility: this.flexibility
                };
                for(var count = 0; count < this.stackCount; count++){
                    var sheet = new BookSheet3D(options);
                    sheet.index = count; //just reference for debugging
                    sheet.viewer = this;
                    this.sheets.push(sheet);
                    sheet.setMatColor(this.color3DSheets);
                    this.pages.push(sheet.frontPage);
                    this.pages.push(sheet.backPage);
                    this.stage.cssScene.add(sheet.frontPage.cssPage);
                    this.stage.cssScene.add(sheet.backPage.cssPage);
                }
                options.depth = this.sheetsDepth;
                options.segments = 1;
                options.flexibility = 0;
                this.leftSheets = new BookSheet3D(options); //to display sheet stack on left side of Realistic book
                this.rightSheets = new BookSheet3D(options); //to display sheet stack on right side of Realistic book
                this.leftSheets.setMatColor(this.color3DSheets);
                this.rightSheets.setMatColor(this.color3DSheets);
                options.depth = this.coverDepth;
                this.leftCover = new BookSheet3D(options);
                this.rightCover = new BookSheet3D(options);
                // this.leftCover.element.loadNormalMap(this.app.options.imagesLocation + "/book-cover-normal.jpg", MOCKUP.MATERIAL_FACE.FRONT);
                // this.rightCover.element.loadNormalMap(this.app.options.imagesLocation + "/book-cover-normal.jpg", MOCKUP.MATERIAL_FACE.BACK);
                this.leftCover.isHard = true;
                this.rightCover.isHard = true;
                this.set3DCoverNormal();
                this.setcolor3DCover(this.app.options.color3DCover);
                this.stage.cssScene.add(this.leftCover.frontPage.cssPage);
                this.stage.cssScene.add(this.rightCover.backPage.cssPage);
                this.zoomViewer.leftPage.element.css({
                    backgroundColor: this.color3DSheets
                });
                this.zoomViewer.rightPage.element.css({
                    backgroundColor: this.color3DSheets
                });
                if (this.orientation === 'vertical') {
                    this.bookWrapper.children.forEach(function(childPaper) {
                        childPaper.rotateZ(THREE.MathUtils.degToRad(-90));
                        childPaper.textureCenter = new THREE.Vector2(0.5, 0.5);
                        childPaper.textureRotation = 90;
                    });
                }
                this.initSpiral();
            }
        },
        {
            key: "initSpiral",
            value: function initSpiral() {
                this.hasSpiral = false;
            }
        },
        {
            key: "set3DCoverNormal",
            value: function set3DCoverNormal() {}
        },
        {
            key: "setcolor3DCover",
            value: function setcolor3DCover() {
                var val = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
            }
        },
        {
            key: "initEvents",
            value: function initEvents() {
                this.stageDOM = this.element[0];
                flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "initEvents", this).call(this);
            }
        },
        {
            key: "dispose",
            value: function dispose() {
                flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "dispose", this).call(this);
                var viewer = this;
                if (viewer.stage) {
                    viewer.stage.clearChild();
                    viewer.stage.cssRenderer.domElement.parentNode.removeChild(viewer.stage.cssRenderer.domElement);
                    viewer.stage.cssRenderer = null;
                    viewer.stage.orbitControl = flipbook_3d_utils.disposeObject(viewer.stage.orbitControl);
                    viewer.stage.renderer = flipbook_3d_utils.disposeObject(viewer.stage.renderer);
                    jQuery(viewer.stage.canvas).remove();
                    viewer.stage.canvas = null;
                    viewer.stage = flipbook_3d_utils.disposeObject(viewer.stage);
                }
                if (viewer.centerTween && viewer.centerTween.stop) viewer.centerTween.stop();
            }
        },
        {
            key: "render",
            value: function render() {
                this.stage.render();
                this.stage.cssRenderer.render(this.stage.cssScene, this.stage.camera);
            }
        },
        {
            key: "resize",
            value: function resize() {
                flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "resize", this).call(this);
                var viewer = this;
                var app = viewer.app, stage = viewer.stage;
                var dimensions = app.dimensions;
                var padding = dimensions.padding;
                var isSingle = viewer.isSingle;
                var zoomWidth = this.availablePageWidth(), zoomHeight = this.availablePageHeight();
                stage.resizeCanvas(dimensions.stage.width, dimensions.stage.height);
                stage.cssRenderer.setSize(dimensions.stage.width, dimensions.stage.height);
                this.pageScaleX = Math.max(Math.max(zoomWidth, zoomHeight) / 400, 1);
                this.initDepth();
                this.sheets.forEach(function(sheet) {
                    sheet.depth = viewer.sheetDepth;
                });
                app.refreshRequestStart();
                var ref = this.refSize = Math.min(zoomHeight, zoomWidth);
                this.coverExtraWidth = (viewer.orientation == 'vertical' ? 2 : 1) * ref * .025;
                this.coverExtraHeight = (viewer.orientation == 'vertical' ? 1 : 2) * ref * .025;
                if (this.has3DCover !== true) {
                    this.coverExtraWidth = 0;
                    this.coverExtraHeight = 0;
                }
                //viewer.app.renderRequestStatus = DV.REQUEST_STATUS.ON;
                viewer.zoomViewer.resize();
                viewer.cameraPositionDirty = true;
                viewer.centerNeedsUpdate = true;
                viewer.checkCenter(true);
                viewer.pagesReady();
                this.pageOffset = (this.hasSpiral ? 6 : 0) * Math.min(this._defaultPageSize.width, this._defaultPageSize.height) / 1000;
            }
        },
        {
            key: "fitCameraToCenteredObject",
            value: function fitCameraToCenteredObject(camera, object, offset, orbitControls) {
                var boundingBox = new THREE.Box3();
                boundingBox.setFromObject(object);
                var middle = new THREE.Vector3();
                var size = new THREE.Vector3();
                boundingBox.getSize(size);
                var coverExtraHeight = this.coverExtraHeight;
                var coverExtraWidth = this.coverExtraWidth * 2;
                if (this.isClosedPage()) {
                    coverExtraWidth = 0;
                    coverExtraHeight = 0;
                }
                size.x = size.x - coverExtraWidth + this.app.dimensions.padding.width;
                size.y = size.y - coverExtraHeight + this.app.dimensions.padding.height;
                // figure out how to fit the box in the view:
                // 1. figure out horizontal FOV (on non-1.0 aspects)
                // 2. figure out distance from the object in X and Y planes
                // 3. select the max distance (to fit both sides in)
                //
                // The reason is as follows:
                //
                // Imagine a bounding box (BB) is centered at (0,0,0).
                // Camera has vertical FOV (camera.fov) and horizontal FOV
                // (camera.fov scaled by aspect, see fovh below)
                //
                // Therefore if you want to put the entire object into the field of view,
                // you have to compute the distance as: z/2 (half of Z size of the BB
                // protruding towards us) plus for both X and Y size of BB you have to
                // figure out the distance created by the appropriate FOV.
                //
                // The FOV is always a triangle:
                //
                //  (size/2)
                // +--------+
                // |       /
                // |      /
                // |     /
                // | F° /
                // |   /
                // |  /
                // | /
                // |/
                //
                // F° is half of respective FOV, so to compute the distance (the length
                // of the straight line) one has to: `size/2 / Math.tan(F)`.
                //
                // FTR, from https://threejs.org/docs/#api/en/cameras/PerspectiveCamera
                // the camera.fov is the vertical FOV.
                var fov = camera.fov * (Math.PI / 180);
                var fovh = 2 * Math.atan(Math.tan(fov / 2) * camera.aspect);
                var dx = size.z / 2 + Math.abs(size.x / 2 / Math.tan(fovh / 2));
                var dy = size.z / 2 + Math.abs(size.y / 2 / Math.tan(fov / 2));
                var cameraZ = Math.max(dx, dy);
                // offset the camera, if desired (to avoid filling the whole canvas)
                if (offset !== undefined && offset !== 0) cameraZ *= offset;
                camera.position.set(0, 0, cameraZ);
                // set the far plane of the camera so that it easily encompasses the whole object
                var minZ = boundingBox.min.z;
                var cameraToFarEdge = minZ < 0 ? -minZ + cameraZ : cameraZ - minZ;
                camera.far = cameraToFarEdge * 3;
                camera.updateProjectionMatrix();
                if (orbitControls !== undefined) {
                    // set camera to rotate around the center
                    orbitControls.target = new THREE.Vector3(0, 0, 0);
                    // prevent camera from zooming out far enough to create far plane cutoff
                    orbitControls.maxDistance = cameraToFarEdge * 2;
                }
            }
        },
        {
            key: "updateShadowSize",
            value: function updateShadowSize() {
                return;
                var shadowSize = this.pageScaleX > 2.5 ? 1024 : 512;
                var shadow = this.stage.spotLight.shadow;
                if (this.stage.spotLight.castShadow === true && shadow.mapSize.height != shadowSize) {
                    shadow.radius = shadowSize / 256;
                    shadow.mapSize.width = shadowSize;
                    shadow.mapSize.height = shadowSize;
                    shadow.needsUpdate = true;
                }
            }
        },
        {
            key: "refresh",
            value: function refresh() {
                var viewer = this, app = this.app, basePage = viewer.getBasePage();
                this.refreshRequested = true; //flag to check if refresh has beem requested
                var ratioStep = 1 / app.pageCount, ratio = ratioStep * basePage;
                var leftWeight = this.isRTL ? 1 - ratio : ratio, rightWeight = 1 - leftWeight;
                var minSheetStack = Math.min(viewer.stackCount, viewer.totalSheets);
                var maxSheetStack = flipbook_3d_utils.limitAt(viewer.totalSheets, viewer.stackCount, viewer.stackCount * 2);
                var midWeight = Math.max(leftWeight, rightWeight);
                var flexibilityFactor = this.isBooklet ? 0 : this.flexibility / maxSheetStack;
                viewer.leftFlexibility = flexibilityFactor * rightWeight;
                viewer.rightFlexibility = flexibilityFactor * leftWeight;
                viewer.midPosition = 0.5 * minSheetStack * viewer.sheetDepth;
                flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "refresh", this).call(this);
                var displayCover = this.has3DCover === true;
                this.leftCover.element.visible = this.rightCover.element.visible = this.leftSheets.element.visible = this.rightSheets.element.visible = displayCover;
                this.wrapper.position.z = -this.midPosition;
                var depthLeft = 0, depthRight = 0, isRTL = viewer.isRTL;
                var isFrontPage = this.isFirstPage(), isLastPage = this.isLastPage();
                var isLeftClosed = this.isLeftClosed = this.isClosedPage() && (isRTL && isLastPage || !isRTL && isFrontPage), isRightClosed = this.isRightClosed = this.isClosedPage() && (!isRTL && isLastPage || isRTL && isFrontPage);
                if (displayCover) {
                    viewer.leftSheets.depth = isRTL ? viewer.sheetsDepth * (1 - viewer.getBasePage() / app.pageCount) : viewer.sheetsDepth * basePage / app.pageCount;
                    viewer.leftSheets.element.visible = isRTL ? app.pageCount - viewer.getBasePage() > 2 : basePage > 2;
                    depthLeft -= viewer.leftSheets.depth / 2;
                    viewer.leftSheets.element.position.z = depthLeft;
                    depthLeft -= viewer.coverDepth + (viewer.leftSheets.element.visible ? viewer.leftSheets.depth / 2 : 0) + viewer.coverDepth * 3;
                    viewer.leftCover.depth = viewer.rightCover.depth = viewer.coverDepth;
                    var maxSheetHeight = Math.max(this.leftSheetHeight, this.rightSheetHeight);
                    if (isRightClosed) maxSheetHeight = this.leftSheetHeight;
                    if (isLeftClosed) maxSheetHeight = this.rightSheetHeight;
                    if (viewer.leftCover.isFlipping !== true) {
                        viewer.leftCover.element.position.z = isLeftClosed ? viewer.midPosition + viewer.coverDepth : depthLeft + viewer.coverDepth / 2;
                        viewer.leftCover.element.position.z = Math.max(viewer.leftCover.element.position.z, -viewer.refSize * 0.05);
                        viewer.leftCover.element.position.x = 0;
                        viewer.leftSheets.sheetAngle = viewer.leftCover.sheetAngle = isLeftClosed ? 180 : 0;
                        viewer.leftSheets.curveAngle = viewer.leftCover.curveAngle = isLeftClosed ? 180 : 0;
                        if (viewer.rightCover.isFlipping !== true) {
                            viewer.leftCover.height = maxSheetHeight;
                            viewer.leftCover.width = viewer.leftCover.sheetAngle < 90 ? this.leftSheetWidth : this.rightSheetWidth;
                            if (!this.isClosedPage()) {
                                viewer.leftCover.width += this.coverExtraWidth;
                                viewer.leftCover.height += this.coverExtraHeight;
                            }
                        }
                        viewer.leftSheets.updateAngle();
                        viewer.leftCover.updateAngle();
                    }
                    viewer.rightSheets.depth = viewer.sheetsDepth - viewer.leftSheets.depth;
                    viewer.rightSheets.element.visible = isRTL ? basePage > 2 : app.pageCount - viewer.getBasePage() > 2;
                    depthRight -= viewer.rightSheets.depth / 2;
                    viewer.rightSheets.element.position.z = depthRight;
                    depthRight -= viewer.coverDepth + (viewer.rightSheets.element.visible ? viewer.rightSheets.depth / 2 : 0) + viewer.coverDepth * 3;
                    if (viewer.rightCover.isFlipping !== true) {
                        viewer.rightCover.element.position.z = isRightClosed ? viewer.midPosition + viewer.coverDepth : depthRight + viewer.coverDepth / 2;
                        viewer.rightCover.element.position.z = Math.max(viewer.rightCover.element.position.z, -viewer.refSize * 0.05);
                        viewer.rightCover.element.position.x = 0;
                        viewer.rightSheets.sheetAngle = viewer.rightCover.sheetAngle = isRightClosed ? 0 : 180;
                        viewer.rightSheets.curveAngle = viewer.rightCover.curveAngle = isRightClosed ? 0 : 180;
                        if (viewer.leftCover.isFlipping !== true) {
                            viewer.rightCover.height = maxSheetHeight;
                            viewer.rightCover.width = viewer.rightCover.sheetAngle < 90 ? this.leftSheetWidth : this.rightSheetWidth;
                            if (!this.isClosedPage()) {
                                viewer.rightCover.width += this.coverExtraWidth;
                                viewer.rightCover.height += this.coverExtraHeight;
                            }
                        }
                        viewer.rightSheets.updateAngle();
                        viewer.rightCover.updateAngle();
                    }
                    viewer.updateSheets();
                    viewer.stage.ground.position.z = Math.min(depthLeft, depthRight) - viewer.refSize * viewer.groundDistance / 100;
                    // if (this.isClosedPage()) {
                    //   viewer.stage.ground.position.z -= viewer.coverDepth * 2;
                    // }
                    viewer.stage.ground.position.z = Math.max(viewer.stage.ground.position.z, -viewer.refSize * 0.1);
                } else {
                    viewer.stage.ground.position.z = -viewer.midPosition - viewer.sheetDepth * 15;
                }
                if (viewer.cameraPositionDirty === true) {
                    viewer.updateCameraPosition();
                }
                this.refreshSpiral();
            }
        },
        {
            key: "refreshSpiral",
            value: function refreshSpiral() {}
        },
        {
            key: "updateCameraPosition",
            value: function updateCameraPosition() {
                var viewer = this;
                var app = viewer.app, stage = viewer.stage;
                var dimensions = app.dimensions;
                var padding = dimensions.padding;
                var cameraZ = 1 / (2 * Math.tan(Math.PI * stage.camera.fov * 0.5 / 180) / (dimensions.stage.height / app.zoomValue)) + 2.2;
                this.updateShadowSize();
                this.stage.spotLight.position.x = -this.pageScaleX * 330;
                this.stage.spotLight.position.y = this.pageScaleX * 330;
                this.stage.spotLight.position.z = this.pageScaleX * 550;
                this.stage.spotLight.shadow.camera.far = this.pageScaleX * 1200;
                this.stage.spotLight.shadow.camera.updateProjectionMatrix();
                var shiftY = (padding.top - padding.bottom) / app.zoomValue / 2, shiftX = -(padding.left - padding.right) / app.zoomValue / 2;
                if (stage.camera.position.z !== cameraZ && app.pendingZoom === true) {
                    stage.camera.position.z = cameraZ;
                }
                if (app.zoomValue === 1) {
                    viewer.bookWrapper.rotation.set(0, 0, 0);
                    viewer.bookHelper.rotation.set(0, 0, 0);
                    viewer.cameraWrapper.rotation.set(0, 0, 0);
                    if (app.options.flipbook3DTiltAngleUp !== 0 || app.options.flipbook3DTiltAngleLeft !== 0) {
                        stage.camera.aspect = dimensions.stage.width / dimensions.stage.height;
                        stage.camera.updateProjectionMatrix();
                        //upward rotation is on X axis and is done after left Rotation , Z axis.
                        //Since book need to rotate upwward, rotate X later works
                        viewer.bookWrapper.rotateZ(THREE.Math.degToRad(-app.options.flipbook3DTiltAngleLeft)); //negative goes left
                        viewer.bookWrapper.rotateX(THREE.Math.degToRad(-app.options.flipbook3DTiltAngleUp)); //negative goes upward
                        if (viewer.orientation == 'vertical') {
                            viewer.bookWrapper.scale.y = 1 / (this.isSingle ? 2 : 1);
                        } else {
                            viewer.bookWrapper.scale.x = 1 / (this.isSingle ? 2 : 1);
                        }
                        viewer.bookHelper.update();
                        viewer.fitCameraToCenteredObject(stage.camera, viewer.bookWrapper);
                        viewer.bookWrapper.rotation.set(0, 0, 0);
                        viewer.bookWrapper.scale.x = 1;
                        viewer.bookWrapper.scale.y = 1;
                        //upward rotation is on X axis and is done after left Rotation , Z axis.
                        //Since book need to rotate upwward, rotate X later works
                        // viewer.bookHelper.rotateZ(THREE.Math.degToRad(app.options.flipbook3DTiltAngleLeft)); //negative goes left
                        // viewer.bookHelper.rotateX(THREE.Math.degToRad(-app.options.flipbook3DTiltAngleUp)); //negative goes upward
                        stage.camera.position.set(shiftX, shiftY, stage.camera.position.z + stage.ground.position.z);
                        this.camera.aspect = dimensions.stage.width / dimensions.stage.height;
                        this.camera.updateProjectionMatrix();
                        //upward rotation is on X axis and is done after left Rotation , Z axis.
                        //Since book need to rotate upwward, rotate X later works
                        viewer.cameraWrapper.rotateX(THREE.Math.degToRad(app.options.flipbook3DTiltAngleUp)); //negative goes upward
                        viewer.cameraWrapper.rotateZ(THREE.Math.degToRad(app.options.flipbook3DTiltAngleLeft)); //positive goes left
                    } else {
                        stage.camera.position.set(shiftX, shiftY, cameraZ);
                    }
                }
                stage.camera.updateProjectionMatrix();
                viewer.app.renderRequestStatus = flipbook_3d_DV.REQUEST_STATUS.ON;
                viewer.cameraPositionDirty = false;
            }
        },
        {
            key: "refreshSheet",
            value: function refreshSheet(options) {
                var viewer = this, _sheet = options.sheet, _sheetStackIndex = options.index;
                // region Determine Next Position, angle and Flexibility based on pageLocation
                var oldAngle = _sheet.sheetAngle, newAngle, isFlexible = !(_sheet.isHard || this.flexibility === 0);
                _sheet.leftFlexibility = !isFlexible ? 0 : viewer.leftFlexibility;
                _sheet.rightFlexibility = !isFlexible ? 0 : viewer.rightFlexibility;
                _sheet.leftPos = viewer.midPosition + (_sheetStackIndex - options.midPoint + 1) * viewer.sheetDepth - viewer.sheetDepth / 2;
                _sheet.rightPos = viewer.midPosition - (_sheetStackIndex - options.midPoint) * viewer.sheetDepth - viewer.sheetDepth / 2;
                newAngle = _sheet.targetSide === defaults_DEARVIEWER.TURN_DIRECTION.LEFT ? 0 : 180;
                //endregion
                if (_sheet.isFlipping === false) {
                    if (options.needsFlip) {
                        _sheet.isFlipping = true;
                        if (_sheet.isCover && options.sheetNumber === 0) if (viewer.isRTL) viewer.rightCover.isFlipping = true;
                        else viewer.leftCover.isFlipping = true;
                        if (_sheet.isCover && viewer.totalSheets - options.sheetNumber === 1) if (viewer.isRTL) viewer.leftCover.isFlipping = true;
                        else viewer.rightCover.isFlipping = true;
                        _sheet.element.position.z = Math.max(oldAngle < 90 ? _sheet.leftPos : _sheet.rightPos, viewer.midPosition) + viewer.sheetDepth;
                        //this.beforeFlip();
                        _sheet.flexibility = oldAngle < 90 ? _sheet.leftFlexibility : _sheet.rightFlexibility;
                        _sheet.flip(oldAngle, newAngle);
                    } else {
                        _sheet.skipFlip = false;
                        _sheet.sheetAngle = _sheet.curveAngle = newAngle;
                        _sheet.flexibility = newAngle < 90 ? _sheet.leftFlexibility : _sheet.rightFlexibility;
                        _sheet.element.position.z = newAngle < 90 ? _sheet.leftPos : _sheet.rightPos;
                        _sheet.side = _sheet.targetSide;
                        //sheets from left side coming to right should follow the right side dimension and vice versa
                        _sheet.height = newAngle < 90 ? this.leftSheetHeight : this.rightSheetHeight;
                        _sheet.width = newAngle < 90 ? this.leftSheetWidth : this.rightSheetWidth;
                    }
                    _sheet.updateAngle();
                    this.app.renderRequestStatus = flipbook_3d_DV.REQUEST_STATUS.ON;
                } else {
                // _sheet.element.position.z = oldAngle < 90 ? _sheet.leftPos : _sheet.rightPos;
                }
                //determine visibility
                _sheet.element.visible = options.visible;
            }
        },
        {
            key: "updateCenter",
            value: function updateCenter() {
                var viewer = this, app = this.app;
                var init = this.orientation == 'vertical' ? viewer.wrapper.position.y : viewer.wrapper.position.x, centerShift = (this.orientation === 'vertical' ? -1 : 1) * viewer.centerShift, length = this.isLeftPage() ? this.orientation == 'vertical' ? this.leftSheetHeight : this.leftSheetWidth : this.orientation == 'vertical' ? this.rightSheetHeight : this.rightSheetWidth;
                var end = centerShift * length / 2;
                viewer.seamPosition = (-app.dimensions.offset.width + app.dimensions.containerWidth) / 2 + end;
                //create a centerTween
                if (end !== viewer.centerEnd) {
                    if (viewer.centerTween && viewer.centerTween.stop) viewer.centerTween.stop();
                    viewer.onCenterStartAnimation(this); //solves issue 301 - called early so that waiting doesn't cause flicker
                    viewer.centerTween = new TWEEN.Tween({
                        x: init
                    }).delay(0).to({
                        x: end
                    }, app.zoomValue === 1 && viewer.skipCenterAnimation !== true ? viewer.app.options.duration : 1).onStart(function() {
                    /*viewer.onCenterStartAnimation(this); //is delayed for some reason - maybe waiting for request frame and causes flicker - issue 301*/ }).onUpdate(function() {
                        viewer.onCenterUpdateAnimation(this);
                    }).onComplete(function() {
                        viewer.onCenterCompleteAnimation(this);
                    }).onStop(function() {
                        viewer.onCenterStopAnimation(this);
                    }).easing(TWEEN.Easing.Cubic.InOut).start();
                    this.updatePendingStatusClass();
                    viewer.skipCenterAnimation = false;
                    viewer.centerEnd = end;
                }
                viewer.renderRequestStatus = flipbook_3d_DV.REQUEST_STATUS.ON;
                this.zoomViewer.updateCenter();
            }
        },
        {
            key: "onCenterUpdateAnimation",
            value: function onCenterUpdateAnimation(tween) {
                if (this.orientation == 'vertical') {
                    this.wrapper.position.y = tween.x;
                    //noinspection JSUnresolvedVariable
                    if (this.stage && this.stage.cssScene) this.stage.cssScene.position.y = tween.x;
                } else {
                    this.wrapper.position.x = tween.x;
                    //noinspection JSUnresolvedVariable
                    if (this.stage && this.stage.cssScene) this.stage.cssScene.position.x = tween.x;
                }
            }
        },
        {
            key: "onCenterStartAnimation",
            value: function onCenterStartAnimation(tween) {}
        },
        {
            key: "onCenterStopAnimation",
            value: function onCenterStopAnimation(tween) {}
        },
        {
            key: "onCenterCompleteAnimation",
            value: function onCenterCompleteAnimation(tween) {}
        },
        {
            key: "flipCover",
            value: function flipCover(sheet) {
                var viewer = this, cover = null, multiplier, diff;
                if (sheet.pageNumber === 0 || this.isBooklet && sheet.pageNumber === 1) {
                    cover = this.isRTL ? this.rightCover : this.leftCover;
                    multiplier = this.isRTL ? 1 : -1;
                } else if (sheet.pageNumber === this.totalSheets - 1) {
                    cover = this.isRTL ? this.leftCover : this.rightCover;
                    multiplier = this.isRTL ? -1 : 1;
                }
                if (cover === null) return;
                diff = cover.depth + sheet.depth + 1;
                cover.sheetAngle = sheet.sheetAngle;
                cover.curveAngle = sheet.curveAngle;
                this.rightCover.height = this.leftCover.height = sheet.height + this.coverExtraHeight;
                this.rightCover.width = this.leftCover.width = sheet.width + this.coverExtraWidth;
                cover.flexibility = sheet.flexibility;
                this.rightCover.updateAngle();
                this.leftCover.updateAngle();
                cover.element.position.x = sheet.element.position.x + multiplier * Math.sin(sheet.sheetAngle * Math.PI / 180) * diff;
                cover.element.position.z = sheet.element.position.z + multiplier * Math.cos(sheet.sheetAngle * Math.PI / 180) * diff;
            }
        },
        {
            key: "pagesReady",
            value: function pagesReady() {
                if (this.isAnimating()) return;
                if (this.refreshRequested !== true) return;
                if (this.app.options.flipbookFitPages === false) {
                    var basePage = this.app.viewer.getBasePage();
                    var leftViewPort = this.leftViewport = this.getViewPort(basePage + (this.isBooklet ? 0 : this.isRTL ? 1 : 0)), rightViewPort = this.rightViewPort = this.getViewPort(basePage + (this.isBooklet ? 0 : this.isRTL ? 0 : 1));
                    if (leftViewPort) {
                        var leftDimen = flipbook_3d_utils.contain(leftViewPort.width, leftViewPort.height, this.availablePageWidth(), this.availablePageHeight());
                        if (this.leftSheetWidth != Math.floor(leftDimen.width) || this.leftSheetHeight != Math.floor(leftDimen.height)) {
                            this.cameraPositionDirty = true;
                        }
                        this.leftSheetWidth = Math.floor(leftDimen.width);
                        this.leftSheetHeight = Math.floor(leftDimen.height);
                    }
                    if (rightViewPort) {
                        var rightDimen = flipbook_3d_utils.contain(rightViewPort.width, rightViewPort.height, this.availablePageWidth(), this.availablePageHeight());
                        if (this.rightSheetWidth != Math.floor(rightDimen.width) || this.rightSheetWidth != Math.floor(rightDimen.height)) {
                            this.cameraPositionDirty = true;
                        }
                        this.rightSheetWidth = Math.floor(rightDimen.width);
                        this.rightSheetHeight = Math.floor(rightDimen.height);
                    }
                    for(var i = 0; i < this.sheets.length; i++){
                        var sheet = this.sheets[i];
                        if (sheet.side === flipbook_3d_DV.TURN_DIRECTION.LEFT) {
                            sheet.height = this.leftSheetHeight;
                            sheet.width = this.leftSheetWidth;
                            sheet.updateAngle();
                        } else {
                            sheet.height = this.rightSheetHeight;
                            sheet.width = this.rightSheetWidth;
                            sheet.updateAngle();
                        }
                    }
                    if (this.isClosedPage()) {
                        var isClosedOnRight = this.isRTL && this.isLastPage() || !this.isRTL && this.isFirstPage();
                        this.leftCover.width = this.rightCover.width = isClosedOnRight ? this.rightSheetWidth : this.leftSheetWidth;
                        this.leftCover.height = this.rightCover.height = isClosedOnRight ? this.rightSheetHeight : this.leftSheetHeight;
                    } else {
                        this.leftCover.height = this.rightCover.height = this.coverExtraHeight + Math.max(this.leftSheetHeight, this.rightSheetHeight);
                        this.leftCover.width = this.coverExtraWidth + this.leftSheetWidth;
                        this.rightCover.width = this.coverExtraWidth + this.rightSheetWidth;
                    }
                    this.leftSheets.width = this.leftSheetWidth;
                    this.leftSheets.height = this.leftSheetHeight;
                    this.rightSheets.height = this.rightSheetHeight;
                    this.rightSheets.width = this.rightSheetWidth;
                    this.leftCover.updateAngle();
                    this.leftSheets.updateAngle();
                    this.rightCover.updateAngle();
                    this.rightSheets.updateAngle();
                    this.updateSheets(true);
                }
                this.updateCenter();
                this.updateCSSLayer();
                this.updatePendingStatusClass();
                this.refreshSpiral();
                if (this.cameraPositionDirty === true) {
                    this.updateCameraPosition();
                }
            }
        },
        {
            key: "updateSheets",
            value: function updateSheets(update) {
                if (this.isClosedPage() !== true) {
                    var rightPage = this.getPageByNumber(this.getRightPageNumber());
                    if (this.rightCover.isFlipping !== true && rightPage && rightPage.sheet.element.geometry.attributes) {
                        var pos = this.rightSheets.element.geometry.attributes.position, posX = update ? rightPage.sheet.element.geometry.boundingBox.max.x * rightPage.sheet.element.scale.x : this.rightSheets.lastSlopeX;
                        pos.setX(21, posX);
                        pos.setX(23, posX);
                        pos.setX(4, posX);
                        pos.setX(6, posX);
                        pos.setX(10, posX);
                        pos.setX(14, posX);
                        pos.needsUpdate = true;
                        this.rightSheets.element.geometry.attributes.uv.needsUpdate = true;
                        this.rightSheets.element.geometry.computeVertexNormals();
                        if (update) this.rightSheets.lastSlopeX = posX;
                    }
                    var leftPage = this.getPageByNumber(this.getLeftPageNumber());
                    if (this.leftCover.isFlipping !== true && leftPage && leftPage.sheet.element.geometry.attributes) {
                        var pos1 = this.leftSheets.element.geometry.attributes.position, posX1 = update ? leftPage.sheet.element.geometry.boundingBox.min.x * leftPage.sheet.element.scale.x : this.leftSheets.lastSlopeX;
                        pos1.setX(16, posX1);
                        pos1.setX(18, posX1);
                        pos1.setX(5, posX1);
                        pos1.setX(7, posX1);
                        pos1.setX(8, posX1);
                        pos1.setX(12, posX1);
                        pos1.needsUpdate = true;
                        this.leftSheets.element.geometry.attributes.uv.needsUpdate = true;
                        this.leftSheets.element.geometry.computeVertexNormals();
                        if (update) this.leftSheets.lastSlopeX = posX1;
                    }
                }
            }
        },
        {
            key: "updateCSSLayer",
            value: function updateCSSLayer() {}
        },
        {
            key: "mouseMove",
            value: function mouseMove(event) {
                event = flipbook_3d_utils.fixMouseEvent(event);
                this.app.renderRequestStatus = flipbook_3d_DV.REQUEST_STATUS.ON;
                if (event.touches != null && event.touches.length === 2) {
                    this.pinchMove(event);
                    return;
                }
                var viewer = this;
                var point = viewer.eventToPoint(event);
                if (viewer.dragSheet !== null && viewer.drag3D !== false) {
                    if (Math.abs(point.x - viewer.startPoint.x) > 2) {
                        if (viewer.isDragging !== true) {
                            viewer.updatePendingStatusClass(true);
                            viewer.isDragging = true;
                        }
                        var width = viewer.dragSheet.width;
                        var x = point.x - (this.app.dimensions.origin.x + viewer.centerEnd - width);
                        var distance = flipbook_3d_utils.limitAt(1 - x / width, -1, 1);
                        var angle = flipbook_3d_utils.toDeg(Math.acos(distance));
                        // angle = utils.limitAt(angle, 0, 180);
                        var sheet = viewer.dragSheet;
                        var isLeftPage = viewer.drag === flipbook_3d_DV.TURN_DIRECTION.LEFT;
                        sheet.sheetAngle = angle;
                        var curveAngle = flipbook_3d_utils.getCurveAngle(isLeftPage, angle, 45);
                        if (sheet.isCover) {
                            sheet.viewer.flipCover(sheet);
                        }
                        sheet.curveAngle = sheet.isHard ? angle : curveAngle;
                        sheet.updateAngle();
                    }
                }
                viewer.checkSwipe(point, event);
            }
        },
        {
            /**
   * @param {MouseEvent & jQueryMouseEvent} event
   */ key: "mouseUp",
            value: function mouseUp(event) {
                var viewer = this;
                event = flipbook_3d_utils.fixMouseEvent(event);
                if (!event.touches && event.button !== 0) return;
                if (viewer.dragSheet == null && event.touches != null && event.touches.length === 0) {
                    this.pinchUp(event);
                    return;
                }
                var point = viewer.eventToPoint(event);
                if (viewer.app.zoomValue === 1) {
                    if (viewer.dragSheet !== null) {
                        var distance = point.x - viewer.startPoint.x;
                        if (Math.abs(distance) > viewer.swipeThreshold * 2) {
                            if (viewer.drag === flipbook_3d_DV.TURN_DIRECTION.LEFT && distance > 0) {
                                viewer.app.openLeft();
                            } else if (viewer.drag === flipbook_3d_DV.TURN_DIRECTION.RIGHT && distance < 0) {
                                viewer.app.openRight();
                            }
                        }
                        viewer.requestRefresh();
                        viewer.updatePendingStatusClass();
                    }
                    var element = event.target || event.originalTarget; //check to see if the clicked element is a link, if so skip turn
                    var isClick = viewer.startPoint && point.x === viewer.startPoint.x && point.y === viewer.startPoint.y && element.nodeName !== "A";
                    if (event.ctrlKey === true && isClick) {
                        this.zoomOnPoint(point);
                    } else if (isClick && point.sheet && viewer.clickAction === flipbook_3d_DV.MOUSE_CLICK_ACTIONS.NAV) {
                        if (point.sheet.sheetAngle > 90) {
                            viewer.app.openRight();
                        } else {
                            viewer.app.openLeft();
                        }
                    }
                }
                viewer.dragSheet = null;
                viewer.drag = null;
                if (viewer.isDragging === true) {
                    viewer.isDragging = false;
                }
                /*3 if there is swipe - clean*/ viewer.startPoint = null;
                viewer.canSwipe = false;
                viewer.app.renderRequestStatus = flipbook_3d_DV.REQUEST_STATUS.ON;
            }
        },
        {
            key: "raycastCLick",
            value: function raycastCLick(event) {
                var viewer = this;
                viewer.mouse = new THREE.Vector2();
                viewer.raycaster = new THREE.Raycaster();
                viewer.mouse.x = event.offsetX / viewer.app.dimensions.stage.width * 2 - 1;
                viewer.mouse.y = 1 - event.offsetY / viewer.app.dimensions.stage.height * 2;
                viewer.raycaster.setFromCamera(viewer.mouse, viewer.camera);
                var intersects = viewer.raycaster.intersectObjects(viewer.bookWrapper.children, true);
                if (intersects.length > 0) {
                    var object, objectCount = 0;
                    do {
                        object = intersects[objectCount] != null ? intersects[objectCount].object : null;
                        if (object.sheet && object.sheet.index) {
                            if (object.sheet.isFlipping !== true) {
                                return object;
                            }
                        }
                        objectCount++;
                    }while (objectCount < intersects.length);
                }
            }
        },
        {
            key: "mouseDown",
            value: function mouseDown(event) {
                event = flipbook_3d_utils.fixMouseEvent(event);
                if (!event.touches && event.button !== 0) return;
                if (event.touches != null && event.touches.length === 2) {
                    this.pinchDown(event);
                } else {
                    event = flipbook_3d_utils.fixMouseEvent(event);
                    var viewer = this;
                    var point = viewer.eventToPoint(event);
                    viewer.startPoint = point;
                    viewer.lastPosX = point.x;
                    viewer.lastPosY = point.y;
                    var object = viewer.raycastCLick(event);
                    var edgeDistance = point.sheet ? point.sheet.width - Math.abs(point.x - (this.app.dimensions.origin.x + viewer.centerEnd)) : 0;
                    if (point.sheet && object && point.isInsideSheet && edgeDistance < point.sheet.width / 2) {
                        viewer.dragSheet = object.sheet;
                        viewer.drag = point.sheet.sheetAngle < 90 ? flipbook_3d_DV.TURN_DIRECTION.LEFT : flipbook_3d_DV.TURN_DIRECTION.RIGHT;
                    } else {
                        viewer.canSwipe = true;
                    }
                }
            }
        },
        {
            key: "eventToPoint",
            value: function eventToPoint(event) {
                var viewer = this, dimensions = this.app.dimensions;
                event = flipbook_3d_utils.fixMouseEvent(event);
                var point = {
                    x: event.clientX,
                    y: event.clientY
                };
                //calculate x and y relative to container
                point.x = point.x - viewer.parentElement[0].getBoundingClientRect().left;
                point.y = point.y - viewer.parentElement[0].getBoundingClientRect().top;
                var left = (-dimensions.offset.width + dimensions.containerWidth) / 2 - dimensions.stage.width / 2, right = (-dimensions.offset.width + dimensions.containerWidth) / 2 + dimensions.stage.width / 2, top = dimensions.padding.top, bottom = dimensions.padding.top + viewer.availablePageHeight();
                var isLeftSheet = point.x < viewer.seamPosition;
                var pageNumber = viewer.getBasePage() + (isLeftSheet ? 0 : 1);
                var sheet = this.getPageByNumber(pageNumber);
                if (sheet) sheet = sheet.sheet;
                var isInsideSheet = point.x > left && point.x < right && point.y > top && point.y < bottom;
                return {
                    isInsideSheet: isInsideSheet,
                    isInsideDragZone: isInsideSheet && point.x - left < viewer.foldSense || right - point.x < viewer.foldSense,
                    x: point.x,
                    y: point.y,
                    left: left,
                    top: top,
                    right: right,
                    bottom: bottom,
                    raw: point,
                    isLeftSheet: isLeftSheet,
                    sheet: sheet
                };
            }
        },
        {
            key: "checkPageLoading",
            value: function checkPageLoading() {
                var isLoaded = true;
                var pages = this.getVisiblePages().main;
                for(var index = 0; index < (this.isBooklet ? 1 : 2); index++){
                    var page = this.getPageByNumber(pages[index]);
                    if (page) {
                        isLoaded = page.textureLoaded && isLoaded;
                    }
                }
                this.element.toggleClass("df-loading", !isLoaded);
            }
        },
        {
            key: "textureLoadedCallback",
            value: function textureLoadedCallback(param) {
                this.app.renderRequestStart();
                this.pagesReady();
            }
        },
        {
            key: "getTextureSize",
            value: function getTextureSize(param) {
                var size = flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "getTextureSize", this).call(this, param);
                if (this.app.zoomValue !== 1 || param.isAnnotation === true) return size;
                var height = flipbook_3d_utils.nearestPowerOfTwo(size.height);
                var width = size.width * height / size.height;
                return this.texturePowerOfTwo ? {
                    height: height,
                    width: width
                } : size;
            }
        },
        {
            key: "getPageByNumber",
            value: function getPageByNumber(pageNumber) {
                if (this.has3DCover) {
                    var isLastPage = !this.isBooklet && pageNumber === this.app.pageCount && pageNumber % 2 === 0, isFirstPage = pageNumber === 1;
                    if (!this.isRTL && isFirstPage || this.isRTL && isLastPage) return this.leftCover.frontPage;
                    if (!this.isRTL && isLastPage || this.isRTL && isFirstPage) return this.rightCover.backPage;
                }
                return flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "getPageByNumber", this).call(this, pageNumber);
            }
        },
        {
            key: "setPage",
            value: function setPage(param) {
                return flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "setPage", this).call(this, param);
            }
        },
        {
            key: "beforeFlip",
            value: function beforeFlip() {
                flipbook_3d_get(flipbook_3d_get_prototype_of(FlipBook3D.prototype), "beforeFlip", this).call(this);
            }
        }
    ]);
    return FlipBook3D;
}(BaseFlipBookViewer);
/**
 * Page3D represents only the material side of the booksheet
 */ var Page3D = /*#__PURE__*/ function(Page2D) {
    "use strict";
    flipbook_3d_inherits(Page3D, Page2D);
    var _super = flipbook_3d_create_super(Page3D);
    function Page3D(options) {
        flipbook_3d_class_call_check(this, Page3D);
        var _this;
        _this = _super.call(this, options);
        var page = flipbook_3d_assert_this_initialized(_this);
        page.element = null;
        page.face = options.face;
        page.parent3D = options.sheet;
        page.sheet = options.sheet;
        page.cssPage = new THREE.CSS3DObject(page.contentLayer[0]);
        return _this;
    }
    flipbook_3d_create_class(Page3D, [
        {
            key: "setLoading",
            value: function setLoading() {
                this.sheet.viewer.checkPageLoading();
            }
        },
        {
            key: "clearMap",
            value: function clearMap() {
                this.sheet.element.material[this.face].map = null;
                this.sheet.element.material[this.face].needsUpdate = true;
            }
        },
        {
            key: "loadTexture",
            value: function loadTexture(param) {
                var page = this, texture = param.texture, callback = param.callback;
                page.textureSrc = texture;
                function completed(object, texture3D) {
                    page.updateTextureLoadStatus(true);
                    page.sheet.resetMatColor(page.face, param.texture === page.textureLoadFallback);
                    if (typeof callback == 'function') callback(param);
                }
                if (typeof flipbook_3d_DV.defaults.beforeLoadTexture == 'function') flipbook_3d_DV.defaults.beforeLoadTexture({
                    texture: texture,
                    page: page
                });
                if (this.face === 4) {
                    this.sheet.backImage(texture, completed);
                } else {
                    this.sheet.frontImage(texture, completed);
                }
            }
        }
    ]);
    return Page3D;
}(Page2D);

;// CONCATENATED MODULE: ./src/js/dearviewer/viewers/viewers-lite.js
function viewers_lite_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}

defaults_DEARVIEWER.defaults.maxTextureSize = 2048;
var FlipBook = function FlipBook(options, appContext) {
    "use strict";
    viewers_lite_class_call_check(this, FlipBook);
    if (defaults_DEARVIEWER.utils.canSupport3D() == false) {
        options.is3D = false; //IE 11
    }
    if (defaults_DEARVIEWER.utils.isTrue(options.is3D)) {
        return new FlipBook3D(options, appContext);
    }
    return new FlipBook2D(options, appContext);
};
defaults_DEARVIEWER.viewers = {};
defaults_DEARVIEWER.viewers["flipbook"] = FlipBook;
defaults_DEARVIEWER.viewers["default"] = defaults_DEARVIEWER.viewers["reader"] = Reader;
defaults_DEARVIEWER.viewers["slider"] = Slider;

;// CONCATENATED MODULE: ./src/js/dearviewer/utils/provider.js
/* globals requirejs, jQuery*/ function provider_assert_this_initialized(self) {
    if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
}
function provider_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function provider_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function provider_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) provider_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) provider_defineProperties(Constructor, staticProps);
    return Constructor;
}
function provider_get_prototype_of(o) {
    provider_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return provider_get_prototype_of(o);
}
function provider_inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) provider_set_prototype_of(subClass, superClass);
}
function provider_instanceof(left, right) {
    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
        return !!right[Symbol.hasInstance](left);
    } else {
        return left instanceof right;
    }
}
function provider_possible_constructor_return(self, call) {
    if (call && (provider_type_of(call) === "object" || typeof call === "function")) {
        return call;
    }
    return provider_assert_this_initialized(self);
}
function provider_set_prototype_of(o, p) {
    provider_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return provider_set_prototype_of(o, p);
}
function provider_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function provider_is_native_reflect_construct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        return true;
    } catch (e) {
        return false;
    }
}
function provider_create_super(Derived) {
    var hasNativeReflectConstruct = provider_is_native_reflect_construct();
    return function _createSuperInternal() {
        var Super = provider_get_prototype_of(Derived), result;
        if (hasNativeReflectConstruct) {
            var NewTarget = provider_get_prototype_of(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget);
        } else {
            result = Super.apply(this, arguments);
        }
        return provider_possible_constructor_return(this, result);
    };
}

;// CONCATENATED MODULE: ./src/js/dearviewer/utils/image-provider.js
function image_provider_assert_this_initialized(self) {
    if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
}
function image_provider_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function image_provider_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function image_provider_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) image_provider_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) image_provider_defineProperties(Constructor, staticProps);
    return Constructor;
}
function image_provider_get_prototype_of(o) {
    image_provider_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return image_provider_get_prototype_of(o);
}
function image_provider_inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) image_provider_set_prototype_of(subClass, superClass);
}
function image_provider_possible_constructor_return(self, call) {
    if (call && (image_provider_type_of(call) === "object" || typeof call === "function")) {
        return call;
    }
    return image_provider_assert_this_initialized(self);
}
function image_provider_set_prototype_of(o, p) {
    image_provider_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return image_provider_set_prototype_of(o, p);
}
function image_provider_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function image_provider_is_native_reflect_construct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        return true;
    } catch (e) {
        return false;
    }
}
function image_provider_create_super(Derived) {
    var hasNativeReflectConstruct = image_provider_is_native_reflect_construct();
    return function _createSuperInternal() {
        var Super = image_provider_get_prototype_of(Derived), result;
        if (hasNativeReflectConstruct) {
            var NewTarget = image_provider_get_prototype_of(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget);
        } else {
            result = Super.apply(this, arguments);
        }
        return image_provider_possible_constructor_return(this, result);
    };
}

// EXTERNAL MODULE: ./src/js/dearviewer/utils/tween.js
var tween = __webpack_require__(101);
;// CONCATENATED MODULE: ./src/js/dearviewer/utils/controls.js
/* globals jQuery */ function controls_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function controls_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function controls_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) controls_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) controls_defineProperties(Constructor, staticProps);
    return Constructor;
}
function controls_type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}

this.thumbnail = utils.createBtn('thumbnail', icons['thumbnail'], text.toggleThumbnails);
        this.outline = utils.createBtn('outline', icons['outline'], text.toggleOutline);*/ this.close = controls_utils.createBtn('close', appContext.options.icons['close'], appContext.options.text.close); //todo
        this.buttons.append(this.close);
    }
    controls_create_class(Sidemenu, [
        {
            key: "dispose",
            value: function dispose() {
                this.element.remove();
            }
        }
    ]);
    return Sidemenu;
}();
var BookMarkViewer = /*#__PURE__*/ function() {
    "use strict";
    function BookMarkViewer(options) {
        controls_class_call_check(this, BookMarkViewer);
        this.outline = null;
        this.lastToggleIsShow = true;
        this.container = options.container;
        this.linkService = options.linkService;
        this.outlineItemClass = options.outlineItemClass || "outlineItem";
        this.outlineToggleClass = options.outlineToggleClass || "outlineItemToggler";
        this.outlineToggleHiddenClass = options.outlineToggleHiddenClass || "outlineItemsHidden";
    }
    controls_create_class(BookMarkViewer, [
        {
            key: "dispose",
            value: function dispose() {
                if (this.container) {
                    if (this.container.parentNode) {
                        this.container.parentNode.removeChild(this.container);
                    }
                }
                this.linkService = null;
            }
        },
        {
            key: "reset",
            value: function reset() {
                this.outline = null;
                this.lastToggleIsShow = true;
                var container = this.container;
                while(container.firstChild){
                    container.removeChild(container.firstChild);
                }
            }
        },
        {
            /**
   * @private
   */ key: "_dispatchEvent",
            value: function _dispatchEvent(outlineCount) {
                var event = document.createEvent('CustomEvent');
                event.initCustomEvent('outlineloaded', true, true, {
                    outlineCount: outlineCount
                });
                this.container.dispatchEvent(event);
            }
        },
        {
            /**
   * @private
   */ key: "_bindLink",
            value: function _bindLink(element, item) {
                var linkService = this.linkService;
                if (item.custom === true) {
                    element.href = linkService.getCustomDestinationHash(item.dest);
                    element.onclick = function goToDestination() {
                        linkService.customNavigateTo(item.dest);
                        return false;
                    };
                } else {
                    if (item.url) {
                        pdfjsLib.addLinkAttributes(element, {
                            url: item.url
                        });
                        return;
                    }
                    element.href = linkService.getDestinationHash(item.dest);
                    element.onclick = function goToDestination() {
                        linkService.navigateTo(item.dest);
                        return false;
                    };
                }
            }
        },
        {
            /**
   * Prepend a button before an outline item which allows the user to toggle
   * the visibility of all outline items at that level.
   *
   * @private
   */ key: "_addToggleButton",
            value: function _addToggleButton(div) {
                var _bookMarkViewer = this;
                var toggler = document.createElement('div');
                toggler.className = this.outlineToggleClass + " " + this.outlineToggleHiddenClass;
                toggler.onclick = (function(event) {
                    event.stopPropagation();
                    toggler.classList.toggle(this.outlineToggleHiddenClass);
                    if (event.shiftKey) {
                        var shouldShowAll = !toggler.classList.contains(this.outlineToggleHiddenClass);
                        _bookMarkViewer._toggleOutlineItem(div, shouldShowAll);
                    }
                }).bind(this);
                div.insertBefore(toggler, div.firstChild);
            }
        },
        {
            /**
   * Toggle the visibility of the subtree of an outline item.
   *
   * @param {Element} root - the root of the outline (sub)tree.
   * @param {boolean} show - whether to show the outline (sub)tree. If false,
   *   the outline subtree rooted at |root| will be collapsed.
   *
   * @private
   */ key: "_toggleOutlineItem",
            value: function _toggleOutlineItem(root, show) {
                this.lastToggleIsShow = show;
                var togglers = root.querySelectorAll('.' + this.outlineToggleClass);
                for(var i = 0, ii = togglers.length; i < ii; ++i){
                    togglers[i].classList[show ? 'remove' : 'add'](this.outlineToggleHiddenClass);
                }
            }
        },
        {
            /**
   * @param {BookMarkViewerRenderParameters} params
   */ key: "render",
            value: function render(params) {
                var outline = params && params.outline || null;
                var outlineCount = 0;
                if (this.outline) {
                    this.reset();
                }
                this.outline = outline;
                if (!outline) {
                    //this._dispatchEvent(outlineCount);
                    return;
                }
                var fragment = document.createDocumentFragment();
                var queue = [
                    {
                        parent: fragment,
                        items: this.outline,
                        custom: false
                    }
                ];
                var hasAnyNesting = false;
                while(queue.length > 0){
                    var levelData = queue.shift();
                    var isCustom = levelData.custom;
                    for(var i = 0, len = levelData.items.length; i < len; i++){
                        var item = levelData.items[i];
                        var div = document.createElement('div');
                        div.className = this.outlineItemClass;
                        var element = document.createElement('a');
                        if (item.custom == null && isCustom != null) item.custom = isCustom;
                        this._bindLink(element, item);
                        //element.
                        element.textContent = item.title.replace(/\x00/g, '');
                        //pdfjsLib.removeNullCharacters(item.title) || "Untitled Bookmark";
                        div.appendChild(element);
                        if (item.items && item.items.length > 0) {
                            hasAnyNesting = true;
                            this._addToggleButton(div);
                            var itemsDiv = document.createElement('div');
                            itemsDiv.className = this.outlineItemClass + "s";
                            div.appendChild(itemsDiv);
                            // noinspection JSCheckFunctionSignatures
                            queue.push({
                                parent: itemsDiv,
                                custom: item.custom,
                                items: item.items
                            });
                        }
                        levelData.parent.appendChild(div);
                        outlineCount++;
                    }
                }
                if (hasAnyNesting) {
                    if (this.container.classList != null) {
                        this.container.classList.add(this.outlineItemClass + "s");
                    } else if (this.container.className != null) {
                        this.container.className += " picWindow";
                    }
                }
                this.container.appendChild(fragment);
                this._dispatchEvent(outlineCount);
            }
        }
    ]);
    return BookMarkViewer;
}();
var ThumbList = /*#__PURE__*/ function() {
    "use strict";
    function ThumbList(config) {
        controls_class_call_check(this, ThumbList);
        var onScroll = function onScroll() {
            app.thumbRequestCount = 0;
            app.thumbRequestStatus = REQUEST_STATUS.COUNT;
        };
        var itemHeight = this.itemHeight = config.itemHeight;
        var itemWidth = this.itemWidth = config.itemWidth;
        var app = this.app = config.app;
        this.items = config.items;
        this.generatorFn = config.generatorFn;
        this.totalRows = config.totalRows || config.items && config.items.length;
        this.addFn = config.addFn;
        this.scrollFn = config.scrollFn;
        this.container = document.createElement('div');
        var self = this;
        for(var count = 0; count < this.totalRows; count++){
            var el = document.createElement("div");
            var pageNumber = count + 1;
            el.id = "df-thumb" + pageNumber;
            var image = document.createElement("div"), thumbNumber = document.createElement("div"), wrapper = document.createElement("div");
            wrapper.className = "df-wrapper";
            thumbNumber.className = "df-thumb-number";
            el.className = "df-thumb";
            image.className = "df-bg-image";
            wrapper.style.height = itemHeight + 'px';
            wrapper.style.width = itemWidth + 'px';
            thumbNumber.innerText = app.provider.getLabelforPage(pageNumber);
            el.appendChild(wrapper);
            wrapper.appendChild(thumbNumber);
            wrapper.appendChild(image);
            this.container.appendChild(el);
        }
        self.dispose = function() {
            if (self.container) {
                if (self.container.parentNode) {
                    self.container.parentNode.removeChild(self.container);
                }
            }
            self.container.removeEventListener('scroll', onScroll);
        };
        self.container.addEventListener('scroll', onScroll);
    }
    controls_create_class(ThumbList, [
        {
            key: "processThumbRequest",
            value: function processThumbRequest() {
                controls_utils.log("Thumb Request Initiated");
                var app = this.app;
                app.thumbRequestStatus = REQUEST_STATUS.OFF;
                //move to thumb if thumb is on
                if (app.activeThumb !== app.currentPageNumber) {
                    var thumbVisible = app.thumbContainer != null && app.thumbContainer.hasClass("df-sidemenu-visible");
                    if (thumbVisible) {
                        var thumbWrapper = app.thumblist.container;
                        var thumbWrapperScrollTop = thumbWrapper.scrollTop, thumbWrapperScrollHeight = thumbWrapper.getBoundingClientRect().height;
                        var thumb = app.thumbContainer.find("#df-thumb" + app.currentPageNumber);
                        if (thumb.length > 0) {
                            app.thumbContainer.find(".df-selected").removeClass("df-selected");
                            thumb.addClass("df-selected");
                            //js calculation
                            thumb = thumb[0];
                            //when the thumb is below the display area scroll so that just it's fully visible
                            if (thumbWrapperScrollTop + thumbWrapperScrollHeight < thumb.offsetTop + thumb.scrollHeight) controls_utils.scrollIntoView(thumb, null, false);
                            else if (thumbWrapperScrollTop > thumb.offsetTop) controls_utils.scrollIntoView(thumb);
                            app.activeThumb = app.currentPageNumber;
                        } else {
                            //noinspection JSValidateTypes
                            controls_jQuery(thumbWrapper).scrollTop(app.currentPageNumber * 124);
                            app.thumbRequestStatus = REQUEST_STATUS.ON;
                        }
                    }
                }
                if (app.thumblist.container.getElementsByClassName("df-thumb-requested").length === 0) {
                    var visible = controls_utils.getVisibleElements({
                        container: app.thumblist.container,
                        elements: app.thumblist.container.children
                    });
                    if (controls_jQuery.inArray(visible)) visible.unshift(app.activeThumb);
                    for(var count = 0; count < visible.length; count++){
                        var thumb1 = app.thumblist.container.children[visible[count] - 1];
                        if (thumb1 !== void 0 && thumb1.classList.contains("df-thumb-loaded") === false && thumb1.classList.contains("df-thumb-requested") === false) {
                            thumb1.classList.add("df-thumb-requested");
                            controls_utils.log("Thumb Requested for " + visible[count]);
                            app.provider.processPage({
                                pageNumber: visible[count],
                                textureTarget: defaults_DEARVIEWER.TEXTURE_TARGET.THUMB
                            });
                            return false;
                        }
                    }
                }
            }
        },
        {
            key: "setPage",
            value: function setPage(param) {
                var app = this.app, pageNumber = param.pageNumber, texture = param.texture, textureTarget = param.textureTarget;
                if (textureTarget === defaults_DEARVIEWER.TEXTURE_TARGET.THUMB) {
                    var thumb = app.container.find("#df-thumb" + pageNumber);
                    thumb.find(".df-wrapper").css({
                        height: param.height,
                        width: param.width
                    });
                    thumb.find(".df-bg-image").css({
                        backgroundImage: controls_utils.bgImage(texture)
                    });
                    thumb.addClass("df-thumb-loaded").removeClass("df-thumb-requested");
                }
                controls_utils.log("Thumbnail set for " + param.pageNumber);
                app.thumbRequestStatus = REQUEST_STATUS.ON;
            }
        }
    ]);
    return ThumbList;
}();
defaults_DEARVIEWER.openLightBox = function openLightBox(app) {
    if (!defaults_DEARVIEWER.activeLightBox) {
        defaults_DEARVIEWER.activeLightBox = new DVLightBox(function() {
            if (defaults_DEARVIEWER.activeLightBox.app) {
                defaults_DEARVIEWER.activeLightBox.app.closeRequested = true;
                defaults_DEARVIEWER.activeLightBox.app.analytics({
                    eventAction: defaults_DEARVIEWER.activeLightBox.app.options.analyticsViewerClose,
                    options: defaults_DEARVIEWER.activeLightBox.app.options
                });
            }
            defaults_DEARVIEWER.activeLightBox.app = controls_utils.disposeObject(defaults_DEARVIEWER.activeLightBox.app);
        });
    }
    defaults_DEARVIEWER.activeLightBox.duration = 300;
    if (defaults_DEARVIEWER.activeLightBox.app === undefined || defaults_DEARVIEWER.activeLightBox.app === null || defaults_DEARVIEWER.activeLightBox.app.closeRequested === true || defaults_DEARVIEWER.openLocalFileInput == app // request is through OpenFile function
    ) {
        defaults_DEARVIEWER.activeLightBox.app = controls_utils.disposeObject(defaults_DEARVIEWER.activeLightBox.app);
        if (defaults_DEARVIEWER.activeLightBox.app === null) {
            defaults_DEARVIEWER.activeLightBox.show(function() {
                defaults_DEARVIEWER.activeLightBox.app = controls_jQuery(defaults_DEARVIEWER.activeLightBox.element).dearviewer({
                    transparent: false,
                    isLightBox: true,
                    // hashNavigationEnabled: true,
                    height: "100%",
                    dataElement: app
                });
                if (defaults_DEARVIEWER._isHashTriggered !== true) {
                    history.pushState(null, null, "#");
                }
                defaults_DEARVIEWER.activeLightBox.lightboxWrapper.toggleClass("df-lightbox-padded", defaults_DEARVIEWER.activeLightBox.app.options.popupFullsize === false);
                defaults_DEARVIEWER.activeLightBox.lightboxWrapper.toggleClass("df-rtl", defaults_DEARVIEWER.activeLightBox.app.options.readDirection === defaults_DEARVIEWER.READ_DIRECTION.RTL);
                defaults_DEARVIEWER.activeLightBox.backGround.css({
                    "backgroundColor": defaults_DEARVIEWER.activeLightBox.app.options.backgroundColor === "transparent" ? defaults_DEARVIEWER.defaults.popupBackGroundColor : defaults_DEARVIEWER.activeLightBox.app.options.backgroundColor
                });
            });
        }
    }
};
defaults_DEARVIEWER.checkBrowserURLforDefaults = function() {
    if (controls_utils.isIEUnsupported) return;
    var viewerType = new URL(location.href).searchParams.get('viewer-type') || new URL(location.href).searchParams.get('viewertype');
    var is3D = new URL(location.href).searchParams.get('is-3d') || new URL(location.href).searchParams.get('is3d');
    if (viewerType) {
        defaults_DEARVIEWER.defaults.viewerType = viewerType;
    }
    if (is3D === "true" || is3D === "false") {
        defaults_DEARVIEWER.defaults.is3D = is3D === "true";
    }
};
defaults_DEARVIEWER.checkBrowserURLforPDF = function() {
    var openFlipbook = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
    if (controls_utils.isIEUnsupported) return;
    var pdf = new URL(location.href).searchParams.get('pdf-source');
    if (pdf) {
        pdf = decodeURI(pdf);
        if (openFlipbook) {
            defaults_DEARVIEWER.openURL(pdf);
        }
    }
    return pdf;
};
//Exists if there is need for open file and other lightbox present in the same page. They cannot share same settings.
//also is needed just be a dummy elemet for lightbox dataElement
function createFileInput() {
    if (defaults_DEARVIEWER.openLocalFileInput === void 0) {
        var input = defaults_DEARVIEWER.openLocalFileInput = controls_jQuery('<input type="file" accept=".pdf" style="display:none">').appendTo(controls_jQuery("body")).data('df-option', defaults_DEARVIEWER.openFileOptions);
        input.change(function() {
            var files = input[0].files;
            var file;
            if (files.length) {
                file = files[0];
                input.val("");
                defaults_DEARVIEWER.openFile(file);
            }
        });
    }
}
//default fileDropHandler
defaults_DEARVIEWER.fileDropHandler = function(files, e) {
    var file = files[0];
    if (file.type === "application/pdf") {
        e.preventDefault();
        e.stopPropagation();
        defaults_DEARVIEWER.openFile(file);
    }
};
defaults_DEARVIEWER.openFile = function(file) {
    if (file) {
        var //callback to handle any actions once file is selected.
        _DEARVIEWER_openFileSelected;
        if (defaults_DEARVIEWER.oldLocalFileObjectURL) window.URL.revokeObjectURL(defaults_DEARVIEWER.oldLocalFileObjectURL);
        defaults_DEARVIEWER.oldLocalFileObjectURL = window.URL.createObjectURL(file);
        (_DEARVIEWER_openFileSelected = defaults_DEARVIEWER['openFileSelected']) === null || _DEARVIEWER_openFileSelected === void 0 ? void 0 : _DEARVIEWER_openFileSelected.call(defaults_DEARVIEWER, {
            url: defaults_DEARVIEWER.oldLocalFileObjectURL,
            file: file
        });
        defaults_DEARVIEWER.openURL(defaults_DEARVIEWER.oldLocalFileObjectURL);
    } else {
        defaults_DEARVIEWER.openURL();
    }
};
defaults_DEARVIEWER.openURL = function(src) {
    createFileInput();
    if (src) {
        defaults_DEARVIEWER.openFileOptions.source = src;
        defaults_DEARVIEWER.openFileOptions.pdfParameters = null;
    }
    defaults_DEARVIEWER.openLightBox(defaults_DEARVIEWER.openLocalFileInput);
};
defaults_DEARVIEWER.openBase64 = function(data) {
    defaults_DEARVIEWER.openFileOptions.source = null;
    defaults_DEARVIEWER.openFileOptions.pdfParameters = {
        data: atob(data)
    };
    defaults_DEARVIEWER.openURL();
};
defaults_DEARVIEWER.openLocalFile = function() {
    createFileInput();
    defaults_DEARVIEWER.openLocalFileInput.click();
};
//jQuery events
defaults_DEARVIEWER.initControls = function() {
    //Lightbox Trigger
    var body = controls_jQuery('body');
    if (defaults_DEARVIEWER.defaults.autoPDFLinktoViewer !== false) {
        body.on('click', 'a[href$=".pdf"]', function(event) {
            var app = controls_jQuery(this);
            //prevent Download button to trigger Flipbook!
            if (app.attr("download") !== undefined || app.attr("target") === "_blank" || app.hasClass("df-ui-btn") || app.parents(".df-app").length > 0) {} else {
                event.preventDefault();
                app.data('df-source', app.attr('href'));
                defaults_DEARVIEWER.openLightBox(app);
            }
        });
    }
    window.addEventListener('popstate', function(event) {
        if (defaults_DEARVIEWER.activeLightBox && defaults_DEARVIEWER.activeLightBox.app && !controls_utils.isChromeExtension()) {
            defaults_DEARVIEWER.activeLightBox.closeButton.trigger("click");
        }
    });
    body.on('click', '.df-open-local-file', function(event) {
        defaults_DEARVIEWER.openLocalFile();
    });
    body.on('click', '.df-sidemenu-buttons .df-ui-close', function() {
        var el = controls_jQuery(this);
        el.closest(".df-app").find(".df-ui-btn.df-active").trigger("click");
    });
    body.on('mouseout', '.df-link-content section.squareAnnotation, .df-link-content section.textAnnotation, .df-link-content section.freeTextAnnotation', function() {
        var el = controls_jQuery(this);
        defaults_DEARVIEWER.handlePopup(el, false);
    });
    body.on('mouseover', '.df-link-content section.squareAnnotation, .df-link-content section.textAnnotation, .df-link-content section.freeTextAnnotation', function() {
        var el = controls_jQuery(this);
        defaults_DEARVIEWER.handlePopup(el, true);
    });
    defaults_DEARVIEWER.handlePopup = function(el) {
        var show = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
        var container = el.closest('.df-container');
        var commentPopup = container.find('.df-comment-popup');
        commentPopup.toggleClass("df-active", show);
        if (show) {
            var elBounds = el[0].getBoundingClientRect();
            var containerBounds = container[0].getBoundingClientRect();
            var popup = el.find(".popupWrapper").first();
            if (el.hasClass("popupTriggerArea")) {
                var annotation_id = el.data("annotation-id");
                if (annotation_id !== void 0) {
                    popup = el.siblings("[data-annotation-id=popup_" + annotation_id + "]");
                }
            }
            commentPopup.html(popup.html());
            var left = elBounds.left - containerBounds.left;
            if (left + 360 > containerBounds.width) left = containerBounds.width - 360 - 10;
            else if (left < 10) left = 10;
            var top = elBounds.top - containerBounds.top + elBounds.height + 5;
            if (top + commentPopup.height() > containerBounds.height) top = elBounds.top - commentPopup.height() - elBounds.height - 10;
            else if (top < 10) top = 10;
            commentPopup.css({
                "left": left,
                "top": top
            });
        }
    };
    if (defaults_DEARVIEWER.fileDropElement != void 0) {
        var fileDropElement = controls_jQuery(defaults_DEARVIEWER.fileDropElement);
        if (fileDropElement.length > 0) {
            fileDropElement.on("dragover", function(event) {
                event.preventDefault();
                event.stopPropagation();
                controls_jQuery(this).addClass('df-dragging');
            });
            fileDropElement.on("dragleave", function(event) {
                event.preventDefault();
                event.stopPropagation();
                controls_jQuery(this).removeClass('df-dragging');
            });
            fileDropElement.on("drop", function(e) {
                var files = e.originalEvent.dataTransfer.files; // Array of all files
                var file;
                if (files.length) {
                    defaults_DEARVIEWER.fileDropHandler(files, e);
                }
            });
        }
    }
};

;// CONCATENATED MODULE: ./src/js/dearviewer/app.js
/* globals pdfjsLib,THREE  */ function app_class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function app_defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function app_create_class(Constructor, protoProps, staticProps) {
    if (protoProps) app_defineProperties(Constructor.prototype, protoProps);
    if (staticProps) app_defineProperties(Constructor, staticProps);
    return Constructor;
}
function app_instanceof(left, right) {
    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
        return !!right[Symbol.hasInstance](left);
    } else {
        return left instanceof right;
    }
}

;// CONCATENATED MODULE: ./src/js/dflip.js
/* globals jQuery, pdfjsLib, THREE */ function dflip_instanceof(left, right) {
    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
        return !!right[Symbol.hasInstance](left);
    } else {
        return left instanceof right;
    }
}

}();
/******/ })()
;