handsontable 18.0.0 → 18.1.0-rc7

package/plugins/multiColumnSorting/multiColumnSorting.mjs

@@ -1,6 +1,5 @@
 import { APPEND_COLUMN_CONFIG_STRATEGY, ColumnSorting } from '../columnSorting/index.mjs';
 import { registerRootComparator } from '../columnSorting/sortService/registry.mjs';
-import { wasHeaderClickedProperly } from '../columnSorting/utils.mjs';
 import { addClass, removeClass } from '../../helpers/dom/element.mjs';
 import { rootComparator } from './rootComparator.mjs';
 import { getClassesToAdd, getClassesToRemove } from './domHelpers.mjs';
@@ -247,23 +246,19 @@ registerRootComparator(PLUGIN_KEY, rootComparator);
         }
     }
     /**
-   * Callback for the `onAfterOnCellMouseDown` hook.
+   * Applies the sort queued by a header press.
+   *
+   * Holding Ctrl/Cmd appends the column to the sort queue instead of replacing it, which is the
+   * only way this differs from single-column sorting. The press-versus-drag handling that decides
+   * whether this runs at all lives in `ColumnSorting`.
    *
    * @private
-   * @param {Event} event Event which are provided by hook.
-   * @param {CellCoords} coords Visual coords of the selected cell.
-   */ onAfterOnCellMouseDown(event, coords) {
-        if (wasHeaderClickedProperly(coords.row, coords.col, event) === false) {
-            return;
-        }
-        if (this.wasClickableHeaderClicked(event, coords.col)) {
-            if (this.hot.getShortcutManager().isCtrlPressed()) {
-                this.hot.deselectCell();
-                this.hot.selectColumns(coords.col);
-                this.sort(this.getNextSortConfig(coords.col, APPEND_COLUMN_CONFIG_STRATEGY));
-            } else {
-                this.sort(this.getColumnNextConfig(coords.col));
-            }
+   * @param {object} press The press that queued this sort.
+   */ applyHeaderClickSort(press) {
+        if (press.isCtrlPressed) {
+            this.sort(this.getNextSortConfig(press.column, APPEND_COLUMN_CONFIG_STRATEGY));
+        } else {
+            this.sort(this.getColumnNextConfig(press.column));
         }
     }
     constructor(...args){

package/plugins/multiColumnSorting/rootComparator.js

@@ -10,27 +10,34 @@ Object.defineProperty(exports, "rootComparator", {
 });
 const _registry = require("../columnSorting/sortService/registry");
 const _engine = require("../columnSorting/sortService/engine");
+/**
+ * Creates the compare function for a single sorted column. Resolved once per sort run — the
+ * factory result is reused for every comparison, so any per-run caching inside the returned
+ * compare function (e.g. normalized-value memoization) stays effective.
+ *
+ * @param {string} sortingOrder Sort order (`asc` for ascending, `desc` for descending).
+ * @param {object} columnMeta Column meta object.
+ * @returns {Function} The compare function.
+ */ function createColumnCompareFunction(sortingOrder, columnMeta) {
+    const pluginSettings = columnMeta.multiColumnSorting;
+    const compareFunctionFactory = pluginSettings.compareFunctionFactory ? pluginSettings.compareFunctionFactory : (0, _registry.getCompareFunctionFactory)(columnMeta.type);
+    return compareFunctionFactory(sortingOrder, columnMeta, pluginSettings);
+}
 function rootComparator(sortingOrders, columnMetas) {
+    // One compare function per sorted column, created once per sort run, not once per comparison.
+    // Re-invoking the factories inside the comparator would allocate fresh closures ~n*log(n) times
+    // and defeat the per-run value caches the built-in compare functions rely on.
+    const compareFunctions = columnMetas.map((columnMeta, column)=>createColumnCompareFunction(sortingOrders[column], columnMeta));
     return function(rowIndexWithValues, nextRowIndexWithValues) {
-        // We sort array of arrays. Single array is in form [rowIndex, ...values].
-        // We compare just values, stored at second index of array.
-        const [, ...values] = rowIndexWithValues;
-        const [, ...nextValues] = nextRowIndexWithValues;
-        return function getCompareResult(column) {
-            const sortingOrder = sortingOrders[column];
-            const columnMeta = columnMetas[column];
-            const value = values[column];
-            const nextValue = nextValues[column];
-            const pluginSettings = columnMeta.multiColumnSorting;
-            const compareFunctionFactory = pluginSettings.compareFunctionFactory ? pluginSettings.compareFunctionFactory : (0, _registry.getCompareFunctionFactory)(columnMeta.type);
-            const compareResult = compareFunctionFactory(sortingOrder, columnMeta, pluginSettings)(value, nextValue);
-            if (compareResult === _engine.DO_NOT_SWAP) {
-                const nextSortedColumn = column + 1;
-                if (typeof columnMetas[nextSortedColumn] !== 'undefined') {
-                    return getCompareResult(nextSortedColumn);
-                }
+        // We sort array of arrays. Single array is in form [rowIndex, ...values],
+        // so the value of sorted column N is stored at index N + 1. Columns after the first act as
+        // tie-breakers: they are consulted only while the previous columns compare as equal.
+        for(let column = 0; column < compareFunctions.length; column += 1){
+            const compareResult = compareFunctions[column](rowIndexWithValues[column + 1], nextRowIndexWithValues[column + 1]);
+            if (compareResult !== _engine.DO_NOT_SWAP) {
+                return compareResult;
             }
-            return compareResult;
-        }(0);
+        }
+        return _engine.DO_NOT_SWAP;
     };
 }

package/plugins/multiColumnSorting/rootComparator.mjs

@@ -1,5 +1,18 @@
 import { getCompareFunctionFactory } from '../columnSorting/sortService/registry.mjs';
 import { DO_NOT_SWAP } from '../columnSorting/sortService/engine.mjs';
+/**
+ * Creates the compare function for a single sorted column. Resolved once per sort run — the
+ * factory result is reused for every comparison, so any per-run caching inside the returned
+ * compare function (e.g. normalized-value memoization) stays effective.
+ *
+ * @param {string} sortingOrder Sort order (`asc` for ascending, `desc` for descending).
+ * @param {object} columnMeta Column meta object.
+ * @returns {Function} The compare function.
+ */ function createColumnCompareFunction(sortingOrder, columnMeta) {
+    const pluginSettings = columnMeta.multiColumnSorting;
+    const compareFunctionFactory = pluginSettings.compareFunctionFactory ? pluginSettings.compareFunctionFactory : getCompareFunctionFactory(columnMeta.type);
+    return compareFunctionFactory(sortingOrder, columnMeta, pluginSettings);
+}
 /**
  * Sort comparator handled by conventional sort algorithm.
  *
@@ -7,26 +20,20 @@ import { DO_NOT_SWAP } from '../columnSorting/sortService/engine.mjs';
  * @param {Array} columnMetas Column meta objects.
  * @returns {Function}
  */ export function rootComparator(sortingOrders, columnMetas) {
+    // One compare function per sorted column, created once per sort run, not once per comparison.
+    // Re-invoking the factories inside the comparator would allocate fresh closures ~n*log(n) times
+    // and defeat the per-run value caches the built-in compare functions rely on.
+    const compareFunctions = columnMetas.map((columnMeta, column)=>createColumnCompareFunction(sortingOrders[column], columnMeta));
     return function(rowIndexWithValues, nextRowIndexWithValues) {
-        // We sort array of arrays. Single array is in form [rowIndex, ...values].
-        // We compare just values, stored at second index of array.
-        const [, ...values] = rowIndexWithValues;
-        const [, ...nextValues] = nextRowIndexWithValues;
-        return function getCompareResult(column) {
-            const sortingOrder = sortingOrders[column];
-            const columnMeta = columnMetas[column];
-            const value = values[column];
-            const nextValue = nextValues[column];
-            const pluginSettings = columnMeta.multiColumnSorting;
-            const compareFunctionFactory = pluginSettings.compareFunctionFactory ? pluginSettings.compareFunctionFactory : getCompareFunctionFactory(columnMeta.type);
-            const compareResult = compareFunctionFactory(sortingOrder, columnMeta, pluginSettings)(value, nextValue);
-            if (compareResult === DO_NOT_SWAP) {
-                const nextSortedColumn = column + 1;
-                if (typeof columnMetas[nextSortedColumn] !== 'undefined') {
-                    return getCompareResult(nextSortedColumn);
-                }
+        // We sort array of arrays. Single array is in form [rowIndex, ...values],
+        // so the value of sorted column N is stored at index N + 1. Columns after the first act as
+        // tie-breakers: they are consulted only while the previous columns compare as equal.
+        for(let column = 0; column < compareFunctions.length; column += 1){
+            const compareResult = compareFunctions[column](rowIndexWithValues[column + 1], nextRowIndexWithValues[column + 1]);
+            if (compareResult !== DO_NOT_SWAP) {
+                return compareResult;
             }
-            return compareResult;
-        }(0);
+        }
+        return DO_NOT_SWAP;
     };
 }

package/plugins/multipleSelectionHandles/multipleSelectionHandles.d.ts

@@ -9,6 +9,7 @@ export declare const PLUGIN_PRIORITY = 160;
  * @class MultipleSelectionHandles
  */
 export declare class MultipleSelectionHandles extends BasePlugin {
+    #private;
     /**
      * Returns the plugin key used to identify this plugin in Handsontable settings.
      */
@@ -21,10 +22,6 @@ export declare class MultipleSelectionHandles extends BasePlugin {
      * @type {Array}
      */
     dragged: string[];
-    /**
-     * @type {null}
-     */
-    lastSetCell: HTMLElement | null;
     /**
      * @type {object}
      */
@@ -43,6 +40,14 @@ export declare class MultipleSelectionHandles extends BasePlugin {
      * Enable plugin for this Handsontable instance.
      */
     enablePlugin(): void;
+    /**
+     * Disables the plugin and forgets any drag in progress.
+     *
+     * Without the reset, an `updateSettings()` mid-drag would take the listeners away while
+     * `#dragTouches` still reported a drag - and because browsers recycle `Touch.identifier`, a later
+     * unrelated finger handed a stale id would pass `isDraggedBy()` and start scrolling the grid.
+     */
+    disablePlugin(): void;
     /**
      * Bind the touch events.
      *
@@ -62,4 +67,14 @@ export declare class MultipleSelectionHandles extends BasePlugin {
      * @returns {boolean} Dragging state.
      */
     isDragged(): boolean;
+    /**
+     * Checks whether one specific finger is the one holding a handle. Reachable through `getPlugin`
+     * because DragToScroll needs it - `isDragged()` alone would let it arm auto-scroll for any finger
+     * landing anywhere while a drag happens to be running.
+     *
+     * @private
+     * @param {number} identifier The finger's `Touch.identifier`.
+     * @returns {boolean} Whether that finger grabbed a handle.
+     */
+    isDraggedBy(identifier: number): boolean;
 }

package/plugins/multipleSelectionHandles/multipleSelectionHandles.js

@@ -20,10 +20,106 @@ _export(exports, {
     }
 });
 const _element = require("../../helpers/dom/element");
+const _cellCoords = require("../../helpers/dom/cellCoords");
+const _event = require("../../helpers/dom/event");
 const _browser = require("../../helpers/browser");
 const _base = require("../base");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
 const PLUGIN_KEY = 'multipleSelectionHandles';
 const PLUGIN_PRIORITY = 160;
+/**
+ * How far the finger must travel, in pixels, before its position is resolved to a cell again.
+ */ const TOUCH_MOVE_THRESHOLD = 2;
+var /**
+   * Viewport coordinates of the dragging finger. Kept so the drag can carry on after DragToScroll
+   * moves the viewport, when no further `touchmove` arrives.
+   */ _lastTouchPosition = /*#__PURE__*/ new WeakMap(), /**
+   * The cell the selection was last extended to. Guards against redundant `setRangeEnd` calls while
+   * the finger moves within one cell.
+   */ _lastTargetCoords = /*#__PURE__*/ new WeakMap(), /**
+   * Which handle each finger currently holding one grabbed, keyed by `Touch.identifier`. Lets a
+   * touch event be matched to the finger it is about, rather than to whatever else is on the screen.
+   */ _dragTouches = /*#__PURE__*/ new WeakMap(), /**
+   * Forgets every finger and the range the gesture started from.
+   */ _resetDrag = /*#__PURE__*/ new WeakSet(), /**
+   * Reads where the finger driving the drag currently is.
+   *
+   * Follows the fingers that actually grabbed a handle, by identifier. Reading `touches[0]` instead
+   * would follow whichever finger touched the screen first, so a thumb already resting on the grid
+   * when the handle was grabbed would drive the selection.
+   *
+   * @param {Event} event The `touchmove` event.
+   * @returns {object|null} The finger's position as `{clientX, clientY}`, or `null` when no
+   * handle-holding finger appears in the event.
+   */ _getDragTouchPoint = /*#__PURE__*/ new WeakSet(), /**
+   * Carries the drag on after DragToScroll moves the viewport.
+   *
+   * A finger held still past the grid edge produces no further `touchmove`, so without this the
+   * selection would stop growing at the last cell that was on screen when the finger got there.
+   *
+   * `#extendSelection` can itself scroll its target into view, which fires `afterScroll` again. That
+   * does not run away: the target is resolved against the CURRENT viewport and then de-duplicated on
+   * coordinates, so it reaches a fixed point after one step. Measured with `dragToScroll: false`,
+   * where nothing suppresses the scroll-into-view: it stops after one row and stays there.
+   */ _onAfterScroll = /*#__PURE__*/ new WeakMap(), /**
+   * Extends the selected range to the cell under the given viewport position.
+   *
+   * The position is resolved with `getCellCoordsFromMousePosition`, which clamps it to the viewport
+   * and returns the nearest cell. That is what lets a finger dragged past the grid edge keep
+   * extending the selection while DragToScroll scrolls the viewport underneath it.
+   *
+   * @param {number} clientX The finger's viewport X coordinate.
+   * @param {number} clientY The finger's viewport Y coordinate.
+   */ _extendSelection = /*#__PURE__*/ new WeakSet();
 class MultipleSelectionHandles extends _base.BasePlugin {
     /**
    * Returns the plugin key used to identify this plugin in Handsontable settings.
@@ -48,10 +144,21 @@ class MultipleSelectionHandles extends _base.BasePlugin {
         if (this.enabled) {
             return;
         }
+        this.addHook('afterScroll', _class_private_field_get(this, _onAfterScroll));
         this.registerListeners();
         super.enablePlugin();
     }
     /**
+   * Disables the plugin and forgets any drag in progress.
+   *
+   * Without the reset, an `updateSettings()` mid-drag would take the listeners away while
+   * `#dragTouches` still reported a drag - and because browsers recycle `Touch.identifier`, a later
+   * unrelated finger handed a stale id would pass `isDraggedBy()` and start scrolling the grid.
+   */ disablePlugin() {
+        _class_private_method_get(this, _resetDrag, resetDrag).call(this);
+        super.disablePlugin();
+    }
+    /**
    * Bind the touch events.
    *
    * @private
@@ -62,6 +169,8 @@ class MultipleSelectionHandles extends _base.BasePlugin {
      * @param {string} query Query for the position.
      * @returns {boolean}
      */ const removeFromDragged = (query)=>{
+            _class_private_field_set(this, _lastTouchPosition, null);
+            _class_private_field_set(this, _lastTargetCoords, null);
             if (this.dragged.length === 1) {
                 // clear array
                 this.dragged.splice(0, this.dragged.length);
@@ -70,10 +179,54 @@ class MultipleSelectionHandles extends _base.BasePlugin {
             const entryPosition = this.dragged.indexOf(query);
             if (entryPosition === -1) {
                 return false;
-            } else if (entryPosition === 0) {
-                this.dragged = this.dragged.slice(0, 1);
-            } else if (entryPosition === 1) {
-                this.dragged = this.dragged.slice(-1);
+            }
+            // Both former branches sliced the array so that the handle being removed was the one KEPT, so
+            // with two handles held the survivor drove the rest of the drag through `this.dragged[0]` and
+            // moved the wrong corner of the range.
+            this.dragged.splice(entryPosition, 1);
+        };
+        /**
+     * Starts tracking one finger's grip on a handle. Refuses when the finger carries no identifier,
+     * because an untracked finger could never be released - the drag would look stuck for good.
+     *
+     * @private
+     * @param {Event} event The `touchstart` event.
+     * @param {string} handle Which handle the finger grabbed.
+     * @returns {boolean} `true` when the drag started.
+     */ const beginDrag = (event, handle)=>{
+            const touch = (0, _event.getFirstChangedTouch)(event);
+            if (touch === null) {
+                return false;
+            }
+            _class_private_field_get(this, _dragTouches).set(touch.identifier, handle);
+            this.dragged.push(handle);
+            return true;
+        };
+        /**
+     * Ends the part of the drag owned by every finger that has left the screen, and leaves the rest
+     * of the gesture running. `touchend` and `touchcancel` both fire once per finger, so neither is
+     * a statement about the gesture as a whole.
+     *
+     * @private
+     * @param {Event} event The `touchend` or `touchcancel` event.
+     */ const releaseLiftedTouches = (event)=>{
+            let released = false;
+            for (const [identifier, handle] of [
+                ..._class_private_field_get(this, _dragTouches)
+            ]){
+                if ((0, _event.getTouchPointById)(event, identifier) === null) {
+                    _class_private_field_get(this, _dragTouches).delete(identifier);
+                    removeFromDragged(handle);
+                    released = true;
+                }
+            }
+            if (!released) {
+                return;
+            }
+            _class_private_field_set(this, _lastTouchPosition, null);
+            _class_private_field_set(this, _lastTargetCoords, null);
+            if (this.dragged.length === 0) {
+                this.touchStartRange = undefined;
             }
         };
         this.eventManager.addEventListener(rootElement, 'touchstart', (event)=>{
@@ -84,7 +237,9 @@ class MultipleSelectionHandles extends _base.BasePlugin {
                 if (!selectedRange) {
                     return false;
                 }
-                this.dragged.push('top');
+                if (!beginDrag(event, 'top')) {
+                    return false;
+                }
                 this.touchStartRange = {
                     width: selectedRange.getWidth(),
                     height: selectedRange.getHeight(),
@@ -97,7 +252,9 @@ class MultipleSelectionHandles extends _base.BasePlugin {
                 if (!selectedRange) {
                     return false;
                 }
-                this.dragged.push('bottom');
+                if (!beginDrag(event, 'bottom')) {
+                    return false;
+                }
                 this.touchStartRange = {
                     width: selectedRange.getWidth(),
                     height: selectedRange.getHeight(),
@@ -107,61 +264,40 @@ class MultipleSelectionHandles extends _base.BasePlugin {
                 return false;
             }
         });
-        this.eventManager.addEventListener(rootElement, 'touchend', (event)=>{
-            const target = (0, _element.eventTargetEl)(event);
-            if ((0, _element.hasClass)(target, 'topSelectionHandle-HitArea')) {
-                removeFromDragged('top');
-                this.touchStartRange = undefined;
-                event.preventDefault();
-                return false;
-            } else if ((0, _element.hasClass)(target, 'bottomSelectionHandle-HitArea')) {
-                removeFromDragged('bottom');
-                this.touchStartRange = undefined;
-                event.preventDefault();
-                return false;
-            }
-        });
+        // A cancelled gesture never reaches `touchend`, and browsers cancel often on a real phone - a
+        // system gesture, an incoming call, the browser claiming the touch for scrolling. Both events are
+        // handled the same way, because both answer the same question: which fingers are gone?
+        for (const eventName of [
+            'touchend',
+            'touchcancel'
+        ]){
+            this.eventManager.addEventListener(rootElement, eventName, (event)=>{
+                const target = (0, _element.eventTargetEl)(event);
+                releaseLiftedTouches(event);
+                if ((0, _element.hasClass)(target, 'topSelectionHandle-HitArea') || (0, _element.hasClass)(target, 'bottomSelectionHandle-HitArea')) {
+                    event.preventDefault();
+                    return false;
+                }
+            });
+        }
         this.eventManager.addEventListener(rootElement, 'touchmove', (event)=>{
-            const { rootDocument } = this.hot;
-            let targetCoords;
-            let selectedRange;
-            let rangeWidth;
-            let rangeHeight;
-            let rangeDirection;
-            let newRangeCoords;
             if (this.dragged.length === 0) {
                 return;
             }
-            const te = event.touches[0];
-            const endTarget = rootDocument.elementFromPoint(te.clientX, te.clientY);
-            if (!endTarget || endTarget === this.lastSetCell) {
+            const point = _class_private_method_get(this, _getDragTouchPoint, getDragTouchPoint).call(this, event);
+            if (point === null) {
                 return;
             }
-            if (endTarget.nodeName === 'TD' || endTarget.nodeName === 'TH') {
-                targetCoords = this.hot.getCoords(endTarget);
-                if (!targetCoords) {
-                    return;
-                }
-                if (targetCoords.col === -1) {
-                    targetCoords.col = 0;
-                }
-                selectedRange = this.hot.getSelectedRangeActive();
-                if (!selectedRange) {
-                    return;
-                }
-                rangeWidth = selectedRange.getWidth();
-                rangeHeight = selectedRange.getHeight();
-                rangeDirection = selectedRange.getDirection();
-                if (rangeWidth === 1 && rangeHeight === 1) {
-                    this.hot.selection.setRangeEnd(targetCoords);
-                }
-                newRangeCoords = this.getCurrentRangeCoords(selectedRange, targetCoords, this.touchStartRange.direction, rangeDirection, this.dragged[0]);
-                if (newRangeCoords.start !== null) {
-                    this.hot.selection.setRangeStart(newRangeCoords.start);
-                }
-                this.hot.selection.setRangeEnd(newRangeCoords.end);
-                this.lastSetCell = endTarget;
+            // Resolving a position walks the visible cells reading their geometry, and a phone can send
+            // 120 touchmove/s. Skip that while the finger has barely moved - the cell cannot have changed.
+            // The threshold lives here, NOT in `#extendSelection`: `#onAfterScroll` calls it with an
+            // unchanged position on purpose, because there it is the viewport that moved.
+            if (_class_private_field_get(this, _lastTouchPosition) !== null && Math.abs(point.clientX - _class_private_field_get(this, _lastTouchPosition).clientX) < TOUCH_MOVE_THRESHOLD && Math.abs(point.clientY - _class_private_field_get(this, _lastTouchPosition).clientY) < TOUCH_MOVE_THRESHOLD) {
+                event.preventDefault();
+                return;
             }
+            _class_private_field_set(this, _lastTouchPosition, point);
+            _class_private_method_get(this, _extendSelection, extendSelection).call(this, point.clientX, point.clientY);
             event.preventDefault();
         });
     }
@@ -334,11 +470,90 @@ class MultipleSelectionHandles extends _base.BasePlugin {
    */ isDragged() {
         return this.dragged.length > 0;
     }
+    /**
+   * Checks whether one specific finger is the one holding a handle. Reachable through `getPlugin`
+   * because DragToScroll needs it - `isDragged()` alone would let it arm auto-scroll for any finger
+   * landing anywhere while a drag happens to be running.
+   *
+   * @private
+   * @param {number} identifier The finger's `Touch.identifier`.
+   * @returns {boolean} Whether that finger grabbed a handle.
+   */ isDraggedBy(identifier) {
+        return _class_private_field_get(this, _dragTouches).has(identifier);
+    }
     constructor(...args){
-        super(...args), /**
+        super(...args), _class_private_method_init(this, _resetDrag), _class_private_method_init(this, _getDragTouchPoint), _class_private_method_init(this, _extendSelection), _class_private_field_init(this, _lastTouchPosition, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _lastTargetCoords, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _dragTouches, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterScroll, {
+            writable: true,
+            value: void 0
+        }), /**
    * @type {Array}
-   */ this.dragged = [], /**
-   * @type {null}
-   */ this.lastSetCell = null;
+   */ this.dragged = [], _class_private_field_set(this, _lastTouchPosition, null), _class_private_field_set(this, _lastTargetCoords, null), _class_private_field_set(this, _dragTouches, new Map()), _class_private_field_set(this, _onAfterScroll, ()=>{
+            if (this.dragged.length === 0 || _class_private_field_get(this, _lastTouchPosition) === null) {
+                return;
+            }
+            const { clientX, clientY } = _class_private_field_get(this, _lastTouchPosition);
+            _class_private_method_get(this, _extendSelection, extendSelection).call(this, clientX, clientY);
+        });
+    }
+}
+function resetDrag() {
+    this.dragged.splice(0, this.dragged.length);
+    _class_private_field_get(this, _dragTouches).clear();
+    this.touchStartRange = undefined;
+    _class_private_field_set(this, _lastTouchPosition, null);
+    _class_private_field_set(this, _lastTargetCoords, null);
+}
+function getDragTouchPoint(event) {
+    for (const identifier of _class_private_field_get(this, _dragTouches).keys()){
+        const point = (0, _event.getTouchPointById)(event, identifier);
+        if (point !== null) {
+            return point;
+        }
+    }
+    return null;
+}
+function extendSelection(clientX, clientY) {
+    const selectedRange = this.hot.getSelectedRangeActive();
+    if (!selectedRange || this.touchStartRange === undefined) {
+        return;
+    }
+    const targetCoords = (0, _cellCoords.getCellCoordsFromMousePosition)(this.hot, clientX, clientY);
+    // `getCellCoordsFromMousePosition` clamps into the body, so a position over a header already
+    // resolves to a real cell - there is no -1 to normalize. The floor only guards the helper's
+    // empty-grid fallback, where `countCols() - 1` / `countRows() - 1` would be -1.
+    const targetRow = Math.max(targetCoords.row ?? 0, 0);
+    const targetCol = Math.max(targetCoords.col ?? 0, 0);
+    // Compare coordinates rather than the resolved cell element: Walkontable reuses the same `td`
+    // elements across scrolls, so the element under a stationary finger stays identical while the
+    // cell it represents changes on every scroll tick.
+    if (_class_private_field_get(this, _lastTargetCoords)?.row === targetRow && _class_private_field_get(this, _lastTargetCoords)?.col === targetCol) {
+        return;
+    }
+    _class_private_field_set(this, _lastTargetCoords, {
+        row: targetRow,
+        col: targetCol
+    });
+    const target = this.hot._createCellCoords(targetRow, targetCol);
+    // Read before the `setRangeEnd` below, which mutates the range: the direction that matters is
+    // the one the range had on entry.
+    const rangeDirection = selectedRange.getDirection();
+    if (selectedRange.getWidth() === 1 && selectedRange.getHeight() === 1) {
+        this.hot.selection.setRangeEnd(target);
+    }
+    const newRangeCoords = this.getCurrentRangeCoords(selectedRange, target, this.touchStartRange.direction, rangeDirection, this.dragged[0]);
+    if (newRangeCoords.start !== null) {
+        this.hot.selection.setRangeStart(newRangeCoords.start);
+    }
+    if (newRangeCoords.end !== null) {
+        this.hot.selection.setRangeEnd(newRangeCoords.end);
     }
 }