Upload 12 files

flipbook.book3.js

@@ -0,0 +1,1230 @@
+/*
+ * Real3D FlipBook [https://real3dflipbook.com]
+ * @author creativeinteractivemedia [https://codecanyon.net/user/creativeinteractivemedia/portfolio]
+ * @version 4.10
+ * @date 2025-05-15
+ */
+'use strict';
+var FLIPBOOK = FLIPBOOK || {};
+
+FLIPBOOK.Book3 = function (el, main, options) {
+    this.options = options;
+    this.main = main;
+
+    this.singlePage = options.singlePageMode;
+    this.pageWidth = options.pageWidth;
+    this.pageHeight = options.pageHeight;
+
+    // Set up the wrapper and parent container
+    this.wrapper = el;
+    this.wrapper.classList.add('flipbook-book3');
+    this.bookLayer = this.wrapper.parentNode;
+
+    this.flipEasing = 'easeOutQuad';
+    this.translateZ = '';
+
+    // Initialize IScroll with options
+    this.iscroll = new FLIPBOOK.IScroll(this.bookLayer, {
+        zoom: true,
+        scrollX: true,
+        scrollY: true,
+        scrollbars: true,
+        keepInCenterV: true,
+        keepInCenterH: true,
+        freeScroll: true,
+        preventDefault: false,
+    });
+
+    // Event listeners for enabling/disabling IScroll
+    main.on('disableIScroll', this.disableIscroll.bind(this));
+    main.on('enableIScroll', this.enableIscroll.bind(this));
+
+    // Handle zoom end event
+    this.iscroll.on('zoomEnd', () => {
+        if (isNaN(this.iscroll.scale)) {
+            return this.zoomTo(options.zoomMin);
+        }
+
+        options.main.onZoom(this.iscroll.scale / this.ratio);
+        this.updateVisiblePages();
+
+        const zoomed = options.main.zoom > 1;
+
+        if (this.zoomed !== zoomed) {
+            const scrollOptions = this.iscroll.options;
+            scrollOptions.eventPassthrough = zoomed ? '' : 'vertical';
+            scrollOptions.freeScroll = zoomed;
+            this.iscroll.refresh();
+            this.zoomed = zoomed;
+        }
+    });
+
+    // Set wrapper and center container dimensions
+    this.wrapper.style.width = `${2 * this.pageWidth}px`;
+    this.wrapper.style.height = `${this.pageHeight}px`;
+
+    this.centerContainer = document.createElement('div');
+    this.centerContainer.className = 'flipbook-center-container3';
+    this.centerContainer.style.width = `${2 * this.pageWidth}px`;
+    this.centerContainer.style.height = `${this.pageHeight}px`;
+    this.wrapper.appendChild(this.centerContainer);
+
+    // Set perspective based on options or view mode
+    const perspective = this.options.perspective || (this.options.viewMode === '3d' ? 3 * this.pageHeight : 200000);
+    this.centerContainer.style.perspective = `${perspective}px`;
+
+    // Initialize pages
+    this.pagesArr = [];
+    this.animating = false;
+
+    let numSheets = this.options.pages.length;
+    if (!this.options.cover) numSheets += 1;
+
+    for (let i = 0; i < numSheets; i++) {
+        const page = new FLIPBOOK.Page3(this, i);
+        this.pagesArr.push(page);
+        this.centerContainer.appendChild(page.wrapper);
+    }
+};
+
+FLIPBOOK.Book3.prototype = Object.create(FLIPBOOK.Book.prototype);
+
+FLIPBOOK.Book3.prototype.constructor = FLIPBOOK.Book3;
+
+FLIPBOOK.Book3.prototype.enableIscroll = function () {
+    if (this.iscrollDisabled) {
+        this.iscroll.enable();
+        this.iscrollDisabled = false;
+    }
+};
+
+FLIPBOOK.Book3.prototype.disableIscroll = function () {
+    if (!this.iscrollDisabled) {
+        this.iscroll.disable();
+        this.iscroll.initiated = false;
+        this.iscrollDisabled = true;
+    }
+};
+
+FLIPBOOK.Book3.prototype.enableMouseWheelZoom = function () {
+    this.iscroll.options.eventPassthrough = 'vertical';
+    this.iscroll.refresh();
+};
+
+FLIPBOOK.Book3.prototype.disableMouseWheelZoom = function () {
+    this.iscroll.options.eventPassthrough = '';
+    this.iscroll.refresh();
+};
+
+FLIPBOOK.Book3.prototype.enablePrev = function (val) {
+    this.prevEnabled = val;
+};
+
+FLIPBOOK.Book3.prototype.enablePan = function () {
+    this.iscroll.enable();
+};
+
+FLIPBOOK.Book3.prototype.disablePan = function () {
+    this.iscroll.disable();
+};
+
+FLIPBOOK.Book3.prototype.setRightIndex = function (val) {
+    this.rightIndex = val;
+};
+
+FLIPBOOK.Book3.prototype.enableNext = function (val) {
+    this.nextEnabled = val;
+};
+
+FLIPBOOK.Book3.prototype.isZoomed = function () {
+    return this.options.main.zoom > this.options.zoomMin && this.options.main.zoom > 1;
+};
+
+FLIPBOOK.Book3.prototype.getNumPages = function () {};
+
+FLIPBOOK.Book3.prototype.move = function (direction) {
+    if (this.zoom <= 1) {
+        return;
+    }
+
+    var iscroll = this.iscroll;
+    var offset2 = 0;
+
+    if (iscroll) {
+        var posX = iscroll.x;
+        var posY = iscroll.y;
+        var offset = 20 * this.zoom;
+        switch (direction) {
+            case 'left':
+                posX += offset;
+                break;
+            case 'right':
+                posX -= offset;
+                break;
+            case 'up':
+                posY += offset;
+                break;
+            case 'down':
+                posY -= offset;
+                break;
+        }
+
+        if (posX > 0) {
+            posX = offset2;
+        }
+        if (posX < iscroll.maxScrollX) {
+            posX = iscroll.maxScrollX - offset2;
+        }
+        if (posY > 0) {
+            posY = offset2;
+        }
+        if (posY < iscroll.maxScrollY) {
+            posY = iscroll.maxScrollY - offset2;
+        }
+
+        iscroll.scrollTo(posX, posY, 0);
+    }
+};
+
+FLIPBOOK.Book3.prototype.zoomTo = function (zoom, time, x, y) {
+    if (!this.enabled) {
+        return;
+    }
+
+    x = x || 0;
+    y = y || 0;
+    time = time || 0;
+    this.zoom = zoom;
+
+    time = 0;
+
+    var iscroll = this.iscroll;
+    if (iscroll) {
+        iscroll.zoom(zoom * this.ratio, x, y, time);
+    }
+};
+
+FLIPBOOK.Book3.prototype.setWrapperW = function (w) {
+    if (this.wrapperW != w) {
+        this.wrapper.style.width = w + 'px';
+        this.wrapperW = w;
+    }
+};
+
+FLIPBOOK.Book3.prototype.updateBookPosition = function () {
+    if (this.singlePage) {
+        this.setWrapperW(this.pageWidth);
+        if (this.iscroll) {
+            this.iscroll.refresh();
+        }
+        this.view = 1;
+        this.focusRight();
+        return;
+    }
+
+    if (this.view == 1) {
+        this.setWrapperW(this.pageWidth);
+    } else {
+        this.setWrapperW(2 * this.pageWidth);
+    }
+    if (this.iscroll) {
+        this.iscroll.refresh();
+    }
+
+    if (this.view == 2) {
+        if (this.isCover()) {
+            this.focusRight();
+        } else if (this.isBackCover()) {
+            if (!this.options.cover) {
+                this.focusBoth();
+            } else {
+                this.focusLeft();
+            }
+        } else {
+            this.focusBoth();
+        }
+    } else if (this.view == 1) {
+        if (this.isCover()) {
+            this.focusRight();
+        } else if (this.isBackCover()) {
+            this.focusLeft();
+        }
+    }
+};
+
+FLIPBOOK.Book3.prototype.focusLeft = function (time, delay) {
+    var pos = this.view == 1 || this.singlePage ? 0 : this.pageWidth / 2;
+
+    this.setBookPosition(pos, time, delay);
+};
+
+FLIPBOOK.Book3.prototype.focusRight = function (time, delay, updatePageNumber) {
+    var pos = this.view == 1 || this.singlePage ? -this.pageWidth : -this.pageWidth / 2;
+
+    this.setBookPosition(pos, time, delay, updatePageNumber);
+};
+
+FLIPBOOK.Book3.prototype.focusBoth = function (time, delay) {
+    var pos = this.view == 1 ? -this.pageWidth / 2 : 0;
+
+    this.setBookPosition(pos, time, delay);
+};
+
+FLIPBOOK.Book3.prototype.setBookPosition = function (pos, time, delay, updatePageNumber) {
+    if (this.centerContainerPosition == pos) {
+        return;
+    }
+    var start = this.centerContainerPosition;
+
+    if (time) {
+        var self = this;
+        delay = delay || 0;
+
+        const animationParams = {
+            from: start,
+            to: pos,
+            delay,
+            duration: time,
+            step(now) {
+                self.centerContainer.style.transform = 'translateX(' + now + 'px) ' + self.translateZ;
+            },
+            complete() {
+                self.centerContainerPosition = pos;
+                if (updatePageNumber) {
+                    self.updateFlipped();
+                    self.options.main.turnPageComplete();
+                }
+            },
+        };
+
+        this.animate(animationParams);
+    } else if (this.centerContainerPosition != pos) {
+        this.centerContainerPosition = pos;
+        this.centerContainer.style.transform = 'translateX(' + pos + 'px) ' + this.translateZ;
+
+        this.updateFlipped();
+        this.options.main.turnPageComplete();
+    }
+};
+
+FLIPBOOK.Book3.prototype.updateSinglePage = function (singlePage) {
+    this.singlePage = singlePage;
+    let ri = this.rightIndex;
+    if (ri > 0) {
+        if (this.singlePage) {
+            ri--;
+        } else if (ri % 2 == 1) {
+            ri++;
+        }
+        this.setRightIndex(ri);
+    }
+    this.resetLoadedPages();
+    this.onResize();
+    this.updateVisiblePages();
+};
+
+FLIPBOOK.Book3.prototype.resetLoadedPages = function () {
+    this.pagesArr.forEach(function (page) {
+        if (page.bgFront) page.bgFront.replaceChildren();
+        if (page.bgBack) page.bgBack.replaceChildren();
+        page.sizeFront = 0;
+        page.sizeBack = 0;
+
+        if (page.html.front) page.html.front.replaceChildren();
+        if (page.html.back) page.html.back.replaceChildren();
+        if (page.htmlContent) {
+            page.htmlContent.front = null;
+            page.htmlContent.back = null;
+        }
+        if (page.htmlLoaded) {
+            page.htmlLoaded.front = null;
+            page.htmlLoaded.back = null;
+        }
+    });
+};
+
+FLIPBOOK.Book3.prototype.updateVisiblePages = function (loadNextPrev) {
+    if (typeof loadNextPrev == 'undefined') {
+        loadNextPrev = true;
+    }
+    var self = this;
+
+    var index = this.rightIndex;
+    if (!this.singlePage) {
+        index /= 2;
+    }
+
+    // if (!this.options.backCover && this.options.rightToLeft) {
+    //     index--;
+    // }
+
+    let numPages = this.options.pages.length;
+    let numSheets = this.singlePage ? numPages : numPages / 2;
+    if (!this.options.cover) numSheets++;
+    this.visibleSheets = [];
+    for (let i = 0; i < numSheets; i++) {
+        this.visibleSheets.push(this.pagesArr[i]);
+    }
+
+    var right = this.visibleSheets[index];
+    var next = this.visibleSheets[index + 1];
+    var left = this.visibleSheets[index - 1];
+    var prev = this.visibleSheets[index - 2];
+
+    if (left) {
+        left._setAngle(180);
+    }
+    if (right) {
+        right._setAngle(0);
+    }
+
+    for (var i = 0; i < this.pagesArr.length; i++) {
+        if (this.pagesArr[i] == right) {
+            this.pagesArr[i].show();
+            this.pagesArr[i].unpauseHtml('front');
+            this.pagesArr[i].pauseHtml('back');
+        } else if (this.pagesArr[i] == left && !this.singlePage) {
+            this.pagesArr[i].show();
+            this.pagesArr[i].unpauseHtml('back');
+            this.pagesArr[i].pauseHtml('front');
+        } else {
+            this.pagesArr[i].hide();
+            this.pagesArr[i].pauseHtml('front');
+            this.pagesArr[i].pauseHtml('back');
+        }
+
+        this.pagesArr[i]._setZIndex(0);
+    }
+    this.updateBookPosition();
+
+    if (left && !this.singlePage) {
+        self.options.main.setLoadingProgress(0.1);
+        left.load('back', function () {
+            self.options.main.setLoadingProgress(1);
+            left.startHTML('back');
+            if (right) {
+                self.options.main.setLoadingProgress(0.1);
+                right.load('front', function () {
+                    self.options.main.setLoadingProgress(1);
+                    right.load('back', null, true);
+                    if (next) {
+                        next.load('front', null, true);
+                    }
+                    if (!self.options.doublePage || self.view != 2) {
+                        right.startHTML('front');
+                    }
+                });
+            } else {
+                left.load('front', null, true);
+                if (prev) {
+                    prev.load('back', null, true);
+                }
+            }
+        });
+    } else {
+        self.options.main.setLoadingProgress(0.1);
+        right.load('front', function () {
+            self.options.main.setLoadingProgress(1);
+            if (!self.singlePage) {
+                right.load('back', null, true);
+            } else {
+                if (left) {
+                    left.load('front', null, true);
+                }
+            }
+            if (next) {
+                next.load('front', null, true);
+            }
+            right.startHTML('front');
+        });
+    }
+};
+
+FLIPBOOK.Book3.prototype.enable = function () {
+    this.onResize();
+    this.enabled = true;
+};
+
+FLIPBOOK.Book3.prototype.disable = function () {
+    this.enabled = false;
+};
+
+FLIPBOOK.Book3.prototype.getLeftPage = function () {
+    return this.pagesArr[this.flippedleft - 1];
+};
+
+FLIPBOOK.Book3.prototype.getRightPage = function () {
+    return this.pagesArr[this.flippedleft];
+};
+
+FLIPBOOK.Book3.prototype.getLeftBackPage = function () {
+    return this.pagesArr[this.flippedleft - 2];
+};
+
+FLIPBOOK.Book3.prototype.getRightBackPage = function () {
+    return this.pagesArr[this.flippedleft + 1];
+};
+
+FLIPBOOK.Book3.prototype.getNextPage = function () {
+    return this.pagesArr[this.flippedleft + 2];
+};
+
+FLIPBOOK.Book3.prototype.getPrevPage = function () {
+    return this.pagesArr[this.flippedleft - 3];
+};
+
+FLIPBOOK.Book3.prototype.nextPage = function () {
+    if (!this.nextEnabled) {
+        return;
+    }
+
+    if (this.view == 1 && this.isFocusedLeft() && !this.singlePage) {
+        var duration = 700;
+        var d = (this.options.pageFlipDuration * duration) / 2;
+        this.focusRight(d, 0, true);
+        return;
+    }
+    this.goToPage(this.rightIndex + 2);
+};
+
+FLIPBOOK.Book3.prototype.prevPage = function () {
+    if (!this.prevEnabled) {
+        return;
+    }
+
+    if (this.view == 1 && this.isFocusedRight() && !this.singlePage) {
+        var duration = 700;
+        var d = (this.options.pageFlipDuration * duration) / 2;
+        this.focusLeft(d, 0, true);
+        return;
+    }
+    var target = this.singlePage ? this.rightIndex : this.rightIndex - 2;
+    this.goToPage(target);
+};
+
+FLIPBOOK.Book3.prototype.goToPage = function (index, instant) {
+    if (!this.enabled || this.flipping || isNaN(index)) {
+        return;
+    }
+
+    if (this.singlePage || index % 2 != 0) {
+        index--;
+    }
+
+    if (index < 0) {
+        index = 0;
+    }
+
+    if (index > this.options.pages.length) {
+        index = this.options.pages.length;
+    }
+
+    if (index == this.rightIndex) {
+        return;
+    }
+
+    if (instant || this.options.instantFlip) {
+        this.setRightIndex(index);
+        this.updateFlipped();
+        this.updateVisiblePages();
+        this.options.main.turnPageComplete();
+    } else {
+        var self = this;
+        var end;
+        var duration = 600;
+        var d = this.options.pageFlipDuration * duration;
+        var easing = this.flipEasing;
+
+        if (index > this.rightIndex) {
+            end = 180;
+            if (self.angle <= 0 || self.angle >= 180 || !self.angle) {
+                self.angle = 1;
+            }
+        } else if (index < this.rightIndex) {
+            end = -180;
+            if (self.angle >= 0 || self.angle <= -180 || !self.angle) {
+                self.angle = -1;
+            }
+        }
+
+        this.flipping = true;
+
+        if (!this.singlePage) {
+            if (this.view == 1) {
+                if (index < this.rightIndex) {
+                    this.focusRight(d);
+                } else {
+                    this.focusLeft(d);
+                }
+            } else {
+                if (index == 0) {
+                    this.focusRight(d);
+                } else if (index == this.visibleSheets.length * 2) {
+                    this.focusLeft(d);
+                } else {
+                    this.focusBoth(d);
+                }
+            }
+        }
+
+        this.goingToPage = index;
+
+        if (this.singlePage) {
+            d /= 2;
+        }
+
+        const animationParams = {
+            from: self.angle,
+            to: end,
+            duration: d,
+            easing: easing,
+            step(now) {
+                self._setPageAngle(now);
+            },
+            complete() {
+                self.setRightIndex(self.goingToPage);
+                self.angle = 0;
+                self.flipping = false;
+
+                self.updateFlipped();
+                self.updateVisiblePages();
+                self.options.main.turnPageComplete();
+            },
+        };
+        this.animate(animationParams);
+
+        this.options.main.turnPageStart();
+    }
+};
+
+FLIPBOOK.Book3.prototype.animate = function (params) {
+    FLIPBOOK.animate(params);
+    // const jq = true;
+    // if (!jq) {
+    //     FLIPBOOK.animate(params);
+    // } else {
+    //     jQuery({
+    //         someValue: params.from,
+    //     }).animate(
+    //         {
+    //             someValue: params.to,
+    //         },
+    //         params
+    //     );
+    // }
+};
+
+FLIPBOOK.Book3.prototype.updateFlipped = function () {
+    if (this.singlePage) {
+        this.flippedleft = this.rightIndex;
+        this.flippedright = this.options.pages.length - this.rightIndex;
+    } else {
+        this.flippedleft = (this.rightIndex + (this.rightIndex % 2)) / 2;
+        this.flippedright = this.options.pages.length / 2 - this.flippedleft;
+    }
+};
+
+FLIPBOOK.Book3.prototype.onSwipe = function (event, phase, distanceX, distanceY, duration, fingerCount) {
+    if (this.isZoomed() || event.target.className === 'flipbook-page-link' || this.flipping) {
+        return;
+    }
+
+    const angle = (-distanceX * 180) / this.main.wrapperW;
+    const threshold = 5;
+    const distance = Math.abs(distanceX);
+
+    if (phase === 'start') {
+        this.dragging = true;
+        return;
+    }
+
+    if ((phase === 'end' || phase === 'cancel') && fingerCount <= 1 && distance > threshold) {
+        angle > 0 ? this.nextPage() : this.prevPage();
+        this.dragging = false;
+        return;
+    }
+
+    if (phase === 'move' && fingerCount <= 1 && this.dragging && distance > threshold) {
+        let increment = angle > 0 ? (this.singlePage ? 1 : 2) : this.singlePage ? -1 : -2;
+        if ((angle > 0 && !this.nextEnabled) || (angle < 0 && !this.prevEnabled)) {
+            return;
+        }
+
+        this.goingToPage = this.rightIndex + increment;
+
+        if (
+            this.goingToPage !== this.rightIndex &&
+            this.goingToPage >= 0 &&
+            this.goingToPage <= this.pagesArr.length * 2 &&
+            !this.options.instantFlip
+        ) {
+            this._setPageAngle(angle);
+        }
+    }
+};
+
+FLIPBOOK.Book3.prototype.pauseHtml = function () {
+    for (var i = 0; i < this.pagesArr.length; i++) {
+        this.pagesArr[i].pauseHtml();
+    }
+};
+
+FLIPBOOK.Book3.prototype._setPageAngle = function (angle) {
+    if (this.angle == angle) {
+        return;
+    }
+
+    this.angle = angle;
+
+    var prev;
+    var next;
+    var left;
+    var right;
+    this.angle = angle;
+    // this.pauseHtml();
+
+    var ri = this.rightIndex;
+    var ri2 = this.goingToPage;
+    // if (this.options.rightToLeft && !this.options.backCover) {
+    //     ri--;
+    //     ri2--;
+    // }
+
+    var flippping;
+
+    if (this.singlePage) {
+        right = this.visibleSheets[ri];
+        left = this.visibleSheets[ri - 1];
+        if (angle > 0) {
+            right._setAngle(angle / 2);
+            next = this.visibleSheets[ri2];
+            if (next) {
+                next.show();
+                next.load('front');
+            }
+        } else {
+            left = this.visibleSheets[ri2];
+            left.show();
+            left.load('front');
+            left._setAngle(angle / 2 + 90);
+        }
+
+        if (next) {
+            next._setAngle(0);
+        }
+        if (prev) {
+            prev._setAngle(90);
+        }
+    } else {
+        right = this.visibleSheets[ri / 2];
+        left = this.visibleSheets[ri / 2 - 1];
+        var newRight = this.visibleSheets[ri2 / 2 - 1];
+        var newLeft = this.visibleSheets[ri2 / 2];
+        if (angle > 0) {
+            if (this.view == 1 && this.isFocusedLeft()) {
+                return;
+            }
+            //flipping from right to left
+            //angle 0 -> 180
+
+            if (angle < 90) {
+                flippping = right;
+                if (newRight) newRight.hide();
+            } else {
+                flippping = newRight;
+                right.hide();
+            }
+            flippping.show();
+            flippping._setAngle(angle);
+            next = this.visibleSheets[ri2 / 2];
+            flippping.load(
+                'back',
+                function () {
+                    if (next) {
+                        next.show();
+                        next.load('front', null, true);
+                    }
+                },
+                true
+            );
+        } else {
+            if (this.view == 1 && this.isFocusedRight()) {
+                return;
+            }
+            //flipping from left to right
+            //angle 0 -> -180
+
+            if (angle > -90) {
+                flippping = left;
+                if (newLeft) newLeft.hide();
+            } else {
+                flippping = newLeft;
+                left.hide();
+            }
+            flippping.show();
+            flippping._setAngle(180 + angle);
+            prev = this.visibleSheets[ri2 / 2 - 1];
+            flippping.load(
+                'front',
+                function () {
+                    if (prev) {
+                        prev.show();
+                        prev.load('back', null, true);
+                    }
+                },
+                true
+            );
+        }
+
+        if (next) {
+            next._setAngle(0);
+        }
+        if (prev) {
+            prev._setAngle(180);
+        }
+    }
+};
+
+FLIPBOOK.Book3.prototype.isCover = function () {
+    return this.rightIndex == 0;
+};
+
+FLIPBOOK.Book3.prototype.isBackCover = function () {
+    return this.rightIndex == this.options.pages.length;
+};
+
+FLIPBOOK.Book3.prototype.onPageUnloaded = function (index) {
+    var pageIndex = index;
+
+    if (this.options.rightToLeft) {
+        pageIndex = this.options.pages.length - index - 1;
+    }
+
+    if (this.pagesArr[pageIndex]) {
+        this.pagesArr[pageIndex].unload();
+    }
+};
+
+FLIPBOOK.Book3.prototype.onResize = function () {
+    var self = this;
+
+    var main = this.main;
+    var w = main.wrapperW;
+    var h = main.wrapperH;
+    var bw = main.bookW;
+    var bh = main.bookH;
+    var pw = main.pageW;
+    var ph = main.pageH;
+    var r1 = w / h;
+    var r2 = pw / ph;
+    var options = this.options;
+
+    function fitToHeight() {
+        self.ratio = h / bh;
+        fit();
+    }
+
+    function fitToWidth() {
+        self.ratio = self.view == 1 ? w / pw : w / bw;
+        fit();
+    }
+
+    function fit() {
+        if (self.iscroll) {
+            self.iscroll.options.zoomMin = self.ratio * options.zoomMin;
+        }
+        if (self.iscroll) {
+            self.iscroll.options.zoomMax = self.ratio * options.zoomMax;
+        }
+
+        self.updateBookPosition();
+        if (self.iscroll) {
+            self.iscroll.zoom(self.ratio * options.main.zoom, w / 2, h / 2, 0);
+        }
+
+        self.bookScale = self.iscroll.scale;
+    }
+
+    var s = Math.min(this.zoom, 1);
+
+    var zoomMin = Number(this.options.zoomMin);
+
+    if (
+        this.singlePage ||
+        (this.options.responsiveView &&
+            w <= this.options.responsiveViewTreshold &&
+            r1 < 2 * r2 &&
+            r1 < this.options.responsiveViewRatio)
+    ) {
+        this.view = 1;
+
+        if (r2 > r1) {
+            this.sc = (zoomMin * r1) / (r2 * s);
+        } else {
+            this.sc = 1;
+        }
+
+        if (w / h > pw / ph) {
+            fitToHeight();
+        } else {
+            fitToWidth();
+        }
+    } else {
+        this.view = 2;
+
+        if (r1 < 2 * r2) {
+            this.sc = (zoomMin * r1) / (2 * r2 * s);
+        } else {
+            this.sc = 1;
+        }
+
+        if (w / h >= bw / bh) {
+            fitToHeight();
+        } else {
+            fitToWidth();
+        }
+    }
+
+    this.updateBookPosition();
+    this.updateFlipped();
+    this.options.main.turnPageComplete();
+};
+
+FLIPBOOK.Book3.prototype.isFocusedRight = function () {
+    var center = this.view == 1 ? -this.pageWidth / 2 : 0;
+    if (this.singlePage) {
+        return this.rightIndex % 2 == 0;
+    } else {
+        return this.centerContainerPosition < center;
+    }
+};
+
+FLIPBOOK.Book3.prototype.isFocusedLeft = function () {
+    var center = this.view == 1 ? -this.pageWidth / 2 : 0;
+
+    if (this.singlePage) {
+        return this.rightIndex % 2 == 1;
+    } else {
+        return this.centerContainerPosition > center;
+    }
+};
+
+FLIPBOOK.Page3 = function (book, index) {
+    this.book = book;
+    this.main = book.main;
+    this.options = book.options;
+
+    this.index = index;
+
+    this.wrapper = document.createElement('div');
+    this.wrapper.className = 'flipbook-page3';
+    this.wrapper.style.width = book.options.pageWidth + 'px';
+    this.wrapper.style.height = book.options.pageHeight + 'px';
+    this.angle = 0;
+    this.wrapper.dataset.sheet = index;
+
+    var options = book.options;
+
+    let preloaderSrc = options.pagePreloader || options.assets.spinner;
+    let preloaderClass = options.pagePreloader ? 'flipbook-page-preloader-image' : 'flipbook-page-preloader';
+
+    this.front = document.createElement('div');
+    this.wrapper.appendChild(this.front);
+    this.front.className = 'flipbook-page3-inner flipbook-page3-inner-front';
+
+    this.bgFront = document.createElement('div');
+    this.front.appendChild(this.bgFront);
+    this.bgFront.className = 'flipbook-page3-bg';
+
+    this.htmlFront = document.createElement('div');
+    this.front.appendChild(this.htmlFront);
+    this.htmlFront.className = 'flipbook-page3-html page_' + String(2 * index);
+    this.htmlFront.style.width = (1000 * options.pageWidth) / options.pageHeight + 'px';
+
+    var transform = 'scale(' + this.options.pageHeight / 1000 + ')';
+    if (this.options.doublePage && this.index > 0) {
+        this.htmlFront.style.transform = transform + ' translateX(-100%)';
+    } else {
+        this.htmlFront.style.transform = transform;
+    }
+
+    this.html = { front: this.htmlFront };
+
+    this.frontHtmlContentVisible = false;
+
+    this.preloaderFront = new Image();
+    this.preloaderFront.src = preloaderSrc;
+    this.preloaderFront.className = preloaderClass;
+    this.front.appendChild(this.preloaderFront);
+
+    if (!book.singlePage) {
+        this.back = document.createElement('div');
+        this.wrapper.appendChild(this.back);
+        this.back.className = 'flipbook-page3-inner flipbook-page3-inner-back';
+        this._setVisibility(this.back, false);
+
+        this.bgBack = document.createElement('div');
+        this.back.appendChild(this.bgBack);
+        this.bgBack.className = 'flipbook-page3-bg';
+
+        this.htmlBack = document.createElement('div');
+        this.back.appendChild(this.htmlBack);
+        this.htmlBack.className = 'flipbook-page3-html page_' + String(2 * index + 1);
+        this.htmlBack.style.width = (1000 * options.pageWidth) / options.pageHeight + 'px';
+
+        this.htmlBack.style.transform = transform;
+
+        this.html.back = this.htmlBack;
+
+        this.backHtmlContentVisible = false;
+
+        this.preloaderBack = new Image();
+        this.preloaderBack.src = preloaderSrc;
+        this.preloaderBack.className = preloaderClass;
+        this.back.appendChild(this.preloaderBack);
+    }
+
+    this.htmlPaused = { front: false, back: false };
+
+    this.hide();
+    this.zIndex = 0;
+
+    if (this.options.rightToLeft && !this.options.backCover) {
+        index++;
+    }
+    this.wrapper.style.left = String(this.book.options.pageWidth - 1) + 'px';
+};
+
+FLIPBOOK.Page3.prototype = {
+    load: function (side, callback, thumb) {
+        var pageSize = this.book.pageHeight * this.book.iscroll.scale * window.devicePixelRatio;
+        var o = this.options;
+        var size = pageSize < o.pageTextureSizeSmall ? o.pageTextureSizeSmall : o.pageTextureSize;
+        var isFront = side == 'front' || this.book.singlePage;
+
+        var pageIndex = this.book.singlePage ? this.index : isFront ? this.index * 2 : this.index * 2 + 1;
+        var index = o.rightToLeft ? o.pages.length - pageIndex - 1 : pageIndex;
+
+        if (
+            (this.sizeFront == size && isFront && this.indexFront == index) ||
+            (this.sizeBack == size && !isFront && this.indexBack == index)
+        ) {
+            if (!thumb) {
+                this.loadHTML(side);
+            }
+            if (callback) {
+                callback.call(this);
+            }
+        } else {
+            if (isFront) {
+                this.sizeFront = size;
+            } else {
+                this.sizeBack = size;
+            }
+
+            var self = this;
+
+            if (isFront) this.indexFront = index;
+            else this.indexBack = index;
+
+            o.main.loadPage(index, size, function (page) {
+                if (page && page.image) {
+                    var img = page.image[size] || page.image;
+                    var page = o.pages[index];
+                    if (
+                        (isFront && page && page.side == 'right') ||
+                        (o.rightToLeft && isFront && page && page.side == 'left')
+                    ) {
+                        if (!img.clone) {
+                            img.clone = new Image();
+                            img.clone.src = img.src;
+                        }
+                        img = img.clone;
+                        img.style.transform = 'translateX(-50%)';
+                    }
+
+                    if (isFront) {
+                        if (self.bgFront) self.bgFront.replaceChildren(img);
+                        if (self.preloaderFront) self.preloaderFront.style.display = 'none';
+                    } else {
+                        if (self.bgBack) self.bgBack.replaceChildren(img);
+                        if (self.preloaderBack) self.preloaderBack.style.display = 'none';
+                    }
+
+                    if (!thumb) {
+                        self.loadHTML(side);
+                    }
+                }
+
+                if (callback) {
+                    callback.call(self);
+                }
+            });
+        }
+    },
+
+    loadHTML: function (side) {
+        var self = this;
+
+        var isFront = side == 'front';
+
+        var pageIndex = this.book.singlePage ? this.index : isFront ? this.index * 2 : this.index * 2 + 1;
+
+        var o = this.options;
+        var index = o.rightToLeft ? o.pages.length - pageIndex - 1 : pageIndex;
+
+        if (index < 0) {
+            return;
+        }
+
+        if (this.htmlContent && this.htmlContent[side]) {
+            this.updateHtmlContent(side);
+        } else {
+            this.options.main.loadPageHTML(index, function (html) {
+                self.htmlContent = this.htmlContent || {};
+                self.htmlContent[side] = html;
+                self.updateHtmlContent(side);
+            });
+        }
+    },
+
+    startHTML: function (side) {
+        this.book.startPageItems(this.html[side]);
+    },
+
+    unload: function () {
+        this.size = null;
+        this.mat = false;
+        this.pageSize = null;
+    },
+
+    pauseHtml: function (side) {
+        if (!this.htmlPaused[side]) {
+            this.htmlPaused[side] = true;
+            const htmlContainer = this.html[side];
+            if (!htmlContainer) {
+                return;
+            }
+            this.main.trigger('hidepagehtml', { page: this });
+
+            var mediaElements = htmlContainer.querySelectorAll('video, audio');
+            mediaElements.forEach(function (media) {
+                media.pause();
+            });
+
+            var iframes = htmlContainer.querySelectorAll('iframe');
+            for (var i = 0; i < iframes.length; i++) {
+                var iframe = iframes[i];
+                var src = iframe.src;
+                var youtubeRegex = /(?:youtube\.com\/embed\/|youtu\.be\/)/;
+                // var youtubeRegex =
+                //     /(?:youtube\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11})/;
+
+                // if (youtubeRegex.test(src)) {
+                //     var youtubeVideo = iframe.contentWindow;
+                //     youtubeVideo.postMessage('{"event":"command","func":"pauseVideo","args":""}', '*');
+                // } else {
+                this.removedIframes = this.removedIframes || [];
+                this.removedIframes.push({
+                    iframe: iframe,
+                    parentNode: iframe.parentNode,
+                });
+                iframe.parentNode.removeChild(iframe);
+                // }
+            }
+        }
+    },
+
+    unpauseHtml: function (side) {
+        this.htmlPaused[side] = false;
+        if (this.removedIframes && this.removedIframes.length) {
+            this.removedIframes.forEach(function (obj) {
+                obj.parentNode.appendChild(obj.iframe);
+            });
+        }
+        this.removedIframes = [];
+    },
+
+    showHtml: function () {
+        if (!this.htmlContentVisible) {
+            this.htmlContentVisible = true;
+        }
+    },
+
+    updateHtmlContent: function (side) {
+        this.htmlLoaded = this.htmlLoaded || {};
+        if (!this.htmlLoaded[side]) {
+            var c = this.htmlContent[side];
+            if (c.jquery) {
+                c = c[0];
+            }
+
+            this.htmlLoaded[side] = true;
+            var container = this.html[side];
+            if (container) container.appendChild(c);
+
+            this.main.trigger('showpagehtml', { page: this });
+        }
+        this.startHTML(side);
+    },
+
+    show: function () {
+        if (this.hidden) {
+            this.wrapper.style.display = 'block';
+            this.setShadowOpacity(0);
+            this.showHtml();
+        }
+        this.hidden = false;
+    },
+
+    setShadowOpacity: function (val) {
+        if (this.shadowOpacity != val && !this.hidden) {
+            this.wrapper.style.setProperty('--page3-shadow-opacity', val);
+            this.shadowOpacity = val;
+        }
+    },
+
+    hide: function () {
+        if (!this.hidden) {
+            this.wrapper.style.display = 'none';
+            this.setShadowOpacity(0);
+        }
+
+        this.hidden = true;
+    },
+
+    _setVisibility: function (div, visible) {
+        if (div && div.dataset.visible != visible) {
+            div.dataset.visible = visible;
+            div.style.opacity = visible ? '1' : '0';
+            div.style.pointerEvents = visible ? 'auto' : 'none';
+        }
+    },
+
+    _setAngle: function (angle) {
+        angle = -angle;
+
+        if (angle != this.angle) {
+            this.setShadowOpacity((1 - Math.abs(angle + 90) / 90) * 0.2);
+            this.wrapper.style.setProperty('--page3-rotate-y', String(angle + 'deg'));
+            this._setVisibility(this.front, angle > -90);
+            this._setVisibility(this.back, angle < -90);
+            this.angle = angle;
+            var i;
+            var max = 0;
+            for (i = 0; i < this.book.pagesArr.length; i++) {
+                if (i != this.index && this.book.pagesArr[i].zIndex > max) {
+                    max = this.book.pagesArr[i].zIndex;
+                }
+            }
+            this._setZIndex(max + 1);
+        }
+    },
+
+    _setZIndex: function (val) {
+        if (this.zIndex != val) {
+            this.wrapper.style['z-index'] = val;
+        }
+        this.zIndex = val;
+    },
+};

flipbook.css

@@ -0,0 +1,2515 @@
+.flipbook-overlay {
+    position: fixed;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    background: rgba(0, 0, 0, 0.71);
+    z-index: 2147483646 !important;
+    opacity: 0;
+    transition: opacity 0.3s ease-out;
+}
+
+.flipbook-wrapper {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    -webkit-box-shadow: 0 10px 25px rgba(0, 0, 0, 0.5);
+    box-shadow: 0 10px 25px rgba(0, 0, 0, 0.5);
+    text-shadow: none;
+    -webkit-border-radius: 4px;
+    border-radius: 4px;
+    background: #ffffff;
+}
+
+.flipbook-wrapper-transparent {
+    width: 100%;
+    height: 100%;
+    background: none;
+}
+
+.flipbook-main-wrapper {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    overflow: hidden;
+    direction: ltr !important;
+    scrollbar-color: rgba(130, 130, 130, 0.5) transparent;
+    scrollbar-width: thin;
+}
+
+.flipbook-bookLayer {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    overflow: hidden;
+
+    cursor: -webkit-grab;
+    cursor: grab;
+}
+
+.flipbook-zoomLayer-inside {
+    display: block;
+    position: relative;
+    background-size: contain;
+    text-align: center;
+}
+
+.flipbook-zoomLayer-inside .flipbook-carousel-page {
+    float: left;
+}
+
+.flipbook-book {
+    display: block;
+    position: relative;
+}
+
+.flipbook-page {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    transform: translateZ(0px);
+    will-change: transform;
+    transform-style: preserve-3d;
+}
+
+.flipbook-page3 {
+    position: absolute;
+    background: #eee;
+    will-change: transform;
+    transform: rotateY(var(--page3-rotate-y, 0));
+    transform-origin: 0 50%;
+    -webkit-transform-origin: 0 50%;
+}
+
+.flipbook-page3-html {
+    position: absolute;
+    height: 1000px;
+    transform-origin: 0 0;
+    top: 0;
+    left: 0;
+}
+
+.flipbook-page3-inner {
+    overflow: hidden;
+    width: 100%;
+    height: 100%;
+    position: absolute;
+    will-change: opacity;
+}
+
+.flipbook-page3-inner-back {
+    transform: scaleX(-1);
+}
+
+.flipbook-page3-bg {
+    width: 100%;
+    height: 100%;
+    position: absolute;
+}
+
+.flipbook-page3-bg img {
+    height: 100% !important;
+}
+
+.flipbook-page3 img {
+    top: 0;
+    bottom: 0;
+    right: 0;
+    left: 0;
+    height: 100%;
+    margin: auto;
+    position: absolute;
+    transform-origin: 0 0;
+    -webkit-transform-origin: 0 0;
+    float: left;
+    user-select: none;
+    pointer-events: none;
+    max-width: unset;
+    width: unset;
+}
+
+.flipbook-page3 canvas {
+    width: 100%;
+    height: 100%;
+}
+
+.flipbook-page3::before {
+    content: '';
+    position: fixed;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    background: rgba(0, 0, 0, 1);
+    opacity: var(--page3-shadow-opacity, 0);
+    will-change: opacity;
+    transform: translateZ(0);
+    z-index: 1;
+    pointer-events: none;
+}
+
+.flipbook-page3-front {
+    transform-origin: 0 50%;
+    -webkit-transform-origin: 0 50%;
+}
+
+.flipbook-page3-back {
+    transform-origin: 0% 50%;
+    -webkit-transform-origin: 0% 50%;
+}
+
+.flipbook-page3-back .flipbook-page3-inner {
+    transform: rotateY(180deg);
+}
+
+.flipbook-book3 {
+    display: block;
+    position: relative;
+}
+
+.flipbook-center-container3 {
+    position: relative;
+    will-change: transform;
+    border: none;
+}
+
+.flipbook-page-htmlContent {
+    transform-origin: 0 0;
+    z-index: 50;
+    position: absolute;
+}
+
+.flipbook-page-html video,
+.flipbook-page-html iframe {
+    max-width: initial;
+}
+
+.flipbook-book canvas {
+    position: absolute;
+    left: 0;
+    top: 0;
+    z-index: 50;
+    width: 100%;
+    height: 100%;
+    backface-visibility: hidden;
+    -webkit-backface-visibility: hidden;
+    transform-style: preserve-3d;
+    -webkit-transform-style: preserve-3d;
+}
+
+.flipbook-page img {
+    width: 100%;
+    height: 100%;
+    backface-visibility: hidden;
+    -webkit-backface-visibility: hidden;
+    transform-style: preserve-3d;
+    -webkit-transform-style: preserve-3d;
+}
+
+.flipbook-left-arrow {
+    display: block !important;
+    position: absolute !important;
+    top: 50% !important;
+    left: 0;
+    font-style: normal;
+    font-weight: normal;
+    -webkit-font-smoothing: antialiased;
+    text-align: center;
+    cursor: pointer;
+}
+
+.flipbook-right-arrow {
+    display: block !important;
+    position: absolute !important;
+    top: 50% !important;
+    right: 0;
+    font-style: normal;
+    font-weight: normal;
+    -webkit-font-smoothing: antialiased;
+    text-align: center;
+    cursor: pointer;
+}
+
+.flipbook-first-arrow {
+    display: block !important;
+    position: absolute !important;
+    top: 50%;
+    left: 0;
+    font-style: normal;
+    font-weight: normal;
+    -webkit-font-smoothing: antialiased;
+    text-align: center;
+    cursor: pointer;
+}
+
+.flipbook-last-arrow {
+    display: block !important;
+    position: absolute !important;
+    top: 50%;
+    right: 0;
+    font-style: normal;
+    font-weight: normal;
+    -webkit-font-smoothing: antialiased;
+    text-align: center;
+    cursor: pointer;
+}
+
+.flipbook-currentPageHolder {
+    position: relative;
+    z-index: 3;
+    pointer-events: auto;
+    display: inline-block;
+    user-select: none;
+    display: flex;
+    align-items: center;
+    box-sizing: content-box;
+    width: max-content;
+}
+
+.flipbook-currentPageHolder form {
+    display: flex;
+    top: 0;
+    margin: 0;
+}
+
+.flipbook-currentPageNumber {
+    border-radius: 15px !important;
+    padding: 5px !important;
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif !important;
+    font-size: 14px;
+    line-height: initial;
+}
+
+.flipbook-currentPageInput {
+    line-height: 14px !important;
+    background: none !important;
+    border: none !important;
+    font-size: 14px !important;
+    max-width: initial !important;
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif !important;
+    text-align: right !important;
+    height: 100% !important;
+    padding: 0 !important;
+    border: 2px solid rgba(128, 128, 128, 0.5);
+}
+
+.flipbook-currentPageInput.digits-3 {
+    min-width: calc(3em) !important;
+}
+
+.flipbook-currentPageInput.digits-2 {
+    min-width: calc(2em) !important;
+}
+
+.flipbook-currentPageInput.digits-1 {
+    min-width: calc(1em) !important;
+}
+
+.flipbook-currentPageInput:focus {
+    outline: 2px solid #88888885;
+}
+
+.flipbook-color-transparent {
+    color: transparent !important;
+}
+
+.flipbook-browser-fullscreen {
+    position: fixed !important;
+    top: 0 !important;
+    left: 0 !important;
+    width: 100% !important;
+    height: 100% !important;
+    z-index: 999999 !important;
+    margin: 0 !important;
+    padding: 0 !important;
+}
+
+.flipbook-menuBottom {
+    position: absolute;
+    bottom: 0;
+    margin: 0;
+    padding: 0;
+    z-index: 2;
+    pointer-events: none;
+    display: flex;
+    overflow: visible;
+}
+
+.flipbook-menu-btn-wrapper {
+    display: inline-block;
+    position: relative;
+    overflow: visible;
+}
+
+.flipbook-tools .flipbook-menu-btn-wrapper {
+    pointer-events: auto;
+    display: flex;
+    align-items: center;
+    position: relative;
+    overflow: visible;
+    cursor: pointer;
+    padding-right: 15px;
+    min-width: 130px;
+}
+
+.flipbook-share .flipbook-menu-btn-wrapper {
+    pointer-events: auto;
+    display: inline-block;
+    align-items: center;
+    position: relative;
+    overflow: visible;
+    cursor: pointer;
+    padding: 15px;
+}
+
+.flipbook-menuBottom .flipbook-has-tooltip::before {
+    bottom: calc(100% + 5px);
+}
+
+.flipbook-menuTop .flipbook-has-tooltip::before {
+    top: calc(100% + 5px);
+}
+
+.flipbook-page-item-has-tooltip:hover {
+    z-index: 1;
+}
+
+.flipbook-page-item-has-tooltip:hover::before {
+    visibility: visible;
+    opacity: 1;
+}
+
+.flipbook-tooltip-left::before {
+    left: -20px;
+    transform: translateX(-100%) translateY(-50%);
+    top: 50%;
+}
+
+.flipbook-tooltip-right::before {
+    left: calc(100% + 20px);
+    transform: translateY(-50%);
+    top: 50%;
+}
+
+.flipbook-tooltip-top::before {
+    left: 50%;
+    transform: translateX(-50%);
+    bottom: calc(100% + 20px);
+}
+
+.flipbook-tooltip-bottom::before {
+    left: 50%;
+    transform: translateX(-50%);
+    top: calc(100% + 20px);
+}
+
+.flipbook-tooltip-topLeft::before {
+    left: -20px;
+    transform: translateX(-100%);
+    bottom: calc(100% + 20px);
+}
+
+.flipbook-tooltip-topRight::before {
+    right: -20px;
+    bottom: calc(100% + 20px);
+}
+
+.flipbook-tooltip-bottomLeft::before {
+    left: -20px;
+    transform: translateX(-100%);
+    top: calc(100% + 20px);
+}
+
+.flipbook-tooltip-bottomRight::before {
+    right: -20px;
+    top: calc(100% + 20px);
+}
+
+.flipbook-page-item-has-tooltip::before {
+    content: attr(data-tooltip);
+    position: absolute;
+    visibility: hidden;
+    opacity: 0;
+    background-color: rgba(255, 255, 255, 0.9);
+    color: black;
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif;
+    text-align: center;
+    border-radius: 4px;
+    padding: 10px 20px;
+    font-size: 32px;
+    font-weight: normal;
+    letter-spacing: normal;
+    line-height: 1.4;
+    text-transform: none;
+    width: max-content;
+    max-width: 600px;
+    transition:
+        opacity 0.3s ease,
+        visibility 0.3s ease;
+}
+
+.flipbook-has-tooltip::before {
+    content: attr(data-tooltip);
+    position: absolute;
+    left: 50%;
+    transform: translateX(-50%);
+    visibility: hidden;
+    opacity: 0;
+    background-color: rgba(0, 0, 0, 0.8);
+    color: white;
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif;
+    font-size: 14px;
+    text-align: center;
+    border-radius: 4px;
+    padding: 5px 10px;
+    font-size: 14px;
+    font-weight: normal;
+    letter-spacing: normal;
+    line-height: 1.4;
+    text-transform: none;
+    width: max-content;
+    white-space: nowrap;
+    transition:
+        opacity 0.3s ease,
+        visibility 0.3s ease;
+}
+
+.flipbook-menu-right .flipbook-has-tooltip:last-child::before {
+    left: 100%;
+    transform: translateX(-100%);
+}
+
+.flipbook-menu-left .flipbook-has-tooltip:first-child::before {
+    left: 0%;
+    transform: translateX(0%);
+}
+
+.flipbook-has-tooltip:hover::before {
+    visibility: visible;
+    opacity: 1;
+}
+
+.flipbook-has-tooltip.disabled:hover::before {
+    visibility: hidden;
+    opacity: 0;
+}
+
+.flipbook-menu-fixed {
+    left: 0;
+    right: 0;
+}
+
+.flipbook-menu-fixed .flipbook-menu {
+    align-items: center;
+}
+
+@media only screen and (max-width: 768px) {
+    .flipbook-menu-fixed .flipbook-menu {
+        justify-content: space-around;
+        width: -webkit-fill-available;
+    }
+}
+
+.flipbook-menu-center {
+    justify-content: center;
+    align-items: center;
+}
+
+.flipbook-menu-right {
+    justify-content: flex-end;
+    align-self: center;
+    flex: 1;
+    display: flex;
+    /* min-width: -webkit-min-content; */
+    /* Workaround to Chrome bug */
+}
+
+.flipbook-menu-left {
+    justify-content: flex-start;
+    align-self: center;
+    flex: 1;
+    display: flex;
+    /* min-width: -webkit-min-content; */
+    /* Workaround to Chrome bug */
+}
+
+.flipbook-menu-floating {
+    margin-top: 5px !important;
+    margin-bottom: 5px !important;
+    left: 50%;
+    transform: translate(-50%, 0);
+    min-width: fit-content;
+    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+    border-radius: 2px;
+}
+
+.flipbook-menuTop {
+    position: absolute;
+    top: 0;
+    margin: 0;
+    padding: 0;
+    z-index: 2;
+    pointer-events: none;
+    display: flex;
+    justify-content: space-between;
+    overflow: visible;
+}
+
+.flipbook-menu {
+    position: relative;
+    text-align: center;
+    display: flex;
+}
+
+.flipbook-menu svg,
+.flipbook-nav svg {
+    box-sizing: content-box;
+}
+
+.flipbook-page-caption-btn {
+    padding: 12px;
+    background-color: rgba(255, 255, 255, 0.9);
+    fill: black;
+    display: flex;
+    justify-content: center;
+    border-radius: 6px;
+    bottom: 50px;
+    right: 50px;
+    position: absolute;
+    cursor: pointer;
+    box-sizing: content-box;
+    transform: scale(2);
+}
+
+.htmlContent > .flipbook-page-caption-btn:hover + .flipbook-page-caption {
+    opacity: 1;
+}
+
+.flipbook-page-caption {
+    opacity: 0;
+    position: absolute;
+    bottom: 120px;
+    max-width: calc(100% - 288px);
+    width: max-content;
+    padding: 24px;
+    border-radius: 12px;
+    right: 120px;
+    background-color: rgba(255, 255, 255, 0.9);
+    color: black;
+    font-size: 24px;
+    transition: opacity 0.3s;
+}
+
+.flipbook-menu-btn {
+    user-select: none;
+    display: inline-flex;
+    justify-content: center;
+    cursor: pointer;
+    background: none;
+    transition: all 0.1s ease-out;
+    pointer-events: auto;
+    box-sizing: content-box;
+}
+
+.flipbook-submenu .flipbook-menu-btn {
+    justify-content: left;
+}
+.flipbook-submenu .flipbook-menu-btn svg {
+    margin-right: 10px;
+}
+
+.flipbook-nav .disabled,
+.flipbook-menu .disabled {
+    opacity: 0.2;
+    cursor: inherit;
+    /* pointer-events: none; */
+}
+
+.flipbook-icon-reverse {
+    transform: scaleX(-1);
+    transform-origin: center;
+}
+
+.flipbook-menu .flipbook-findbar {
+    pointer-events: auto;
+    margin-top: 10px;
+}
+
+.flipbook-menu .flipbook-findbar input {
+    width: 140px;
+    margin-left: 0;
+}
+
+.flipbook-thumbHolder {
+    bottom: 0;
+    position: absolute;
+    top: 0;
+    z-index: 9;
+    min-width: 170px;
+    display: flex;
+    flex-direction: column;
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif !important;
+}
+
+.flipbook-thumbsWrapper {
+    bottom: 0;
+    left: 0;
+    top: 90px;
+    overflow: auto;
+    width: 100%;
+    height: 100%;
+}
+
+.flipbook-thumbsScroller {
+    margin: 0;
+    position: relative;
+    text-align: center;
+    display: grid;
+    justify-content: center;
+}
+
+.flipbook-thumbs-grid .flipbook-thumbsWrapper {
+    width: calc(100% - 100px);
+    max-width: 1600px;
+    margin: auto;
+    padding-top: 20px;
+    padding-bottom: 50px;
+    height: max-content;
+}
+
+.flipbook-thumbs-grid .flipbook-thumbsScroller {
+    display: block;
+}
+.flipbook-thumbs-grid {
+    background-color: rgba(0, 0, 0, 0.5) !important;
+    backdrop-filter: blur(20px);
+    width: 100%;
+    color: white;
+}
+
+.flipbook-thumbs-grid .flipbook-menu-title,
+.flipbook-thumbs-grid .flipbook-btn-close svg {
+    color: white !important;
+    fill: white !important;
+}
+
+.flipbook-thumbs-grid .flipbook-menu-header {
+    display: none;
+}
+
+.flipbook-thumbs-grid-close {
+    display: none;
+}
+
+.flipbook-thumbs-grid .flipbook-thumbs-grid-close {
+    display: flex;
+    justify-content: end;
+    top: 10px;
+    right: 40px;
+    z-index: 1;
+}
+
+.flipbook-thumbs-grid .flipbook-thumbs-grid-close svg {
+    font-size: 30px;
+    fill: #fff !important;
+    text-shadow: drop-shadow(rgb(0, 0, 0) 0px 0px 1px);
+    padding: 10px;
+}
+
+.flipbook-thumb {
+    margin: 15px 10px 10px;
+    cursor: pointer;
+    position: relative;
+    display: inline-block;
+    background: rgba(255, 255, 255, 0.5);
+    border: 1px solid rgb(0 0 0 / 25%);
+}
+
+.flipbook-thumb:hover,
+.flipbook-thumb-active {
+    border: 1px solid rgb(0 0 0 / 50%);
+    box-shadow: 0 0 0px 2px rgb(0 0 0 / 25%);
+    transition: 0.2s all;
+    opacity: 0.7;
+}
+
+.flipbook-thumb:hover .flipbook-thumb-num {
+    background: rgba(0, 0, 0, 0.8);
+    transition: 0.2s all;
+}
+
+.flipbook-search {
+    padding: 16px;
+    position: relative;
+}
+
+.flipbook-search-clear {
+    position: absolute;
+    top: 7px;
+    right: 7px;
+}
+
+.flipbook-search-match {
+    padding: 8px 16px;
+    font-size: 14px;
+    line-height: 20px;
+    cursor: pointer;
+    width: 218px;
+}
+
+.flipbook-search-match:hover {
+    text-decoration: underline;
+}
+
+.flipbook-search-match-title {
+    height: 20px;
+}
+
+.flipbook-search-match-text {
+    text-align: left;
+}
+
+.flipbook-thumb-num {
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif;
+    font-size: 14px;
+    line-height: 14px;
+    user-select: none;
+    font-weight: 600;
+    position: relative;
+    position: absolute;
+    bottom: 11px;
+    bottom: 2px;
+    right: 2px;
+    border-radius: 2px;
+    background: rgba(0, 0, 0, 0.6);
+    color: white !important;
+    padding: 4px 6px;
+    display: inline-block;
+}
+
+.flipbook-thumb img {
+    display: inline-block;
+}
+
+.flipbook-toc {
+    margin: 0;
+    padding: 0;
+    position: absolute;
+    top: 50px;
+    bottom: 0;
+    overflow: auto;
+    width: calc(100% - 20px);
+    padding: 0 10px;
+    box-sizing: content-box;
+}
+
+.flipbook-toc ul {
+    list-style: none;
+    padding-left: 0;
+    margin: 0;
+}
+.flipbook-toc .title-container {
+    display: flex;
+    align-items: center;
+    flex: 1;
+}
+
+.flipbook-toc ul ul {
+    padding-left: 20px; /* Indent only nested lists */
+}
+
+.flipbook-toc li {
+    margin: 5px 0;
+}
+
+.flipbook-toc .toc-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 5px 0;
+    cursor: pointer;
+    transition: background-color 0.2s;
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif;
+}
+
+.flipbook-toc .toc-item:hover {
+    background-color: rgba(128, 128, 128, 0.2);
+}
+
+.flipbook-toc .expand-icon,
+.flipbook-toc .spacer {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 1em; /* Fixed width */
+    height: 1em; /* Fixed height to match icon size */
+    margin-right: 8px;
+    flex-shrink: 0;
+}
+
+.flipbook-toc .expand-icon svg {
+    transition: transform 0.2s ease-in-out;
+}
+
+.flipbook-toc .expand-icon.expanded svg {
+    transform: rotate(90deg);
+}
+
+.flipbook-toc .spacer {
+    visibility: hidden;
+}
+
+.flipbook-toc .title-container span.title {
+    font-size: 14px;
+    /* color: #333; */
+}
+
+.flipbook-toc .page-number {
+    font-size: 12px;
+    margin-left: 10px;
+    white-space: nowrap;
+    margin-right: 5px;
+}
+
+.flipbook-tocHolder {
+    position: absolute;
+    top: 0;
+    width: 250px;
+    bottom: 0;
+    z-index: 9;
+}
+
+.flipbook-tocItem {
+    display: block;
+}
+
+.flipbook-tocItem {
+    display: flex;
+    justify-content: space-between;
+    padding: 8px 15px; /* Adjusted padding */
+    margin: 5px 0; /* Optional for spacing between items */
+    align-items: center; /* Ensure vertical alignment of content */
+
+    cursor: pointer;
+    font-size: 14px;
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif;
+    width: 100%;
+}
+
+.flipbook-tocItem .flipbook-icon {
+    margin-right: 10px; /* Add space between icon and title */
+    display: inline-block;
+}
+
+.flipbook-tocItem .title {
+    flex-grow: 1; /* Allow the title to take up remaining space */
+    text-align: left; /* Ensure title aligns left */
+    margin-left: 10px; /* Add some space between icon and title */
+}
+
+.flipbook-tocItem .flipbook-toc-number {
+    text-align: right;
+    width: 25px; /* Ensure the width remains fixed */
+    flex-shrink: 0; /* Prevent the page number from shrinking */
+}
+
+.flipbook-tocItem .title:hover {
+    text-decoration: underline;
+}
+
+.flipbook-tocItem .right {
+    float: right;
+}
+
+.flipbook-tocItem > span {
+    vertical-align: top;
+}
+
+.flipbook-tocItem > span > span {
+    vertical-align: middle;
+}
+
+.flipbook-findbar {
+    position: relative;
+}
+
+.flipbook-findbar input {
+    width: 210px;
+    padding: 5px;
+    font-size: 14px;
+    line-height: initial;
+    border: 1px solid rgba(128, 128, 128, 0.7);
+}
+
+.flipbook-findbar input:focus {
+    outline: 1px solid rgba(128, 128, 128, 0.7);
+}
+
+.flipbook-find-info {
+    padding-left: 10px;
+    max-width: 200px;
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif !important;
+    font-size: 14px;
+    pointer-events: none;
+}
+
+.invisible {
+    opacity: 0;
+    pointer-events: none;
+    display: none;
+}
+
+/* .hidden {
+    display: none !important;
+} */
+
+.flipbook-hidden {
+    display: none !important;
+}
+
+.flipbook-overlay-visible {
+    opacity: 1;
+}
+
+.transition {
+    -webkit-transition: all 0.3s ease-out;
+    -moz-transition: all 0.3s ease-out;
+    -o-transition: all 0.3s ease-out;
+    transition: all 0.3s ease-out;
+}
+
+.flipbook-share-email {
+    background-image: url("data:image/svg+xml,%3Csvg aria-hidden='true' focusable='false' data-prefix='fas' data-icon='at' class='svg-inline--fa fa-at fa-w-16' role='img' xmlns='http://www.w3.org/2000/svg' viewBox='0 0 512 512'%3E%3Cpath fill='currentColor' d='M256 8C118.941 8 8 118.919 8 256c0 137.059 110.919 248 248 248 48.154 0 95.342-14.14 135.408-40.223 12.005-7.815 14.625-24.288 5.552-35.372l-10.177-12.433c-7.671-9.371-21.179-11.667-31.373-5.129C325.92 429.757 291.314 440 256 440c-101.458 0-184-82.542-184-184S154.542 72 256 72c100.139 0 184 57.619 184 160 0 38.786-21.093 79.742-58.17 83.693-17.349-.454-16.91-12.857-13.476-30.024l23.433-121.11C394.653 149.75 383.308 136 368.225 136h-44.981a13.518 13.518 0 0 0-13.432 11.993l-.01.092c-14.697-17.901-40.448-21.775-59.971-21.775-74.58 0-137.831 62.234-137.831 151.46 0 65.303 36.785 105.87 96 105.87 26.984 0 57.369-15.637 74.991-38.333 9.522 34.104 40.613 34.103 70.71 34.103C462.609 379.41 504 307.798 504 232 504 95.653 394.023 8 256 8zm-21.68 304.43c-22.249 0-36.07-15.623-36.07-40.771 0-44.993 30.779-72.729 58.63-72.729 22.292 0 35.601 15.241 35.601 40.77 0 45.061-33.875 72.73-58.161 72.73z'%3E%3C/path%3E%3C/svg%3E");
+}
+
+.flipbook-icon {
+    font-style: normal;
+    font-weight: normal;
+    height: 100%;
+    line-height: 1;
+    -webkit-font-smoothing: antialiased;
+    bottom: 0;
+    text-align: center;
+    display: flex;
+    box-sizing: content-box !important;
+    justify-self: left;
+}
+
+.flipbook-icon path {
+    box-sizing: content-box !important;
+}
+
+.flipbook-btn-close {
+    height: 40px;
+    width: 40px;
+    position: absolute;
+    top: 0;
+    right: 0;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.flipbook-btn-close .flipbook-icon {
+    width: 16px;
+}
+
+.flipbook-font {
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif;
+    font-size: 14px;
+}
+
+.flipbook-btn {
+    text-transform: uppercase;
+    font-weight: bold;
+    user-select: none;
+    cursor: pointer;
+    width: 200px;
+    line-height: 32px;
+    text-align: center;
+    margin: 5px auto;
+    border: none;
+    background: #f9f9f9;
+    background: none;
+    border-radius: 3px;
+    -webkit-transition: none;
+    -o-transition: none;
+    transition: none;
+    font-size: 12px;
+}
+
+.flipbook-bg-gradient {
+    background: #313538dd;
+}
+
+.flipbook-color-gradient {
+    color: #eee;
+    fill: #eee;
+}
+
+.flipbook-color-gradient:hover {
+    color: #eee;
+    fill: #eee;
+}
+
+.flipbook-bg-dark {
+    background: rgb(49, 53, 56);
+}
+
+.flipbook-color-dark {
+    color: rgba(255, 255, 255, 0.75);
+    fill: rgba(255, 255, 255, 0.75);
+}
+
+.flipbook-color-dark:hover {
+    color: #fff;
+    fill: #fff;
+}
+
+.flipbook-bg-light {
+    /* background: rgb(255, 255, 255); */
+}
+
+.flipbook-color-light {
+    color: rgba(50, 50, 50, 0.75);
+    fill: rgba(50, 50, 50, 0.75);
+}
+
+.flipbook-color-light:hover {
+    color: rgb(50, 50, 50);
+    fill: rgb(50, 50, 50);
+}
+
+.flipbook-bg-twilight {
+    background: #141414;
+}
+
+.flipbook-color-twilight {
+    color: #feffd3;
+    fill: #feffd3;
+}
+
+.flipbook-color-twilight:hover {
+    color: #feffd3;
+    fill: #feffd3;
+}
+
+.flipbook-bg-darkgrey {
+    background: #212121;
+}
+
+.flipbook-color-darkgrey {
+    color: #9e9e9e;
+    fill: #9e9e9e;
+}
+
+.flipbook-color-darkgrey:hover {
+    color: #bdbdbd;
+    fill: #bdbdbd;
+}
+
+.flipbook-bg-lightgrey {
+    background: #e0e0e0;
+}
+
+.flipbook-color-lightgrey {
+    color: #757575;
+    fill: #757575;
+}
+
+.flipbook-color-lightgrey:hover {
+    color: #616161;
+    fill: #616161;
+}
+
+.flipbook-sub-menu {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.5);
+    z-index: 999;
+}
+
+.flipbook-sub-menu-center {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 100%;
+    height: 100%;
+}
+
+.flipbook-menu-header {
+    position: relative;
+    padding: 10px;
+    font-size: 16px;
+    text-align: center;
+}
+
+.flipbook-menu-title {
+    pointer-events: none;
+    user-select: none;
+}
+
+.flipbook-sub-menu-content {
+    display: inline-block;
+    margin-top: -20px;
+    min-width: 250px;
+    padding-bottom: 10px;
+}
+
+.flipbook-carousel-slide {
+    -webkit-box-sizing: border-box;
+    -o-box-sizing: border-box;
+    box-sizing: border-box;
+    text-align: center;
+    position: absolute;
+    overflow: hidden;
+}
+
+.flipbook-carousel-slide .slide-wrapper {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+}
+
+.flipbook-carousel-page {
+    display: inline-block;
+    background: #f1f1f1;
+    position: relative;
+    -o-transform-origin: 0 0;
+}
+
+.flipbook-scroll-page {
+    display: block;
+    background: #f1f1f1;
+    position: relative;
+}
+
+.flipbook-carousel-page-inner,
+.flipbook-scroll-page-inner {
+    -webkit-transform-origin: 0 0;
+    -o-transform-origin: 0 0;
+    transform-origin: 0 0;
+    margin: 0;
+    padding: 0;
+    position: absolute;
+    height: 100%;
+    width: 100%;
+    overflow: hidden;
+}
+
+.flipbook-carousel-page-inner canvas,
+.flipbook-scroll-page-inner {
+    width: 100%;
+    height: 100%;
+}
+
+.flipbook-carousel-page img,
+.flipbook-scroll-page img {
+    top: 0;
+    bottom: 0;
+    right: 0;
+    left: 0;
+    margin: auto;
+    position: absolute;
+    pointer-events: none;
+    user-select: none;
+    max-width: 200%;
+}
+
+.flipbook-carousel-page .page-carousel-img,
+.flipbook-scroll-page .page-scroll-img {
+    height: 100%;
+}
+
+/* Hide scrollbar for Chrome, Safari and Opera */
+.flipbook-overflow-hidden::-webkit-scrollbar {
+    display: none;
+}
+
+/* Hide scrollbar for IE, Edge and Firefox */
+
+.flipbook-overflow-hidden {
+    -ms-overflow-style: none;
+    /* IE and Edge */
+    scrollbar-width: none;
+    /* Firefox */
+    overflow: hidden;
+}
+
+/*share*/
+
+.flipbook-share .social.bottom,
+.flipbook-share .social.top {
+    -webkit-transform-origin: 0 0;
+    -o-transform-origin: 0 0;
+}
+
+.flipbook-share {
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+.flipbook-share [class*='entypo-']:before {
+    font-family: entypo, sans-serif;
+}
+
+.flipbook-share label {
+    font-size: 16px;
+    cursor: pointer;
+    margin: 0;
+    padding: 5px 10px;
+    border-radius: 5px;
+    background: #a29baa;
+    color: #333;
+    transition: all 0.3s ease;
+}
+
+.flipbook-share label:hover {
+    opacity: 0.8;
+}
+
+.flipbook-share label span {
+    text-transform: uppercase;
+    font-size: 0.9em;
+    font-family: Lato, sans-serif;
+    font-weight: 700;
+    -webkit-font-smoothing: antialiased;
+    padding-left: 6px;
+}
+
+.flipbook-share ul {
+    position: relative;
+    left: 0;
+    right: 0;
+    height: 46px;
+    color: #fff;
+    margin: auto;
+    padding: 0;
+    list-style: none;
+}
+
+.flipbook-share ul li {
+    font-size: 16px;
+    cursor: pointer;
+    width: 40px;
+    margin: 0;
+    padding: 9px 0;
+    text-align: center;
+    float: left;
+    height: 22px;
+    position: relative;
+    z-index: 2;
+    -webkit-box-sizing: content-box;
+    box-sizing: content-box;
+    transition: all 0.3s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.flipbook-page-preloader {
+    width: auto !important;
+    height: auto !important;
+}
+
+.flipbook-page-preloader-image {
+    width: 100%;
+    height: 100%;
+    position: absolute;
+    top: 0;
+    left: 0;
+}
+
+/** preloader*/
+
+.cssload-container {
+    width: 100%;
+    height: 100%;
+    top: 0;
+    left: 0;
+    text-align: center;
+    position: absolute;
+    z-index: 2147483647 !important;
+    pointer-events: none;
+}
+
+.cssload-speeding-wheel {
+    width: 24px;
+    height: 24px;
+    /* margin: 0 auto; */
+    border: 3px solid rgba(0, 0, 0, 0.4);
+    border-radius: 50%;
+    border-left-color: rgba(255, 255, 255, 0.2);
+    border-right-color: rgba(255, 255, 255, 0.2);
+    animation: cssload-spin 575ms infinite linear;
+    -o-animation: cssload-spin 575ms infinite linear;
+    -ms-animation: cssload-spin 575ms infinite linear;
+    -webkit-animation: cssload-spin 575ms infinite linear;
+    -moz-animation: cssload-spin 575ms infinite linear;
+    top: 45%;
+    position: absolute;
+    left: 50%;
+    margin-left: -15px;
+    margin-top: -15px;
+    z-index: 3;
+}
+
+@keyframes cssload-spin {
+    100% {
+        transform: rotate(360deg);
+    }
+}
+
+@-o-keyframes cssload-spin {
+    100% {
+        -o-transform: rotate(360deg);
+        transform: rotate(360deg);
+    }
+}
+
+@-ms-keyframes cssload-spin {
+    100% {
+        -ms-transform: rotate(360deg);
+        transform: rotate(360deg);
+    }
+}
+
+@-webkit-keyframes cssload-spin {
+    100% {
+        -webkit-transform: rotate(360deg);
+        transform: rotate(360deg);
+    }
+}
+
+@-moz-keyframes cssload-spin {
+    100% {
+        -moz-transform: rotate(360deg);
+        transform: rotate(360deg);
+    }
+}
+
+/**new preloader end*/
+
+.flipbook-loading-text {
+    position: absolute;
+    top: 45%;
+    margin-top: 20px;
+    width: 100%;
+    font-family: 'Open Sans', 'Helvetica Neue', Arial, sans-serif !important;
+    font-size: 14px;
+    color: #aaa !important;
+}
+
+.flipbook-loading-bg {
+    width: 40px;
+    height: 40px;
+    border-radius: 4px;
+    top: 45%;
+    left: 50%;
+    position: absolute;
+    pointer-events: none;
+    background: rgba(0, 0, 0, 0.2);
+    margin: -20px;
+    display: none;
+}
+
+.flipbook-fillPreloader {
+    position: fixed;
+    width: 100%;
+    height: 100%;
+    display: table-cell;
+    text-align: center;
+    vertical-align: middle;
+    pointer-events: none;
+}
+
+.flipbook-fillPreloader img {
+    position: absolute;
+    margin: auto;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+
+    -webkit-transition: all 0.11s ease-out;
+    -moz-transition: all 0.1s ease-out;
+    transition: all 0.1s ease-out;
+}
+
+.thumb-btn-close {
+    right: 0;
+    margin: 3px;
+    border-radius: 2px;
+    position: absolute;
+    cursor: pointer;
+    padding: 4px 6px;
+    background: rgba(0, 0, 0, 0.6);
+}
+
+.thumb-btn-close:hover {
+    background: rgba(0, 0, 0, 0.8);
+}
+
+.flipbook-noselect {
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+.flipbook-btn-active {
+    background: rgba(128, 128, 128, 0.5);
+}
+
+.flipbook-move {
+    cursor: move;
+    /* fallback if move cursor is unsupported */
+    cursor: -webkit-grab;
+    cursor: grab;
+}
+
+.flipbook-page-item {
+    bottom: auto;
+    right: auto;
+    position: absolute;
+    -webkit-transition: all 0.2s ease-out;
+    -moz-transition: all 0.2s ease-out;
+    -o-transition: all 0.2s ease-out;
+    transition: all 0.2s ease-out;
+    z-index: 0;
+}
+
+.flipbook-page-item iframe {
+    width: 100%;
+    height: 100%;
+}
+
+.textLayer mark {
+    background: #ff0;
+    color: transparent !important;
+    padding: 0;
+}
+
+.textLayer .mark-blue {
+    background: blue;
+}
+
+.textLayer .mark-red {
+    background: red;
+}
+
+.textLayer .mark-green {
+    background: green;
+}
+
+/* 
+.flipbook-textLayer {
+    position: absolute;
+    left: 0;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    overflow: hidden;
+    opacity: var(--flipbook-link-opacity);
+    line-height: 1;
+    color: #000;
+    pointer-events: none;
+}
+
+.flipbook-textLayer br {
+    user-select: none;
+}
+
+.flipbook-page-htmlContent * {
+    max-width: initial;
+}
+
+.flipbook-page-htmlContent .pageClickArea {
+    position: absolute;
+    width: 5%;
+    height: 100%;
+    top: 0;
+    cursor: pointer;
+    draggable: none;
+}
+
+.pageClickAreaLeft {
+    left: 0;
+}
+
+.pageClickAreaRight {
+    right: 0;
+}
+
+.textLayer mark {
+    background: #ff0;
+    color: transparent;
+}
+
+.textLayer .mark-blue {
+    background: blue;
+}
+
+.textLayer .mark-red {
+    background: red;
+}
+
+.textLayer .mark-green {
+    background: green;
+}
+
+.textLayer > span {
+    color: transparent !important;
+    position: absolute;
+    white-space: pre;
+    cursor: text;
+    -webkit-transform-origin: 0 0;
+    -moz-transform-origin: 0% 0%;
+    -o-transform-origin: 0% 0%;
+    -ms-transform-origin: 0% 0%;
+    transform-origin: 0 0;
+}
+
+.textLayer > span::selection {
+    color: transparent !important;
+}
+
+.textLayer > div {
+    color: transparent !important;
+    position: absolute;
+    white-space: pre;
+    cursor: text;
+    -webkit-transform-origin: 0 0;
+    -moz-transform-origin: 0% 0%;
+    -o-transform-origin: 0% 0%;
+    -ms-transform-origin: 0% 0%;
+    transform-origin: 0 0;
+}
+
+.textLayer .highlight {
+    margin: -1px;
+    padding: 1px;
+    background-color: rgb(180, 0, 170);
+    border-radius: 4px;
+}
+
+.textLayer .highlight.begin {
+    border-radius: 4px 0 0 4px;
+}
+
+.textLayer .highlight.end {
+    border-radius: 0 4px 4px 0;
+}
+
+.textLayer .highlight.middle {
+    border-radius: 0;
+}
+
+.textLayer .highlight.selected {
+    background-color: rgb(0, 100, 0);
+}
+
+.textLayer ::selection {
+    background: rgb(0, 0, 255);
+}
+
+.textLayer ::-moz-selection {
+    background: rgb(0, 0, 255);
+}
+
+.textLayer .endOfContent {
+    background: initial;
+    display: block;
+    position: absolute;
+    left: 0;
+    top: 100%;
+    right: 0;
+    bottom: 0;
+    z-index: -1;
+    cursor: default;
+    -webkit-user-select: none;
+    -ms-user-select: none;
+    -moz-user-select: none;
+}
+
+.textLayer .endOfContent.active {
+    top: 0;
+}
+
+.flipbook-disable-text-selection {
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+.annotationLayer section {
+    position: absolute;
+    padding: 0;
+    margin: 0;
+    background: none;
+} */
+
+.flipbook-page-html .pageClickArea {
+    position: absolute;
+    width: 50px;
+    height: 50px;
+    bottom: 0;
+    cursor: pointer;
+    z-index: 20;
+}
+
+.pageClickAreaLeft {
+    left: 0;
+}
+
+.pageClickAreaRight {
+    /* right: 0; */
+}
+
+.annotationLayer .linkAnnotation > a,
+.annotationLayer .buttonWidgetAnnotation.pushButton > a,
+.flipbook-page-item-link {
+    position: absolute;
+    font-size: 1em;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: var(--flipbook-link-color);
+    animation-duration: 2000ms;
+    animation-delay: 500ms;
+    animation-name: flashLinks;
+    opacity: var(--flipbook-link-opacity);
+}
+
+.flipbook-page-auto-link {
+    background: var(--flipbook-link-color);
+    color: transparent !important;
+    animation-duration: 2000ms;
+    animation-delay: 500ms;
+    animation-name: flashLinks;
+    pointer-events: auto;
+}
+
+.flipbook-page-auto-link-hover {
+    background: var(--flipbook-link-color-hover) !important;
+    color: transparent !important;
+}
+
+@keyframes flashLinks {
+    0% {
+        background: var(--flipbook-link-color);
+    }
+
+    20% {
+        background: var(--flipbook-link-color-hover);
+    }
+
+    100% {
+        background: var(--flipbook-link-color);
+    }
+}
+
+.flipbook-tooltip {
+    position: absolute;
+    background: rgba(0, 0, 0, 0.8);
+    top: 300px;
+    left: 300px;
+    color: white;
+    padding: 6px 12px;
+    font-size: 13px;
+    line-height: 13px;
+    font-weight: normal;
+    white-space: nowrap;
+    text-align: center;
+    -webkit-transition: opacity 0.2s ease-in;
+    transition: opacity 0.2s ease-in;
+    z-index: 10000;
+}
+
+.flipbook-submenu {
+    position: absolute;
+    right: 0;
+    width: max-content;
+    text-wrap: nowrap;
+}
+
+.flipbook-menuTop .flipbook-submenu {
+    top: calc(100% + 5px);
+}
+
+.flipbook-menuBottom .flipbook-submenu {
+    bottom: calc(100% + 5px);
+}
+
+.flipbook-menuTop * {
+    box-sizing: content-box !important;
+}
+
+.flipbook-menuBottom * {
+    box-sizing: content-box !important;
+}
+
+.flipbook-add-note-rect {
+    position: absolute;
+    pointer-events: none;
+}
+
+.add-note-btn {
+    pointer-events: auto;
+}
+
+.flipbook-add-note-rect .add-note-btn {
+    background: rgba(0, 0, 0, 0.8);
+    border-radius: 0.25em;
+    color: white;
+    padding: 0.3em 1em;
+    text-shadow: 0 1px 0 #000;
+    font-weight: normal;
+    white-space: nowrap;
+    text-align: center;
+    z-index: 10000;
+    left: 50%;
+    transform: translateX(-50%) translateY(-120%);
+    pointer-events: auto;
+    cursor: pointer;
+    position: absolute;
+    opacity: 0;
+}
+
+.flipbook-add-note-rect.hover .add-note-btn {
+    opacity: 1;
+    pointer-events: auto;
+}
+
+.flipbook-note-display {
+    width: 230px;
+    height: 125px;
+    position: absolute;
+    background-color: #fafafa;
+    -webkit-box-shadow: 0 2px 10px 0 rgb(27 47 73 / 30%);
+    box-shadow: 0 2px 10px 0 rgb(27 47 73 / 30%);
+    border-radius: 5px;
+    pointer-events: auto;
+    top: 0;
+    left: 50%;
+    transform: translateX(-50%);
+}
+
+.flipbook-note-display .note-content {
+    height: 76px;
+    position: absolute;
+    width: 210px;
+    margin: 11px 15px 5px 15px;
+    overflow: hidden;
+}
+
+.flipbook-note-display .note-article {
+    font-family: inherit;
+    resize: none;
+    font-size: 14px;
+    width: 200px;
+    height: 76px;
+    position: absolute;
+    left: 0;
+    top: 0;
+    border-width: 1px;
+    border-style: solid;
+    padding: 0;
+    color: rgb(89, 97, 104);
+    border-color: transparent;
+    background-color: transparent;
+    outline: none !important;
+}
+
+.flipbook-note-display .note-article:focus {
+    box-shadow: none;
+}
+
+.flipbook-note-display .note-delete-button .svg-icon {
+    width: 22px;
+    height: 22px;
+    fill: #a6aaad;
+}
+
+.flipbook-note-display .note-button {
+    float: right;
+    font-size: 22px;
+    line-height: 22px;
+    height: 22px;
+    color: #8d8d8d;
+    cursor: pointer;
+    text-align: center;
+    margin: 5px 11px;
+}
+
+.flipbook-note-display .note-footer {
+    height: 37px;
+    width: 100%;
+    margin: 0;
+    bottom: 0;
+    position: absolute;
+}
+
+.flipbook-page-note {
+    pointer-events: auto;
+    cursor: pointer;
+}
+
+.annotationLayer .linkAnnotation > a:hover,
+.annotationLayer .buttonWidgetAnnotation.pushButton > a:hover,
+.flipbook-page-item-link:hover {
+    background: var(--flipbook-link-color-hover) !important;
+    color: transparent !important;
+}
+
+.flipbook-page-auto-link:hover {
+    background: var(--flipbook-link-color-hover) !important;
+    color: transparent !important;
+}
+
+.flipbook-note-display {
+    opacity: 1;
+}
+
+.flipbook-spotlight-overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgb(0, 0, 0, 0.88);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    flex-direction: column;
+    z-index: 10002;
+}
+
+.flipbook-spotlight-overlay img {
+    max-width: 80%;
+    max-height: 80%;
+    box-shadow: 0 0 20px rgba(0, 0, 0, 0.5);
+}
+
+.flipbook-spotlight-close-button {
+    position: absolute;
+    top: 10px;
+    right: 10px;
+    background: rgba(0, 0, 0, 0.8);
+    border-radius: 2px;
+    border: none;
+    cursor: pointer;
+    padding: 0;
+    width: 24px;
+    height: 24px;
+    z-index: 1;
+}
+
+.flipbook-spotlight-close-button:hover {
+    opacity: 0.7;
+}
+
+.flipbook-spotlight-caption-container {
+    color: white;
+    text-align: center;
+    font-size: 16px;
+    line-height: 1.6;
+    padding: 15px;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    margin-top: 10px;
+}
+
+.flipbook-spotlight-title {
+    font-weight: bold;
+    font-size: 18px;
+    margin-bottom: 5px;
+}
+
+.flipbook-spotlight-description {
+    font-size: 14px;
+    font-weight: normal;
+}
+
+.flipbook-page-html {
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    width: 100%;
+}
+
+.flipbook-page-html .htmlContent {
+    position: absolute;
+    height: 100%;
+    width: 100%;
+    z-index: 4;
+    pointer-events: none;
+}
+
+.flipbook-page-html .htmlContent * {
+    pointer-events: auto;
+}
+
+.flipbook-page3-inner[data-visible='false'] .htmlContent * {
+    pointer-events: none !important;
+}
+
+.flipbook-page-html .textLayer {
+    position: absolute;
+    text-align: initial;
+    inset: 0;
+    overflow: hidden;
+    opacity: 0.25;
+    line-height: 1;
+    -webkit-text-size-adjust: none;
+    -moz-text-size-adjust: none;
+    text-size-adjust: none;
+    forced-color-adjust: none;
+    transform-origin: 0 0;
+    z-index: 2;
+    font-weight: initial;
+}
+
+.flipbook-page-html .textLayer :is(span, br) {
+    color: transparent !important;
+    position: absolute;
+    white-space: pre;
+    cursor: text;
+    transform-origin: 0% 0%;
+}
+
+/* Only necessary in Google Chrome, see issue 14205, and most unfortunately
+* the problem doesn't show up in "text" reference tests. */
+.flipbook-page-html .textLayer span.markedContent {
+    top: 0;
+    height: 0;
+}
+
+.flipbook-page-html .textLayer .highlight {
+    margin: -1px;
+    padding: 1px;
+    background-color: var(--highlight-bg-color);
+    border-radius: 4px;
+}
+
+.flipbook-page-html .textLayer .highlight.appended {
+    position: initial;
+}
+
+.flipbook-page-html .textLayer .highlight.begin {
+    border-radius: 4px 0 0 4px;
+}
+
+.flipbook-page-html .textLayer .highlight.end {
+    border-radius: 0 4px 4px 0;
+}
+
+.flipbook-page-html .textLayer .highlight.middle {
+    border-radius: 0;
+}
+
+.flipbook-page-html .textLayer .highlight.selected {
+    background-color: var(--highlight-selected-bg-color);
+}
+
+.flipbook-page-html .textLayer ::-moz-selection {
+    background: blue;
+    background: AccentColor; /* stylelint-disable-line declaration-block-no-duplicate-properties */
+}
+
+.flipbook-page-html .textLayer ::selection {
+    background: blue;
+    background: AccentColor; /* stylelint-disable-line declaration-block-no-duplicate-properties */
+}
+
+/* Avoids https://github.com/mozilla/pdf.js/issues/13840 in Chrome */
+.flipbook-page-html .textLayer br::-moz-selection {
+    background: transparent;
+}
+.flipbook-page-html .textLayer br::selection {
+    background: transparent;
+}
+
+.flipbook-page-html .textLayer .endOfContent {
+    display: block;
+    position: absolute;
+    inset: 100% 0 0;
+    z-index: -1;
+    cursor: default;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    user-select: none;
+}
+
+.flipbook-page-html .textLayer .endOfContent.active {
+    top: 0;
+}
+
+:root {
+    --annotation-unfocused-field-background: url("data:image/svg+xml;charset=UTF-8,<svg width='1px' height='1px' xmlns='http://www.w3.org/2000/svg'><rect width='100%' height='100%' style='fill:rgba(0, 54, 255, 0.13);'/></svg>");
+    --input-focus-border-color: Highlight;
+    --input-focus-outline: 1px solid Canvas;
+    --input-unfocused-border-color: transparent;
+    --input-disabled-border-color: transparent;
+    --input-hover-border-color: black;
+    --link-outline: none;
+}
+
+@media screen and (forced-colors: active) {
+    :root {
+        --input-focus-border-color: CanvasText;
+        --input-unfocused-border-color: ActiveText;
+        --input-disabled-border-color: GrayText;
+        --input-hover-border-color: Highlight;
+        --link-outline: 1.5px solid LinkText;
+        --hcm-highligh-filter: invert(100%);
+    }
+    .annotationLayer .textWidgetAnnotation :is(input, textarea):required,
+    .annotationLayer .choiceWidgetAnnotation select:required,
+    .annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input:required {
+        outline: 1.5px solid selectedItem;
+    }
+
+    .annotationLayer .linkAnnotation:hover {
+        -webkit-backdrop-filter: var(--hcm-highligh-filter);
+        backdrop-filter: var(--hcm-highligh-filter);
+    }
+
+    .annotationLayer .linkAnnotation > a:hover {
+        opacity: 0 !important;
+        background: none !important;
+        box-shadow: none;
+    }
+
+    .annotationLayer .popupAnnotation .popup {
+        outline: calc(1.5px * var(--scale-factor)) solid CanvasText !important;
+        background-color: ButtonFace !important;
+        color: ButtonText !important;
+    }
+
+    .annotationLayer .highlightArea:hover::after {
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        -webkit-backdrop-filter: var(--hcm-highligh-filter);
+        backdrop-filter: var(--hcm-highligh-filter);
+        content: '';
+        pointer-events: none;
+    }
+
+    .annotationLayer .popupAnnotation.focused .popup {
+        outline: calc(3px * var(--scale-factor)) solid Highlight !important;
+    }
+}
+
+.annotationLayer {
+    position: absolute;
+    top: 0;
+    left: 0;
+    pointer-events: none;
+    transform-origin: 0 0;
+    z-index: 3;
+}
+
+.annotationLayer[data-main-rotation='90'] .norotate {
+    transform: rotate(270deg) translateX(-100%);
+}
+.annotationLayer[data-main-rotation='180'] .norotate {
+    transform: rotate(180deg) translate(-100%, -100%);
+}
+.annotationLayer[data-main-rotation='270'] .norotate {
+    transform: rotate(90deg) translateY(-100%);
+}
+
+.annotationLayer canvas {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    pointer-events: none;
+}
+
+.annotationLayer section {
+    position: absolute;
+    text-align: initial;
+    pointer-events: auto;
+    box-sizing: border-box;
+    transform-origin: 0 0;
+}
+
+.annotationLayer .linkAnnotation {
+    outline: var(--link-outline);
+}
+
+.annotationLayer :is(.linkAnnotation, .buttonWidgetAnnotation.pushButton) > a {
+    position: absolute;
+    font-size: 1em;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+}
+
+.annotationLayer :is(.linkAnnotation, .buttonWidgetAnnotation.pushButton):not(.hasBorder) > a:hover {
+    /* opacity: 0.2;
+    background-color: rgba(255, 255, 0, 1);
+    box-shadow: 0 2px 10px rgba(255, 255, 0, 1); */
+}
+
+.annotationLayer .linkAnnotation.hasBorder:hover {
+    background-color: rgba(255, 255, 0, 0.2);
+}
+
+.annotationLayer .hasBorder {
+    background-size: 100% 100%;
+}
+
+.annotationLayer .textAnnotation img {
+    position: absolute;
+    cursor: pointer;
+    width: 100%;
+    height: 100%;
+    top: 0;
+    left: 0;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea),
+.annotationLayer .choiceWidgetAnnotation select,
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input {
+    background-image: var(--annotation-unfocused-field-background);
+    border: 2px solid var(--input-unfocused-border-color);
+    box-sizing: border-box;
+    font: calc(9px * var(--scale-factor)) sans-serif;
+    height: 100%;
+    margin: 0;
+    vertical-align: top;
+    width: 100%;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea):required,
+.annotationLayer .choiceWidgetAnnotation select:required,
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input:required {
+    outline: 1.5px solid red;
+}
+
+.annotationLayer .choiceWidgetAnnotation select option {
+    padding: 0;
+}
+
+.annotationLayer .buttonWidgetAnnotation.radioButton input {
+    border-radius: 50%;
+}
+
+.annotationLayer .textWidgetAnnotation textarea {
+    resize: none;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea)[disabled],
+.annotationLayer .choiceWidgetAnnotation select[disabled],
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input[disabled] {
+    background: none;
+    border: 2px solid var(--input-disabled-border-color);
+    cursor: not-allowed;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea):hover,
+.annotationLayer .choiceWidgetAnnotation select:hover,
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input:hover {
+    border: 2px solid var(--input-hover-border-color);
+}
+.annotationLayer .textWidgetAnnotation :is(input, textarea):hover,
+.annotationLayer .choiceWidgetAnnotation select:hover,
+.annotationLayer .buttonWidgetAnnotation.checkBox input:hover {
+    border-radius: 2px;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea):focus,
+.annotationLayer .choiceWidgetAnnotation select:focus {
+    background: none;
+    border: 2px solid var(--input-focus-border-color);
+    border-radius: 2px;
+    outline: var(--input-focus-outline);
+}
+
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) :focus {
+    background-image: none;
+    background-color: transparent;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox :focus {
+    border: 2px solid var(--input-focus-border-color);
+    border-radius: 2px;
+    outline: var(--input-focus-outline);
+}
+
+.annotationLayer .buttonWidgetAnnotation.radioButton :focus {
+    border: 2px solid var(--input-focus-border-color);
+    outline: var(--input-focus-outline);
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::before,
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::after,
+.annotationLayer .buttonWidgetAnnotation.radioButton input:checked::before {
+    background-color: CanvasText;
+    content: '';
+    display: block;
+    position: absolute;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::before,
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::after {
+    height: 80%;
+    left: 45%;
+    width: 1px;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::before {
+    transform: rotate(45deg);
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::after {
+    transform: rotate(-45deg);
+}
+
+.annotationLayer .buttonWidgetAnnotation.radioButton input:checked::before {
+    border-radius: 50%;
+    height: 50%;
+    left: 30%;
+    top: 20%;
+    width: 50%;
+}
+
+.annotationLayer .textWidgetAnnotation input.comb {
+    font-family: monospace;
+    padding-left: 2px;
+    padding-right: 0;
+}
+
+.annotationLayer .textWidgetAnnotation input.comb:focus {
+    /*
+* Letter spacing is placed on the right side of each character. Hence, the
+* letter spacing of the last character may be placed outside the visible
+* area, causing horizontal scrolling. We avoid this by extending the width
+* when the element has focus and revert this when it loses focus.
+*/
+    width: 103%;
+}
+
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input {
+    -webkit-appearance: none;
+    -moz-appearance: none;
+    appearance: none;
+}
+
+.annotationLayer .fileAttachmentAnnotation .popupTriggerArea {
+    height: 100%;
+    width: 100%;
+}
+
+.annotationLayer .popupAnnotation {
+    position: absolute;
+    font-size: calc(9px * var(--scale-factor));
+    pointer-events: none;
+    width: -moz-max-content;
+    width: max-content;
+    max-width: 45%;
+    height: auto;
+}
+
+.annotationLayer .popup {
+    background-color: rgba(255, 255, 153, 1);
+    box-shadow: 0 calc(2px * var(--scale-factor)) calc(5px * var(--scale-factor)) rgba(136, 136, 136, 1);
+    border-radius: calc(2px * var(--scale-factor));
+    outline: 1.5px solid rgb(255, 255, 74);
+    padding: calc(6px * var(--scale-factor));
+    cursor: pointer;
+    font: message-box;
+    white-space: normal;
+    word-wrap: break-word;
+    pointer-events: auto;
+}
+
+.annotationLayer .popupAnnotation.focused .popup {
+    outline-width: 3px;
+}
+
+.annotationLayer .popup * {
+    font-size: calc(9px * var(--scale-factor));
+}
+
+.annotationLayer .popup > .header {
+    display: inline-block;
+}
+
+.annotationLayer .popup > .header h1 {
+    display: inline;
+}
+
+.annotationLayer .popup > .header .popupDate {
+    display: inline-block;
+    margin-left: calc(5px * var(--scale-factor));
+    width: -moz-fit-content;
+    width: fit-content;
+}
+
+.annotationLayer .popupContent {
+    border-top: 1px solid rgba(51, 51, 51, 1);
+    margin-top: calc(2px * var(--scale-factor));
+    padding-top: calc(2px * var(--scale-factor));
+}
+
+.annotationLayer .richText > * {
+    white-space: pre-wrap;
+    font-size: calc(9px * var(--scale-factor));
+}
+
+.annotationLayer .popupTriggerArea {
+    cursor: pointer;
+}
+
+.annotationLayer section svg {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    top: 0;
+    left: 0;
+}
+
+.annotationLayer .annotationTextContent {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    opacity: 0;
+    color: transparent !important;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    user-select: none;
+    pointer-events: none;
+}
+
+.annotationLayer .annotationTextContent span {
+    width: 100%;
+    display: inline-block;
+}
+
+.annotationLayer svg.quadrilateralsContainer {
+    contain: strict;
+    width: 0;
+    height: 0;
+    position: absolute;
+    top: 0;
+    left: 0;
+    z-index: -1;
+}
+
+/* print.js https://github.com/crabbly/Print.js/releases/tag/v1.5.0 */
+.printModal {
+    font-family: sans-serif;
+    display: flex;
+    text-align: center;
+    font-weight: 300;
+    font-size: 30px;
+    left: 0;
+    top: 0;
+    position: absolute;
+    color: #045fb4;
+    width: 100%;
+    height: 100%;
+    background-color: hsla(0, 0%, 100%, 0.9);
+}
+
+.printClose {
+    position: absolute;
+    right: 10px;
+    top: 10px;
+}
+
+.printClose:before {
+    content: '\00D7';
+    font-family:
+        Helvetica Neue,
+        sans-serif;
+    font-weight: 100;
+    line-height: 1px;
+    padding-top: 0.5em;
+    display: block;
+    font-size: 2em;
+    text-indent: 1px;
+    overflow: hidden;
+    height: 1.25em;
+    width: 1.25em;
+    text-align: center;
+    cursor: pointer;
+}
+
+.printSpinner {
+    margin-top: 3px;
+    margin-left: -40px;
+    position: absolute;
+    display: inline-block;
+    width: 25px;
+    height: 25px;
+    border: 2px solid #045fb4;
+    border-radius: 50%;
+    animation: spin 0.75s linear infinite;
+}
+
+.printSpinner:after,
+.printSpinner:before {
+    left: -2px;
+    top: -2px;
+    display: none;
+    position: absolute;
+    content: '';
+    width: inherit;
+    height: inherit;
+    border: inherit;
+    border-radius: inherit;
+}
+
+.printSpinner,
+.printSpinner:after,
+.printSpinner:before {
+    display: inline-block;
+    border-color: #045fb4 transparent transparent;
+    animation-duration: 1.2s;
+}
+
+.printSpinner:before {
+    transform: rotate(120deg);
+}
+
+.printSpinner:after {
+    transform: rotate(240deg);
+}
+
+@keyframes spin {
+    0% {
+        transform: rotate(0deg);
+    }
+
+    to {
+        transform: rotate(1turn);
+    }
+}

flipbook.scroll.js

@@ -0,0 +1,539 @@
+/*
+ * Real3D FlipBook [https://real3dflipbook.com]
+ * @author creativeinteractivemedia [https://codecanyon.net/user/creativeinteractivemedia/portfolio]
+ * @version 4.10
+ * @date 2025-05-15
+ */
+'use strict';
+var FLIPBOOK = FLIPBOOK || {};
+
+FLIPBOOK.BookScroll = function (el, wrapper, main, options) {
+    this.options = options;
+    this.main = main;
+    this.singlePage = options.singlePageMode;
+    if (this.singlePage) {
+        this.view = 1;
+    }
+    this.view = 1;
+
+    this.pageWidth = options.pageWidth;
+    this.pageHeight = options.pageHeight;
+    this.rightIndex = 0;
+
+    this.pageGap = 16;
+
+    this.slides = [];
+    this.pagesArr = [];
+    this.leftPage = 0;
+    this.rightPage = 0;
+    this.rotation = 0;
+
+    this.verticalScroller = el;
+
+    this.verticalScroller.style.width = this.pageWidth + 'px';
+
+    options.pageGap = this.pageGap;
+
+    for (let i = 0; i < options.numPages; i++) {
+        const page = new FLIPBOOK.PageScroll(this, wrapper, main, options, i);
+        this.verticalScroller.appendChild(page.wrapper);
+        page.initObserver();
+        this.pagesArr.push(page);
+    }
+
+    //make new div that has width equal to page width, height equal to page height * number of pages
+
+    this.prevPageEnabled = false;
+
+    this.setRightIndex(0);
+    this.currentSlide = 0;
+    this.flipping = false;
+
+    this.wrapper = wrapper;
+
+    this.verticalScroller.classList.remove('book');
+    this.verticalScroller.style.paddingTop = this.pageGap / 2 + 'px';
+    this.verticalScroller.style.paddingBottom = this.pageGap / 2 + 'px';
+    this.iscroll = new IScroll(this.wrapper, {
+        freeScroll: true,
+        mouseWheel: true,
+        scrollbars: true,
+        interactiveScrollbars: true,
+        zoom: true,
+        scrollX: true,
+        scrollY: true,
+        keepInCenterV: true,
+        keepInCenterH: true,
+        preventDefault: false,
+        zoomMin: 0.01,
+        zoomMax: 10,
+        mouseWheelTimeout: 100,
+        disablePointer: false,
+        disableTouch: false,
+        disableMouse: false,
+        momentum: true,
+    });
+
+    this.main.on('disableIScroll', () => {
+        this.disableIscroll();
+    });
+    this.main.on('enableIScroll', () => {
+        this.enableIscroll();
+    });
+
+    var self = this;
+
+    this.iscroll.on('scrollStart', function () {
+        self.scrolling = true;
+    });
+
+    this.iscroll.on('zoomEnd', function () {
+        self.updateRightIndex();
+    });
+
+    this.iscroll.on('scrollEnd', function () {
+        self.updateRightIndex();
+        self.scrolling = false;
+        self.pagesArr.forEach((page) => {
+            if (page.visibility > 0) {
+                page.load();
+            }
+        });
+    });
+
+    this.zoomDisabled = false;
+
+    main.on('pageLoaded', function (_) {});
+};
+
+FLIPBOOK.BookScroll.prototype = Object.create(FLIPBOOK.Book.prototype);
+
+FLIPBOOK.BookScroll.prototype.constructor = FLIPBOOK.BookScroll;
+
+FLIPBOOK.BookScroll.prototype.enableIscroll = function () {
+    if (this.iscrollDisabled) {
+        this.iscroll.enable();
+        this.iscrollDisabled = false;
+    }
+};
+
+FLIPBOOK.BookScroll.prototype.disableIscroll = function () {
+    if (!this.iscrollDisabled) {
+        this.iscroll.disable();
+        this.iscroll.initiated = false;
+        this.iscrollDisabled = true;
+    }
+};
+
+FLIPBOOK.BookScroll.prototype.goToPage = function (value, instant) {
+    if (!this.enabled) {
+        return;
+    }
+
+    if (value > this.options.pages.length) {
+        value = this.options.pages.length;
+    }
+
+    if (this.singlePage || value % 2 != 0) {
+        value--;
+    }
+
+    if (value == this.rightIndex) {
+        return;
+    }
+
+    this.enableIscroll();
+
+    if (isNaN(value) || value < 0) {
+        value = 0;
+    }
+
+    let y = -value * (this.pageHeight + this.pageGap) * this.iscroll.scale;
+
+    let maxY = -(this.iscroll.scrollerHeight - this.main.wrapperH);
+
+    y = Math.max(y, maxY);
+
+    var duration = instant ? 0 : 600;
+
+    this.iscroll.scrollTo(0, y, duration);
+
+    this.setRightIndex(value);
+    this.main.turnPageComplete();
+};
+
+FLIPBOOK.BookScroll.prototype.setRightIndex = function (value) {
+    if (value != this.rightIndex) {
+        this.rightIndex = value;
+        this.main.turnPageComplete();
+    }
+};
+
+FLIPBOOK.BookScroll.prototype.nextPage = function (instant) {
+    this.goToPage(this.rightIndex + 2, instant);
+};
+
+FLIPBOOK.BookScroll.prototype.prevPage = function (instant) {
+    this.goToPage(this.rightIndex, instant);
+};
+
+FLIPBOOK.BookScroll.prototype.enablePrev = function (val) {
+    this.prevEnabled = val;
+};
+
+FLIPBOOK.BookScroll.prototype.enableNext = function (val) {
+    this.nextEnabled = val;
+};
+
+FLIPBOOK.BookScroll.prototype.isFocusedRight = function () {
+    return this.rightIndex % 2 == 0;
+};
+
+FLIPBOOK.BookScroll.prototype.isFocusedLeft = function () {
+    return this.rightIndex % 2 == 1;
+};
+
+FLIPBOOK.BookScroll.prototype.updateVisiblePages = function () {};
+
+FLIPBOOK.BookScroll.prototype.disable = function () {
+    this.enabled = false;
+};
+
+FLIPBOOK.BookScroll.prototype.enable = function () {
+    this.enabled = true;
+    this.onResize();
+};
+
+FLIPBOOK.BookScroll.prototype.resize = function () {};
+
+FLIPBOOK.BookScroll.prototype.onResize = function () {
+    var w = this.main.wrapperW;
+    var h = this.main.wrapperH;
+
+    if (w == 0 || h == 0 || (this.w === w && this.h === h)) {
+        return;
+    }
+
+    this.w = w;
+    this.h = h;
+
+    if (this.zoom) {
+        this.iscroll.refresh();
+        this.fit();
+        this.iscroll.scrollTo(0, this.iscroll.y, 0);
+    }
+    this.updateRightIndex();
+};
+
+FLIPBOOK.BookScroll.prototype.updateRightIndex = function () {
+    let maxVisibility = 0;
+    let currentIndex = 0;
+    this.pagesArr.forEach((page) => {
+        if (page.visibility > maxVisibility) {
+            maxVisibility = page.visibility;
+            currentIndex = page.index;
+        }
+    });
+    this.setRightIndex(currentIndex);
+};
+
+FLIPBOOK.BookScroll.prototype.zoomIn = function (value, time, e) {
+    if (e && e.type === 'mousewheel') {
+        return;
+    }
+    this.zoomTo(value);
+};
+
+FLIPBOOK.BookScroll.prototype.fitToHeight = function () {
+    this.iscroll.zoom((this.zoom * this.main.wrapperH) / this.pageHeight, 0, 0, 0);
+};
+
+FLIPBOOK.BookScroll.prototype.fitToWidth = function () {
+    this.iscroll.zoom((this.zoom * this.main.wrapperW) / this.pageWidth, 0, 0, 0);
+};
+
+FLIPBOOK.BookScroll.prototype.fit = function () {
+    if (this.options.fitToWidth) {
+        this.fitToWidth();
+    } else if (this.main.wrapperW / this.main.wrapperH < this.pageWidth / this.pageHeight) {
+        this.fitToWidth();
+    } else {
+        this.fitToHeight();
+    }
+};
+
+FLIPBOOK.BookScroll.prototype.zoomTo = function (zoom, time, x, y) {
+    if (!this.enabled || this.zoomDisabled) {
+        return;
+    }
+    var m = this.main;
+    var w = m.wrapperW;
+    var h = m.wrapperH;
+
+    if (w == 0 || h == 0) {
+        return;
+    }
+
+    this.zoom = zoom;
+    this.fit();
+
+    if (zoom > 1) {
+        this.disableFlip();
+    }
+
+    this.onZoom(zoom);
+};
+
+FLIPBOOK.BookScroll.prototype.zoomOut = function (value) {
+    this.zoomTo(value);
+};
+
+FLIPBOOK.BookScroll.prototype.onZoom = function (zoom) {
+    this.options.main.onZoom(zoom);
+};
+
+FLIPBOOK.BookScroll.prototype.enable = function () {
+    this.enabled = true;
+};
+
+FLIPBOOK.BookScroll.prototype.disable = function () {
+    this.enabled = false;
+};
+
+FLIPBOOK.BookScroll.prototype.onSwipe = function (event, phase, direction) {
+    if (phase == 'start') {
+        return;
+    }
+    if (phase == 'end' || phase == 'cancel') {
+        return;
+    }
+    if (direction == 'up' || direction == 'down') {
+        return;
+    }
+};
+
+FLIPBOOK.BookScroll.prototype.disableFlip = function () {};
+
+FLIPBOOK.BookScroll.prototype.enableFlip = function () {};
+
+FLIPBOOK.BookScroll.prototype.enablePan = function () {};
+
+FLIPBOOK.BookScroll.prototype.disablePan = function () {};
+
+FLIPBOOK.BookScroll.prototype.canFlipNext = function () {
+    return this.rightIndex + 1 < this.options.numPages;
+};
+
+FLIPBOOK.PageScroll = function (book, bookWrapper, main, options, index, texture, html) {
+    this.rotation = 0;
+    this.bookWrapper = bookWrapper;
+    this.index = index;
+    this.options = options;
+    this.texture = texture;
+    this.html = html;
+    this.index = index;
+    this.wrapper = document.createElement('div');
+    this.wrapper.className = 'flipbook-scroll-page';
+    this.wrapper.style.marginBottom = this.options.pageGap + 'px';
+    this.main = main;
+    this.book = book;
+
+    this.inner = document.createElement('div');
+    this.inner.className = 'flipbook-scroll-page-inner';
+    this.wrapper.appendChild(this.inner);
+
+    this.bg = document.createElement('div');
+    this.bg.className = 'flipbook-scroll-page-bg';
+    this.inner.appendChild(this.bg);
+
+    this.html = document.createElement('div');
+    this.html.className = 'flipbook-page3-html';
+    this.wrapper.appendChild(this.html);
+    this.html.style.width = (1000 * this.options.pageWidth) / this.options.pageHeight + 'px';
+    this.html.style.transform = 'scale(' + this.options.pageHeight / 1000 + ') translateZ(0)';
+
+    if (this.options.doublePage) {
+        if (this.index % 2 == 0 && this.index > 0) {
+            this.html.style.left = '-100%';
+        } else {
+            this.html.style.left = '0';
+        }
+    }
+
+    this.preloader = document.createElement('img');
+
+    if (options.pagePreloader) {
+        this.preloader.src = options.pagePreloader;
+        this.preloader.className = 'flipbook-page-preloader-image';
+    } else {
+        this.preloader.src = options.assets.spinner;
+        this.preloader.className = 'flipbook-page-preloader';
+    }
+
+    this.inner.appendChild(this.preloader);
+
+    this.setSize(this.pw, this.ph);
+};
+
+FLIPBOOK.PageScroll.prototype = {
+    initObserver: function () {
+        const observer = new IntersectionObserver(
+            (entries) => {
+                const entry = entries[0];
+                const visibility = entry.intersectionRatio;
+
+                if (visibility > 0) {
+                    this.show(visibility);
+                } else {
+                    this.hide();
+                }
+            },
+            { root: this.bookWrapper, threshold: [0, 0.1, 0.5] }
+        );
+        observer.observe(this.wrapper);
+    },
+
+    show: function (visibility) {
+        this.visibility = visibility;
+        if (!this.book.scrolling) {
+            this.load();
+        }
+        if (!this.isVisible) {
+            this.bg.style.display = 'block';
+            this.html.style.display = 'block';
+            this.isVisible = true;
+        }
+    },
+
+    load: function (callback, thumb) {
+        if (this.loaded) {
+            return;
+        }
+        if (this.visibility == 0) {
+            return;
+        }
+        this.loaded = true;
+        var size = this.options.pageTextureSize;
+
+        if (this.size >= size) {
+            if (!thumb) {
+                this.loadHTML();
+            }
+            if (callback) {
+                callback.call(this);
+            }
+            return;
+        }
+
+        this.size = size;
+
+        var self = this;
+
+        var index = this.options.rightToLeft ? this.options.numPages - this.index - 1 : this.index;
+
+        this.options.main.loadPage(index, size, function (page) {
+            page = page || {};
+
+            if (page && page.image) {
+                var img = page.image[size] || page.image;
+                img.classList.add('page-scroll-img');
+
+                if (
+                    self.index % 2 == 0 &&
+                    (self.options.pages[index].side == 'left' || self.options.pages[index].side == 'right')
+                ) {
+                    if (!img.clone) {
+                        img.clone = new Image();
+                        img.clone.src = img.src;
+                    }
+                    img = img.clone;
+                }
+
+                self.bg.appendChild(img);
+
+                if (self.options.doublePage && self.index > 0 && self.index % 2 == 0) {
+                    img.style.left = '-100%';
+                }
+
+                if (self.options.doublePage) {
+                    if (self.index == 0 || (self.index == self.options.pages.length - 1 && self.options.backCover)) {
+                        img.style.width = '100%';
+                    } else {
+                        img.style.width = '200%';
+                    }
+                } else {
+                    img.style.width = '100%';
+                }
+
+                self.inner.removeChild(self.preloader);
+            }
+
+            if (!thumb) {
+                self.loadHTML();
+            }
+
+            if (callback) {
+                callback.call(self);
+            }
+        });
+    },
+
+    hide: function () {
+        this.visibility = 0;
+        if (this.isVisible) {
+            this.bg.style.display = 'none';
+            this.html.style.display = 'none';
+            this.isVisible = false;
+            this.pauseHTML();
+        }
+    },
+
+    pauseHTML: function () {
+        var mediaElements = this.html.querySelectorAll('video, audio');
+        mediaElements.forEach(function (media) {
+            media.pause();
+        });
+    },
+
+    loadHTML: function () {
+        var self = this;
+
+        var index = this.options.rightToLeft ? this.options.numPages - this.index - 1 : this.index;
+
+        if (this.htmlContent) {
+            this.updateHtmlContent();
+        } else {
+            this.options.main.loadPageHTML(index, function (html) {
+                self.htmlContent = html;
+                self.updateHtmlContent();
+            });
+        }
+    },
+
+    setSize: function () {
+        this.wrapper.style.width = this.options.pageWidth + 'px';
+        this.wrapper.style.height = this.options.pageHeight + 'px';
+        this.updateHtmlContent();
+    },
+
+    updateHtmlContent: function () {
+        var c = this.htmlContent;
+
+        if (c && !this.htmlContentVisible) {
+            if (c.jquery) {
+                c = c[0];
+            }
+            this.htmlContentVisible = true;
+
+            this.html.replaceChildren();
+            this.html.appendChild(c);
+            this.startHTML();
+            this.main.trigger('showpagehtml', { page: this });
+        }
+        this.startHTML();
+    },
+
+    startHTML: function () {
+        this.book.startPageItems(this.wrapper);
+    },
+};

flipbook.swipe.js

@@ -0,0 +1,1294 @@
+/*
+ * Real3D FlipBook [https://real3dflipbook.com]
+ * @author creativeinteractivemedia [https://codecanyon.net/user/creativeinteractivemedia/portfolio]
+ * @version 4.10
+ * @date 2025-05-15
+ */
+'use strict';
+var FLIPBOOK = FLIPBOOK || {};
+
+FLIPBOOK.BookSwipe = function (el, wrapper, main, options) {
+    this.options = options;
+    this.main = main;
+    this.singlePage = options.singlePageMode;
+    if (this.singlePage) {
+        this.view = 1;
+    }
+    this.pageWidth = this.options.pageWidth;
+    this.pageHeight = this.options.pageHeight;
+    this.slides = [];
+    this.pagesArr = [];
+    this.leftPage = 0;
+    this.rightPage = 0;
+    this.rotation = 0;
+
+    this.prevPageEnabled = false;
+
+    this.setRightIndex(options.rightToLeft ? options.pages.length : 0);
+    this.currentSlide = 0;
+    this.flipping = false;
+
+    this.wrapper = wrapper;
+
+    this.scroller = el;
+    this.scroller.classList.remove('book');
+    this.scroller.classList.add('flipbook-carousel-scroller');
+
+    this.iscroll = new IScroll(this.wrapper, {
+        snap: true,
+        snapSpeed: 200 * this.options.pageFlipDuration,
+        freeScroll: true,
+        scrollX: true,
+        scrollY: false,
+        preventDefault: false,
+        eventPassthrough: 'vertical',
+    });
+
+    var self = this;
+
+    this.zoomDisabled = false;
+
+    this.iscroll.on('scrollStart', function () {
+        self.zoomDisabled = true;
+    });
+
+    this.iscroll.on('scrollEnd', function () {
+        self.zoomDisabled = false;
+    });
+
+    for (var i = 0; i < 3; i++) {
+        var slide = document.createElement('div');
+        slide.className = 'flipbook-carousel-slide';
+
+        var slideInner = document.createElement('div');
+        slideInner.className = 'slide-inner';
+
+        slide.appendChild(slideInner);
+        this.scroller.appendChild(slide);
+
+        this.slides.push(slide);
+    }
+
+    this.slides[0].iscroll = new IScroll(this.slides[0], {
+        zoom: true,
+        scrollX: true,
+        scrollY: true,
+        freeScroll: true,
+        keepInCenterV: true,
+        keepInCenterH: true,
+        preventDefault: false,
+    });
+
+    this.slides[2].iscroll = new IScroll(this.slides[2], {
+        zoom: true,
+        scrollX: true,
+        scrollY: true,
+        freeScroll: true,
+        keepInCenterV: true,
+        keepInCenterH: true,
+        preventDefault: false,
+    });
+
+    this.slides[1].iscroll = new IScroll(this.slides[1], {
+        zoom: true,
+        scrollX: true,
+        scrollY: true,
+        freeScroll: true,
+        keepInCenterV: true,
+        keepInCenterH: true,
+        preventDefault: false,
+    });
+
+    // eslint-disable-next-line no-redeclare
+    for (var i = 0; i < 3; i++) {
+        this.slides[i].iscroll.on('zoomEnd', function () {
+            var scale = options.main.zoom;
+            this.options.eventPassthrough = scale > 1 ? '' : 'vertical';
+            this.options.freeScroll = scale > 1;
+            this.refresh();
+        });
+    }
+
+    this.resizeInnerSlides();
+
+    var page;
+
+    options.pages.forEach((page, index) => {
+        if (!page.empty) {
+            const newPage = new FLIPBOOK.PageSwipe(this, index, page.src, page.htmlContent);
+            this.pagesArr.push(newPage);
+            if (options.loadAllPages) {
+                newPage.load();
+            }
+        }
+    });
+
+    if (!options.cover) {
+        page = new FLIPBOOK.PageSwipe(this, options.numPages);
+        this.pagesArr.push(page);
+    }
+
+    this.iscroll.on('scrollStart', function () {
+        if (this.distX < 0) {
+            self.loadNextSpread();
+        } else {
+            self.loadPrevSpread();
+        }
+    });
+
+    this.iscroll.on('scrollEnd', function () {
+        var sliderPage = this.currentPage.pageX;
+
+        if (self.currentSlide == sliderPage) {
+            return;
+        }
+
+        if (self.singlePage) {
+            if (sliderPage > self.currentSlide) {
+                self.setRightIndex(self.rightIndex + 1);
+            } else if (sliderPage < self.currentSlide) {
+                self.setRightIndex(self.rightIndex - 1);
+            }
+        } else {
+            if (sliderPage > self.currentSlide) {
+                self.setRightIndex(self.rightIndex + 2);
+            } else if (sliderPage < self.currentSlide) {
+                self.setRightIndex(self.rightIndex - 2);
+            }
+        }
+
+        self.currentSlide = sliderPage;
+
+        self.updateVisiblePages();
+
+        self.flipping = false;
+    });
+
+    this.flipEnabled = true;
+    this.nextEnabled = true;
+    this.prevEnabled = true;
+
+    main.on('enableIScroll', () => {
+        this.enableIscroll();
+    });
+
+    main.on('disableIScroll', () => {
+        this.disableIscroll();
+    });
+
+    main.on('pageLoaded', function (_) {});
+};
+
+FLIPBOOK.BookSwipe.prototype = Object.create(FLIPBOOK.Book.prototype);
+
+FLIPBOOK.BookSwipe.prototype.constructor = FLIPBOOK.BookSwipe;
+
+FLIPBOOK.BookSwipe.prototype.enableIscroll = function () {
+    if (this.iscrollDisabled) {
+        if (this.zoom > 1) {
+            if (this.slides[0].iscroll) {
+                this.slides[0].iscroll.enable();
+            }
+            if (this.slides[1].iscroll) {
+                this.slides[1].iscroll.enable();
+            }
+            if (this.slides[2].iscroll) {
+                this.slides[2].iscroll.enable();
+            }
+        } else {
+            this.iscroll.enable();
+        }
+
+        this.iscrollDisabled = false;
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.disableIscroll = function () {
+    if (!this.iscrollDisabled) {
+        if (this.zoom > 1) {
+            if (this.slides[0].iscroll) {
+                this.slides[0].iscroll.disable();
+                this.slides[0].iscroll.initiated = false;
+            }
+            if (this.slides[1].iscroll) {
+                this.slides[1].iscroll.disable();
+                this.slides[1].iscroll.initiated = false;
+            }
+            if (this.slides[2].iscroll) {
+                this.slides[2].iscroll.disable();
+                this.slides[2].iscroll.initiated = false;
+            }
+        } else {
+            this.iscroll.disable();
+            this.iscroll.initiated = false;
+        }
+
+        this.iscrollDisabled = true;
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.goToPage = function (value, instant) {
+    if (!this.enabled) {
+        return;
+    }
+
+    if (!this.flipEnabled) {
+        return;
+    }
+
+    if (value > this.options.pages.length) {
+        value = this.options.pages.length;
+    }
+
+    if (this.singlePage || value % 2 != 0) {
+        value--;
+    }
+
+    if (isNaN(value) || value < 0) {
+        value = 0;
+    }
+
+    if (instant) {
+        this.setRightIndex(value);
+        this.updateVisiblePages();
+        return;
+    }
+
+    if (this.singlePage) {
+        if (value > this.rightIndex) {
+            this.setSlidePages(this.currentSlide + 1, [value]);
+            this.setRightIndex(value - 1);
+            this.nextPage(instant);
+        } else if (value < this.rightIndex) {
+            this.setSlidePages(this.currentSlide - 1, [value]);
+            this.setRightIndex(value + 1);
+            this.prevPage(instant);
+        }
+    } else {
+        if (this.options.rightToLeft && !this.options.backCover && value < 2) {
+            value = 2;
+        }
+
+        if (value > this.rightIndex) {
+            if (value >= this.pagesArr.length) {
+                this.setSlidePages(2, [value - 1, value]);
+                this.setRightIndex(value - 2);
+                this.goToSlide(2, instant);
+            } else {
+                this.setSlidePages(this.currentSlide + 1, [value - 1, value]);
+                this.setRightIndex(value - 2);
+                this.nextPage(instant);
+            }
+        } else if (value < this.rightIndex) {
+            if (value == 0) {
+                this.setRightIndex(value + 2);
+                this.setSlidePages(0, [value]);
+                this.goToSlide(0, instant);
+            } else {
+                this.setRightIndex(value + 2);
+                this.setSlidePages(this.currentSlide - 1, [value - 1, value]);
+                this.prevPage(instant);
+            }
+        }
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.setRightIndex = function (value) {
+    this.rightIndex = value;
+};
+
+FLIPBOOK.BookSwipe.prototype.nextPage = function (instant) {
+    if (this.currentSlide == 2) {
+        return;
+    }
+
+    this.flipping = true;
+
+    this.goToSlide(this.currentSlide + 1, instant);
+
+    this.loadNextSpread();
+};
+
+FLIPBOOK.BookSwipe.prototype.prevPage = function (instant) {
+    if (this.currentSlide == 0) {
+        return;
+    }
+
+    this.flipping = true;
+
+    this.goToSlide(this.currentSlide - 1, instant);
+
+    this.loadPrevSpread();
+};
+
+FLIPBOOK.BookSwipe.prototype.enablePrev = function (val) {
+    this.prevEnabled = val;
+};
+
+FLIPBOOK.BookSwipe.prototype.enableNext = function (val) {
+    this.nextEnabled = val;
+};
+
+FLIPBOOK.BookSwipe.prototype.setSlidePages = function (slide, pages) {
+    var self = this;
+    var arr = [];
+    for (var i = 0; i < pages.length; i++) {
+        if (pages[i]) {
+            arr.push(pages[i].index);
+        }
+    }
+
+    if (this.slides[slide].pages && this.slides[slide].pages.length > 0) {
+        if (arr.join('') === this.slides[slide].pages.join('')) {
+            return;
+        }
+    }
+
+    this.clearSlidePages(slide);
+
+    var slideInner = this.slides[slide].firstChild;
+
+    pages.forEach((page) => {
+        let pageIndex;
+
+        if (typeof page === 'number') {
+            pageIndex = page;
+        } else {
+            pageIndex = page.index;
+        }
+
+        if (self.pagesArr[pageIndex]) {
+            slideInner.appendChild(self.pagesArr[pageIndex].wrapper);
+            self.slides[slide].pages.push(pageIndex);
+        }
+    });
+
+    this.resizeInnerSlides();
+
+    if (this.slides[slide].iscroll) {
+        this.slides[slide].iscroll.refresh();
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.clearSlidePages = function (slide) {
+    this.slides[slide].firstChild.innerHTML = '';
+    this.slides[slide].pages = [];
+};
+
+FLIPBOOK.BookSwipe.prototype.loadNextSpread = function () {
+    var index = this.rightIndex;
+
+    if (this.options.rightToLeft && !this.options.backCover) {
+        index--;
+    }
+
+    var next = this.pagesArr[index + 1];
+    if (next) {
+        next.load();
+    }
+    if (!this.singlePage) {
+        var afterNext = this.pagesArr[index + 2];
+        if (afterNext) {
+            afterNext.load();
+        }
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.loadPrevSpread = function () {
+    var index = this.rightIndex;
+    var prev;
+
+    if (this.options.rightToLeft && !this.options.backCover) {
+        index--;
+    }
+
+    if (this.singlePage) {
+        prev = this.pagesArr[index - 1];
+        if (prev) {
+            prev.load();
+        }
+    } else {
+        prev = this.pagesArr[index - 2];
+        if (prev) {
+            prev.load();
+        }
+        var beforePrev = this.pagesArr[index - 3];
+        if (beforePrev) {
+            beforePrev.load();
+        }
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.loadVisiblePages = function () {
+    var main = this.options.main;
+    var index = this.rightIndex;
+
+    if (this.options.rightToLeft && !this.options.backCover && !this.singlePage) {
+        index--;
+    }
+
+    var right = this.pagesArr[index];
+    var left = this.pagesArr[index - 1];
+    var next = this.pagesArr[index + 1];
+    var afterNext = this.pagesArr[index + 2];
+    var prev = this.pagesArr[index - 2];
+    var beforePrev = this.pagesArr[index - 3];
+
+    if (this.singlePage) {
+        if (right) {
+            right.load(function () {
+                main.setLoadingProgress(1);
+                if (left) {
+                    left.load(null, true);
+                }
+                if (next) {
+                    next.load(null, true);
+                }
+            });
+        } else if (left) {
+            left.load();
+        }
+    } else {
+        if (left) {
+            left.load(function () {
+                if (right) {
+                    right.load(function () {
+                        main.setLoadingProgress(1);
+                        if (prev) {
+                            prev.load(null, true);
+                        }
+                        if (beforePrev) {
+                            beforePrev.load(null, true);
+                        }
+                        if (next) {
+                            next.load(null, true);
+                        }
+                        if (afterNext) {
+                            afterNext.load(null, true);
+                        }
+                    });
+                } else {
+                    main.setLoadingProgress(1);
+                    if (prev) {
+                        prev.load(null, true);
+                    }
+
+                    if (beforePrev) {
+                        beforePrev.load(null, true);
+                    }
+                }
+            });
+        } else {
+            if (right) {
+                right.load(function () {
+                    main.setLoadingProgress(1);
+                    if (next) {
+                        next.load(null, true);
+                    }
+                    if (afterNext) {
+                        afterNext.load(null, true);
+                    }
+                });
+            }
+        }
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.updateVisiblePages = function () {
+    if (this.visiblePagesRightIndex === this.rightIndex) {
+        return;
+    }
+
+    this.visiblePagesRightIndex = this.rightIndex;
+
+    var index = this.rightIndex;
+
+    if (this.options.rightToLeft && !this.options.backCover && !this.singlePage) {
+        index--;
+    }
+
+    var right = this.pagesArr[index];
+    var left = this.pagesArr[index - 1];
+    var next = this.pagesArr[index + 1];
+    var afterNext = this.pagesArr[index + 2];
+    var prev = this.pagesArr[index - 2];
+    var beforePrev = this.pagesArr[index - 3];
+
+    if (next) {
+        next.hideHTML();
+    }
+    if (afterNext) {
+        afterNext.hideHTML();
+    }
+    if (prev) {
+        prev.hideHTML();
+    }
+    if (beforePrev) {
+        beforePrev.hideHTML();
+    }
+
+    if (this.singlePage) {
+        if (right) {
+            right.startHTML();
+        }
+
+        if (!left) {
+            //cover
+            this.setSlidePages(0, [right]);
+
+            if (next) {
+                this.setSlidePages(1, [next]);
+            } else {
+                this.clearSlidePages(1);
+            }
+            this.goToSlide(0, true);
+
+            this.clearSlidePages(2);
+        } else {
+            if (next) {
+                this.setSlidePages(1, [right]);
+                if (left) {
+                    this.setSlidePages(0, [left]);
+                }
+                this.setSlidePages(2, [next]);
+                this.goToSlide(1, true);
+            } else {
+                if (right) {
+                    this.setSlidePages(2, [right]);
+                }
+                if (left) {
+                    this.setSlidePages(1, [left]);
+                }
+                this.goToSlide(2, true);
+
+                this.clearSlidePages(0);
+            }
+        }
+
+        if (left) {
+            left.hideHTML();
+        }
+    } else {
+        if (!left) {
+            if (right) {
+                right.startHTML();
+            }
+            //cover
+            this.setSlidePages(0, [right]);
+
+            if (afterNext) {
+                this.setSlidePages(1, [next, afterNext]);
+            } else {
+                this.setSlidePages(1, [next]);
+            }
+
+            this.goToSlide(0, true);
+
+            this.clearSlidePages(2);
+        } else {
+            left.startHTML();
+
+            if (right) {
+                right.startHTML();
+
+                //L R
+
+                if (!next) {
+                    this.setSlidePages(2, [left, right]);
+
+                    if (beforePrev) {
+                        this.setSlidePages(1, [beforePrev, prev]);
+                    } else {
+                        this.setSlidePages(1, [prev]);
+                    }
+
+                    this.goToSlide(2, true);
+
+                    this.clearSlidePages(0);
+                } else {
+                    if (prev && !(this.rightIndex == 2 && !this.options.cover)) {
+                        this.setSlidePages(1, [left, right]);
+
+                        if (beforePrev) {
+                            this.setSlidePages(0, [beforePrev, prev]);
+                        } else {
+                            this.setSlidePages(0, [prev]);
+                        }
+
+                        if (afterNext) {
+                            this.setSlidePages(2, [next, afterNext]);
+                        } else {
+                            this.setSlidePages(2, [next]);
+                        }
+
+                        this.goToSlide(1, true);
+                    } else {
+                        this.setSlidePages(0, [left, right]);
+
+                        if (afterNext) {
+                            this.setSlidePages(1, [next, afterNext]);
+                        } else {
+                            this.setSlidePages(1, [next]);
+                        }
+
+                        this.clearSlidePages(2);
+                    }
+                }
+            } else {
+                this.setSlidePages(2, [left]);
+
+                if (beforePrev) {
+                    this.setSlidePages(1, [beforePrev, prev]);
+                } else {
+                    this.setSlidePages(1, [prev]);
+                }
+
+                this.goToSlide(2, true);
+                this.clearSlidePages(0);
+            }
+        }
+    }
+
+    this.loadVisiblePages();
+
+    this.flippedleft = (this.rightIndex + (this.rightIndex % 2)) / 2;
+    this.flippedright = this.options.pages.length / 2 - this.flippedleft;
+
+    this.options.main.turnPageComplete();
+};
+
+FLIPBOOK.BookSwipe.prototype.loadPage = function (index) {
+    if (this.pagesArr[index]) {
+        this.pagesArr[index].load();
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.disable = function () {
+    this.enabled = false;
+};
+
+FLIPBOOK.BookSwipe.prototype.enable = function () {
+    this.enabled = true;
+    this.onResize();
+};
+
+FLIPBOOK.BookSwipe.prototype.resize = function () {};
+
+FLIPBOOK.BookSwipe.prototype.updateSinglePage = function (singlePage) {
+    this.singlePageView = singlePage;
+    this.onResize(true);
+};
+
+FLIPBOOK.BookSwipe.prototype.onResize = function (force) {
+    var w = this.main.wrapperW;
+    var h = this.main.wrapperH;
+
+    if (w == 0 || h == 0) {
+        return;
+    }
+
+    if (!force && this.w === w && this.h === h) {
+        return;
+    }
+
+    this.w = w;
+    this.h = h;
+
+    var pw = this.pageWidth;
+    var ph = this.pageHeight;
+
+    var portrait = (2 * this.options.zoomMin * pw) / ph > w / h;
+    var doublePage =
+        !this.options.singlePageMode &&
+        (!this.options.responsiveView ||
+            w > this.options.responsiveViewTreshold ||
+            !portrait ||
+            w / h >= this.options.responsiveViewRatio);
+
+    if (typeof this.singlePageView != 'undefined') {
+        doublePage = !this.singlePageView;
+    }
+
+    var bw = doublePage ? 2 * pw : pw;
+    var bh = ph;
+    this.bw = bw;
+    this.bh = bh;
+
+    var scale;
+    if (h / w > bh / bw) {
+        //fit to width
+        scale = ((bh / bw) * w) / this.options.pageHeight;
+    } else {
+        scale = h / this.options.pageHeight;
+    }
+
+    var spaceBetweenSlides = 0;
+
+    for (var i = 0; i < this.slides.length; i++) {
+        this.slides[i].style.width = w + spaceBetweenSlides + 'px';
+        this.slides[i].style.height = h + 'px';
+        this.slides[i].style.left = i * w + i * spaceBetweenSlides + 'px';
+
+        if (this.slides[i].iscroll) {
+            this.slides[i].iscroll.options.zoomMin = this.options.zoomMin * scale;
+            this.slides[i].iscroll.options.zoomMax = this.options.zoomMax * scale;
+            this.slides[i].iscroll.refresh();
+        }
+    }
+
+    this.scroller.style.width = this.slides.length * (w + spaceBetweenSlides) + 'px';
+    this.iscroll.refresh();
+
+    if ((!doublePage || this.options.singlePageMode) && !this.singlePage) {
+        if (this.rightIndex % 2 == 0 && this.rightIndex > 0) {
+            this.setRightIndex(this.rightIndex - 1);
+        }
+
+        this.singlePage = true;
+        this.view = 1;
+
+        this.resizeInnerSlides();
+    } else if (doublePage && !this.options.singlePageMode && this.singlePage) {
+        if (this.rightIndex % 2 != 0) {
+            this.setRightIndex(this.rightIndex + 1);
+        }
+
+        this.singlePage = false;
+        this.view = 2;
+
+        this.resizeInnerSlides();
+    }
+
+    this.zoomTo(this.zoom);
+
+    // this.updateVisiblePages();
+};
+
+FLIPBOOK.BookSwipe.prototype.isFocusedRight = function () {
+    return this.rightIndex % 2 == 0;
+};
+
+FLIPBOOK.BookSwipe.prototype.isFocusedLeft = function () {
+    return this.rightIndex % 2 == 1;
+};
+
+FLIPBOOK.BookSwipe.prototype.resizeInnerSlides = function () {
+    var pw = (this.options.pageHeight * this.pageWidth) / this.pageHeight;
+
+    if (this.rotation == 90 || this.rotation == 270) {
+        pw = (this.options.pageHeight * this.pageHeight) / this.pageWidth;
+    }
+
+    var sw = this.singlePage ? pw : 2 * pw;
+
+    for (var i = 0; i < 3; i++) {
+        sw = this.slides[i].pages && this.slides[i].pages.length == 1 ? pw : 2 * pw;
+        this.slides[i].firstChild.style.width = `${sw}px`;
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.goToSlide = function (slideIndex, instant) {
+    if (this.iscroll.currentPage.pageX == slideIndex) {
+        return;
+    }
+
+    this.onResize();
+
+    var time = instant ? 0 : 600 * this.options.pageFlipDuration;
+    var slide = this.slides[slideIndex];
+
+    if (slide.pages && slide.pages[0]) {
+        this.pagesArr[slide.pages[0]].updateHtmlContent();
+    }
+
+    if (this.iscroll.pages.length > 0) {
+        this.iscroll.goToPage(slideIndex, 0, time);
+    }
+
+    if (instant) {
+        this.currentSlide = slideIndex;
+    }
+
+    this.zoomTo(this.options.zoomMin);
+};
+
+FLIPBOOK.BookSwipe.prototype.zoomIn = function (value, time, e) {
+    if (e && e.type === 'mousewheel') {
+        return;
+    }
+    this.zoomTo(value);
+};
+
+FLIPBOOK.BookSwipe.prototype.zoomTo = function (zoom, time, x, y) {
+    if (!this.enabled || this.zoomDisabled) {
+        return;
+    }
+
+    x = x || 0;
+    y = y || 0;
+
+    if (zoom > 1) {
+        this.disableFlip();
+    }
+
+    if (w == 0 || h == 0) {
+        return;
+    }
+
+    var m = this.main;
+    var w = m.wrapperW;
+    var h = m.wrapperH;
+    var bw = m.bookW;
+    var bh = m.bookH;
+    var pw = m.pageW;
+    var ph = m.pageH;
+    var r1 = w / h;
+    var r2 = pw / ph;
+
+    var s = Math.min(this.zoom, 1);
+
+    var zoomMin = Number(this.options.zoomMin);
+
+    var self = this;
+
+    function fitToHeight() {
+        self.ratio = h / bh;
+        fit();
+    }
+
+    function fitToWidth() {
+        self.ratio = self.view == 1 ? w / pw : w / bw;
+        fit();
+    }
+
+    function fit() {
+        for (var i = 0; i < 3; i++) {
+            if (self.slides[i].iscroll) {
+                self.slides[i].iscroll.options.zoomMin = self.ratio * self.options.zoomMin;
+                self.slides[i].iscroll.options.zoomMax = self.ratio * self.options.zoomMax;
+                self.slides[i].iscroll.zoom(self.ratio * zoom, x, y, 0);
+            }
+        }
+    }
+
+    if (
+        !this.options.singlePageMode &&
+        this.options.responsiveView &&
+        w <= this.options.responsiveViewTreshold &&
+        r1 < 2 * r2 &&
+        r1 < this.options.responsiveViewRatio
+    ) {
+        this.view = 1;
+
+        if (r2 > r1) {
+            this.sc = (zoomMin * r1) / (r2 * s);
+        } else {
+            this.sc = 1;
+        }
+
+        if (w / h > pw / ph) {
+            fitToHeight();
+        } else {
+            fitToWidth();
+        }
+    } else if (this.singlePage && r1 < 2 * r2) {
+        if (r2 > r1) {
+            this.sc = (zoomMin * r1) / (r2 * s);
+        } else {
+            this.sc = 1;
+        }
+
+        if (w / h > pw / ph) {
+            fitToHeight();
+        } else {
+            fitToWidth();
+        }
+    } else {
+        this.view = 2;
+
+        if (r1 < 2 * r2) {
+            this.sc = (zoomMin * r1) / (2 * r2 * s);
+        } else {
+            this.sc = 1;
+        }
+
+        if (w / h >= bw / bh) {
+            fitToHeight();
+        } else {
+            fitToWidth();
+        }
+    }
+
+    this.zoom = zoom;
+
+    this.onZoom(zoom);
+};
+
+FLIPBOOK.BookSwipe.prototype.zoomOut = function (value) {
+    this.zoomTo(value);
+};
+
+FLIPBOOK.BookSwipe.prototype.move = function (direction) {
+    if (this.zoom <= 1) {
+        return;
+    }
+
+    for (var i = 0; i < 3; i++) {
+        var iscroll = this.slides[i].iscroll;
+        var offset2 = 0;
+
+        if (iscroll) {
+            var posX = iscroll.x;
+            var posY = iscroll.y;
+            var offset = 20 * this.zoom;
+            switch (direction) {
+                case 'left':
+                    posX += offset;
+                    break;
+                case 'right':
+                    posX -= offset;
+                    break;
+                case 'up':
+                    posY += offset;
+                    break;
+                case 'down':
+                    posY -= offset;
+                    break;
+            }
+
+            if (posX > 0) {
+                posX = offset2;
+            }
+            if (posX < iscroll.maxScrollX) {
+                posX = iscroll.maxScrollX - offset2;
+            }
+            if (posY > 0) {
+                posY = offset2;
+            }
+            if (posY < iscroll.maxScrollY) {
+                posY = iscroll.maxScrollY - offset2;
+            }
+
+            iscroll.scrollTo(posX, posY, 0);
+        }
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.onZoom = function (zoom) {
+    if (zoom > 1) {
+        this.disableFlip();
+        this.enablePan();
+    } else {
+        this.enableFlip();
+        this.disablePan();
+    }
+
+    this.options.main.onZoom(zoom);
+};
+
+FLIPBOOK.BookSwipe.prototype.rotateLeft = function () {
+    this.rotation = (this.rotation + 360 - 90) % 360;
+
+    for (var i = 0; i < this.pagesArr.length; i++) {
+        var page = this.pagesArr[i];
+        page.setRotation(this.rotation);
+    }
+
+    this.resizeInnerSlides();
+    this.onResize();
+};
+
+FLIPBOOK.BookSwipe.prototype.rotateRight = function () {
+    this.rotation = (this.rotation + 360 + 90) % 360;
+
+    for (var i = 0; i < this.pagesArr.length; i++) {
+        var page = this.pagesArr[i];
+        page.setRotation(this.rotation);
+    }
+
+    this.resizeInnerSlides();
+    this.onResize();
+};
+
+FLIPBOOK.BookSwipe.prototype.onSwipe = function (event, phase, distanceX, distanceY) {
+    if (phase == 'start') {
+        return;
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.onPageUnloaded = function (i) {
+    var index = this.options.rightToLeft ? this.options.numPages - i - 1 : i;
+
+    this.pagesArr[index].unload();
+};
+
+FLIPBOOK.BookSwipe.prototype.disableFlip = function () {
+    this.flipEnabled = false;
+    this.iscroll.disable();
+};
+
+FLIPBOOK.BookSwipe.prototype.enableFlip = function () {
+    if (this.options.numPages == 1) {
+        this.disableFlip();
+        return;
+    }
+
+    this.flipEnabled = true;
+    this.iscroll.enable();
+};
+
+FLIPBOOK.BookSwipe.prototype.enablePan = function () {
+    if (this.slides[0].iscroll) {
+        this.slides[0].iscroll.enable();
+    }
+    if (this.slides[1].iscroll) {
+        this.slides[1].iscroll.enable();
+    }
+    if (this.slides[2].iscroll) {
+        this.slides[2].iscroll.enable();
+    }
+};
+
+FLIPBOOK.BookSwipe.prototype.disablePan = function () {
+    if (this.slides[0].iscroll) {
+        this.slides[0].iscroll.disable();
+    }
+    if (this.slides[1].iscroll) {
+        this.slides[1].iscroll.disable();
+    }
+    if (this.slides[2].iscroll) {
+        this.slides[2].iscroll.disable();
+    }
+};
+
+FLIPBOOK.PageSwipe = function (book, index, texture, html) {
+    this.rotation = 0;
+    this.index = index;
+    this.options = book.options;
+    this.texture = texture;
+    this.html = html;
+    this.index = index;
+
+    this.wrapper = document.createElement('div');
+    this.wrapper.classList.add('flipbook-carousel-page');
+    this.wrapper.dataset.page = index + 1;
+    this.main = book.main;
+    this.book = book;
+
+    this.inner = document.createElement('div');
+    this.inner.classList.add('flipbook-carousel-page-inner');
+    this.wrapper.appendChild(this.inner);
+
+    this.bg = document.createElement('div');
+    this.bg.classList.add('flipbook-carousel-page-bg');
+    this.inner.appendChild(this.bg);
+
+    this.htmlElement = document.createElement('div');
+    this.htmlElement.classList.add('flipbook-page3-html');
+    this.htmlElement.style.width = (1000 * this.options.pageWidth) / this.options.pageHeight + 'px';
+    this.htmlElement.style.transform = 'scale(' + this.options.pageHeight / 1000 + ') translateZ(0)';
+    this.inner.appendChild(this.htmlElement);
+
+    if (this.options.doublePage) {
+        if (!this.options.rightToLeft && this.index % 2 === 0 && this.index > 0) {
+            this.htmlElement.style.left = '-100%';
+        } else if (this.options.rightToLeft && this.index % 2 === 1 && this.index > 0) {
+            this.htmlElement.style.left = '-100%';
+        } else {
+            this.htmlElement.style.left = '0';
+        }
+    }
+
+    if (this.options.pagePreloader) {
+        this.preloader = document.createElement('img');
+        this.preloader.src = this.options.pagePreloader;
+        this.preloader.classList.add('flipbook-page-preloader-image');
+        this.inner.appendChild(this.preloader);
+    } else {
+        this.preloader = document.createElement('img');
+        this.preloader.src = this.options.assets.spinner;
+        this.preloader.classList.add('flipbook-page-preloader');
+        this.inner.appendChild(this.preloader);
+    }
+
+    this.setSize(this.pw, this.ph);
+};
+
+FLIPBOOK.PageSwipe.prototype = {
+    load: function (callback, thumb) {
+        var size = this.options.pageTextureSize;
+
+        if (this.size >= size) {
+            if (!thumb) {
+                this.loadHTML();
+            }
+            if (callback) {
+                callback.call(this);
+            }
+            return;
+        }
+
+        this.size = size;
+
+        var self = this;
+
+        var index = this.options.rightToLeft ? this.options.numPages - this.index - 1 : this.index;
+        var o = this.options;
+        var p = o.pages[index];
+
+        this.options.main.loadPage(index, size, function (page) {
+            page = page || {};
+
+            if (page && page.image) {
+                var img = page.image[size] || page.image;
+                img.classList.add('page-carousel-img');
+
+                if (self.index % 2 == 0 && ((p && p.side == 'left') || (p && p.side == 'right'))) {
+                    if (!img.clone) {
+                        img.clone = new Image();
+                        img.clone.src = img.src;
+                    }
+                    img = img.clone;
+                }
+
+                self.bg.appendChild(img);
+
+                if (self.options.rightToLeft) {
+                    if (self.options.doublePage && self.index < self.options.numPages - 1 && self.index % 2 == 1) {
+                        img.style.left = '-100%';
+                    }
+
+                    if (self.options.doublePage) {
+                        if (self.index == self.options.numPages - 1 || (self.index == 0 && self.options.backCover)) {
+                            img.style.width = '100%';
+                        } else {
+                            img.style.width = '200%';
+                        }
+                    } else {
+                        img.style.width = '100%';
+                    }
+                } else {
+                    if (self.options.doublePage && self.index > 0 && self.index % 2 == 0) {
+                        img.style.left = '-100%';
+                    }
+
+                    if (self.options.doublePage) {
+                        if (self.index == 0 || (self.index == self.options.numPages - 1 && self.options.backCover)) {
+                            img.style.width = '100%';
+                        } else {
+                            img.style.width = '200%';
+                        }
+                    } else {
+                        img.style.width = '100%';
+                    }
+                }
+
+                self.preloader.remove();
+            }
+
+            self.setRotation();
+
+            if (!thumb) {
+                self.loadHTML();
+            }
+
+            if (callback) {
+                callback.call(self);
+            }
+        });
+    },
+
+    loadHTML: function () {
+        var self = this;
+
+        var index = !this.options.rightToLeft ? this.index : this.options.numPages - this.index - 1;
+
+        if (this.htmlContent) {
+            this.updateHtmlContent();
+        } else {
+            this.options.main.loadPageHTML(index, function (html) {
+                self.htmlContent = html;
+                self.updateHtmlContent();
+            });
+        }
+    },
+
+    hideHTML: function () {
+        if (this.htmlContentVisible) {
+            this.htmlElement.innerHTML = '';
+            this.htmlContentVisible = false;
+            this.main.trigger('hidepagehtml', { page: this });
+        }
+    },
+
+    startHTML: function () {
+        this.book.startPageItems(this.wrapper);
+    },
+
+    unload: function () {
+        this.pageSize = 0;
+        this.size = 0;
+        this.inner.appendChild(this.preloader);
+    },
+
+    dispose: function () {
+        if (this.pageSize) {
+            this.pageSize = null;
+            this.bg.innerHTML = '';
+        }
+    },
+
+    setSize: function () {
+        var w = this.options.pageWidth;
+        var h = this.options.pageHeight;
+
+        if (this.rotation === 0 || this.rotation === 180) {
+            this.wrapper.style.width = w + 'px';
+            this.wrapper.style.height = h + 'px';
+            this.pw = w;
+            this.ph = h;
+        } else {
+            this.wrapper.style.width = h + 'px';
+            this.wrapper.style.height = w + 'px';
+            this.pw = h;
+            this.ph = w;
+        }
+
+        this.updateHtmlContent();
+    },
+
+    setRotation: function (val) {
+        this.setSize();
+
+        if (this.options.doublePage) {
+            return;
+        }
+
+        if (typeof val != 'undefined') {
+            this.rotation = val;
+        }
+        if (this.img) {
+            this.img.style.transform = 'rotate(' + this.rotation + 'deg) translateZ(0)';
+            if (this.rotation === 90 || this.rotation === 270) {
+                this.img.style.width = this.wrapper.clientHeight + 'px';
+                this.img.style.height = this.wrapper.clientWidth + 'px';
+            } else {
+                this.img.style.width = this.wrapper.clientWidth + 'px';
+                this.img.style.height = this.wrapper.clientHeight + 'px';
+            }
+        }
+    },
+
+    updateHtmlContent: function () {
+        var c = this.htmlContent;
+
+        if (c && !this.htmlContentVisible) {
+            this.htmlContentVisible = true;
+
+            this.htmlElement.innerHTML = '';
+            this.htmlElement.appendChild(this.htmlContent);
+            this.main.trigger('showpagehtml', { page: this });
+        }
+        this.startHTML();
+    },
+};

iscroll.js

@@ -0,0 +1,2607 @@
+/*
+ * Real3D FlipBook [https://real3dflipbook.com]
+ * @author creativeinteractivemedia [https://codecanyon.net/user/creativeinteractivemedia/portfolio]
+ * @version 4.10
+ * @date 2025-05-15
+ */
+/*! iScroll v5.2.0-snapshot ~ (c) 2008-2017 Matteo Spinelli ~ http://cubiq.org/license */
+(function (window, document, Math) {
+    var rAF =
+        window.requestAnimationFrame ||
+        window.webkitRequestAnimationFrame ||
+        window.mozRequestAnimationFrame ||
+        window.oRequestAnimationFrame ||
+        window.msRequestAnimationFrame ||
+        function (callback) {
+            window.setTimeout(callback, 1000 / 60);
+        };
+
+    var utils = (function () {
+        var me = {};
+
+        var _elementStyle = document.createElement('div').style;
+        var _vendor = (function () {
+            var vendors = ['t', 'webkitT', 'MozT', 'msT', 'OT'];
+            var transform;
+            var i = 0;
+            var l = vendors.length;
+
+            for (; i < l; i++) {
+                transform = vendors[i] + 'ransform';
+                if (transform in _elementStyle) {
+                    return vendors[i].substr(0, vendors[i].length - 1);
+                }
+            }
+
+            return false;
+        })();
+
+        function _prefixStyle(style) {
+            if (_vendor === false) {
+                return false;
+            }
+            if (_vendor === '') {
+                return style;
+            }
+            return _vendor + style.charAt(0).toUpperCase() + style.substr(1);
+        }
+
+        me.getTime =
+            Date.now ||
+            function getTime() {
+                return new Date().getTime();
+            };
+
+        me.extend = function (target, obj) {
+            for (var i in obj) {
+                target[i] = obj[i];
+            }
+        };
+
+        me.addEvent = function (el, type, fn, capture) {
+            el.addEventListener(type, fn, !!capture);
+        };
+
+        me.removeEvent = function (el, type, fn, capture) {
+            el.removeEventListener(type, fn, !!capture);
+        };
+
+        me.prefixPointerEvent = function (pointerEvent) {
+            return window.MSPointerEvent
+                ? 'MSPointer' + pointerEvent.charAt(7).toUpperCase() + pointerEvent.substr(8)
+                : pointerEvent;
+        };
+
+        me.momentum = function (current, start, time, lowerMargin, wrapperSize, deceleration) {
+            var distance = current - start;
+            var speed = Math.abs(distance) / time;
+            var destination;
+            var duration;
+
+            deceleration = deceleration === undefined ? 0.0006 : deceleration;
+
+            destination = current + ((speed * speed) / (2 * deceleration)) * (distance < 0 ? -1 : 1);
+            duration = speed / deceleration;
+
+            if (destination < lowerMargin) {
+                destination = wrapperSize ? lowerMargin - (wrapperSize / 2.5) * (speed / 8) : lowerMargin;
+                distance = Math.abs(destination - current);
+                duration = distance / speed;
+            } else if (destination > 0) {
+                destination = wrapperSize ? (wrapperSize / 2.5) * (speed / 8) : 0;
+                distance = Math.abs(current) + destination;
+                duration = distance / speed;
+            }
+
+            return {
+                destination: Math.round(destination),
+                duration: duration,
+            };
+        };
+
+        var _transform = _prefixStyle('transform');
+
+        me.extend(me, {
+            hasTransform: _transform !== false,
+            hasPerspective: _prefixStyle('perspective') in _elementStyle,
+            hasTouch: 'ontouchstart' in window,
+            hasPointer: !!(window.PointerEvent || window.MSPointerEvent), // IE10 is prefixed
+            hasTransition: _prefixStyle('transition') in _elementStyle,
+        });
+
+        /*
+    This should find all Android browsers lower than build 535.19 (both stock browser and webview)
+    - galaxy S2 is ok
+      - 2.3.6 : `AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1`
+      - 4.0.4 : `AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30`
+     - galaxy S3 is badAndroid (stock brower, webview)
+       `AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30`
+     - galaxy S4 is badAndroid (stock brower, webview)
+       `AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30`
+     - galaxy S5 is OK
+       `AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Mobile Safari/537.36 (Chrome/)`
+     - galaxy S6 is OK
+       `AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Mobile Safari/537.36 (Chrome/)`
+    */
+        me.isBadAndroid = (function () {
+            var appVersion = window.navigator.appVersion;
+            // Android browser is not a chrome browser.
+            if (/Android/.test(appVersion) && !/Chrome\/\d/.test(appVersion)) {
+                var safariVersion = appVersion.match(/Safari\/(\d+.\d)/);
+                if (safariVersion && typeof safariVersion === 'object' && safariVersion.length >= 2) {
+                    return parseFloat(safariVersion[1]) < 535.19;
+                } else {
+                    return true;
+                }
+            } else {
+                return false;
+            }
+        })();
+
+        me.extend((me.style = {}), {
+            transform: _transform,
+            transitionTimingFunction: _prefixStyle('transitionTimingFunction'),
+            transitionDuration: _prefixStyle('transitionDuration'),
+            transitionDelay: _prefixStyle('transitionDelay'),
+            transformOrigin: _prefixStyle('transformOrigin'),
+            touchAction: _prefixStyle('touchAction'),
+        });
+
+        me.hasClass = function (e, c) {
+            var re = new RegExp('(^|\\s)' + c + '(\\s|$)');
+            return re.test(e.className);
+        };
+
+        me.addClass = function (e, c) {
+            if (me.hasClass(e, c)) {
+                return;
+            }
+
+            var newclass = e.className.split(' ');
+            newclass.push(c);
+            e.className = newclass.join(' ');
+        };
+
+        me.removeClass = function (e, c) {
+            if (!me.hasClass(e, c)) {
+                return;
+            }
+
+            var re = new RegExp('(^|\\s)' + c + '(\\s|$)', 'g');
+            e.className = e.className.replace(re, ' ');
+        };
+
+        me.offset = function (el) {
+            var left = -el.offsetLeft;
+            var top = -el.offsetTop;
+
+            // jshint -W084
+            while ((el = el.offsetParent)) {
+                left -= el.offsetLeft;
+                top -= el.offsetTop;
+            }
+            // jshint +W084
+
+            /*custom*/
+            return { left: 0, top: 0 };
+            /*end*/
+
+            return {
+                left: left,
+                top: top,
+            };
+        };
+
+        me.preventDefaultException = function (el, exceptions) {
+            for (var i in exceptions) {
+                if (exceptions[i].test(el[i])) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        me.extend((me.eventType = {}), {
+            touchstart: 1,
+            touchmove: 1,
+            touchend: 1,
+
+            mousedown: 2,
+            mousemove: 2,
+            mouseup: 2,
+
+            pointerdown: 3,
+            pointermove: 3,
+            pointerup: 3,
+
+            MSPointerDown: 3,
+            MSPointerMove: 3,
+            MSPointerUp: 3,
+        });
+
+        me.extend((me.ease = {}), {
+            quadratic: {
+                style: 'cubic-bezier(0.25, 0.46, 0.45, 0.94)',
+                fn: function (k) {
+                    return k * (2 - k);
+                },
+            },
+            circular: {
+                style: 'cubic-bezier(0.1, 0.57, 0.1, 1)', // Not properly "circular" but this looks better, it should be (0.075, 0.82, 0.165, 1)
+                fn: function (k) {
+                    return Math.sqrt(1 - --k * k);
+                },
+            },
+            back: {
+                style: 'cubic-bezier(0.175, 0.885, 0.32, 1.275)',
+                fn: function (k) {
+                    var b = 4;
+                    return (k = k - 1) * k * ((b + 1) * k + b) + 1;
+                },
+            },
+            bounce: {
+                style: '',
+                fn: function (k) {
+                    if ((k /= 1) < 1 / 2.75) {
+                        return 7.5625 * k * k;
+                    } else if (k < 2 / 2.75) {
+                        return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75;
+                    } else if (k < 2.5 / 2.75) {
+                        return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375;
+                    } else {
+                        return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375;
+                    }
+                },
+            },
+            elastic: {
+                style: '',
+                fn: function (k) {
+                    var f = 0.22;
+                    var e = 0.4;
+
+                    if (k === 0) {
+                        return 0;
+                    }
+                    if (k == 1) {
+                        return 1;
+                    }
+
+                    return e * Math.pow(2, -10 * k) * Math.sin(((k - f / 4) * (2 * Math.PI)) / f) + 1;
+                },
+            },
+        });
+
+        me.tap = function (e, eventName) {
+            var ev = document.createEvent('Event');
+            ev.initEvent(eventName, true, true);
+            ev.pageX = e.pageX;
+            ev.pageY = e.pageY;
+            e.target.dispatchEvent(ev);
+        };
+
+        me.click = function (e) {
+            var target = e.target;
+            var ev;
+
+            if (!/(SELECT|INPUT|TEXTAREA)/i.test(target.tagName)) {
+                // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/initMouseEvent
+                // initMouseEvent is deprecated.
+                ev = document.createEvent(window.MouseEvent ? 'MouseEvents' : 'Event');
+                ev.initEvent('click', true, true);
+                ev.view = e.view || window;
+                ev.detail = 1;
+                ev.screenX = target.screenX || 0;
+                ev.screenY = target.screenY || 0;
+                ev.clientX = target.clientX || 0;
+                ev.clientY = target.clientY || 0;
+                ev.ctrlKey = !!e.ctrlKey;
+                ev.altKey = !!e.altKey;
+                ev.shiftKey = !!e.shiftKey;
+                ev.metaKey = !!e.metaKey;
+                ev.button = 0;
+                ev.relatedTarget = null;
+                ev._constructed = true;
+                target.dispatchEvent(ev);
+            }
+        };
+
+        me.getTouchAction = function (eventPassthrough, addPinch) {
+            var touchAction = 'none';
+            if (eventPassthrough === 'vertical') {
+                touchAction = 'pan-y';
+            } else if (eventPassthrough === 'horizontal') {
+                touchAction = 'pan-x';
+            }
+            if (addPinch && touchAction != 'none') {
+                // add pinch-zoom support if the browser supports it, but if not (eg. Chrome <55) do nothing
+                touchAction += ' pinch-zoom';
+            }
+            return touchAction;
+        };
+
+        me.getRect = function (el) {
+            if (el instanceof SVGElement) {
+                var rect = el.getBoundingClientRect();
+                return {
+                    top: rect.top,
+                    left: rect.left,
+                    width: rect.width,
+                    height: rect.height,
+                };
+            } else {
+                return {
+                    top: el.offsetTop,
+                    left: el.offsetLeft,
+                    width: el.offsetWidth,
+                    height: el.offsetHeight,
+                };
+            }
+        };
+
+        return me;
+    })();
+    function IScroll(el, options) {
+        this.wrapper = typeof el == 'string' ? document.querySelector(el) : el;
+        this.scroller = this.wrapper.children[0];
+        this.scrollerStyle = this.scroller.style; // cache style for better performance
+
+        this.options = {
+            zoomMin: 1,
+            zoomMax: 4,
+            startZoom: 1,
+
+            resizeScrollbars: true,
+
+            mouseWheelSpeed: 20,
+            mouseWheelTimeout: 400,
+
+            snapThreshold: 0.334,
+
+            // INSERT POINT: OPTIONS
+            disablePointer: !utils.hasPointer,
+            disableTouch: utils.hasPointer || !utils.hasTouch,
+            disableMouse: utils.hasPointer || utils.hasTouch,
+            startX: 0,
+            startY: 0,
+            scrollY: true,
+            directionLockThreshold: 5,
+            momentum: true,
+
+            bounce: true,
+            bounceTime: 600,
+            bounceEasing: '',
+
+            preventDefault: true,
+            preventDefaultException: { tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT)$/ },
+
+            HWCompositing: true,
+            useTransition: true,
+            useTransform: true,
+            bindToWrapper: typeof window.onmousedown === 'undefined',
+        };
+
+        for (var i in options) {
+            this.options[i] = options[i];
+        }
+
+        // Normalize options
+        this.translateZ = this.options.HWCompositing && utils.hasPerspective ? ' translateZ(0)' : '';
+
+        this.options.useTransition = utils.hasTransition && this.options.useTransition;
+        this.options.useTransform = utils.hasTransform && this.options.useTransform;
+
+        this.options.eventPassthrough =
+            this.options.eventPassthrough === true ? 'vertical' : this.options.eventPassthrough;
+        this.options.preventDefault = !this.options.eventPassthrough && this.options.preventDefault;
+
+        // If you want eventPassthrough I have to lock one of the axes
+        this.options.scrollY = this.options.eventPassthrough == 'vertical' ? false : this.options.scrollY;
+        this.options.scrollX = this.options.eventPassthrough == 'horizontal' ? false : this.options.scrollX;
+
+        // With eventPassthrough we also need lockDirection mechanism
+        this.options.freeScroll = this.options.freeScroll && !this.options.eventPassthrough;
+        this.options.directionLockThreshold = this.options.eventPassthrough ? 0 : this.options.directionLockThreshold;
+
+        this.options.bounceEasing =
+            typeof this.options.bounceEasing == 'string'
+                ? utils.ease[this.options.bounceEasing] || utils.ease.circular
+                : this.options.bounceEasing;
+
+        this.options.resizePolling = this.options.resizePolling === undefined ? 60 : this.options.resizePolling;
+
+        if (this.options.tap === true) {
+            this.options.tap = 'tap';
+        }
+
+        // https://github.com/cubiq/iscroll/issues/1029
+        if (!this.options.useTransition && !this.options.useTransform) {
+            if (!/relative|absolute/i.test(this.scrollerStyle.position)) {
+                this.scrollerStyle.position = 'relative';
+            }
+        }
+
+        if (this.options.shrinkScrollbars == 'scale') {
+            this.options.useTransition = false;
+        }
+
+        this.options.invertWheelDirection = this.options.invertWheelDirection ? -1 : 1;
+
+        // INSERT POINT: NORMALIZATION
+
+        // Some defaults
+        this.x = 0;
+        this.y = 0;
+        this.directionX = 0;
+        this.directionY = 0;
+        this._events = {};
+
+        this.scale = Math.min(Math.max(this.options.startZoom, this.options.zoomMin), this.options.zoomMax);
+
+        // INSERT POINT: DEFAULTS
+
+        this._init();
+        this.refresh();
+
+        this.scrollTo(this.options.startX, this.options.startY);
+        this.enable();
+    }
+
+    IScroll.prototype = {
+        version: '5.2.0-snapshot',
+
+        _init: function () {
+            this._initEvents();
+
+            if (this.options.zoom) {
+                this._initZoom();
+            }
+
+            if (this.options.scrollbars || this.options.indicators) {
+                this._initIndicators();
+            }
+
+            if (this.options.mouseWheel) {
+                this._initWheel();
+            }
+
+            if (this.options.snap) {
+                this._initSnap();
+            }
+
+            if (this.options.keyBindings) {
+                this._initKeys();
+            }
+
+            // INSERT POINT: _init
+        },
+
+        destroy: function () {
+            this._initEvents(true);
+            clearTimeout(this.resizeTimeout);
+            this.resizeTimeout = null;
+            this._execEvent('destroy');
+        },
+
+        _transitionEnd: function (e) {
+            if (e.target != this.scroller || !this.isInTransition) {
+                return;
+            }
+
+            this._transitionTime();
+            if (!this.resetPosition(this.options.bounceTime)) {
+                this.isInTransition = false;
+                this._execEvent('scrollEnd');
+            }
+        },
+
+        _start: function (e) {
+            //ignore secondary touch
+            if (e.type == 'pointerdown' && !e.isPrimary) {
+                return;
+            }
+            // React to left mouse button only
+            if (utils.eventType[e.type] != 1) {
+                // for button property
+                // http://unixpapa.com/js/mouse.html
+                var button;
+                if (!e.which) {
+                    /* IE case */
+                    button = e.button < 2 ? 0 : e.button == 4 ? 1 : 2;
+                } else {
+                    /* All others */
+                    button = e.button;
+                }
+                if (button !== 0) {
+                    return;
+                }
+            }
+
+            if (!this.enabled || (this.initiated && utils.eventType[e.type] !== this.initiated)) {
+                return;
+            }
+
+            if (
+                this.options.preventDefault &&
+                !utils.isBadAndroid &&
+                !utils.preventDefaultException(e.target, this.options.preventDefaultException)
+            ) {
+                e.preventDefault();
+            }
+
+            var point = e.touches ? e.touches[0] : e;
+            var pos;
+
+            this.initiated = utils.eventType[e.type];
+            this.moved = false;
+            this.distX = 0;
+            this.distY = 0;
+            this.directionX = 0;
+            this.directionY = 0;
+            this.directionLocked = 0;
+
+            this.startTime = utils.getTime();
+
+            if (this.options.useTransition && this.isInTransition) {
+                this._transitionTime();
+                this.isInTransition = false;
+                pos = this.getComputedPosition();
+                this._translate(Math.round(pos.x), Math.round(pos.y));
+                this._execEvent('scrollEnd');
+            } else if (!this.options.useTransition && this.isAnimating) {
+                this.isAnimating = false;
+                this._execEvent('scrollEnd');
+            }
+
+            this.startX = this.x;
+            this.startY = this.y;
+            this.absStartX = this.x;
+            this.absStartY = this.y;
+            this.pointX = point.pageX;
+            this.pointY = point.pageY;
+
+            this._execEvent('beforeScrollStart');
+        },
+
+        _move: function (e) {
+            if (!this.enabled || utils.eventType[e.type] !== this.initiated) {
+                return;
+            }
+
+            //ignore secondary touch
+            if (e.type == 'pointermove' && !e.isPrimary) {
+                return;
+            }
+
+            if (this.options.preventDefault) {
+                // increases performance on Android? TODO: check!
+                e.preventDefault();
+            }
+
+            var point = e.touches ? e.touches[0] : e;
+            var deltaX = point.pageX - this.pointX;
+            var deltaY = point.pageY - this.pointY;
+            var timestamp = utils.getTime();
+            var newX;
+            var newY;
+            var absDistX;
+            var absDistY;
+
+            this.pointX = point.pageX;
+            this.pointY = point.pageY;
+
+            this.distX += deltaX;
+            this.distY += deltaY;
+            absDistX = Math.abs(this.distX);
+            absDistY = Math.abs(this.distY);
+
+            // We need to move at least 10 pixels for the scrolling to initiate
+            if (timestamp - this.endTime > 300 && absDistX < 10 && absDistY < 10) {
+                return;
+            }
+
+            // If you are scrolling in one direction lock the other
+            if (!this.directionLocked && !this.options.freeScroll) {
+                if (absDistX > absDistY + this.options.directionLockThreshold) {
+                    this.directionLocked = 'h'; // lock horizontally
+                } else if (absDistY >= absDistX + this.options.directionLockThreshold) {
+                    this.directionLocked = 'v'; // lock vertically
+                } else {
+                    this.directionLocked = 'n'; // no lock
+                }
+            }
+
+            if (this.directionLocked == 'h') {
+                if (this.options.eventPassthrough == 'vertical') {
+                    e.preventDefault();
+                } else if (this.options.eventPassthrough == 'horizontal') {
+                    this.initiated = false;
+                    return;
+                }
+
+                deltaY = 0;
+            } else if (this.directionLocked == 'v') {
+                if (this.options.eventPassthrough == 'horizontal') {
+                    e.preventDefault();
+                } else if (this.options.eventPassthrough == 'vertical') {
+                    this.initiated = false;
+                    return;
+                }
+
+                deltaX = 0;
+            }
+
+            deltaX = this.hasHorizontalScroll ? deltaX : 0;
+            deltaY = this.hasVerticalScroll ? deltaY : 0;
+
+            newX = this.x + deltaX;
+            newY = this.y + deltaY;
+
+            // Slow down if outside of the boundaries
+            if (newX > 0 || newX < this.maxScrollX) {
+                newX = this.options.bounce ? this.x + deltaX / 3 : newX > 0 ? 0 : this.maxScrollX;
+            }
+            if (newY > 0 || newY < this.maxScrollY) {
+                newY = this.options.bounce ? this.y + deltaY / 3 : newY > 0 ? 0 : this.maxScrollY;
+            }
+
+            this.directionX = deltaX > 0 ? -1 : deltaX < 0 ? 1 : 0;
+            this.directionY = deltaY > 0 ? -1 : deltaY < 0 ? 1 : 0;
+
+            if (!this.moved) {
+                this._execEvent('scrollStart');
+            }
+
+            this.moved = true;
+
+            this._translate(newX, newY);
+
+            /* REPLACE START: _move */
+
+            if (timestamp - this.startTime > 300) {
+                this.startTime = timestamp;
+                this.startX = this.x;
+                this.startY = this.y;
+            }
+
+            /* REPLACE END: _move */
+        },
+
+        _end: function (e) {
+            if (!this.enabled || utils.eventType[e.type] !== this.initiated) {
+                return;
+            }
+
+            //ignore secondary touch
+            if (e.type == 'pointerup' && !e.isPrimary) {
+                return;
+            }
+
+            if (
+                this.options.preventDefault &&
+                !utils.preventDefaultException(e.target, this.options.preventDefaultException)
+            ) {
+                e.preventDefault();
+            }
+
+            var point = e.changedTouches ? e.changedTouches[0] : e;
+            var momentumX;
+            var momentumY;
+            var duration = utils.getTime() - this.startTime;
+            var newX = Math.round(this.x);
+            var newY = Math.round(this.y);
+            var distanceX = Math.abs(newX - this.startX);
+            var distanceY = Math.abs(newY - this.startY);
+            var time = 0;
+            var easing = '';
+
+            this.isInTransition = 0;
+            this.initiated = 0;
+            this.endTime = utils.getTime();
+
+            // reset if we are outside of the boundaries
+            if (this.resetPosition(this.options.bounceTime)) {
+                return;
+            }
+
+            this.scrollTo(newX, newY); // ensures that the last position is rounded
+
+            // we scrolled less than 10 pixels
+            if (!this.moved) {
+                if (this.options.tap) {
+                    utils.tap(e, this.options.tap);
+                }
+
+                if (this.options.click) {
+                    utils.click(e);
+                }
+
+                this._execEvent('scrollCancel');
+                return;
+            }
+
+            if (this._events.flick && duration < 200 && distanceX < 100 && distanceY < 100) {
+                this._execEvent('flick');
+                return;
+            }
+
+            // start momentum animation if needed
+            if (this.options.momentum && duration < 300) {
+                momentumX = this.hasHorizontalScroll
+                    ? utils.momentum(
+                          this.x,
+                          this.startX,
+                          duration,
+                          this.maxScrollX,
+                          this.options.bounce ? this.wrapperWidth : 0,
+                          this.options.deceleration
+                      )
+                    : { destination: newX, duration: 0 };
+                momentumY = this.hasVerticalScroll
+                    ? utils.momentum(
+                          this.y,
+                          this.startY,
+                          duration,
+                          this.maxScrollY,
+                          this.options.bounce ? this.wrapperHeight : 0,
+                          this.options.deceleration
+                      )
+                    : { destination: newY, duration: 0 };
+                newX = momentumX.destination;
+                newY = momentumY.destination;
+                time = Math.max(momentumX.duration, momentumY.duration);
+                this.isInTransition = 1;
+            }
+
+            if (this.options.snap) {
+                var snap = this._nearestSnap(newX, newY);
+                this.currentPage = snap;
+                time =
+                    this.options.snapSpeed ||
+                    Math.max(
+                        Math.max(Math.min(Math.abs(newX - snap.x), 1000), Math.min(Math.abs(newY - snap.y), 1000)),
+                        300
+                    );
+                newX = snap.x;
+                newY = snap.y;
+
+                this.directionX = 0;
+                this.directionY = 0;
+                easing = this.options.bounceEasing;
+            }
+
+            // INSERT POINT: _end
+
+            if (newX != this.x || newY != this.y) {
+                // change easing function when scroller goes out of the boundaries
+                if (newX > 0 || newX < this.maxScrollX || newY > 0 || newY < this.maxScrollY) {
+                    easing = utils.ease.quadratic;
+                }
+
+                this.scrollTo(newX, newY, time, easing);
+
+                //custom
+                this._execEvent('scrollToPage');
+                return;
+            }
+
+            this._execEvent('scrollEnd');
+        },
+
+        _resize: function () {
+            var that = this;
+
+            clearTimeout(this.resizeTimeout);
+
+            this.resizeTimeout = setTimeout(function () {
+                that.refresh();
+            }, this.options.resizePolling);
+        },
+
+        resetPosition: function (time) {
+            var x = this.x;
+            var y = this.y;
+
+            time = time || 0;
+
+            if (!this.hasHorizontalScroll || this.x > 0) {
+                x = 0;
+                // custom start
+                if (this.options.keepInCenterH && this.getScrollerWidth() * this.scale < this.wrapperWidth) {
+                    x = this.wrapperWidth / 2 - (this.getScrollerWidth() * this.scale) / 2;
+                }
+                // custom end
+            } else if (this.x < this.maxScrollX) {
+                x = this.maxScrollX;
+            }
+
+            if (!this.hasVerticalScroll || this.y > 0) {
+                y = 0;
+                // custom start
+                if (this.options.keepInCenterV && this.getScrollerHeight() * this.scale < this.wrapperHeight) {
+                    y = this.wrapperHeight / 2 - (this.getScrollerHeight() * this.scale) / 2;
+                }
+                // custom end
+            } else if (this.y < this.maxScrollY) {
+                y = this.maxScrollY;
+            }
+
+            if (x == this.x && y == this.y) {
+                return false;
+            }
+
+            this.scrollTo(x, y, time, this.options.bounceEasing);
+
+            return true;
+        },
+
+        disable: function () {
+            this.enabled = false;
+        },
+
+        enable: function () {
+            this.enabled = true;
+        },
+
+        //custom
+
+        setScrollerSize: function (w, h) {
+            this.scrollerW = w;
+            this.scrollerH = h;
+        },
+
+        setWrapperOffset: function (left, top) {
+            this.wrapperOffsetLeft = left;
+            this.wrapperOffsetTop = top;
+        },
+
+        //custom end
+
+        refresh: function () {
+            utils.getRect(this.wrapper); // Force reflow
+
+            this.wrapperWidth = this.wrapper.clientWidth;
+            this.wrapperHeight = this.wrapper.clientHeight;
+
+            var rect = utils.getRect(this.scroller);
+            if (this.scrollerW) {
+                rect.width = this.scrollerW;
+            }
+            if (this.scrollerH) {
+                rect.height = this.scrollerH;
+            }
+            /* REPLACE START: refresh */
+            this.scrollerWidth = Math.round(rect.width * this.scale);
+            this.scrollerHeight = Math.round(rect.height * this.scale);
+
+            this.maxScrollX = this.wrapperWidth - this.scrollerWidth;
+            this.maxScrollY = this.wrapperHeight - this.scrollerHeight;
+            /* REPLACE END: refresh */
+
+            this.hasHorizontalScroll = this.options.scrollX && this.maxScrollX < 0;
+            this.hasVerticalScroll = this.options.scrollY && this.maxScrollY < 0;
+
+            if (!this.hasHorizontalScroll) {
+                this.maxScrollX = 0;
+                this.scrollerWidth = this.wrapperWidth;
+            }
+
+            if (!this.hasVerticalScroll) {
+                this.maxScrollY = 0;
+                this.scrollerHeight = this.wrapperHeight;
+            }
+
+            this.endTime = 0;
+            this.directionX = 0;
+            this.directionY = 0;
+
+            if (utils.hasPointer && !this.options.disablePointer) {
+                // The wrapper should have `touchAction` property for using pointerEvent.
+                this.wrapper.style[utils.style.touchAction] = utils.getTouchAction(this.options.eventPassthrough, true);
+
+                // case. not support 'pinch-zoom'
+                // https://github.com/cubiq/iscroll/issues/1118#issuecomment-270057583
+                if (!this.wrapper.style[utils.style.touchAction]) {
+                    this.wrapper.style[utils.style.touchAction] = utils.getTouchAction(
+                        this.options.eventPassthrough,
+                        false
+                    );
+                }
+            }
+            this.wrapperOffset = utils.offset(this.wrapper);
+            if (this.wrapperOffsetLeft) {
+                this.wrapperOffset.left = this.wrapperOffsetLeft;
+            }
+            if (this.wrapperOffsetTop) {
+                this.wrapperOffset.top = this.wrapperOffsetTop;
+            }
+
+            this._execEvent('refresh');
+
+            this.resetPosition();
+
+            // INSERT POINT: _refresh
+        },
+
+        on: function (type, fn) {
+            if (!this._events[type]) {
+                this._events[type] = [];
+            }
+
+            this._events[type].push(fn);
+        },
+
+        off: function (type, fn) {
+            if (!this._events[type]) {
+                return;
+            }
+
+            var index = this._events[type].indexOf(fn);
+
+            if (index > -1) {
+                this._events[type].splice(index, 1);
+            }
+        },
+
+        _execEvent: function (type) {
+            if (!this._events[type]) {
+                return;
+            }
+
+            var i = 0;
+            var l = this._events[type].length;
+
+            if (!l) {
+                return;
+            }
+
+            for (; i < l; i++) {
+                this._events[type][i].apply(this, [].slice.call(arguments, 1));
+            }
+        },
+
+        scrollBy: function (x, y, time, easing) {
+            x = this.x + x;
+            y = this.y + y;
+            time = time || 0;
+
+            this.scrollTo(x, y, time, easing);
+        },
+
+        //custom
+
+        getScrollerWidth: function () {
+            return this.scrollerW !== undefined ? this.scrollerW : this.scroller.offsetWidth;
+        },
+
+        getScrollerHeight: function () {
+            return this.scrollerH !== undefined ? this.scrollerH : this.scroller.offsetHeight;
+        },
+
+        //end custom
+
+        scrollTo: function (x, y, time, easing) {
+            /*custom*/
+
+            if (this.wrapperWidth == 0 || this.wrapperHeight == 0) {
+                return;
+            }
+
+            if (time) {
+                if (this.prevDisabled && x == 0) {
+                    this.goToPage(1, 0, 0);
+                    return;
+                }
+
+                if (this.nextDisabled && x == -(this.scrollerWidth - this.wrapperWidth)) {
+                    this.goToPage(1, 0, 0);
+                    return;
+                }
+            }
+
+            if (this.options.keepInCenterH && this.getScrollerWidth() * this.scale < this.wrapperWidth) {
+                x = this.wrapperWidth / 2 - (this.getScrollerWidth() * this.scale) / 2;
+            }
+
+            if (this.options.keepInCenterV && this.getScrollerHeight() * this.scale < this.wrapperHeight) {
+                y = this.wrapperHeight / 2 - (this.getScrollerHeight() * this.scale) / 2;
+            }
+            /*end custom*/
+
+            easing = easing || utils.ease.circular;
+
+            this.isInTransition = this.options.useTransition && time > 0;
+            var transitionType = this.options.useTransition && easing.style;
+            if (!time || transitionType) {
+                if (transitionType) {
+                    this._transitionTimingFunction(easing.style);
+                    this._transitionTime(time);
+                }
+                this._translate(x, y);
+            } else {
+                this._animate(x, y, time, easing.fn);
+            }
+        },
+
+        scrollToElement: function (el, time, offsetX, offsetY, easing) {
+            el = el.nodeType ? el : this.scroller.querySelector(el);
+
+            if (!el) {
+                return;
+            }
+
+            var pos = utils.offset(el);
+
+            pos.left -= this.wrapperOffset.left;
+            pos.top -= this.wrapperOffset.top;
+
+            // if offsetX/Y are true we center the element to the screen
+            var elRect = utils.getRect(el);
+            var wrapperRect = utils.getRect(this.wrapper);
+            if (offsetX === true) {
+                offsetX = Math.round(elRect.width / 2 - wrapperRect.width / 2);
+            }
+            if (offsetY === true) {
+                offsetY = Math.round(elRect.height / 2 - wrapperRect.height / 2);
+            }
+
+            pos.left -= offsetX || 0;
+            pos.top -= offsetY || 0;
+
+            pos.left = pos.left > 0 ? 0 : pos.left < this.maxScrollX ? this.maxScrollX : pos.left;
+            pos.top = pos.top > 0 ? 0 : pos.top < this.maxScrollY ? this.maxScrollY : pos.top;
+
+            time =
+                time === undefined || time === null || time === 'auto'
+                    ? Math.max(Math.abs(this.x - pos.left), Math.abs(this.y - pos.top))
+                    : time;
+
+            this.scrollTo(pos.left, pos.top, time, easing);
+        },
+
+        _transitionTime: function (time) {
+            if (!this.options.useTransition) {
+                return;
+            }
+            time = time || 0;
+            var durationProp = utils.style.transitionDuration;
+            if (!durationProp) {
+                return;
+            }
+
+            this.scrollerStyle[durationProp] = time + 'ms';
+
+            if (!time && utils.isBadAndroid) {
+                this.scrollerStyle[durationProp] = '0.0001ms';
+                // remove 0.0001ms
+                var self = this;
+                rAF(function () {
+                    if (self.scrollerStyle[durationProp] === '0.0001ms') {
+                        self.scrollerStyle[durationProp] = '0s';
+                    }
+                });
+            }
+
+            if (this.indicators) {
+                for (var i = this.indicators.length; i--; ) {
+                    this.indicators[i].transitionTime(time);
+                }
+            }
+
+            // INSERT POINT: _transitionTime
+        },
+
+        _transitionTimingFunction: function (easing) {
+            this.scrollerStyle[utils.style.transitionTimingFunction] = easing;
+
+            if (this.indicators) {
+                for (var i = this.indicators.length; i--; ) {
+                    this.indicators[i].transitionTimingFunction(easing);
+                }
+            }
+
+            // INSERT POINT: _transitionTimingFunction
+        },
+
+        _translate: function (x, y) {
+            if (this.options.useTransform) {
+                /* REPLACE START: _translate */ this.scrollerStyle[utils.style.transform] =
+                    'translate(' +
+                    x +
+                    'px,' +
+                    y +
+                    'px) scale(' +
+                    this.scale +
+                    ') ' +
+                    this.translateZ; /* REPLACE END: _translate */
+            } else {
+                x = Math.round(x);
+                y = Math.round(y);
+                this.scrollerStyle.left = x + 'px';
+                this.scrollerStyle.top = y + 'px';
+            }
+
+            this.x = x;
+            this.y = y;
+
+            if (this.indicators) {
+                for (var i = this.indicators.length; i--; ) {
+                    this.indicators[i].updatePosition();
+                }
+            }
+
+            // INSERT POINT: _translate
+        },
+
+        _initEvents: function (remove) {
+            var eventType = remove ? utils.removeEvent : utils.addEvent;
+            var target = this.options.bindToWrapper ? this.wrapper : window;
+
+            eventType(window, 'orientationchange', this);
+            eventType(window, 'resize', this);
+
+            if (this.options.click) {
+                eventType(this.wrapper, 'click', this, true);
+            }
+
+            if (!this.options.disableMouse) {
+                eventType(this.wrapper, 'mousedown', this);
+                eventType(target, 'mousemove', this);
+                eventType(target, 'mousecancel', this);
+                eventType(target, 'mouseup', this);
+            }
+
+            if (utils.hasPointer && !this.options.disablePointer) {
+                eventType(this.wrapper, utils.prefixPointerEvent('pointerdown'), this);
+                eventType(target, utils.prefixPointerEvent('pointermove'), this);
+                eventType(target, utils.prefixPointerEvent('pointercancel'), this);
+                eventType(target, utils.prefixPointerEvent('pointerup'), this);
+            }
+
+            if (utils.hasTouch && !this.options.disableTouch) {
+                eventType(this.wrapper, 'touchstart', this);
+                eventType(target, 'touchmove', this);
+                eventType(target, 'touchcancel', this);
+                eventType(target, 'touchend', this);
+            }
+
+            eventType(this.scroller, 'transitionend', this);
+            eventType(this.scroller, 'webkitTransitionEnd', this);
+            eventType(this.scroller, 'oTransitionEnd', this);
+            eventType(this.scroller, 'MSTransitionEnd', this);
+        },
+
+        getComputedPosition: function () {
+            var matrix = window.getComputedStyle(this.scroller, null);
+            var x;
+            var y;
+
+            if (this.options.useTransform) {
+                matrix = matrix[utils.style.transform].split(')')[0].split(', ');
+                x = +(matrix[12] || matrix[4]);
+                y = +(matrix[13] || matrix[5]);
+            } else {
+                x = +matrix.left.replace(/[^-\d.]/g, '');
+                y = +matrix.top.replace(/[^-\d.]/g, '');
+            }
+
+            return { x: x, y: y };
+        },
+        _initIndicators: function () {
+            var interactive = this.options.interactiveScrollbars;
+            var customStyle = typeof this.options.scrollbars != 'string';
+            var indicators = [];
+            var indicator;
+
+            var that = this;
+
+            this.indicators = [];
+
+            if (this.options.scrollbars) {
+                // Vertical scrollbar
+                if (this.options.scrollY) {
+                    indicator = {
+                        el: createDefaultScrollbar('v', interactive, this.options.scrollbars),
+                        interactive: interactive,
+                        defaultScrollbars: true,
+                        customStyle: customStyle,
+                        resize: this.options.resizeScrollbars,
+                        shrink: this.options.shrinkScrollbars,
+                        fade: this.options.fadeScrollbars,
+                        listenX: false,
+                    };
+
+                    this.wrapper.appendChild(indicator.el);
+                    indicators.push(indicator);
+                }
+
+                // Horizontal scrollbar
+                if (this.options.scrollX) {
+                    indicator = {
+                        el: createDefaultScrollbar('h', interactive, this.options.scrollbars),
+                        interactive: interactive,
+                        defaultScrollbars: true,
+                        customStyle: customStyle,
+                        resize: this.options.resizeScrollbars,
+                        shrink: this.options.shrinkScrollbars,
+                        fade: this.options.fadeScrollbars,
+                        listenY: false,
+                    };
+
+                    this.wrapper.appendChild(indicator.el);
+                    indicators.push(indicator);
+                }
+            }
+
+            if (this.options.indicators) {
+                // TODO: check concat compatibility
+                indicators = indicators.concat(this.options.indicators);
+            }
+
+            for (var i = indicators.length; i--; ) {
+                this.indicators.push(new Indicator(this, indicators[i]));
+            }
+
+            // TODO: check if we can use array.map (wide compatibility and performance issues)
+            function _indicatorsMap(fn) {
+                if (that.indicators) {
+                    for (var i = that.indicators.length; i--; ) {
+                        fn.call(that.indicators[i]);
+                    }
+                }
+            }
+
+            if (this.options.fadeScrollbars) {
+                this.on('scrollEnd', function () {
+                    _indicatorsMap(function () {
+                        this.fade();
+                    });
+                });
+
+                this.on('scrollCancel', function () {
+                    _indicatorsMap(function () {
+                        this.fade();
+                    });
+                });
+
+                this.on('scrollStart', function () {
+                    _indicatorsMap(function () {
+                        this.fade(1);
+                    });
+                });
+
+                this.on('beforeScrollStart', function () {
+                    _indicatorsMap(function () {
+                        this.fade(1, true);
+                    });
+                });
+            }
+
+            this.on('refresh', function () {
+                _indicatorsMap(function () {
+                    this.refresh();
+                });
+            });
+
+            this.on('destroy', function () {
+                _indicatorsMap(function () {
+                    this.destroy();
+                });
+
+                delete this.indicators;
+            });
+        },
+
+        _initZoom: function () {
+            this.scrollerStyle[utils.style.transformOrigin] = '0 0';
+        },
+
+        _zoomStart: function (e) {
+            var c1 = Math.abs(e.touches[0].pageX - e.touches[1].pageX);
+            var c2 = Math.abs(e.touches[0].pageY - e.touches[1].pageY);
+
+            this.touchesDistanceStart = Math.sqrt(c1 * c1 + c2 * c2);
+            this.startScale = this.scale;
+
+            this.originX = Math.abs(e.touches[0].pageX + e.touches[1].pageX) / 2 + this.wrapperOffset.left - this.x;
+            this.originY = Math.abs(e.touches[0].pageY + e.touches[1].pageY) / 2 + this.wrapperOffset.top - this.y;
+
+            this._execEvent('zoomStart');
+        },
+
+        _zoom: function (e) {
+            if (!this.enabled || utils.eventType[e.type] !== this.initiated) {
+                return;
+            }
+
+            if (this.options.preventDefault) {
+                e.preventDefault();
+            }
+
+            var c1 = Math.abs(e.touches[0].pageX - e.touches[1].pageX);
+            var c2 = Math.abs(e.touches[0].pageY - e.touches[1].pageY);
+            var distance = Math.sqrt(c1 * c1 + c2 * c2);
+            var scale = (1 / this.touchesDistanceStart) * distance * this.startScale;
+            var lastScale;
+            var x;
+            var y;
+
+            this.scaled = true;
+
+            if (scale < this.options.zoomMin) {
+                scale = 0.5 * this.options.zoomMin * Math.pow(2.0, scale / this.options.zoomMin);
+            } else if (scale > this.options.zoomMax) {
+                scale = 2.0 * this.options.zoomMax * Math.pow(0.5, this.options.zoomMax / scale);
+            }
+
+            lastScale = scale / this.startScale;
+            x = this.originX - this.originX * lastScale + this.startX;
+            y = this.originY - this.originY * lastScale + this.startY;
+
+            this.scale = scale;
+
+            this.scrollTo(x, y, 0);
+        },
+
+        _zoomEnd: function (e) {
+            if (!this.enabled || utils.eventType[e.type] !== this.initiated) {
+                return;
+            }
+
+            if (this.options.preventDefault) {
+                e.preventDefault();
+            }
+
+            var newX;
+            var newY;
+            var lastScale;
+
+            this.isInTransition = 0;
+            this.initiated = 0;
+
+            if (this.scale > this.options.zoomMax) {
+                this.scale = this.options.zoomMax;
+            } else if (this.scale < this.options.zoomMin) {
+                this.scale = this.options.zoomMin;
+            }
+
+            // Update boundaries
+            this.refresh();
+
+            lastScale = this.scale / this.startScale;
+
+            newX = this.originX - this.originX * lastScale + this.startX;
+            newY = this.originY - this.originY * lastScale + this.startY;
+
+            if (newX > 0) {
+                newX = 0;
+            } else if (newX < this.maxScrollX) {
+                newX = this.maxScrollX;
+            }
+
+            if (newY > 0) {
+                newY = 0;
+            } else if (newY < this.maxScrollY) {
+                newY = this.maxScrollY;
+            }
+
+            if (this.x != newX || this.y != newY) {
+                this.scrollTo(newX, newY, this.options.bounceTime);
+            }
+
+            this.scaled = false;
+
+            this._execEvent('zoomEnd');
+        },
+
+        zoom: function (scale, x, y, time) {
+            /*custom*/
+            if (this.wrapperWidth == 0 || this.wrapperHeight == 0) {
+                return;
+            }
+            /* end custom*/
+
+            if (scale < this.options.zoomMin) {
+                scale = this.options.zoomMin;
+            } else if (scale > this.options.zoomMax) {
+                scale = this.options.zoomMax;
+            }
+
+            if (scale == this.scale) {
+                return;
+            }
+
+            var relScale = scale / this.scale;
+
+            /*custom*/
+            var that = this;
+            if (relScale != 1) {
+                clearTimeout(this.zoomStartTimeout);
+                this.zoomStartTimeout = setTimeout(function () {
+                    that._execEvent('zoomStart');
+                }, 0);
+
+                // Execute the zoomEnd event after 400ms the wheel stopped scrolling
+                clearTimeout(this.wheelTimeout);
+                this.wheelTimeout = setTimeout(function () {
+                    that._execEvent('zoomEnd');
+                }, Number(time + 100));
+            }
+
+            /*custom end*/
+
+            x = x === undefined ? this.wrapperWidth / 2 : x;
+            y = y === undefined ? this.wrapperHeight / 2 : y;
+            time = time === undefined ? 300 : time;
+
+            x = x + this.wrapperOffset.left - this.x;
+            y = y + this.wrapperOffset.top - this.y;
+
+            x = x - x * relScale + this.x;
+            y = y - y * relScale + this.y;
+
+            this.scale = scale;
+
+            this.refresh(); // update boundaries
+
+            if (x > 0) {
+                x = 0;
+            } else if (x < this.maxScrollX) {
+                x = this.maxScrollX;
+            }
+
+            if (y > 0) {
+                y = 0;
+            } else if (y < this.maxScrollY) {
+                y = this.maxScrollY;
+            }
+
+            this.scrollTo(x, y, time);
+        },
+
+        _wheelZoom: function (e) {
+            var wheelDeltaY;
+            var deltaScale;
+            var that = this;
+
+            /*custom - moved to function zoom()
+
+      // Execute the zoomEnd event after 400ms the wheel stopped scrolling
+      clearTimeout(this.wheelTimeout);
+      this.wheelTimeout = setTimeout(function () {
+        that._execEvent('zoomEnd');
+      }, 400);
+
+      custom end*/
+
+            if ('deltaX' in e) {
+                wheelDeltaY = -e.deltaY / Math.abs(e.deltaY);
+            } else if ('wheelDeltaX' in e) {
+                wheelDeltaY = e.wheelDeltaY / Math.abs(e.wheelDeltaY);
+            } else if ('wheelDelta' in e) {
+                wheelDeltaY = e.wheelDelta / Math.abs(e.wheelDelta);
+            } else if ('detail' in e) {
+                wheelDeltaY = -e.detail / Math.abs(e.wheelDelta);
+            } else {
+                return;
+            }
+
+            deltaScale = this.scale + wheelDeltaY / 5;
+
+            this.zoom(deltaScale, e.pageX, e.pageY, 0);
+        },
+
+        _initWheel: function () {
+            utils.addEvent(this.wrapper, 'wheel', this);
+            utils.addEvent(this.wrapper, 'mousewheel', this);
+            utils.addEvent(this.wrapper, 'DOMMouseScroll', this);
+
+            this.on('destroy', function () {
+                clearTimeout(this.wheelTimeout);
+                this.wheelTimeout = null;
+                utils.removeEvent(this.wrapper, 'wheel', this);
+                utils.removeEvent(this.wrapper, 'mousewheel', this);
+                utils.removeEvent(this.wrapper, 'DOMMouseScroll', this);
+            });
+        },
+
+        _wheel: function (e) {
+            if (!this.enabled) {
+                return;
+            }
+            //custom - prevent default wheel behavior only if options.preventDefault
+            if (this.options.preventDefault) {
+                //custom end
+                e.preventDefault();
+                //custom
+            }
+            //custom end
+            var wheelDeltaX;
+            var wheelDeltaY;
+            var newX;
+            var newY;
+            var that = this;
+
+            if (this.wheelTimeout === undefined) {
+                that._execEvent('scrollStart');
+            }
+
+            // Execute the scrollEnd event after 400ms the wheel stopped scrolling
+            clearTimeout(this.wheelTimeout);
+
+            /* custom - fixed timet 400ms changed to this.options.mouseWheelTimeout, default is 400
+            this.wheelTimeout = setTimeout(function () {
+                if (!that.options.snap) {
+                    that._execEvent('scrollEnd');
+                }
+                that.wheelTimeout = undefined;
+            }, 400);
+
+			*/
+
+            this.wheelTimeout = setTimeout(function () {
+                if (!that.options.snap) {
+                    that._execEvent('scrollEnd');
+                }
+                that.wheelTimeout = undefined;
+            }, this.options.mouseWheelTimeout);
+
+            if ('deltaX' in e) {
+                if (e.deltaMode === 1) {
+                    wheelDeltaX = -e.deltaX * this.options.mouseWheelSpeed;
+                    wheelDeltaY = -e.deltaY * this.options.mouseWheelSpeed;
+                } else {
+                    wheelDeltaX = -e.deltaX;
+                    wheelDeltaY = -e.deltaY;
+                }
+            } else if ('wheelDeltaX' in e) {
+                wheelDeltaX = (e.wheelDeltaX / 120) * this.options.mouseWheelSpeed;
+                wheelDeltaY = (e.wheelDeltaY / 120) * this.options.mouseWheelSpeed;
+            } else if ('wheelDelta' in e) {
+                wheelDeltaX = wheelDeltaY = (e.wheelDelta / 120) * this.options.mouseWheelSpeed;
+            } else if ('detail' in e) {
+                wheelDeltaX = wheelDeltaY = (-e.detail / 3) * this.options.mouseWheelSpeed;
+            } else {
+                return;
+            }
+
+            wheelDeltaX *= this.options.invertWheelDirection;
+            wheelDeltaY *= this.options.invertWheelDirection;
+
+            if (!this.hasVerticalScroll) {
+                wheelDeltaX = wheelDeltaY;
+                wheelDeltaY = 0;
+            }
+
+            if (this.options.snap) {
+                newX = this.currentPage.pageX;
+                newY = this.currentPage.pageY;
+
+                if (wheelDeltaX > 0) {
+                    newX--;
+                } else if (wheelDeltaX < 0) {
+                    newX++;
+                }
+
+                if (wheelDeltaY > 0) {
+                    newY--;
+                } else if (wheelDeltaY < 0) {
+                    newY++;
+                }
+
+                this.goToPage(newX, newY);
+
+                return;
+            }
+
+            newX = this.x + Math.round(this.hasHorizontalScroll ? wheelDeltaX : 0);
+            newY = this.y + Math.round(this.hasVerticalScroll ? wheelDeltaY : 0);
+
+            this.directionX = wheelDeltaX > 0 ? -1 : wheelDeltaX < 0 ? 1 : 0;
+            this.directionY = wheelDeltaY > 0 ? -1 : wheelDeltaY < 0 ? 1 : 0;
+
+            if (newX > 0) {
+                newX = 0;
+            } else if (newX < this.maxScrollX) {
+                newX = this.maxScrollX;
+            }
+
+            if (newY > 0) {
+                newY = 0;
+            } else if (newY < this.maxScrollY) {
+                newY = this.maxScrollY;
+            }
+            //custom - prevent page scrolling if iscroll is scrolling
+            else {
+                e.preventDefault();
+            }
+            //end custom
+
+            this.scrollTo(newX, newY, 0);
+
+            // INSERT POINT: _wheel
+        },
+
+        _initSnap: function () {
+            this.currentPage = {};
+
+            if (typeof this.options.snap == 'string') {
+                this.options.snap = this.scroller.querySelectorAll(this.options.snap);
+            }
+
+            this.on('refresh', function () {
+                var i = 0;
+                var l;
+                var m = 0;
+                var n;
+                var cx;
+                var cy;
+                var x = 0;
+                var y;
+                var stepX = this.options.snapStepX || this.wrapperWidth;
+                var stepY = this.options.snapStepY || this.wrapperHeight;
+                var el;
+                var rect;
+
+                this.pages = [];
+
+                if (!this.wrapperWidth || !this.wrapperHeight || !this.scrollerWidth || !this.scrollerHeight) {
+                    return;
+                }
+
+                if (this.options.snap === true) {
+                    cx = Math.round(stepX / 2);
+                    cy = Math.round(stepY / 2);
+
+                    while (x > -this.scrollerWidth) {
+                        this.pages[i] = [];
+                        l = 0;
+                        y = 0;
+
+                        while (y > -this.scrollerHeight) {
+                            this.pages[i][l] = {
+                                x: Math.max(x, this.maxScrollX),
+                                y: Math.max(y, this.maxScrollY),
+                                width: stepX,
+                                height: stepY,
+                                cx: x - cx,
+                                cy: y - cy,
+                            };
+
+                            y -= stepY;
+                            l++;
+                        }
+
+                        x -= stepX;
+                        i++;
+                    }
+                } else {
+                    el = this.options.snap;
+                    l = el.length;
+                    n = -1;
+
+                    for (; i < l; i++) {
+                        rect = utils.getRect(el[i]);
+                        if (i === 0 || rect.left <= utils.getRect(el[i - 1]).left) {
+                            m = 0;
+                            n++;
+                        }
+
+                        if (!this.pages[m]) {
+                            this.pages[m] = [];
+                        }
+
+                        x = Math.max(-rect.left, this.maxScrollX);
+                        y = Math.max(-rect.top, this.maxScrollY);
+                        cx = x - Math.round(rect.width / 2);
+                        cy = y - Math.round(rect.height / 2);
+
+                        this.pages[m][n] = {
+                            x: x,
+                            y: y,
+                            width: rect.width,
+                            height: rect.height,
+                            cx: cx,
+                            cy: cy,
+                        };
+
+                        if (x > this.maxScrollX) {
+                            m++;
+                        }
+                    }
+                }
+
+                this.goToPage(this.currentPage.pageX || 0, this.currentPage.pageY || 0, 0);
+
+                // Update snap threshold if needed
+                if (this.options.snapThreshold % 1 === 0) {
+                    this.snapThresholdX = this.options.snapThreshold;
+                    this.snapThresholdY = this.options.snapThreshold;
+                } else {
+                    this.snapThresholdX = Math.round(
+                        this.pages[this.currentPage.pageX][this.currentPage.pageY].width * this.options.snapThreshold
+                    );
+                    this.snapThresholdY = Math.round(
+                        this.pages[this.currentPage.pageX][this.currentPage.pageY].height * this.options.snapThreshold
+                    );
+                }
+            });
+
+            this.on('flick', function () {
+                var time =
+                    this.options.snapSpeed ||
+                    Math.max(
+                        Math.max(
+                            Math.min(Math.abs(this.x - this.startX), 1000),
+                            Math.min(Math.abs(this.y - this.startY), 1000)
+                        ),
+                        300
+                    );
+
+                this.goToPage(this.currentPage.pageX + this.directionX, this.currentPage.pageY + this.directionY, time);
+            });
+        },
+
+        _nearestSnap: function (x, y) {
+            if (!this.pages.length) {
+                return { x: 0, y: 0, pageX: 0, pageY: 0 };
+            }
+
+            var i = 0;
+            var l = this.pages.length;
+            var m = 0;
+
+            // Check if we exceeded the snap threshold
+            if (
+                Math.abs(x - this.absStartX) < this.snapThresholdX &&
+                Math.abs(y - this.absStartY) < this.snapThresholdY
+            ) {
+                return this.currentPage;
+            }
+
+            if (x > 0) {
+                x = 0;
+            } else if (x < this.maxScrollX) {
+                x = this.maxScrollX;
+            }
+
+            if (y > 0) {
+                y = 0;
+            } else if (y < this.maxScrollY) {
+                y = this.maxScrollY;
+            }
+
+            for (; i < l; i++) {
+                if (x >= this.pages[i][0].cx) {
+                    x = this.pages[i][0].x;
+                    break;
+                }
+            }
+
+            l = this.pages[i].length;
+
+            for (; m < l; m++) {
+                if (y >= this.pages[0][m].cy) {
+                    y = this.pages[0][m].y;
+                    break;
+                }
+            }
+
+            if (i == this.currentPage.pageX) {
+                i += this.directionX;
+
+                if (i < 0) {
+                    i = 0;
+                } else if (i >= this.pages.length) {
+                    i = this.pages.length - 1;
+                }
+
+                x = this.pages[i][0].x;
+            }
+
+            if (m == this.currentPage.pageY) {
+                m += this.directionY;
+
+                if (m < 0) {
+                    m = 0;
+                } else if (m >= this.pages[0].length) {
+                    m = this.pages[0].length - 1;
+                }
+
+                y = this.pages[0][m].y;
+            }
+
+            return {
+                x: x,
+                y: y,
+                pageX: i,
+                pageY: m,
+            };
+        },
+
+        goToPage: function (x, y, time, easing) {
+            easing = easing || this.options.bounceEasing;
+
+            if (x >= this.pages.length) {
+                x = this.pages.length - 1;
+            } else if (x < 0) {
+                x = 0;
+            }
+
+            if (y >= this.pages[x].length) {
+                y = this.pages[x].length - 1;
+            } else if (y < 0) {
+                y = 0;
+            }
+
+            var posX = this.pages[x][y].x;
+            var posY = this.pages[x][y].y;
+
+            time =
+                time === undefined
+                    ? this.options.snapSpeed ||
+                      Math.max(
+                          Math.max(Math.min(Math.abs(posX - this.x), 1000), Math.min(Math.abs(posY - this.y), 1000)),
+                          300
+                      )
+                    : time;
+
+            this.currentPage = {
+                x: posX,
+                y: posY,
+                pageX: x,
+                pageY: y,
+            };
+
+            this.scrollTo(posX, posY, time, easing);
+        },
+
+        next: function (time, easing) {
+            var x = this.currentPage.pageX;
+            var y = this.currentPage.pageY;
+
+            x++;
+
+            if (x >= this.pages.length && this.hasVerticalScroll) {
+                x = 0;
+                y++;
+            }
+
+            this.goToPage(x, y, time, easing);
+        },
+
+        prev: function (time, easing) {
+            var x = this.currentPage.pageX;
+            var y = this.currentPage.pageY;
+
+            x--;
+
+            if (x < 0 && this.hasVerticalScroll) {
+                x = 0;
+                y--;
+            }
+
+            this.goToPage(x, y, time, easing);
+        },
+
+        _initKeys: function (e) {
+            // default key bindings
+            var keys = {
+                pageUp: 33,
+                pageDown: 34,
+                end: 35,
+                home: 36,
+                left: 37,
+                up: 38,
+                right: 39,
+                down: 40,
+            };
+            var i;
+
+            // if you give me characters I give you keycode
+            if (typeof this.options.keyBindings == 'object') {
+                for (i in this.options.keyBindings) {
+                    if (typeof this.options.keyBindings[i] == 'string') {
+                        this.options.keyBindings[i] = this.options.keyBindings[i].toUpperCase().charCodeAt(0);
+                    }
+                }
+            } else {
+                this.options.keyBindings = {};
+            }
+
+            for (i in keys) {
+                this.options.keyBindings[i] = this.options.keyBindings[i] || keys[i];
+            }
+
+            utils.addEvent(window, 'keydown', this);
+
+            this.on('destroy', function () {
+                utils.removeEvent(window, 'keydown', this);
+            });
+        },
+
+        _key: function (e) {
+            if (!this.enabled) {
+                return;
+            }
+
+            var snap = this.options.snap; // we are using this alot, better to cache it
+            var newX = snap ? this.currentPage.pageX : this.x;
+            var newY = snap ? this.currentPage.pageY : this.y;
+            var now = utils.getTime();
+            var prevTime = this.keyTime || 0;
+            var acceleration = 0.25;
+            var pos;
+
+            if (this.options.useTransition && this.isInTransition) {
+                pos = this.getComputedPosition();
+
+                this._translate(Math.round(pos.x), Math.round(pos.y));
+                this.isInTransition = false;
+            }
+
+            this.keyAcceleration = now - prevTime < 200 ? Math.min(this.keyAcceleration + acceleration, 50) : 0;
+
+            switch (e.keyCode) {
+                case this.options.keyBindings.pageUp:
+                    if (this.hasHorizontalScroll && !this.hasVerticalScroll) {
+                        newX += snap ? 1 : this.wrapperWidth;
+                    } else {
+                        newY += snap ? 1 : this.wrapperHeight;
+                    }
+                    break;
+                case this.options.keyBindings.pageDown:
+                    if (this.hasHorizontalScroll && !this.hasVerticalScroll) {
+                        newX -= snap ? 1 : this.wrapperWidth;
+                    } else {
+                        newY -= snap ? 1 : this.wrapperHeight;
+                    }
+                    break;
+                case this.options.keyBindings.end:
+                    newX = snap ? this.pages.length - 1 : this.maxScrollX;
+                    newY = snap ? this.pages[0].length - 1 : this.maxScrollY;
+                    break;
+                case this.options.keyBindings.home:
+                    newX = 0;
+                    newY = 0;
+                    break;
+                case this.options.keyBindings.left:
+                    newX += snap ? -1 : (5 + this.keyAcceleration) >> 0;
+                    break;
+                case this.options.keyBindings.up:
+                    newY += snap ? 1 : (5 + this.keyAcceleration) >> 0;
+                    break;
+                case this.options.keyBindings.right:
+                    newX -= snap ? -1 : (5 + this.keyAcceleration) >> 0;
+                    break;
+                case this.options.keyBindings.down:
+                    newY -= snap ? 1 : (5 + this.keyAcceleration) >> 0;
+                    break;
+                default:
+                    return;
+            }
+
+            if (snap) {
+                this.goToPage(newX, newY);
+                return;
+            }
+
+            if (newX > 0) {
+                newX = 0;
+                this.keyAcceleration = 0;
+            } else if (newX < this.maxScrollX) {
+                newX = this.maxScrollX;
+                this.keyAcceleration = 0;
+            }
+
+            if (newY > 0) {
+                newY = 0;
+                this.keyAcceleration = 0;
+            } else if (newY < this.maxScrollY) {
+                newY = this.maxScrollY;
+                this.keyAcceleration = 0;
+            }
+
+            this.scrollTo(newX, newY, 0);
+
+            this.keyTime = now;
+        },
+
+        _animate: function (destX, destY, duration, easingFn) {
+            var that = this;
+            var startX = this.x;
+            var startY = this.y;
+            var startTime = utils.getTime();
+            var destTime = startTime + duration;
+
+            function step() {
+                var now = utils.getTime();
+                var newX;
+                var newY;
+                var easing;
+
+                if (now >= destTime) {
+                    that.isAnimating = false;
+                    that._translate(destX, destY);
+
+                    if (!that.resetPosition(that.options.bounceTime)) {
+                        that._execEvent('scrollEnd');
+                    }
+
+                    return;
+                }
+
+                now = (now - startTime) / duration;
+                easing = easingFn(now);
+                newX = (destX - startX) * easing + startX;
+                newY = (destY - startY) * easing + startY;
+                that._translate(newX, newY);
+
+                if (that.isAnimating) {
+                    rAF(step);
+                }
+            }
+
+            this.isAnimating = true;
+            step();
+        },
+        handleEvent: function (e) {
+            switch (e.type) {
+                case 'touchstart':
+                case 'pointerdown':
+                case 'MSPointerDown':
+                case 'mousedown':
+                    this._start(e);
+
+                    if (this.options.zoom && e.touches && e.touches.length > 1) {
+                        this._zoomStart(e);
+                    }
+                    break;
+                case 'touchmove':
+                case 'pointermove':
+                case 'MSPointerMove':
+                case 'mousemove':
+                    if (this.options.zoom && e.touches && e.touches[1]) {
+                        this._zoom(e);
+                        return;
+                    }
+                    this._move(e);
+                    break;
+                case 'touchend':
+                case 'pointerup':
+                case 'MSPointerUp':
+                case 'mouseup':
+                case 'touchcancel':
+                case 'pointercancel':
+                case 'MSPointerCancel':
+                case 'mousecancel':
+                    if (this.scaled) {
+                        this._zoomEnd(e);
+                        return;
+                    }
+                    this._end(e);
+                    break;
+                case 'orientationchange':
+                case 'resize':
+                    this._resize();
+                    break;
+                case 'transitionend':
+                case 'webkitTransitionEnd':
+                case 'oTransitionEnd':
+                case 'MSTransitionEnd':
+                    this._transitionEnd(e);
+                    break;
+                case 'wheel':
+                case 'DOMMouseScroll':
+                case 'mousewheel':
+                    if (this.options.wheelAction == 'zoom') {
+                        this._wheelZoom(e);
+                        return;
+                    }
+                    this._wheel(e);
+                    break;
+                case 'keydown':
+                    this._key(e);
+                    break;
+            }
+        },
+    };
+    function createDefaultScrollbar(direction, interactive, type) {
+        var scrollbar = document.createElement('div');
+        var indicator = document.createElement('div');
+
+        if (type === true) {
+            scrollbar.style.cssText = 'position:absolute;z-index:9999';
+            indicator.style.cssText =
+                '-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;position:absolute;background:rgba(0,0,0,0.5);border:1px solid rgba(255,255,255,0.9);border-radius:3px';
+        }
+
+        indicator.className = 'iScrollIndicator';
+
+        if (direction == 'h') {
+            if (type === true) {
+                scrollbar.style.cssText += ';height:7px;left:2px;right:2px;bottom:0';
+                indicator.style.height = '100%';
+            }
+            scrollbar.className = 'iScrollHorizontalScrollbar';
+        } else {
+            if (type === true) {
+                scrollbar.style.cssText += ';width:7px;bottom:2px;top:2px;right:1px';
+                indicator.style.width = '100%';
+            }
+            scrollbar.className = 'iScrollVerticalScrollbar';
+        }
+
+        scrollbar.style.cssText += ';overflow:hidden';
+
+        if (!interactive) {
+            scrollbar.style.pointerEvents = 'none';
+        }
+
+        scrollbar.appendChild(indicator);
+
+        return scrollbar;
+    }
+
+    function Indicator(scroller, options) {
+        this.wrapper = typeof options.el == 'string' ? document.querySelector(options.el) : options.el;
+        this.wrapperStyle = this.wrapper.style;
+        this.indicator = this.wrapper.children[0];
+        this.indicatorStyle = this.indicator.style;
+        this.scroller = scroller;
+
+        this.options = {
+            listenX: true,
+            listenY: true,
+            interactive: false,
+            resize: true,
+            defaultScrollbars: false,
+            shrink: false,
+            fade: false,
+            speedRatioX: 0,
+            speedRatioY: 0,
+        };
+
+        for (var i in options) {
+            this.options[i] = options[i];
+        }
+
+        this.sizeRatioX = 1;
+        this.sizeRatioY = 1;
+        this.maxPosX = 0;
+        this.maxPosY = 0;
+
+        if (this.options.interactive) {
+            if (!this.options.disableTouch) {
+                utils.addEvent(this.indicator, 'touchstart', this);
+                utils.addEvent(window, 'touchend', this);
+            }
+            if (!this.options.disablePointer) {
+                utils.addEvent(this.indicator, utils.prefixPointerEvent('pointerdown'), this);
+                utils.addEvent(window, utils.prefixPointerEvent('pointerup'), this);
+            }
+            if (!this.options.disableMouse) {
+                utils.addEvent(this.indicator, 'mousedown', this);
+                utils.addEvent(window, 'mouseup', this);
+            }
+        }
+
+        if (this.options.fade) {
+            this.wrapperStyle[utils.style.transform] = this.scroller.translateZ;
+            var durationProp = utils.style.transitionDuration;
+            if (!durationProp) {
+                return;
+            }
+            this.wrapperStyle[durationProp] = utils.isBadAndroid ? '0.0001ms' : '0ms';
+            // remove 0.0001ms
+            var self = this;
+            if (utils.isBadAndroid) {
+                rAF(function () {
+                    if (self.wrapperStyle[durationProp] === '0.0001ms') {
+                        self.wrapperStyle[durationProp] = '0s';
+                    }
+                });
+            }
+            this.wrapperStyle.opacity = '0';
+        }
+    }
+
+    Indicator.prototype = {
+        handleEvent: function (e) {
+            switch (e.type) {
+                case 'touchstart':
+                case 'pointerdown':
+                case 'MSPointerDown':
+                case 'mousedown':
+                    this._start(e);
+                    break;
+                case 'touchmove':
+                case 'pointermove':
+                case 'MSPointerMove':
+                case 'mousemove':
+                    this._move(e);
+                    break;
+                case 'touchend':
+                case 'pointerup':
+                case 'MSPointerUp':
+                case 'mouseup':
+                case 'touchcancel':
+                case 'pointercancel':
+                case 'MSPointerCancel':
+                case 'mousecancel':
+                    this._end(e);
+                    break;
+            }
+        },
+
+        destroy: function () {
+            if (this.options.fadeScrollbars) {
+                clearTimeout(this.fadeTimeout);
+                this.fadeTimeout = null;
+            }
+            if (this.options.interactive) {
+                utils.removeEvent(this.indicator, 'touchstart', this);
+                utils.removeEvent(this.indicator, utils.prefixPointerEvent('pointerdown'), this);
+                utils.removeEvent(this.indicator, 'mousedown', this);
+
+                utils.removeEvent(window, 'touchmove', this);
+                utils.removeEvent(window, utils.prefixPointerEvent('pointermove'), this);
+                utils.removeEvent(window, 'mousemove', this);
+
+                utils.removeEvent(window, 'touchend', this);
+                utils.removeEvent(window, utils.prefixPointerEvent('pointerup'), this);
+                utils.removeEvent(window, 'mouseup', this);
+            }
+
+            if (this.options.defaultScrollbars && this.wrapper.parentNode) {
+                this.wrapper.parentNode.removeChild(this.wrapper);
+            }
+        },
+
+        _start: function (e) {
+            var point = e.touches ? e.touches[0] : e;
+
+            e.preventDefault();
+            e.stopPropagation();
+
+            this.transitionTime();
+
+            this.initiated = true;
+            this.moved = false;
+            this.lastPointX = point.pageX;
+            this.lastPointY = point.pageY;
+
+            this.startTime = utils.getTime();
+
+            if (!this.options.disableTouch) {
+                utils.addEvent(window, 'touchmove', this);
+            }
+            if (!this.options.disablePointer) {
+                utils.addEvent(window, utils.prefixPointerEvent('pointermove'), this);
+            }
+            if (!this.options.disableMouse) {
+                utils.addEvent(window, 'mousemove', this);
+            }
+
+            this.scroller._execEvent('beforeScrollStart');
+        },
+
+        _move: function (e) {
+            var point = e.touches ? e.touches[0] : e;
+            var deltaX;
+            var deltaY;
+            var newX;
+            var newY;
+            var timestamp = utils.getTime();
+
+            if (!this.moved) {
+                this.scroller._execEvent('scrollStart');
+            }
+
+            this.moved = true;
+
+            deltaX = point.pageX - this.lastPointX;
+            this.lastPointX = point.pageX;
+
+            deltaY = point.pageY - this.lastPointY;
+            this.lastPointY = point.pageY;
+
+            newX = this.x + deltaX;
+            newY = this.y + deltaY;
+
+            this._pos(newX, newY);
+
+            // INSERT POINT: indicator._move
+
+            e.preventDefault();
+            e.stopPropagation();
+        },
+
+        _end: function (e) {
+            if (!this.initiated) {
+                return;
+            }
+
+            this.initiated = false;
+
+            e.preventDefault();
+            e.stopPropagation();
+
+            utils.removeEvent(window, 'touchmove', this);
+            utils.removeEvent(window, utils.prefixPointerEvent('pointermove'), this);
+            utils.removeEvent(window, 'mousemove', this);
+
+            if (this.scroller.options.snap) {
+                var snap = this.scroller._nearestSnap(this.scroller.x, this.scroller.y);
+
+                var time =
+                    this.options.snapSpeed ||
+                    Math.max(
+                        Math.max(
+                            Math.min(Math.abs(this.scroller.x - snap.x), 1000),
+                            Math.min(Math.abs(this.scroller.y - snap.y), 1000)
+                        ),
+                        300
+                    );
+
+                if (this.scroller.x != snap.x || this.scroller.y != snap.y) {
+                    this.scroller.directionX = 0;
+                    this.scroller.directionY = 0;
+                    this.scroller.currentPage = snap;
+                    this.scroller.scrollTo(snap.x, snap.y, time, this.scroller.options.bounceEasing);
+                }
+            }
+
+            if (this.moved) {
+                this.scroller._execEvent('scrollEnd');
+            }
+        },
+
+        transitionTime: function (time) {
+            time = time || 0;
+            var durationProp = utils.style.transitionDuration;
+            if (!durationProp) {
+                return;
+            }
+
+            this.indicatorStyle[durationProp] = time + 'ms';
+
+            if (!time && utils.isBadAndroid) {
+                this.indicatorStyle[durationProp] = '0.0001ms';
+                // remove 0.0001ms
+                var self = this;
+                rAF(function () {
+                    if (self.indicatorStyle[durationProp] === '0.0001ms') {
+                        self.indicatorStyle[durationProp] = '0s';
+                    }
+                });
+            }
+        },
+
+        transitionTimingFunction: function (easing) {
+            this.indicatorStyle[utils.style.transitionTimingFunction] = easing;
+        },
+
+        refresh: function () {
+            this.transitionTime();
+
+            if (this.options.listenX && !this.options.listenY) {
+                this.indicatorStyle.display = this.scroller.hasHorizontalScroll ? 'block' : 'none';
+            } else if (this.options.listenY && !this.options.listenX) {
+                this.indicatorStyle.display = this.scroller.hasVerticalScroll ? 'block' : 'none';
+            } else {
+                this.indicatorStyle.display =
+                    this.scroller.hasHorizontalScroll || this.scroller.hasVerticalScroll ? 'block' : 'none';
+            }
+
+            if (this.scroller.hasHorizontalScroll && this.scroller.hasVerticalScroll) {
+                utils.addClass(this.wrapper, 'iScrollBothScrollbars');
+                utils.removeClass(this.wrapper, 'iScrollLoneScrollbar');
+
+                if (this.options.defaultScrollbars && this.options.customStyle) {
+                    if (this.options.listenX) {
+                        this.wrapper.style.right = '8px';
+                    } else {
+                        this.wrapper.style.bottom = '8px';
+                    }
+                }
+            } else {
+                utils.removeClass(this.wrapper, 'iScrollBothScrollbars');
+                utils.addClass(this.wrapper, 'iScrollLoneScrollbar');
+
+                if (this.options.defaultScrollbars && this.options.customStyle) {
+                    if (this.options.listenX) {
+                        this.wrapper.style.right = '2px';
+                    } else {
+                        this.wrapper.style.bottom = '2px';
+                    }
+                }
+            }
+
+            utils.getRect(this.wrapper); // force refresh
+
+            if (this.options.listenX) {
+                this.wrapperWidth = this.wrapper.clientWidth;
+                if (this.options.resize) {
+                    this.indicatorWidth = Math.max(
+                        Math.round(
+                            (this.wrapperWidth * this.wrapperWidth) /
+                                (this.scroller.scrollerWidth || this.wrapperWidth || 1)
+                        ),
+                        8
+                    );
+                    this.indicatorStyle.width = this.indicatorWidth + 'px';
+                } else {
+                    this.indicatorWidth = this.indicator.clientWidth;
+                }
+
+                this.maxPosX = this.wrapperWidth - this.indicatorWidth;
+
+                if (this.options.shrink == 'clip') {
+                    this.minBoundaryX = -this.indicatorWidth + 8;
+                    this.maxBoundaryX = this.wrapperWidth - 8;
+                } else {
+                    this.minBoundaryX = 0;
+                    this.maxBoundaryX = this.maxPosX;
+                }
+
+                this.sizeRatioX =
+                    this.options.speedRatioX || (this.scroller.maxScrollX && this.maxPosX / this.scroller.maxScrollX);
+            }
+
+            if (this.options.listenY) {
+                this.wrapperHeight = this.wrapper.clientHeight;
+                if (this.options.resize) {
+                    this.indicatorHeight = Math.max(
+                        Math.round(
+                            (this.wrapperHeight * this.wrapperHeight) /
+                                (this.scroller.scrollerHeight || this.wrapperHeight || 1)
+                        ),
+                        8
+                    );
+                    this.indicatorStyle.height = this.indicatorHeight + 'px';
+                } else {
+                    this.indicatorHeight = this.indicator.clientHeight;
+                }
+
+                this.maxPosY = this.wrapperHeight - this.indicatorHeight;
+
+                if (this.options.shrink == 'clip') {
+                    this.minBoundaryY = -this.indicatorHeight + 8;
+                    this.maxBoundaryY = this.wrapperHeight - 8;
+                } else {
+                    this.minBoundaryY = 0;
+                    this.maxBoundaryY = this.maxPosY;
+                }
+
+                this.maxPosY = this.wrapperHeight - this.indicatorHeight;
+                this.sizeRatioY =
+                    this.options.speedRatioY || (this.scroller.maxScrollY && this.maxPosY / this.scroller.maxScrollY);
+            }
+
+            this.updatePosition();
+        },
+
+        updatePosition: function () {
+            var x = (this.options.listenX && Math.round(this.sizeRatioX * this.scroller.x)) || 0;
+            var y = (this.options.listenY && Math.round(this.sizeRatioY * this.scroller.y)) || 0;
+
+            if (!this.options.ignoreBoundaries) {
+                if (x < this.minBoundaryX) {
+                    if (this.options.shrink == 'scale') {
+                        this.width = Math.max(this.indicatorWidth + x, 8);
+                        this.indicatorStyle.width = this.width + 'px';
+                    }
+                    x = this.minBoundaryX;
+                } else if (x > this.maxBoundaryX) {
+                    if (this.options.shrink == 'scale') {
+                        this.width = Math.max(this.indicatorWidth - (x - this.maxPosX), 8);
+                        this.indicatorStyle.width = this.width + 'px';
+                        x = this.maxPosX + this.indicatorWidth - this.width;
+                    } else {
+                        x = this.maxBoundaryX;
+                    }
+                } else if (this.options.shrink == 'scale' && this.width != this.indicatorWidth) {
+                    this.width = this.indicatorWidth;
+                    this.indicatorStyle.width = this.width + 'px';
+                }
+
+                if (y < this.minBoundaryY) {
+                    if (this.options.shrink == 'scale') {
+                        this.height = Math.max(this.indicatorHeight + y * 3, 8);
+                        this.indicatorStyle.height = this.height + 'px';
+                    }
+                    y = this.minBoundaryY;
+                } else if (y > this.maxBoundaryY) {
+                    if (this.options.shrink == 'scale') {
+                        this.height = Math.max(this.indicatorHeight - (y - this.maxPosY) * 3, 8);
+                        this.indicatorStyle.height = this.height + 'px';
+                        y = this.maxPosY + this.indicatorHeight - this.height;
+                    } else {
+                        y = this.maxBoundaryY;
+                    }
+                } else if (this.options.shrink == 'scale' && this.height != this.indicatorHeight) {
+                    this.height = this.indicatorHeight;
+                    this.indicatorStyle.height = this.height + 'px';
+                }
+            }
+
+            this.x = x;
+            this.y = y;
+
+            if (this.scroller.options.useTransform) {
+                this.indicatorStyle[utils.style.transform] =
+                    'translate(' + x + 'px,' + y + 'px)' + this.scroller.translateZ;
+            } else {
+                this.indicatorStyle.left = x + 'px';
+                this.indicatorStyle.top = y + 'px';
+            }
+        },
+
+        _pos: function (x, y) {
+            if (x < 0) {
+                x = 0;
+            } else if (x > this.maxPosX) {
+                x = this.maxPosX;
+            }
+
+            if (y < 0) {
+                y = 0;
+            } else if (y > this.maxPosY) {
+                y = this.maxPosY;
+            }
+
+            x = this.options.listenX ? Math.round(x / this.sizeRatioX) : this.scroller.x;
+            y = this.options.listenY ? Math.round(y / this.sizeRatioY) : this.scroller.y;
+
+            this.scroller.scrollTo(x, y);
+        },
+
+        fade: function (val, hold) {
+            if (hold && !this.visible) {
+                return;
+            }
+
+            clearTimeout(this.fadeTimeout);
+            this.fadeTimeout = null;
+
+            var time = val ? 250 : 500;
+            var delay = val ? 0 : 300;
+
+            val = val ? '1' : '0';
+
+            this.wrapperStyle[utils.style.transitionDuration] = time + 'ms';
+
+            this.fadeTimeout = setTimeout(
+                function (val) {
+                    this.wrapperStyle.opacity = val;
+                    this.visible = +val;
+                }.bind(this, val),
+                delay
+            );
+        },
+    };
+
+    IScroll.utils = utils;
+
+    if (typeof module != 'undefined' && module.exports) {
+        module.exports = IScroll;
+    } else if (typeof define == 'function' && define.amd) {
+        define(function () {
+            return IScroll;
+        });
+    } else {
+        window.IScroll = IScroll;
+    }
+
+    window.FLIPBOOK = window.FLIPBOOK || {};
+    window.FLIPBOOK.IScroll = IScroll;
+
+    window.PointerEvent = undefined;
+
+    // var oldEPD = Event.prototype.preventDefault;
+    // Event.prototype.preventDefault = function() {
+    //     debugger;
+    //     oldEPD.call(this);
+    // };
+})(window, document, Math);

mark.js

@@ -0,0 +1,1464 @@
+/*
+ * Real3D FlipBook [https://real3dflipbook.com]
+ * @author creativeinteractivemedia [https://codecanyon.net/user/creativeinteractivemedia/portfolio]
+ * @version 4.10
+ * @date 2025-05-15
+ */
+/*!***************************************************
+ * mark.js v9.0.0
+ * https://markjs.io/
+ * Copyright (c) 2014–2018, Julian Kühnel
+ * Released under the MIT license https://git.io/vwTVl
+ *****************************************************/
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined'
+        ? (module.exports = factory())
+        : typeof define === 'function' && define.amd
+          ? define(factory)
+          : (global.Mark = factory());
+})(this, function () {
+    'use strict';
+
+    function _typeof(obj) {
+        if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') {
+            _typeof = function (obj) {
+                return typeof obj;
+            };
+        } else {
+            _typeof = function (obj) {
+                return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype
+                    ? 'symbol'
+                    : typeof obj;
+            };
+        }
+
+        return _typeof(obj);
+    }
+
+    function _classCallCheck(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 _createClass(Constructor, protoProps, staticProps) {
+        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) _defineProperties(Constructor, staticProps);
+        return Constructor;
+    }
+
+    function _extends() {
+        _extends =
+            Object.assign ||
+            function (target) {
+                for (var i = 1; i < arguments.length; i++) {
+                    var source = arguments[i];
+
+                    for (var key in source) {
+                        if (Object.prototype.hasOwnProperty.call(source, key)) {
+                            target[key] = source[key];
+                        }
+                    }
+                }
+
+                return target;
+            };
+
+        return _extends.apply(this, arguments);
+    }
+
+    var DOMIterator =
+        /*#__PURE__*/
+        (function () {
+            function DOMIterator(ctx) {
+                var iframes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+                var exclude = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+                var iframesTimeout = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 5000;
+
+                _classCallCheck(this, DOMIterator);
+
+                this.ctx = ctx;
+                this.iframes = iframes;
+                this.exclude = exclude;
+                this.iframesTimeout = iframesTimeout;
+            }
+
+            _createClass(
+                DOMIterator,
+                [
+                    {
+                        key: 'getContexts',
+                        value: function getContexts() {
+                            var ctx,
+                                filteredCtx = [];
+
+                            if (typeof this.ctx === 'undefined' || !this.ctx) {
+                                ctx = [];
+                            } else if (NodeList.prototype.isPrototypeOf(this.ctx)) {
+                                ctx = Array.prototype.slice.call(this.ctx);
+                            } else if (Array.isArray(this.ctx)) {
+                                ctx = this.ctx;
+                            } else if (typeof this.ctx === 'string') {
+                                ctx = Array.prototype.slice.call(document.querySelectorAll(this.ctx));
+                            } else {
+                                ctx = [this.ctx];
+                            }
+
+                            ctx.forEach(function (ctx) {
+                                var isDescendant =
+                                    filteredCtx.filter(function (contexts) {
+                                        return contexts.contains(ctx);
+                                    }).length > 0;
+
+                                if (filteredCtx.indexOf(ctx) === -1 && !isDescendant) {
+                                    filteredCtx.push(ctx);
+                                }
+                            });
+                            return filteredCtx;
+                        },
+                    },
+                    {
+                        key: 'getIframeContents',
+                        value: function getIframeContents(ifr, successFn) {
+                            var errorFn =
+                                arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
+                            var doc;
+
+                            try {
+                                var ifrWin = ifr.contentWindow;
+                                doc = ifrWin.document;
+
+                                if (!ifrWin || !doc) {
+                                    throw new Error('iframe inaccessible');
+                                }
+                            } catch (e) {
+                                errorFn();
+                            }
+
+                            if (doc) {
+                                successFn(doc);
+                            }
+                        },
+                    },
+                    {
+                        key: 'isIframeBlank',
+                        value: function isIframeBlank(ifr) {
+                            var bl = 'about:blank',
+                                src = ifr.getAttribute('src').trim(),
+                                href = ifr.contentWindow.location.href;
+                            return href === bl && src !== bl && src;
+                        },
+                    },
+                    {
+                        key: 'observeIframeLoad',
+                        value: function observeIframeLoad(ifr, successFn, errorFn) {
+                            var _this = this;
+
+                            var called = false,
+                                tout = null;
+
+                            var listener = function listener() {
+                                if (called) {
+                                    return;
+                                }
+
+                                called = true;
+                                clearTimeout(tout);
+
+                                try {
+                                    if (!_this.isIframeBlank(ifr)) {
+                                        ifr.removeEventListener('load', listener);
+
+                                        _this.getIframeContents(ifr, successFn, errorFn);
+                                    }
+                                } catch (e) {
+                                    errorFn();
+                                }
+                            };
+
+                            ifr.addEventListener('load', listener);
+                            tout = setTimeout(listener, this.iframesTimeout);
+                        },
+                    },
+                    {
+                        key: 'onIframeReady',
+                        value: function onIframeReady(ifr, successFn, errorFn) {
+                            try {
+                                if (ifr.contentWindow.document.readyState === 'complete') {
+                                    if (this.isIframeBlank(ifr)) {
+                                        this.observeIframeLoad(ifr, successFn, errorFn);
+                                    } else {
+                                        this.getIframeContents(ifr, successFn, errorFn);
+                                    }
+                                } else {
+                                    this.observeIframeLoad(ifr, successFn, errorFn);
+                                }
+                            } catch (e) {
+                                errorFn();
+                            }
+                        },
+                    },
+                    {
+                        key: 'waitForIframes',
+                        value: function waitForIframes(ctx, done) {
+                            var _this2 = this;
+
+                            var eachCalled = 0;
+                            this.forEachIframe(
+                                ctx,
+                                function () {
+                                    return true;
+                                },
+                                function (ifr) {
+                                    eachCalled++;
+
+                                    _this2.waitForIframes(ifr.querySelector('html'), function () {
+                                        if (!--eachCalled) {
+                                            done();
+                                        }
+                                    });
+                                },
+                                function (handled) {
+                                    if (!handled) {
+                                        done();
+                                    }
+                                }
+                            );
+                        },
+                    },
+                    {
+                        key: 'forEachIframe',
+                        value: function forEachIframe(ctx, filter, each) {
+                            var _this3 = this;
+
+                            var end =
+                                arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {};
+                            var ifr = ctx.querySelectorAll('iframe'),
+                                open = ifr.length,
+                                handled = 0;
+                            ifr = Array.prototype.slice.call(ifr);
+
+                            var checkEnd = function checkEnd() {
+                                if (--open <= 0) {
+                                    end(handled);
+                                }
+                            };
+
+                            if (!open) {
+                                checkEnd();
+                            }
+
+                            ifr.forEach(function (ifr) {
+                                if (DOMIterator.matches(ifr, _this3.exclude)) {
+                                    checkEnd();
+                                } else {
+                                    _this3.onIframeReady(
+                                        ifr,
+                                        function (con) {
+                                            if (filter(ifr)) {
+                                                handled++;
+                                                each(con);
+                                            }
+
+                                            checkEnd();
+                                        },
+                                        checkEnd
+                                    );
+                                }
+                            });
+                        },
+                    },
+                    {
+                        key: 'createIterator',
+                        value: function createIterator(ctx, whatToShow, filter) {
+                            return document.createNodeIterator(ctx, whatToShow, filter, false);
+                        },
+                    },
+                    {
+                        key: 'createInstanceOnIframe',
+                        value: function createInstanceOnIframe(contents) {
+                            return new DOMIterator(contents.querySelector('html'), this.iframes);
+                        },
+                    },
+                    {
+                        key: 'compareNodeIframe',
+                        value: function compareNodeIframe(node, prevNode, ifr) {
+                            var compCurr = node.compareDocumentPosition(ifr),
+                                prev = Node.DOCUMENT_POSITION_PRECEDING;
+
+                            if (compCurr & prev) {
+                                if (prevNode !== null) {
+                                    var compPrev = prevNode.compareDocumentPosition(ifr),
+                                        after = Node.DOCUMENT_POSITION_FOLLOWING;
+
+                                    if (compPrev & after) {
+                                        return true;
+                                    }
+                                } else {
+                                    return true;
+                                }
+                            }
+
+                            return false;
+                        },
+                    },
+                    {
+                        key: 'getIteratorNode',
+                        value: function getIteratorNode(itr) {
+                            var prevNode = itr.previousNode();
+                            var node;
+
+                            if (prevNode === null) {
+                                node = itr.nextNode();
+                            } else {
+                                node = itr.nextNode() && itr.nextNode();
+                            }
+
+                            return {
+                                prevNode: prevNode,
+                                node: node,
+                            };
+                        },
+                    },
+                    {
+                        key: 'checkIframeFilter',
+                        value: function checkIframeFilter(node, prevNode, currIfr, ifr) {
+                            var key = false,
+                                handled = false;
+                            ifr.forEach(function (ifrDict, i) {
+                                if (ifrDict.val === currIfr) {
+                                    key = i;
+                                    handled = ifrDict.handled;
+                                }
+                            });
+
+                            if (this.compareNodeIframe(node, prevNode, currIfr)) {
+                                if (key === false && !handled) {
+                                    ifr.push({
+                                        val: currIfr,
+                                        handled: true,
+                                    });
+                                } else if (key !== false && !handled) {
+                                    ifr[key].handled = true;
+                                }
+
+                                return true;
+                            }
+
+                            if (key === false) {
+                                ifr.push({
+                                    val: currIfr,
+                                    handled: false,
+                                });
+                            }
+
+                            return false;
+                        },
+                    },
+                    {
+                        key: 'handleOpenIframes',
+                        value: function handleOpenIframes(ifr, whatToShow, eCb, fCb) {
+                            var _this4 = this;
+
+                            ifr.forEach(function (ifrDict) {
+                                if (!ifrDict.handled) {
+                                    _this4.getIframeContents(ifrDict.val, function (con) {
+                                        _this4.createInstanceOnIframe(con).forEachNode(whatToShow, eCb, fCb);
+                                    });
+                                }
+                            });
+                        },
+                    },
+                    {
+                        key: 'iterateThroughNodes',
+                        value: function iterateThroughNodes(whatToShow, ctx, eachCb, filterCb, doneCb) {
+                            var _this5 = this;
+
+                            var itr = this.createIterator(ctx, whatToShow, filterCb);
+
+                            var ifr = [],
+                                elements = [],
+                                node,
+                                prevNode,
+                                retrieveNodes = function retrieveNodes() {
+                                    var _this5$getIteratorNod = _this5.getIteratorNode(itr);
+
+                                    prevNode = _this5$getIteratorNod.prevNode;
+                                    node = _this5$getIteratorNod.node;
+                                    return node;
+                                };
+
+                            while (retrieveNodes()) {
+                                if (this.iframes) {
+                                    this.forEachIframe(
+                                        ctx,
+                                        function (currIfr) {
+                                            return _this5.checkIframeFilter(node, prevNode, currIfr, ifr);
+                                        },
+                                        function (con) {
+                                            _this5.createInstanceOnIframe(con).forEachNode(
+                                                whatToShow,
+                                                function (ifrNode) {
+                                                    return elements.push(ifrNode);
+                                                },
+                                                filterCb
+                                            );
+                                        }
+                                    );
+                                }
+
+                                elements.push(node);
+                            }
+
+                            elements.forEach(function (node) {
+                                eachCb(node);
+                            });
+
+                            if (this.iframes) {
+                                this.handleOpenIframes(ifr, whatToShow, eachCb, filterCb);
+                            }
+
+                            doneCb();
+                        },
+                    },
+                    {
+                        key: 'forEachNode',
+                        value: function forEachNode(whatToShow, each, filter) {
+                            var _this6 = this;
+
+                            var done =
+                                arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {};
+                            var contexts = this.getContexts();
+                            var open = contexts.length;
+
+                            if (!open) {
+                                done();
+                            }
+
+                            contexts.forEach(function (ctx) {
+                                var ready = function ready() {
+                                    _this6.iterateThroughNodes(whatToShow, ctx, each, filter, function () {
+                                        if (--open <= 0) {
+                                            done();
+                                        }
+                                    });
+                                };
+
+                                if (_this6.iframes) {
+                                    _this6.waitForIframes(ctx, ready);
+                                } else {
+                                    ready();
+                                }
+                            });
+                        },
+                    },
+                ],
+                [
+                    {
+                        key: 'matches',
+                        value: function matches(element, selector) {
+                            var selectors = typeof selector === 'string' ? [selector] : selector,
+                                fn =
+                                    element.matches ||
+                                    element.matchesSelector ||
+                                    element.msMatchesSelector ||
+                                    element.mozMatchesSelector ||
+                                    element.oMatchesSelector ||
+                                    element.webkitMatchesSelector;
+
+                            if (fn) {
+                                var match = false;
+                                selectors.every(function (sel) {
+                                    if (fn.call(element, sel)) {
+                                        match = true;
+                                        return false;
+                                    }
+
+                                    return true;
+                                });
+                                return match;
+                            } else {
+                                return false;
+                            }
+                        },
+                    },
+                ]
+            );
+
+            return DOMIterator;
+        })();
+
+    var RegExpCreator =
+        /*#__PURE__*/
+        (function () {
+            function RegExpCreator(options) {
+                _classCallCheck(this, RegExpCreator);
+
+                this.opt = _extends(
+                    {},
+                    {
+                        diacritics: true,
+                        synonyms: {},
+                        accuracy: 'partially',
+                        caseSensitive: false,
+                        ignoreJoiners: false,
+                        ignorePunctuation: [],
+                        wildcards: 'disabled',
+                    },
+                    options
+                );
+            }
+
+            _createClass(RegExpCreator, [
+                {
+                    key: 'create',
+                    value: function create(str) {
+                        if (this.opt.wildcards !== 'disabled') {
+                            str = this.setupWildcardsRegExp(str);
+                        }
+
+                        str = this.escapeStr(str);
+
+                        if (Object.keys(this.opt.synonyms).length) {
+                            str = this.createSynonymsRegExp(str);
+                        }
+
+                        if (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) {
+                            str = this.setupIgnoreJoinersRegExp(str);
+                        }
+
+                        if (this.opt.diacritics) {
+                            str = this.createDiacriticsRegExp(str);
+                        }
+
+                        str = this.createMergedBlanksRegExp(str);
+
+                        if (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) {
+                            str = this.createJoinersRegExp(str);
+                        }
+
+                        if (this.opt.wildcards !== 'disabled') {
+                            str = this.createWildcardsRegExp(str);
+                        }
+
+                        str = this.createAccuracyRegExp(str);
+                        return new RegExp(str, 'gm'.concat(this.opt.caseSensitive ? '' : 'i'));
+                    },
+                },
+                {
+                    key: 'sortByLength',
+                    value: function sortByLength(arry) {
+                        return arry.sort(function (a, b) {
+                            return a.length === b.length ? (a > b ? 1 : -1) : b.length - a.length;
+                        });
+                    },
+                },
+                {
+                    key: 'escapeStr',
+                    value: function escapeStr(str) {
+                        return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+                    },
+                },
+                {
+                    key: 'createSynonymsRegExp',
+                    value: function createSynonymsRegExp(str) {
+                        var _this = this;
+
+                        var syn = this.opt.synonyms,
+                            sens = this.opt.caseSensitive ? '' : 'i',
+                            joinerPlaceholder = this.opt.ignoreJoiners || this.opt.ignorePunctuation.length ? '\0' : '';
+
+                        for (var index in syn) {
+                            if (syn.hasOwnProperty(index)) {
+                                var keys = Array.isArray(syn[index]) ? syn[index] : [syn[index]];
+                                keys.unshift(index);
+                                keys = this.sortByLength(keys)
+                                    .map(function (key) {
+                                        if (_this.opt.wildcards !== 'disabled') {
+                                            key = _this.setupWildcardsRegExp(key);
+                                        }
+
+                                        key = _this.escapeStr(key);
+                                        return key;
+                                    })
+                                    .filter(function (k) {
+                                        return k !== '';
+                                    });
+
+                                if (keys.length > 1) {
+                                    str = str.replace(
+                                        new RegExp(
+                                            '('.concat(
+                                                keys
+                                                    .map(function (k) {
+                                                        return _this.escapeStr(k);
+                                                    })
+                                                    .join('|'),
+                                                ')'
+                                            ),
+                                            'gm'.concat(sens)
+                                        ),
+                                        joinerPlaceholder +
+                                            '('.concat(
+                                                keys
+                                                    .map(function (k) {
+                                                        return _this.processSynonyms(k);
+                                                    })
+                                                    .join('|'),
+                                                ')'
+                                            ) +
+                                            joinerPlaceholder
+                                    );
+                                }
+                            }
+                        }
+
+                        return str;
+                    },
+                },
+                {
+                    key: 'processSynonyms',
+                    value: function processSynonyms(str) {
+                        if (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) {
+                            str = this.setupIgnoreJoinersRegExp(str);
+                        }
+
+                        return str;
+                    },
+                },
+                {
+                    key: 'setupWildcardsRegExp',
+                    value: function setupWildcardsRegExp(str) {
+                        str = str.replace(/(?:\\)*\?/g, function (val) {
+                            return val.charAt(0) === '\\' ? '?' : '\x01';
+                        });
+                        return str.replace(/(?:\\)*\*/g, function (val) {
+                            return val.charAt(0) === '\\' ? '*' : '\x02';
+                        });
+                    },
+                },
+                {
+                    key: 'createWildcardsRegExp',
+                    value: function createWildcardsRegExp(str) {
+                        var spaces = this.opt.wildcards === 'withSpaces';
+                        return str
+                            .replace(/\u0001/g, spaces ? '[\\S\\s]?' : '\\S?')
+                            .replace(/\u0002/g, spaces ? '[\\S\\s]*?' : '\\S*');
+                    },
+                },
+                {
+                    key: 'setupIgnoreJoinersRegExp',
+                    value: function setupIgnoreJoinersRegExp(str) {
+                        return str.replace(/[^(|)\\]/g, function (val, indx, original) {
+                            var nextChar = original.charAt(indx + 1);
+
+                            if (/[(|)\\]/.test(nextChar) || nextChar === '') {
+                                return val;
+                            } else {
+                                return val + '\0';
+                            }
+                        });
+                    },
+                },
+                {
+                    key: 'createJoinersRegExp',
+                    value: function createJoinersRegExp(str) {
+                        var joiner = [];
+                        var ignorePunctuation = this.opt.ignorePunctuation;
+
+                        if (Array.isArray(ignorePunctuation) && ignorePunctuation.length) {
+                            joiner.push(this.escapeStr(ignorePunctuation.join('')));
+                        }
+
+                        if (this.opt.ignoreJoiners) {
+                            joiner.push('\\u00ad\\u200b\\u200c\\u200d');
+                        }
+
+                        return joiner.length ? str.split(/\u0000+/).join('['.concat(joiner.join(''), ']*')) : str;
+                    },
+                },
+                {
+                    key: 'createDiacriticsRegExp',
+                    value: function createDiacriticsRegExp(str) {
+                        var sens = this.opt.caseSensitive ? '' : 'i',
+                            dct = this.opt.caseSensitive
+                                ? [
+                                      'aàáảãạăằắẳẵặâầấẩẫậäåāą',
+                                      'AÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ',
+                                      'cçćč',
+                                      'CÇĆČ',
+                                      'dđď',
+                                      'DĐĎ',
+                                      'eèéẻẽẹêềếểễệëěēę',
+                                      'EÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ',
+                                      'iìíỉĩịîïī',
+                                      'IÌÍỈĨỊÎÏĪ',
+                                      'lł',
+                                      'LŁ',
+                                      'nñňń',
+                                      'NÑŇŃ',
+                                      'oòóỏõọôồốổỗộơởỡớờợöøō',
+                                      'OÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ',
+                                      'rř',
+                                      'RŘ',
+                                      'sšśșş',
+                                      'SŠŚȘŞ',
+                                      'tťțţ',
+                                      'TŤȚŢ',
+                                      'uùúủũụưừứửữựûüůū',
+                                      'UÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ',
+                                      'yýỳỷỹỵÿ',
+                                      'YÝỲỶỸỴŸ',
+                                      'zžżź',
+                                      'ZŽŻŹ',
+                                  ]
+                                : [
+                                      'aàáảãạăằắẳẵặâầấẩẫậäåāąAÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ',
+                                      'cçćčCÇĆČ',
+                                      'dđďDĐĎ',
+                                      'eèéẻẽẹêềếểễệëěēęEÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ',
+                                      'iìíỉĩịîïīIÌÍỈĨỊÎÏĪ',
+                                      'lłLŁ',
+                                      'nñňńNÑŇŃ',
+                                      'oòóỏõọôồốổỗộơởỡớờợöøōOÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ',
+                                      'rřRŘ',
+                                      'sšśșşSŠŚȘŞ',
+                                      'tťțţTŤȚŢ',
+                                      'uùúủũụưừứửữựûüůūUÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ',
+                                      'yýỳỷỹỵÿYÝỲỶỸỴŸ',
+                                      'zžżźZŽŻŹ',
+                                  ];
+                        var handled = [];
+                        str.split('').forEach(function (ch) {
+                            dct.every(function (dct) {
+                                if (dct.indexOf(ch) !== -1) {
+                                    if (handled.indexOf(dct) > -1) {
+                                        return false;
+                                    }
+
+                                    str = str.replace(
+                                        new RegExp('['.concat(dct, ']'), 'gm'.concat(sens)),
+                                        '['.concat(dct, ']')
+                                    );
+                                    handled.push(dct);
+                                }
+
+                                return true;
+                            });
+                        });
+                        return str;
+                    },
+                },
+                {
+                    key: 'createMergedBlanksRegExp',
+                    value: function createMergedBlanksRegExp(str) {
+                        return str.replace(/[\s]+/gim, '[\\s]+');
+                    },
+                },
+                {
+                    key: 'createAccuracyRegExp',
+                    value: function createAccuracyRegExp(str) {
+                        var _this2 = this;
+
+                        var chars = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~¡¿';
+                        var acc = this.opt.accuracy,
+                            val = typeof acc === 'string' ? acc : acc.value,
+                            ls = typeof acc === 'string' ? [] : acc.limiters,
+                            lsJoin = '';
+                        ls.forEach(function (limiter) {
+                            lsJoin += '|'.concat(_this2.escapeStr(limiter));
+                        });
+
+                        switch (val) {
+                            case 'partially':
+                            default:
+                                return '()('.concat(str, ')');
+
+                            case 'complementary':
+                                lsJoin = '\\s' + (lsJoin ? lsJoin : this.escapeStr(chars));
+                                return '()([^'.concat(lsJoin, ']*').concat(str, '[^').concat(lsJoin, ']*)');
+
+                            case 'exactly':
+                                return '(^|\\s'.concat(lsJoin, ')(').concat(str, ')(?=$|\\s').concat(lsJoin, ')');
+                        }
+                    },
+                },
+            ]);
+
+            return RegExpCreator;
+        })();
+
+    var Mark =
+        /*#__PURE__*/
+        (function () {
+            function Mark(ctx) {
+                _classCallCheck(this, Mark);
+
+                this.ctx = ctx;
+                this.ie = false;
+                var ua = window.navigator.userAgent;
+
+                if (ua.indexOf('MSIE') > -1 || ua.indexOf('Trident') > -1) {
+                    this.ie = true;
+                }
+            }
+
+            _createClass(Mark, [
+                {
+                    key: 'log',
+                    value: function log(msg) {
+                        var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'debug';
+                        var log = this.opt.log;
+
+                        if (!this.opt.debug) {
+                            return;
+                        }
+
+                        if (_typeof(log) === 'object' && typeof log[level] === 'function') {
+                            log[level]('mark.js: '.concat(msg));
+                        }
+                    },
+                },
+                {
+                    key: 'getSeparatedKeywords',
+                    value: function getSeparatedKeywords(sv) {
+                        var _this = this;
+
+                        var stack = [];
+                        sv.forEach(function (kw) {
+                            if (!_this.opt.separateWordSearch) {
+                                if (kw.trim() && stack.indexOf(kw) === -1) {
+                                    stack.push(kw);
+                                }
+                            } else {
+                                kw.split(' ').forEach(function (kwSplitted) {
+                                    if (kwSplitted.trim() && stack.indexOf(kwSplitted) === -1) {
+                                        stack.push(kwSplitted);
+                                    }
+                                });
+                            }
+                        });
+                        return {
+                            keywords: stack.sort(function (a, b) {
+                                return b.length - a.length;
+                            }),
+                            length: stack.length,
+                        };
+                    },
+                },
+                {
+                    key: 'isNumeric',
+                    value: function isNumeric(value) {
+                        return Number(parseFloat(value)) == value;
+                    },
+                },
+                {
+                    key: 'checkRanges',
+                    value: function checkRanges(array) {
+                        var _this2 = this;
+
+                        if (!Array.isArray(array) || Object.prototype.toString.call(array[0]) !== '[object Object]') {
+                            this.log('markRanges() will only accept an array of objects');
+                            this.opt.noMatch(array);
+                            return [];
+                        }
+
+                        var stack = [];
+                        var last = 0;
+                        array
+                            .sort(function (a, b) {
+                                return a.start - b.start;
+                            })
+                            .forEach(function (item) {
+                                var _this2$callNoMatchOnI = _this2.callNoMatchOnInvalidRanges(item, last),
+                                    start = _this2$callNoMatchOnI.start,
+                                    end = _this2$callNoMatchOnI.end,
+                                    valid = _this2$callNoMatchOnI.valid;
+
+                                if (valid) {
+                                    item.start = start;
+                                    item.length = end - start;
+                                    stack.push(item);
+                                    last = end;
+                                }
+                            });
+                        return stack;
+                    },
+                },
+                {
+                    key: 'callNoMatchOnInvalidRanges',
+                    value: function callNoMatchOnInvalidRanges(range, last) {
+                        var start,
+                            end,
+                            valid = false;
+
+                        if (range && typeof range.start !== 'undefined') {
+                            start = parseInt(range.start, 10);
+                            end = start + parseInt(range.length, 10);
+
+                            if (
+                                this.isNumeric(range.start) &&
+                                this.isNumeric(range.length) &&
+                                end - last > 0 &&
+                                end - start > 0
+                            ) {
+                                valid = true;
+                            } else {
+                                this.log('Ignoring invalid or overlapping range: ' + ''.concat(JSON.stringify(range)));
+                                this.opt.noMatch(range);
+                            }
+                        } else {
+                            this.log('Ignoring invalid range: '.concat(JSON.stringify(range)));
+                            this.opt.noMatch(range);
+                        }
+
+                        return {
+                            start: start,
+                            end: end,
+                            valid: valid,
+                        };
+                    },
+                },
+                {
+                    key: 'checkWhitespaceRanges',
+                    value: function checkWhitespaceRanges(range, originalLength, string) {
+                        var end,
+                            valid = true,
+                            max = string.length,
+                            offset = originalLength - max,
+                            start = parseInt(range.start, 10) - offset;
+                        start = start > max ? max : start;
+                        end = start + parseInt(range.length, 10);
+
+                        if (end > max) {
+                            end = max;
+                            this.log('End range automatically set to the max value of '.concat(max));
+                        }
+
+                        if (start < 0 || end - start < 0 || start > max || end > max) {
+                            valid = false;
+                            this.log('Invalid range: '.concat(JSON.stringify(range)));
+                            this.opt.noMatch(range);
+                        } else if (string.substring(start, end).replace(/\s+/g, '') === '') {
+                            valid = false;
+                            this.log('Skipping whitespace only range: ' + JSON.stringify(range));
+                            this.opt.noMatch(range);
+                        }
+
+                        return {
+                            start: start,
+                            end: end,
+                            valid: valid,
+                        };
+                    },
+                },
+                {
+                    key: 'getTextNodes',
+                    value: function getTextNodes(cb) {
+                        var _this3 = this;
+
+                        var val = '',
+                            nodes = [];
+                        this.iterator.forEachNode(
+                            NodeFilter.SHOW_TEXT,
+                            function (node) {
+                                nodes.push({
+                                    start: val.length,
+                                    end: (val += node.textContent).length,
+                                    node: node,
+                                });
+                            },
+                            function (node) {
+                                if (_this3.matchesExclude(node.parentNode)) {
+                                    return NodeFilter.FILTER_REJECT;
+                                } else {
+                                    return NodeFilter.FILTER_ACCEPT;
+                                }
+                            },
+                            function () {
+                                cb({
+                                    value: val,
+                                    nodes: nodes,
+                                });
+                            }
+                        );
+                    },
+                },
+                {
+                    key: 'matchesExclude',
+                    value: function matchesExclude(el) {
+                        return DOMIterator.matches(
+                            el,
+                            this.opt.exclude.concat(['script', 'style', 'title', 'head', 'html'])
+                        );
+                    },
+                },
+                {
+                    key: 'wrapRangeInTextNode',
+                    value: function wrapRangeInTextNode(node, start, end) {
+                        var hEl = !this.opt.element ? 'mark' : this.opt.element,
+                            startNode = node.splitText(start),
+                            ret = startNode.splitText(end - start);
+                        var repl = document.createElement(hEl);
+                        repl.setAttribute('data-markjs', 'true');
+
+                        if (this.opt.className) {
+                            repl.setAttribute('class', this.opt.className);
+                        }
+
+                        repl.textContent = startNode.textContent;
+                        startNode.parentNode.replaceChild(repl, startNode);
+                        return ret;
+                    },
+                },
+                {
+                    key: 'wrapRangeInMappedTextNode',
+                    value: function wrapRangeInMappedTextNode(dict, start, end, filterCb, eachCb) {
+                        var _this4 = this;
+
+                        dict.nodes.every(function (n, i) {
+                            var sibl = dict.nodes[i + 1];
+
+                            if (typeof sibl === 'undefined' || sibl.start > start) {
+                                if (!filterCb(n.node)) {
+                                    return false;
+                                }
+
+                                var s = start - n.start,
+                                    e = (end > n.end ? n.end : end) - n.start,
+                                    startStr = dict.value.substr(0, n.start),
+                                    endStr = dict.value.substr(e + n.start);
+                                n.node = _this4.wrapRangeInTextNode(n.node, s, e);
+                                dict.value = startStr + endStr;
+                                dict.nodes.forEach(function (k, j) {
+                                    if (j >= i) {
+                                        if (dict.nodes[j].start > 0 && j !== i) {
+                                            dict.nodes[j].start -= e;
+                                        }
+
+                                        dict.nodes[j].end -= e;
+                                    }
+                                });
+                                end -= e;
+                                eachCb(n.node.previousSibling, n.start);
+
+                                if (end > n.end) {
+                                    start = n.end;
+                                } else {
+                                    return false;
+                                }
+                            }
+
+                            return true;
+                        });
+                    },
+                },
+                {
+                    key: 'wrapGroups',
+                    value: function wrapGroups(node, pos, len, eachCb) {
+                        node = this.wrapRangeInTextNode(node, pos, pos + len);
+                        eachCb(node.previousSibling);
+                        return node;
+                    },
+                },
+                {
+                    key: 'separateGroups',
+                    value: function separateGroups(node, match, matchIdx, filterCb, eachCb) {
+                        var matchLen = match.length;
+
+                        for (var i = 1; i < matchLen; i++) {
+                            var pos = node.textContent.indexOf(match[i]);
+
+                            if (match[i] && pos > -1 && filterCb(match[i], node)) {
+                                node = this.wrapGroups(node, pos, match[i].length, eachCb);
+                            }
+                        }
+
+                        return node;
+                    },
+                },
+                {
+                    key: 'wrapMatches',
+                    value: function wrapMatches(regex, ignoreGroups, filterCb, eachCb, endCb) {
+                        var _this5 = this;
+
+                        var matchIdx = ignoreGroups === 0 ? 0 : ignoreGroups + 1;
+                        this.getTextNodes(function (dict) {
+                            dict.nodes.forEach(function (node) {
+                                node = node.node;
+                                var match;
+
+                                while ((match = regex.exec(node.textContent)) !== null && match[matchIdx] !== '') {
+                                    if (_this5.opt.separateGroups) {
+                                        node = _this5.separateGroups(node, match, matchIdx, filterCb, eachCb);
+                                    } else {
+                                        if (!filterCb(match[matchIdx], node)) {
+                                            continue;
+                                        }
+
+                                        var pos = match.index;
+
+                                        if (matchIdx !== 0) {
+                                            for (var i = 1; i < matchIdx; i++) {
+                                                pos += match[i].length;
+                                            }
+                                        }
+
+                                        node = _this5.wrapGroups(node, pos, match[matchIdx].length, eachCb);
+                                    }
+
+                                    regex.lastIndex = 0;
+                                }
+                            });
+                            endCb();
+                        });
+                    },
+                },
+                {
+                    key: 'wrapMatchesAcrossElements',
+                    value: function wrapMatchesAcrossElements(regex, ignoreGroups, filterCb, eachCb, endCb) {
+                        var _this6 = this;
+
+                        var matchIdx = ignoreGroups === 0 ? 0 : ignoreGroups + 1;
+                        this.getTextNodes(function (dict) {
+                            var match;
+
+                            while ((match = regex.exec(dict.value)) !== null && match[matchIdx] !== '') {
+                                var start = match.index;
+
+                                if (matchIdx !== 0) {
+                                    for (var i = 1; i < matchIdx; i++) {
+                                        start += match[i].length;
+                                    }
+                                }
+
+                                var end = start + match[matchIdx].length;
+
+                                _this6.wrapRangeInMappedTextNode(
+                                    dict,
+                                    start,
+                                    end,
+                                    function (node) {
+                                        return filterCb(match[matchIdx], node);
+                                    },
+                                    function (node, lastIndex) {
+                                        regex.lastIndex = lastIndex;
+                                        eachCb(node);
+                                    }
+                                );
+                            }
+
+                            endCb();
+                        });
+                    },
+                },
+                {
+                    key: 'wrapRangeFromIndex',
+                    value: function wrapRangeFromIndex(ranges, filterCb, eachCb, endCb) {
+                        var _this7 = this;
+
+                        this.getTextNodes(function (dict) {
+                            var originalLength = dict.value.length;
+                            ranges.forEach(function (range, counter) {
+                                var _this7$checkWhitespac = _this7.checkWhitespaceRanges(
+                                        range,
+                                        originalLength,
+                                        dict.value
+                                    ),
+                                    start = _this7$checkWhitespac.start,
+                                    end = _this7$checkWhitespac.end,
+                                    valid = _this7$checkWhitespac.valid;
+
+                                if (valid) {
+                                    _this7.wrapRangeInMappedTextNode(
+                                        dict,
+                                        start,
+                                        end,
+                                        function (node) {
+                                            return filterCb(node, range, dict.value.substring(start, end), counter);
+                                        },
+                                        function (node) {
+                                            eachCb(node, range);
+                                        }
+                                    );
+                                }
+                            });
+                            endCb();
+                        });
+                    },
+                },
+                {
+                    key: 'unwrapMatches',
+                    value: function unwrapMatches(node) {
+                        var parent = node.parentNode;
+                        var docFrag = document.createDocumentFragment();
+
+                        while (node.firstChild) {
+                            docFrag.appendChild(node.removeChild(node.firstChild));
+                        }
+
+                        parent.replaceChild(docFrag, node);
+
+                        if (!this.ie) {
+                            parent.normalize();
+                        } else {
+                            this.normalizeTextNode(parent);
+                        }
+                    },
+                },
+                {
+                    key: 'normalizeTextNode',
+                    value: function normalizeTextNode(node) {
+                        if (!node) {
+                            return;
+                        }
+
+                        if (node.nodeType === 3) {
+                            while (node.nextSibling && node.nextSibling.nodeType === 3) {
+                                node.nodeValue += node.nextSibling.nodeValue;
+                                node.parentNode.removeChild(node.nextSibling);
+                            }
+                        } else {
+                            this.normalizeTextNode(node.firstChild);
+                        }
+
+                        this.normalizeTextNode(node.nextSibling);
+                    },
+                },
+                {
+                    key: 'markRegExp',
+                    value: function markRegExp(regexp, opt) {
+                        var _this8 = this;
+
+                        this.opt = opt;
+                        this.log('Searching with expression "'.concat(regexp, '"'));
+                        var totalMatches = 0,
+                            fn = 'wrapMatches';
+
+                        var eachCb = function eachCb(element) {
+                            totalMatches++;
+
+                            _this8.opt.each(element);
+                        };
+
+                        if (this.opt.acrossElements) {
+                            fn = 'wrapMatchesAcrossElements';
+                        }
+
+                        this[fn](
+                            regexp,
+                            this.opt.ignoreGroups,
+                            function (match, node) {
+                                return _this8.opt.filter(node, match, totalMatches);
+                            },
+                            eachCb,
+                            function () {
+                                if (totalMatches === 0) {
+                                    _this8.opt.noMatch(regexp);
+                                }
+
+                                _this8.opt.done(totalMatches);
+                            }
+                        );
+                    },
+                },
+                {
+                    key: 'mark',
+                    value: function mark(sv, opt) {
+                        var _this9 = this;
+
+                        this.opt = opt;
+                        var totalMatches = 0,
+                            fn = 'wrapMatches';
+
+                        var _this$getSeparatedKey = this.getSeparatedKeywords(typeof sv === 'string' ? [sv] : sv),
+                            kwArr = _this$getSeparatedKey.keywords,
+                            kwArrLen = _this$getSeparatedKey.length,
+                            handler = function handler(kw) {
+                                var regex = new RegExpCreator(_this9.opt).create(kw);
+                                var matches = 0;
+
+                                _this9.log('Searching with expression "'.concat(regex, '"'));
+
+                                _this9[fn](
+                                    regex,
+                                    1,
+                                    function (term, node) {
+                                        return _this9.opt.filter(node, kw, totalMatches, matches);
+                                    },
+                                    function (element) {
+                                        matches++;
+                                        totalMatches++;
+
+                                        _this9.opt.each(element);
+                                    },
+                                    function () {
+                                        if (matches === 0) {
+                                            _this9.opt.noMatch(kw);
+                                        }
+
+                                        if (kwArr[kwArrLen - 1] === kw) {
+                                            _this9.opt.done(totalMatches);
+                                        } else {
+                                            handler(kwArr[kwArr.indexOf(kw) + 1]);
+                                        }
+                                    }
+                                );
+                            };
+
+                        if (this.opt.acrossElements) {
+                            fn = 'wrapMatchesAcrossElements';
+                        }
+
+                        if (kwArrLen === 0) {
+                            this.opt.done(totalMatches);
+                        } else {
+                            handler(kwArr[0]);
+                        }
+                    },
+                },
+                {
+                    key: 'markRanges',
+                    value: function markRanges(rawRanges, opt) {
+                        var _this10 = this;
+
+                        this.opt = opt;
+                        var totalMatches = 0,
+                            ranges = this.checkRanges(rawRanges);
+
+                        if (ranges && ranges.length) {
+                            this.log('Starting to mark with the following ranges: ' + JSON.stringify(ranges));
+                            this.wrapRangeFromIndex(
+                                ranges,
+                                function (node, range, match, counter) {
+                                    return _this10.opt.filter(node, range, match, counter);
+                                },
+                                function (element, range) {
+                                    totalMatches++;
+
+                                    _this10.opt.each(element, range);
+                                },
+                                function () {
+                                    _this10.opt.done(totalMatches);
+                                }
+                            );
+                        } else {
+                            this.opt.done(totalMatches);
+                        }
+                    },
+                },
+                {
+                    key: 'unmark',
+                    value: function unmark(opt) {
+                        var _this11 = this;
+
+                        this.opt = opt;
+                        var sel = this.opt.element ? this.opt.element : '*';
+                        sel += '[data-markjs]';
+
+                        if (this.opt.className) {
+                            sel += '.'.concat(this.opt.className);
+                        }
+
+                        this.log('Removal selector "'.concat(sel, '"'));
+                        this.iterator.forEachNode(
+                            NodeFilter.SHOW_ELEMENT,
+                            function (node) {
+                                _this11.unwrapMatches(node);
+                            },
+                            function (node) {
+                                var matchesSel = DOMIterator.matches(node, sel),
+                                    matchesExclude = _this11.matchesExclude(node);
+
+                                if (!matchesSel || matchesExclude) {
+                                    return NodeFilter.FILTER_REJECT;
+                                } else {
+                                    return NodeFilter.FILTER_ACCEPT;
+                                }
+                            },
+                            this.opt.done
+                        );
+                    },
+                },
+                {
+                    key: 'opt',
+                    set: function set(val) {
+                        this._opt = _extends(
+                            {},
+                            {
+                                element: '',
+                                className: '',
+                                exclude: [],
+                                iframes: false,
+                                iframesTimeout: 5000,
+                                separateWordSearch: true,
+                                acrossElements: false,
+                                ignoreGroups: 0,
+                                each: function each() {},
+                                noMatch: function noMatch() {},
+                                filter: function filter() {
+                                    return true;
+                                },
+                                done: function done() {},
+                                debug: false,
+                                log: window.console,
+                            },
+                            val
+                        );
+                    },
+                    get: function get() {
+                        return this._opt;
+                    },
+                },
+                {
+                    key: 'iterator',
+                    get: function get() {
+                        return new DOMIterator(this.ctx, this.opt.iframes, this.opt.exclude, this.opt.iframesTimeout);
+                    },
+                },
+            ]);
+
+            return Mark;
+        })();
+
+    function Mark$1(ctx) {
+        var _this = this;
+
+        var instance = new Mark(ctx);
+
+        this.mark = function (sv, opt) {
+            instance.mark(sv, opt);
+            return _this;
+        };
+
+        this.markRegExp = function (sv, opt) {
+            instance.markRegExp(sv, opt);
+            return _this;
+        };
+
+        this.markRanges = function (sv, opt) {
+            instance.markRanges(sv, opt);
+            return _this;
+        };
+
+        this.unmark = function (opt) {
+            instance.unmark(opt);
+            return _this;
+        };
+
+        return this;
+    }
+
+    return Mark$1;
+});

mod3d.js

@@ -0,0 +1,2520 @@
+/*
+ * Real3D FlipBook [https://real3dflipbook.com]
+ * @author creativeinteractivemedia [https://codecanyon.net/user/creativeinteractivemedia/portfolio]
+ * @version 4.10
+ * @date 2025-05-15
+ */
+/**
+*   MOD3 3D Modifier Library for JavaScript
+*   port of AS3DMod ActionScript3 library (http://code.google.com/p/as3dmod/)
+*
+*   @version 1.0.0 (2023-01-03 16:08:34)
+*   https://github.com/foo123/MOD3
+*
+**//**
+*   MOD3 3D Modifier Library for JavaScript
+*   port of AS3DMod ActionScript3 library (http://code.google.com/p/as3dmod/)
+*
+*   @version 1.0.0 (2023-01-03 16:08:34)
+*   https://github.com/foo123/MOD3
+*
+**/
+!function(root, name, factory) {
+"use strict";
+if (('object' === typeof module) && module.exports) /* CommonJS */
+    (module.$deps = module.$deps||{}) && (module.exports = module.$deps[name] = factory.call(root));
+else if (('function' === typeof define) && define.amd && ('function' === typeof require) && ('function' === typeof require.specified) && require.specified(name) /*&& !require.defined(name)*/) /* AMD */
+    define(name, ['module'], function(module) {factory.moduleUri = module.uri; return factory.call(root);});
+else if (!(name in root)) /* Browser/WebWorker/.. */
+    (root[name] = factory.call(root)||1) && ('function' === typeof(define)) && define.amd && define(function() {return root[name];});
+}(  /* current root */          'undefined' !== typeof self ? self : this,
+    /* module name */           "MOD3",
+    /* module factory */        function ModuleFactory__MOD3(undef) {
+"use strict";
+
+var HAS = Object.prototype.hasOwnProperty,
+    toString = Object.prototype.toString,
+    def = Object.defineProperty,
+    stdMath = Math, PI = stdMath.PI,
+    TWO_PI = 2*PI, HALF_PI = PI/2, INV_PI = 1/PI,
+    EMPTY_ARR = [], EMPTY_OBJ = {}, NOP = function() {},
+    isNode = ("undefined" !== typeof global) && ("[object global]" === toString.call(global)),
+    isBrowser = ("undefined" !== typeof window) && ("[object Window]" === toString.call(window))
+;
+
+// basic backwards-compatible "class" construction
+function makeSuper(superklass)
+{
+    var called = {};
+    return function $super(method, args) {
+        var self = this, m = ':'+method, ret;
+        if (1 === called[m]) return (superklass.prototype.$super || NOP).call(self, method, args);
+        called[m] = 1;
+        ret = ('constructor' === method ? superklass : (superklass.prototype[method] || NOP)).apply(self, args || []);
+        called[m] = 0;
+        return ret;
+    };
+}
+function makeClass(superklass, klass, statik)
+{
+    if (arguments.length < 2)
+    {
+        klass = superklass;
+        superklass = null;
+    }
+    var C = HAS.call(klass, 'constructor') ? klass.constructor : function() {}, p;
+    if (superklass)
+    {
+        C.prototype = Object.create(superklass.prototype);
+        C.prototype.$super = makeSuper(superklass);
+    }
+    else
+    {
+        C.prototype.$super = NOP;
+    }
+    C.prototype.constructor = C;
+    for (p in klass)
+    {
+        if (HAS.call(klass, p) && ('constructor' !== p))
+        {
+            C.prototype[p] = klass[p];
+        }
+    }
+    if (statik)
+    {
+        for (p in statik)
+        {
+            if (HAS.call(statik, p))
+            {
+                C[p] = statik[p];
+            }
+        }
+    }
+    return C;
+}
+var MOD3 = {
+    VERSION: "1.0.0",
+    Class: makeClass
+};
+/**
+* MOD3  Constants and Auxilliary methods
+**/
+MOD3.Constants = {
+    // cache math constants for reference and optimization
+    PI: PI,
+    invPI: INV_PI,
+    halfPI: HALF_PI,
+    doublePI: TWO_PI,
+    toRad: PI/180,
+    toDeg: 180/PI
+};
+MOD3.ModConstant = {
+    NONE: 0,
+    LEFT: -1,
+    RIGHT: 1,
+
+    X: 1,
+    Y: 2,
+    Z: 4,
+
+    Xi: 0,
+    Yi: 1,
+    Zi: 2
+};
+MOD3.XYZi = [
+    null,
+    0,
+    1,
+    null,
+    2
+];
+MOD3.iXYZ = [
+    1,
+    2,
+    4
+];
+MOD3.xyz = [
+    "x",
+    "y",
+    "z"
+];
+MOD3.XYZ = [
+    "X",
+    "Y",
+    "Z"
+];
+
+// Typed Arrays Substitutes
+MOD3.Array32F = typeof Float32Array !== "undefined" ? Float32Array : Array;
+MOD3.Array64F = typeof Float64Array !== "undefined" ? Float64Array : Array;
+MOD3.Array8I = typeof Int8Array !== "undefined" ? Int8Array : Array;
+MOD3.Array16I = typeof Int16Array !== "undefined" ? Int16Array : Array;
+MOD3.Array32I = typeof Int32Array !== "undefined" ? Int32Array : Array;
+MOD3.Array8U = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+MOD3.Array16U = typeof Uint16Array !== "undefined" ? Uint16Array : Array;
+MOD3.Array32U = typeof Uint32Array !== "undefined" ? Uint32Array : Array;
+// vector typed-array
+MOD3.VecArray = MOD3.Array32F;
+/**
+* MOD3  Math Utilities Class
+**/
+MOD3.XMath = {
+    normalize: function(start, end, val) {
+        var range = end - start;
+        return 0 === range ? 1 : MOD3.XMath.trim(0, 1, (val - start)/end);
+    },
+
+    toRange: function(start, end, normalized) {
+        var range = end - start;
+        return 0 === range ? 0 : (start + range*normalized);
+    },
+
+    inRange: function(start, end, value, excluding) {
+        return false !== excluding ? (value >= start && value <= end) : (value > start && value < end);
+    },
+
+    sign: function(val, ifZero) {
+        return 0 === val ? (ifZero || 0) : (val > 0 ? 1 : -1);
+    },
+
+    trim: function(start, end, value) {
+        return value < start ? start : (value > end ? end : value);
+    },
+
+    wrap: function(start, end, value) {
+        var r = end - start;
+        return value < start ? (value + r) : (value >= end ? value - r : value);
+    },
+
+    degToRad: function(deg) {
+        return deg/180*PI;
+    },
+
+    radToDeg: function(rad)  {
+        return rad/PI*180;
+    },
+
+    presicion: function(number, precision) {
+        var r = stdMath.pow(10, precision);
+        return stdMath.round(number*r)/r;
+    },
+
+    uceil: function(val) {
+        return val < 0 ? stdMath.floor(val) : stdMath.ceil(val);
+    }
+};
+// alias
+MOD3.XMath.clamp = MOD3.XMath.trim;
+/**
+* MOD3  Range Auxilliary Class
+**/
+MOD3.Range = MOD3.Class({
+    constructor: function Range(s, e)  {
+        var self = this;
+        if (!(self instanceof Range)) return new Range(s, e);
+        self.start = null != s ? s : 0;
+        self.end = null != e ? e : 1;
+    },
+
+    name: "Range",
+    start: 0,
+    end: 1,
+
+    dispose: function() {
+        var self = this;
+        self.start = null;
+        self.end = null;
+        return self;
+    },
+
+    getSize: function()  {
+        return this.end - this.start;
+    },
+
+    move: function(amount)  {
+        this.start += amount;
+        this.end += amount;
+    },
+
+    isIn: function(n) {
+        return (n >= this.start && n <= this.end);
+    },
+
+    normalize: function(n) {
+        return MOD3.XMath.normalize(this.start, this.end, n);
+    },
+
+    toRange: function(n) {
+        return MOD3.XMath.toRange(this.start, this.end, n);
+    },
+
+    trim: function(n) {
+        return MOD3.XMath.trim(this.start, this.end, n);
+    },
+
+    interpolate: function(n, r) {
+        return MOD3.XMath.toRange(this.start, this.end, r.normalize(n));
+    },
+
+    toString: function() {
+        return "[" + this.start + " - " + this.end + "]";
+    }
+});
+/**
+* MOD3  Phase Auxilliary Class
+**/
+MOD3.Phase = MOD3.Class({
+    constructor: function Phase(v) {
+        var self = this;
+        if (!(self instanceof Phase)) return new Phase(v);
+        self.value = v || 0;
+    },
+
+    name: "Phase",
+    value: 0,
+
+    dispose: function() {
+        this.value = null;
+        return this;
+    },
+
+    getPhasedValue: function()  {
+        return stdMath.sin(this.value);
+    },
+
+    getAbsPhasedValue: function()  {
+        return stdMath.abs(stdMath.sin(this.value));
+    },
+
+    getNormValue: function() {
+        return (stdMath.sin(this.value) + 1)*0.5;
+    }
+});
+/**
+* MOD3  2D Point Class
+**/
+MOD3.Point = MOD3.Class({
+    constructor: function Point(x, y) {
+        var self = this;
+        if (!(self instanceof Point)) return new Point(x, y);
+        self.x = x || 0;
+        self.y = y || 0;
+    },
+
+    name: "Point",
+    x: 0,
+    y: 0,
+
+    dispose: function() {
+        var self = this;
+        self.x = null;
+        self.y = null;
+        return self;
+    },
+
+    clone: function() {
+        return new MOD3.Point(this.x, this.y);
+    }
+});
+/**
+* MOD3  2D Transform Matrix Class
+**/
+MOD3.Matrix = MOD3.Class(null, {
+    constructor: function Matrix(m11, m12,
+                                 m21, m22)
+   {
+        var self = this;
+        if (!(self instanceof Matrix)) return new Matrix(m11, m12,
+                                                         m21, m22);
+        self.m = new MOD3.VecArray([
+            m11 == null ? 1 : m11,
+            m12 == null ? 0 : m12,
+            m21 == null ? 0 : m21,
+            m22 == null ? 1 : m22
+        ]);
+    },
+
+    name: "Matrix",
+    m: null,
+
+    dispose: function() {
+        this.m = null;
+        return this;
+    },
+
+    reset: function() {
+        var m = this.m;
+        m[0] = 1; m[1] = 0;
+        m[2] = 0; m[3] = 1;
+        return this;
+    },
+
+    rotate: function(angle)  {
+        var m = this.m, c = stdMath.cos(angle), s = stdMath.sin(angle);
+        m[0] = c; m[1] = -s;
+        m[2] = s; m[3] = c;
+        return this;
+    },
+
+    scale: function(sx, sy) {
+        var m = this.m;
+        m[0] = 1; m[1] = 0;
+        m[2] = 0; m[3] = 1;
+        if (sx != null)
+        {
+            m[0] = sx;
+            m[3] = sx;
+        }
+        if (sy != null)
+        {
+            m[3] = sy;
+        }
+        return this;
+    },
+
+    multiply: function(b) {
+        return MOD3.Matrix.mult(this, b);
+    },
+
+    transformPoint: function(p) {
+        var xy = MOD3.Matrix.transform(this, [p.x, p.y]);
+        return new MOD3.Point(xy[0], xy[1]);
+    },
+
+    transformPointSelf: function(p) {
+        var xy = MOD3.Matrix.transform(this, [p.x, p.y]);
+        p.x = xy[0]; p.y = xy[1];
+        return p;
+    },
+
+    clone: function() {
+        var m = this.m;
+        return new MOD3.Matrix(m[0], m[1],
+                          m[2], m[3]);
+    }
+}, {
+    transform: function(m2, xy) {
+        var m = m2.m, x = xy[0], y = xy[1];
+        xy[0] = m[0]*x + m[1]*y;
+        xy[1] = m[2]*x + m[3]*y;
+        return xy;
+    },
+
+    mult: function(m1, m2) {
+        var a = m1.m, b = m2.m, a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+        a[0] = a0*b[0] + a1*b[2];
+        a[1] = a0*b[1] + a1*b[3];
+        a[2] = a2*b[0] + a3*b[2];
+        a[3] = a2*b[1] + a3*b[3];
+        return m1;
+    }
+});
+/**
+* MOD3  Vector3 Class
+**/
+MOD3.Vector3 = MOD3.Class(null, {
+    constructor: function Vector3(x, y, z) {
+        var self = this;
+        if (!(self instanceof Vector3)) return new Vector3(x, y, z);
+
+        // use an internal typed-array for speed
+        var v = new MOD3.VecArray(3);
+        if (x && (3 === x.length))
+        {
+            // array passed
+            v[0] = x[0] || 0;
+            v[1] = x[1] || 0;
+            v[2] = x[2] || 0;
+        }
+        else
+        {
+            // numbers passed
+            v[0] = x || 0;
+            v[1] = y || 0;
+            v[2] = z || 0;
+        }
+        self.xyz = v;
+    },
+
+    name: "Vector3",
+    xyz: null,
+
+    dispose: function() {
+        this.xyz = null;
+        return this;
+    },
+
+    getXYZ: function() {
+       // copy it
+       return new MOD3.VecArray(this.xyz);
+    },
+
+    getXYZRef: function() {
+       return this.xyz;
+    },
+
+    setXYZ: function(w) {
+       var v = this.xyz;
+       v[0] = w[0];
+       v[1] = w[1];
+       v[2] = w[2];
+       return this;
+    },
+
+    setXYZRef: function(xyz) {
+       this.xyz = xyz;
+       return this;
+    },
+
+    clone: function() {
+        return new MOD3.Vector3(this.xyz);
+    },
+
+    equalsSelf: function(b) {
+        var v = this.xyz, w = b.xyz;
+        return (v[0] === w[0]) && (v[1] === w[1]) && (v[2] === w[2]);
+    },
+
+    zeroSelf: function() {
+        var v = this.xyz;
+        v[0] = 0; v[1] = 0; v[2] = 0;
+        return this;
+    },
+
+    negate: function() {
+        var v = this.xyz;
+        return new MOD3.Vector3(-v[0], -v[1], -v[2]);
+    },
+
+    negateSelf: function() {
+        var v = this.xyz;
+        v[0] = -v[0]; v[1] = -v[1]; v[2] = -v[2];
+        return this;
+    },
+
+    add: function(b) {
+        var v = this.xyz, w = b.xyz;
+        return new MOD3.Vector3(v[0] + w[0], v[1] + w[1], v[2] + w[2]);
+    },
+
+    addSelf: function(b) {
+        var v = this.xyz, w = b.xyz;
+        v[0] += w[0]; v[1] += w[1]; v[2] += w[2];
+        return this;
+    },
+
+    subtract: function(b) {
+        var v = this.xyz, w = b.xyz;
+        return new MOD3.Vector3(v[0] - w[0], v[1] - w[1], v[2] - w[2]);
+    },
+
+    subtractSelf: function(b) {
+        var v = this.xyz, w = b.xyz;
+        v[0] -= w[0]; v[1] -= w[1]; v[2] -= w[2];
+        return this;
+    },
+
+    multiplyScalar: function(s) {
+        var v = this.xyz;
+        return new MOD3.Vector3(v[0]*s, v[1]*s, v[2]*s);
+    },
+
+    multiplyScalarSelf: function(s) {
+        var v = this.xyz;
+        v[0] *= s; v[1] *= s; v[2] *= s;
+        return this;
+    },
+
+    multiply: function(b) {
+        var v = this.xyz, w = b.xyz;
+        return new MOD3.Vector3(v[0] * w[0], v[1] * w[1], v[2] * w[2]);
+    },
+
+    multiplySelf: function(b) {
+        var v = this.xyz, w = b.xyz;
+        v[0] *= w[0]; v[1] *= w[1]; v[2] *= w[2];
+        return this;
+    },
+
+    divide: function(s) {
+        var v = this.xyz;
+        return new MOD3.Vector3(v[0] / s, v[1] / s, v[2] / s);
+    },
+
+    divideSelf: function(s) {
+        var v = this.xyz;
+        v[0] /= s; v[1] /= s; v[2] /= s;
+        return this;
+    },
+
+    normalize: function() {
+        var v = this.xyz,
+            x = v[0], y = v[1], z = v[2],
+            m = x * x + y * y + z * z, n;
+        if (0 < m)
+        {
+            n = stdMath.sqrt(m);
+            x /= n;
+            y /= n;
+            z /= n;
+        }
+        return new MOD3.Vector3(x, y, z);
+    },
+
+    normalizeSelf: function() {
+        var v = this.xyz,
+            x = v[0], y = v[1], z = v[2],
+            m = x * x + y * y + z * z, n;
+        if (0 < m)
+        {
+            n = stdMath.sqrt(m);
+            x /= n;
+            y /= n;
+            z /= n;
+        }
+        v[0] = x; v[1] = y; v[2] = z;
+        return this;
+    },
+
+    getMagnitude: function() {
+        var v = this.xyz, x = v[0], y = v[1], z = v[2];
+        return stdMath.sqrt(x*x + y*y + z*z);
+    },
+
+    setMagnitude: function(m) {
+        this.normalizeSelf();
+        var v = this.xyz;
+        v[0] *= m; v[1] *= m; v[2] *= m;
+        return this;
+    },
+
+    dot: function(b) {
+        var v = this.xyz, w = b.xyz;
+        return v[0]*w[0] + v[1]*w[1] + v[2]*w[2];
+    },
+
+    cross: function(b) {
+        var v = this.xyz, w = b.xyz,
+            x1 = v[0], y1 = v[1], z1 = v[2],
+            x2 = w[0], y2 = w[1], z2 = w[2];
+        return new MOD3.Vector3(y1 * z2 - z1 * y2, z1 * x2 - x1 * z2, x1 * y2 - y1 * x2);
+    },
+
+    crossSelf: function(v) {
+        var v = this.xyz, w = b.xyz,
+            x1 = v[0], y1 = v[1], z1 = v[2],
+            x2 = w[0], y2 = w[1], z2 = w[2];
+        v[0] = y1 * z2 - z1 * y2;
+        v[1] = z1 * x2 - x1 * z2;
+        v[2] = x1 * y2 - y1 * x2;
+        return this;
+    },
+
+    distance: function(b) {
+        var v = this.xyz, w = b.xyz,
+            dx = v[0] - w[0],
+            dy = v[1] - w[1],
+            dz = v[2] - w[2];
+        return stdMath.sqrt(dx*dx + dy*dy + dz*dz);
+    },
+
+    toString: function() {
+        var v = this.xyz;
+        return "[" + v[0] + " , " + v[1] + " , " + v[2] + "]";
+    }
+}, {
+    ZERO: function() {
+        return new MOD3.Vector3(0, 0, 0);
+    },
+
+    X: function(direct_or_complement) {
+        return false === direct_or_complement ? new MOD3.Vector3(0, 1, 1) : new MOD3.Vector3(1, 0, 0);
+    },
+
+    Y: function(direct_or_complement) {
+        return false === direct_or_complement ? new MOD3.Vector3(1, 0, 1) : new MOD3.Vector3(0, 1, 0);
+    },
+
+    Z: function(direct_or_complement) {
+        return false === direct_or_complement ? new MOD3.Vector3(1, 1, 0) : new MOD3.Vector3(0, 0, 1);
+    },
+
+    dot: function(v, w) {
+        return v[0]*w[0] + v[1]*w[1] + v[2]*w[2];
+    },
+
+    equals: function(v, w) {
+        return (v[0] === w[0]) && (v[1] === w[1]) && (v[2] === w[2]);
+    },
+
+    cross: function(v, w) {
+        var vw = new MOD3.VecArray(3);
+        vw[0] = v[1] * w[2] - v[2] * w[1];
+        vw[1] = v[2] * w[0] - v[0] * w[2];
+        vw[2] = v[0] * w[1] - v[1] * w[0];
+        return vw;
+    },
+
+    mod: function(v) {
+        var x = v[0], y = v[1], z = v[2];
+        return stdMath.sqrt(x*x + y*y + z*z);
+    },
+
+    dist: function(v, w) {
+        var dx = v[0] - w[0],
+            dy = v[1] - w[1],
+            dz = v[2] - w[2];
+        return stdMath.sqrt(dx*dx + dy*dy + dz*dz);
+    },
+
+    add: function(v, w) {
+        v[0] += w[0];
+        v[1] += w[1];
+        v[2] += w[2];
+        return v;
+    },
+
+    sub: function(v, w) {
+        v[0] -= w[0];
+        v[1] -= w[1];
+        v[2] -= w[2];
+        return v;
+    },
+
+    mul: function(v, w) {
+        v[0] *= w[0];
+        v[1] *= w[1];
+        v[2] *= w[2];
+        return v;
+    },
+
+    muls: function(v, m) {
+        v[0] *= m;
+        v[1] *= m;
+        v[2] *= m;
+        return v;
+    },
+
+    norm: function(v) {
+        var x = v[0], y = v[1], z = v[2],
+            m = x*x + y*y + z*z, n;
+        if (0 < m)
+        {
+            n = stdMath.sqrt(m);
+            x /= n;
+            y /= n;
+            z /= n;
+        }
+        v[0] = x; v[1] = y; v[2] = z;
+        return v;
+    }
+});
+// alaises
+MOD3.Vector3.modulo = MOD3.Vector3.mod;
+MOD3.Vector3.distance = MOD3.Vector3.dist;
+MOD3.Vector3.prototype.dotSelf = MOD3.Vector3.prototype.dot;
+MOD3.Vector3.prototype.distanceSelf = MOD3.Vector3.prototype.distance;
+/**
+* MOD3  3D Transform Matrix Class
+**/
+MOD3.Matrix4 = MOD3.Class(null, {
+    constructor: function Matrix4(n11, n12, n13, n14,
+                                   n21, n22, n23, n24,
+                                   n31, n32, n33, n34,
+                                   n41, n42, n43, n44)
+    {
+        var self = this;
+        if (!(self instanceof Matrix4)) return new Matrix4(n11, n12, n13, n14,
+                                                           n21, n22, n23, n24,
+                                                           n31, n32, n33, n34,
+                                                           n41, n42, n43, n44);
+        self.m = new MOD3.VecArray([
+            n11 == null ? 1 : n11,
+            n12 == null ? 0 : n12,
+            n13 == null ? 0 : n13,
+            n14 == null ? 0 : n14,
+
+            n21 == null ? 0 : n21,
+            n22 == null ? 1 : n22,
+            n23 == null ? 0 : n23,
+            n24 == null ? 0 : n24,
+
+            n31 == null ? 0 : n31,
+            n32 == null ? 0 : n32,
+            n33 == null ? 1 : n33,
+            n34 == null ? 0 : n34,
+
+            n41 == null ? 0 : n41,
+            n42 == null ? 0 : n42,
+            n43 == null ? 0 : n43,
+            n44 == null ? 1 : n44
+        ]);
+    },
+
+    name: "Matrix4",
+    m: null,
+
+    dispose: function() {
+        this.m = null;
+        return this;
+    },
+
+    reset: function() {
+        var m = this.m;
+        m[0 ] = 1; m[1 ] = 0; m[2 ] = 0; m[3 ] = 0;
+        m[4 ] = 0; m[5 ] = 1; m[6 ] = 0; m[7 ] = 0;
+        m[8 ] = 0; m[9 ] = 0; m[10] = 1; m[11] = 0;
+        m[12] = 0; m[13] = 0; m[14] = 0; m[15] = 1;
+        return this;
+    },
+
+    translate: function(tx, ty, tz, reset) {
+        var m = this.m;
+        if (true === reset) this.reset();
+        m[3 ] = tx;
+        m[7 ] = ty;
+        m[11] = tz;
+        return this;
+    },
+
+    scale: function(sx, sy, sz, reset) {
+        var m = this.m;
+        if (true === reset) this.reset();
+        m[0 ] = sx;
+        m[5 ] = sy;
+        m[10] = sz;
+        return this;
+    },
+
+    rotate: function(rx, ry, rz, theta, reset)  {
+        var m = this.m,
+            nCos = stdMath.cos(theta), nSin = stdMath.sin(theta), scos = 1 - nCos,
+            sxy = rx*ry*scos, syz = ry*rz*scos, sxz = rx*rz*scos,
+            sz = nSin*rz, sy = nSin*ry, sx = nSin*rx
+        ;
+        if (true === reset) this.reset();
+        m[0 ] = nCos + rx*rx*scos;
+        m[1 ] = -sz + sxy;
+        m[2 ] = sy + sxz;
+        m[3 ] = 0;
+
+        m[4 ] = sz + sxy;
+        m[5 ] = nCos + ry*ry*scos;
+        m[6 ] = -sx + syz;
+        m[7 ] = 0;
+
+        m[8 ] = -sy + sxz;
+        m[9 ] = sx + syz;
+        m[10] = nCos + rz*rz*scos;
+        m[11] = 0;
+        return this;
+    },
+
+    translateFromVector: function(v, reset) {
+        return this.translate(v.xyz[0], v.xyz[1], v.xyz[2], reset);
+    },
+
+    scaleFromVector: function(v, reset) {
+        return this.scale(v.xyz[0], v.xyz[1], v.xyz[2], reset);
+    },
+
+    rotateFromVector: function(v, theta, reset)  {
+        return this.rotate(v.xyz[0], v.xyz[1], v.xyz[2], theta, reset);
+    },
+
+    multiply: function(b) {
+        return MOD3.Matrix4.mult(this, b);
+    },
+
+    multiplyVector: function(v) {
+        MOD3.Matrix4.multXYZ(this, v.xyz);
+        return v;
+    }
+}, {
+    multXYZ: function(m4, v) {
+        var m = m4.m, x = v[0], y = v[1], z = v[2];
+        v[0] = x*m[0 ] + y*m[1 ] + z*m[2 ] + m[3 ];
+        v[1] = x*m[4 ] + y*m[5 ] + z*m[6 ] + m[7 ];
+        v[2] = x*m[8 ] + y*m[9 ] + z*m[10] + m[11];
+        return v;
+    },
+
+    mult: function(m1, m2) {
+        var a = m1.m, b = m2.m,
+            a11 = a[0 ], b11 = b[0 ],
+            a21 = a[4 ], b21 = b[4 ],
+            a31 = a[8 ], b31 = b[8 ],
+            a12 = a[1 ], b12 = b[1 ],
+            a22 = a[5 ], b22 = b[5 ],
+            a32 = a[9 ], b32 = b[9 ],
+            a13 = a[2 ], b13 = b[2 ],
+            a23 = a[6 ], b23 = b[6 ],
+            a33 = a[10], b33 = b[10],
+            a14 = a[3 ], b14 = b[3 ],
+            a24 = a[7 ], b24 = b[7 ],
+            a34 = a[11], b34 = b[11];
+
+        a[0 ] = a11*b11 + a12*b21 + a13*b31;
+        a[1 ] = a11*b12 + a12*b22 + a13*b32;
+        a[2 ] = a11*b13 + a12*b23 + a13*b33;
+        a[3 ] = a11*b14 + a12*b24 + a13*b34 + a14;
+
+        a[4 ] = a21*b11 + a22*b21 + a23*b31;
+        a[5 ] = a21*b12 + a22*b22 + a23*b32;
+        a[6 ] = a21*b13 + a22*b23 + a23*b33;
+        a[7 ] = a21*b14 + a22*b24 + a23*b34 + a24;
+
+        a[8 ] = a31*b11 + a32*b21 + a33*b31;
+        a[9 ] = a31*b12 + a32*b22 + a33*b32;
+        a[10] = a31*b13 + a32*b23 + a33*b33;
+        a[11] = a31*b14 + a32*b24 + a33*b34 + a34;
+        return m1;
+    }
+});
+// aliases
+MOD3.Matrix4.prototype.translationMatrix = MOD3.Matrix4.prototype.translate;
+MOD3.Matrix4.prototype.scaleMatrix = MOD3.Matrix4.prototype.scale;
+MOD3.Matrix4.prototype.rotationMatrix = MOD3.Matrix4.prototype.rotate;
+MOD3.Matrix4.prototype.translationMatrixFromVector = MOD3.Matrix4.prototype.translateFromVector;
+MOD3.Matrix4.prototype.scaleMatrixFromVector = MOD3.Matrix4.prototype.scaleFromVector;
+MOD3.Matrix4.prototype.rotationMatrixFromVector = MOD3.Matrix4.prototype.rotateFromVector;
+// fast list utilities
+MOD3.List = {
+     operate: function operate(x, F, F0, i0, i1, reverse) {
+        var len = x.length;
+        if (arguments.length < 5) i1 = len-1;
+        if (0 > i1) i1 += len;
+        if (arguments.length < 4) i0 = 0;
+        if (i0 > i1) return F0;
+        if (true === reverse)
+        {
+        var i, k, l=i1-i0+1, l1=l-1, r=l&15, q=r&1, lr=l1-r, Fv=q?F(F0,x[i1],i1):F0;
+        for (i=l1-q; i>lr; i-=2) { k = i0+i; Fv = F(F(Fv,x[k],k),x[k-1],k-1); }
+        for (i=lr; i>=0; i-=16)  { k = i0+i; Fv = F(F(F(F(F(F(F(F(F(F(F(F(F(F(F(F(Fv,x[k],k),x[k-1],k-1),x[k-2],k-2),x[k-3],k-3),x[k-4],k-4),x[k-5],k-5),x[k-6],k-6),x[k-7],k-7),x[k-8],k-8),x[k-9],k-9),x[k-10],k-10),x[k-11],k-11),x[k-12],k-12),x[k-13],k-13),x[k-14],k-14),x[k-15],k-15); }
+        }
+        else
+        {
+        var i, k, l=i1-i0+1, r=l&15, q=r&1, Fv=q?F(F0,x[i0],i0):F0;
+        for (i=q; i<r; i+=2)  { k = i0+i; Fv = F(F(Fv,x[k],k),x[k+1],k+1); }
+        for (i=r; i<l; i+=16) { k = i0+i; Fv = F(F(F(F(F(F(F(F(F(F(F(F(F(F(F(F(Fv,x[k],k),x[k+1],k+1),x[k+2],k+2),x[k+3],k+3),x[k+4],k+4),x[k+5],k+5),x[k+6],k+6),x[k+7],k+7),x[k+8],k+8),x[k+9],k+9),x[k+10],k+10),x[k+11],k+11),x[k+12],k+12),x[k+13],k+13),x[k+14],k+14),x[k+15],k+15); }
+        }
+        return Fv;
+    }
+
+    ,each: function each(x, F, i0, i1, reverse) {
+        if (null == x || !x.length) return x;
+        var len = x.length;
+        if (arguments.length < 4) i1 = len-1;
+        if (0 > i1) i1 += len;
+        if (arguments.length < 3) i0 = 0;
+        if (i0 > i1) return x;
+        var i, k, l=i1-i0+1, l1, lr, r, q;
+        if (true === reverse)
+        {
+            l1=l-1; r=l&15; q=r&1; lr=l1-r;
+            if (q) F(x[i1]);
+            for (i=l1-q; i>lr; i-=2)
+            {
+                k = i0+i;
+                F(x[k  ]);
+                F(x[k-1]);
+            }
+            for (i=lr; i>=0; i-=16)
+            {
+                k = i0+i;
+                F(x[k  ] );
+                F(x[k-1] );
+                F(x[k-2] );
+                F(x[k-3] );
+                F(x[k-4] );
+                F(x[k-5] );
+                F(x[k-6] );
+                F(x[k-7] );
+                F(x[k-8] );
+                F(x[k-9] );
+                F(x[k-10]);
+                F(x[k-11]);
+                F(x[k-12]);
+                F(x[k-13]);
+                F(x[k-14]);
+                F(x[k-15]);
+            }
+        }
+        else
+        {
+            r=l&15; q=r&1;
+            if (q) F(x[i0]);
+            for (i=q; i<r; i+=2)
+            {
+                k = i0+i;
+                F(x[k  ]);
+                F(x[k+1]);
+            }
+            for (i=r; i<l; i+=16)
+            {
+                k = i0+i;
+                F(x[k  ] );
+                F(x[k+1] );
+                F(x[k+2] );
+                F(x[k+3] );
+                F(x[k+4] );
+                F(x[k+5] );
+                F(x[k+6] );
+                F(x[k+7] );
+                F(x[k+8] );
+                F(x[k+9] );
+                F(x[k+10]);
+                F(x[k+11]);
+                F(x[k+12]);
+                F(x[k+13]);
+                F(x[k+14]);
+                F(x[k+15]);
+            }
+        }
+        return x;
+    }
+};
+/**
+* MOD3  MeshProxy Super Class
+**/
+function dispose(o)
+{
+    o.dispose();
+}
+function reset(o)
+{
+    o.reset();
+}
+function collapse(o)
+{
+    o.collapse();
+}
+
+MOD3.FaceProxy = MOD3.Class(null, {
+    constructor: function FaceProxy() {
+        this.vertices = [];
+    },
+
+    name: "FaceProxy",
+    vertices: null,
+
+    dispose: function() {
+        var self = this;
+        self.vertices = null;
+        return self;
+    },
+
+    addVertex: function(v)  {
+        this.vertices.push(v);
+    },
+
+    getVertices: function() {
+        return this.vertices;
+    }
+});
+
+MOD3.VertexProxy = MOD3.Class(null, {
+    constructor: function VertexProxy(vertex, mesh) {
+        var self = this;
+        self.mesh = mesh || null;
+        // use internal typed-arrays for speed
+        self.original = new MOD3.VecArray([0,0,0]);
+        self.ratio = new MOD3.VecArray([0,0,0]);
+        // vertex can be zero
+        if (null != vertex) self.setVertex(vertex);
+    },
+
+    name: "VertexProxy",
+    mesh: null,
+    vertex: null,
+    original: null,
+    ratio: null,
+
+    dispose: function() {
+        var self = this;
+        self.mesh = null;
+        self.vertex = null;
+        self.original = null;
+        self.ratio = null;
+        return self;
+    },
+
+    setVertex: function(vt)  {
+        // override
+        var self = this;
+        self.vertex = vt;
+        return self;
+    },
+
+    getRatioVector: function() {
+        var r = this.ratio, rv = new MOD3.VecArray(3);
+        rv[0] = r[0]; rv[1] = r[1]; rv[2] = r[2];
+        return rv;
+    },
+
+    getRatio: function(axis) {
+        return this.ratio[MOD3.XYZi[axis]] || 0;
+    },
+
+    setRatios: function(rx, ry, rz) {
+        var r = this.ratio;
+        r[0] = rx || 0;
+        r[1] = ry || 0;
+        r[2] = rz || 0;
+        return this;
+    },
+
+    getOriginalValue: function(axis) {
+        return this.original[MOD3.XYZi[axis]] || 0;
+    },
+
+    setOriginalPosition: function(ox, oy, oz) {
+        var o = this.original;
+        o[0] = ox || 0;
+        o[1] = oy || 0;
+        o[2] = oz || 0;
+        return this;
+    },
+
+    getXYZ: function() {
+        // override
+        return new MOD3.VecArray([0,0,0]);
+    },
+
+    getX: function() {
+        // override
+        return 0;
+    },
+
+    getY: function() {
+        // override
+        return 0;
+    },
+
+    getZ: function() {
+        // override
+        return 0;
+    },
+
+    getValue: function(axis)  {
+        var self = this;
+        // override
+        return MOD3.ModConstant.X === axis
+            ? self.getX()
+            : (MOD3.ModConstant.Y === axis
+            ? self.getY()
+            : (MOD3.ModConstant.Z === axis
+            ? self.getZ()
+            : 0))
+        ;
+    },
+
+    setXYZ: function(xyz) {
+        // override
+        return this;
+    },
+
+    setX: function(vo) {
+        // override
+        return this;
+    },
+
+    setY: function(vo) {
+        // override
+        return this;
+    },
+
+    setZ: function(vo) {
+        // override
+        return this;
+    },
+
+    setValue: function(axis, vo) {
+        var self = this;
+        // override
+        if (MOD3.ModConstant.X === axis)       self.setX(vo);
+        else if (MOD3.ModConstant.Y === axis)  self.setY(vo);
+        else if (MOD3.ModConstant.Z === axis)  self.setZ(vo);
+        return self;
+    },
+
+    reset: function() {
+        // override
+        var self = this;
+        self.setXYZ(self.original);
+        return self;
+    },
+
+    collapse: function() {
+        // override
+        var self = this, xyz = self.getXYZ(), o = self.original;
+        o[0] = xyz[0]; o[1] = xyz[1]; o[2] = xyz[2];
+        return self;
+    }
+});
+
+MOD3.MeshProxy = MOD3.Class(null, {
+    constructor: function MeshProxy(mesh) {
+        var self = this;
+        self.maxX = 0;
+        self.maxY = 0;
+        self.maxZ = 0;
+
+        self.minX = 0;
+        self.minY = 0;
+        self.minZ = 0;
+
+        self.maxAxis = 0;
+        self.midAxis = 0;
+        self.minAxis = 0;
+
+        self.width = 0;
+        self.height = 0;
+        self.depth = 0;
+
+        self.vertices = null;
+        self.faces = null;
+        self.mesh = null;
+
+        if (null != mesh) self.setMesh(mesh);
+    },
+
+    name: "MeshProxy",
+
+    maxX: 0,
+    maxY: 0,
+    maxZ: 0,
+    minX: 0,
+    minY: 0,
+    minZ: 0,
+
+    maxAxis: 0,
+    midAxis: 0,
+    minAxis: 0,
+
+    width: 0,
+    height: 0,
+    depth: 0,
+
+    vertices : null,
+    faces : null,
+    mesh : null,
+    v: null,
+
+    dispose: function() {
+        var self = this;
+        self.maxX = null;
+        self.maxY = null;
+        self.maxZ = null;
+        self.minX = null;
+        self.minY = null;
+        self.minZ = null;
+
+        self.maxAxis = null;
+        self.midAxis = null;
+        self.minAxis = null;
+
+        self.width = null;
+        self.height = null;
+        self.depth = null;
+
+        self.disposeFaces();
+        self.disposeVertices();
+        self.mesh = null;
+        self.v = null;
+        return self;
+    },
+
+    disposeVertices: function() {
+        var self = this;
+        if (self.vertices) MOD3.List.each(self.vertices, dispose);
+        self.vertices = null;
+        return self;
+    },
+
+    disposeFaces: function() {
+        var self = this;
+        if (self.faces) MOD3.List.each(self.faces, dispose);
+        self.faces = null;
+        return self;
+    },
+
+    init: function(mesh) {
+        var self = this;
+        self.mesh = mesh;
+        //self.vertices = [];
+        // not used
+        //self.faces = [];
+        return self;
+    },
+
+    setMesh: function(mesh) {
+        var self = this;
+        self.init(mesh);
+        self.preApply();
+        self.analyzeGeometry()
+        self.postApply();
+        return self;
+    },
+
+    getVertices: function() {
+        return this.vertices;
+    },
+
+    getFaces: function() {
+        return this.faces;
+    },
+
+    applyModifiers: function(modStack) {
+        var self = this, sl, i;
+        for (i=0,sl=modStack.length; i<sl; ++i)
+        {
+            modStack[i].enabled && modStack[i].apply(self);
+        }
+        return self;
+    },
+
+    analyzeGeometry: function() {
+        var self = this,
+            vertices = self.vertices,
+            minX = 0, minY = 0,  minZ = 0,
+            maxX = 0, maxY = 0, maxZ = 0,
+            width = 0, height = 0, depth = 0,
+            maxe, mine, w
+        ;
+        if (!vertices || !vertices.length) return self;
+
+        w = vertices[0].getXYZ();
+        minX = w[0];
+        minY = w[1];
+        minZ = w[2];
+
+        maxX = w[0];
+        maxY = w[1];
+        maxZ = w[2];
+
+        MOD3.List.each(vertices, function(v) {
+            var xyz = v.getXYZ(), x = xyz[0], y = xyz[1], z = xyz[2];
+            minX = stdMath.min(minX, x);
+            minY = stdMath.min(minY, y);
+            minZ = stdMath.min(minZ, z);
+
+            maxX = stdMath.max(maxX, x);
+            maxY = stdMath.max(maxY, y);
+            maxZ = stdMath.max(maxZ, z);
+            v.setOriginalPosition(x, y, z);
+        });
+
+        width = maxX - minX;
+        height = maxY - minY;
+        depth = maxZ - minZ;
+
+        self.width = width;
+        self.height = height;
+        self.depth = depth;
+        self.minX = minX;
+        self.maxX = maxX;
+        self.minY = minY;
+        self.maxY = maxY;
+        self.minZ = minZ;
+        self.maxZ = maxZ;
+
+        maxe = stdMath.max(width, height, depth);
+        mine = stdMath.min(width, height, depth);
+
+        if ((maxe === width) && (mine === height))
+        {
+            self.minAxis = MOD3.ModConstant.Y;
+            self.midAxis = MOD3.ModConstant.Z;
+            self.maxAxis = MOD3.ModConstant.X;
+        }
+        else if ((maxe === width) && (mine === depth))
+        {
+            self.minAxis = MOD3.ModConstant.Z;
+            self.midAxis = MOD3.ModConstant.Y;
+            self.maxAxis = MOD3.ModConstant.X;
+        }
+        else if ((maxe === height) && (mine === width))
+        {
+            self.minAxis = MOD3.ModConstant.X;
+            self.midAxis = MOD3.ModConstant.Z;
+            self.maxAxis = MOD3.ModConstant.Y;
+        }
+        else if ((maxe === height) && (mine === depth))
+        {
+            self.minAxis = MOD3.ModConstant.Z;
+            self.midAxis = MOD3.ModConstant.X;
+            self.maxAxis = MOD3.ModConstant.Y;
+        }
+        else if ((maxe === depth) && (mine === width))
+        {
+            self.minAxis = MOD3.ModConstant.X;
+            self.midAxis = MOD3.ModConstant.Y;
+            self.maxAxis = MOD3.ModConstant.Z;
+        }
+        else if ((maxe === depth) && (mine === height))
+        {
+            self.minAxis = MOD3.ModConstant.Y;
+            self.midAxis = MOD3.ModConstant.X;
+            self.maxAxis = MOD3.ModConstant.Z;
+        }
+
+        MOD3.List.each(vertices, function(v) {
+            var xyz = v.getXYZ();
+            v.setRatios(width > 0 ? (xyz[0] - minX) / width : 0, height > 0 ? (xyz[1] - minY) / height : 0, depth > 0 ? (xyz[2] - minZ) / depth : 0);
+        });
+        return self;
+    },
+
+    resetGeometry: function() {
+        var self = this;
+        MOD3.List.each(self.vertices, reset);
+        return self;
+    },
+
+    collapseGeometry: function() {
+        var self = this;
+        MOD3.List.each(self.vertices, collapse);
+        self.analyzeGeometry();
+        return self;
+    },
+
+    getMin: function(axis) {
+        var self = this;
+        return MOD3.ModConstant.X === axis
+            ? self.minX
+            : (MOD3.ModConstant.Y === axis
+            ? self.minY
+            : (MOD3.ModConstant.Z === axis
+            ? self.minZ
+            : -1))
+        ;
+    },
+
+    getMax: function(axis) {
+        var self = this;
+        return MOD3.ModConstant.X === axis
+            ? self.maxX
+            : (MOD3.ModConstant.Y === axis
+            ? self.maxY
+            : (MOD3.ModConstant.Z === axis
+            ? self.maxZ
+            : -1))
+        ;
+    },
+
+    getSize: function(axis) {
+        var self = this;
+        return MOD3.ModConstant.X === axis
+            ? self.width
+            : (MOD3.ModConstant.Y === axis
+            ? self.height
+            : (MOD3.ModConstant.Z === axis
+            ? self.depth
+            : -1))
+        ;
+    },
+
+    update: function()  {
+        // do nothing
+        return this;
+    },
+
+    preApply: function()  {
+        // do nothing
+        return this;
+    },
+
+    postApply: function()  {
+        // do nothing
+        return this;
+    },
+
+    updateMeshPosition: function(p) {
+        // do nothing
+        return this;
+    }
+});
+
+MOD3.Library3d = {
+    id      : "Library3d",
+    Mesh    : MOD3.MeshProxy,
+    Vertex  : MOD3.VertexProxy
+};
+
+MOD3.Factory = {
+    getLibrary: function(json) {
+        if (json && json.library && MOD3[json.library]) return MOD3[json.library];
+        // dummy, default
+        return MOD3.Library3d;
+    }
+
+    ,getMeshProxy: function(lib3D) {
+        if (arguments.length) return lib3D.Mesh ? new lib3D.Mesh() : null;
+        return null;
+    }
+
+    ,getModifier: function(json) {
+        if (json && json.modifier && MOD3[json.modifier]) return new MOD3[json.modifier]();
+        return null;
+    }
+
+    /*
+    ,getMesh: function(json) {
+        if (json && json.mesh && MOD3[json.mesh] ) return new MOD3.MeshProxy().unserialize(json);
+        // dummy, default
+        return new MOD3.MeshProxy();
+    }
+
+    ,getVertex: function(json) {
+        if (json && json.vertex && MOD3[json.vertex]) return new MOD3.VertexProxy().unserialize(json);
+        // dummy, default
+        return new MOD3.VertexProxy();
+    }*/
+};
+/**
+* MOD3  Modifier & ModifierStack Classes
+**/
+var _modCount = 0;
+
+MOD3.Modifier = MOD3.Class({
+    constructor: function Modifier() {
+        var self = this;
+        self.id = ++_modCount;
+        self.name = 'Modifier';
+        self.axes = MOD3.ModConstant.NONE;
+        self.constraint = MOD3.ModConstant.NONE;
+        self.enabled = true;
+    },
+
+    id: null,
+    name: 'Modifier',
+    axes: null,
+    constraint: null,
+    enabled: true,
+
+    dispose: function() {
+        var self = this;
+        self.name = null;
+        self.axes = null;
+        self.constraint = null;
+        return self;
+    },
+
+    enable: function(enabled) {
+        if (arguments.length)
+        {
+            this.enabled = !!enabled;
+            return this;
+        }
+        return this.enabled;
+    },
+
+    constraintAxes: function(axes) {
+        this.axes = axes || MOD3.ModConstant.NONE;
+        return this;
+    },
+
+    setConstraint: function(c) {
+        this.constraint = c || MOD3.ModConstant.NONE;
+        return this;
+    },
+
+    // override
+    apply: function(modifiable) {
+        return this;
+    },
+
+    toString: function() {
+        return '[Modifier '+this.name+']';
+    }
+});
+
+MOD3.ModifierStack = MOD3.Class({
+    constructor: function ModifierStack(lib3d, mesh) {
+        var self = this;
+        if (!(self instanceof ModifierStack)) return new ModifierStack(lib3d, mesh);
+        self.stack = [];
+        self.setModifiable(MOD3.Factory.getMeshProxy(lib3d), mesh);
+    },
+
+    name: "ModifierStack",
+    modifiable: null,
+    stack: null,
+
+    dispose: function(withModifiers) {
+        var self = this;
+        if (withModifiers && self.stack) while (self.stack.length) self.stack.pop().dispose();
+        if (self.modifiable) self.modifiable.dispose();
+        self.stack = null;
+        self.modifiable = null;
+        return self;
+    },
+
+    getModifiable: function() {
+        return this.modifiable;
+    },
+
+    setModifiable: function(modifiable, mesh) {
+        var self = this;
+        self.modifiable = modifiable;
+        if (mesh) self.modifiable.setMesh(mesh);
+        return self;
+    },
+
+    add: function(modifier) {
+        var self = this;
+        if (modifier) self.stack.push(modifier);
+        return self;
+    },
+
+    apply: function() {
+        var self = this, modifiable = self.modifiable, stack = self.stack;
+        if (modifiable && stack && stack.length)
+            modifiable
+                .preApply()
+                .resetGeometry()
+                .applyModifiers(stack)
+                .postApply()
+                .update()
+            ;
+        return self;
+    },
+
+    collapse: function() {
+        var self = this, modifiable = self.modifiable, stack = self.stack;
+        if (modifiable && stack && stack.length)
+        {
+            modifiable
+                .preApply()
+                .resetGeometry()
+                .applyModifiers(stack)
+                .collapseGeometry()
+                .postApply()
+                .update()
+            ;
+            stack.length = 0;
+        }
+        return self;
+    },
+
+    clear: function() {
+        var self = this;
+        if (self.stack) self.stack.length = 0;
+        return self;
+    }
+});
+// aliases
+MOD3.ModifierStack.prototype.getMeshInfo = MOD3.ModifierStack.prototype.getModifiable;
+MOD3.ModifierStack.prototype.addModifier = MOD3.ModifierStack.prototype.add;
+!function(MOD3) {
+"use strict";
+/**
+* MOD3  Pivot Modifier
+**/
+
+/**[DOC_MD]
+ * ### Pivot modifier
+ *
+ * Allows to move the pivot point of a 3D mesh.
+ *
+ * @author Bartek Drozdz
+ *
+[/DOC_MD]**/
+MOD3.Pivot = MOD3.Class(MOD3.Modifier, {
+    constructor: function Pivot(x, y, z) {
+        var self = this;
+        if (!(self instanceof Pivot)) return new Pivot(x, y, z);
+        self.$super('constructor');
+        self.name = 'Pivot';
+        self.vector = new MOD3.Vector3(x||0, y||0, z||0);
+    },
+
+    vector: null,
+
+    dispose: function() {
+        var self = this;
+        self.vector.dispose();
+        self.vector = null;
+        self.$super('dispose');
+        return self;
+    },
+
+    setMeshCenter: function(modifiable) {
+        var self = this;
+        self.vector = new MOD3.Vector3(
+        -(modifiable.minX + 0.5*modifiable.width),
+        -(modifiable.minY + 0.5*modifiable.height),
+        -(modifiable.minZ + 0.5*modifiable.depth)
+        );
+        return self;
+    },
+
+    apply: function(modifiable) {
+        var self = this, pivot = self.vector, pv = pivot.xyz;
+
+        MOD3.List.each(modifiable.vertices, function(v) {
+            v.setXYZ(MOD3.Vector3.add(v.getXYZ(), pv));
+        });
+        modifiable.updateMeshPosition(pivot.negate());
+        return self;
+    }
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  Bend Modifier
+**/
+
+/**[DOC_MD]
+ * ### Bend modifier 
+ *
+ * Bends an object along an axis. 
+ *
+ * @author Bartek Drozdz
+ *  
+[/DOC_MD]**/
+var stdMath = Math, PI = stdMath.PI,
+    TWO_PI = 2*PI, HALF_PI = PI/2;
+
+MOD3.Bend = MOD3.Class(MOD3.Modifier, {
+    constructor: function Bend(force, offset, angle) {
+        var self = this;
+        if (!(self instanceof Bend)) return new Bend(force, offset, angle);
+        self.$super('constructor');
+        self.name = 'Bend';
+        self.constraint = MOD3.ModConstant.NONE;
+        self.switchAxes = false;
+        self.force = force || 0;
+        self.offset = offset || 0;
+        self.angle = angle || 0;
+    },
+
+    force: 0,
+    offset: 0,
+    angle: 0,
+    switchAxes: false,
+    
+    dispose: function() {
+        var self = this;
+        self.force = null;
+        self.offset = null;
+        self.angle = null;
+        self.switchAxes = null;
+        self.$super('dispose');
+        return self;
+    },
+    
+    apply: function(modifiable) {   
+        var self = this;
+        
+        if (0 === self.force) return self;
+        
+        var constraint = self.constraint, switchAxes = self.switchAxes,
+            force = self.force, offset = stdMath.min(1, stdMath.max(0, self.offset)), a = self.angle,
+            max = switchAxes ? modifiable.midAxis : modifiable.maxAxis,
+            min = modifiable.minAxis,
+            mid = switchAxes ? modifiable.maxAxis : modifiable.midAxis,
+            width = modifiable.getSize(max),
+            height = modifiable.getSize(mid),
+            origin = modifiable.getMin(max),
+            //diagAngle = stdMath.atan2(height, width),
+            m1 = new MOD3.Matrix().rotate(a),
+            m2 = new MOD3.Matrix().rotate(-a),
+            distance = origin + width * offset,
+            radius = width / PI / force,
+            bendAngle = TWO_PI * (width / (radius * TWO_PI))
+        ;
+        
+        MOD3.List.each(modifiable.vertices, function(v) {
+            var xyz = v.getXYZ(),
+                vmax = xyz[MOD3.XYZi[max]],
+                vmid = xyz[MOD3.XYZi[mid]],
+                vmin = xyz[MOD3.XYZi[min]],
+                np = MOD3.Matrix.transform(m1, [vmax, vmid]),
+                p, fa, op, ow, np2
+            ;
+            vmax = np[0]; vmid = np[1];
+
+            p = (vmax - origin) / width;
+
+            if (
+                ((MOD3.ModConstant.LEFT === constraint) && (p <= offset)) || 
+                ((MOD3.ModConstant.RIGHT === constraint) && (p >= offset))
+            ) 
+            {  
+                /* do nothing */ 
+            } 
+            else 
+            {
+                fa = (HALF_PI - bendAngle * offset) + (bendAngle * p);
+                op = stdMath.sin(fa) * (radius + vmin);
+                ow = stdMath.cos(fa) * (radius + vmin);
+                vmin = op - radius;
+                vmax = distance - ow;
+            }
+
+            np2 = MOD3.Matrix.transform(m2, [vmax, vmid]);
+            vmax = np2[0]; vmid = np2[1];
+            xyz[MOD3.XYZi[max]] = vmax;
+            xyz[MOD3.XYZi[mid]] = vmid;
+            xyz[MOD3.XYZi[min]] = vmin;
+            v.setXYZ(xyz);
+        });
+        return self;
+    }
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  Bloat Modifier
+**/
+
+/**[DOC_MD]
+ * ### Bloat modifier
+ *
+ * Bloats a mesh by forcing vertices out of specified sphere
+ *
+ * @author makc
+ *
+[/DOC_MD]**/
+var stdMath = Math;
+
+MOD3.Bloat = MOD3.Class(MOD3.Modifier, {
+    constructor: function Bloat(radius, a, center) {
+        var self = this;
+        if (!(self instanceof Bloat)) return new Bloat(radius, a, center);
+        self.$super('constructor');
+        self.name = 'Bloat';
+        self.radius = radius || 0;
+        self.a = null == a ? 0.01 : a;
+        self.center = center || MOD3.Vector3.ZERO();
+        //self.u = MOD3.Vector3.ZERO();
+    },
+
+    radius: 0,
+    a: 0.01,
+    center: null,
+    //u: null,
+
+    dispose: function() {
+        var self = this;
+        self.center.dispose();
+        self.center = null;
+        self.radius = null;
+        self.a = null;
+        self.$super('dispose');
+        return self;
+    },
+
+    apply: function(modifiable)  {
+        var self = this, center = self.center.xyz,
+            radius = stdMath.max(0, self.radius), a = stdMath.max(0, self.a);
+
+        MOD3.List.each(modifiable.vertices, function(v) {
+            // get a vector towards vertex
+            // change norm to norm + r * exp (-a * norm)
+            var uu = MOD3.Vector3.sub(v.getXYZ(), center), magn = MOD3.Vector3.mod(uu);
+            MOD3.Vector3.muls(MOD3.Vector3.norm(uu), magn + radius * stdMath.exp(- magn * a));
+            // move vertex accordingly
+            v.setXYZ(MOD3.Vector3.add(uu, center));
+            // ?? needed??
+            //self.u=uu;
+        });
+        return self;
+    }
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  Twist Modifier
+**/
+
+/**[DOC_MD]
+ * ### Twist modifier
+ *
+ * Twist mesh along an axis
+ * Adapted from the Twist modifier for PV3D
+ *
+[/DOC_MD]**/
+MOD3.Twist = MOD3.Class(MOD3.Modifier, {
+    constructor: function Twist(angle, vector, center) {
+        var self = this;
+        if (!(self instanceof Twist)) return new Twist(angle, vector, center);
+        self.$super('constructor');
+        self.name = 'Twist';
+        self.angle = angle || 0;
+        self.vector = vector || MOD3.Vector3.Y();
+        self.center = center || MOD3.Vector3.ZERO();
+    },
+
+    angle: 0,
+    vector: null,
+    center: null,
+
+    dispose: function() {
+        var self = this;
+        self.vector.dispose();
+        self.vector = null;
+        self.angle = null;
+        self.center.dispose();
+        self.center = null;
+        self.$super('dispose');
+        return self;
+    },
+
+    apply: function(modifiable) {
+        var self = this,
+            tvec = self.vector.normalizeSelf().xyz, angle = self.angle, center = self.center.xyz,
+            modulo = MOD3.Vector3.mod([0.5*modifiable.maxX, 0.5*modifiable.maxY, 0.5*modifiable.maxZ]),
+            d = -MOD3.Vector3.dot(tvec, center),
+            m1 = new MOD3.Matrix4(), m2 = new MOD3.Matrix4()
+        ;
+
+        MOD3.List.each(modifiable.vertices, function(v) {
+            var xyz = v.getXYZ(),
+                a = (MOD3.Vector3.dot(xyz, tvec) + d) * angle / modulo,
+                m = MOD3.Matrix4.mult(
+                    m2.rotate(tvec[0], tvec[1], tvec[2], a, true),
+                    m1.translate(xyz[0], xyz[1], xyz[2], true)
+                )
+            ;
+            v.setXYZ([m.m[3], m.m[7], m.m[11]]);
+        });
+        return self;
+    }
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  Skew Modifier
+**/
+
+/**[DOC_MD]
+ * ### Skew modifier
+ *
+ * Skew mesh along an axis
+ *
+ * @author Bartek Drozdz
+ *
+[/DOC_MD]**/
+var stdMath = Math;
+
+MOD3.Skew = MOD3.Class(MOD3.Modifier, {
+    constructor: function Skew(force, offset, power, falloff) {
+        var self = this;
+        if (!(self instanceof Skew)) return new Skew(force, offset, power, falloff);
+        self.$super('constructor');
+        self.name = 'Skew';
+        self.constraint = MOD3.ModConstant.NONE;
+        self.force = force != null ? force : 0;
+        self.offset = offset != null ? offset : 0.5;
+        self.power = power != null ? power : 1;
+        self.falloff = falloff != null ? falloff : 1;
+        self.inverseFalloff = false;
+        self.oneSide = false;
+        self.swapAxes = false;
+        self.skewAxis = 0;
+    },
+
+    force: 0,
+    skewAxis: 0,
+    offset: 0.5,
+    power: 1,
+    falloff:  1,
+    inverseFalloff: false,
+    oneSide: false,
+    swapAxes: false,
+
+    dispose: function() {
+        var self = this;
+        self.force = null;
+        self.skewAxis = null;
+        self.offset = null;
+        self.power = null;
+        self.falloff = null;
+        self.inverseFalloff = null;
+        self.oneSide = null;
+        self.swapAxes = null;
+        self.$super('dispose');
+        return self;
+    },
+
+    apply: function(modifiable) {
+        var self = this,
+            constraint = self.constraint,
+            skewAxis = self.skewAxis || modifiable.maxAxis,
+            swapAxes = self.swapAxes,
+            offset = stdMath.min(1, stdMath.max(0, self.offset)),
+            oneSide = self.oneSide,
+            inverseFalloff = !!self.inverseFalloff,
+            falloff = stdMath.min(1, stdMath.max(0, self.falloff)),
+            mirrorfalloff = 1-falloff,
+            power = self.power,
+            force = self.force,
+            displaceAxis = MOD3.ModConstant.X === skewAxis
+                ? (swapAxes ? MOD3.ModConstant.Z : MOD3.ModConstant.Y)
+                : (MOD3.ModConstant.Y === skewAxis
+                ? (swapAxes ? MOD3.ModConstant.Z : MOD3.ModConstant.X)
+                : (MOD3.ModConstant.Z === skewAxis
+                ? (swapAxes ? MOD3.ModConstant.Y : MOD3.ModConstant.X)
+                : 0))
+        ;
+
+        MOD3.List.each(modifiable.vertices, function(v) {
+            var r, dr, f, p, vRatio;
+            vRatio = v.getRatio(skewAxis);
+            if ((MOD3.ModConstant.LEFT === constraint) && (vRatio <= offset)) return;
+            if ((MOD3.ModConstant.RIGHT === constraint) && (vRatio > offset)) return;
+
+            r = vRatio - offset;
+            if (oneSide && (0 > r)) r = -r;
+
+            dr = v.getRatio(displaceAxis);
+            if (inverseFalloff) dr = 1 - dr;
+
+            f = falloff + dr * mirrorfalloff;
+            p = (0 > r ? -1 : 1) * stdMath.pow(stdMath.abs(r), power);
+            v.setValue(displaceAxis, v.getValue(displaceAxis) + force * p * f);
+        });
+        return self;
+    },
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  Taper Modifier
+**/
+
+/**[DOC_MD]
+ * ### Taper modifier
+ *
+ * The taper modifier displaces the vertices on two axes proportionally to their position on the third axis.
+ *
+ * @author Bartek Drozdz
+ *
+[/DOC_MD]**/
+var stdMath = Math;
+
+MOD3.Taper = MOD3.Class(MOD3.Modifier, {
+    constructor: function Taper(force, power, v1, v2)  {
+        var self = this;
+        if (!(self instanceof Taper)) return new Taper(force, power, v1, v2);
+        self.$super('constructor');
+        self.name = 'Taper';
+        /*self.start = 0;
+        self.end = 1;*/
+        self.force = force != null ? force : 0;
+        self.power = power != null ? power : 1;
+        self.vector = v1 || MOD3.Vector3.Y(false);
+        self.vector2 = v2 || MOD3.Vector3.Y();
+    },
+
+    force: 0,
+    power: 1,
+    /*start: 0,
+    end: 1,*/
+    vector: null,
+    vector2: null,
+
+    /*setFalloff : function(start, end)  {
+        this.start = (start!==undef) ? start : 0;
+        this.end = (end!==undef) ? end : 1;
+
+        return this;
+    },*/
+
+    dispose: function() {
+        var self = this;
+        self.vector.dispose();
+        self.vector2.dispose();
+        self.vector = null;
+        self.vector2 = null;
+        self.force = null;
+        self.power = null;
+        self.$super('dispose');
+        return self;
+    },
+
+    apply: function(modifiable) {
+        var self = this,
+            vec = self.vector.xyz, vec2 = self.vector2.xyz,
+            force = self.force, power = self.power, m = new MOD3.Matrix4();
+
+        MOD3.List.each(modifiable.vertices, 1 !== power
+            ? function(v) {
+                var ar = MOD3.Vector3.mod(MOD3.Vector3.mul(v.getRatioVector(), vec2)), sc = force * stdMath.pow(ar, power);
+                v.setXYZ(MOD3.Matrix4.multXYZ(m.scale(1 + sc * vec[0], 1 + sc * vec[1], 1 + sc * vec[2]), v.getXYZ()));
+            }
+            : function(v) {
+                var ar = MOD3.Vector3.mod(MOD3.Vector3.mul(v.getRatioVector(), vec2)), sc = force * ar;
+                v.setXYZ(MOD3.Matrix4.multXYZ(m.scale(1 + sc * vec[0], 1 + sc * vec[1], 1 + sc * vec[2]), v.getXYZ()));
+            }
+        );
+        return self;
+    }
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  Wheel Modifier
+**/
+
+/**[DOC_MD]
+ * ### Wheel modifier
+ *
+ * Use it with vehicle models for wheels.
+ *
+ * The usual problem with a 3d wheel in a vahicle is that it is
+ * supposed to turn (steer) and roll in the same time.
+ * So, this code:
+ *
+ * ```javascript
+ * wheel.rotationY = 10; // Steer 10deg to the left
+ * wheel.rotationZ += 5; // Roll with a speed of 5
+ * ```
+ * This will make the wheel roll incorectly.
+ *
+ * A usual way to solve this problem is to put the wheel in another DisplayObject3D/Mesh,
+ * turn the parent and roll the child, like that:
+ * ```javascript
+ * steer.rotationY = 10; // Steer 10deg to the left
+ * steer.wheel.rotationZ += 5; // Roll with a speed of 5
+ * ```
+ * That will make the wheel behave correctly. But it can be uncomfortanble to apply, especially
+ * to imported complex Collada models.
+ *
+ * The Wheel modifier elegantly solves this problem by doind the proper math in order to steer and roll
+ * a single mesh at the same time. The only thing you need to do is to specify a steer vector and
+ * roll vector - usually it will be 2 of the cardinal axes. The default value is:
+ *
+ * * steer - along the Y axis / new Vector3(0, 1, 0)
+ * * roll - along the Z axis / new Vector3(0, 0, 1)
+ *
+ *
+ * It should work with most car models imported from 3D editors as this is the natural position of a wheel.
+ *
+ * *Please note, that Papervision primitive cylinder, which may also be used as wheel, will require different axes
+ * (Y for roll and Z or X for steer).*
+ *
+ * @author Bartek Drozdz
+ *
+ [/DOC_MD]**/
+MOD3.Wheel = MOD3.Class(MOD3.Modifier, {
+   constructor: function Wheel(speed, turn, roll, steerVector, rollVector) {
+        var self = this;
+        if (!(self instanceof Wheel)) return new Wheel(speed, turn, roll, steerVector, rollVector);
+        self.$super('constructor');
+        self.name = 'Wheel';
+        self.speed = speed || 0;
+        self.turn = turn || 0;
+        self.roll = roll || 0;
+        self.steerVector = steerVector || MOD3.Vector3.Y();
+        self.rollVector = rollVector || MOD3.Vector3.Z();
+    },
+
+    speed:  0,
+    turn: 0,
+    roll: 0,
+    steerVector: null,
+    rollVector: null,
+
+    dispose: function() {
+        var self = this;
+        self.speed = null;
+        self.turn = null;
+        self.roll = null;
+        self.steerVector.dispose();
+        self.rollVector.dispose();
+        self.steerVector = null;
+        self.rollVector = null;
+        self.$super('dispose');
+
+        return self;
+    },
+
+    apply: function(modifiable) {
+        var self = this,
+            steerVector = self.steerVector.normalizeSelf(),
+            rollVector = self.rollVector.normalizeSelf(),
+            turn = self.turn, roll = self.roll,
+            //radius = 0.5*modifiable.width,
+            //step = radius * self.speed / PI,
+            //perimeter = radius * TWO_PI,
+            ms = null, mt = null
+        ;
+
+        self.roll += self.speed;
+
+        if (turn)
+        {
+            mt = new MOD3.Matrix4().rotateFromVector(steerVector, turn);
+            ms = new MOD3.Matrix4().rotateFromVector(mt.multiplyVector(rollVector.clone()), roll);
+        }
+        else
+        {
+            ms = new MOD3.Matrix4().rotateFromVector(rollVector, roll);
+        }
+
+        MOD3.List.each(modifiable.vertices, mt
+            ? function(v) {
+                v.setXYZ(MOD3.Matrix4.multXYZ(ms, MOD3.Matrix4.multXYZ(mt, v.getXYZ())));
+            }
+            : function(v) {
+                v.setXYZ(MOD3.Matrix4.multXYZ(ms, v.getXYZ()));
+            }
+        );
+        return self;
+    }
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  Break Modifier
+**/
+
+/**[DOC_MD]
+ * ### Break modifier
+ *
+ * Allow to break a mesh
+ *
+ * @author Bartek Drozdz
+ *
+[/DOC_MD]**/
+var stdMath = Math;
+
+MOD3.Break = MOD3.Class(MOD3.Modifier, {
+    constructor: function Break(offset, angle, vector) {
+        var self = this;
+        if (!(self instanceof Break)) return new Break(offset, angle, vector);
+        self.$super('constructor');
+        self.name = 'Break';
+        self.offset = offset || 0;
+        self.angle = angle || 0;
+        self.vector = vector || MOD3.Vector3.Y();
+        self.range = new MOD3.Range(0, 1);
+    },
+
+    offset: 0,
+    angle: 0,
+    vector: null,
+    range: null,
+
+    dispose: function() {
+        var self = this;
+        self.vector.dispose();
+        self.range.dispose();
+        self.vector = null;
+        self.range = null;
+        self.offset = null;
+        self.angle = null;
+        self.$super('dispose');
+        return self;
+    },
+
+    apply: function(modifiable) {
+        var self = this,
+            offset = stdMath.min(1, stdMath.max(0, self.offset)), range = self.range, angle = self.angle,
+            bv = self.vector.normalizeSelf().xyz, pv, rm;
+
+        pv = modifiable.minZ + modifiable.depth*offset;
+        rm = new MOD3.Matrix4().rotate(bv[0], bv[1], bv[2], angle);
+
+        MOD3.List.each(modifiable.vertices, function(v) {
+            var c = v.getXYZ();
+            c[2] -= pv;
+            if ((0 <= c[2]) && range.isIn(v.ratio[1])) MOD3.Matrix4.multXYZ(rm, c);
+            c[2] += pv;
+            v.setXYZ(c);
+        });
+        return self;
+   }
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  Noise Modifier
+**/
+
+/**[DOC_MD]
+ * ### Noise modifier
+ *
+ * Randomly displaces each vertex in all 3 axes
+ *
+ *
+[/DOC_MD]**/
+var stdMath = Math;
+
+MOD3.Noise = MOD3.Class(MOD3.Modifier, {
+    constructor: function Noise(force) {
+        var self = this;
+        if (!(self instanceof Noise)) return new Noise(force);
+        self.$super('constructor');
+        self.name = 'Noise';
+        self.force = force || 0;
+        self.start = 0;
+        self.end = 1;
+        self.axes = MOD3.ModConstant.X | MOD3.ModConstant.Y | MOD3.ModConstant.Z;
+    },
+
+    force: 0,
+    start: 0,
+    end: 1,
+
+    dispose: function() {
+        var self = this;
+        self.force = null;
+        self.start = null;
+        self.end = null;
+        self.$super('dispose');
+        return self;
+    },
+
+    setFalloff: function(start, end) {
+        var self = this;
+        self.start = start != null ? start : 0;
+        self.end = end != null ? end : 1;
+        return self;
+    },
+
+    apply: function(modifiable) {
+        var self = this,
+            axes = self.axes, start = self.start, end = self.end,
+            force = self.force, halfforce = 0.5*force,
+            maxAxis = modifiable.maxAxis;
+
+        if ((0 == axes) || (0 == force)) return self;
+
+        MOD3.List.each(modifiable.vertices, function(v) {
+            var r = stdMath.random() * force - halfforce,
+                p = v.getRatio(maxAxis), rp, xyz;
+            if (start < end)
+            {
+                if (p < start) p = 0;
+                else if (p > end) p = 1;
+            }
+            else if (start > end)
+            {
+                p = 1 - p;
+                if (p > start) p = 0;
+                else if (p < end) p = 1;
+            }
+            else
+            {
+                p = 1;
+            }
+
+            rp = r * p;
+            xyz = v.getXYZ();
+            v.setXYZ([
+                xyz[0] + (axes & MOD3.ModConstant.X ? rp : 0),
+                xyz[1] + (axes & MOD3.ModConstant.Y ? rp : 0),
+                xyz[2] + (axes & MOD3.ModConstant.Z ? rp : 0)
+            ]);
+        });
+        return self;
+    }
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  DisplaceMap (BitmapDisplacement) Modifier
+**/
+
+/**[DOC_MD]
+ * ### DisplaceMap (BitmapDisplacement) Modifier
+ *
+ * Displaces vertices based on RGB values of bitmapData pixels.
+ *
+ * BitmapDisplacement is inspired by both the AS3 built-in DisplacementMapFilter. It allows
+ * to use color values for each channels of a bitmap to modify the position of vertices in a mesh.
+ *
+ * The displacement takes place along the cardinal axes, and each axis is mapped to a
+ * channel in the bitmap: X for Red, Y for Green and Z for Blue.
+ *
+ * @author Bartek Drozdz
+ *
+[/DOC_MD]**/
+MOD3.DisplaceMap = MOD3.Class(MOD3.Modifier, {
+    constructor: function DisplaceMap(bmp, force, offset) {
+        var self = this;
+        if (!(self instanceof DisplaceMap)) return new DisplaceMap(bmp, force, offset);
+        self.$super('constructor');
+        self.name = 'DisplaceMap';
+        if (+bmp === bmp) // number
+        {
+            self.force = bmp || 1;
+            self.offset = null == force ? 127 : force;// 0x7F;
+        }
+        else
+        {
+            self.setBitmap(bmp);
+            self.force = force || 1;
+            self.offset = null == offset ? 127 : offset;// 0x7F;
+        }
+        self.axes = MOD3.ModConstant.X | MOD3.ModConstant.Y | MOD3.ModConstant.Z;
+    },
+
+    width: null,
+    height: null,
+    bmpData: null,
+    force: 1,
+    offset: 127,
+
+    dispose: function() {
+        var self = this;
+        self.bmpData = null;
+        self.width = null;
+        self.height = null;
+        self.force = null;
+        self.offset = null;
+        self.$super('dispose');
+        return self;
+    },
+
+    setBitmap: function(bmpData) {
+        var self = this;
+        self.bmpData = bmpData ? bmpData.data : null;
+        self.width = bmpData ? bmpData.width : 0;
+        self.height = bmpData ? bmpData.height : 0;
+        return self;
+    },
+
+    apply: function(modifiable) {
+        var self = this,
+            axes = self.axes,
+            w = self.width, h = self.height, bmp = self.bmpData,
+            force = self.force, offset = self.offset;
+
+        if (!axes || !bmp) return self;
+
+        MOD3.List.each(modifiable.vertices, function(v) {
+            var uv, uu, vv, xyz = v.getXYZ();
+
+            uu = ~~((w - 1) * v.ratio[0]/* X */);
+            vv = ~~((h - 1) * v.ratio[2]/* Z */);
+            uv = (vv * w + uu) << 2;
+
+            v.setXYZ([
+                xyz[0] + (axes & MOD3.ModConstant.X ? ((bmp[uv] & 0xff) - offset) * force : 0),
+                xyz[1] + (axes & MOD3.ModConstant.Y ? ((bmp[uv+1] & 0xff) - offset) * force : 0),
+                xyz[2] + (axes & MOD3.ModConstant.Z ? ((bmp[uv+2] & 0xff) - offset) * force : 0)
+            ]);
+        });
+        return self;
+    }
+});
+}(MOD3);!function(MOD3) {
+"use strict";
+/**
+* MOD3  Perlin/Simplex Noise Modifier
+**/
+
+/**[DOC_MD]
+ * ### Perlin modifier
+ *
+ *  Displaces vertices based on a perlin/simplex noise source.
+ *
+ *  Accepts a perlin/simplex noise data (with width and height information) and displaces vertices
+ *  based on the value of each point of the noise map.
+ *
+ *  @author Bartek Drozdz
+ *
+ *  @uses: https://github.com/josephg/noisejs for JavaScript
+ *
+[/DOC_MD]**/
+function cyclic_shift(a, w, h, dX, dY)
+{
+    var size = w*h, b = new MOD3.VecArray(size), i, j, i2, j2, index;
+    if (dX < 0) dX += w;
+    if (dY < 0) dY += h;
+    dX = ~~dX; dY = ~~dY;
+    for (i=0,j=0,index=0; index<size; ++index,++i)
+    {
+        if (i >= w) {i = 0; ++j;}
+        i2 = (i + dX) % w; j2 = (j + dY) % h;
+        b[index] = a[i2 + j2 * w];
+    }
+    return b;
+}
+/*function generate2d(perlinNoise2d, w, h)
+{
+    var size = w*h, a = new MOD3.VecArray(size), i, j, index;
+    for (i=0,j=0,index=0; index<size; ++index,++i)
+    {
+        if (i >= w) {i = 0; ++j;}
+        a[index] = perlinNoise2d(i/w, j/h);
+    }
+    return a;
+}*/
+MOD3.Perlin = MOD3.Class(MOD3.Modifier, {
+    constructor: function Perlin(force, noise, autoRun) {
+        var self = this;
+        if (!(self instanceof Perlin)) return new Perlin(force, noise, autoRun);
+        self.$super('constructor');
+        self.name = 'Perlin';
+        self.force = null != force ? force : 1;
+        self.perlin = noise;
+        self.autoRun = null != autoRun ? !!autoRun : true;
+        self.axes = MOD3.ModConstant.X | MOD3.ModConstant.Y | MOD3.ModConstant.Z;
+    },
+
+    speedX: 1,
+    speedY: 1,
+    perlin: null,
+    force: 1,
+    offset: 0,
+    autoRun: true,
+
+    dispose: function() {
+        var self = this;
+        self.perlin = null;
+        self.speedX = null;
+        self.speedY = null;
+        self.force = null;
+        self.offset = null;
+        self.autoRun = null;
+        self.$super('dispose');
+
+        return self;
+    },
+
+    setSpeed: function(dX, dY) {
+        var self = this;
+        self.speedX = dX;
+        self.speedY = dY;
+        return self;
+    },
+
+    apply: function(modifiable) {
+        var self = this,
+            axes = self.axes, force = self.force,
+            offset = self.offset, pn = self.perlin,
+            w, h;
+
+        if (!axes || !pn) return self;
+        w = pn.width; h = pn.height;
+        if (self.autoRun)
+        {
+            pn = self.perlin = cyclic_shift(pn, w, h, self.speedX, self.speedY);
+            pn.width = w; pn.height = h;
+        }
+
+        MOD3.List.each(modifiable.vertices, function(v) {
+            var xyz = v.getXYZ(),
+                uu = ~~((w - 1) * v.ratio[0]/* u */),
+                vv = ~~((h - 1) * v.ratio[2]/* v */),
+                uv = uu + vv * w;
+
+            v.setXYZ([
+                xyz[0] + (axes & MOD3.ModConstant.X ? (pn[uv] - offset) * force : 0),
+                xyz[1] + (axes & MOD3.ModConstant.Y ? (pn[uv/*+1*/] - offset) * force : 0),
+                xyz[2] + (axes & MOD3.ModConstant.Z ? (pn[uv/*+2*/] - offset) * force : 0)
+            ]);
+        });
+        return self;
+    }
+});
+}(MOD3);// export it
+return MOD3;
+});