CDSS-daming-web/node_modules/better-scroll/dist/better-scroll.js

/*!
 * better-scroll / better-scroll
 * (c) 2016-2021 ustbhuangyi
 * Released under the MIT License.
 */
(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
    typeof define === 'function' && define.amd ? define(['exports'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BetterScroll = {}));
}(this, (function (exports) { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */
    /* global Reflect, Promise */

    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    var __assign = function() {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };

    function __awaiter(thisArg, _arguments, P, generator) {
        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
        return new (P || (P = Promise))(function (resolve, reject) {
            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
            step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
    }

    function __generator(thisArg, body) {
        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f) throw new TypeError("Generator is already executing.");
            while (_) try {
                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
                if (y = 0, t) op = [op[0] & 2, t.value];
                switch (op[0]) {
                    case 0: case 1: t = op; break;
                    case 4: _.label++; return { value: op[1], done: false };
                    case 5: _.label++; y = op[1]; op = [0]; continue;
                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
                    default:
                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                        if (t[2]) _.ops.pop();
                        _.trys.pop(); continue;
                }
                op = body.call(thisArg, _);
            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
        }
    }

    function __spreadArrays() {
        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
        for (var r = Array(s), k = 0, i = 0; i < il; i++)
            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
                r[k] = a[j];
        return r;
    }

    var propertiesConfig$7 = [
        {
            sourceKey: 'scroller.scrollBehaviorX.currentPos',
            key: 'x'
        },
        {
            sourceKey: 'scroller.scrollBehaviorY.currentPos',
            key: 'y'
        },
        {
            sourceKey: 'scroller.scrollBehaviorX.hasScroll',
            key: 'hasHorizontalScroll'
        },
        {
            sourceKey: 'scroller.scrollBehaviorY.hasScroll',
            key: 'hasVerticalScroll'
        },
        {
            sourceKey: 'scroller.scrollBehaviorX.contentSize',
            key: 'scrollerWidth'
        },
        {
            sourceKey: 'scroller.scrollBehaviorY.contentSize',
            key: 'scrollerHeight'
        },
        {
            sourceKey: 'scroller.scrollBehaviorX.maxScrollPos',
            key: 'maxScrollX'
        },
        {
            sourceKey: 'scroller.scrollBehaviorY.maxScrollPos',
            key: 'maxScrollY'
        },
        {
            sourceKey: 'scroller.scrollBehaviorX.minScrollPos',
            key: 'minScrollX'
        },
        {
            sourceKey: 'scroller.scrollBehaviorY.minScrollPos',
            key: 'minScrollY'
        },
        {
            sourceKey: 'scroller.scrollBehaviorX.movingDirection',
            key: 'movingDirectionX'
        },
        {
            sourceKey: 'scroller.scrollBehaviorY.movingDirection',
            key: 'movingDirectionY'
        },
        {
            sourceKey: 'scroller.scrollBehaviorX.direction',
            key: 'directionX'
        },
        {
            sourceKey: 'scroller.scrollBehaviorY.direction',
            key: 'directionY'
        },
        {
            sourceKey: 'scroller.actions.enabled',
            key: 'enabled'
        },
        {
            sourceKey: 'scroller.animater.pending',
            key: 'pending'
        },
        {
            sourceKey: 'scroller.animater.stop',
            key: 'stop'
        },
        {
            sourceKey: 'scroller.scrollTo',
            key: 'scrollTo'
        },
        {
            sourceKey: 'scroller.scrollBy',
            key: 'scrollBy'
        },
        {
            sourceKey: 'scroller.scrollToElement',
            key: 'scrollToElement'
        },
        {
            sourceKey: 'scroller.resetPosition',
            key: 'resetPosition'
        }
    ];

    function warn(msg) {
        console.error("[BScroll warn]: " + msg);
    }
    function assert(condition, msg) {
        if (!condition) {
            throw new Error('[BScroll] ' + msg);
        }
    }

    // ssr support
    var inBrowser = typeof window !== 'undefined';
    var ua = inBrowser && navigator.userAgent.toLowerCase();
    var isWeChatDevTools = !!(ua && /wechatdevtools/.test(ua));
    var isAndroid = ua && ua.indexOf('android') > 0;
    /* istanbul ignore next */
    var isIOSBadVersion = (function () {
        if (typeof ua === 'string') {
            var regex = /os (\d\d?_\d(_\d)?)/;
            var matches = regex.exec(ua);
            if (!matches)
                return false;
            var parts = matches[1].split('_').map(function (item) {
                return parseInt(item, 10);
            });
            // ios version >= 13.4 issue 982
            return !!(parts[0] === 13 && parts[1] >= 4);
        }
        return false;
    })();
    /* istanbul ignore next */
    var supportsPassive = false;
    /* istanbul ignore next */
    if (inBrowser) {
        var EventName = 'test-passive';
        try {
            var opts = {};
            Object.defineProperty(opts, 'passive', {
                get: function () {
                    supportsPassive = true;
                },
            }); // https://github.com/facebook/flow/issues/285
            window.addEventListener(EventName, function () { }, opts);
        }
        catch (e) { }
    }

    function getNow() {
        return window.performance &&
            window.performance.now &&
            window.performance.timing
            ? window.performance.now() + window.performance.timing.navigationStart
            : +new Date();
    }
    var extend = function (target, source) {
        for (var key in source) {
            target[key] = source[key];
        }
        return target;
    };
    function isUndef(v) {
        return v === undefined || v === null;
    }
    function getDistance(x, y) {
        return Math.sqrt(x * x + y * y);
    }
    function between(x, min, max) {
        if (x < min) {
            return min;
        }
        if (x > max) {
            return max;
        }
        return x;
    }
    function findIndex(ary, fn) {
        if (ary.findIndex) {
            return ary.findIndex(fn);
        }
        var index = -1;
        ary.some(function (item, i, ary) {
            var ret = fn(item, i, ary);
            if (ret) {
                index = i;
                return ret;
            }
        });
        return index;
    }

    var elementStyle = (inBrowser &&
        document.createElement('div').style);
    var vendor = (function () {
        /* istanbul ignore if  */
        if (!inBrowser) {
            return false;
        }
        var transformNames = [
            {
                key: 'standard',
                value: 'transform',
            },
            {
                key: 'webkit',
                value: 'webkitTransform',
            },
            {
                key: 'Moz',
                value: 'MozTransform',
            },
            {
                key: 'O',
                value: 'OTransform',
            },
            {
                key: 'ms',
                value: 'msTransform',
            },
        ];
        for (var _i = 0, transformNames_1 = transformNames; _i < transformNames_1.length; _i++) {
            var obj = transformNames_1[_i];
            if (elementStyle[obj.value] !== undefined) {
                return obj.key;
            }
        }
        /* istanbul ignore next  */
        return false;
    })();
    /* istanbul ignore next  */
    function prefixStyle(style) {
        if (vendor === false) {
            return style;
        }
        if (vendor === 'standard') {
            if (style === 'transitionEnd') {
                return 'transitionend';
            }
            return style;
        }
        return vendor + style.charAt(0).toUpperCase() + style.substr(1);
    }
    function getElement(el) {
        return (typeof el === 'string'
            ? document.querySelector(el)
            : el);
    }
    function addEvent(el, type, fn, capture) {
        var useCapture = supportsPassive
            ? {
                passive: false,
                capture: !!capture,
            }
            : !!capture;
        el.addEventListener(type, fn, useCapture);
    }
    function removeEvent(el, type, fn, capture) {
        el.removeEventListener(type, fn, {
            capture: !!capture,
        });
    }
    function offset(el) {
        var left = 0;
        var top = 0;
        while (el) {
            left -= el.offsetLeft;
            top -= el.offsetTop;
            el = el.offsetParent;
        }
        return {
            left: left,
            top: top,
        };
    }
    function offsetToBody(el) {
        var rect = el.getBoundingClientRect();
        return {
            left: -(rect.left + window.pageXOffset),
            top: -(rect.top + window.pageYOffset),
        };
    }
    var cssVendor = vendor && vendor !== 'standard' ? '-' + vendor.toLowerCase() + '-' : '';
    var transform = prefixStyle('transform');
    var transition = prefixStyle('transition');
    var hasPerspective = inBrowser && prefixStyle('perspective') in elementStyle;
    // fix issue #361
    var hasTouch = inBrowser && ('ontouchstart' in window || isWeChatDevTools);
    var hasTransition = inBrowser && transition in elementStyle;
    var style = {
        transform: transform,
        transition: transition,
        transitionTimingFunction: prefixStyle('transitionTimingFunction'),
        transitionDuration: prefixStyle('transitionDuration'),
        transitionDelay: prefixStyle('transitionDelay'),
        transformOrigin: prefixStyle('transformOrigin'),
        transitionEnd: prefixStyle('transitionEnd'),
        transitionProperty: prefixStyle('transitionProperty'),
    };
    var eventTypeMap = {
        touchstart: 1,
        touchmove: 1,
        touchend: 1,
        touchcancel: 1,
        mousedown: 2,
        mousemove: 2,
        mouseup: 2,
    };
    function getRect(el) {
        /* istanbul ignore if  */
        if (el instanceof window.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,
            };
        }
    }
    function preventDefaultExceptionFn(el, exceptions) {
        for (var i in exceptions) {
            if (exceptions[i].test(el[i])) {
                return true;
            }
        }
        return false;
    }
    var tagExceptionFn = preventDefaultExceptionFn;
    function tap(e, eventName) {
        var ev = document.createEvent('Event');
        ev.initEvent(eventName, true, true);
        ev.pageX = e.pageX;
        ev.pageY = e.pageY;
        e.target.dispatchEvent(ev);
    }
    function click(e, event) {
        if (event === void 0) { event = 'click'; }
        var eventSource;
        if (e.type === 'mouseup') {
            eventSource = e;
        }
        else if (e.type === 'touchend' || e.type === 'touchcancel') {
            eventSource = e.changedTouches[0];
        }
        var posSrc = {};
        if (eventSource) {
            posSrc.screenX = eventSource.screenX || 0;
            posSrc.screenY = eventSource.screenY || 0;
            posSrc.clientX = eventSource.clientX || 0;
            posSrc.clientY = eventSource.clientY || 0;
        }
        var ev;
        var bubbles = true;
        var cancelable = true;
        var ctrlKey = e.ctrlKey, shiftKey = e.shiftKey, altKey = e.altKey, metaKey = e.metaKey;
        var pressedKeysMap = {
            ctrlKey: ctrlKey,
            shiftKey: shiftKey,
            altKey: altKey,
            metaKey: metaKey,
        };
        if (typeof MouseEvent !== 'undefined') {
            try {
                ev = new MouseEvent(event, extend(__assign({ bubbles: bubbles,
                    cancelable: cancelable }, pressedKeysMap), posSrc));
            }
            catch (e) {
                /* istanbul ignore next */
                createEvent();
            }
        }
        else {
            createEvent();
        }
        function createEvent() {
            ev = document.createEvent('Event');
            ev.initEvent(event, bubbles, cancelable);
            extend(ev, posSrc);
        }
        // forwardedTouchEvent set to true in case of the conflict with fastclick
        ev.forwardedTouchEvent = true;
        ev._constructed = true;
        e.target.dispatchEvent(ev);
    }
    function dblclick(e) {
        click(e, 'dblclick');
    }
    function prepend(el, target) {
        var firstChild = target.firstChild;
        if (firstChild) {
            before(el, firstChild);
        }
        else {
            target.appendChild(el);
        }
    }
    function before(el, target) {
        var parentNode = target.parentNode;
        parentNode.insertBefore(el, target);
    }
    function removeChild(el, child) {
        el.removeChild(child);
    }
    function hasClass(el, className) {
        var reg = new RegExp('(^|\\s)' + className + '(\\s|$)');
        return reg.test(el.className);
    }
    function HTMLCollectionToArray(el) {
        return Array.prototype.slice.call(el, 0);
    }
    function getClientSize(el) {
        return {
            width: el.clientWidth,
            height: el.clientHeight,
        };
    }

    var ease = {
        // easeOutQuint
        swipe: {
            style: 'cubic-bezier(0.23, 1, 0.32, 1)',
            fn: function (t) {
                return 1 + --t * t * t * t * t;
            }
        },
        // easeOutQuard
        swipeBounce: {
            style: 'cubic-bezier(0.25, 0.46, 0.45, 0.94)',
            fn: function (t) {
                return t * (2 - t);
            }
        },
        // easeOutQuart
        bounce: {
            style: 'cubic-bezier(0.165, 0.84, 0.44, 1)',
            fn: function (t) {
                return 1 - --t * t * t * t;
            }
        }
    };

    var DEFAULT_INTERVAL = 1000 / 60;
    var windowCompat = inBrowser && window;
    /* istanbul ignore next */
    function noop$1() { }
    var requestAnimationFrame = (function () {
        /* istanbul ignore if  */
        if (!inBrowser) {
            return noop$1;
        }
        return (windowCompat.requestAnimationFrame ||
            windowCompat.webkitRequestAnimationFrame ||
            windowCompat.mozRequestAnimationFrame ||
            windowCompat.oRequestAnimationFrame ||
            // if all else fails, use setTimeout
            function (callback) {
                return window.setTimeout(callback, callback.interval || DEFAULT_INTERVAL); // make interval as precise as possible.
            });
    })();
    var cancelAnimationFrame = (function () {
        /* istanbul ignore if  */
        if (!inBrowser) {
            return noop$1;
        }
        return (windowCompat.cancelAnimationFrame ||
            windowCompat.webkitCancelAnimationFrame ||
            windowCompat.mozCancelAnimationFrame ||
            windowCompat.oCancelAnimationFrame ||
            function (id) {
                window.clearTimeout(id);
            });
    })();

    /* istanbul ignore next */
    var noop = function (val) { };
    var sharedPropertyDefinition = {
        enumerable: true,
        configurable: true,
        get: noop,
        set: noop,
    };
    var getProperty = function (obj, key) {
        var keys = key.split('.');
        for (var i = 0; i < keys.length - 1; i++) {
            obj = obj[keys[i]];
            if (typeof obj !== 'object' || !obj)
                return;
        }
        var lastKey = keys.pop();
        if (typeof obj[lastKey] === 'function') {
            return function () {
                return obj[lastKey].apply(obj, arguments);
            };
        }
        else {
            return obj[lastKey];
        }
    };
    var setProperty = function (obj, key, value) {
        var keys = key.split('.');
        var temp;
        for (var i = 0; i < keys.length - 1; i++) {
            temp = keys[i];
            if (!obj[temp])
                obj[temp] = {};
            obj = obj[temp];
        }
        obj[keys.pop()] = value;
    };
    function propertiesProxy(target, sourceKey, key) {
        sharedPropertyDefinition.get = function proxyGetter() {
            return getProperty(this, sourceKey);
        };
        sharedPropertyDefinition.set = function proxySetter(val) {
            setProperty(this, sourceKey, val);
        };
        Object.defineProperty(target, key, sharedPropertyDefinition);
    }

    var EventEmitter = /** @class */ (function () {
        function EventEmitter(names) {
            this.events = {};
            this.eventTypes = {};
            this.registerType(names);
        }
        EventEmitter.prototype.on = function (type, fn, context) {
            if (context === void 0) { context = this; }
            this.hasType(type);
            if (!this.events[type]) {
                this.events[type] = [];
            }
            this.events[type].push([fn, context]);
            return this;
        };
        EventEmitter.prototype.once = function (type, fn, context) {
            var _this = this;
            if (context === void 0) { context = this; }
            this.hasType(type);
            var magic = function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                _this.off(type, magic);
                var ret = fn.apply(context, args);
                if (ret === true) {
                    return ret;
                }
            };
            magic.fn = fn;
            this.on(type, magic);
            return this;
        };
        EventEmitter.prototype.off = function (type, fn) {
            if (!type && !fn) {
                this.events = {};
                return this;
            }
            if (type) {
                this.hasType(type);
                if (!fn) {
                    this.events[type] = [];
                    return this;
                }
                var events = this.events[type];
                if (!events) {
                    return this;
                }
                var count = events.length;
                while (count--) {
                    if (events[count][0] === fn ||
                        (events[count][0] && events[count][0].fn === fn)) {
                        events.splice(count, 1);
                    }
                }
                return this;
            }
        };
        EventEmitter.prototype.trigger = function (type) {
            var args = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                args[_i - 1] = arguments[_i];
            }
            this.hasType(type);
            var events = this.events[type];
            if (!events) {
                return;
            }
            var len = events.length;
            var eventsCopy = __spreadArrays(events);
            var ret;
            for (var i = 0; i < len; i++) {
                var event_1 = eventsCopy[i];
                var fn = event_1[0], context = event_1[1];
                if (fn) {
                    ret = fn.apply(context, args);
                    if (ret === true) {
                        return ret;
                    }
                }
            }
        };
        EventEmitter.prototype.registerType = function (names) {
            var _this = this;
            names.forEach(function (type) {
                _this.eventTypes[type] = type;
            });
        };
        EventEmitter.prototype.destroy = function () {
            this.events = {};
            this.eventTypes = {};
        };
        EventEmitter.prototype.hasType = function (type) {
            var types = this.eventTypes;
            var isType = types[type] === type;
            if (!isType) {
                warn("EventEmitter has used unknown event type: \"" + type + "\", should be oneof [" +
                    ("" + Object.keys(types).map(function (_) { return JSON.stringify(_); })) +
                    "]");
            }
        };
        return EventEmitter;
    }());
    var EventRegister = /** @class */ (function () {
        function EventRegister(wrapper, events) {
            this.wrapper = wrapper;
            this.events = events;
            this.addDOMEvents();
        }
        EventRegister.prototype.destroy = function () {
            this.removeDOMEvents();
            this.events = [];
        };
        EventRegister.prototype.addDOMEvents = function () {
            this.handleDOMEvents(addEvent);
        };
        EventRegister.prototype.removeDOMEvents = function () {
            this.handleDOMEvents(removeEvent);
        };
        EventRegister.prototype.handleDOMEvents = function (eventOperation) {
            var _this = this;
            var wrapper = this.wrapper;
            this.events.forEach(function (event) {
                eventOperation(wrapper, event.name, _this, !!event.capture);
            });
        };
        EventRegister.prototype.handleEvent = function (e) {
            var eventType = e.type;
            this.events.some(function (event) {
                if (event.name === eventType) {
                    event.handler(e);
                    return true;
                }
                return false;
            });
        };
        return EventRegister;
    }());

    var CustomOptions = /** @class */ (function () {
        function CustomOptions() {
        }
        return CustomOptions;
    }());
    var OptionsConstructor = /** @class */ (function (_super) {
        __extends(OptionsConstructor, _super);
        function OptionsConstructor() {
            var _this = _super.call(this) || this;
            _this.startX = 0;
            _this.startY = 0;
            _this.scrollX = false;
            _this.scrollY = true;
            _this.freeScroll = false;
            _this.directionLockThreshold = 0;
            _this.eventPassthrough = "" /* None */;
            _this.click = false;
            _this.dblclick = false;
            _this.tap = '';
            _this.bounce = {
                top: true,
                bottom: true,
                left: true,
                right: true,
            };
            _this.bounceTime = 800;
            _this.momentum = true;
            _this.momentumLimitTime = 300;
            _this.momentumLimitDistance = 15;
            _this.swipeTime = 2500;
            _this.swipeBounceTime = 500;
            _this.deceleration = 0.0015;
            _this.flickLimitTime = 200;
            _this.flickLimitDistance = 100;
            _this.resizePolling = 60;
            _this.probeType = 0 /* Default */;
            _this.stopPropagation = false;
            _this.preventDefault = true;
            _this.preventDefaultException = {
                tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT|AUDIO)$/,
            };
            _this.tagException = {
                tagName: /^TEXTAREA$/,
            };
            _this.HWCompositing = true;
            _this.useTransition = true;
            _this.bindToWrapper = false;
            _this.bindToTarget = false;
            _this.disableMouse = hasTouch;
            _this.disableTouch = !hasTouch;
            _this.autoBlur = true;
            _this.autoEndDistance = 5;
            _this.outOfBoundaryDampingFactor = 1 / 3;
            _this.specifiedIndexAsContent = 0;
            _this.quadrant = 1 /* First */;
            return _this;
        }
        OptionsConstructor.prototype.merge = function (options) {
            if (!options)
                return this;
            for (var key in options) {
                if (key === 'bounce') {
                    this.bounce = this.resolveBounce(options[key]);
                    continue;
                }
                this[key] = options[key];
            }
            return this;
        };
        OptionsConstructor.prototype.process = function () {
            this.translateZ =
                this.HWCompositing && hasPerspective ? ' translateZ(1px)' : '';
            this.useTransition = this.useTransition && hasTransition;
            this.preventDefault = !this.eventPassthrough && this.preventDefault;
            // If you want eventPassthrough I have to lock one of the axes
            this.scrollX =
                this.eventPassthrough === "horizontal" /* Horizontal */
                    ? false
                    : this.scrollX;
            this.scrollY =
                this.eventPassthrough === "vertical" /* Vertical */ ? false : this.scrollY;
            // With eventPassthrough we also need lockDirection mechanism
            this.freeScroll = this.freeScroll && !this.eventPassthrough;
            // force true when freeScroll is true
            this.scrollX = this.freeScroll ? true : this.scrollX;
            this.scrollY = this.freeScroll ? true : this.scrollY;
            this.directionLockThreshold = this.eventPassthrough
                ? 0
                : this.directionLockThreshold;
            return this;
        };
        OptionsConstructor.prototype.resolveBounce = function (bounceOptions) {
            var DEFAULT_BOUNCE = {
                top: true,
                right: true,
                bottom: true,
                left: true,
            };
            var NEGATED_BOUNCE = {
                top: false,
                right: false,
                bottom: false,
                left: false,
            };
            var ret;
            if (typeof bounceOptions === 'object') {
                ret = extend(DEFAULT_BOUNCE, bounceOptions);
            }
            else {
                ret = bounceOptions ? DEFAULT_BOUNCE : NEGATED_BOUNCE;
            }
            return ret;
        };
        return OptionsConstructor;
    }(CustomOptions));

    var ActionsHandler = /** @class */ (function () {
        function ActionsHandler(wrapper, options) {
            this.wrapper = wrapper;
            this.options = options;
            this.hooks = new EventEmitter([
                'beforeStart',
                'start',
                'move',
                'end',
                'click',
            ]);
            this.handleDOMEvents();
        }
        ActionsHandler.prototype.handleDOMEvents = function () {
            var _a = this.options, bindToWrapper = _a.bindToWrapper, disableMouse = _a.disableMouse, disableTouch = _a.disableTouch, click = _a.click;
            var wrapper = this.wrapper;
            var target = bindToWrapper ? wrapper : window;
            var wrapperEvents = [];
            var targetEvents = [];
            var shouldRegisterTouch = !disableTouch;
            var shouldRegisterMouse = !disableMouse;
            if (click) {
                wrapperEvents.push({
                    name: 'click',
                    handler: this.click.bind(this),
                    capture: true,
                });
            }
            if (shouldRegisterTouch) {
                wrapperEvents.push({
                    name: 'touchstart',
                    handler: this.start.bind(this),
                });
                targetEvents.push({
                    name: 'touchmove',
                    handler: this.move.bind(this),
                }, {
                    name: 'touchend',
                    handler: this.end.bind(this),
                }, {
                    name: 'touchcancel',
                    handler: this.end.bind(this),
                });
            }
            if (shouldRegisterMouse) {
                wrapperEvents.push({
                    name: 'mousedown',
                    handler: this.start.bind(this),
                });
                targetEvents.push({
                    name: 'mousemove',
                    handler: this.move.bind(this),
                }, {
                    name: 'mouseup',
                    handler: this.end.bind(this),
                });
            }
            this.wrapperEventRegister = new EventRegister(wrapper, wrapperEvents);
            this.targetEventRegister = new EventRegister(target, targetEvents);
        };
        ActionsHandler.prototype.beforeHandler = function (e, type) {
            var _a = this.options, preventDefault = _a.preventDefault, stopPropagation = _a.stopPropagation, preventDefaultException = _a.preventDefaultException;
            var preventDefaultConditions = {
                start: function () {
                    return (preventDefault &&
                        !preventDefaultExceptionFn(e.target, preventDefaultException));
                },
                end: function () {
                    return (preventDefault &&
                        !preventDefaultExceptionFn(e.target, preventDefaultException));
                },
                move: function () {
                    return preventDefault;
                },
            };
            if (preventDefaultConditions[type]()) {
                e.preventDefault();
            }
            if (stopPropagation) {
                e.stopPropagation();
            }
        };
        ActionsHandler.prototype.setInitiated = function (type) {
            if (type === void 0) { type = 0; }
            this.initiated = type;
        };
        ActionsHandler.prototype.start = function (e) {
            var _eventType = eventTypeMap[e.type];
            if (this.initiated && this.initiated !== _eventType) {
                return;
            }
            this.setInitiated(_eventType);
            // if textarea or other html tags in options.tagException is manipulated
            // do not make bs scroll
            if (tagExceptionFn(e.target, this.options.tagException)) {
                this.setInitiated();
                return;
            }
            // only allow mouse left button
            if (_eventType === 2 /* Mouse */ && e.button !== 0 /* Left */)
                return;
            if (this.hooks.trigger(this.hooks.eventTypes.beforeStart, e)) {
                return;
            }
            this.beforeHandler(e, 'start');
            var point = (e.touches ? e.touches[0] : e);
            this.pointX = point.pageX;
            this.pointY = point.pageY;
            this.hooks.trigger(this.hooks.eventTypes.start, e);
        };
        ActionsHandler.prototype.move = function (e) {
            if (eventTypeMap[e.type] !== this.initiated) {
                return;
            }
            this.beforeHandler(e, 'move');
            var point = (e.touches ? e.touches[0] : e);
            var deltaX = point.pageX - this.pointX;
            var deltaY = point.pageY - this.pointY;
            this.pointX = point.pageX;
            this.pointY = point.pageY;
            if (this.hooks.trigger(this.hooks.eventTypes.move, {
                deltaX: deltaX,
                deltaY: deltaY,
                e: e,
            })) {
                return;
            }
            // auto end when out of viewport
            var scrollLeft = document.documentElement.scrollLeft ||
                window.pageXOffset ||
                document.body.scrollLeft;
            var scrollTop = document.documentElement.scrollTop ||
                window.pageYOffset ||
                document.body.scrollTop;
            var pX = this.pointX - scrollLeft;
            var pY = this.pointY - scrollTop;
            var autoEndDistance = this.options.autoEndDistance;
            if (pX > document.documentElement.clientWidth - autoEndDistance ||
                pY > document.documentElement.clientHeight - autoEndDistance ||
                pX < autoEndDistance ||
                pY < autoEndDistance) {
                this.end(e);
            }
        };
        ActionsHandler.prototype.end = function (e) {
            if (eventTypeMap[e.type] !== this.initiated) {
                return;
            }
            this.setInitiated();
            this.beforeHandler(e, 'end');
            this.hooks.trigger(this.hooks.eventTypes.end, e);
        };
        ActionsHandler.prototype.click = function (e) {
            this.hooks.trigger(this.hooks.eventTypes.click, e);
        };
        ActionsHandler.prototype.setContent = function (content) {
            if (content !== this.wrapper) {
                this.wrapper = content;
                this.rebindDOMEvents();
            }
        };
        ActionsHandler.prototype.rebindDOMEvents = function () {
            this.wrapperEventRegister.destroy();
            this.targetEventRegister.destroy();
            this.handleDOMEvents();
        };
        ActionsHandler.prototype.destroy = function () {
            this.wrapperEventRegister.destroy();
            this.targetEventRegister.destroy();
            this.hooks.destroy();
        };
        return ActionsHandler;
    }());

    var translaterMetaData = {
        x: ['translateX', 'px'],
        y: ['translateY', 'px'],
    };
    var Translater = /** @class */ (function () {
        function Translater(content) {
            this.setContent(content);
            this.hooks = new EventEmitter(['beforeTranslate', 'translate']);
        }
        Translater.prototype.getComputedPosition = function () {
            var cssStyle = window.getComputedStyle(this.content, null);
            var matrix = cssStyle[style.transform].split(')')[0].split(', ');
            var x = +(matrix[12] || matrix[4]) || 0;
            var y = +(matrix[13] || matrix[5]) || 0;
            return {
                x: x,
                y: y,
            };
        };
        Translater.prototype.translate = function (point) {
            var transformStyle = [];
            Object.keys(point).forEach(function (key) {
                if (!translaterMetaData[key]) {
                    return;
                }
                var transformFnName = translaterMetaData[key][0];
                if (transformFnName) {
                    var transformFnArgUnit = translaterMetaData[key][1];
                    var transformFnArg = point[key];
                    transformStyle.push(transformFnName + "(" + transformFnArg + transformFnArgUnit + ")");
                }
            });
            this.hooks.trigger(this.hooks.eventTypes.beforeTranslate, transformStyle, point);
            this.style[style.transform] = transformStyle.join(' ');
            this.hooks.trigger(this.hooks.eventTypes.translate, point);
        };
        Translater.prototype.setContent = function (content) {
            if (this.content !== content) {
                this.content = content;
                this.style = content.style;
            }
        };
        Translater.prototype.destroy = function () {
            this.hooks.destroy();
        };
        return Translater;
    }());

    var Base = /** @class */ (function () {
        function Base(content, translater, options) {
            this.translater = translater;
            this.options = options;
            this.timer = 0;
            this.hooks = new EventEmitter([
                'move',
                'end',
                'beforeForceStop',
                'forceStop',
                'callStop',
                'time',
                'timeFunction',
            ]);
            this.setContent(content);
        }
        Base.prototype.translate = function (endPoint) {
            this.translater.translate(endPoint);
        };
        Base.prototype.setPending = function (pending) {
            this.pending = pending;
        };
        Base.prototype.setForceStopped = function (forceStopped) {
            this.forceStopped = forceStopped;
        };
        Base.prototype.setCallStop = function (called) {
            this.callStopWhenPending = called;
        };
        Base.prototype.setContent = function (content) {
            if (this.content !== content) {
                this.content = content;
                this.style = content.style;
                this.stop();
            }
        };
        Base.prototype.clearTimer = function () {
            if (this.timer) {
                cancelAnimationFrame(this.timer);
                this.timer = 0;
            }
        };
        Base.prototype.destroy = function () {
            this.hooks.destroy();
            cancelAnimationFrame(this.timer);
        };
        return Base;
    }());

    // iOS 13.6 - 14.x, window.getComputedStyle sometimes will get wrong transform value
    // when bs use transition mode
    // eg: translateY -100px -> -200px, when the last frame which is about to scroll to -200px
    // window.getComputedStyle(this.content) will calculate transformY to be -100px(startPoint)
    // it is weird
    // so we should validate position caculated by 'window.getComputedStyle'
    var isValidPostion = function (startPoint, endPoint, currentPos, prePos) {
        var computeDirection = function (endValue, startValue) {
            var delta = endValue - startValue;
            var direction = delta > 0
                ? -1 /* Negative */
                : delta < 0
                    ? 1 /* Positive */
                    : 0 /* Default */;
            return direction;
        };
        var directionX = computeDirection(endPoint.x, startPoint.x);
        var directionY = computeDirection(endPoint.y, startPoint.y);
        var deltaX = currentPos.x - prePos.x;
        var deltaY = currentPos.y - prePos.y;
        return directionX * deltaX <= 0 && directionY * deltaY <= 0;
    };

    var Transition = /** @class */ (function (_super) {
        __extends(Transition, _super);
        function Transition() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        Transition.prototype.startProbe = function (startPoint, endPoint) {
            var _this = this;
            var prePos = startPoint;
            var probe = function () {
                var pos = _this.translater.getComputedPosition();
                if (isValidPostion(startPoint, endPoint, pos, prePos)) {
                    _this.hooks.trigger(_this.hooks.eventTypes.move, pos);
                }
                // call bs.stop() should not dispatch end hook again.
                // forceStop hook will do this.
                /* istanbul ignore if  */
                if (!_this.pending) {
                    if (_this.callStopWhenPending) {
                        _this.callStopWhenPending = false;
                    }
                    else {
                        // transition ends should dispatch end hook.
                        _this.hooks.trigger(_this.hooks.eventTypes.end, pos);
                    }
                }
                prePos = pos;
                if (_this.pending) {
                    _this.timer = requestAnimationFrame(probe);
                }
            };
            // when manually call bs.stop(), then bs.scrollTo()
            // we should reset callStopWhenPending to dispatch end hook
            if (this.callStopWhenPending) {
                this.setCallStop(false);
            }
            cancelAnimationFrame(this.timer);
            probe();
        };
        Transition.prototype.transitionTime = function (time) {
            if (time === void 0) { time = 0; }
            this.style[style.transitionDuration] = time + 'ms';
            this.hooks.trigger(this.hooks.eventTypes.time, time);
        };
        Transition.prototype.transitionTimingFunction = function (easing) {
            this.style[style.transitionTimingFunction] = easing;
            this.hooks.trigger(this.hooks.eventTypes.timeFunction, easing);
        };
        Transition.prototype.transitionProperty = function () {
            this.style[style.transitionProperty] = style.transform;
        };
        Transition.prototype.move = function (startPoint, endPoint, time, easingFn) {
            this.setPending(time > 0);
            this.transitionTimingFunction(easingFn);
            this.transitionProperty();
            this.transitionTime(time);
            this.translate(endPoint);
            var isRealtimeProbeType = this.options.probeType === 3 /* Realtime */;
            if (time && isRealtimeProbeType) {
                this.startProbe(startPoint, endPoint);
            }
            // if we change content's transformY in a tick
            // such as: 0 -> 50px -> 0
            // transitionend will not be triggered
            // so we forceupdate by reflow
            if (!time) {
                this._reflow = this.content.offsetHeight;
                if (isRealtimeProbeType) {
                    this.hooks.trigger(this.hooks.eventTypes.move, endPoint);
                }
                this.hooks.trigger(this.hooks.eventTypes.end, endPoint);
            }
        };
        Transition.prototype.doStop = function () {
            var pending = this.pending;
            this.setForceStopped(false);
            this.setCallStop(false);
            // still in transition
            if (pending) {
                this.setPending(false);
                cancelAnimationFrame(this.timer);
                var _a = this.translater.getComputedPosition(), x = _a.x, y = _a.y;
                this.transitionTime();
                this.translate({ x: x, y: y });
                this.setForceStopped(true);
                this.setCallStop(true);
                this.hooks.trigger(this.hooks.eventTypes.forceStop, { x: x, y: y });
            }
            return pending;
        };
        Transition.prototype.stop = function () {
            var stopFromTransition = this.doStop();
            if (stopFromTransition) {
                this.hooks.trigger(this.hooks.eventTypes.callStop);
            }
        };
        return Transition;
    }(Base));

    var Animation = /** @class */ (function (_super) {
        __extends(Animation, _super);
        function Animation() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        Animation.prototype.move = function (startPoint, endPoint, time, easingFn) {
            // time is 0
            if (!time) {
                this.translate(endPoint);
                if (this.options.probeType === 3 /* Realtime */) {
                    this.hooks.trigger(this.hooks.eventTypes.move, endPoint);
                }
                this.hooks.trigger(this.hooks.eventTypes.end, endPoint);
                return;
            }
            this.animate(startPoint, endPoint, time, easingFn);
        };
        Animation.prototype.animate = function (startPoint, endPoint, duration, easingFn) {
            var _this = this;
            var startTime = getNow();
            var destTime = startTime + duration;
            var isRealtimeProbeType = this.options.probeType === 3 /* Realtime */;
            var step = function () {
                var now = getNow();
                // js animation end
                if (now >= destTime) {
                    _this.translate(endPoint);
                    if (isRealtimeProbeType) {
                        _this.hooks.trigger(_this.hooks.eventTypes.move, endPoint);
                    }
                    _this.hooks.trigger(_this.hooks.eventTypes.end, endPoint);
                    return;
                }
                now = (now - startTime) / duration;
                var easing = easingFn(now);
                var newPoint = {};
                Object.keys(endPoint).forEach(function (key) {
                    var startValue = startPoint[key];
                    var endValue = endPoint[key];
                    newPoint[key] = (endValue - startValue) * easing + startValue;
                });
                _this.translate(newPoint);
                if (isRealtimeProbeType) {
                    _this.hooks.trigger(_this.hooks.eventTypes.move, newPoint);
                }
                if (_this.pending) {
                    _this.timer = requestAnimationFrame(step);
                }
                // call bs.stop() should not dispatch end hook again.
                // forceStop hook will do this.
                /* istanbul ignore if  */
                if (!_this.pending) {
                    if (_this.callStopWhenPending) {
                        _this.callStopWhenPending = false;
                    }
                    else {
                        // raf ends should dispatch end hook.
                        _this.hooks.trigger(_this.hooks.eventTypes.end, endPoint);
                    }
                }
            };
            this.setPending(true);
            // when manually call bs.stop(), then bs.scrollTo()
            // we should reset callStopWhenPending to dispatch end hook
            if (this.callStopWhenPending) {
                this.setCallStop(false);
            }
            cancelAnimationFrame(this.timer);
            step();
        };
        Animation.prototype.doStop = function () {
            var pending = this.pending;
            this.setForceStopped(false);
            this.setCallStop(false);
            // still in requestFrameAnimation
            if (pending) {
                this.setPending(false);
                cancelAnimationFrame(this.timer);
                var pos = this.translater.getComputedPosition();
                this.setForceStopped(true);
                this.setCallStop(true);
                this.hooks.trigger(this.hooks.eventTypes.forceStop, pos);
            }
            return pending;
        };
        Animation.prototype.stop = function () {
            var stopFromAnimation = this.doStop();
            if (stopFromAnimation) {
                this.hooks.trigger(this.hooks.eventTypes.callStop);
            }
        };
        return Animation;
    }(Base));

    function createAnimater(element, translater, options) {
        var useTransition = options.useTransition;
        var animaterOptions = {};
        Object.defineProperty(animaterOptions, 'probeType', {
            enumerable: true,
            configurable: false,
            get: function () {
                return options.probeType;
            },
        });
        if (useTransition) {
            return new Transition(element, translater, animaterOptions);
        }
        else {
            return new Animation(element, translater, animaterOptions);
        }
    }

    var Behavior = /** @class */ (function () {
        function Behavior(wrapper, content, options) {
            this.wrapper = wrapper;
            this.options = options;
            this.hooks = new EventEmitter([
                'beforeComputeBoundary',
                'computeBoundary',
                'momentum',
                'end',
                'ignoreHasScroll'
            ]);
            this.refresh(content);
        }
        Behavior.prototype.start = function () {
            this.dist = 0;
            this.setMovingDirection(0 /* Default */);
            this.setDirection(0 /* Default */);
        };
        Behavior.prototype.move = function (delta) {
            delta = this.hasScroll ? delta : 0;
            this.setMovingDirection(delta);
            return this.performDampingAlgorithm(delta, this.options.outOfBoundaryDampingFactor);
        };
        Behavior.prototype.setMovingDirection = function (delta) {
            this.movingDirection =
                delta > 0
                    ? -1 /* Negative */
                    : delta < 0
                        ? 1 /* Positive */
                        : 0 /* Default */;
        };
        Behavior.prototype.setDirection = function (delta) {
            this.direction =
                delta > 0
                    ? -1 /* Negative */
                    : delta < 0
                        ? 1 /* Positive */
                        : 0 /* Default */;
        };
        Behavior.prototype.performDampingAlgorithm = function (delta, dampingFactor) {
            var newPos = this.currentPos + delta;
            // Slow down or stop if outside of the boundaries
            if (newPos > this.minScrollPos || newPos < this.maxScrollPos) {
                if ((newPos > this.minScrollPos && this.options.bounces[0]) ||
                    (newPos < this.maxScrollPos && this.options.bounces[1])) {
                    newPos = this.currentPos + delta * dampingFactor;
                }
                else {
                    newPos =
                        newPos > this.minScrollPos ? this.minScrollPos : this.maxScrollPos;
                }
            }
            return newPos;
        };
        Behavior.prototype.end = function (duration) {
            var momentumInfo = {
                duration: 0
            };
            var absDist = Math.abs(this.currentPos - this.startPos);
            // start momentum animation if needed
            if (this.options.momentum &&
                duration < this.options.momentumLimitTime &&
                absDist > this.options.momentumLimitDistance) {
                var wrapperSize = (this.direction === -1 /* Negative */ && this.options.bounces[0]) ||
                    (this.direction === 1 /* Positive */ && this.options.bounces[1])
                    ? this.wrapperSize
                    : 0;
                momentumInfo = this.hasScroll
                    ? this.momentum(this.currentPos, this.startPos, duration, this.maxScrollPos, this.minScrollPos, wrapperSize, this.options)
                    : { destination: this.currentPos, duration: 0 };
            }
            else {
                this.hooks.trigger(this.hooks.eventTypes.end, momentumInfo);
            }
            return momentumInfo;
        };
        Behavior.prototype.momentum = function (current, start, time, lowerMargin, upperMargin, wrapperSize, options) {
            if (options === void 0) { options = this.options; }
            var distance = current - start;
            var speed = Math.abs(distance) / time;
            var deceleration = options.deceleration, swipeBounceTime = options.swipeBounceTime, swipeTime = options.swipeTime;
            var duration = Math.min(swipeTime, (speed * 2) / deceleration);
            var momentumData = {
                destination: current + ((speed * speed) / deceleration) * (distance < 0 ? -1 : 1),
                duration: duration,
                rate: 15
            };
            this.hooks.trigger(this.hooks.eventTypes.momentum, momentumData, distance);
            if (momentumData.destination < lowerMargin) {
                momentumData.destination = wrapperSize
                    ? Math.max(lowerMargin - wrapperSize / 4, lowerMargin - (wrapperSize / momentumData.rate) * speed)
                    : lowerMargin;
                momentumData.duration = swipeBounceTime;
            }
            else if (momentumData.destination > upperMargin) {
                momentumData.destination = wrapperSize
                    ? Math.min(upperMargin + wrapperSize / 4, upperMargin + (wrapperSize / momentumData.rate) * speed)
                    : upperMargin;
                momentumData.duration = swipeBounceTime;
            }
            momentumData.destination = Math.round(momentumData.destination);
            return momentumData;
        };
        Behavior.prototype.updateDirection = function () {
            var absDist = this.currentPos - this.absStartPos;
            this.setDirection(absDist);
        };
        Behavior.prototype.refresh = function (content) {
            var _a = this.options.rect, size = _a.size, position = _a.position;
            var isWrapperStatic = window.getComputedStyle(this.wrapper, null).position === 'static';
            // Force reflow
            var wrapperRect = getRect(this.wrapper);
            // use client is more fair than offset
            this.wrapperSize = this.wrapper[size === 'width' ? 'clientWidth' : 'clientHeight'];
            this.setContent(content);
            var contentRect = getRect(this.content);
            this.contentSize = contentRect[size];
            this.relativeOffset = contentRect[position];
            /* istanbul ignore if  */
            if (isWrapperStatic) {
                this.relativeOffset -= wrapperRect[position];
            }
            this.computeBoundary();
            this.setDirection(0 /* Default */);
        };
        Behavior.prototype.setContent = function (content) {
            if (content !== this.content) {
                this.content = content;
                this.resetState();
            }
        };
        Behavior.prototype.resetState = function () {
            this.currentPos = 0;
            this.startPos = 0;
            this.dist = 0;
            this.setDirection(0 /* Default */);
            this.setMovingDirection(0 /* Default */);
            this.resetStartPos();
        };
        Behavior.prototype.computeBoundary = function () {
            this.hooks.trigger(this.hooks.eventTypes.beforeComputeBoundary);
            var boundary = {
                minScrollPos: 0,
                maxScrollPos: this.wrapperSize - this.contentSize
            };
            if (boundary.maxScrollPos < 0) {
                boundary.maxScrollPos -= this.relativeOffset;
                if (this.options.specifiedIndexAsContent === 0) {
                    boundary.minScrollPos = -this.relativeOffset;
                }
            }
            this.hooks.trigger(this.hooks.eventTypes.computeBoundary, boundary);
            this.minScrollPos = boundary.minScrollPos;
            this.maxScrollPos = boundary.maxScrollPos;
            this.hasScroll =
                this.options.scrollable && this.maxScrollPos < this.minScrollPos;
            if (!this.hasScroll && this.minScrollPos < this.maxScrollPos) {
                this.maxScrollPos = this.minScrollPos;
                this.contentSize = this.wrapperSize;
            }
        };
        Behavior.prototype.updatePosition = function (pos) {
            this.currentPos = pos;
        };
        Behavior.prototype.getCurrentPos = function () {
            return this.currentPos;
        };
        Behavior.prototype.checkInBoundary = function () {
            var position = this.adjustPosition(this.currentPos);
            var inBoundary = position === this.getCurrentPos();
            return {
                position: position,
                inBoundary: inBoundary
            };
        };
        // adjust position when out of boundary
        Behavior.prototype.adjustPosition = function (pos) {
            if (!this.hasScroll &&
                !this.hooks.trigger(this.hooks.eventTypes.ignoreHasScroll)) {
                pos = this.minScrollPos;
            }
            else if (pos > this.minScrollPos) {
                pos = this.minScrollPos;
            }
            else if (pos < this.maxScrollPos) {
                pos = this.maxScrollPos;
            }
            return pos;
        };
        Behavior.prototype.updateStartPos = function () {
            this.startPos = this.currentPos;
        };
        Behavior.prototype.updateAbsStartPos = function () {
            this.absStartPos = this.currentPos;
        };
        Behavior.prototype.resetStartPos = function () {
            this.updateStartPos();
            this.updateAbsStartPos();
        };
        Behavior.prototype.getAbsDist = function (delta) {
            this.dist += delta;
            return Math.abs(this.dist);
        };
        Behavior.prototype.destroy = function () {
            this.hooks.destroy();
        };
        return Behavior;
    }());

    var _a, _b, _c, _d;
    var PassthroughHandlers = (_a = {},
        _a["yes" /* Yes */] = function (e) {
            return true;
        },
        _a["no" /* No */] = function (e) {
            e.preventDefault();
            return false;
        },
        _a);
    var DirectionMap = (_b = {},
        _b["horizontal" /* Horizontal */] = (_c = {},
            _c["yes" /* Yes */] = "horizontal" /* Horizontal */,
            _c["no" /* No */] = "vertical" /* Vertical */,
            _c),
        _b["vertical" /* Vertical */] = (_d = {},
            _d["yes" /* Yes */] = "vertical" /* Vertical */,
            _d["no" /* No */] = "horizontal" /* Horizontal */,
            _d),
        _b);
    var DirectionLockAction = /** @class */ (function () {
        function DirectionLockAction(directionLockThreshold, freeScroll, eventPassthrough) {
            this.directionLockThreshold = directionLockThreshold;
            this.freeScroll = freeScroll;
            this.eventPassthrough = eventPassthrough;
            this.reset();
        }
        DirectionLockAction.prototype.reset = function () {
            this.directionLocked = "" /* Default */;
        };
        DirectionLockAction.prototype.checkMovingDirection = function (absDistX, absDistY, e) {
            this.computeDirectionLock(absDistX, absDistY);
            return this.handleEventPassthrough(e);
        };
        DirectionLockAction.prototype.adjustDelta = function (deltaX, deltaY) {
            if (this.directionLocked === "horizontal" /* Horizontal */) {
                deltaY = 0;
            }
            else if (this.directionLocked === "vertical" /* Vertical */) {
                deltaX = 0;
            }
            return {
                deltaX: deltaX,
                deltaY: deltaY
            };
        };
        DirectionLockAction.prototype.computeDirectionLock = function (absDistX, absDistY) {
            // If you are scrolling in one direction, lock it
            if (this.directionLocked === "" /* Default */ && !this.freeScroll) {
                if (absDistX > absDistY + this.directionLockThreshold) {
                    this.directionLocked = "horizontal" /* Horizontal */; // lock horizontally
                }
                else if (absDistY >= absDistX + this.directionLockThreshold) {
                    this.directionLocked = "vertical" /* Vertical */; // lock vertically
                }
                else {
                    this.directionLocked = "none" /* None */; // no lock
                }
            }
        };
        DirectionLockAction.prototype.handleEventPassthrough = function (e) {
            var handleMap = DirectionMap[this.directionLocked];
            if (handleMap) {
                if (this.eventPassthrough === handleMap["yes" /* Yes */]) {
                    return PassthroughHandlers["yes" /* Yes */](e);
                }
                else if (this.eventPassthrough === handleMap["no" /* No */]) {
                    return PassthroughHandlers["no" /* No */](e);
                }
            }
            return false;
        };
        return DirectionLockAction;
    }());

    var applyQuadrantTransformation = function (deltaX, deltaY, quadrant) {
        if (quadrant === 2 /* Second */) {
            return [deltaY, -deltaX];
        }
        else if (quadrant === 3 /* Third */) {
            return [-deltaX, -deltaY];
        }
        else if (quadrant === 4 /* Forth */) {
            return [-deltaY, deltaX];
        }
        else {
            return [deltaX, deltaY];
        }
    };
    var ScrollerActions = /** @class */ (function () {
        function ScrollerActions(scrollBehaviorX, scrollBehaviorY, actionsHandler, animater, options) {
            this.hooks = new EventEmitter([
                'start',
                'beforeMove',
                'scrollStart',
                'scroll',
                'beforeEnd',
                'end',
                'scrollEnd',
                'contentNotMoved',
                'detectMovingDirection',
                'coordinateTransformation',
            ]);
            this.scrollBehaviorX = scrollBehaviorX;
            this.scrollBehaviorY = scrollBehaviorY;
            this.actionsHandler = actionsHandler;
            this.animater = animater;
            this.options = options;
            this.directionLockAction = new DirectionLockAction(options.directionLockThreshold, options.freeScroll, options.eventPassthrough);
            this.enabled = true;
            this.bindActionsHandler();
        }
        ScrollerActions.prototype.bindActionsHandler = function () {
            var _this = this;
            // [mouse|touch]start event
            this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.start, function (e) {
                if (!_this.enabled)
                    return true;
                return _this.handleStart(e);
            });
            // [mouse|touch]move event
            this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.move, function (_a) {
                var deltaX = _a.deltaX, deltaY = _a.deltaY, e = _a.e;
                if (!_this.enabled)
                    return true;
                var _b = applyQuadrantTransformation(deltaX, deltaY, _this.options.quadrant), transformateDeltaX = _b[0], transformateDeltaY = _b[1];
                var transformateDeltaData = {
                    deltaX: transformateDeltaX,
                    deltaY: transformateDeltaY,
                };
                _this.hooks.trigger(_this.hooks.eventTypes.coordinateTransformation, transformateDeltaData);
                return _this.handleMove(transformateDeltaData.deltaX, transformateDeltaData.deltaY, e);
            });
            // [mouse|touch]end event
            this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.end, function (e) {
                if (!_this.enabled)
                    return true;
                return _this.handleEnd(e);
            });
            // click
            this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.click, function (e) {
                // handle native click event
                if (_this.enabled && !e._constructed) {
                    _this.handleClick(e);
                }
            });
        };
        ScrollerActions.prototype.handleStart = function (e) {
            var timestamp = getNow();
            this.fingerMoved = false;
            this.contentMoved = false;
            this.startTime = timestamp;
            this.directionLockAction.reset();
            this.scrollBehaviorX.start();
            this.scrollBehaviorY.start();
            // force stopping last transition or animation
            this.animater.doStop();
            this.scrollBehaviorX.resetStartPos();
            this.scrollBehaviorY.resetStartPos();
            this.hooks.trigger(this.hooks.eventTypes.start, e);
        };
        ScrollerActions.prototype.handleMove = function (deltaX, deltaY, e) {
            if (this.hooks.trigger(this.hooks.eventTypes.beforeMove, e)) {
                return;
            }
            var absDistX = this.scrollBehaviorX.getAbsDist(deltaX);
            var absDistY = this.scrollBehaviorY.getAbsDist(deltaY);
            var timestamp = getNow();
            // We need to move at least momentumLimitDistance pixels
            // for the scrolling to initiate
            if (this.checkMomentum(absDistX, absDistY, timestamp)) {
                return true;
            }
            if (this.directionLockAction.checkMovingDirection(absDistX, absDistY, e)) {
                this.actionsHandler.setInitiated();
                return true;
            }
            var delta = this.directionLockAction.adjustDelta(deltaX, deltaY);
            var prevX = this.scrollBehaviorX.getCurrentPos();
            var newX = this.scrollBehaviorX.move(delta.deltaX);
            var prevY = this.scrollBehaviorY.getCurrentPos();
            var newY = this.scrollBehaviorY.move(delta.deltaY);
            if (this.hooks.trigger(this.hooks.eventTypes.detectMovingDirection)) {
                return;
            }
            if (!this.fingerMoved) {
                this.fingerMoved = true;
            }
            var positionChanged = newX !== prevX || newY !== prevY;
            if (!this.contentMoved && !positionChanged) {
                this.hooks.trigger(this.hooks.eventTypes.contentNotMoved);
            }
            if (!this.contentMoved && positionChanged) {
                this.contentMoved = true;
                this.hooks.trigger(this.hooks.eventTypes.scrollStart);
            }
            if (this.contentMoved && positionChanged) {
                this.animater.translate({
                    x: newX,
                    y: newY,
                });
                this.dispatchScroll(timestamp);
            }
        };
        ScrollerActions.prototype.dispatchScroll = function (timestamp) {
            // dispatch scroll in interval time
            if (timestamp - this.startTime > this.options.momentumLimitTime) {
                // refresh time and starting position to initiate a momentum
                this.startTime = timestamp;
                this.scrollBehaviorX.updateStartPos();
                this.scrollBehaviorY.updateStartPos();
                if (this.options.probeType === 1 /* Throttle */) {
                    this.hooks.trigger(this.hooks.eventTypes.scroll, this.getCurrentPos());
                }
            }
            // dispatch scroll all the time
            if (this.options.probeType > 1 /* Throttle */) {
                this.hooks.trigger(this.hooks.eventTypes.scroll, this.getCurrentPos());
            }
        };
        ScrollerActions.prototype.checkMomentum = function (absDistX, absDistY, timestamp) {
            return (timestamp - this.endTime > this.options.momentumLimitTime &&
                absDistY < this.options.momentumLimitDistance &&
                absDistX < this.options.momentumLimitDistance);
        };
        ScrollerActions.prototype.handleEnd = function (e) {
            if (this.hooks.trigger(this.hooks.eventTypes.beforeEnd, e)) {
                return;
            }
            var currentPos = this.getCurrentPos();
            this.scrollBehaviorX.updateDirection();
            this.scrollBehaviorY.updateDirection();
            if (this.hooks.trigger(this.hooks.eventTypes.end, e, currentPos)) {
                return true;
            }
            currentPos = this.ensureIntegerPos(currentPos);
            this.animater.translate(currentPos);
            this.endTime = getNow();
            var duration = this.endTime - this.startTime;
            this.hooks.trigger(this.hooks.eventTypes.scrollEnd, currentPos, duration);
        };
        ScrollerActions.prototype.ensureIntegerPos = function (currentPos) {
            this.ensuringInteger = true;
            var x = currentPos.x, y = currentPos.y;
            var _a = this.scrollBehaviorX, minScrollPosX = _a.minScrollPos, maxScrollPosX = _a.maxScrollPos;
            var _b = this.scrollBehaviorY, minScrollPosY = _b.minScrollPos, maxScrollPosY = _b.maxScrollPos;
            x = x > 0 ? Math.ceil(x) : Math.floor(x);
            y = y > 0 ? Math.ceil(y) : Math.floor(y);
            x = between(x, maxScrollPosX, minScrollPosX);
            y = between(y, maxScrollPosY, minScrollPosY);
            return { x: x, y: y };
        };
        ScrollerActions.prototype.handleClick = function (e) {
            if (!preventDefaultExceptionFn(e.target, this.options.preventDefaultException)) {
                e.preventDefault();
                e.stopPropagation();
            }
        };
        ScrollerActions.prototype.getCurrentPos = function () {
            return {
                x: this.scrollBehaviorX.getCurrentPos(),
                y: this.scrollBehaviorY.getCurrentPos(),
            };
        };
        ScrollerActions.prototype.refresh = function () {
            this.endTime = 0;
        };
        ScrollerActions.prototype.destroy = function () {
            this.hooks.destroy();
        };
        return ScrollerActions;
    }());

    function createActionsHandlerOptions(bsOptions) {
        var options = [
            'click',
            'bindToWrapper',
            'disableMouse',
            'disableTouch',
            'preventDefault',
            'stopPropagation',
            'tagException',
            'preventDefaultException',
            'autoEndDistance',
        ].reduce(function (prev, cur) {
            prev[cur] = bsOptions[cur];
            return prev;
        }, {});
        return options;
    }
    function createBehaviorOptions(bsOptions, extraProp, bounces, rect) {
        var options = [
            'momentum',
            'momentumLimitTime',
            'momentumLimitDistance',
            'deceleration',
            'swipeBounceTime',
            'swipeTime',
            'outOfBoundaryDampingFactor',
            'specifiedIndexAsContent',
        ].reduce(function (prev, cur) {
            prev[cur] = bsOptions[cur];
            return prev;
        }, {});
        // add extra property
        options.scrollable = !!bsOptions[extraProp];
        options.bounces = bounces;
        options.rect = rect;
        return options;
    }

    function bubbling(source, target, events) {
        events.forEach(function (event) {
            var sourceEvent;
            var targetEvent;
            if (typeof event === 'string') {
                sourceEvent = targetEvent = event;
            }
            else {
                sourceEvent = event.source;
                targetEvent = event.target;
            }
            source.on(sourceEvent, function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                return target.trigger.apply(target, __spreadArrays([targetEvent], args));
            });
        });
    }

    function isSamePoint(startPoint, endPoint) {
        // keys of startPoint and endPoint should be equal
        var keys = Object.keys(startPoint);
        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
            var key = keys_1[_i];
            if (startPoint[key] !== endPoint[key])
                return false;
        }
        return true;
    }

    var MIN_SCROLL_DISTANCE = 1;
    var Scroller = /** @class */ (function () {
        function Scroller(wrapper, content, options) {
            this.wrapper = wrapper;
            this.content = content;
            this.resizeTimeout = 0;
            this.hooks = new EventEmitter([
                'beforeStart',
                'beforeMove',
                'beforeScrollStart',
                'scrollStart',
                'scroll',
                'beforeEnd',
                'scrollEnd',
                'resize',
                'touchEnd',
                'end',
                'flick',
                'scrollCancel',
                'momentum',
                'scrollTo',
                'minDistanceScroll',
                'scrollToElement',
                'beforeRefresh',
            ]);
            this.options = options;
            var _a = this.options.bounce, left = _a.left, right = _a.right, top = _a.top, bottom = _a.bottom;
            // direction X
            this.scrollBehaviorX = new Behavior(wrapper, content, createBehaviorOptions(options, 'scrollX', [left, right], {
                size: 'width',
                position: 'left',
            }));
            // direction Y
            this.scrollBehaviorY = new Behavior(wrapper, content, createBehaviorOptions(options, 'scrollY', [top, bottom], {
                size: 'height',
                position: 'top',
            }));
            this.translater = new Translater(this.content);
            this.animater = createAnimater(this.content, this.translater, this.options);
            this.actionsHandler = new ActionsHandler(this.options.bindToTarget ? this.content : wrapper, createActionsHandlerOptions(this.options));
            this.actions = new ScrollerActions(this.scrollBehaviorX, this.scrollBehaviorY, this.actionsHandler, this.animater, this.options);
            var resizeHandler = this.resize.bind(this);
            this.resizeRegister = new EventRegister(window, [
                {
                    name: 'orientationchange',
                    handler: resizeHandler,
                },
                {
                    name: 'resize',
                    handler: resizeHandler,
                },
            ]);
            this.registerTransitionEnd();
            this.init();
        }
        Scroller.prototype.init = function () {
            var _this = this;
            this.bindTranslater();
            this.bindAnimater();
            this.bindActions();
            // enable pointer events when scrolling ends
            this.hooks.on(this.hooks.eventTypes.scrollEnd, function () {
                _this.togglePointerEvents(true);
            });
        };
        Scroller.prototype.registerTransitionEnd = function () {
            this.transitionEndRegister = new EventRegister(this.content, [
                {
                    name: style.transitionEnd,
                    handler: this.transitionEnd.bind(this),
                },
            ]);
        };
        Scroller.prototype.bindTranslater = function () {
            var _this = this;
            var hooks = this.translater.hooks;
            hooks.on(hooks.eventTypes.beforeTranslate, function (transformStyle) {
                if (_this.options.translateZ) {
                    transformStyle.push(_this.options.translateZ);
                }
            });
            // disable pointer events when scrolling
            hooks.on(hooks.eventTypes.translate, function (pos) {
                var prevPos = _this.getCurrentPos();
                _this.updatePositions(pos);
                // scrollEnd will dispatch when scroll is force stopping in touchstart handler
                // so in touchend handler, don't toggle pointer-events
                if (_this.actions.ensuringInteger === true) {
                    _this.actions.ensuringInteger = false;
                    return;
                }
                // a valid translate
                if (pos.x !== prevPos.x || pos.y !== prevPos.y) {
                    _this.togglePointerEvents(false);
                }
            });
        };
        Scroller.prototype.bindAnimater = function () {
            var _this = this;
            // reset position
            this.animater.hooks.on(this.animater.hooks.eventTypes.end, function (pos) {
                if (!_this.resetPosition(_this.options.bounceTime)) {
                    _this.animater.setPending(false);
                    _this.hooks.trigger(_this.hooks.eventTypes.scrollEnd, pos);
                }
            });
            bubbling(this.animater.hooks, this.hooks, [
                {
                    source: this.animater.hooks.eventTypes.move,
                    target: this.hooks.eventTypes.scroll,
                },
                {
                    source: this.animater.hooks.eventTypes.forceStop,
                    target: this.hooks.eventTypes.scrollEnd,
                },
            ]);
        };
        Scroller.prototype.bindActions = function () {
            var _this = this;
            var actions = this.actions;
            bubbling(actions.hooks, this.hooks, [
                {
                    source: actions.hooks.eventTypes.start,
                    target: this.hooks.eventTypes.beforeStart,
                },
                {
                    source: actions.hooks.eventTypes.start,
                    target: this.hooks.eventTypes.beforeScrollStart,
                },
                {
                    source: actions.hooks.eventTypes.beforeMove,
                    target: this.hooks.eventTypes.beforeMove,
                },
                {
                    source: actions.hooks.eventTypes.scrollStart,
                    target: this.hooks.eventTypes.scrollStart,
                },
                {
                    source: actions.hooks.eventTypes.scroll,
                    target: this.hooks.eventTypes.scroll,
                },
                {
                    source: actions.hooks.eventTypes.beforeEnd,
                    target: this.hooks.eventTypes.beforeEnd,
                },
            ]);
            actions.hooks.on(actions.hooks.eventTypes.end, function (e, pos) {
                _this.hooks.trigger(_this.hooks.eventTypes.touchEnd, pos);
                if (_this.hooks.trigger(_this.hooks.eventTypes.end, pos)) {
                    return true;
                }
                // check if it is a click operation
                if (!actions.fingerMoved) {
                    _this.hooks.trigger(_this.hooks.eventTypes.scrollCancel);
                    if (_this.checkClick(e)) {
                        return true;
                    }
                }
                // reset if we are outside of the boundaries
                if (_this.resetPosition(_this.options.bounceTime, ease.bounce)) {
                    _this.animater.setForceStopped(false);
                    return true;
                }
            });
            actions.hooks.on(actions.hooks.eventTypes.scrollEnd, function (pos, duration) {
                var deltaX = Math.abs(pos.x - _this.scrollBehaviorX.startPos);
                var deltaY = Math.abs(pos.y - _this.scrollBehaviorY.startPos);
                if (_this.checkFlick(duration, deltaX, deltaY)) {
                    _this.animater.setForceStopped(false);
                    _this.hooks.trigger(_this.hooks.eventTypes.flick);
                    return;
                }
                if (_this.momentum(pos, duration)) {
                    _this.animater.setForceStopped(false);
                    return;
                }
                if (actions.contentMoved) {
                    _this.hooks.trigger(_this.hooks.eventTypes.scrollEnd, pos);
                }
                if (_this.animater.forceStopped) {
                    _this.animater.setForceStopped(false);
                }
            });
        };
        Scroller.prototype.checkFlick = function (duration, deltaX, deltaY) {
            var flickMinMovingDistance = 1; // distinguish flick from click
            if (this.hooks.events.flick.length > 1 &&
                duration < this.options.flickLimitTime &&
                deltaX < this.options.flickLimitDistance &&
                deltaY < this.options.flickLimitDistance &&
                (deltaY > flickMinMovingDistance || deltaX > flickMinMovingDistance)) {
                return true;
            }
        };
        Scroller.prototype.momentum = function (pos, duration) {
            var meta = {
                time: 0,
                easing: ease.swiper,
                newX: pos.x,
                newY: pos.y,
            };
            // start momentum animation if needed
            var momentumX = this.scrollBehaviorX.end(duration);
            var momentumY = this.scrollBehaviorY.end(duration);
            meta.newX = isUndef(momentumX.destination)
                ? meta.newX
                : momentumX.destination;
            meta.newY = isUndef(momentumY.destination)
                ? meta.newY
                : momentumY.destination;
            meta.time = Math.max(momentumX.duration, momentumY.duration);
            this.hooks.trigger(this.hooks.eventTypes.momentum, meta, this);
            // when x or y changed, do momentum animation now!
            if (meta.newX !== pos.x || meta.newY !== pos.y) {
                // change easing function when scroller goes out of the boundaries
                if (meta.newX > this.scrollBehaviorX.minScrollPos ||
                    meta.newX < this.scrollBehaviorX.maxScrollPos ||
                    meta.newY > this.scrollBehaviorY.minScrollPos ||
                    meta.newY < this.scrollBehaviorY.maxScrollPos) {
                    meta.easing = ease.swipeBounce;
                }
                this.scrollTo(meta.newX, meta.newY, meta.time, meta.easing);
                return true;
            }
        };
        Scroller.prototype.checkClick = function (e) {
            var cancelable = {
                preventClick: this.animater.forceStopped,
            };
            // we scrolled less than momentumLimitDistance pixels
            if (this.hooks.trigger(this.hooks.eventTypes.checkClick)) {
                this.animater.setForceStopped(false);
                return true;
            }
            if (!cancelable.preventClick) {
                var _dblclick = this.options.dblclick;
                var dblclickTrigged = false;
                if (_dblclick && this.lastClickTime) {
                    var _a = _dblclick.delay, delay = _a === void 0 ? 300 : _a;
                    if (getNow() - this.lastClickTime < delay) {
                        dblclickTrigged = true;
                        dblclick(e);
                    }
                }
                if (this.options.tap) {
                    tap(e, this.options.tap);
                }
                if (this.options.click &&
                    !preventDefaultExceptionFn(e.target, this.options.preventDefaultException)) {
                    click(e);
                }
                this.lastClickTime = dblclickTrigged ? null : getNow();
                return true;
            }
            return false;
        };
        Scroller.prototype.resize = function () {
            var _this = this;
            if (!this.actions.enabled) {
                return;
            }
            // fix a scroll problem under Android condition
            /* istanbul ignore if  */
            if (isAndroid) {
                this.wrapper.scrollTop = 0;
            }
            clearTimeout(this.resizeTimeout);
            this.resizeTimeout = window.setTimeout(function () {
                _this.hooks.trigger(_this.hooks.eventTypes.resize);
            }, this.options.resizePolling);
        };
        /* istanbul ignore next */
        Scroller.prototype.transitionEnd = function (e) {
            if (e.target !== this.content || !this.animater.pending) {
                return;
            }
            var animater = this.animater;
            animater.transitionTime();
            if (!this.resetPosition(this.options.bounceTime, ease.bounce)) {
                this.animater.setPending(false);
                if (this.options.probeType !== 3 /* Realtime */) {
                    this.hooks.trigger(this.hooks.eventTypes.scrollEnd, this.getCurrentPos());
                }
            }
        };
        Scroller.prototype.togglePointerEvents = function (enabled) {
            if (enabled === void 0) { enabled = true; }
            var el = this.content.children.length
                ? this.content.children
                : [this.content];
            var pointerEvents = enabled ? 'auto' : 'none';
            for (var i = 0; i < el.length; i++) {
                var node = el[i];
                // ignore BetterScroll instance's wrapper DOM
                /* istanbul ignore if  */
                if (node.isBScrollContainer) {
                    continue;
                }
                node.style.pointerEvents = pointerEvents;
            }
        };
        Scroller.prototype.refresh = function (content) {
            var contentChanged = this.setContent(content);
            this.hooks.trigger(this.hooks.eventTypes.beforeRefresh);
            this.scrollBehaviorX.refresh(content);
            this.scrollBehaviorY.refresh(content);
            if (contentChanged) {
                this.translater.setContent(content);
                this.animater.setContent(content);
                this.transitionEndRegister.destroy();
                this.registerTransitionEnd();
                if (this.options.bindToTarget) {
                    this.actionsHandler.setContent(content);
                }
            }
            this.actions.refresh();
            this.wrapperOffset = offset(this.wrapper);
        };
        Scroller.prototype.setContent = function (content) {
            var contentChanged = content !== this.content;
            if (contentChanged) {
                this.content = content;
            }
            return contentChanged;
        };
        Scroller.prototype.scrollBy = function (deltaX, deltaY, time, easing) {
            if (time === void 0) { time = 0; }
            var _a = this.getCurrentPos(), x = _a.x, y = _a.y;
            easing = !easing ? ease.bounce : easing;
            deltaX += x;
            deltaY += y;
            this.scrollTo(deltaX, deltaY, time, easing);
        };
        Scroller.prototype.scrollTo = function (x, y, time, easing, extraTransform) {
            if (time === void 0) { time = 0; }
            if (easing === void 0) { easing = ease.bounce; }
            if (extraTransform === void 0) { extraTransform = {
                start: {},
                end: {},
            }; }
            var easingFn = this.options.useTransition ? easing.style : easing.fn;
            var currentPos = this.getCurrentPos();
            var startPoint = __assign({ x: currentPos.x, y: currentPos.y }, extraTransform.start);
            var endPoint = __assign({ x: x,
                y: y }, extraTransform.end);
            this.hooks.trigger(this.hooks.eventTypes.scrollTo, endPoint);
            // it is an useless move
            if (isSamePoint(startPoint, endPoint))
                return;
            var deltaX = Math.abs(endPoint.x - startPoint.x);
            var deltaY = Math.abs(endPoint.y - startPoint.y);
            // considering of browser compatibility for decimal transform value
            // force translating immediately
            if (deltaX < MIN_SCROLL_DISTANCE && deltaY < MIN_SCROLL_DISTANCE) {
                time = 0;
                this.hooks.trigger(this.hooks.eventTypes.minDistanceScroll);
            }
            this.animater.move(startPoint, endPoint, time, easingFn);
        };
        Scroller.prototype.scrollToElement = function (el, time, offsetX, offsetY, easing) {
            var targetEle = getElement(el);
            var pos = offset(targetEle);
            var getOffset = function (offset, size, wrapperSize) {
                if (typeof offset === 'number') {
                    return offset;
                }
                // if offsetX/Y are true we center the element to the screen
                return offset ? Math.round(size / 2 - wrapperSize / 2) : 0;
            };
            offsetX = getOffset(offsetX, targetEle.offsetWidth, this.wrapper.offsetWidth);
            offsetY = getOffset(offsetY, targetEle.offsetHeight, this.wrapper.offsetHeight);
            var getPos = function (pos, wrapperPos, offset, scrollBehavior) {
                pos -= wrapperPos;
                pos = scrollBehavior.adjustPosition(pos - offset);
                return pos;
            };
            pos.left = getPos(pos.left, this.wrapperOffset.left, offsetX, this.scrollBehaviorX);
            pos.top = getPos(pos.top, this.wrapperOffset.top, offsetY, this.scrollBehaviorY);
            if (this.hooks.trigger(this.hooks.eventTypes.scrollToElement, targetEle, pos)) {
                return;
            }
            this.scrollTo(pos.left, pos.top, time, easing);
        };
        Scroller.prototype.resetPosition = function (time, easing) {
            if (time === void 0) { time = 0; }
            if (easing === void 0) { easing = ease.bounce; }
            var _a = this.scrollBehaviorX.checkInBoundary(), x = _a.position, xInBoundary = _a.inBoundary;
            var _b = this.scrollBehaviorY.checkInBoundary(), y = _b.position, yInBoundary = _b.inBoundary;
            if (xInBoundary && yInBoundary) {
                return false;
            }
            /* istanbul ignore if  */
            if (isIOSBadVersion) {
                // fix ios 13.4 bouncing
                // see it in issues 982
                this.reflow();
            }
            // out of boundary
            this.scrollTo(x, y, time, easing);
            return true;
        };
        /* istanbul ignore next */
        Scroller.prototype.reflow = function () {
            this._reflow = this.content.offsetHeight;
        };
        Scroller.prototype.updatePositions = function (pos) {
            this.scrollBehaviorX.updatePosition(pos.x);
            this.scrollBehaviorY.updatePosition(pos.y);
        };
        Scroller.prototype.getCurrentPos = function () {
            return this.actions.getCurrentPos();
        };
        Scroller.prototype.enable = function () {
            this.actions.enabled = true;
        };
        Scroller.prototype.disable = function () {
            cancelAnimationFrame(this.animater.timer);
            this.actions.enabled = false;
        };
        Scroller.prototype.destroy = function () {
            var _this = this;
            var keys = [
                'resizeRegister',
                'transitionEndRegister',
                'actionsHandler',
                'actions',
                'hooks',
                'animater',
                'translater',
                'scrollBehaviorX',
                'scrollBehaviorY',
            ];
            keys.forEach(function (key) { return _this[key].destroy(); });
        };
        return Scroller;
    }());

    var BScrollConstructor = /** @class */ (function (_super) {
        __extends(BScrollConstructor, _super);
        function BScrollConstructor(el, options) {
            var _this = _super.call(this, [
                'refresh',
                'contentChanged',
                'enable',
                'disable',
                'beforeScrollStart',
                'scrollStart',
                'scroll',
                'scrollEnd',
                'scrollCancel',
                'touchEnd',
                'flick',
                'destroy'
            ]) || this;
            var wrapper = getElement(el);
            if (!wrapper) {
                warn('Can not resolve the wrapper DOM.');
                return _this;
            }
            _this.plugins = {};
            _this.options = new OptionsConstructor().merge(options).process();
            if (!_this.setContent(wrapper).valid) {
                return _this;
            }
            _this.hooks = new EventEmitter([
                'refresh',
                'enable',
                'disable',
                'destroy',
                'beforeInitialScrollTo',
                'contentChanged'
            ]);
            _this.init(wrapper);
            return _this;
        }
        BScrollConstructor.use = function (ctor) {
            var name = ctor.pluginName;
            var installed = BScrollConstructor.plugins.some(function (plugin) { return ctor === plugin.ctor; });
            if (installed)
                return BScrollConstructor;
            if (isUndef(name)) {
                warn("Plugin Class must specify plugin's name in static property by 'pluginName' field.");
                return BScrollConstructor;
            }
            BScrollConstructor.pluginsMap[name] = true;
            BScrollConstructor.plugins.push({
                name: name,
                applyOrder: ctor.applyOrder,
                ctor: ctor
            });
            return BScrollConstructor;
        };
        BScrollConstructor.prototype.setContent = function (wrapper) {
            var contentChanged = false;
            var valid = true;
            var content = wrapper.children[this.options.specifiedIndexAsContent];
            if (!content) {
                warn('The wrapper need at least one child element to be content element to scroll.');
                valid = false;
            }
            else {
                contentChanged = this.content !== content;
                if (contentChanged) {
                    this.content = content;
                }
            }
            return {
                valid: valid,
                contentChanged: contentChanged
            };
        };
        BScrollConstructor.prototype.init = function (wrapper) {
            var _this = this;
            this.wrapper = wrapper;
            // mark wrapper to recognize bs instance by DOM attribute
            wrapper.isBScrollContainer = true;
            this.scroller = new Scroller(wrapper, this.content, this.options);
            this.scroller.hooks.on(this.scroller.hooks.eventTypes.resize, function () {
                _this.refresh();
            });
            this.eventBubbling();
            this.handleAutoBlur();
            this.enable();
            this.proxy(propertiesConfig$7);
            this.applyPlugins();
            // maybe boundary has changed, should refresh
            this.refreshWithoutReset(this.content);
            var _a = this.options, startX = _a.startX, startY = _a.startY;
            var position = {
                x: startX,
                y: startY
            };
            // maybe plugins want to control scroll position
            if (this.hooks.trigger(this.hooks.eventTypes.beforeInitialScrollTo, position)) {
                return;
            }
            this.scroller.scrollTo(position.x, position.y);
        };
        BScrollConstructor.prototype.applyPlugins = function () {
            var _this = this;
            var options = this.options;
            BScrollConstructor.plugins
                .sort(function (a, b) {
                var _a;
                var applyOrderMap = (_a = {},
                    _a["pre" /* Pre */] = -1,
                    _a["post" /* Post */] = 1,
                    _a);
                var aOrder = a.applyOrder ? applyOrderMap[a.applyOrder] : 0;
                var bOrder = b.applyOrder ? applyOrderMap[b.applyOrder] : 0;
                return aOrder - bOrder;
            })
                .forEach(function (item) {
                var ctor = item.ctor;
                if (options[item.name] && typeof ctor === 'function') {
                    _this.plugins[item.name] = new ctor(_this);
                }
            });
        };
        BScrollConstructor.prototype.handleAutoBlur = function () {
            /* istanbul ignore if  */
            if (this.options.autoBlur) {
                this.on(this.eventTypes.beforeScrollStart, function () {
                    var activeElement = document.activeElement;
                    if (activeElement &&
                        (activeElement.tagName === 'INPUT' ||
                            activeElement.tagName === 'TEXTAREA')) {
                        activeElement.blur();
                    }
                });
            }
        };
        BScrollConstructor.prototype.eventBubbling = function () {
            bubbling(this.scroller.hooks, this, [
                this.eventTypes.beforeScrollStart,
                this.eventTypes.scrollStart,
                this.eventTypes.scroll,
                this.eventTypes.scrollEnd,
                this.eventTypes.scrollCancel,
                this.eventTypes.touchEnd,
                this.eventTypes.flick
            ]);
        };
        BScrollConstructor.prototype.refreshWithoutReset = function (content) {
            this.scroller.refresh(content);
            this.hooks.trigger(this.hooks.eventTypes.refresh, content);
            this.trigger(this.eventTypes.refresh, content);
        };
        BScrollConstructor.prototype.proxy = function (propertiesConfig) {
            var _this = this;
            propertiesConfig.forEach(function (_a) {
                var key = _a.key, sourceKey = _a.sourceKey;
                propertiesProxy(_this, sourceKey, key);
            });
        };
        BScrollConstructor.prototype.refresh = function () {
            var _a = this.setContent(this.wrapper), contentChanged = _a.contentChanged, valid = _a.valid;
            if (valid) {
                var content = this.content;
                this.refreshWithoutReset(content);
                if (contentChanged) {
                    this.hooks.trigger(this.hooks.eventTypes.contentChanged, content);
                    this.trigger(this.eventTypes.contentChanged, content);
                }
                this.scroller.resetPosition();
            }
        };
        BScrollConstructor.prototype.enable = function () {
            this.scroller.enable();
            this.hooks.trigger(this.hooks.eventTypes.enable);
            this.trigger(this.eventTypes.enable);
        };
        BScrollConstructor.prototype.disable = function () {
            this.scroller.disable();
            this.hooks.trigger(this.hooks.eventTypes.disable);
            this.trigger(this.eventTypes.disable);
        };
        BScrollConstructor.prototype.destroy = function () {
            this.hooks.trigger(this.hooks.eventTypes.destroy);
            this.trigger(this.eventTypes.destroy);
            this.scroller.destroy();
        };
        BScrollConstructor.prototype.eventRegister = function (names) {
            this.registerType(names);
        };
        BScrollConstructor.plugins = [];
        BScrollConstructor.pluginsMap = {};
        return BScrollConstructor;
    }(EventEmitter));
    function createBScroll(el, options) {
        var bs = new BScrollConstructor(el, options);
        return bs;
    }
    createBScroll.use = BScrollConstructor.use;
    createBScroll.plugins = BScrollConstructor.plugins;
    createBScroll.pluginsMap = BScrollConstructor.pluginsMap;
    var BScroll = createBScroll;

    var MouseWheel = /** @class */ (function () {
        function MouseWheel(scroll) {
            this.scroll = scroll;
            this.wheelEndTimer = 0;
            this.wheelMoveTimer = 0;
            this.wheelStart = false;
            this.init();
        }
        MouseWheel.prototype.init = function () {
            this.handleBScroll();
            this.handleOptions();
            this.handleHooks();
            this.registerEvent();
        };
        MouseWheel.prototype.handleBScroll = function () {
            this.scroll.registerType([
                'alterOptions',
                'mousewheelStart',
                'mousewheelMove',
                'mousewheelEnd',
            ]);
        };
        MouseWheel.prototype.handleOptions = function () {
            var userOptions = (this.scroll.options.mouseWheel === true
                ? {}
                : this.scroll.options.mouseWheel);
            var defaultOptions = {
                speed: 20,
                invert: false,
                easeTime: 300,
                discreteTime: 400,
                throttleTime: 0,
                dampingFactor: 0.1,
            };
            this.mouseWheelOpt = extend(defaultOptions, userOptions);
        };
        MouseWheel.prototype.handleHooks = function () {
            this.hooksFn = [];
            this.registerHooks(this.scroll.hooks, 'destroy', this.destroy);
        };
        MouseWheel.prototype.registerEvent = function () {
            this.eventRegister = new EventRegister(this.scroll.scroller.wrapper, [
                {
                    name: 'wheel',
                    handler: this.wheelHandler.bind(this),
                },
                {
                    name: 'mousewheel',
                    handler: this.wheelHandler.bind(this),
                },
                {
                    name: 'DOMMouseScroll',
                    handler: this.wheelHandler.bind(this),
                },
            ]);
        };
        MouseWheel.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        MouseWheel.prototype.wheelHandler = function (e) {
            if (!this.scroll.enabled) {
                return;
            }
            this.beforeHandler(e);
            // start
            if (!this.wheelStart) {
                this.wheelStartHandler(e);
                this.wheelStart = true;
            }
            // move
            var delta = this.getWheelDelta(e);
            this.wheelMoveHandler(delta);
            // end
            this.wheelEndDetector(delta);
        };
        MouseWheel.prototype.wheelStartHandler = function (e) {
            this.cleanCache();
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
            scrollBehaviorX.setMovingDirection(0 /* Default */);
            scrollBehaviorY.setMovingDirection(0 /* Default */);
            scrollBehaviorX.setDirection(0 /* Default */);
            scrollBehaviorY.setDirection(0 /* Default */);
            this.scroll.trigger(this.scroll.eventTypes.alterOptions, this.mouseWheelOpt);
            this.scroll.trigger(this.scroll.eventTypes.mousewheelStart);
        };
        MouseWheel.prototype.cleanCache = function () {
            this.deltaCache = [];
        };
        MouseWheel.prototype.wheelMoveHandler = function (delta) {
            var _this = this;
            var _a = this.mouseWheelOpt, throttleTime = _a.throttleTime, dampingFactor = _a.dampingFactor;
            if (throttleTime && this.wheelMoveTimer) {
                this.deltaCache.push(delta);
            }
            else {
                var cachedDelta = this.deltaCache.reduce(function (prev, current) {
                    return {
                        x: prev.x + current.x,
                        y: prev.y + current.y,
                    };
                }, { x: 0, y: 0 });
                this.cleanCache();
                var _b = this.scroll.scroller, scrollBehaviorX = _b.scrollBehaviorX, scrollBehaviorY = _b.scrollBehaviorY;
                scrollBehaviorX.setMovingDirection(-delta.directionX);
                scrollBehaviorY.setMovingDirection(-delta.directionY);
                scrollBehaviorX.setDirection(delta.x);
                scrollBehaviorY.setDirection(delta.y);
                // when out of boundary, perform a damping scroll
                var newX = scrollBehaviorX.performDampingAlgorithm(Math.round(delta.x) + cachedDelta.x, dampingFactor);
                var newY = scrollBehaviorY.performDampingAlgorithm(Math.round(delta.y) + cachedDelta.x, dampingFactor);
                if (!this.scroll.trigger(this.scroll.eventTypes.mousewheelMove, {
                    x: newX,
                    y: newY,
                })) {
                    var easeTime = this.getEaseTime();
                    if (newX !== this.scroll.x || newY !== this.scroll.y) {
                        this.scroll.scrollTo(newX, newY, easeTime);
                    }
                }
                if (throttleTime) {
                    this.wheelMoveTimer = window.setTimeout(function () {
                        _this.wheelMoveTimer = 0;
                    }, throttleTime);
                }
            }
        };
        MouseWheel.prototype.wheelEndDetector = function (delta) {
            var _this = this;
            window.clearTimeout(this.wheelEndTimer);
            this.wheelEndTimer = window.setTimeout(function () {
                _this.wheelStart = false;
                window.clearTimeout(_this.wheelMoveTimer);
                _this.wheelMoveTimer = 0;
                _this.scroll.trigger(_this.scroll.eventTypes.mousewheelEnd, delta);
            }, this.mouseWheelOpt.discreteTime);
        };
        MouseWheel.prototype.getWheelDelta = function (e) {
            var _a = this.mouseWheelOpt, speed = _a.speed, invert = _a.invert;
            var wheelDeltaX = 0;
            var wheelDeltaY = 0;
            var direction = invert ? -1 /* Negative */ : 1 /* Positive */;
            switch (true) {
                case 'deltaX' in e:
                    if (e.deltaMode === 1) {
                        wheelDeltaX = -e.deltaX * speed;
                        wheelDeltaY = -e.deltaY * speed;
                    }
                    else {
                        wheelDeltaX = -e.deltaX;
                        wheelDeltaY = -e.deltaY;
                    }
                    break;
                case 'wheelDeltaX' in e:
                    wheelDeltaX = (e.wheelDeltaX / 120) * speed;
                    wheelDeltaY = (e.wheelDeltaY / 120) * speed;
                    break;
                case 'wheelDelta' in e:
                    wheelDeltaX = wheelDeltaY = (e.wheelDelta / 120) * speed;
                    break;
                case 'detail' in e:
                    wheelDeltaX = wheelDeltaY = (-e.detail / 3) * speed;
                    break;
            }
            wheelDeltaX *= direction;
            wheelDeltaY *= direction;
            if (!this.scroll.hasVerticalScroll) {
                if (Math.abs(wheelDeltaY) > Math.abs(wheelDeltaX)) {
                    wheelDeltaX = wheelDeltaY;
                }
                wheelDeltaY = 0;
            }
            if (!this.scroll.hasHorizontalScroll) {
                wheelDeltaX = 0;
            }
            var directionX = wheelDeltaX > 0
                ? -1 /* Negative */
                : wheelDeltaX < 0
                    ? 1 /* Positive */
                    : 0 /* Default */;
            var directionY = wheelDeltaY > 0
                ? -1 /* Negative */
                : wheelDeltaY < 0
                    ? 1 /* Positive */
                    : 0 /* Default */;
            return {
                x: wheelDeltaX,
                y: wheelDeltaY,
                directionX: directionX,
                directionY: directionY,
            };
        };
        MouseWheel.prototype.beforeHandler = function (e) {
            var _a = this.scroll.options, preventDefault = _a.preventDefault, stopPropagation = _a.stopPropagation, preventDefaultException = _a.preventDefaultException;
            if (preventDefault &&
                !preventDefaultExceptionFn(e.target, preventDefaultException)) {
                e.preventDefault();
            }
            if (stopPropagation) {
                e.stopPropagation();
            }
        };
        MouseWheel.prototype.getEaseTime = function () {
            var SAFE_EASETIME = 100;
            var easeTime = this.mouseWheelOpt.easeTime;
            // scrollEnd event will be triggered in every calling of scrollTo when easeTime is too small
            // easeTime needs to be greater than 100
            if (easeTime < SAFE_EASETIME) {
                warn("easeTime should be greater than 100." +
                    "If mouseWheel easeTime is too small," +
                    "scrollEnd will be triggered many times.");
            }
            return Math.max(easeTime, SAFE_EASETIME);
        };
        MouseWheel.prototype.destroy = function () {
            this.eventRegister.destroy();
            window.clearTimeout(this.wheelEndTimer);
            window.clearTimeout(this.wheelMoveTimer);
            this.hooksFn.forEach(function (item) {
                var hooks = item[0];
                var hooksName = item[1];
                var handlerFn = item[2];
                hooks.off(hooksName, handlerFn);
            });
        };
        MouseWheel.pluginName = 'mouseWheel';
        MouseWheel.applyOrder = "pre" /* Pre */;
        return MouseWheel;
    }());

    var ObserveDOM = /** @class */ (function () {
        function ObserveDOM(scroll) {
            this.scroll = scroll;
            this.stopObserver = false;
            this.init();
        }
        ObserveDOM.prototype.init = function () {
            this.handleMutationObserver();
            this.handleHooks();
        };
        ObserveDOM.prototype.handleMutationObserver = function () {
            var _this = this;
            if (typeof MutationObserver !== 'undefined') {
                var timer_1 = 0;
                this.observer = new MutationObserver(function (mutations) {
                    _this.mutationObserverHandler(mutations, timer_1);
                });
                this.startObserve(this.observer);
            }
            else {
                this.checkDOMUpdate();
            }
        };
        ObserveDOM.prototype.handleHooks = function () {
            var _this = this;
            this.hooksFn = [];
            this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.contentChanged, function () {
                _this.stopObserve();
                // launch a new mutationObserver
                _this.handleMutationObserver();
            });
            this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.enable, function () {
                if (_this.stopObserver) {
                    _this.handleMutationObserver();
                }
            });
            this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.disable, function () {
                _this.stopObserve();
            });
            this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.destroy, function () {
                _this.destroy();
            });
        };
        ObserveDOM.prototype.mutationObserverHandler = function (mutations, timer) {
            var _this = this;
            if (this.shouldNotRefresh()) {
                return;
            }
            var immediateRefresh = false;
            var deferredRefresh = false;
            for (var i = 0; i < mutations.length; i++) {
                var mutation = mutations[i];
                if (mutation.type !== 'attributes') {
                    immediateRefresh = true;
                    break;
                }
                else {
                    if (mutation.target !== this.scroll.scroller.content) {
                        deferredRefresh = true;
                        break;
                    }
                }
            }
            if (immediateRefresh) {
                this.scroll.refresh();
            }
            else if (deferredRefresh) {
                // attributes changes too often
                clearTimeout(timer);
                timer = window.setTimeout(function () {
                    if (!_this.shouldNotRefresh()) {
                        _this.scroll.refresh();
                    }
                }, 60);
            }
        };
        ObserveDOM.prototype.startObserve = function (observer) {
            var config = {
                attributes: true,
                childList: true,
                subtree: true,
            };
            observer.observe(this.scroll.scroller.content, config);
        };
        ObserveDOM.prototype.shouldNotRefresh = function () {
            var scroller = this.scroll.scroller;
            var scrollBehaviorX = scroller.scrollBehaviorX, scrollBehaviorY = scroller.scrollBehaviorY;
            var outsideBoundaries = scrollBehaviorX.currentPos > scrollBehaviorX.minScrollPos ||
                scrollBehaviorX.currentPos < scrollBehaviorX.maxScrollPos ||
                scrollBehaviorY.currentPos > scrollBehaviorY.minScrollPos ||
                scrollBehaviorY.currentPos < scrollBehaviorY.maxScrollPos;
            return scroller.animater.pending || outsideBoundaries;
        };
        ObserveDOM.prototype.checkDOMUpdate = function () {
            var _this = this;
            var content = this.scroll.scroller.content;
            var contentRect = getRect(content);
            var oldWidth = contentRect.width;
            var oldHeight = contentRect.height;
            var check = function () {
                if (_this.stopObserver) {
                    return;
                }
                contentRect = getRect(content);
                var newWidth = contentRect.width;
                var newHeight = contentRect.height;
                if (oldWidth !== newWidth || oldHeight !== newHeight) {
                    _this.scroll.refresh();
                }
                oldWidth = newWidth;
                oldHeight = newHeight;
                next();
            };
            var next = function () {
                setTimeout(function () {
                    check();
                }, 1000);
            };
            next();
        };
        ObserveDOM.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        ObserveDOM.prototype.stopObserve = function () {
            this.stopObserver = true;
            if (this.observer) {
                this.observer.disconnect();
            }
        };
        ObserveDOM.prototype.destroy = function () {
            this.stopObserve();
            this.hooksFn.forEach(function (item) {
                var hooks = item[0];
                var hooksName = item[1];
                var handlerFn = item[2];
                hooks.off(hooksName, handlerFn);
            });
            this.hooksFn.length = 0;
        };
        ObserveDOM.pluginName = 'observeDOM';
        return ObserveDOM;
    }());

    var sourcePrefix$6 = 'plugins.pullDownRefresh';
    var propertiesMap$6 = [
        {
            key: 'finishPullDown',
            name: 'finishPullDown'
        },
        {
            key: 'openPullDown',
            name: 'openPullDown'
        },
        {
            key: 'closePullDown',
            name: 'closePullDown'
        },
        {
            key: 'autoPullDownRefresh',
            name: 'autoPullDownRefresh'
        }
    ];
    var propertiesConfig$6 = propertiesMap$6.map(function (item) {
        return {
            key: item.key,
            sourceKey: sourcePrefix$6 + "." + item.name
        };
    });

    var PULLING_DOWN_EVENT = 'pullingDown';
    var ENTER_THRESHOLD_EVENT = 'enterThreshold';
    var LEAVE_THRESHOLD_EVENT = 'leaveThreshold';
    var PullDown = /** @class */ (function () {
        function PullDown(scroll) {
            this.scroll = scroll;
            this.pulling = 0 /* DEFAULT */;
            this.thresholdBoundary = 0 /* DEFAULT */;
            this.init();
        }
        PullDown.prototype.setPulling = function (status) {
            this.pulling = status;
        };
        PullDown.prototype.setThresholdBoundary = function (boundary) {
            this.thresholdBoundary = boundary;
        };
        PullDown.prototype.init = function () {
            this.handleBScroll();
            this.handleOptions(this.scroll.options.pullDownRefresh);
            this.handleHooks();
            this.watch();
        };
        PullDown.prototype.handleBScroll = function () {
            this.scroll.registerType([
                PULLING_DOWN_EVENT,
                ENTER_THRESHOLD_EVENT,
                LEAVE_THRESHOLD_EVENT,
            ]);
            this.scroll.proxy(propertiesConfig$6);
        };
        PullDown.prototype.handleOptions = function (userOptions) {
            if (userOptions === void 0) { userOptions = {}; }
            userOptions = (userOptions === true ? {} : userOptions);
            var defaultOptions = {
                threshold: 90,
                stop: 40,
            };
            this.options = extend(defaultOptions, userOptions);
            this.scroll.options.probeType = 3 /* Realtime */;
        };
        PullDown.prototype.handleHooks = function () {
            var _this = this;
            this.hooksFn = [];
            var scroller = this.scroll.scroller;
            var scrollBehaviorY = scroller.scrollBehaviorY;
            this.currentMinScrollY = this.cachedOriginanMinScrollY =
                scrollBehaviorY.minScrollPos;
            this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.contentChanged, function () {
                _this.finishPullDown();
            });
            this.registerHooks(scrollBehaviorY.hooks, scrollBehaviorY.hooks.eventTypes.computeBoundary, function (boundary) {
                // content is smaller than wrapper
                if (boundary.maxScrollPos > 0) {
                    // allow scrolling when content is not full of wrapper
                    boundary.maxScrollPos = -1;
                }
                boundary.minScrollPos = _this.currentMinScrollY;
            });
            // integrate with mousewheel
            if (this.hasMouseWheelPlugin()) {
                this.registerHooks(this.scroll, this.scroll.eventTypes.alterOptions, function (mouseWheelOptions) {
                    var SANE_DISCRETE_TIME = 300;
                    var SANE_EASE_TIME = 350;
                    mouseWheelOptions.discreteTime = SANE_DISCRETE_TIME;
                    // easeTime > discreteTime ensure goInto checkPullDown function
                    mouseWheelOptions.easeTime = SANE_EASE_TIME;
                });
                this.registerHooks(this.scroll, this.scroll.eventTypes.mousewheelEnd, function () {
                    // mouseWheel need trigger checkPullDown manually
                    scroller.hooks.trigger(scroller.hooks.eventTypes.end);
                });
            }
        };
        PullDown.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        PullDown.prototype.hasMouseWheelPlugin = function () {
            return !!this.scroll.eventTypes.alterOptions;
        };
        PullDown.prototype.watch = function () {
            var scroller = this.scroll.scroller;
            this.watching = true;
            this.registerHooks(scroller.hooks, scroller.hooks.eventTypes.end, this.checkPullDown);
            this.registerHooks(this.scroll, this.scroll.eventTypes.scrollStart, this.resetStateBeforeScrollStart);
            this.registerHooks(this.scroll, this.scroll.eventTypes.scroll, this.checkLocationOfThresholdBoundary);
            if (this.hasMouseWheelPlugin()) {
                this.registerHooks(this.scroll, this.scroll.eventTypes.mousewheelStart, this.resetStateBeforeScrollStart);
            }
        };
        PullDown.prototype.resetStateBeforeScrollStart = function () {
            // current fetching pulldownRefresh has ended
            if (!this.isFetchingStatus()) {
                this.setPulling(1 /* MOVING */);
                this.setThresholdBoundary(0 /* DEFAULT */);
            }
        };
        PullDown.prototype.checkLocationOfThresholdBoundary = function () {
            // pulldownRefresh is in the phase of Moving
            if (this.pulling === 1 /* MOVING */) {
                var scroll_1 = this.scroll;
                // enter threshold boundary
                var enteredThresholdBoundary = this.thresholdBoundary !== 1 /* INSIDE */ &&
                    this.locateInsideThresholdBoundary();
                // leave threshold boundary
                var leftThresholdBoundary = this.thresholdBoundary !== 2 /* OUTSIDE */ &&
                    !this.locateInsideThresholdBoundary();
                if (enteredThresholdBoundary) {
                    this.setThresholdBoundary(1 /* INSIDE */);
                    scroll_1.trigger(ENTER_THRESHOLD_EVENT);
                }
                if (leftThresholdBoundary) {
                    this.setThresholdBoundary(2 /* OUTSIDE */);
                    scroll_1.trigger(LEAVE_THRESHOLD_EVENT);
                }
            }
        };
        PullDown.prototype.locateInsideThresholdBoundary = function () {
            return this.scroll.y <= this.options.threshold;
        };
        PullDown.prototype.unwatch = function () {
            var scroll = this.scroll;
            var scroller = scroll.scroller;
            this.watching = false;
            scroller.hooks.off(scroller.hooks.eventTypes.end, this.checkPullDown);
            scroll.off(scroll.eventTypes.scrollStart, this.resetStateBeforeScrollStart);
            scroll.off(scroll.eventTypes.scroll, this.checkLocationOfThresholdBoundary);
            if (this.hasMouseWheelPlugin()) {
                scroll.off(scroll.eventTypes.mousewheelStart, this.resetStateBeforeScrollStart);
            }
        };
        PullDown.prototype.checkPullDown = function () {
            var _a = this.options, threshold = _a.threshold, stop = _a.stop;
            // check if a real pull down action
            if (this.scroll.y < threshold) {
                return false;
            }
            if (this.pulling === 1 /* MOVING */) {
                this.modifyBehaviorYBoundary(stop);
                this.setPulling(2 /* FETCHING */);
                this.scroll.trigger(PULLING_DOWN_EVENT);
            }
            this.scroll.scrollTo(this.scroll.x, stop, this.scroll.options.bounceTime, ease.bounce);
            return this.isFetchingStatus();
        };
        PullDown.prototype.isFetchingStatus = function () {
            return this.pulling === 2 /* FETCHING */;
        };
        PullDown.prototype.modifyBehaviorYBoundary = function (stopDistance) {
            var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
            // manually modify minScrollPos for a hang animation
            // to prevent from resetPosition
            this.cachedOriginanMinScrollY = scrollBehaviorY.minScrollPos;
            this.currentMinScrollY = stopDistance;
            scrollBehaviorY.computeBoundary();
        };
        PullDown.prototype.finishPullDown = function () {
            if (this.isFetchingStatus()) {
                var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
                // restore minScrollY since the hang animation has ended
                this.currentMinScrollY = this.cachedOriginanMinScrollY;
                scrollBehaviorY.computeBoundary();
                this.setPulling(0 /* DEFAULT */);
                this.scroll.resetPosition(this.scroll.options.bounceTime, ease.bounce);
            }
        };
        // allow 'true' type is compat for beta version implements
        PullDown.prototype.openPullDown = function (config) {
            if (config === void 0) { config = {}; }
            this.handleOptions(config);
            if (!this.watching) {
                this.watch();
            }
        };
        PullDown.prototype.closePullDown = function () {
            this.unwatch();
        };
        PullDown.prototype.autoPullDownRefresh = function () {
            var _a = this.options, threshold = _a.threshold, stop = _a.stop;
            if (this.isFetchingStatus() || !this.watching) {
                return;
            }
            this.modifyBehaviorYBoundary(stop);
            this.scroll.trigger(this.scroll.eventTypes.scrollStart);
            this.scroll.scrollTo(this.scroll.x, threshold);
            this.setPulling(2 /* FETCHING */);
            this.scroll.trigger(PULLING_DOWN_EVENT);
            this.scroll.scrollTo(this.scroll.x, stop, this.scroll.options.bounceTime, ease.bounce);
        };
        PullDown.pluginName = 'pullDownRefresh';
        return PullDown;
    }());

    var sourcePrefix$5 = 'plugins.pullUpLoad';
    var propertiesMap$5 = [
        {
            key: 'finishPullUp',
            name: 'finishPullUp'
        },
        {
            key: 'openPullUp',
            name: 'openPullUp'
        },
        {
            key: 'closePullUp',
            name: 'closePullUp'
        },
        {
            key: 'autoPullUpLoad',
            name: 'autoPullUpLoad'
        }
    ];
    var propertiesConfig$5 = propertiesMap$5.map(function (item) {
        return {
            key: item.key,
            sourceKey: sourcePrefix$5 + "." + item.name
        };
    });

    var PULL_UP_HOOKS_NAME = 'pullingUp';
    var PullUp = /** @class */ (function () {
        function PullUp(scroll) {
            this.scroll = scroll;
            this.pulling = false;
            this.watching = false;
            this.init();
        }
        PullUp.prototype.init = function () {
            this.handleBScroll();
            this.handleOptions(this.scroll.options.pullUpLoad);
            this.handleHooks();
            this.watch();
        };
        PullUp.prototype.handleBScroll = function () {
            this.scroll.registerType([PULL_UP_HOOKS_NAME]);
            this.scroll.proxy(propertiesConfig$5);
        };
        PullUp.prototype.handleOptions = function (userOptions) {
            if (userOptions === void 0) { userOptions = {}; }
            userOptions = (userOptions === true ? {} : userOptions);
            var defaultOptions = {
                threshold: 0,
            };
            this.options = extend(defaultOptions, userOptions);
            this.scroll.options.probeType = 3 /* Realtime */;
        };
        PullUp.prototype.handleHooks = function () {
            var _this = this;
            this.hooksFn = [];
            var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
            this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.contentChanged, function () {
                _this.finishPullUp();
            });
            this.registerHooks(scrollBehaviorY.hooks, scrollBehaviorY.hooks.eventTypes.computeBoundary, function (boundary) {
                // content is smaller than wrapper
                if (boundary.maxScrollPos > 0) {
                    // allow scrolling when content is not full of wrapper
                    boundary.maxScrollPos = -1;
                }
            });
        };
        PullUp.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        PullUp.prototype.watch = function () {
            if (this.watching) {
                return;
            }
            this.watching = true;
            this.registerHooks(this.scroll, this.scroll.eventTypes.scroll, this.checkPullUp);
        };
        PullUp.prototype.unwatch = function () {
            this.watching = false;
            this.scroll.off(this.scroll.eventTypes.scroll, this.checkPullUp);
        };
        PullUp.prototype.checkPullUp = function (pos) {
            var _this = this;
            var threshold = this.options.threshold;
            if (this.scroll.movingDirectionY === 1 /* Positive */ &&
                pos.y <= this.scroll.maxScrollY + threshold) {
                this.pulling = true;
                // must reset pulling after scrollEnd
                this.scroll.once(this.scroll.eventTypes.scrollEnd, function () {
                    _this.pulling = false;
                });
                this.unwatch();
                this.scroll.trigger(PULL_UP_HOOKS_NAME);
            }
        };
        PullUp.prototype.finishPullUp = function () {
            var _this = this;
            // reset Direction, fix #936
            this.scroll.scroller.scrollBehaviorY.setMovingDirection(0 /* Default */);
            if (this.pulling) {
                this.scroll.once(this.scroll.eventTypes.scrollEnd, function () {
                    _this.watch();
                });
            }
            else {
                this.watch();
            }
        };
        // allow 'true' type is compat for beta version implements
        PullUp.prototype.openPullUp = function (config) {
            if (config === void 0) { config = {}; }
            this.handleOptions(config);
            this.watch();
        };
        PullUp.prototype.closePullUp = function () {
            this.unwatch();
        };
        PullUp.prototype.autoPullUpLoad = function () {
            var threshold = this.options.threshold;
            var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
            if (this.pulling || !this.watching) {
                return;
            }
            // simulate a pullUp action
            var NEGATIVE_VALUE = -1;
            var outOfBoundaryPos = scrollBehaviorY.maxScrollPos + threshold + NEGATIVE_VALUE;
            this.scroll.scroller.scrollBehaviorY.setMovingDirection(NEGATIVE_VALUE);
            this.scroll.scrollTo(this.scroll.x, outOfBoundaryPos, this.scroll.options.bounceTime);
        };
        PullUp.pluginName = 'pullUpLoad';
        return PullUp;
    }());

    var EventHandler = /** @class */ (function () {
        function EventHandler(indicator, options) {
            this.indicator = indicator;
            this.options = options;
            this.hooks = new EventEmitter(['touchStart', 'touchMove', 'touchEnd']);
            this.registerEvents();
        }
        EventHandler.prototype.registerEvents = function () {
            var _a = this.options, disableMouse = _a.disableMouse, disableTouch = _a.disableTouch;
            var startEvents = [];
            var moveEvents = [];
            var endEvents = [];
            if (!disableMouse) {
                startEvents.push({
                    name: 'mousedown',
                    handler: this.start.bind(this),
                });
                moveEvents.push({
                    name: 'mousemove',
                    handler: this.move.bind(this),
                });
                endEvents.push({
                    name: 'mouseup',
                    handler: this.end.bind(this),
                });
            }
            if (!disableTouch) {
                startEvents.push({
                    name: 'touchstart',
                    handler: this.start.bind(this),
                });
                moveEvents.push({
                    name: 'touchmove',
                    handler: this.move.bind(this),
                });
                endEvents.push({
                    name: 'touchend',
                    handler: this.end.bind(this),
                }, {
                    name: 'touchcancel',
                    handler: this.end.bind(this),
                });
            }
            this.startEventRegister = new EventRegister(this.indicator.indicatorEl, startEvents);
            this.moveEventRegister = new EventRegister(window, moveEvents);
            this.endEventRegister = new EventRegister(window, endEvents);
        };
        EventHandler.prototype.BScrollIsDisabled = function () {
            return !this.indicator.scroll.enabled;
        };
        EventHandler.prototype.start = function (e) {
            if (this.BScrollIsDisabled()) {
                return;
            }
            var point = (e.touches ? e.touches[0] : e);
            e.preventDefault();
            e.stopPropagation();
            this.initiated = true;
            this.lastPoint = point[this.indicator.keysMap.point];
            this.hooks.trigger(this.hooks.eventTypes.touchStart);
        };
        EventHandler.prototype.move = function (e) {
            if (!this.initiated) {
                return;
            }
            var point = (e.touches ? e.touches[0] : e);
            var pointPos = point[this.indicator.keysMap.point];
            e.preventDefault();
            e.stopPropagation();
            var delta = pointPos - this.lastPoint;
            this.lastPoint = pointPos;
            this.hooks.trigger(this.hooks.eventTypes.touchMove, delta);
        };
        EventHandler.prototype.end = function (e) {
            if (!this.initiated) {
                return;
            }
            this.initiated = false;
            e.preventDefault();
            e.stopPropagation();
            this.hooks.trigger(this.hooks.eventTypes.touchEnd);
        };
        EventHandler.prototype.destroy = function () {
            this.startEventRegister.destroy();
            this.moveEventRegister.destroy();
            this.endEventRegister.destroy();
        };
        return EventHandler;
    }());

    var Indicator$1 = /** @class */ (function () {
        function Indicator(scroll, options) {
            this.scroll = scroll;
            this.options = options;
            this.hooksFn = [];
            this.wrapper = options.wrapper;
            this.direction = options.direction;
            this.indicatorEl = this.wrapper.children[0];
            this.keysMap = this.getKeysMap();
            this.handleFade();
            this.handleHooks();
        }
        Indicator.prototype.handleFade = function () {
            if (this.options.fade) {
                this.wrapper.style.opacity = '0';
            }
        };
        Indicator.prototype.handleHooks = function () {
            var _this = this;
            var _a = this.options, fade = _a.fade, interactive = _a.interactive, scrollbarTrackClickable = _a.scrollbarTrackClickable;
            var scroll = this.scroll;
            var scrollHooks = scroll.hooks;
            var translaterHooks = scroll.scroller.translater.hooks;
            var animaterHooks = scroll.scroller.animater.hooks;
            this.registerHooks(scrollHooks, scrollHooks.eventTypes.refresh, this.refresh);
            this.registerHooks(translaterHooks, translaterHooks.eventTypes.translate, function (pos) {
                var hasScrollKey = _this.keysMap.hasScroll;
                if (_this.scroll[hasScrollKey]) {
                    _this.updatePosition(pos);
                }
            });
            this.registerHooks(animaterHooks, animaterHooks.eventTypes.time, this.transitionTime);
            this.registerHooks(animaterHooks, animaterHooks.eventTypes.timeFunction, this.transitionTimingFunction);
            if (fade) {
                this.registerHooks(scroll, scroll.eventTypes.scrollEnd, function () {
                    _this.fade();
                });
                this.registerHooks(scroll, scroll.eventTypes.scrollStart, function () {
                    _this.fade(true);
                });
                // for mousewheel event
                if (scroll.eventTypes.mousewheelStart &&
                    scroll.eventTypes.mousewheelEnd) {
                    this.registerHooks(scroll, scroll.eventTypes.mousewheelStart, function () {
                        _this.fade(true);
                    });
                    this.registerHooks(scroll, scroll.eventTypes.mousewheelMove, function () {
                        _this.fade(true);
                    });
                    this.registerHooks(scroll, scroll.eventTypes.mousewheelEnd, function () {
                        _this.fade();
                    });
                }
            }
            if (interactive) {
                var _b = this.scroll.options, disableMouse = _b.disableMouse, disableTouch = _b.disableTouch;
                this.eventHandler = new EventHandler(this, {
                    disableMouse: disableMouse,
                    disableTouch: disableTouch,
                });
                var eventHandlerHooks = this.eventHandler.hooks;
                this.registerHooks(eventHandlerHooks, eventHandlerHooks.eventTypes.touchStart, this.startHandler);
                this.registerHooks(eventHandlerHooks, eventHandlerHooks.eventTypes.touchMove, this.moveHandler);
                this.registerHooks(eventHandlerHooks, eventHandlerHooks.eventTypes.touchEnd, this.endHandler);
            }
            if (scrollbarTrackClickable) {
                this.bindClick();
            }
        };
        Indicator.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        Indicator.prototype.bindClick = function () {
            var wrapper = this.wrapper;
            this.clickEventRegister = new EventRegister(wrapper, [
                {
                    name: 'click',
                    handler: this.handleClick.bind(this),
                },
            ]);
        };
        Indicator.prototype.handleClick = function (e) {
            var newPos = this.calculateclickOffsetPos(e);
            var _a = this.scroll, x = _a.x, y = _a.y;
            x = this.direction === "horizontal" /* Horizontal */ ? newPos : x;
            y = this.direction === "vertical" /* Vertical */ ? newPos : y;
            this.scroll.scrollTo(x, y, this.options.scrollbarTrackOffsetTime);
        };
        Indicator.prototype.calculateclickOffsetPos = function (e) {
            var _a = this.keysMap, poinKey = _a.point, domRectKey = _a.domRect;
            var scrollbarTrackOffsetType = this.options.scrollbarTrackOffsetType;
            var clickPointOffset = e[poinKey] - this.wrapperRect[domRectKey];
            var scrollToWhere = clickPointOffset < this.currentPos ? -1 /* Up */ : 1 /* Down */;
            var delta = 0;
            var currentPos = this.currentPos;
            if (scrollbarTrackOffsetType === "step" /* Step */) {
                delta = this.scrollInfo.baseSize * scrollToWhere;
            }
            else {
                delta = 0;
                currentPos = clickPointOffset;
            }
            return this.newPos(currentPos, delta, this.scrollInfo);
        };
        Indicator.prototype.getKeysMap = function () {
            if (this.direction === "vertical" /* Vertical */) {
                return {
                    hasScroll: 'hasVerticalScroll',
                    size: 'height',
                    wrapperSize: 'clientHeight',
                    scrollerSize: 'scrollerHeight',
                    maxScrollPos: 'maxScrollY',
                    pos: 'y',
                    point: 'pageY',
                    translateProperty: 'translateY',
                    domRect: 'top',
                };
            }
            return {
                hasScroll: 'hasHorizontalScroll',
                size: 'width',
                wrapperSize: 'clientWidth',
                scrollerSize: 'scrollerWidth',
                maxScrollPos: 'maxScrollX',
                pos: 'x',
                point: 'pageX',
                translateProperty: 'translateX',
                domRect: 'left',
            };
        };
        Indicator.prototype.fade = function (visible) {
            var _a = this.options, fadeInTime = _a.fadeInTime, fadeOutTime = _a.fadeOutTime;
            var time = visible ? fadeInTime : fadeOutTime;
            var wrapper = this.wrapper;
            wrapper.style[style.transitionDuration] = time + 'ms';
            wrapper.style.opacity = visible ? '1' : '0';
        };
        Indicator.prototype.refresh = function () {
            var hasScrollKey = this.keysMap.hasScroll;
            var scroll = this.scroll;
            var x = scroll.x, y = scroll.y;
            this.wrapperRect = this.wrapper.getBoundingClientRect();
            if (this.canScroll(scroll[hasScrollKey])) {
                var _a = this.keysMap, wrapperSizeKey = _a.wrapperSize, scrollerSizeKey = _a.scrollerSize, maxScrollPosKey = _a.maxScrollPos;
                this.scrollInfo = this.refreshScrollInfo(this.wrapper[wrapperSizeKey], scroll[scrollerSizeKey], scroll[maxScrollPosKey], this.indicatorEl[wrapperSizeKey]);
                this.updatePosition({
                    x: x,
                    y: y,
                });
            }
        };
        Indicator.prototype.transitionTime = function (time) {
            if (time === void 0) { time = 0; }
            this.indicatorEl.style[style.transitionDuration] = time + 'ms';
        };
        Indicator.prototype.transitionTimingFunction = function (easing) {
            this.indicatorEl.style[style.transitionTimingFunction] = easing;
        };
        Indicator.prototype.canScroll = function (hasScroll) {
            this.wrapper.style.display = hasScroll ? 'block' : 'none';
            return hasScroll;
        };
        Indicator.prototype.refreshScrollInfo = function (wrapperSize, scrollerSize, maxScrollPos, indicatorElSize) {
            var baseSize = Math.max(Math.round((wrapperSize * wrapperSize) / (scrollerSize || wrapperSize || 1)), this.options.minSize);
            if (this.options.isCustom) {
                baseSize = indicatorElSize;
            }
            var maxIndicatorScrollPos = wrapperSize - baseSize;
            // sizeRatio is negative
            var sizeRatio = maxIndicatorScrollPos / maxScrollPos;
            return {
                baseSize: baseSize,
                maxScrollPos: maxIndicatorScrollPos,
                minScrollPos: 0,
                sizeRatio: sizeRatio,
            };
        };
        Indicator.prototype.updatePosition = function (point) {
            var _a = this.caculatePosAndSize(point, this.scrollInfo), pos = _a.pos, size = _a.size;
            this.refreshStyle(size, pos);
            this.currentPos = pos;
        };
        Indicator.prototype.caculatePosAndSize = function (point, scrollInfo) {
            var posKey = this.keysMap.pos;
            var sizeRatio = scrollInfo.sizeRatio, baseSize = scrollInfo.baseSize, maxScrollPos = scrollInfo.maxScrollPos, minScrollPos = scrollInfo.minScrollPos;
            var minSize = this.options.minSize;
            var pos = Math.round(sizeRatio * point[posKey]);
            var size;
            // when out of boundary, slow down size reduction
            if (pos < minScrollPos) {
                size = Math.max(baseSize + pos * 3, minSize);
                pos = minScrollPos;
            }
            else if (pos > maxScrollPos) {
                size = Math.max(baseSize - (pos - maxScrollPos) * 3, minSize);
                pos = maxScrollPos + baseSize - size;
            }
            else {
                size = baseSize;
            }
            return {
                pos: pos,
                size: size,
            };
        };
        Indicator.prototype.refreshStyle = function (size, pos) {
            var _a = this.keysMap, translatePropertyKey = _a.translateProperty, sizeKey = _a.size;
            var translateZ = this.scroll.options.translateZ;
            this.indicatorEl.style[sizeKey] = size + "px";
            this.indicatorEl.style[style.transform] = translatePropertyKey + "(" + pos + "px)" + translateZ;
        };
        Indicator.prototype.startHandler = function () {
            this.moved = false;
            this.startTime = getNow();
            this.transitionTime();
            this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.beforeScrollStart);
        };
        Indicator.prototype.moveHandler = function (delta) {
            if (!this.moved && !this.indicatorNotMoved(delta)) {
                this.moved = true;
                this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.scrollStart);
            }
            if (this.moved) {
                var newPos = this.newPos(this.currentPos, delta, this.scrollInfo);
                this.syncBScroll(newPos);
            }
        };
        Indicator.prototype.endHandler = function () {
            if (this.moved) {
                var _a = this.scroll, x = _a.x, y = _a.y;
                this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.scrollEnd, {
                    x: x,
                    y: y,
                });
            }
        };
        Indicator.prototype.indicatorNotMoved = function (delta) {
            var currentPos = this.currentPos;
            var _a = this.scrollInfo, maxScrollPos = _a.maxScrollPos, minScrollPos = _a.minScrollPos;
            var notMoved = (currentPos === minScrollPos && delta <= 0) ||
                (currentPos === maxScrollPos && delta >= 0);
            return notMoved;
        };
        Indicator.prototype.syncBScroll = function (newPos) {
            var timestamp = getNow();
            var _a = this.scroll, x = _a.x, y = _a.y, options = _a.options, scroller = _a.scroller, maxScrollY = _a.maxScrollY, minScrollY = _a.minScrollY, maxScrollX = _a.maxScrollX, minScrollX = _a.minScrollX;
            var probeType = options.probeType, momentumLimitTime = options.momentumLimitTime;
            var position = { x: x, y: y };
            if (this.direction === "vertical" /* Vertical */) {
                position.y = between(newPos, maxScrollY, minScrollY);
            }
            else {
                position.x = between(newPos, maxScrollX, minScrollX);
            }
            scroller.translater.translate(position);
            // dispatch scroll in interval time
            if (timestamp - this.startTime > momentumLimitTime) {
                this.startTime = timestamp;
                if (probeType === 1 /* Throttle */) {
                    scroller.hooks.trigger(scroller.hooks.eventTypes.scroll, position);
                }
            }
            // dispatch scroll all the time
            if (probeType > 1 /* Throttle */) {
                scroller.hooks.trigger(scroller.hooks.eventTypes.scroll, position);
            }
        };
        Indicator.prototype.newPos = function (currentPos, delta, scrollInfo) {
            var maxScrollPos = scrollInfo.maxScrollPos, sizeRatio = scrollInfo.sizeRatio, minScrollPos = scrollInfo.minScrollPos;
            var newPos = currentPos + delta;
            newPos = between(newPos, minScrollPos, maxScrollPos);
            return Math.round(newPos / sizeRatio);
        };
        Indicator.prototype.destroy = function () {
            var _a = this.options, interactive = _a.interactive, scrollbarTrackClickable = _a.scrollbarTrackClickable, isCustom = _a.isCustom;
            if (interactive) {
                this.eventHandler.destroy();
            }
            if (scrollbarTrackClickable) {
                this.clickEventRegister.destroy();
            }
            if (!isCustom) {
                this.wrapper.parentNode.removeChild(this.wrapper);
            }
            this.hooksFn.forEach(function (item) {
                var hooks = item[0];
                var hooksName = item[1];
                var handlerFn = item[2];
                hooks.off(hooksName, handlerFn);
            });
            this.hooksFn.length = 0;
        };
        return Indicator;
    }());

    var ScrollBar = /** @class */ (function () {
        function ScrollBar(scroll) {
            this.scroll = scroll;
            this.handleOptions();
            this.createIndicators();
            this.handleHooks();
        }
        ScrollBar.prototype.handleHooks = function () {
            var _this = this;
            var scroll = this.scroll;
            scroll.hooks.on(scroll.hooks.eventTypes.destroy, function () {
                for (var _i = 0, _a = _this.indicators; _i < _a.length; _i++) {
                    var indicator = _a[_i];
                    indicator.destroy();
                }
            });
        };
        ScrollBar.prototype.handleOptions = function () {
            var userOptions = (this.scroll.options.scrollbar === true
                ? {}
                : this.scroll.options.scrollbar);
            var defaultOptions = {
                fade: true,
                fadeInTime: 250,
                fadeOutTime: 500,
                interactive: false,
                customElements: [],
                minSize: 8,
                scrollbarTrackClickable: false,
                scrollbarTrackOffsetType: "step" /* Step */,
                scrollbarTrackOffsetTime: 300,
            };
            this.options = extend(defaultOptions, userOptions);
        };
        ScrollBar.prototype.createIndicators = function () {
            var indicatorOptions;
            var scroll = this.scroll;
            var indicators = [];
            var scrollDirectionConfigKeys = ['scrollX', 'scrollY'];
            var indicatorDirections = [
                "horizontal" /* Horizontal */,
                "vertical" /* Vertical */,
            ];
            var customScrollbarEls = this.options.customElements;
            for (var i = 0; i < scrollDirectionConfigKeys.length; i++) {
                var key = scrollDirectionConfigKeys[i];
                // wanna scroll in specified direction
                if (scroll.options[key]) {
                    var customElement = customScrollbarEls.shift();
                    var direction = indicatorDirections[i];
                    var isCustom = false;
                    var scrollbarWrapper = customElement
                        ? customElement
                        : this.createScrollbarElement(direction);
                    // internal scrollbar
                    if (scrollbarWrapper !== customElement) {
                        scroll.wrapper.appendChild(scrollbarWrapper);
                    }
                    else {
                        // custom scrollbar passed by users
                        isCustom = true;
                    }
                    indicatorOptions = __assign(__assign({ wrapper: scrollbarWrapper, direction: direction }, this.options), { isCustom: isCustom });
                    indicators.push(new Indicator$1(scroll, indicatorOptions));
                }
            }
            this.indicators = indicators;
        };
        ScrollBar.prototype.createScrollbarElement = function (direction, scrollbarTrackClickable) {
            if (scrollbarTrackClickable === void 0) { scrollbarTrackClickable = this.options.scrollbarTrackClickable; }
            var scrollbarWrapperEl = document.createElement('div');
            var scrollbarIndicatorEl = document.createElement('div');
            scrollbarWrapperEl.style.cssText =
                'position:absolute;z-index:9999;overflow:hidden;';
            scrollbarIndicatorEl.style.cssText =
                '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;';
            scrollbarIndicatorEl.className = 'bscroll-indicator';
            if (direction === "horizontal" /* Horizontal */) {
                scrollbarWrapperEl.style.cssText +=
                    'height:7px;left:2px;right:2px;bottom:0;';
                scrollbarIndicatorEl.style.height = '100%';
                scrollbarWrapperEl.className = 'bscroll-horizontal-scrollbar';
            }
            else {
                scrollbarWrapperEl.style.cssText +=
                    'width:7px;bottom:2px;top:2px;right:1px;';
                scrollbarIndicatorEl.style.width = '100%';
                scrollbarWrapperEl.className = 'bscroll-vertical-scrollbar';
            }
            if (!scrollbarTrackClickable) {
                scrollbarWrapperEl.style.cssText += 'pointer-events:none;';
            }
            scrollbarWrapperEl.appendChild(scrollbarIndicatorEl);
            return scrollbarWrapperEl;
        };
        ScrollBar.pluginName = 'scrollbar';
        return ScrollBar;
    }());

    var PagesMatrix = /** @class */ (function () {
        function PagesMatrix(scroll) {
            this.scroll = scroll;
            this.init();
        }
        PagesMatrix.prototype.init = function () {
            var scroller = this.scroll.scroller;
            var scrollBehaviorX = scroller.scrollBehaviorX, scrollBehaviorY = scroller.scrollBehaviorY;
            this.wrapperWidth = scrollBehaviorX.wrapperSize;
            this.wrapperHeight = scrollBehaviorY.wrapperSize;
            this.scrollerHeight = scrollBehaviorY.contentSize;
            this.scrollerWidth = scrollBehaviorX.contentSize;
            this.pages = this.buildPagesMatrix(this.wrapperWidth, this.wrapperHeight);
            this.pageLengthOfX = this.pages ? this.pages.length : 0;
            this.pageLengthOfY = this.pages && this.pages[0] ? this.pages[0].length : 0;
        };
        PagesMatrix.prototype.getPageStats = function (pageX, pageY) {
            return this.pages[pageX][pageY];
        };
        PagesMatrix.prototype.getNearestPageIndex = function (x, y) {
            var pageX = 0;
            var pageY = 0;
            var l = this.pages.length;
            for (; pageX < l - 1; pageX++) {
                if (x >= this.pages[pageX][0].cx) {
                    break;
                }
            }
            l = this.pages[pageX].length;
            for (; pageY < l - 1; pageY++) {
                if (y >= this.pages[0][pageY].cy) {
                    break;
                }
            }
            return {
                pageX: pageX,
                pageY: pageY,
            };
        };
        // (n x 1) matrix for horizontal scroll or
        // (1 * n) matrix for vertical scroll
        PagesMatrix.prototype.buildPagesMatrix = function (stepX, stepY) {
            var pages = [];
            var x = 0;
            var y;
            var cx;
            var cy;
            var i = 0;
            var l;
            var maxScrollPosX = this.scroll.scroller.scrollBehaviorX.maxScrollPos;
            var maxScrollPosY = this.scroll.scroller.scrollBehaviorY.maxScrollPos;
            cx = Math.round(stepX / 2);
            cy = Math.round(stepY / 2);
            while (x > -this.scrollerWidth) {
                pages[i] = [];
                l = 0;
                y = 0;
                while (y > -this.scrollerHeight) {
                    pages[i][l] = {
                        x: Math.max(x, maxScrollPosX),
                        y: Math.max(y, maxScrollPosY),
                        width: stepX,
                        height: stepY,
                        cx: x - cx,
                        cy: y - cy,
                    };
                    y -= stepY;
                    l++;
                }
                x -= stepX;
                i++;
            }
            return pages;
        };
        return PagesMatrix;
    }());

    var BASE_PAGE = {
        pageX: 0,
        pageY: 0,
        x: 0,
        y: 0,
    };

    var SlidePages = /** @class */ (function () {
        function SlidePages(scroll, slideOptions) {
            this.scroll = scroll;
            this.slideOptions = slideOptions;
            this.slideX = false;
            this.slideY = false;
            this.currentPage = extend({}, BASE_PAGE);
        }
        SlidePages.prototype.refresh = function () {
            this.pagesMatrix = new PagesMatrix(this.scroll);
            this.checkSlideLoop();
            this.currentPage = this.getAdjustedCurrentPage();
        };
        SlidePages.prototype.getAdjustedCurrentPage = function () {
            var _a = this.currentPage, pageX = _a.pageX, pageY = _a.pageY;
            // page index should be handled
            // because page counts may reduce
            pageX = Math.min(pageX, this.pagesMatrix.pageLengthOfX - 1);
            pageY = Math.min(pageY, this.pagesMatrix.pageLengthOfY - 1);
            // loop scene should also be respected
            // because clonedNode will cause pageLength increasing
            if (this.loopX) {
                pageX = Math.min(pageX, this.pagesMatrix.pageLengthOfX - 2);
            }
            if (this.loopY) {
                pageY = Math.min(pageY, this.pagesMatrix.pageLengthOfY - 2);
            }
            var _b = this.pagesMatrix.getPageStats(pageX, pageY), x = _b.x, y = _b.y;
            return { pageX: pageX, pageY: pageY, x: x, y: y };
        };
        SlidePages.prototype.setCurrentPage = function (newPage) {
            this.currentPage = newPage;
        };
        SlidePages.prototype.getInternalPage = function (pageX, pageY) {
            if (pageX >= this.pagesMatrix.pageLengthOfX) {
                pageX = this.pagesMatrix.pageLengthOfX - 1;
            }
            else if (pageX < 0) {
                pageX = 0;
            }
            if (pageY >= this.pagesMatrix.pageLengthOfY) {
                pageY = this.pagesMatrix.pageLengthOfY - 1;
            }
            else if (pageY < 0) {
                pageY = 0;
            }
            var _a = this.pagesMatrix.getPageStats(pageX, pageY), x = _a.x, y = _a.y;
            return {
                pageX: pageX,
                pageY: pageY,
                x: x,
                y: y,
            };
        };
        SlidePages.prototype.getInitialPage = function (showFirstPage, firstInitialised) {
            if (showFirstPage === void 0) { showFirstPage = false; }
            if (firstInitialised === void 0) { firstInitialised = false; }
            var _a = this.slideOptions, startPageXIndex = _a.startPageXIndex, startPageYIndex = _a.startPageYIndex;
            var firstPageX = this.loopX ? 1 : 0;
            var firstPageY = this.loopY ? 1 : 0;
            var pageX = showFirstPage ? firstPageX : this.currentPage.pageX;
            var pageY = showFirstPage ? firstPageY : this.currentPage.pageY;
            if (firstInitialised) {
                pageX = this.loopX ? startPageXIndex + 1 : startPageXIndex;
                pageY = this.loopY ? startPageYIndex + 1 : startPageYIndex;
            }
            else {
                pageX = showFirstPage ? firstPageX : this.currentPage.pageX;
                pageY = showFirstPage ? firstPageY : this.currentPage.pageY;
            }
            var _b = this.pagesMatrix.getPageStats(pageX, pageY), x = _b.x, y = _b.y;
            return {
                pageX: pageX,
                pageY: pageY,
                x: x,
                y: y,
            };
        };
        SlidePages.prototype.getExposedPage = function (page) {
            var exposedPage = extend({}, page);
            // only pageX or pageY need fix
            if (this.loopX) {
                exposedPage.pageX = this.fixedPage(exposedPage.pageX, this.pagesMatrix.pageLengthOfX - 2);
            }
            if (this.loopY) {
                exposedPage.pageY = this.fixedPage(exposedPage.pageY, this.pagesMatrix.pageLengthOfY - 2);
            }
            return exposedPage;
        };
        SlidePages.prototype.getExposedPageByPageIndex = function (pageIndexX, pageIndexY) {
            var page = {
                pageX: pageIndexX,
                pageY: pageIndexY,
            };
            if (this.loopX) {
                page.pageX = pageIndexX + 1;
            }
            if (this.loopY) {
                page.pageY = pageIndexY + 1;
            }
            var _a = this.pagesMatrix.getPageStats(page.pageX, page.pageY), x = _a.x, y = _a.y;
            return {
                x: x,
                y: y,
                pageX: pageIndexX,
                pageY: pageIndexY,
            };
        };
        SlidePages.prototype.getWillChangedPage = function (page) {
            page = extend({}, page);
            // Page need fix
            if (this.loopX) {
                page.pageX = this.fixedPage(page.pageX, this.pagesMatrix.pageLengthOfX - 2);
                page.x = this.pagesMatrix.getPageStats(page.pageX + 1, 0).x;
            }
            if (this.loopY) {
                page.pageY = this.fixedPage(page.pageY, this.pagesMatrix.pageLengthOfY - 2);
                page.y = this.pagesMatrix.getPageStats(0, page.pageY + 1).y;
            }
            return page;
        };
        SlidePages.prototype.fixedPage = function (page, realPageLen) {
            var pageIndex = [];
            for (var i = 0; i < realPageLen; i++) {
                pageIndex.push(i);
            }
            pageIndex.unshift(realPageLen - 1);
            pageIndex.push(0);
            return pageIndex[page];
        };
        SlidePages.prototype.getPageStats = function () {
            return this.pagesMatrix.getPageStats(this.currentPage.pageX, this.currentPage.pageY);
        };
        SlidePages.prototype.getValidPageIndex = function (x, y) {
            var lastX = this.pagesMatrix.pageLengthOfX - 1;
            var lastY = this.pagesMatrix.pageLengthOfY - 1;
            var firstX = 0;
            var firstY = 0;
            if (this.loopX) {
                x += 1;
                firstX = firstX + 1;
                lastX = lastX - 1;
            }
            if (this.loopY) {
                y += 1;
                firstY = firstY + 1;
                lastY = lastY - 1;
            }
            x = between(x, firstX, lastX);
            y = between(y, firstY, lastY);
            return {
                pageX: x,
                pageY: y,
            };
        };
        SlidePages.prototype.nextPageIndex = function () {
            return this.getPageIndexByDirection("positive" /* Positive */);
        };
        SlidePages.prototype.prevPageIndex = function () {
            return this.getPageIndexByDirection("negative" /* Negative */);
        };
        SlidePages.prototype.getNearestPage = function (x, y) {
            var pageIndex = this.pagesMatrix.getNearestPageIndex(x, y);
            var pageX = pageIndex.pageX, pageY = pageIndex.pageY;
            var newX = this.pagesMatrix.getPageStats(pageX, 0).x;
            var newY = this.pagesMatrix.getPageStats(0, pageY).y;
            return {
                x: newX,
                y: newY,
                pageX: pageX,
                pageY: pageY,
            };
        };
        SlidePages.prototype.getPageByDirection = function (page, directionX, directionY) {
            var pageX = page.pageX, pageY = page.pageY;
            if (pageX === this.currentPage.pageX) {
                pageX = between(pageX + directionX, 0, this.pagesMatrix.pageLengthOfX - 1);
            }
            if (pageY === this.currentPage.pageY) {
                pageY = between(pageY + directionY, 0, this.pagesMatrix.pageLengthOfY - 1);
            }
            var x = this.pagesMatrix.getPageStats(pageX, 0).x;
            var y = this.pagesMatrix.getPageStats(0, pageY).y;
            return {
                x: x,
                y: y,
                pageX: pageX,
                pageY: pageY,
            };
        };
        SlidePages.prototype.resetLoopPage = function () {
            if (this.loopX) {
                if (this.currentPage.pageX === 0) {
                    return {
                        pageX: this.pagesMatrix.pageLengthOfX - 2,
                        pageY: this.currentPage.pageY,
                    };
                }
                if (this.currentPage.pageX === this.pagesMatrix.pageLengthOfX - 1) {
                    return {
                        pageX: 1,
                        pageY: this.currentPage.pageY,
                    };
                }
            }
            if (this.loopY) {
                if (this.currentPage.pageY === 0) {
                    return {
                        pageX: this.currentPage.pageX,
                        pageY: this.pagesMatrix.pageLengthOfY - 2,
                    };
                }
                if (this.currentPage.pageY === this.pagesMatrix.pageLengthOfY - 1) {
                    return {
                        pageX: this.currentPage.pageX,
                        pageY: 1,
                    };
                }
            }
        };
        SlidePages.prototype.getPageIndexByDirection = function (direction) {
            var x = this.currentPage.pageX;
            var y = this.currentPage.pageY;
            if (this.slideX) {
                x = direction === "negative" /* Negative */ ? x - 1 : x + 1;
            }
            if (this.slideY) {
                y = direction === "negative" /* Negative */ ? y - 1 : y + 1;
            }
            return {
                pageX: x,
                pageY: y,
            };
        };
        SlidePages.prototype.checkSlideLoop = function () {
            this.wannaLoop = this.slideOptions.loop;
            if (this.pagesMatrix.pageLengthOfX > 1) {
                this.slideX = true;
            }
            else {
                this.slideX = false;
            }
            if (this.pagesMatrix.pages[0] && this.pagesMatrix.pageLengthOfY > 1) {
                this.slideY = true;
            }
            else {
                this.slideY = false;
            }
            this.loopX = this.wannaLoop && this.slideX;
            this.loopY = this.wannaLoop && this.slideY;
            if (this.slideX && this.slideY) {
                warn('slide does not support two direction at the same time.');
            }
        };
        return SlidePages;
    }());

    var sourcePrefix$4 = 'plugins.slide';
    var propertiesMap$4 = [
        {
            key: 'next',
            name: 'next',
        },
        {
            key: 'prev',
            name: 'prev',
        },
        {
            key: 'goToPage',
            name: 'goToPage',
        },
        {
            key: 'getCurrentPage',
            name: 'getCurrentPage',
        },
        {
            key: 'startPlay',
            name: 'startPlay',
        },
        {
            key: 'pausePlay',
            name: 'pausePlay',
        },
    ];
    var propertiesConfig$4 = propertiesMap$4.map(function (item) {
        return {
            key: item.key,
            sourceKey: sourcePrefix$4 + "." + item.name,
        };
    });

    var samePage = function (p1, p2) {
        return p1.pageX === p2.pageX && p1.pageY === p2.pageY;
    };
    var Slide = /** @class */ (function () {
        function Slide(scroll) {
            this.scroll = scroll;
            this.cachedClonedPageDOM = [];
            this.resetLooping = false;
            this.autoplayTimer = 0;
            if (!this.satisfyInitialization()) {
                return;
            }
            this.init();
        }
        Slide.prototype.satisfyInitialization = function () {
            if (this.scroll.scroller.content.children.length <= 0) {
                warn("slide need at least one slide page to be initialised." +
                    "please check your DOM layout.");
                return false;
            }
            return true;
        };
        Slide.prototype.init = function () {
            this.willChangeToPage = extend({}, BASE_PAGE);
            this.handleBScroll();
            this.handleOptions();
            this.handleHooks();
            this.createPages();
        };
        Slide.prototype.createPages = function () {
            this.pages = new SlidePages(this.scroll, this.options);
        };
        Slide.prototype.handleBScroll = function () {
            this.scroll.registerType(['slideWillChange', 'slidePageChanged']);
            this.scroll.proxy(propertiesConfig$4);
        };
        Slide.prototype.handleOptions = function () {
            var userOptions = (this.scroll.options.slide === true
                ? {}
                : this.scroll.options.slide);
            var defaultOptions = {
                loop: true,
                threshold: 0.1,
                speed: 400,
                easing: ease.bounce,
                listenFlick: true,
                autoplay: true,
                interval: 3000,
                startPageXIndex: 0,
                startPageYIndex: 0,
            };
            this.options = extend(defaultOptions, userOptions);
        };
        Slide.prototype.handleLoop = function (prevSlideContent) {
            var loop = this.options.loop;
            var slideContent = this.scroll.scroller.content;
            var currentSlidePagesLength = slideContent.children.length;
            // only should respect loop scene
            if (loop) {
                if (slideContent !== prevSlideContent) {
                    this.resetLoopChangedStatus();
                    this.removeClonedSlidePage(prevSlideContent);
                    currentSlidePagesLength > 1 &&
                        this.cloneFirstAndLastSlidePage(slideContent);
                }
                else {
                    // many pages reduce to one page
                    if (currentSlidePagesLength === 3 && this.initialised) {
                        this.removeClonedSlidePage(slideContent);
                        this.moreToOnePageInLoop = true;
                        this.oneToMorePagesInLoop = false;
                    }
                    else if (currentSlidePagesLength > 1) {
                        // one page increases to many page
                        if (this.initialised && this.cachedClonedPageDOM.length === 0) {
                            this.oneToMorePagesInLoop = true;
                            this.moreToOnePageInLoop = false;
                        }
                        else {
                            this.removeClonedSlidePage(slideContent);
                            this.resetLoopChangedStatus();
                        }
                        this.cloneFirstAndLastSlidePage(slideContent);
                    }
                    else {
                        this.resetLoopChangedStatus();
                    }
                }
            }
        };
        Slide.prototype.resetLoopChangedStatus = function () {
            this.moreToOnePageInLoop = false;
            this.oneToMorePagesInLoop = false;
        };
        Slide.prototype.handleHooks = function () {
            var _this = this;
            var scrollHooks = this.scroll.hooks;
            var scrollerHooks = this.scroll.scroller.hooks;
            var listenFlick = this.options.listenFlick;
            this.prevContent = this.scroll.scroller.content;
            this.hooksFn = [];
            // scroll
            this.registerHooks(this.scroll, this.scroll.eventTypes.beforeScrollStart, this.pausePlay);
            this.registerHooks(this.scroll, this.scroll.eventTypes.scrollEnd, this.modifyCurrentPage);
            this.registerHooks(this.scroll, this.scroll.eventTypes.scrollEnd, this.startPlay);
            // for mousewheel event
            if (this.scroll.eventTypes.mousewheelMove) {
                this.registerHooks(this.scroll, this.scroll.eventTypes.mousewheelMove, function () {
                    // prevent default action of mousewheelMove
                    return true;
                });
                this.registerHooks(this.scroll, this.scroll.eventTypes.mousewheelEnd, function (delta) {
                    if (delta.directionX === 1 /* Positive */ ||
                        delta.directionY === 1 /* Positive */) {
                        _this.next();
                    }
                    if (delta.directionX === -1 /* Negative */ ||
                        delta.directionY === -1 /* Negative */) {
                        _this.prev();
                    }
                });
            }
            // scrollHooks
            this.registerHooks(scrollHooks, scrollHooks.eventTypes.refresh, this.refreshHandler);
            this.registerHooks(scrollHooks, scrollHooks.eventTypes.destroy, this.destroy);
            // scroller
            this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.beforeRefresh, function () {
                _this.handleLoop(_this.prevContent);
                _this.setSlideInlineStyle();
            });
            this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.momentum, this.modifyScrollMetaHandler);
            this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.scroll, this.scrollHandler);
            // a click operation will clearTimer, so restart a new one
            this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.checkClick, this.startPlay);
            if (listenFlick) {
                this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.flick, this.flickHandler);
            }
        };
        Slide.prototype.startPlay = function () {
            var _this = this;
            var _a = this.options, interval = _a.interval, autoplay = _a.autoplay;
            if (autoplay) {
                clearTimeout(this.autoplayTimer);
                this.autoplayTimer = window.setTimeout(function () {
                    _this.next();
                }, interval);
            }
        };
        Slide.prototype.pausePlay = function () {
            if (this.options.autoplay) {
                clearTimeout(this.autoplayTimer);
            }
        };
        Slide.prototype.setSlideInlineStyle = function () {
            var styleConfigurations = [
                {
                    direction: 'scrollX',
                    sizeType: 'offsetWidth',
                    styleType: 'width',
                },
                {
                    direction: 'scrollY',
                    sizeType: 'offsetHeight',
                    styleType: 'height',
                },
            ];
            var _a = this.scroll.scroller, slideContent = _a.content, slideWrapper = _a.wrapper;
            var scrollOptions = this.scroll.options;
            styleConfigurations.forEach(function (_a) {
                var direction = _a.direction, sizeType = _a.sizeType, styleType = _a.styleType;
                // wanna scroll in this direction
                if (scrollOptions[direction]) {
                    var size = slideWrapper[sizeType];
                    var children = slideContent.children;
                    var length_1 = children.length;
                    for (var i = 0; i < length_1; i++) {
                        var slidePageDOM = children[i];
                        slidePageDOM.style[styleType] = size + 'px';
                    }
                    slideContent.style[styleType] = size * length_1 + 'px';
                }
            });
        };
        Slide.prototype.next = function (time, easing) {
            var _a = this.pages.nextPageIndex(), pageX = _a.pageX, pageY = _a.pageY;
            this.goTo(pageX, pageY, time, easing);
        };
        Slide.prototype.prev = function (time, easing) {
            var _a = this.pages.prevPageIndex(), pageX = _a.pageX, pageY = _a.pageY;
            this.goTo(pageX, pageY, time, easing);
        };
        Slide.prototype.goToPage = function (pageX, pageY, time, easing) {
            var pageIndex = this.pages.getValidPageIndex(pageX, pageY);
            this.goTo(pageIndex.pageX, pageIndex.pageY, time, easing);
        };
        Slide.prototype.getCurrentPage = function () {
            return this.exposedPage || this.pages.getInitialPage(false, true);
        };
        Slide.prototype.setCurrentPage = function (page) {
            this.pages.setCurrentPage(page);
            this.exposedPage = this.pages.getExposedPage(page);
        };
        Slide.prototype.nearestPage = function (x, y) {
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
            var maxScrollPosX = scrollBehaviorX.maxScrollPos, minScrollPosX = scrollBehaviorX.minScrollPos;
            var maxScrollPosY = scrollBehaviorY.maxScrollPos, minScrollPosY = scrollBehaviorY.minScrollPos;
            return this.pages.getNearestPage(between(x, maxScrollPosX, minScrollPosX), between(y, maxScrollPosY, minScrollPosY));
        };
        Slide.prototype.satisfyThreshold = function (x, y) {
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
            var satisfied = true;
            if (Math.abs(x - scrollBehaviorX.absStartPos) <= this.thresholdX &&
                Math.abs(y - scrollBehaviorY.absStartPos) <= this.thresholdY) {
                satisfied = false;
            }
            return satisfied;
        };
        Slide.prototype.refreshHandler = function (content) {
            var _this = this;
            if (!this.satisfyInitialization()) {
                return;
            }
            this.pages.refresh();
            this.computeThreshold();
            var contentChanged = (this.contentChanged = this.prevContent !== content);
            if (contentChanged) {
                this.prevContent = content;
            }
            var initPage = this.pages.getInitialPage(this.oneToMorePagesInLoop || this.moreToOnePageInLoop, contentChanged || !this.initialised);
            if (this.initialised) {
                this.goTo(initPage.pageX, initPage.pageY, 0);
            }
            else {
                this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.beforeInitialScrollTo, function (position) {
                    _this.initialised = true;
                    position.x = initPage.x;
                    position.y = initPage.y;
                });
            }
            this.startPlay();
        };
        Slide.prototype.computeThreshold = function () {
            var threshold = this.options.threshold;
            // Integer
            if (threshold % 1 === 0) {
                this.thresholdX = threshold;
                this.thresholdY = threshold;
            }
            else {
                // decimal
                var _a = this.pages.getPageStats(), width = _a.width, height = _a.height;
                this.thresholdX = Math.round(width * threshold);
                this.thresholdY = Math.round(height * threshold);
            }
        };
        Slide.prototype.cloneFirstAndLastSlidePage = function (slideContent) {
            var children = slideContent.children;
            var preprendDOM = children[children.length - 1].cloneNode(true);
            var appendDOM = children[0].cloneNode(true);
            prepend(preprendDOM, slideContent);
            slideContent.appendChild(appendDOM);
            this.cachedClonedPageDOM = [preprendDOM, appendDOM];
        };
        Slide.prototype.removeClonedSlidePage = function (slideContent) {
            // maybe slideContent has removed from DOM Tree
            var slidePages = (slideContent && slideContent.children) || [];
            if (slidePages.length) {
                this.cachedClonedPageDOM.forEach(function (el) {
                    removeChild(slideContent, el);
                });
            }
            this.cachedClonedPageDOM = [];
        };
        Slide.prototype.modifyCurrentPage = function (point) {
            var _a = this.getCurrentPage(), prevExposedPageX = _a.pageX, prevExposedPageY = _a.pageY;
            var newPage = this.nearestPage(point.x, point.y);
            this.setCurrentPage(newPage);
            /* istanbul ignore if */
            if (this.contentChanged) {
                this.contentChanged = false;
                return true;
            }
            var _b = this.getCurrentPage(), currentExposedPageX = _b.pageX, currentExposedPageY = _b.pageY;
            this.pageWillChangeTo(newPage);
            // loop is true, and one page becomes many pages when call bs.refresh
            if (this.oneToMorePagesInLoop) {
                this.oneToMorePagesInLoop = false;
                return true;
            }
            // loop is true, and many page becomes one page when call bs.refresh
            // if prevPage > 0, dispatch slidePageChanged and scrollEnd events
            /* istanbul ignore if */
            if (this.moreToOnePageInLoop &&
                prevExposedPageX === 0 &&
                prevExposedPageY === 0) {
                this.moreToOnePageInLoop = false;
                return true;
            }
            if (prevExposedPageX !== currentExposedPageX ||
                prevExposedPageY !== currentExposedPageY) {
                // only trust pageX & pageY when loop is true
                var page = this.pages.getExposedPageByPageIndex(currentExposedPageX, currentExposedPageY);
                this.scroll.trigger(this.scroll.eventTypes.slidePageChanged, page);
            }
            // triggered by resetLoop
            if (this.resetLooping) {
                this.resetLooping = false;
                return;
            }
            var changePage = this.pages.resetLoopPage();
            if (changePage) {
                this.resetLooping = true;
                this.goTo(changePage.pageX, changePage.pageY, 0);
                // stop user's scrollEnd
                // since it is a seamless scroll
                return true;
            }
        };
        Slide.prototype.goTo = function (pageX, pageY, time, easing) {
            var newPage = this.pages.getInternalPage(pageX, pageY);
            var scrollEasing = easing || this.options.easing || ease.bounce;
            var x = newPage.x, y = newPage.y;
            var deltaX = x - this.scroll.scroller.scrollBehaviorX.currentPos;
            var deltaY = y - this.scroll.scroller.scrollBehaviorY.currentPos;
            /* istanbul ignore if */
            if (!deltaX && !deltaY) {
                this.scroll.scroller.togglePointerEvents(true);
                return;
            }
            time = time === undefined ? this.getEaseTime(deltaX, deltaY) : time;
            this.scroll.scroller.scrollTo(x, y, time, scrollEasing);
        };
        Slide.prototype.flickHandler = function () {
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
            var currentPosX = scrollBehaviorX.currentPos, startPosX = scrollBehaviorX.startPos, directionX = scrollBehaviorX.direction;
            var currentPosY = scrollBehaviorY.currentPos, startPosY = scrollBehaviorY.startPos, directionY = scrollBehaviorY.direction;
            var _b = this.pages.currentPage, pageX = _b.pageX, pageY = _b.pageY;
            var time = this.getEaseTime(currentPosX - startPosX, currentPosY - startPosY);
            this.goTo(pageX + directionX, pageY + directionY, time);
        };
        Slide.prototype.getEaseTime = function (deltaX, deltaY) {
            return (this.options.speed ||
                Math.max(Math.max(Math.min(Math.abs(deltaX), 1000), Math.min(Math.abs(deltaY), 1000)), 300));
        };
        Slide.prototype.modifyScrollMetaHandler = function (scrollMeta) {
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY, animater = _a.animater;
            var newX = scrollMeta.newX;
            var newY = scrollMeta.newY;
            var newPage = this.satisfyThreshold(newX, newY) || animater.forceStopped
                ? this.pages.getPageByDirection(this.nearestPage(newX, newY), scrollBehaviorX.direction, scrollBehaviorY.direction)
                : this.pages.currentPage;
            scrollMeta.time = this.getEaseTime(scrollMeta.newX - newPage.x, scrollMeta.newY - newPage.y);
            scrollMeta.newX = newPage.x;
            scrollMeta.newY = newPage.y;
            scrollMeta.easing = this.options.easing || ease.bounce;
        };
        Slide.prototype.scrollHandler = function (_a) {
            var x = _a.x, y = _a.y;
            if (this.satisfyThreshold(x, y)) {
                var newPage = this.nearestPage(x, y);
                this.pageWillChangeTo(newPage);
            }
        };
        Slide.prototype.pageWillChangeTo = function (newPage) {
            var changeToPage = this.pages.getWillChangedPage(newPage);
            if (!samePage(this.willChangeToPage, changeToPage)) {
                this.willChangeToPage = changeToPage;
                this.scroll.trigger(this.scroll.eventTypes.slideWillChange, this.willChangeToPage);
            }
        };
        Slide.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        Slide.prototype.destroy = function () {
            var slideContent = this.scroll.scroller.content;
            var _a = this.options, loop = _a.loop, autoplay = _a.autoplay;
            if (loop) {
                this.removeClonedSlidePage(slideContent);
            }
            if (autoplay) {
                clearTimeout(this.autoplayTimer);
            }
            this.hooksFn.forEach(function (item) {
                var hooks = item[0];
                var hooksName = item[1];
                var handlerFn = item[2];
                if (hooks.eventTypes[hooksName]) {
                    hooks.off(hooksName, handlerFn);
                }
            });
            this.hooksFn.length = 0;
        };
        Slide.pluginName = 'slide';
        return Slide;
    }());

    var sourcePrefix$3 = 'plugins.wheel';
    var propertiesMap$3 = [
        {
            key: 'wheelTo',
            name: 'wheelTo',
        },
        {
            key: 'getSelectedIndex',
            name: 'getSelectedIndex',
        },
        {
            key: 'restorePosition',
            name: 'restorePosition',
        },
    ];
    var propertiesConfig$3 = propertiesMap$3.map(function (item) {
        return {
            key: item.key,
            sourceKey: sourcePrefix$3 + "." + item.name,
        };
    });

    var WHEEL_INDEX_CHANGED_EVENT_NAME = 'wheelIndexChanged';
    var CONSTANTS = {
        rate: 4
    };
    var Wheel = /** @class */ (function () {
        function Wheel(scroll) {
            this.scroll = scroll;
            this.init();
        }
        Wheel.prototype.init = function () {
            this.handleBScroll();
            this.handleOptions();
            this.handleHooks();
            // init boundary for Wheel
            this.refreshBoundary();
            this.setSelectedIndex(this.options.selectedIndex);
        };
        Wheel.prototype.handleBScroll = function () {
            this.scroll.proxy(propertiesConfig$3);
            this.scroll.registerType([WHEEL_INDEX_CHANGED_EVENT_NAME]);
        };
        Wheel.prototype.handleOptions = function () {
            var userOptions = (this.scroll.options.wheel === true
                ? {}
                : this.scroll.options.wheel);
            var defaultOptions = {
                wheelWrapperClass: 'wheel-scroll',
                wheelItemClass: 'wheel-item',
                rotate: 25,
                adjustTime: 400,
                selectedIndex: 0,
                wheelDisabledItemClass: 'wheel-disabled-item'
            };
            this.options = extend(defaultOptions, userOptions);
        };
        Wheel.prototype.handleHooks = function () {
            var _this = this;
            var scroll = this.scroll;
            var scroller = this.scroll.scroller;
            var actionsHandler = scroller.actionsHandler, scrollBehaviorX = scroller.scrollBehaviorX, scrollBehaviorY = scroller.scrollBehaviorY, animater = scroller.animater;
            var prevContent = scroller.content;
            // BScroll
            scroll.on(scroll.eventTypes.scrollEnd, function (position) {
                var index = _this.findNearestValidWheel(position.y).index;
                if (scroller.animater.forceStopped && !_this.isAdjustingPosition) {
                    _this.target = _this.items[index];
                    // since stopped from an animation.
                    // prevent user's scrollEnd callback triggered twice
                    return true;
                }
                else {
                    _this.setSelectedIndex(index);
                    if (_this.isAdjustingPosition) {
                        _this.isAdjustingPosition = false;
                    }
                }
            });
            // BScroll.hooks
            this.scroll.hooks.on(this.scroll.hooks.eventTypes.refresh, function (content) {
                if (content !== prevContent) {
                    prevContent = content;
                    _this.setSelectedIndex(_this.options.selectedIndex, true);
                }
                // rotate all wheel-items
                // because position may not change
                _this.rotateX(_this.scroll.y);
                // check we are stop at a disable item or not
                _this.wheelTo(_this.selectedIndex, 0);
            });
            this.scroll.hooks.on(this.scroll.hooks.eventTypes.beforeInitialScrollTo, function (position) {
                // selectedIndex has higher priority than bs.options.startY
                position.x = 0;
                position.y = -(_this.selectedIndex * _this.itemHeight);
            });
            // Scroller
            scroller.hooks.on(scroller.hooks.eventTypes.checkClick, function () {
                var index = HTMLCollectionToArray(_this.items).indexOf(_this.target);
                if (index === -1)
                    return true;
                _this.wheelTo(index, _this.options.adjustTime, ease.swipe);
                return true;
            });
            scroller.hooks.on(scroller.hooks.eventTypes.scrollTo, function (endPoint) {
                endPoint.y = _this.findNearestValidWheel(endPoint.y).y;
            });
            // when content is scrolling
            // click wheel-item DOM repeatedly and crazily will cause scrollEnd not triggered
            // so reset forceStopped
            scroller.hooks.on(scroller.hooks.eventTypes.minDistanceScroll, function () {
                var animater = scroller.animater;
                if (animater.forceStopped === true) {
                    animater.forceStopped = false;
                }
            });
            scroller.hooks.on(scroller.hooks.eventTypes.scrollToElement, function (el, pos) {
                if (!hasClass(el, _this.options.wheelItemClass)) {
                    return true;
                }
                else {
                    pos.top = _this.findNearestValidWheel(pos.top).y;
                }
            });
            // ActionsHandler
            actionsHandler.hooks.on(actionsHandler.hooks.eventTypes.beforeStart, function (e) {
                _this.target = e.target;
            });
            // ScrollBehaviorX
            // Wheel has no x direction now
            scrollBehaviorX.hooks.on(scrollBehaviorX.hooks.eventTypes.computeBoundary, function (boundary) {
                boundary.maxScrollPos = 0;
                boundary.minScrollPos = 0;
            });
            // ScrollBehaviorY
            scrollBehaviorY.hooks.on(scrollBehaviorY.hooks.eventTypes.computeBoundary, function (boundary) {
                _this.items = _this.scroll.scroller.content.children;
                _this.checkWheelAllDisabled();
                _this.itemHeight =
                    _this.items.length > 0
                        ? scrollBehaviorY.contentSize / _this.items.length
                        : 0;
                boundary.maxScrollPos = -_this.itemHeight * (_this.items.length - 1);
                boundary.minScrollPos = 0;
            });
            scrollBehaviorY.hooks.on(scrollBehaviorY.hooks.eventTypes.momentum, function (momentumInfo) {
                momentumInfo.rate = CONSTANTS.rate;
                momentumInfo.destination = _this.findNearestValidWheel(momentumInfo.destination).y;
            });
            scrollBehaviorY.hooks.on(scrollBehaviorY.hooks.eventTypes.end, function (momentumInfo) {
                var validWheel = _this.findNearestValidWheel(scrollBehaviorY.currentPos);
                momentumInfo.destination = validWheel.y;
                momentumInfo.duration = _this.options.adjustTime;
            });
            // Animater
            animater.hooks.on(animater.hooks.eventTypes.time, function (time) {
                _this.transitionDuration(time);
            });
            animater.hooks.on(animater.hooks.eventTypes.timeFunction, function (easing) {
                _this.timeFunction(easing);
            });
            // bs.stop() to make wheel stop at a correct position when pending
            animater.hooks.on(animater.hooks.eventTypes.callStop, function () {
                var index = _this.findNearestValidWheel(_this.scroll.y).index;
                _this.isAdjustingPosition = true;
                _this.wheelTo(index, 0);
            });
            // Translater
            animater.translater.hooks.on(animater.translater.hooks.eventTypes.translate, function (endPoint) {
                _this.rotateX(endPoint.y);
            });
        };
        Wheel.prototype.refreshBoundary = function () {
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY, content = _a.content;
            scrollBehaviorX.refresh(content);
            scrollBehaviorY.refresh(content);
        };
        Wheel.prototype.setSelectedIndex = function (index, contentChanged) {
            if (contentChanged === void 0) { contentChanged = false; }
            var prevSelectedIndex = this.selectedIndex;
            this.selectedIndex = index;
            // if content DOM changed, should not trigger event
            if (prevSelectedIndex !== index && !contentChanged) {
                this.scroll.trigger(WHEEL_INDEX_CHANGED_EVENT_NAME, index);
            }
        };
        Wheel.prototype.getSelectedIndex = function () {
            return this.selectedIndex;
        };
        Wheel.prototype.wheelTo = function (index, time, ease) {
            if (index === void 0) { index = 0; }
            if (time === void 0) { time = 0; }
            var y = -index * this.itemHeight;
            this.scroll.scrollTo(0, y, time, ease);
        };
        Wheel.prototype.restorePosition = function () {
            // bs is scrolling
            var isPending = this.scroll.pending;
            if (isPending) {
                var selectedIndex = this.getSelectedIndex();
                this.scroll.scroller.animater.clearTimer();
                this.wheelTo(selectedIndex, 0);
            }
        };
        Wheel.prototype.transitionDuration = function (time) {
            for (var i = 0; i < this.items.length; i++) {
                this.items[i].style[style.transitionDuration] =
                    time + 'ms';
            }
        };
        Wheel.prototype.timeFunction = function (easing) {
            for (var i = 0; i < this.items.length; i++) {
                this.items[i].style[style.transitionTimingFunction] = easing;
            }
        };
        Wheel.prototype.rotateX = function (y) {
            var _a = this.options.rotate, rotate = _a === void 0 ? 25 : _a;
            for (var i = 0; i < this.items.length; i++) {
                var deg = rotate * (y / this.itemHeight + i);
                // Too small value is invalid in some phones, issue 1026
                var SafeDeg = deg.toFixed(3);
                this.items[i].style[style.transform] = "rotateX(" + SafeDeg + "deg)";
            }
        };
        Wheel.prototype.findNearestValidWheel = function (y) {
            y = y > 0 ? 0 : y < this.scroll.maxScrollY ? this.scroll.maxScrollY : y;
            var currentIndex = Math.abs(Math.round(-y / this.itemHeight));
            var cacheIndex = currentIndex;
            var items = this.items;
            var wheelDisabledItemClassName = this.options
                .wheelDisabledItemClass;
            // implement web native select element
            // first, check whether there is a enable item whose index is smaller than currentIndex
            // then, check whether there is a enable item whose index is bigger than currentIndex
            // otherwise, there are all disabled items, just keep currentIndex unchange
            while (currentIndex >= 0) {
                if (!hasClass(items[currentIndex], wheelDisabledItemClassName)) {
                    break;
                }
                currentIndex--;
            }
            if (currentIndex < 0) {
                currentIndex = cacheIndex;
                while (currentIndex <= items.length - 1) {
                    if (!hasClass(items[currentIndex], wheelDisabledItemClassName)) {
                        break;
                    }
                    currentIndex++;
                }
            }
            // keep it unchange when all the items are disabled
            if (currentIndex === items.length) {
                currentIndex = cacheIndex;
            }
            // when all the items are disabled, selectedIndex should always be -1
            return {
                index: this.wheelItemsAllDisabled ? -1 : currentIndex,
                y: -currentIndex * this.itemHeight
            };
        };
        Wheel.prototype.checkWheelAllDisabled = function () {
            var wheelDisabledItemClassName = this.options.wheelDisabledItemClass;
            var items = this.items;
            this.wheelItemsAllDisabled = true;
            for (var i = 0; i < items.length; i++) {
                if (!hasClass(items[i], wheelDisabledItemClassName)) {
                    this.wheelItemsAllDisabled = false;
                    break;
                }
            }
        };
        Wheel.pluginName = 'wheel';
        return Wheel;
    }());

    var sourcePrefix$2 = 'plugins.zoom';
    var propertiesMap$2 = [
        {
            key: 'zoomTo',
            name: 'zoomTo'
        }
    ];
    var propertiesConfig$2 = propertiesMap$2.map(function (item) {
        return {
            key: item.key,
            sourceKey: sourcePrefix$2 + "." + item.name
        };
    });

    var TWO_FINGERS = 2;
    var RAW_SCALE = 1;
    var Zoom = /** @class */ (function () {
        function Zoom(scroll) {
            this.scroll = scroll;
            this.scale = RAW_SCALE;
            this.prevScale = 1;
            this.init();
        }
        Zoom.prototype.init = function () {
            this.handleBScroll();
            this.handleOptions();
            this.handleHooks();
            this.tryInitialZoomTo(this.zoomOpt);
        };
        Zoom.prototype.zoomTo = function (scale, x, y, bounceTime) {
            var _a = this.resolveOrigin(x, y), originX = _a.originX, originY = _a.originY;
            var origin = {
                x: originX,
                y: originY,
                baseScale: this.scale,
            };
            this._doZoomTo(scale, origin, bounceTime, true);
        };
        Zoom.prototype.handleBScroll = function () {
            this.scroll.proxy(propertiesConfig$2);
            this.scroll.registerType([
                'beforeZoomStart',
                'zoomStart',
                'zooming',
                'zoomEnd',
            ]);
        };
        Zoom.prototype.handleOptions = function () {
            var userOptions = (this.scroll.options.zoom === true
                ? {}
                : this.scroll.options.zoom);
            var defaultOptions = {
                start: 1,
                min: 1,
                max: 4,
                initialOrigin: [0, 0],
                minimalZoomDistance: 5,
                bounceTime: 800,
            };
            this.zoomOpt = extend(defaultOptions, userOptions);
        };
        Zoom.prototype.handleHooks = function () {
            var _this = this;
            var scroll = this.scroll;
            var scroller = this.scroll.scroller;
            this.wrapper = this.scroll.scroller.wrapper;
            this.setTransformOrigin(this.scroll.scroller.content);
            var scrollBehaviorX = scroller.scrollBehaviorX;
            var scrollBehaviorY = scroller.scrollBehaviorY;
            this.hooksFn = [];
            // BScroll
            this.registerHooks(scroll.hooks, scroll.hooks.eventTypes.contentChanged, function (content) {
                _this.setTransformOrigin(content);
                _this.scale = RAW_SCALE;
                _this.tryInitialZoomTo(_this.zoomOpt);
            });
            this.registerHooks(scroll.hooks, scroll.hooks.eventTypes.beforeInitialScrollTo, function () {
                // if perform a zoom action, we should prevent initial scroll when initialised
                if (_this.zoomOpt.start !== RAW_SCALE) {
                    return true;
                }
            });
            // enlarge boundary
            this.registerHooks(scrollBehaviorX.hooks, scrollBehaviorX.hooks.eventTypes.beforeComputeBoundary, function () {
                // content may change, don't cache it's size
                var contentSize = getRect(_this.scroll.scroller.content);
                scrollBehaviorX.contentSize = Math.floor(contentSize.width * _this.scale);
            });
            this.registerHooks(scrollBehaviorY.hooks, scrollBehaviorY.hooks.eventTypes.beforeComputeBoundary, function () {
                // content may change, don't cache it's size
                var contentSize = getRect(_this.scroll.scroller.content);
                scrollBehaviorY.contentSize = Math.floor(contentSize.height * _this.scale);
            });
            // touch event
            this.registerHooks(scroller.actions.hooks, scroller.actions.hooks.eventTypes.start, function (e) {
                var numberOfFingers = (e.touches && e.touches.length) || 0;
                _this.fingersOperation(numberOfFingers);
                if (numberOfFingers === TWO_FINGERS) {
                    _this.zoomStart(e);
                }
            });
            this.registerHooks(scroller.actions.hooks, scroller.actions.hooks.eventTypes.beforeMove, function (e) {
                var numberOfFingers = (e.touches && e.touches.length) || 0;
                _this.fingersOperation(numberOfFingers);
                if (numberOfFingers === TWO_FINGERS) {
                    _this.zoom(e);
                    return true;
                }
            });
            this.registerHooks(scroller.actions.hooks, scroller.actions.hooks.eventTypes.beforeEnd, function (e) {
                var numberOfFingers = _this.fingersOperation();
                if (numberOfFingers === TWO_FINGERS) {
                    _this.zoomEnd();
                    return true;
                }
            });
            this.registerHooks(scroller.translater.hooks, scroller.translater.hooks.eventTypes.beforeTranslate, function (transformStyle, point) {
                var scale = point.scale ? point.scale : _this.prevScale;
                _this.prevScale = scale;
                transformStyle.push("scale(" + scale + ")");
            });
            this.registerHooks(scroller.hooks, scroller.hooks.eventTypes.scrollEnd, function () {
                if (_this.fingersOperation() === TWO_FINGERS) {
                    _this.scroll.trigger(_this.scroll.eventTypes.zoomEnd, {
                        scale: _this.scale,
                    });
                }
            });
            this.registerHooks(this.scroll.hooks, 'destroy', this.destroy);
        };
        Zoom.prototype.setTransformOrigin = function (content) {
            content.style[style.transformOrigin] = '0 0';
        };
        Zoom.prototype.tryInitialZoomTo = function (options) {
            var start = options.start, initialOrigin = options.initialOrigin;
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
            if (start !== RAW_SCALE) {
                // Movable plugin may wanna modify minScrollPos or maxScrollPos
                // so we force Movable to caculate them
                this.resetBoundaries([scrollBehaviorX, scrollBehaviorY]);
                this.zoomTo(start, initialOrigin[0], initialOrigin[1], 0);
            }
        };
        // getter or setter operation
        Zoom.prototype.fingersOperation = function (amounts) {
            if (typeof amounts === 'number') {
                this.numberOfFingers = amounts;
            }
            else {
                return this.numberOfFingers;
            }
        };
        Zoom.prototype._doZoomTo = function (scale, origin, time, useCurrentPos) {
            var _this = this;
            if (time === void 0) { time = this.zoomOpt.bounceTime; }
            if (useCurrentPos === void 0) { useCurrentPos = false; }
            var _a = this.zoomOpt, min = _a.min, max = _a.max;
            var fromScale = this.scale;
            var toScale = between(scale, min, max);
            (function () {
                if (time === 0) {
                    _this.scroll.trigger(_this.scroll.eventTypes.zooming, {
                        scale: toScale,
                    });
                    return;
                }
                if (time > 0) {
                    var timer_1;
                    var startTime_1 = getNow();
                    var endTime_1 = startTime_1 + time;
                    var scheduler_1 = function () {
                        var now = getNow();
                        if (now >= endTime_1) {
                            _this.scroll.trigger(_this.scroll.eventTypes.zooming, {
                                scale: toScale,
                            });
                            cancelAnimationFrame(timer_1);
                            return;
                        }
                        var ratio = ease.bounce.fn((now - startTime_1) / time);
                        var currentScale = ratio * (toScale - fromScale) + fromScale;
                        _this.scroll.trigger(_this.scroll.eventTypes.zooming, {
                            scale: currentScale,
                        });
                        timer_1 = requestAnimationFrame(scheduler_1);
                    };
                    // start scheduler job
                    scheduler_1();
                }
            })();
            // suppose you are zooming by two fingers
            this.fingersOperation(2);
            this._zoomTo(toScale, fromScale, origin, time, useCurrentPos);
        };
        Zoom.prototype._zoomTo = function (toScale, fromScale, origin, time, useCurrentPos) {
            if (useCurrentPos === void 0) { useCurrentPos = false; }
            var ratio = toScale / origin.baseScale;
            this.setScale(toScale);
            var scroller = this.scroll.scroller;
            var scrollBehaviorX = scroller.scrollBehaviorX, scrollBehaviorY = scroller.scrollBehaviorY;
            this.resetBoundaries([scrollBehaviorX, scrollBehaviorY]);
            // position is restrained in boundary
            var newX = this.getNewPos(origin.x, ratio, scrollBehaviorX, true, useCurrentPos);
            var newY = this.getNewPos(origin.y, ratio, scrollBehaviorY, true, useCurrentPos);
            if (scrollBehaviorX.currentPos !== Math.round(newX) ||
                scrollBehaviorY.currentPos !== Math.round(newY) ||
                toScale !== fromScale) {
                scroller.scrollTo(newX, newY, time, ease.bounce, {
                    start: {
                        scale: fromScale,
                    },
                    end: {
                        scale: toScale,
                    },
                });
            }
        };
        Zoom.prototype.resolveOrigin = function (x, y) {
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
            var resolveFormula = {
                left: function () {
                    return 0;
                },
                top: function () {
                    return 0;
                },
                right: function () {
                    return scrollBehaviorX.contentSize;
                },
                bottom: function () {
                    return scrollBehaviorY.contentSize;
                },
                center: function (index) {
                    var baseSize = index === 0
                        ? scrollBehaviorX.contentSize
                        : scrollBehaviorY.contentSize;
                    return baseSize / 2;
                },
            };
            return {
                originX: typeof x === 'number' ? x : resolveFormula[x](0),
                originY: typeof y === 'number' ? y : resolveFormula[y](1),
            };
        };
        Zoom.prototype.zoomStart = function (e) {
            var firstFinger = e.touches[0];
            var secondFinger = e.touches[1];
            this.startDistance = this.getFingerDistance(e);
            this.startScale = this.scale;
            var _a = offsetToBody(this.wrapper), left = _a.left, top = _a.top;
            this.origin = {
                x: Math.abs(firstFinger.pageX + secondFinger.pageX) / 2 +
                    left -
                    this.scroll.x,
                y: Math.abs(firstFinger.pageY + secondFinger.pageY) / 2 +
                    top -
                    this.scroll.y,
                baseScale: this.startScale,
            };
            this.scroll.trigger(this.scroll.eventTypes.beforeZoomStart);
        };
        Zoom.prototype.zoom = function (e) {
            var currentDistance = this.getFingerDistance(e);
            // at least minimalZoomDistance pixels for the zoom to initiate
            if (!this.zoomed &&
                Math.abs(currentDistance - this.startDistance) <
                    this.zoomOpt.minimalZoomDistance) {
                return;
            }
            // when out of boundary , perform a damping algorithm
            var endScale = this.dampingScale((currentDistance / this.startDistance) * this.startScale);
            var ratio = endScale / this.startScale;
            this.setScale(endScale);
            if (!this.zoomed) {
                this.zoomed = true;
                this.scroll.trigger(this.scroll.eventTypes.zoomStart);
            }
            var scroller = this.scroll.scroller;
            var scrollBehaviorX = scroller.scrollBehaviorX, scrollBehaviorY = scroller.scrollBehaviorY;
            var x = this.getNewPos(this.origin.x, ratio, scrollBehaviorX, false, false);
            var y = this.getNewPos(this.origin.y, ratio, scrollBehaviorY, false, false);
            this.scroll.trigger(this.scroll.eventTypes.zooming, {
                scale: this.scale,
            });
            scroller.translater.translate({ x: x, y: y, scale: endScale });
        };
        Zoom.prototype.zoomEnd = function () {
            if (!this.zoomed)
                return;
            // if out of boundary, do rebound!
            if (this.shouldRebound()) {
                this._doZoomTo(this.scale, this.origin, this.zoomOpt.bounceTime);
                return;
            }
            this.scroll.trigger(this.scroll.eventTypes.zoomEnd, { scale: this.scale });
        };
        Zoom.prototype.getFingerDistance = function (e) {
            var firstFinger = e.touches[0];
            var secondFinger = e.touches[1];
            var deltaX = Math.abs(firstFinger.pageX - secondFinger.pageX);
            var deltaY = Math.abs(firstFinger.pageY - secondFinger.pageY);
            return getDistance(deltaX, deltaY);
        };
        Zoom.prototype.shouldRebound = function () {
            var _a = this.zoomOpt, min = _a.min, max = _a.max;
            var currentScale = this.scale;
            // scale exceeded!
            if (currentScale !== between(currentScale, min, max)) {
                return true;
            }
            var _b = this.scroll.scroller, scrollBehaviorX = _b.scrollBehaviorX, scrollBehaviorY = _b.scrollBehaviorY;
            // enlarge boundaries manually when zoom is end
            this.resetBoundaries([scrollBehaviorX, scrollBehaviorY]);
            var xInBoundary = scrollBehaviorX.checkInBoundary().inBoundary;
            var yInBoundary = scrollBehaviorX.checkInBoundary().inBoundary;
            return !(xInBoundary && yInBoundary);
        };
        Zoom.prototype.dampingScale = function (scale) {
            var _a = this.zoomOpt, min = _a.min, max = _a.max;
            if (scale < min) {
                scale = 0.5 * min * Math.pow(2.0, scale / min);
            }
            else if (scale > max) {
                scale = 2.0 * max * Math.pow(0.5, max / scale);
            }
            return scale;
        };
        Zoom.prototype.setScale = function (scale) {
            this.scale = scale;
        };
        Zoom.prototype.resetBoundaries = function (scrollBehaviorPairs) {
            scrollBehaviorPairs.forEach(function (behavior) { return behavior.computeBoundary(); });
        };
        Zoom.prototype.getNewPos = function (origin, lastScale, scrollBehavior, shouldInBoundary, useCurrentPos) {
            if (useCurrentPos === void 0) { useCurrentPos = false; }
            var newPos = origin -
                origin * lastScale +
                (useCurrentPos ? scrollBehavior.currentPos : scrollBehavior.startPos);
            if (shouldInBoundary) {
                newPos = between(newPos, scrollBehavior.maxScrollPos, scrollBehavior.minScrollPos);
            }
            // maxScrollPos or minScrollPos maybe a negative or positive digital
            return newPos > 0 ? Math.floor(newPos) : Math.ceil(newPos);
        };
        Zoom.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        Zoom.prototype.destroy = function () {
            this.hooksFn.forEach(function (item) {
                var hooks = item[0];
                var hooksName = item[1];
                var handlerFn = item[2];
                hooks.off(hooksName, handlerFn);
            });
            this.hooksFn.length = 0;
        };
        Zoom.pluginName = 'zoom';
        return Zoom;
    }());

    var BScrollFamily = /** @class */ (function () {
        function BScrollFamily(scroll) {
            this.ancestors = [];
            this.descendants = [];
            this.hooksManager = [];
            this.analyzed = false;
            this.selfScroll = scroll;
        }
        BScrollFamily.create = function (scroll) {
            return new BScrollFamily(scroll);
        };
        BScrollFamily.prototype.hasAncestors = function (bscrollFamily) {
            var index = findIndex(this.ancestors, function (_a) {
                var item = _a[0];
                return item === bscrollFamily;
            });
            return index > -1;
        };
        BScrollFamily.prototype.hasDescendants = function (bscrollFamily) {
            var index = findIndex(this.descendants, function (_a) {
                var item = _a[0];
                return item === bscrollFamily;
            });
            return index > -1;
        };
        BScrollFamily.prototype.addAncestor = function (bscrollFamily, distance) {
            var ancestors = this.ancestors;
            ancestors.push([bscrollFamily, distance]);
            // by ascend
            ancestors.sort(function (a, b) {
                return a[1] - b[1];
            });
        };
        BScrollFamily.prototype.addDescendant = function (bscrollFamily, distance) {
            var descendants = this.descendants;
            descendants.push([bscrollFamily, distance]);
            // by ascend
            descendants.sort(function (a, b) {
                return a[1] - b[1];
            });
        };
        BScrollFamily.prototype.removeAncestor = function (bscrollFamily) {
            var ancestors = this.ancestors;
            if (ancestors.length) {
                var index = findIndex(this.ancestors, function (_a) {
                    var item = _a[0];
                    return item === bscrollFamily;
                });
                if (index > -1) {
                    return ancestors.splice(index, 1);
                }
            }
        };
        BScrollFamily.prototype.removeDescendant = function (bscrollFamily) {
            var descendants = this.descendants;
            if (descendants.length) {
                var index = findIndex(this.descendants, function (_a) {
                    var item = _a[0];
                    return item === bscrollFamily;
                });
                if (index > -1) {
                    return descendants.splice(index, 1);
                }
            }
        };
        BScrollFamily.prototype.registerHooks = function (hook, eventType, handler) {
            hook.on(eventType, handler);
            this.hooksManager.push([hook, eventType, handler]);
        };
        BScrollFamily.prototype.setAnalyzed = function (flag) {
            if (flag === void 0) { flag = false; }
            this.analyzed = flag;
        };
        BScrollFamily.prototype.purge = function () {
            var _this = this;
            // remove self from graph
            this.ancestors.forEach(function (_a) {
                var bscrollFamily = _a[0];
                bscrollFamily.removeDescendant(_this);
            });
            this.descendants.forEach(function (_a) {
                var bscrollFamily = _a[0];
                bscrollFamily.removeAncestor(_this);
            });
            // remove all hook handlers
            this.hooksManager.forEach(function (_a) {
                var hooks = _a[0], eventType = _a[1], handler = _a[2];
                hooks.off(eventType, handler);
            });
            this.hooksManager = [];
        };
        return BScrollFamily;
    }());

    var sourcePrefix$1 = 'plugins.nestedScroll';
    var propertiesMap$1 = [
        {
            key: 'purgeNestedScroll',
            name: 'purgeNestedScroll',
        },
    ];
    var propertiesConfig$1 = propertiesMap$1.map(function (item) {
        return {
            key: item.key,
            sourceKey: sourcePrefix$1 + "." + item.name,
        };
    });

    var DEFAUL_GROUP_ID = 'INTERNAL_NESTED_SCROLL';
    var forceScrollStopHandler = function (scrolls) {
        scrolls.forEach(function (scroll) {
            if (scroll.pending) {
                scroll.stop();
                scroll.resetPosition();
            }
        });
    };
    var enableScrollHander = function (scrolls) {
        scrolls.forEach(function (scroll) {
            scroll.enable();
        });
    };
    var disableScrollHander = function (scrolls, currentScroll) {
        scrolls.forEach(function (scroll) {
            if (scroll.hasHorizontalScroll === currentScroll.hasHorizontalScroll ||
                scroll.hasVerticalScroll === currentScroll.hasVerticalScroll) {
                scroll.disable();
            }
        });
    };
    var syncTouchstartData = function (scrolls) {
        scrolls.forEach(function (scroll) {
            var _a = scroll.scroller, actions = _a.actions, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
            // prevent click triggering many times
            actions.fingerMoved = true;
            actions.contentMoved = false;
            actions.directionLockAction.reset();
            scrollBehaviorX.start();
            scrollBehaviorY.start();
            scrollBehaviorX.resetStartPos();
            scrollBehaviorY.resetStartPos();
            actions.startTime = +new Date();
        });
    };
    var isOutOfBoundary = function (scroll) {
        var hasHorizontalScroll = scroll.hasHorizontalScroll, hasVerticalScroll = scroll.hasVerticalScroll, x = scroll.x, y = scroll.y, minScrollX = scroll.minScrollX, maxScrollX = scroll.maxScrollX, minScrollY = scroll.minScrollY, maxScrollY = scroll.maxScrollY, movingDirectionX = scroll.movingDirectionX, movingDirectionY = scroll.movingDirectionY;
        var ret = false;
        var outOfLeftBoundary = x >= minScrollX && movingDirectionX === -1 /* Negative */;
        var outOfRightBoundary = x <= maxScrollX && movingDirectionX === 1 /* Positive */;
        var outOfTopBoundary = y >= minScrollY && movingDirectionY === -1 /* Negative */;
        var outOfBottomBoundary = y <= maxScrollY && movingDirectionY === 1 /* Positive */;
        if (hasVerticalScroll) {
            ret = outOfTopBoundary || outOfBottomBoundary;
        }
        else if (hasHorizontalScroll) {
            ret = outOfLeftBoundary || outOfRightBoundary;
        }
        return ret;
    };
    var isResettingPosition = function (scroll) {
        var hasHorizontalScroll = scroll.hasHorizontalScroll, hasVerticalScroll = scroll.hasVerticalScroll, x = scroll.x, y = scroll.y, minScrollX = scroll.minScrollX, maxScrollX = scroll.maxScrollX, minScrollY = scroll.minScrollY, maxScrollY = scroll.maxScrollY;
        var ret = false;
        var outOfLeftBoundary = x > minScrollX;
        var outOfRightBoundary = x < maxScrollX;
        var outOfTopBoundary = y > minScrollY;
        var outOfBottomBoundary = y < maxScrollY;
        if (hasVerticalScroll) {
            ret = outOfTopBoundary || outOfBottomBoundary;
        }
        else if (hasHorizontalScroll) {
            ret = outOfLeftBoundary || outOfRightBoundary;
        }
        return ret;
    };
    var resetPositionHandler = function (scroll) {
        scroll.scroller.reflow();
        scroll.resetPosition(0 /* Immediately */);
    };
    var calculateDistance = function (childNode, parentNode) {
        var distance = 0;
        var parent = childNode.parentNode;
        while (parent && parent !== parentNode) {
            distance++;
            parent = parent.parentNode;
        }
        return distance;
    };
    var NestedScroll = /** @class */ (function () {
        function NestedScroll(scroll) {
            var groupId = this.handleOptions(scroll);
            var instance = NestedScroll.instancesMap[groupId];
            if (!instance) {
                instance = NestedScroll.instancesMap[groupId] = this;
                instance.store = [];
                instance.hooksFn = [];
            }
            instance.init(scroll);
            return instance;
        }
        NestedScroll.getAllNestedScrolls = function () {
            var instancesMap = NestedScroll.instancesMap;
            return Object.keys(instancesMap).map(function (key) { return instancesMap[key]; });
        };
        NestedScroll.purgeAllNestedScrolls = function () {
            var nestedScrolls = NestedScroll.getAllNestedScrolls();
            nestedScrolls.forEach(function (ns) { return ns.purgeNestedScroll(); });
        };
        NestedScroll.prototype.handleOptions = function (scroll) {
            var userOptions = (scroll.options.nestedScroll === true
                ? {}
                : scroll.options.nestedScroll);
            var defaultOptions = {
                groupId: DEFAUL_GROUP_ID,
            };
            this.options = extend(defaultOptions, userOptions);
            var groupIdType = typeof this.options.groupId;
            if (groupIdType !== 'string' && groupIdType !== 'number') {
                warn('groupId must be string or number for NestedScroll plugin');
            }
            return this.options.groupId;
        };
        NestedScroll.prototype.init = function (scroll) {
            scroll.proxy(propertiesConfig$1);
            this.addBScroll(scroll);
            this.buildBScrollGraph();
            this.analyzeBScrollGraph();
            this.ensureEventInvokeSequence();
            this.handleHooks(scroll);
        };
        NestedScroll.prototype.handleHooks = function (scroll) {
            var _this = this;
            this.registerHooks(scroll.hooks, scroll.hooks.eventTypes.destroy, function () {
                _this.deleteScroll(scroll);
            });
        };
        NestedScroll.prototype.deleteScroll = function (scroll) {
            var wrapper = scroll.wrapper;
            wrapper.isBScrollContainer = undefined;
            var store = this.store;
            var hooksFn = this.hooksFn;
            var i = findIndex(store, function (bscrollFamily) {
                return bscrollFamily.selfScroll === scroll;
            });
            if (i > -1) {
                var bscrollFamily = store[i];
                bscrollFamily.purge();
                store.splice(i, 1);
            }
            var k = findIndex(hooksFn, function (_a) {
                var hooks = _a[0];
                return hooks === scroll.hooks;
            });
            if (k > -1) {
                var _a = hooksFn[k], hooks = _a[0], eventType = _a[1], handler = _a[2];
                hooks.off(eventType, handler);
                hooksFn.splice(k, 1);
            }
        };
        NestedScroll.prototype.addBScroll = function (scroll) {
            this.store.push(BScrollFamily.create(scroll));
        };
        NestedScroll.prototype.buildBScrollGraph = function () {
            var store = this.store;
            var bf1;
            var bf2;
            var wrapper1;
            var wrapper2;
            var len = this.store.length;
            // build graph
            for (var i = 0; i < len; i++) {
                bf1 = store[i];
                wrapper1 = bf1.selfScroll.wrapper;
                for (var j = 0; j < len; j++) {
                    bf2 = store[j];
                    wrapper2 = bf2.selfScroll.wrapper;
                    // same bs
                    if (bf1 === bf2)
                        continue;
                    if (!wrapper1.contains(wrapper2))
                        continue;
                    // bs1 contains bs2
                    var distance = calculateDistance(wrapper2, wrapper1);
                    if (!bf1.hasDescendants(bf2)) {
                        bf1.addDescendant(bf2, distance);
                    }
                    if (!bf2.hasAncestors(bf1)) {
                        bf2.addAncestor(bf1, distance);
                    }
                }
            }
        };
        NestedScroll.prototype.analyzeBScrollGraph = function () {
            this.store.forEach(function (bscrollFamily) {
                if (bscrollFamily.analyzed) {
                    return;
                }
                var ancestors = bscrollFamily.ancestors, descendants = bscrollFamily.descendants, currentScroll = bscrollFamily.selfScroll;
                var beforeScrollStartHandler = function () {
                    // always get the latest scroll
                    var ancestorScrolls = ancestors.map(function (_a) {
                        var bscrollFamily = _a[0];
                        return bscrollFamily.selfScroll;
                    });
                    var descendantScrolls = descendants.map(function (_a) {
                        var bscrollFamily = _a[0];
                        return bscrollFamily.selfScroll;
                    });
                    forceScrollStopHandler(__spreadArrays(ancestorScrolls, descendantScrolls));
                    if (isResettingPosition(currentScroll)) {
                        resetPositionHandler(currentScroll);
                    }
                    syncTouchstartData(ancestorScrolls);
                    disableScrollHander(ancestorScrolls, currentScroll);
                };
                var touchEndHandler = function () {
                    var ancestorScrolls = ancestors.map(function (_a) {
                        var bscrollFamily = _a[0];
                        return bscrollFamily.selfScroll;
                    });
                    var descendantScrolls = descendants.map(function (_a) {
                        var bscrollFamily = _a[0];
                        return bscrollFamily.selfScroll;
                    });
                    enableScrollHander(__spreadArrays(ancestorScrolls, descendantScrolls));
                };
                bscrollFamily.registerHooks(currentScroll, currentScroll.eventTypes.beforeScrollStart, beforeScrollStartHandler);
                bscrollFamily.registerHooks(currentScroll, currentScroll.eventTypes.touchEnd, touchEndHandler);
                var selfActionsHooks = currentScroll.scroller.actions.hooks;
                bscrollFamily.registerHooks(selfActionsHooks, selfActionsHooks.eventTypes.detectMovingDirection, function () {
                    var ancestorScrolls = ancestors.map(function (_a) {
                        var bscrollFamily = _a[0];
                        return bscrollFamily.selfScroll;
                    });
                    var parentScroll = ancestorScrolls[0];
                    var otherAncestorScrolls = ancestorScrolls.slice(1);
                    var contentMoved = currentScroll.scroller.actions.contentMoved;
                    var isTopScroll = ancestorScrolls.length === 0;
                    if (contentMoved) {
                        disableScrollHander(ancestorScrolls, currentScroll);
                    }
                    else if (!isTopScroll) {
                        if (isOutOfBoundary(currentScroll)) {
                            disableScrollHander([currentScroll], currentScroll);
                            if (parentScroll) {
                                enableScrollHander([parentScroll]);
                            }
                            disableScrollHander(otherAncestorScrolls, currentScroll);
                            return true;
                        }
                    }
                });
                bscrollFamily.setAnalyzed(true);
            });
        };
        // make sure touchmove|touchend invoke from child to parent
        NestedScroll.prototype.ensureEventInvokeSequence = function () {
            var copied = this.store.slice();
            var sequencedScroll = copied.sort(function (a, b) {
                return a.descendants.length - b.descendants.length;
            });
            sequencedScroll.forEach(function (bscrollFamily) {
                var scroll = bscrollFamily.selfScroll;
                scroll.scroller.actionsHandler.rebindDOMEvents();
            });
        };
        NestedScroll.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        NestedScroll.prototype.purgeNestedScroll = function () {
            var groupId = this.options.groupId;
            this.store.forEach(function (bscrollFamily) {
                bscrollFamily.purge();
            });
            this.store = [];
            this.hooksFn.forEach(function (_a) {
                var hooks = _a[0], eventType = _a[1], handler = _a[2];
                hooks.off(eventType, handler);
            });
            this.hooksFn = [];
            delete NestedScroll.instancesMap[groupId];
        };
        NestedScroll.pluginName = 'nestedScroll';
        NestedScroll.instancesMap = {};
        return NestedScroll;
    }());

    var PRE_NUM = 10;
    var POST_NUM = 30;
    var IndexCalculator = /** @class */ (function () {
        function IndexCalculator(wrapperHeight, tombstoneHeight) {
            this.wrapperHeight = wrapperHeight;
            this.tombstoneHeight = tombstoneHeight;
            this.lastDirection = 1 /* DOWN */;
            this.lastPos = 0;
        }
        IndexCalculator.prototype.calculate = function (pos, list) {
            var offset = pos - this.lastPos;
            this.lastPos = pos;
            var direction = this.getDirection(offset);
            // important! start index is much more important than end index.
            var start = this.calculateIndex(0, pos, list);
            var end = this.calculateIndex(start, pos + this.wrapperHeight, list);
            if (direction === 1 /* DOWN */) {
                start -= PRE_NUM;
                end += POST_NUM;
            }
            else {
                start -= POST_NUM;
                end += PRE_NUM;
            }
            if (start < 0) {
                start = 0;
            }
            return {
                start: start,
                end: end,
            };
        };
        IndexCalculator.prototype.getDirection = function (offset) {
            var direction;
            if (offset > 0) {
                direction = 1 /* DOWN */;
            }
            else if (offset < 0) {
                direction = 0 /* UP */;
            }
            else {
                return this.lastDirection;
            }
            this.lastDirection = direction;
            return direction;
        };
        IndexCalculator.prototype.calculateIndex = function (start, offset, list) {
            if (offset <= 0) {
                return start;
            }
            var i = start;
            var startPos = list[i] && list[i].pos !== -1 ? list[i].pos : 0;
            var lastPos = startPos;
            var tombstone = 0;
            while (i < list.length && list[i].pos < offset) {
                lastPos = list[i].pos;
                i++;
            }
            if (i === list.length) {
                tombstone = Math.floor((offset - lastPos) / this.tombstoneHeight);
            }
            i += tombstone;
            return i;
        };
        IndexCalculator.prototype.resetState = function () {
            this.lastDirection = 1 /* DOWN */;
            this.lastPos = 0;
        };
        return IndexCalculator;
    }());

    var ListItem = /** @class */ (function () {
        function ListItem() {
            this.data = null;
            this.dom = null;
            this.tombstone = null;
            this.width = 0;
            this.height = 0;
            this.pos = 0;
        }
        return ListItem;
    }());
    var DataManager = /** @class */ (function () {
        function DataManager(list, fetchFn, onFetchFinish) {
            this.fetchFn = fetchFn;
            this.onFetchFinish = onFetchFinish;
            this.loadedNum = 0;
            this.fetching = false;
            this.hasMore = true;
            this.list = list || [];
        }
        DataManager.prototype.update = function (end) {
            return __awaiter(this, void 0, void 0, function () {
                var len;
                return __generator(this, function (_a) {
                    if (!this.hasMore) {
                        end = Math.min(end, this.list.length);
                    }
                    // add data placeholder
                    if (end > this.list.length) {
                        len = end - this.list.length;
                        this.addEmptyData(len);
                    }
                    // tslint:disable-next-line: no-floating-promises
                    return [2 /*return*/, this.checkToFetch(end)];
                });
            });
        };
        DataManager.prototype.add = function (data) {
            for (var i = 0; i < data.length; i++) {
                if (!this.list[this.loadedNum]) {
                    this.list[this.loadedNum] = { data: data[i] };
                }
                else {
                    this.list[this.loadedNum] = __assign(__assign({}, this.list[this.loadedNum]), { data: data[i] });
                }
                this.loadedNum++;
            }
            return this.list;
        };
        DataManager.prototype.addEmptyData = function (len) {
            for (var i = 0; i < len; i++) {
                this.list.push(new ListItem());
            }
            return this.list;
        };
        DataManager.prototype.fetch = function (len) {
            return __awaiter(this, void 0, void 0, function () {
                var data;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            if (this.fetching) {
                                return [2 /*return*/, []];
                            }
                            this.fetching = true;
                            return [4 /*yield*/, this.fetchFn(len)];
                        case 1:
                            data = _a.sent();
                            this.fetching = false;
                            return [2 /*return*/, data];
                    }
                });
            });
        };
        DataManager.prototype.checkToFetch = function (end) {
            return __awaiter(this, void 0, void 0, function () {
                var min, newData, currentEnd;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            if (!this.hasMore) {
                                return [2 /*return*/];
                            }
                            if (end <= this.loadedNum) {
                                return [2 /*return*/];
                            }
                            min = end - this.loadedNum;
                            return [4 /*yield*/, this.fetch(min)];
                        case 1:
                            newData = _a.sent();
                            if (newData instanceof Array && newData.length) {
                                this.add(newData);
                                currentEnd = this.onFetchFinish(this.list, true);
                                return [2 /*return*/, this.checkToFetch(currentEnd)];
                            }
                            else if (typeof newData === 'boolean' && newData === false) {
                                this.hasMore = false;
                                this.list.splice(this.loadedNum);
                                this.onFetchFinish(this.list, false);
                            }
                            return [2 /*return*/];
                    }
                });
            });
        };
        DataManager.prototype.getList = function () {
            return this.list;
        };
        DataManager.prototype.resetState = function () {
            this.loadedNum = 0;
            this.fetching = false;
            this.hasMore = true;
            this.list = [];
        };
        return DataManager;
    }());

    var Tombstone = /** @class */ (function () {
        function Tombstone(create) {
            this.create = create;
            this.cached = [];
            this.width = 0;
            this.height = 0;
            this.initialed = false;
            this.getSize();
        }
        Tombstone.isTombstone = function (el) {
            if (el && el.classList) {
                return el.classList.contains('tombstone');
            }
            return false;
        };
        Tombstone.prototype.getSize = function () {
            if (!this.initialed) {
                var tombstone = this.create();
                tombstone.style.position = 'absolute';
                document.body.appendChild(tombstone);
                tombstone.style.display = '';
                this.height = tombstone.offsetHeight;
                this.width = tombstone.offsetWidth;
                document.body.removeChild(tombstone);
                this.cached.push(tombstone);
            }
        };
        Tombstone.prototype.getOne = function () {
            var tombstone = this.cached.pop();
            if (tombstone) {
                var tombstoneStyle = tombstone.style;
                tombstoneStyle.display = '';
                tombstoneStyle.opacity = '1';
                tombstoneStyle[style.transform] = '';
                tombstoneStyle[style.transition] = '';
                return tombstone;
            }
            return this.create();
        };
        Tombstone.prototype.recycle = function (tombstones) {
            for (var _i = 0, tombstones_1 = tombstones; _i < tombstones_1.length; _i++) {
                var tombstone = tombstones_1[_i];
                tombstone.style.display = 'none';
                this.cached.push(tombstone);
            }
            return this.cached;
        };
        Tombstone.prototype.recycleOne = function (tombstone) {
            this.cached.push(tombstone);
            return this.cached;
        };
        return Tombstone;
    }());

    var ANIMATION_DURATION_MS = 200;
    var DomManager = /** @class */ (function () {
        function DomManager(content, renderFn, tombstone) {
            this.renderFn = renderFn;
            this.tombstone = tombstone;
            this.unusedDom = [];
            this.timers = [];
            this.setContent(content);
        }
        DomManager.prototype.update = function (list, start, end) {
            if (start >= list.length) {
                start = list.length - 1;
            }
            if (end > list.length) {
                end = list.length;
            }
            this.collectUnusedDom(list, start, end);
            this.createDom(list, start, end);
            this.cacheHeight(list, start, end);
            var _a = this.positionDom(list, start, end), startPos = _a.startPos, startDelta = _a.startDelta, endPos = _a.endPos;
            return {
                start: start,
                startPos: startPos,
                startDelta: startDelta,
                end: end,
                endPos: endPos,
            };
        };
        DomManager.prototype.collectUnusedDom = function (list, start, end) {
            // TODO optimise
            for (var i = 0; i < list.length; i++) {
                if (i === start) {
                    i = end - 1;
                    continue;
                }
                if (list[i].dom) {
                    var dom = list[i].dom;
                    if (Tombstone.isTombstone(dom)) {
                        this.tombstone.recycleOne(dom);
                        dom.style.display = 'none';
                    }
                    else {
                        this.unusedDom.push(dom);
                    }
                    list[i].dom = null;
                }
            }
            return list;
        };
        DomManager.prototype.createDom = function (list, start, end) {
            for (var i = start; i < end; i++) {
                var dom = list[i].dom;
                var data = list[i].data;
                if (dom) {
                    if (Tombstone.isTombstone(dom) && data) {
                        list[i].tombstone = dom;
                        list[i].dom = null;
                    }
                    else {
                        continue;
                    }
                }
                dom = data
                    ? this.renderFn(data, this.unusedDom.pop())
                    : this.tombstone.getOne();
                dom.style.position = 'absolute';
                list[i].dom = dom;
                list[i].pos = -1;
                this.content.appendChild(dom);
            }
        };
        DomManager.prototype.cacheHeight = function (list, start, end) {
            for (var i = start; i < end; i++) {
                if (list[i].data && !list[i].height) {
                    list[i].height = list[i].dom.offsetHeight;
                }
            }
        };
        DomManager.prototype.positionDom = function (list, start, end) {
            var _this = this;
            var tombstoneEles = [];
            var _a = this.getStartPos(list, start, end), startPos = _a.start, startDelta = _a.delta;
            var pos = startPos;
            for (var i = start; i < end; i++) {
                var tombstone = list[i].tombstone;
                if (tombstone) {
                    var tombstoneStyle = tombstone.style;
                    tombstoneStyle[style.transition] = cssVendor + "transform " + ANIMATION_DURATION_MS + "ms, opacity " + ANIMATION_DURATION_MS + "ms";
                    tombstoneStyle[style.transform] = "translateY(" + pos + "px)";
                    tombstoneStyle.opacity = '0';
                    list[i].tombstone = null;
                    tombstoneEles.push(tombstone);
                }
                if (list[i].dom && list[i].pos !== pos) {
                    list[i].dom.style[style.transform] = "translateY(" + pos + "px)";
                    list[i].pos = pos;
                }
                pos += list[i].height || this.tombstone.height;
            }
            var timerId = window.setTimeout(function () {
                _this.tombstone.recycle(tombstoneEles);
            }, ANIMATION_DURATION_MS);
            this.timers.push(timerId);
            return {
                startPos: startPos,
                startDelta: startDelta,
                endPos: pos,
            };
        };
        DomManager.prototype.getStartPos = function (list, start, end) {
            if (list[start] && list[start].pos !== -1) {
                return {
                    start: list[start].pos,
                    delta: 0,
                };
            }
            // TODO optimise
            var pos = list[0].pos === -1 ? 0 : list[0].pos;
            for (var i_1 = 0; i_1 < start; i_1++) {
                pos += list[i_1].height || this.tombstone.height;
            }
            var originPos = pos;
            var i;
            for (i = start; i < end; i++) {
                if (!Tombstone.isTombstone(list[i].dom) && list[i].pos !== -1) {
                    pos = list[i].pos;
                    break;
                }
            }
            var x = i;
            if (x < end) {
                while (x > start) {
                    pos -= list[x - 1].height;
                    x--;
                }
            }
            var delta = originPos - pos;
            return {
                start: pos,
                delta: delta,
            };
        };
        DomManager.prototype.removeTombstone = function () {
            var tombstones = this.content.querySelectorAll('.tombstone');
            for (var i = tombstones.length - 1; i >= 0; i--) {
                this.content.removeChild(tombstones[i]);
            }
        };
        DomManager.prototype.setContent = function (content) {
            if (content !== this.content) {
                this.content = content;
            }
        };
        DomManager.prototype.destroy = function () {
            this.removeTombstone();
            this.timers.forEach(function (id) {
                clearTimeout(id);
            });
        };
        DomManager.prototype.resetState = function () {
            this.destroy();
            this.timers = [];
            this.unusedDom = [];
        };
        return DomManager;
    }());

    var EXTRA_SCROLL_Y = -2000;
    var InfinityScroll = /** @class */ (function () {
        function InfinityScroll(scroll) {
            this.scroll = scroll;
            this.start = 0;
            this.end = 0;
            this.init();
        }
        InfinityScroll.prototype.init = function () {
            var _this = this;
            this.handleOptions();
            var _a = this.options, fetchFn = _a.fetch, renderFn = _a.render, createTombstoneFn = _a.createTombstone;
            this.tombstone = new Tombstone(createTombstoneFn);
            this.indexCalculator = new IndexCalculator(this.scroll.scroller.scrollBehaviorY.wrapperSize, this.tombstone.height);
            this.domManager = new DomManager(this.scroll.scroller.content, renderFn, this.tombstone);
            this.dataManager = new DataManager([], fetchFn, this.onFetchFinish.bind(this));
            this.scroll.on(this.scroll.eventTypes.destroy, this.destroy, this);
            this.scroll.on(this.scroll.eventTypes.scroll, this.update, this);
            this.scroll.on(this.scroll.eventTypes.contentChanged, function (content) {
                _this.domManager.setContent(content);
                _this.indexCalculator.resetState();
                _this.domManager.resetState();
                _this.dataManager.resetState();
                _this.update({ y: 0 });
            });
            var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
            scrollBehaviorY.hooks.on(scrollBehaviorY.hooks.eventTypes.computeBoundary, this.modifyBoundary, this);
            this.update({ y: 0 });
        };
        InfinityScroll.prototype.modifyBoundary = function (boundary) {
            // manually set position to allow scroll
            boundary.maxScrollPos = EXTRA_SCROLL_Y;
        };
        InfinityScroll.prototype.handleOptions = function () {
            // narrow down type to an object
            var infinityOptions = this.scroll.options.infinity;
            if (infinityOptions) {
                if (typeof infinityOptions.fetch !== 'function') {
                    warn('Infinity plugin need fetch Function to new data.');
                }
                if (typeof infinityOptions.render !== 'function') {
                    warn('Infinity plugin need render Function to render each item.');
                }
                if (typeof infinityOptions.render !== 'function') {
                    warn('Infinity plugin need createTombstone Function to create tombstone.');
                }
                this.options = infinityOptions;
            }
            this.scroll.options.probeType = 3 /* Realtime */;
        };
        InfinityScroll.prototype.update = function (pos) {
            var position = Math.round(-pos.y);
            // important! calculate start/end index to render
            var _a = this.indexCalculator.calculate(position, this.dataManager.getList()), start = _a.start, end = _a.end;
            this.start = start;
            this.end = end;
            // tslint:disable-next-line: no-floating-promises
            this.dataManager.update(end);
            this.updateDom(this.dataManager.getList());
        };
        InfinityScroll.prototype.onFetchFinish = function (list, hasMore) {
            var end = this.updateDom(list).end;
            if (!hasMore) {
                this.domManager.removeTombstone();
                this.scroll.scroller.animater.stop();
                this.scroll.resetPosition();
            }
            // tslint:disable-next-line: no-floating-promises
            return end;
        };
        InfinityScroll.prototype.updateDom = function (list) {
            var _a = this.domManager.update(list, this.start, this.end), end = _a.end, startPos = _a.startPos, endPos = _a.endPos, startDelta = _a.startDelta;
            if (startDelta) {
                this.scroll.minScrollY = startDelta;
            }
            if (endPos > this.scroll.maxScrollY) {
                this.scroll.maxScrollY = -(endPos - this.scroll.scroller.scrollBehaviorY.wrapperSize);
            }
            return {
                end: end,
                startPos: startPos,
                endPos: endPos,
            };
        };
        InfinityScroll.prototype.destroy = function () {
            var _a = this.scroll.scroller, content = _a.content, scrollBehaviorY = _a.scrollBehaviorY;
            while (content.firstChild) {
                content.removeChild(content.firstChild);
            }
            this.domManager.destroy();
            this.scroll.off('scroll', this.update);
            this.scroll.off('destroy', this.destroy);
            scrollBehaviorY.hooks.off(scrollBehaviorY.hooks.eventTypes.computeBoundary);
        };
        InfinityScroll.pluginName = 'infinity';
        return InfinityScroll;
    }());

    var sourcePrefix = 'plugins.movable';
    var propertiesMap = [
        {
            key: 'putAt',
            name: 'putAt',
        },
    ];
    var propertiesConfig = propertiesMap.map(function (item) {
        return {
            key: item.key,
            sourceKey: sourcePrefix + "." + item.name,
        };
    });

    var Movable = /** @class */ (function () {
        function Movable(scroll) {
            this.scroll = scroll;
            this.handleBScroll();
            this.handleHooks();
        }
        Movable.prototype.handleBScroll = function () {
            this.scroll.proxy(propertiesConfig);
        };
        Movable.prototype.handleHooks = function () {
            var _this = this;
            this.hooksFn = [];
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
            var computeBoundary = function (boundary, behavior) {
                if (boundary.maxScrollPos > 0) {
                    // content is smaller than wrapper
                    boundary.minScrollPos = behavior.wrapperSize - behavior.contentSize;
                    boundary.maxScrollPos = 0;
                }
            };
            this.registerHooks(scrollBehaviorX.hooks, scrollBehaviorX.hooks.eventTypes.ignoreHasScroll, function () { return true; });
            this.registerHooks(scrollBehaviorX.hooks, scrollBehaviorX.hooks.eventTypes.computeBoundary, function (boundary) {
                computeBoundary(boundary, scrollBehaviorX);
            });
            this.registerHooks(scrollBehaviorY.hooks, scrollBehaviorY.hooks.eventTypes.ignoreHasScroll, function () { return true; });
            this.registerHooks(scrollBehaviorY.hooks, scrollBehaviorY.hooks.eventTypes.computeBoundary, function (boundary) {
                computeBoundary(boundary, scrollBehaviorY);
            });
            this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.destroy, function () {
                _this.destroy();
            });
        };
        Movable.prototype.putAt = function (x, y, time, easing) {
            if (time === void 0) { time = this.scroll.options.bounceTime; }
            if (easing === void 0) { easing = ease.bounce; }
            var position = this.resolvePostion(x, y);
            this.scroll.scrollTo(position.x, position.y, time, easing);
        };
        Movable.prototype.resolvePostion = function (x, y) {
            var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
            var resolveFormula = {
                left: function () {
                    return 0;
                },
                top: function () {
                    return 0;
                },
                right: function () {
                    return scrollBehaviorX.minScrollPos;
                },
                bottom: function () {
                    return scrollBehaviorY.minScrollPos;
                },
                center: function (index) {
                    var baseSize = index === 0
                        ? scrollBehaviorX.minScrollPos
                        : scrollBehaviorY.minScrollPos;
                    return baseSize / 2;
                },
            };
            return {
                x: typeof x === 'number' ? x : resolveFormula[x](0),
                y: typeof y === 'number' ? y : resolveFormula[y](1),
            };
        };
        Movable.prototype.destroy = function () {
            this.hooksFn.forEach(function (item) {
                var hooks = item[0];
                var hooksName = item[1];
                var handlerFn = item[2];
                hooks.off(hooksName, handlerFn);
            });
            this.hooksFn.length = 0;
        };
        Movable.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        Movable.pluginName = 'movable';
        Movable.applyOrder = "pre" /* Pre */;
        return Movable;
    }());

    var isImageTag = function (el) {
        return el.tagName.toLowerCase() === 'img';
    };
    var ObserveImage = /** @class */ (function () {
        function ObserveImage(scroll) {
            this.scroll = scroll;
            this.refreshTimer = 0;
            this.init();
        }
        ObserveImage.prototype.init = function () {
            this.handleOptions(this.scroll.options.observeImage);
            this.bindEventsToWrapper();
        };
        ObserveImage.prototype.handleOptions = function (userOptions) {
            if (userOptions === void 0) { userOptions = {}; }
            userOptions = (userOptions === true ? {} : userOptions);
            var defaultOptions = {
                debounceTime: 100,
            };
            this.options = extend(defaultOptions, userOptions);
        };
        ObserveImage.prototype.bindEventsToWrapper = function () {
            var wrapper = this.scroll.scroller.wrapper;
            this.imageLoadEventRegister = new EventRegister(wrapper, [
                {
                    name: 'load',
                    handler: this.load.bind(this),
                    capture: true,
                },
            ]);
            this.imageErrorEventRegister = new EventRegister(wrapper, [
                {
                    name: 'error',
                    handler: this.load.bind(this),
                    capture: true,
                },
            ]);
        };
        ObserveImage.prototype.load = function (e) {
            var _this = this;
            var target = e.target;
            var debounceTime = this.options.debounceTime;
            if (target && isImageTag(target)) {
                if (debounceTime === 0) {
                    this.scroll.refresh();
                }
                else {
                    clearTimeout(this.refreshTimer);
                    this.refreshTimer = window.setTimeout(function () {
                        _this.scroll.refresh();
                    }, this.options.debounceTime);
                }
            }
        };
        ObserveImage.pluginName = 'observeImage';
        return ObserveImage;
    }());

    var resolveRatioOption = function (ratioConfig) {
        var ret = {
            ratioX: 0,
            ratioY: 0,
        };
        /* istanbul ignore if  */
        if (!ratioConfig) {
            return ret;
        }
        if (typeof ratioConfig === 'number') {
            ret.ratioX = ret.ratioY = ratioConfig;
        }
        else if (typeof ratioConfig === 'object' && ratioConfig) {
            ret.ratioX = ratioConfig.x || 0;
            ret.ratioY = ratioConfig.y || 0;
        }
        return ret;
    };
    var handleBubbleAndCancelable = function (e) {
        e.preventDefault();
        e.stopPropagation();
    };
    var Indicator = /** @class */ (function () {
        function Indicator(scroll, options) {
            this.scroll = scroll;
            this.options = options;
            this.currentPos = {
                x: 0,
                y: 0,
            };
            this.hooksFn = [];
            this.handleDOM();
            this.handleHooks();
            this.handleInteractive();
        }
        Indicator.prototype.handleDOM = function () {
            var _a = this.options, relationElement = _a.relationElement, _b = _a.relationElementHandleElementIndex, relationElementHandleElementIndex = _b === void 0 ? 0 : _b;
            this.wrapper = relationElement;
            this.indicatorEl = this.wrapper.children[relationElementHandleElementIndex];
        };
        Indicator.prototype.handleHooks = function () {
            var _this = this;
            var scroll = this.scroll;
            var scrollHooks = scroll.hooks;
            var translaterHooks = scroll.scroller.translater.hooks;
            var animaterHooks = scroll.scroller.animater.hooks;
            this.registerHooks(scrollHooks, scrollHooks.eventTypes.refresh, this.refresh);
            this.registerHooks(translaterHooks, translaterHooks.eventTypes.translate, function (pos) {
                _this.updatePosition(pos);
            });
            this.registerHooks(animaterHooks, animaterHooks.eventTypes.time, this.transitionTime);
            this.registerHooks(animaterHooks, animaterHooks.eventTypes.timeFunction, this.transitionTimingFunction);
        };
        Indicator.prototype.transitionTime = function (time) {
            if (time === void 0) { time = 0; }
            this.indicatorEl.style[style.transitionDuration] = time + 'ms';
        };
        Indicator.prototype.transitionTimingFunction = function (easing) {
            this.indicatorEl.style[style.transitionTimingFunction] = easing;
        };
        Indicator.prototype.handleInteractive = function () {
            if (this.options.interactive !== false) {
                this.registerEvents();
            }
        };
        Indicator.prototype.registerHooks = function (hooks, name, handler) {
            hooks.on(name, handler, this);
            this.hooksFn.push([hooks, name, handler]);
        };
        Indicator.prototype.registerEvents = function () {
            var _a = this.scroll.options, disableMouse = _a.disableMouse, disableTouch = _a.disableTouch;
            var startEvents = [];
            var moveEvents = [];
            var endEvents = [];
            if (!disableMouse) {
                startEvents.push({
                    name: 'mousedown',
                    handler: this.start.bind(this),
                });
                moveEvents.push({
                    name: 'mousemove',
                    handler: this.move.bind(this),
                });
                endEvents.push({
                    name: 'mouseup',
                    handler: this.end.bind(this),
                });
            }
            if (!disableTouch) {
                startEvents.push({
                    name: 'touchstart',
                    handler: this.start.bind(this),
                });
                moveEvents.push({
                    name: 'touchmove',
                    handler: this.move.bind(this),
                });
                endEvents.push({
                    name: 'touchend',
                    handler: this.end.bind(this),
                }, {
                    name: 'touchcancel',
                    handler: this.end.bind(this),
                });
            }
            this.startEventRegister = new EventRegister(this.indicatorEl, startEvents);
            this.moveEventRegister = new EventRegister(window, moveEvents);
            this.endEventRegister = new EventRegister(window, endEvents);
        };
        Indicator.prototype.refresh = function () {
            var _a = this.scroll, x = _a.x, y = _a.y, hasHorizontalScroll = _a.hasHorizontalScroll, hasVerticalScroll = _a.hasVerticalScroll, maxBScrollX = _a.maxScrollX, maxBScrollY = _a.maxScrollY;
            var _b = resolveRatioOption(this.options.ratio), ratioX = _b.ratioX, ratioY = _b.ratioY;
            var _c = getClientSize(this.wrapper), wrapperWidth = _c.width, wrapperHeight = _c.height;
            var _d = getRect(this.indicatorEl), indicatorWidth = _d.width, indicatorHeight = _d.height;
            if (hasHorizontalScroll) {
                this.maxScrollX = wrapperWidth - indicatorWidth;
                this.translateXSign =
                    this.maxScrollX > 0 ? -1 /* Positive */ : 1 /* NotPositive */;
                this.minScrollX = 0;
                // ensure positive
                this.ratioX = ratioX ? ratioX : Math.abs(this.maxScrollX / maxBScrollX);
            }
            if (hasVerticalScroll) {
                this.maxScrollY = wrapperHeight - indicatorHeight;
                this.translateYSign =
                    this.maxScrollY > 0 ? -1 /* Positive */ : 1 /* NotPositive */;
                this.minScrollY = 0;
                this.ratioY = ratioY ? ratioY : Math.abs(this.maxScrollY / maxBScrollY);
            }
            this.updatePosition({
                x: x,
                y: y,
            });
        };
        Indicator.prototype.start = function (e) {
            if (this.BScrollIsDisabled()) {
                return;
            }
            var point = (e.touches ? e.touches[0] : e);
            handleBubbleAndCancelable(e);
            this.initiated = true;
            this.moved = false;
            this.lastPointX = point.pageX;
            this.lastPointY = point.pageY;
            this.startTime = getNow();
            this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.beforeScrollStart);
        };
        Indicator.prototype.BScrollIsDisabled = function () {
            return !this.scroll.enabled;
        };
        Indicator.prototype.move = function (e) {
            if (!this.initiated) {
                return;
            }
            var point = (e.touches ? e.touches[0] : e);
            var pointX = point.pageX;
            var pointY = point.pageY;
            handleBubbleAndCancelable(e);
            var deltaX = pointX - this.lastPointX;
            var deltaY = pointY - this.lastPointY;
            this.lastPointX = pointX;
            this.lastPointY = pointY;
            if (!this.moved && !this.indicatorNotMoved(deltaX, deltaY)) {
                this.moved = true;
                this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.scrollStart);
            }
            if (this.moved) {
                var newPos = this.getBScrollPosByRatio(this.currentPos, deltaX, deltaY);
                this.syncBScroll(newPos);
            }
        };
        Indicator.prototype.end = function (e) {
            if (!this.initiated) {
                return;
            }
            this.initiated = false;
            handleBubbleAndCancelable(e);
            if (this.moved) {
                var _a = this.scroll, x = _a.x, y = _a.y;
                this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.scrollEnd, {
                    x: x,
                    y: y,
                });
            }
        };
        Indicator.prototype.getBScrollPosByRatio = function (currentPos, deltaX, deltaY) {
            var currentX = currentPos.x, currentY = currentPos.y;
            var _a = this.scroll, hasHorizontalScroll = _a.hasHorizontalScroll, hasVerticalScroll = _a.hasVerticalScroll, BScrollMinScrollX = _a.minScrollX, BScrollMaxScrollX = _a.maxScrollX, BScrollMinScrollY = _a.minScrollY, BScrollMaxScrollY = _a.maxScrollY;
            var _b = this.scroll, x = _b.x, y = _b.y;
            if (hasHorizontalScroll) {
                var newPosX = between(currentX + deltaX, Math.min(this.minScrollX, this.maxScrollX), Math.max(this.minScrollX, this.maxScrollX));
                var roundX = Math.round((newPosX / this.ratioX) * this.translateXSign);
                x = between(roundX, BScrollMaxScrollX, BScrollMinScrollX);
            }
            if (hasVerticalScroll) {
                var newPosY = between(currentY + deltaY, Math.min(this.minScrollY, this.maxScrollY), Math.max(this.minScrollY, this.maxScrollY));
                var roundY = Math.round((newPosY / this.ratioY) * this.translateYSign);
                y = between(roundY, BScrollMaxScrollY, BScrollMinScrollY);
            }
            return { x: x, y: y };
        };
        Indicator.prototype.indicatorNotMoved = function (deltaX, deltaY) {
            var _a = this.currentPos, x = _a.x, y = _a.y;
            var xNotMoved = (x === this.minScrollX && deltaX <= 0) ||
                (x === this.maxScrollX && deltaX >= 0);
            var yNotMoved = (y === this.minScrollY && deltaY <= 0) ||
                (y === this.maxScrollY && deltaY >= 0);
            return xNotMoved && yNotMoved;
        };
        Indicator.prototype.syncBScroll = function (newPos) {
            var timestamp = getNow();
            var _a = this.scroll, options = _a.options, scroller = _a.scroller;
            var probeType = options.probeType, momentumLimitTime = options.momentumLimitTime;
            scroller.translater.translate(newPos);
            // dispatch scroll in interval time
            if (timestamp - this.startTime > momentumLimitTime) {
                this.startTime = timestamp;
                if (probeType === 1 /* Throttle */) {
                    scroller.hooks.trigger(scroller.hooks.eventTypes.scroll, newPos);
                }
            }
            // dispatch scroll all the time
            if (probeType > 1 /* Throttle */) {
                scroller.hooks.trigger(scroller.hooks.eventTypes.scroll, newPos);
            }
        };
        Indicator.prototype.updatePosition = function (BScrollPos) {
            var newIndicatorPos = this.getIndicatorPosByRatio(BScrollPos);
            this.applyTransformProperty(newIndicatorPos);
            this.currentPos = __assign({}, newIndicatorPos);
        };
        Indicator.prototype.applyTransformProperty = function (pos) {
            var translateZ = this.scroll.options.translateZ;
            var transformProperties = [
                "translateX(" + pos.x + "px)",
                "translateY(" + pos.y + "px)",
                "" + translateZ,
            ];
            this.indicatorEl.style[style.transform] = transformProperties.join(' ');
        };
        Indicator.prototype.getIndicatorPosByRatio = function (BScrollPos) {
            var x = BScrollPos.x, y = BScrollPos.y;
            var _a = this.scroll, hasHorizontalScroll = _a.hasHorizontalScroll, hasVerticalScroll = _a.hasVerticalScroll;
            var position = __assign({}, this.currentPos);
            if (hasHorizontalScroll) {
                var roundX = Math.round(this.ratioX * x * this.translateXSign);
                // maybe maxScrollX is negative
                position.x = between(roundX, Math.min(this.minScrollX, this.maxScrollX), Math.max(this.minScrollX, this.maxScrollX));
            }
            if (hasVerticalScroll) {
                var roundY = Math.round(this.ratioY * y * this.translateYSign);
                // maybe maxScrollY is negative
                position.y = between(roundY, Math.min(this.minScrollY, this.maxScrollY), Math.max(this.minScrollY, this.maxScrollY));
            }
            return position;
        };
        Indicator.prototype.destroy = function () {
            if (this.options.interactive !== false) {
                this.startEventRegister.destroy();
                this.moveEventRegister.destroy();
                this.endEventRegister.destroy();
            }
            this.hooksFn.forEach(function (item) {
                var hooks = item[0];
                var hooksName = item[1];
                var handlerFn = item[2];
                hooks.off(hooksName, handlerFn);
            });
            this.hooksFn.length = 0;
        };
        return Indicator;
    }());

    var Indicators = /** @class */ (function () {
        function Indicators(scroll) {
            this.scroll = scroll;
            this.options = [];
            this.indicators = [];
            this.handleOptions();
            this.handleHooks();
        }
        Indicators.prototype.handleOptions = function () {
            var UserIndicatorsOptions = this.scroll.options.indicators;
            assert(Array.isArray(UserIndicatorsOptions), "'indicators' must be an array.");
            for (var _i = 0, UserIndicatorsOptions_1 = UserIndicatorsOptions; _i < UserIndicatorsOptions_1.length; _i++) {
                var indicatorOptions = UserIndicatorsOptions_1[_i];
                assert(!!indicatorOptions.relationElement, "'relationElement' must be a HTMLElement.");
                this.createIndicators(indicatorOptions);
            }
        };
        Indicators.prototype.createIndicators = function (options) {
            this.indicators.push(new Indicator(this.scroll, options));
        };
        Indicators.prototype.handleHooks = function () {
            var _this = this;
            var scrollHooks = this.scroll.hooks;
            scrollHooks.on(scrollHooks.eventTypes.destroy, function () {
                for (var _i = 0, _a = _this.indicators; _i < _a.length; _i++) {
                    var indicator = _a[_i];
                    indicator.destroy();
                }
                _this.indicators = [];
            });
        };
        Indicators.pluginName = 'indicators';
        return Indicators;
    }());

    BScroll.use(MouseWheel)
        .use(ObserveDOM)
        .use(PullDown)
        .use(PullUp)
        .use(ScrollBar)
        .use(Slide)
        .use(Wheel)
        .use(Zoom)
        .use(NestedScroll)
        .use(InfinityScroll)
        .use(Movable)
        .use(ObserveImage)
        .use(Indicators);

    exports.Behavior = Behavior;
    exports.CustomOptions = CustomOptions;
    exports.Indicators = Indicators;
    exports.InfinityScroll = InfinityScroll;
    exports.MouseWheel = MouseWheel;
    exports.Movable = Movable;
    exports.NestedScroll = NestedScroll;
    exports.ObserveDom = ObserveDOM;
    exports.ObserveImage = ObserveImage;
    exports.PullDownRefresh = PullDown;
    exports.PullUpLoad = PullUp;
    exports.ScrollBar = ScrollBar;
    exports.Slide = Slide;
    exports.Wheel = Wheel;
    exports.Zoom = Zoom;
    exports.createBScroll = createBScroll;
    exports.default = BScroll;

    Object.defineProperty(exports, '__esModule', { value: true });

})));