@rowsncolumns/spreadsheet 10.2.68

package/dist/esm/api/scroller.js

@@ -0,0 +1,704 @@
+import { start, stop } from "./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)
+ */
+export class Scroller {
+    __callback;
+    options;
+    // Internal fields
+    __isSingleTouch = false;
+    __isTracking = false;
+    __didDecelerationComplete = false;
+    __isGesturing = false;
+    __isDragging = false;
+    __isDecelerating = false;
+    __isAnimating = false;
+    // Dimensions
+    __clientLeft = 0;
+    __clientTop = 0;
+    __clientWidth = 0;
+    __clientHeight = 0;
+    __contentWidth = 0;
+    __contentHeight = 0;
+    __snapWidth = 100;
+    __snapHeight = 100;
+    __zoomLevel = 1;
+    __scrollLeft = 0;
+    __scrollTop = 0;
+    __maxScrollLeft = 0;
+    __maxScrollTop = 0;
+    __scheduledLeft = 0;
+    __scheduledTop = 0;
+    __scheduledZoom = 0;
+    // Last positions
+    __lastTouchLeft = 0;
+    __lastTouchTop = 0;
+    __lastTouchMove = 0;
+    __positions = [];
+    // Deceleration support
+    __minDecelerationScrollLeft = 0;
+    __minDecelerationScrollTop = 0;
+    __maxDecelerationScrollLeft = 0;
+    __maxDecelerationScrollTop = 0;
+    __decelerationVelocityX = 0;
+    __decelerationVelocityY = 0;
+    __zoomComplete;
+    __interruptedAnimation;
+    __initialTouchLeft;
+    __initialTouchTop;
+    __zoomLevelStart;
+    __lastScale;
+    __enableScrollX;
+    __enableScrollY;
+    constructor(callback, options = {}) {
+        this.__callback = callback;
+        this.__zoomComplete = null;
+        this.__interruptedAnimation = false;
+        this.__initialTouchLeft = 0;
+        this.__initialTouchTop = 0;
+        this.__zoomLevelStart = 1;
+        this.options = {
+            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
+    easeOutCubic(pos) {
+        return Math.pow(pos - 1, 3) + 1;
+    }
+    easeInOutCubic(pos) {
+        if ((pos /= 0.5) < 1) {
+            return 0.5 * Math.pow(pos, 3);
+        }
+        return 0.5 * (Math.pow(pos - 2, 3) + 2);
+    }
+    // Public API
+    setDimensions(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);
+    }
+    setPosition(left = 0, top = 0) {
+        this.__clientLeft = left;
+        this.__clientTop = top;
+    }
+    setSnapSize(width, height) {
+        this.__snapWidth = width;
+        this.__snapHeight = height;
+    }
+    getValues() {
+        return {
+            left: this.__scrollLeft,
+            top: this.__scrollTop,
+            right: this.__scrollLeft + this.__clientWidth / this.__zoomLevel,
+            bottom: this.__scrollTop + this.__clientHeight / this.__zoomLevel,
+            zoom: this.__zoomLevel,
+        };
+    }
+    getPoint(scrollLeft, scrollTop) {
+        const values = this.getValues();
+        return {
+            left: scrollLeft / values.zoom,
+            top: scrollTop / values.zoom,
+        };
+    }
+    getScrollMax() {
+        return {
+            left: this.__maxScrollLeft,
+            top: this.__maxScrollTop,
+        };
+    }
+    zoomTo(level, isAnimated = false, fixedLeft, fixedTop, callback) {
+        if (!this.options.zooming) {
+            throw new Error("Zooming is not enabled!");
+        }
+        if (callback) {
+            this.__zoomComplete = callback;
+        }
+        if (this.__isDecelerating) {
+            stop(this.__isDecelerating);
+            this.__isDecelerating = false;
+        }
+        const oldLevel = this.__zoomLevel;
+        const k = level / oldLevel;
+        if (fixedLeft === undefined)
+            fixedLeft = this.__clientWidth / 2;
+        if (fixedTop === undefined)
+            fixedTop = this.__clientHeight / 2;
+        level = Math.max(Math.min(level, this.options.maxZoom ?? 1), this.options.minZoom ?? 1);
+        this.__computeScrollMax(level);
+        let left = k * (this.__scrollLeft + fixedLeft) - fixedLeft;
+        let 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);
+    }
+    zoomBy(factor, isAnimated = false, originLeft = 0, originTop = 0, callback) {
+        this.zoomTo(this.__zoomLevel * factor, isAnimated, originLeft, originTop, callback);
+    }
+    scrollTo(left, top, isAnimated = false, zoom) {
+        if (this.__isDecelerating) {
+            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 ?? 0) * zoom;
+            top = (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 ?? 0) / this.__clientWidth) * this.__clientWidth;
+            }
+            else if (this.options.snapping) {
+                left = Math.round(left ?? 0 / this.__snapWidth) * this.__snapWidth;
+            }
+        }
+        if (!this.options.scrollingY) {
+            top = this.__scrollTop;
+        }
+        else {
+            if (this.options.paging) {
+                top = Math.round(top ?? 0 / this.__clientHeight) * this.__clientHeight;
+            }
+            else if (this.options.snapping) {
+                top = Math.round(top ?? 0 / this.__snapHeight) * this.__snapHeight;
+            }
+        }
+        left = Math.max(Math.min(this.__maxScrollLeft, left ?? 0), 0);
+        top = Math.max(Math.min(this.__maxScrollTop, top ?? 0), 0);
+        if (left === this.__scrollLeft && top === this.__scrollTop) {
+            isAnimated = false;
+        }
+        this.__publish(left, top, zoom, isAnimated);
+    }
+    scrollBy(left = 0, top = 0, isAnimated = false) {
+        const startLeft = this.__isAnimating
+            ? this.__scheduledLeft
+            : this.__scrollLeft;
+        const startTop = this.__isAnimating
+            ? this.__scheduledTop
+            : this.__scrollTop;
+        this.scrollTo(startLeft + left, startTop + top, isAnimated);
+    }
+    /**
+     * Mouse wheel handler for zooming support
+     */
+    doMouseZoom(wheelDelta, timeStamp, pageX, pageY) {
+        const 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
+     */
+    doTouchStart(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) {
+            stop(this.__isDecelerating);
+            this.__isDecelerating = false;
+            this.__interruptedAnimation = true;
+        }
+        // Stop animation
+        if (this.__isAnimating) {
+            stop(this.__isAnimating);
+            this.__isAnimating = false;
+            this.__interruptedAnimation = true;
+        }
+        // Use center point when dealing with two fingers
+        let currentTouchLeft, currentTouchTop;
+        const 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
+     */
+    doTouchMove(touches, timeStamp, scale) {
+        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;
+        }
+        let 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;
+        }
+        const positions = this.__positions;
+        // Are we already in dragging mode?
+        if (this.__isDragging) {
+            // Compute move distance
+            const moveX = currentTouchLeft - this.__lastTouchLeft;
+            const moveY = currentTouchTop - this.__lastTouchTop;
+            // Read previous scroll position and zooming
+            let scrollLeft = this.__scrollLeft;
+            let scrollTop = this.__scrollTop;
+            let level = this.__zoomLevel;
+            // Work with scaling
+            if (scale !== undefined && this.options.zooming) {
+                const oldLevel = level;
+                // Recompute level based on previous scale and new scale
+                level = (level / (this.__lastScale ?? 1)) * scale;
+                // Limit level according to configuration
+                level = Math.max(Math.min(level, this.options.maxZoom ?? 1), this.options.minZoom ?? 1);
+                // Only do further computation when change happened
+                if (oldLevel !== level) {
+                    // Compute relative event position to container
+                    const currentTouchLeftRel = currentTouchLeft - this.__clientLeft;
+                    const 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 * (this.options.speedMultiplier ?? 1);
+                const maxScrollLeft = this.__maxScrollLeft;
+                if (scrollLeft > maxScrollLeft || scrollLeft < 0) {
+                    // Slow down on the edges
+                    if (this.options.bouncing) {
+                        scrollLeft += (moveX / 2) * (this.options.speedMultiplier ?? 1);
+                    }
+                    else if (scrollLeft > maxScrollLeft) {
+                        scrollLeft = maxScrollLeft;
+                    }
+                    else {
+                        scrollLeft = 0;
+                    }
+                }
+            }
+            if (this.__enableScrollY) {
+                scrollTop -= moveY * (this.options.speedMultiplier ?? 1);
+                const maxScrollTop = this.__maxScrollTop;
+                if (scrollTop > maxScrollTop || scrollTop < 0) {
+                    // Slow down on the edges
+                    if (this.options.bouncing) {
+                        scrollTop += (moveY / 2) * (this.options.speedMultiplier ?? 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 {
+            const minimumTrackingForScroll = this.options.locking ? 3 : 0;
+            const minimumTrackingForDrag = 5;
+            const distanceX = Math.abs(currentTouchLeft - this.__initialTouchLeft);
+            const 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
+     */
+    doTouchEnd(timeStamp) {
+        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) {
+                const positions = this.__positions;
+                const endPos = positions.length - 1;
+                let startPos = endPos;
+                for (let i = endPos; i > 0 && positions[i] > this.__lastTouchMove - 100; i -= 3) {
+                    startPos = i;
+                }
+                if (startPos !== endPos) {
+                    const timeOffset = positions[endPos] - positions[startPos];
+                    const movedLeft = this.__scrollLeft - positions[startPos - 2];
+                    const movedTop = this.__scrollTop - positions[startPos - 1];
+                    this.__decelerationVelocityX = (movedLeft / timeOffset) * (1000 / 60);
+                    this.__decelerationVelocityY = (movedTop / timeOffset) * (1000 / 60);
+                    const minVelocityToStartDeceleration = this.options.paging || this.options.snapping ? 4 : 1;
+                    if (Math.abs(this.__decelerationVelocityX) >
+                        minVelocityToStartDeceleration ||
+                        Math.abs(this.__decelerationVelocityY) >
+                            minVelocityToStartDeceleration) {
+                        this.__startDeceleration(timeStamp);
+                    }
+                }
+                else {
+                    this.options?.scrollingComplete?.();
+                }
+            }
+            else if (timeStamp - this.__lastTouchMove > 100) {
+                this.options.scrollingComplete?.();
+            }
+        }
+        if (!this.__isDecelerating) {
+            if (this.__interruptedAnimation || this.__isDragging) {
+                this.options.scrollingComplete?.();
+            }
+            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
+     */
+    __publish(left, top, zoom, isAnimated = false) {
+        // Remember whether we had an animation, then we try to continue
+        // based on the current "drive" of the animation.
+        const wasAnimating = this.__isAnimating;
+        if (wasAnimating) {
+            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;
+            const oldLeft = this.__scrollLeft;
+            const oldTop = this.__scrollTop;
+            const oldZoom = this.__zoomLevel;
+            const diffLeft = left - oldLeft;
+            const diffTop = top - oldTop;
+            const diffZoom = zoom - oldZoom;
+            const step = (percent, now, render) => {
+                if (render) {
+                    this.__scrollLeft = oldLeft + diffLeft * percent;
+                    this.__scrollTop = oldTop + diffTop * percent;
+                    this.__zoomLevel = oldZoom + diffZoom * percent;
+                    // Push values out
+                    if (this.__callback) {
+                        this.__callback(this.__scrollLeft, this.__scrollTop, this.__zoomLevel);
+                    }
+                }
+            };
+            const verify = (id) => this.__isAnimating === id;
+            const completed = (renderedFramesPerSecond, animationId, wasFinished) => {
+                if (animationId === this.__isAnimating) {
+                    this.__isAnimating = false;
+                }
+                if (this.__didDecelerationComplete || wasFinished) {
+                    this.options.scrollingComplete?.();
+                }
+                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 = 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
+     */
+    __computeScrollMax(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
+     */
+    __startDeceleration(timeStamp) {
+        if (this.options.paging) {
+            const scrollLeft = Math.max(Math.min(this.__scrollLeft, this.__maxScrollLeft), 0);
+            const scrollTop = Math.max(Math.min(this.__scrollTop, this.__maxScrollTop), 0);
+            const clientWidth = this.__clientWidth;
+            const 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
+        const step = (percent, now, render) => {
+            this.__stepThroughDeceleration(render);
+        };
+        // How much velocity is required to keep the deceleration running
+        const minVelocityToKeepDecelerating = this.options.snapping ? 4 : 0.1;
+        // Detect whether it's still worth to continue animating steps
+        const verify = () => {
+            const shouldContinue = Math.abs(this.__decelerationVelocityX) >=
+                minVelocityToKeepDecelerating ||
+                Math.abs(this.__decelerationVelocityY) >= minVelocityToKeepDecelerating;
+            if (!shouldContinue) {
+                this.__didDecelerationComplete = true;
+            }
+            return shouldContinue;
+        };
+        const completed = (renderedFramesPerSecond, animationId, wasFinished) => {
+            this.__isDecelerating = false;
+            if (this.__didDecelerationComplete) {
+                this.options.scrollingComplete?.();
+            }
+            // 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 = 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
+     */
+    __stepThroughDeceleration(render) {
+        // Add deceleration to scroll position
+        let scrollLeft = this.__scrollLeft + this.__decelerationVelocityX;
+        let scrollTop = this.__scrollTop + this.__decelerationVelocityY;
+        // Hard limit scroll position for non-bouncing mode
+        if (!this.options.bouncing) {
+            const scrollLeftFixed = Math.max(Math.min(this.__maxDecelerationScrollLeft, scrollLeft), this.__minDecelerationScrollLeft);
+            if (scrollLeftFixed !== scrollLeft) {
+                scrollLeft = scrollLeftFixed;
+                this.__decelerationVelocityX = 0;
+            }
+            const 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) {
+            const frictionFactor = 0.95;
+            this.__decelerationVelocityX *= frictionFactor;
+            this.__decelerationVelocityY *= frictionFactor;
+        }
+        // Bouncing support
+        if (this.options.bouncing) {
+            let scrollOutsideX = 0;
+            let scrollOutsideY = 0;
+            const penetrationDeceleration = this.options.penetrationDeceleration;
+            const 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 ?? 1);
+                }
+                else {
+                    this.__decelerationVelocityX =
+                        scrollOutsideX * (penetrationAcceleration ?? 1);
+                }
+            }
+            if (scrollOutsideY !== 0) {
+                if (scrollOutsideY * this.__decelerationVelocityY <= 0) {
+                    this.__decelerationVelocityY +=
+                        scrollOutsideY * (penetrationDeceleration ?? 1);
+                }
+                else {
+                    this.__decelerationVelocityY =
+                        scrollOutsideY * (penetrationAcceleration ?? 1);
+                }
+            }
+        }
+    }
+}
+function NOOP() {
+    throw new Error("Function not implemented.");
+}