cbvirtua 1.0.105 → 1.0.107

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

@@ -0,0 +1,200 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,210 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,76 @@
+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

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