cbvirtua 1.0.109 → 1.0.115

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/scroller/Scroller.js

@@ -1,456 +0,0 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(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);
-};
-import ActionsHandler from '../base/ActionsHandler';
-import Translater from '../translater';
-import createAnimater from '../animater';
-import { Behavior } from './Behavior';
-import ScrollerActions from './Actions';
-import { createActionsHandlerOptions, createBehaviorOptions, } from './createOptions';
-import { getElement, ease, offset, style, preventDefaultExceptionFn, isAndroid, isIOSBadVersion, click, dblclick, tap, isUndef, getNow, cancelAnimationFrame, EventEmitter, EventRegister, } from '@better-scroll/shared-utils';
-import { bubbling } from '../utils/bubbling';
-import { isSamePoint } from '../utils/compare';
-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, // just for event api
-            },
-            {
-                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 /* Probe.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;
-}());
-export default Scroller;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/scroller/createOptions.d.ts

@@ -1,5 +0,0 @@
-import { Options as BScrollOptions } from '../Options';
-import { Options as ActionsHandlerOptions } from '../base/ActionsHandler';
-import { Options as BehaviorOptions, Bounces, Rect } from './Behavior';
-export declare function createActionsHandlerOptions(bsOptions: BScrollOptions): ActionsHandlerOptions;
-export declare function createBehaviorOptions(bsOptions: BScrollOptions, extraProp: 'scrollX' | 'scrollY', bounces: Bounces, rect: Rect): BehaviorOptions;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/scroller/createOptions.js

@@ -1,37 +0,0 @@
-export 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;
-}
-export 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;
-}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/translater/index.d.ts

@@ -1,19 +0,0 @@
-import { EventEmitter } from '@better-scroll/shared-utils';
-export interface TranslaterPoint {
-    x: number;
-    y: number;
-    [key: string]: number;
-}
-export default class Translater {
-    content: HTMLElement;
-    style: CSSStyleDeclaration;
-    hooks: EventEmitter;
-    constructor(content: HTMLElement);
-    getComputedPosition(): {
-        x: number;
-        y: number;
-    };
-    translate(point: TranslaterPoint): void;
-    setContent(content: HTMLElement): void;
-    destroy(): void;
-}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/translater/index.js

@@ -1,49 +0,0 @@
-import { style, EventEmitter, } from '@better-scroll/shared-utils';
-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("".concat(transformFnName, "(").concat(transformFnArg).concat(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;
-}());
-export default Translater;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/bubbling.d.ts

@@ -1,8 +0,0 @@
-import { EventEmitter } from '@better-scroll/shared-utils';
-interface BubblingEventMap {
-    source: string;
-    target: string;
-}
-type BubblingEventConfig = BubblingEventMap | string;
-export declare function bubbling(source: EventEmitter, target: EventEmitter, events: BubblingEventConfig[]): void;
-export {};

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/bubbling.js

@@ -1,29 +0,0 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-export 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, __spreadArray([targetEvent], args, false));
-        });
-    });
-}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/compare.d.ts

@@ -1,2 +0,0 @@
-import { TranslaterPoint } from '../translater';
-export declare function isSamePoint(startPoint: TranslaterPoint, endPoint: TranslaterPoint): boolean;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/compare.js

@@ -1,10 +0,0 @@
-export 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;
-}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/compat.d.ts

@@ -1,7 +0,0 @@
-import { TranslaterPoint } from '../translater';
-type Position = {
-    x: number;
-    y: number;
-};
-export declare const isValidPostion: (startPoint: TranslaterPoint, endPoint: TranslaterPoint, currentPos: Position, prePos: Position) => boolean;
-export {};

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/compat.js

@@ -1,22 +0,0 @@
-// 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'
-export var isValidPostion = function (startPoint, endPoint, currentPos, prePos) {
-    var computeDirection = function (endValue, startValue) {
-        var delta = endValue - startValue;
-        var direction = delta > 0
-            ? -1 /* Direction.Negative */
-            : delta < 0
-                ? 1 /* Direction.Positive */
-                : 0 /* Direction.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;
-};

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/typesHelper.d.ts

@@ -1 +0,0 @@
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/typesHelper.js

@@ -1 +0,0 @@
-export {};

package/better-scroll-dev/better-scroll-dev/dist/packages/indicators/src/index.d.ts

@@ -1,18 +0,0 @@
-import BScroll from '@better-scroll/core';
-import Indicator from './indicator';
-import { IndicatorOptions } from './types';
-declare module '@better-scroll/core' {
-    interface CustomOptions {
-        indicators?: IndicatorOptions[];
-    }
-}
-export default class Indicators {
-    scroll: BScroll;
-    static pluginName: string;
-    options: IndicatorOptions[];
-    indicators: Indicator[];
-    constructor(scroll: BScroll);
-    private handleOptions;
-    private createIndicators;
-    private handleHooks;
-}