@rowsncolumns/spreadsheet 10.2.68

package/dist/cjs/api/scroller.js

@@ -0,0 +1,702 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scroller = void 0;
+var tslib_1 = require("tslib");
+var animate_1 = require("./animate");
+/*
+ * Scroller
+ * http://github.com/zynga/scroller
+ *
+ * Copyright 2011, Zynga Inc.
+ * Licensed under the MIT License.
+ * https://raw.github.com/zynga/scroller/master/MIT-LICENSE.txt
+ *
+ * Based on the work of: Unify Project (unify-project.org)
+ * http://unify-project.org
+ * Copyright 2011, Deutsche Telekom AG
+ * License: MIT + Apache (V2)
+ */
+var Scroller = /** @class */ (function () {
+    function Scroller(callback, options) {
+        if (options === void 0) { options = {}; }
+        // Internal fields
+        this.__isSingleTouch = false;
+        this.__isTracking = false;
+        this.__didDecelerationComplete = false;
+        this.__isGesturing = false;
+        this.__isDragging = false;
+        this.__isDecelerating = false;
+        this.__isAnimating = false;
+        // Dimensions
+        this.__clientLeft = 0;
+        this.__clientTop = 0;
+        this.__clientWidth = 0;
+        this.__clientHeight = 0;
+        this.__contentWidth = 0;
+        this.__contentHeight = 0;
+        this.__snapWidth = 100;
+        this.__snapHeight = 100;
+        this.__zoomLevel = 1;
+        this.__scrollLeft = 0;
+        this.__scrollTop = 0;
+        this.__maxScrollLeft = 0;
+        this.__maxScrollTop = 0;
+        this.__scheduledLeft = 0;
+        this.__scheduledTop = 0;
+        this.__scheduledZoom = 0;
+        // Last positions
+        this.__lastTouchLeft = 0;
+        this.__lastTouchTop = 0;
+        this.__lastTouchMove = 0;
+        this.__positions = [];
+        // Deceleration support
+        this.__minDecelerationScrollLeft = 0;
+        this.__minDecelerationScrollTop = 0;
+        this.__maxDecelerationScrollLeft = 0;
+        this.__maxDecelerationScrollTop = 0;
+        this.__decelerationVelocityX = 0;
+        this.__decelerationVelocityY = 0;
+        this.__callback = callback;
+        this.__zoomComplete = null;
+        this.__interruptedAnimation = false;
+        this.__initialTouchLeft = 0;
+        this.__initialTouchTop = 0;
+        this.__zoomLevelStart = 1;
+        this.options = tslib_1.__assign({ scrollingX: true, scrollingY: true, animating: true, animationDuration: 250, bouncing: true, locking: true, paging: false, snapping: false, zooming: false, minZoom: 0.5, maxZoom: 3, speedMultiplier: 1, scrollingComplete: undefined, penetrationDeceleration: 0.03, penetrationAcceleration: 0.08 }, options);
+    }
+    // Easing Equations
+    Scroller.prototype.easeOutCubic = function (pos) {
+        return Math.pow(pos - 1, 3) + 1;
+    };
+    Scroller.prototype.easeInOutCubic = function (pos) {
+        if ((pos /= 0.5) < 1) {
+            return 0.5 * Math.pow(pos, 3);
+        }
+        return 0.5 * (Math.pow(pos - 2, 3) + 2);
+    };
+    // Public API
+    Scroller.prototype.setDimensions = function (clientWidth, clientHeight, contentWidth, contentHeight) {
+        if (clientWidth !== null)
+            this.__clientWidth = clientWidth;
+        if (clientHeight !== null)
+            this.__clientHeight = clientHeight;
+        if (contentWidth !== null)
+            this.__contentWidth = contentWidth;
+        if (contentHeight !== null)
+            this.__contentHeight = contentHeight;
+        this.__computeScrollMax();
+        this.scrollTo(this.__scrollLeft, this.__scrollTop, true);
+    };
+    Scroller.prototype.setPosition = function (left, top) {
+        if (left === void 0) { left = 0; }
+        if (top === void 0) { top = 0; }
+        this.__clientLeft = left;
+        this.__clientTop = top;
+    };
+    Scroller.prototype.setSnapSize = function (width, height) {
+        this.__snapWidth = width;
+        this.__snapHeight = height;
+    };
+    Scroller.prototype.getValues = function () {
+        return {
+            left: this.__scrollLeft,
+            top: this.__scrollTop,
+            right: this.__scrollLeft + this.__clientWidth / this.__zoomLevel,
+            bottom: this.__scrollTop + this.__clientHeight / this.__zoomLevel,
+            zoom: this.__zoomLevel,
+        };
+    };
+    Scroller.prototype.getPoint = function (scrollLeft, scrollTop) {
+        var values = this.getValues();
+        return {
+            left: scrollLeft / values.zoom,
+            top: scrollTop / values.zoom,
+        };
+    };
+    Scroller.prototype.getScrollMax = function () {
+        return {
+            left: this.__maxScrollLeft,
+            top: this.__maxScrollTop,
+        };
+    };
+    Scroller.prototype.zoomTo = function (level, isAnimated, fixedLeft, fixedTop, callback) {
+        var _a, _b;
+        if (isAnimated === void 0) { isAnimated = false; }
+        if (!this.options.zooming) {
+            throw new Error("Zooming is not enabled!");
+        }
+        if (callback) {
+            this.__zoomComplete = callback;
+        }
+        if (this.__isDecelerating) {
+            (0, animate_1.stop)(this.__isDecelerating);
+            this.__isDecelerating = false;
+        }
+        var oldLevel = this.__zoomLevel;
+        var k = level / oldLevel;
+        if (fixedLeft === undefined)
+            fixedLeft = this.__clientWidth / 2;
+        if (fixedTop === undefined)
+            fixedTop = this.__clientHeight / 2;
+        level = Math.max(Math.min(level, (_a = this.options.maxZoom) !== null && _a !== void 0 ? _a : 1), (_b = this.options.minZoom) !== null && _b !== void 0 ? _b : 1);
+        this.__computeScrollMax(level);
+        var left = k * (this.__scrollLeft + fixedLeft) - fixedLeft;
+        var top = k * (this.__scrollTop + fixedTop) - fixedTop;
+        left = Math.max(Math.min(left, this.__maxScrollLeft), 0);
+        top = Math.max(Math.min(top, this.__maxScrollTop), 0);
+        this.__publish(left, top, level, isAnimated);
+    };
+    Scroller.prototype.zoomBy = function (factor, isAnimated, originLeft, originTop, callback) {
+        if (isAnimated === void 0) { isAnimated = false; }
+        if (originLeft === void 0) { originLeft = 0; }
+        if (originTop === void 0) { originTop = 0; }
+        this.zoomTo(this.__zoomLevel * factor, isAnimated, originLeft, originTop, callback);
+    };
+    Scroller.prototype.scrollTo = function (left, top, isAnimated, zoom) {
+        if (isAnimated === void 0) { isAnimated = false; }
+        if (this.__isDecelerating) {
+            (0, animate_1.stop)(this.__isDecelerating);
+            this.__isDecelerating = false;
+        }
+        if (zoom !== undefined && zoom !== this.__zoomLevel) {
+            if (!this.options.zooming) {
+                throw new Error("Zooming is not enabled!");
+            }
+            left = (left !== null && left !== void 0 ? left : 0) * zoom;
+            top = (top !== null && top !== void 0 ? top : 0) * zoom;
+            this.__computeScrollMax(zoom);
+        }
+        else {
+            zoom = this.__zoomLevel;
+        }
+        if (!this.options.scrollingX) {
+            left = this.__scrollLeft;
+        }
+        else {
+            if (this.options.paging) {
+                left =
+                    Math.round((left !== null && left !== void 0 ? left : 0) / this.__clientWidth) * this.__clientWidth;
+            }
+            else if (this.options.snapping) {
+                left = Math.round(left !== null && left !== void 0 ? left : 0 / this.__snapWidth) * this.__snapWidth;
+            }
+        }
+        if (!this.options.scrollingY) {
+            top = this.__scrollTop;
+        }
+        else {
+            if (this.options.paging) {
+                top = Math.round(top !== null && top !== void 0 ? top : 0 / this.__clientHeight) * this.__clientHeight;
+            }
+            else if (this.options.snapping) {
+                top = Math.round(top !== null && top !== void 0 ? top : 0 / this.__snapHeight) * this.__snapHeight;
+            }
+        }
+        left = Math.max(Math.min(this.__maxScrollLeft, left !== null && left !== void 0 ? left : 0), 0);
+        top = Math.max(Math.min(this.__maxScrollTop, top !== null && top !== void 0 ? top : 0), 0);
+        if (left === this.__scrollLeft && top === this.__scrollTop) {
+            isAnimated = false;
+        }
+        this.__publish(left, top, zoom, isAnimated);
+    };
+    Scroller.prototype.scrollBy = function (left, top, isAnimated) {
+        if (left === void 0) { left = 0; }
+        if (top === void 0) { top = 0; }
+        if (isAnimated === void 0) { isAnimated = false; }
+        var startLeft = this.__isAnimating
+            ? this.__scheduledLeft
+            : this.__scrollLeft;
+        var startTop = this.__isAnimating
+            ? this.__scheduledTop
+            : this.__scrollTop;
+        this.scrollTo(startLeft + left, startTop + top, isAnimated);
+    };
+    /**
+     * Mouse wheel handler for zooming support
+     */
+    Scroller.prototype.doMouseZoom = function (wheelDelta, timeStamp, pageX, pageY) {
+        var change = wheelDelta > 0 ? 0.97 : 1.03;
+        this.zoomTo(this.__zoomLevel * change, false, pageX - this.__clientLeft, pageY - this.__clientTop);
+    };
+    /**
+     * Touch start handler for scrolling support
+     */
+    Scroller.prototype.doTouchStart = function (touches, timeStamp) {
+        if (touches.length === undefined) {
+            throw new Error("Invalid touch list: " + touches);
+        }
+        if (timeStamp instanceof Date) {
+            timeStamp = timeStamp.valueOf();
+        }
+        if (typeof timeStamp !== "number") {
+            throw new Error("Invalid timestamp value: " + timeStamp);
+        }
+        // Reset interruptedAnimation flag
+        this.__interruptedAnimation = true;
+        // Stop deceleration
+        if (this.__isDecelerating) {
+            (0, animate_1.stop)(this.__isDecelerating);
+            this.__isDecelerating = false;
+            this.__interruptedAnimation = true;
+        }
+        // Stop animation
+        if (this.__isAnimating) {
+            (0, animate_1.stop)(this.__isAnimating);
+            this.__isAnimating = false;
+            this.__interruptedAnimation = true;
+        }
+        // Use center point when dealing with two fingers
+        var currentTouchLeft, currentTouchTop;
+        var isSingleTouch = touches.length === 1;
+        if (isSingleTouch) {
+            currentTouchLeft = touches[0].pageX;
+            currentTouchTop = touches[0].pageY;
+        }
+        else {
+            currentTouchLeft = Math.abs(touches[0].pageX + touches[1].pageX) / 2;
+            currentTouchTop = Math.abs(touches[0].pageY + touches[1].pageY) / 2;
+        }
+        // Store initial positions
+        this.__initialTouchLeft = currentTouchLeft;
+        this.__initialTouchTop = currentTouchTop;
+        // Store current zoom level
+        this.__zoomLevelStart = this.__zoomLevel;
+        // Store initial touch positions
+        this.__lastTouchLeft = currentTouchLeft;
+        this.__lastTouchTop = currentTouchTop;
+        // Store initial move time stamp
+        this.__lastTouchMove = timeStamp;
+        // Reset initial scale
+        this.__lastScale = 1;
+        // Reset locking flags
+        this.__enableScrollX = !isSingleTouch && this.options.scrollingX;
+        this.__enableScrollY = !isSingleTouch && this.options.scrollingY;
+        // Reset tracking flag
+        this.__isTracking = true;
+        // Reset deceleration complete flag
+        this.__didDecelerationComplete = false;
+        // Dragging starts directly with two fingers, otherwise lazy with an offset
+        this.__isDragging = !isSingleTouch;
+        // Some features are disabled in multi touch scenarios
+        this.__isSingleTouch = isSingleTouch;
+        // Clearing data structure
+        this.__positions = [];
+    };
+    /**
+     * Touch move handler for scrolling support
+     */
+    Scroller.prototype.doTouchMove = function (touches, timeStamp, scale) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (touches.length === undefined) {
+            throw new Error("Invalid touch list: " + touches);
+        }
+        if (timeStamp instanceof Date) {
+            timeStamp = timeStamp.valueOf();
+        }
+        if (typeof timeStamp !== "number") {
+            throw new Error("Invalid timestamp value: " + timeStamp);
+        }
+        // Ignore event when tracking is not enabled
+        if (!this.__isTracking) {
+            return;
+        }
+        var currentTouchLeft, currentTouchTop;
+        // Compute move based around center of fingers
+        if (touches.length === 2) {
+            currentTouchLeft = Math.abs(touches[0].pageX + touches[1].pageX) / 2;
+            currentTouchTop = Math.abs(touches[0].pageY + touches[1].pageY) / 2;
+        }
+        else {
+            currentTouchLeft = touches[0].pageX;
+            currentTouchTop = touches[0].pageY;
+        }
+        var positions = this.__positions;
+        // Are we already in dragging mode?
+        if (this.__isDragging) {
+            // Compute move distance
+            var moveX = currentTouchLeft - this.__lastTouchLeft;
+            var moveY = currentTouchTop - this.__lastTouchTop;
+            // Read previous scroll position and zooming
+            var scrollLeft = this.__scrollLeft;
+            var scrollTop = this.__scrollTop;
+            var level = this.__zoomLevel;
+            // Work with scaling
+            if (scale !== undefined && this.options.zooming) {
+                var oldLevel = level;
+                // Recompute level based on previous scale and new scale
+                level = (level / ((_a = this.__lastScale) !== null && _a !== void 0 ? _a : 1)) * scale;
+                // Limit level according to configuration
+                level = Math.max(Math.min(level, (_b = this.options.maxZoom) !== null && _b !== void 0 ? _b : 1), (_c = this.options.minZoom) !== null && _c !== void 0 ? _c : 1);
+                // Only do further computation when change happened
+                if (oldLevel !== level) {
+                    // Compute relative event position to container
+                    var currentTouchLeftRel = currentTouchLeft - this.__clientLeft;
+                    var currentTouchTopRel = currentTouchTop - this.__clientTop;
+                    // Recompute left and top coordinates based on new zoom level
+                    scrollLeft =
+                        ((currentTouchLeftRel + scrollLeft) * level) / oldLevel -
+                            currentTouchLeftRel;
+                    scrollTop =
+                        ((currentTouchTopRel + scrollTop) * level) / oldLevel -
+                            currentTouchTopRel;
+                    // Recompute max scroll values
+                    this.__computeScrollMax(level);
+                }
+            }
+            if (this.__enableScrollX) {
+                scrollLeft -= moveX * ((_d = this.options.speedMultiplier) !== null && _d !== void 0 ? _d : 1);
+                var maxScrollLeft = this.__maxScrollLeft;
+                if (scrollLeft > maxScrollLeft || scrollLeft < 0) {
+                    // Slow down on the edges
+                    if (this.options.bouncing) {
+                        scrollLeft += (moveX / 2) * ((_e = this.options.speedMultiplier) !== null && _e !== void 0 ? _e : 1);
+                    }
+                    else if (scrollLeft > maxScrollLeft) {
+                        scrollLeft = maxScrollLeft;
+                    }
+                    else {
+                        scrollLeft = 0;
+                    }
+                }
+            }
+            if (this.__enableScrollY) {
+                scrollTop -= moveY * ((_f = this.options.speedMultiplier) !== null && _f !== void 0 ? _f : 1);
+                var maxScrollTop = this.__maxScrollTop;
+                if (scrollTop > maxScrollTop || scrollTop < 0) {
+                    // Slow down on the edges
+                    if (this.options.bouncing) {
+                        scrollTop += (moveY / 2) * ((_g = this.options.speedMultiplier) !== null && _g !== void 0 ? _g : 1);
+                    }
+                    else if (scrollTop > maxScrollTop) {
+                        scrollTop = maxScrollTop;
+                    }
+                    else {
+                        scrollTop = 0;
+                    }
+                }
+            }
+            // Keep list from growing infinitely
+            if (positions.length > 60) {
+                positions.splice(0, 30);
+            }
+            // Track scroll movement for deceleration
+            positions.push(scrollLeft, scrollTop, timeStamp);
+            // Sync scroll position
+            this.__publish(scrollLeft, scrollTop, level);
+        }
+        else {
+            var minimumTrackingForScroll = this.options.locking ? 3 : 0;
+            var minimumTrackingForDrag = 5;
+            var distanceX = Math.abs(currentTouchLeft - this.__initialTouchLeft);
+            var distanceY = Math.abs(currentTouchTop - this.__initialTouchTop);
+            this.__enableScrollX =
+                this.options.scrollingX && distanceX >= minimumTrackingForScroll;
+            this.__enableScrollY =
+                this.options.scrollingY && distanceY >= minimumTrackingForScroll;
+            positions.push(this.__scrollLeft, this.__scrollTop, timeStamp);
+            this.__isDragging =
+                (this.__enableScrollX || this.__enableScrollY) &&
+                    (distanceX >= minimumTrackingForDrag ||
+                        distanceY >= minimumTrackingForDrag);
+            if (this.__isDragging) {
+                this.__interruptedAnimation = false;
+            }
+        }
+        // Update last touch positions and time stamp for next event
+        this.__lastTouchLeft = currentTouchLeft;
+        this.__lastTouchTop = currentTouchTop;
+        this.__lastTouchMove = timeStamp;
+        this.__lastScale = scale;
+    };
+    /**
+     * Touch end handler for scrolling support
+     */
+    Scroller.prototype.doTouchEnd = function (timeStamp) {
+        var _a, _b, _c, _d, _e, _f;
+        if (timeStamp instanceof Date) {
+            timeStamp = timeStamp.valueOf();
+        }
+        if (typeof timeStamp !== "number") {
+            throw new Error("Invalid timestamp value: " + timeStamp);
+        }
+        // Ignore event when tracking is not enabled
+        if (!this.__isTracking) {
+            return;
+        }
+        // Not touching anymore
+        this.__isTracking = false;
+        // Reset dragging flag and start deceleration if necessary
+        if (this.__isDragging) {
+            this.__isDragging = false;
+            if (this.__isSingleTouch &&
+                this.options.animating &&
+                timeStamp - this.__lastTouchMove <= 100) {
+                var positions = this.__positions;
+                var endPos = positions.length - 1;
+                var startPos = endPos;
+                for (var i = endPos; i > 0 && positions[i] > this.__lastTouchMove - 100; i -= 3) {
+                    startPos = i;
+                }
+                if (startPos !== endPos) {
+                    var timeOffset = positions[endPos] - positions[startPos];
+                    var movedLeft = this.__scrollLeft - positions[startPos - 2];
+                    var movedTop = this.__scrollTop - positions[startPos - 1];
+                    this.__decelerationVelocityX = (movedLeft / timeOffset) * (1000 / 60);
+                    this.__decelerationVelocityY = (movedTop / timeOffset) * (1000 / 60);
+                    var minVelocityToStartDeceleration = this.options.paging || this.options.snapping ? 4 : 1;
+                    if (Math.abs(this.__decelerationVelocityX) >
+                        minVelocityToStartDeceleration ||
+                        Math.abs(this.__decelerationVelocityY) >
+                            minVelocityToStartDeceleration) {
+                        this.__startDeceleration(timeStamp);
+                    }
+                }
+                else {
+                    (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.scrollingComplete) === null || _b === void 0 ? void 0 : _b.call(_a);
+                }
+            }
+            else if (timeStamp - this.__lastTouchMove > 100) {
+                (_d = (_c = this.options).scrollingComplete) === null || _d === void 0 ? void 0 : _d.call(_c);
+            }
+        }
+        if (!this.__isDecelerating) {
+            if (this.__interruptedAnimation || this.__isDragging) {
+                (_f = (_e = this.options).scrollingComplete) === null || _f === void 0 ? void 0 : _f.call(_e);
+            }
+            this.scrollTo(this.__scrollLeft, this.__scrollTop, true, this.__zoomLevel);
+        }
+        // Cleanup
+        this.__positions.length = 0;
+    };
+    /**
+     * Applies the scroll position to the content element
+     *
+     * @param left - Left scroll position
+     * @param top - Top scroll position
+     * @param zoom - Zoom level
+     * @param isAnimated - Whether animation should be used to move to the new coordinates
+     */
+    Scroller.prototype.__publish = function (left, top, zoom, isAnimated) {
+        var _this = this;
+        if (isAnimated === void 0) { isAnimated = false; }
+        // Remember whether we had an animation, then we try to continue
+        // based on the current "drive" of the animation.
+        var wasAnimating = this.__isAnimating;
+        if (wasAnimating) {
+            (0, animate_1.stop)(wasAnimating);
+            this.__isAnimating = false;
+        }
+        if (isAnimated && this.options.animating) {
+            // Keep scheduled positions for scrollBy/zoomBy functionality.
+            this.__scheduledLeft = left;
+            this.__scheduledTop = top;
+            this.__scheduledZoom = zoom;
+            var oldLeft_1 = this.__scrollLeft;
+            var oldTop_1 = this.__scrollTop;
+            var oldZoom_1 = this.__zoomLevel;
+            var diffLeft_1 = left - oldLeft_1;
+            var diffTop_1 = top - oldTop_1;
+            var diffZoom_1 = zoom - oldZoom_1;
+            var step = function (percent, now, render) {
+                if (render) {
+                    _this.__scrollLeft = oldLeft_1 + diffLeft_1 * percent;
+                    _this.__scrollTop = oldTop_1 + diffTop_1 * percent;
+                    _this.__zoomLevel = oldZoom_1 + diffZoom_1 * percent;
+                    // Push values out
+                    if (_this.__callback) {
+                        _this.__callback(_this.__scrollLeft, _this.__scrollTop, _this.__zoomLevel);
+                    }
+                }
+            };
+            var verify = function (id) { return _this.__isAnimating === id; };
+            var completed = function (renderedFramesPerSecond, animationId, wasFinished) {
+                var _a, _b;
+                if (animationId === _this.__isAnimating) {
+                    _this.__isAnimating = false;
+                }
+                if (_this.__didDecelerationComplete || wasFinished) {
+                    (_b = (_a = _this.options).scrollingComplete) === null || _b === void 0 ? void 0 : _b.call(_a);
+                }
+                if (_this.options.zooming) {
+                    _this.__computeScrollMax();
+                    if (_this.__zoomComplete) {
+                        _this.__zoomComplete();
+                        _this.__zoomComplete = null;
+                    }
+                }
+            };
+            // When continuing based on previous animation, choose an ease-out animation instead of ease-in-out
+            this.__isAnimating = (0, animate_1.start)(step, verify, completed, this.options.animationDuration, wasAnimating ? this.easeOutCubic : this.easeInOutCubic);
+        }
+        else {
+            this.__scheduledLeft = this.__scrollLeft = left;
+            this.__scheduledTop = this.__scrollTop = top;
+            this.__scheduledZoom = this.__zoomLevel = zoom;
+            // Push values out
+            if (this.__callback) {
+                this.__callback(left, top, zoom);
+            }
+            // Fix max scroll ranges
+            if (this.options.zooming) {
+                this.__computeScrollMax();
+                if (this.__zoomComplete) {
+                    this.__zoomComplete();
+                    this.__zoomComplete = null;
+                }
+            }
+        }
+    };
+    /**
+     * Recomputes scroll minimum values based on client dimensions and content dimensions.
+     *
+     * @param zoomLevel - Optional zoom level to compute scroll max for
+     */
+    Scroller.prototype.__computeScrollMax = function (zoomLevel) {
+        if (zoomLevel === undefined) {
+            zoomLevel = this.__zoomLevel;
+        }
+        this.__maxScrollLeft = Math.max(this.__contentWidth * zoomLevel - this.__clientWidth, 0);
+        this.__maxScrollTop = Math.max(this.__contentHeight * zoomLevel - this.__clientHeight, 0);
+    };
+    /**
+     * Called when a touch sequence ends and the speed of the finger was high enough
+     * to switch into deceleration mode.
+     *
+     * @param timeStamp - Timestamp of the touch end event
+     */
+    Scroller.prototype.__startDeceleration = function (timeStamp) {
+        var _this = this;
+        if (this.options.paging) {
+            var scrollLeft = Math.max(Math.min(this.__scrollLeft, this.__maxScrollLeft), 0);
+            var scrollTop = Math.max(Math.min(this.__scrollTop, this.__maxScrollTop), 0);
+            var clientWidth = this.__clientWidth;
+            var clientHeight = this.__clientHeight;
+            // We limit deceleration not to the min/max values of the allowed range, but to the size of the visible client area.
+            // Each page should have exactly the size of the client area.
+            this.__minDecelerationScrollLeft =
+                Math.floor(scrollLeft / clientWidth) * clientWidth;
+            this.__minDecelerationScrollTop =
+                Math.floor(scrollTop / clientHeight) * clientHeight;
+            this.__maxDecelerationScrollLeft =
+                Math.ceil(scrollLeft / clientWidth) * clientWidth;
+            this.__maxDecelerationScrollTop =
+                Math.ceil(scrollTop / clientHeight) * clientHeight;
+        }
+        else {
+            this.__minDecelerationScrollLeft = 0;
+            this.__minDecelerationScrollTop = 0;
+            this.__maxDecelerationScrollLeft = this.__maxScrollLeft;
+            this.__maxDecelerationScrollTop = this.__maxScrollTop;
+        }
+        // Wrap class method
+        var step = function (percent, now, render) {
+            _this.__stepThroughDeceleration(render);
+        };
+        // How much velocity is required to keep the deceleration running
+        var minVelocityToKeepDecelerating = this.options.snapping ? 4 : 0.1;
+        // Detect whether it's still worth to continue animating steps
+        var verify = function () {
+            var shouldContinue = Math.abs(_this.__decelerationVelocityX) >=
+                minVelocityToKeepDecelerating ||
+                Math.abs(_this.__decelerationVelocityY) >= minVelocityToKeepDecelerating;
+            if (!shouldContinue) {
+                _this.__didDecelerationComplete = true;
+            }
+            return shouldContinue;
+        };
+        var completed = function (renderedFramesPerSecond, animationId, wasFinished) {
+            var _a, _b;
+            _this.__isDecelerating = false;
+            if (_this.__didDecelerationComplete) {
+                (_b = (_a = _this.options).scrollingComplete) === null || _b === void 0 ? void 0 : _b.call(_a);
+            }
+            // Animate to grid when snapping is active, otherwise just fix out-of-boundary positions
+            _this.scrollTo(_this.__scrollLeft, _this.__scrollTop, _this.options.snapping);
+        };
+        // Start animation and switch on flag
+        this.__isDecelerating = (0, animate_1.start)(step, verify, completed);
+    };
+    /**
+     * Called on every step of the animation
+     *
+     * @param render - Whether to render the current step or keep it in memory only
+     */
+    Scroller.prototype.__stepThroughDeceleration = function (render) {
+        // Add deceleration to scroll position
+        var scrollLeft = this.__scrollLeft + this.__decelerationVelocityX;
+        var scrollTop = this.__scrollTop + this.__decelerationVelocityY;
+        // Hard limit scroll position for non-bouncing mode
+        if (!this.options.bouncing) {
+            var scrollLeftFixed = Math.max(Math.min(this.__maxDecelerationScrollLeft, scrollLeft), this.__minDecelerationScrollLeft);
+            if (scrollLeftFixed !== scrollLeft) {
+                scrollLeft = scrollLeftFixed;
+                this.__decelerationVelocityX = 0;
+            }
+            var scrollTopFixed = Math.max(Math.min(this.__maxDecelerationScrollTop, scrollTop), this.__minDecelerationScrollTop);
+            if (scrollTopFixed !== scrollTop) {
+                scrollTop = scrollTopFixed;
+                this.__decelerationVelocityY = 0;
+            }
+        }
+        // Update scroll position
+        if (render) {
+            this.__publish(scrollLeft, scrollTop, this.__zoomLevel);
+        }
+        else {
+            this.__scrollLeft = scrollLeft;
+            this.__scrollTop = scrollTop;
+        }
+        // Slow down velocity on every iteration
+        if (!this.options.paging) {
+            var frictionFactor = 0.95;
+            this.__decelerationVelocityX *= frictionFactor;
+            this.__decelerationVelocityY *= frictionFactor;
+        }
+        // Bouncing support
+        if (this.options.bouncing) {
+            var scrollOutsideX = 0;
+            var scrollOutsideY = 0;
+            var penetrationDeceleration = this.options.penetrationDeceleration;
+            var penetrationAcceleration = this.options.penetrationAcceleration;
+            // Check limits
+            if (scrollLeft < this.__minDecelerationScrollLeft) {
+                scrollOutsideX = this.__minDecelerationScrollLeft - scrollLeft;
+            }
+            else if (scrollLeft > this.__maxDecelerationScrollLeft) {
+                scrollOutsideX = this.__maxDecelerationScrollLeft - scrollLeft;
+            }
+            if (scrollTop < this.__minDecelerationScrollTop) {
+                scrollOutsideY = this.__minDecelerationScrollTop - scrollTop;
+            }
+            else if (scrollTop > this.__maxDecelerationScrollTop) {
+                scrollOutsideY = this.__maxDecelerationScrollTop - scrollTop;
+            }
+            // Slow down until slow enough, then flip back to snap position
+            if (scrollOutsideX !== 0) {
+                if (scrollOutsideX * this.__decelerationVelocityX <= 0) {
+                    this.__decelerationVelocityX +=
+                        scrollOutsideX * (penetrationDeceleration !== null && penetrationDeceleration !== void 0 ? penetrationDeceleration : 1);
+                }
+                else {
+                    this.__decelerationVelocityX =
+                        scrollOutsideX * (penetrationAcceleration !== null && penetrationAcceleration !== void 0 ? penetrationAcceleration : 1);
+                }
+            }
+            if (scrollOutsideY !== 0) {
+                if (scrollOutsideY * this.__decelerationVelocityY <= 0) {
+                    this.__decelerationVelocityY +=
+                        scrollOutsideY * (penetrationDeceleration !== null && penetrationDeceleration !== void 0 ? penetrationDeceleration : 1);
+                }
+                else {
+                    this.__decelerationVelocityY =
+                        scrollOutsideY * (penetrationAcceleration !== null && penetrationAcceleration !== void 0 ? penetrationAcceleration : 1);
+                }
+            }
+        }
+    };
+    return Scroller;
+}());
+exports.Scroller = Scroller;
+function NOOP() {
+    throw new Error("Function not implemented.");
+}