Upload 6 files

libs/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);

libs/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;
+});

libs/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;
+});