cbvirtua 1.0.109 → 1.0.115

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

@@ -1,200 +0,0 @@
-import DirectionLockAction from './DirectionLock';
-import { preventDefaultExceptionFn, getNow, EventEmitter, between, maybePrevent, } from '@better-scroll/shared-utils';
-var applyQuadrantTransformation = function (deltaX, deltaY, quadrant) {
-    if (quadrant === 2 /* Quadrant.Second */) {
-        return [deltaY, -deltaX];
-    }
-    else if (quadrant === 3 /* Quadrant.Third */) {
-        return [-deltaX, -deltaY];
-    }
-    else if (quadrant === 4 /* Quadrant.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 /* Probe.Throttle */) {
-                this.hooks.trigger(this.hooks.eventTypes.scroll, this.getCurrentPos());
-            }
-        }
-        // dispatch scroll all the time
-        if (this.options.probeType > 1 /* Probe.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)) {
-            maybePrevent(e);
-            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;
-}());
-export default ScrollerActions;

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

@@ -1,70 +0,0 @@
-import { EventEmitter } from '@better-scroll/shared-utils';
-export type Bounces = [boolean, boolean];
-export type Rect = {
-    size: string;
-    position: string;
-};
-export interface Options {
-    scrollable: boolean;
-    momentum: boolean;
-    momentumLimitTime: number;
-    momentumLimitDistance: number;
-    deceleration: number;
-    swipeBounceTime: number;
-    swipeTime: number;
-    bounces: Bounces;
-    rect: Rect;
-    outOfBoundaryDampingFactor: number;
-    specifiedIndexAsContent: number;
-    [key: string]: number | boolean | Bounces | Rect;
-}
-export type Boundary = {
-    minScrollPos: number;
-    maxScrollPos: number;
-};
-export declare class Behavior {
-    wrapper: HTMLElement;
-    options: Options;
-    content: HTMLElement;
-    currentPos: number;
-    startPos: number;
-    absStartPos: number;
-    dist: number;
-    minScrollPos: number;
-    maxScrollPos: number;
-    hasScroll: boolean;
-    direction: number;
-    movingDirection: number;
-    relativeOffset: number;
-    wrapperSize: number;
-    contentSize: number;
-    hooks: EventEmitter;
-    constructor(wrapper: HTMLElement, content: HTMLElement, options: Options);
-    start(): void;
-    move(delta: number): number;
-    setMovingDirection(delta: number): void;
-    setDirection(delta: number): void;
-    performDampingAlgorithm(delta: number, dampingFactor: number): number;
-    end(duration: number): {
-        destination?: number | undefined;
-        duration?: number | undefined;
-    };
-    private momentum;
-    updateDirection(): void;
-    refresh(content: HTMLElement): void;
-    private setContent;
-    private resetState;
-    computeBoundary(): void;
-    updatePosition(pos: number): void;
-    getCurrentPos(): number;
-    checkInBoundary(): {
-        position: number;
-        inBoundary: boolean;
-    };
-    adjustPosition(pos: number): number;
-    updateStartPos(): void;
-    updateAbsStartPos(): void;
-    resetStartPos(): void;
-    getAbsDist(delta: number): number;
-    destroy(): void;
-}

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

@@ -1,210 +0,0 @@
-import { getRect, EventEmitter } from '@better-scroll/shared-utils';
-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 /* Direction.Default */);
-        this.setDirection(0 /* Direction.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 /* Direction.Negative */
-                : delta < 0
-                    ? 1 /* Direction.Positive */
-                    : 0 /* Direction.Default */;
-    };
-    Behavior.prototype.setDirection = function (delta) {
-        this.direction =
-            delta > 0
-                ? -1 /* Direction.Negative */
-                : delta < 0
-                    ? 1 /* Direction.Positive */
-                    : 0 /* Direction.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 /* Direction.Negative */ && this.options.bounces[0]) ||
-                (this.direction === 1 /* Direction.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 /* Direction.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 /* Direction.Default */);
-        this.setMovingDirection(0 /* Direction.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;
-}());
-export { Behavior };

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

@@ -1,16 +0,0 @@
-import { TouchEvent, DirectionLock } from '@better-scroll/shared-utils';
-export default class DirectionLockAction {
-    directionLockThreshold: number;
-    freeScroll: boolean;
-    eventPassthrough: string;
-    directionLocked: DirectionLock;
-    constructor(directionLockThreshold: number, freeScroll: boolean, eventPassthrough: string);
-    reset(): void;
-    checkMovingDirection(absDistX: number, absDistY: number, e: TouchEvent): boolean;
-    adjustDelta(deltaX: number, deltaY: number): {
-        deltaX: number;
-        deltaY: number;
-    };
-    private computeDirectionLock;
-    private handleEventPassthrough;
-}

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

@@ -1,76 +0,0 @@
-var _a, _b, _c, _d;
-import { maybePrevent, } from '@better-scroll/shared-utils';
-var PassthroughHandlers = (_a = {},
-    _a["yes" /* Passthrough.Yes */] = function (e) {
-        return true;
-    },
-    _a["no" /* Passthrough.No */] = function (e) {
-        maybePrevent(e);
-        return false;
-    },
-    _a);
-var DirectionMap = (_b = {},
-    _b["horizontal" /* DirectionLock.Horizontal */] = (_c = {},
-        _c["yes" /* Passthrough.Yes */] = "horizontal" /* EventPassthrough.Horizontal */,
-        _c["no" /* Passthrough.No */] = "vertical" /* EventPassthrough.Vertical */,
-        _c),
-    _b["vertical" /* DirectionLock.Vertical */] = (_d = {},
-        _d["yes" /* Passthrough.Yes */] = "vertical" /* EventPassthrough.Vertical */,
-        _d["no" /* Passthrough.No */] = "horizontal" /* EventPassthrough.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 = "" /* DirectionLock.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" /* DirectionLock.Horizontal */) {
-            deltaY = 0;
-        }
-        else if (this.directionLocked === "vertical" /* DirectionLock.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 === "" /* DirectionLock.Default */ && !this.freeScroll) {
-            if (absDistX > absDistY + this.directionLockThreshold) {
-                this.directionLocked = "horizontal" /* DirectionLock.Horizontal */; // lock horizontally
-            }
-            else if (absDistY >= absDistX + this.directionLockThreshold) {
-                this.directionLocked = "vertical" /* DirectionLock.Vertical */; // lock vertically
-            }
-            else {
-                this.directionLocked = "none" /* DirectionLock.None */; // no lock
-            }
-        }
-    };
-    DirectionLockAction.prototype.handleEventPassthrough = function (e) {
-        var handleMap = DirectionMap[this.directionLocked];
-        if (handleMap) {
-            if (this.eventPassthrough === handleMap["yes" /* Passthrough.Yes */]) {
-                return PassthroughHandlers["yes" /* Passthrough.Yes */](e);
-            }
-            else if (this.eventPassthrough === handleMap["no" /* Passthrough.No */]) {
-                return PassthroughHandlers["no" /* Passthrough.No */](e);
-            }
-        }
-        return false;
-    };
-    return DirectionLockAction;
-}());
-export default DirectionLockAction;

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

@@ -1,65 +0,0 @@
-import ActionsHandler from '../base/ActionsHandler';
-import Translater, { TranslaterPoint } from '../translater';
-import { Animater } from '../animater';
-import { OptionsConstructor as BScrollOptions } from '../Options';
-import { Behavior } from './Behavior';
-import ScrollerActions from './Actions';
-import { EaseItem, EventEmitter, EventRegister } from '@better-scroll/shared-utils';
-export interface ExposedAPI {
-    scrollTo(x: number, y: number, time?: number, easing?: EaseItem, extraTransform?: {
-        start: object;
-        end: object;
-    }): void;
-    scrollBy(deltaX: number, deltaY: number, time?: number, easing?: EaseItem): void;
-    scrollToElement(el: HTMLElement | string, time: number, offsetX: number | boolean, offsetY: number | boolean, easing?: EaseItem): void;
-    resetPosition(time?: number, easing?: EaseItem): boolean;
-}
-export default class Scroller implements ExposedAPI {
-    wrapper: HTMLElement;
-    content: HTMLElement;
-    actionsHandler: ActionsHandler;
-    translater: Translater;
-    animater: Animater;
-    scrollBehaviorX: Behavior;
-    scrollBehaviorY: Behavior;
-    actions: ScrollerActions;
-    hooks: EventEmitter;
-    resizeRegister: EventRegister;
-    transitionEndRegister: EventRegister;
-    options: BScrollOptions;
-    wrapperOffset: {
-        left: number;
-        top: number;
-    };
-    _reflow: number;
-    resizeTimeout: number;
-    lastClickTime: number | null;
-    [key: string]: any;
-    constructor(wrapper: HTMLElement, content: HTMLElement, options: BScrollOptions);
-    private init;
-    private registerTransitionEnd;
-    private bindTranslater;
-    private bindAnimater;
-    private bindActions;
-    private checkFlick;
-    private momentum;
-    private checkClick;
-    private resize;
-    private transitionEnd;
-    togglePointerEvents(enabled?: boolean): void;
-    refresh(content: HTMLElement): void;
-    private setContent;
-    scrollBy(deltaX: number, deltaY: number, time?: number, easing?: EaseItem): void;
-    scrollTo(x: number, y: number, time?: number, easing?: EaseItem, extraTransform?: {
-        start: {};
-        end: {};
-    }): void;
-    scrollToElement(el: HTMLElement | string, time: number, offsetX: number | boolean, offsetY: number | boolean, easing?: EaseItem): void;
-    resetPosition(time?: number, easing?: EaseItem): boolean;
-    reflow(): void;
-    updatePositions(pos: TranslaterPoint): void;
-    getCurrentPos(): TranslaterPoint;
-    enable(): void;
-    disable(): void;
-    destroy(this: Scroller): void;
-}