handsontable 18.0.0 → 18.1.0-rc7

package/plugins/formulas/hyperlinkUrl.d.mts

@@ -0,0 +1 @@
+export * from './hyperlinkUrl.js';

package/plugins/formulas/hyperlinkUrl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolves the URL of a `HYPERLINK` cell against the host document, and refuses anything that is not
+ * a navigable link.
+ *
+ * The URL is parsed instead of pattern-matched, so obfuscations that survive a string comparison
+ * (`JaVaScRiPt:`, `java\tscript:`, leading whitespace) are normalized before the protocol is read.
+ *
+ * @param {string} rawUrl The URL as reported by the formula engine.
+ * @param {string} baseUrl The document URL that relative URLs are resolved against.
+ * @returns {string|null} The resolved absolute URL, or `null` when the cell must not become a link.
+ */
+export declare function resolveHyperlinkUrl(rawUrl: string, baseUrl: string): string | null;

package/plugins/formulas/hyperlinkUrl.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveHyperlinkUrl", {
+    enumerable: true,
+    get: function() {
+        return resolveHyperlinkUrl;
+    }
+});
+/**
+ * URL schemes a `HYPERLINK` cell may link to. Everything outside this list is refused, which is what
+ * keeps `javascript:`, `data:` and `vbscript:` payloads out of the anchor's `href`. Default
+ * sanitization is a pass-through in this codebase, so the guard cannot be delegated to a sanitizer.
+ */ const ALLOWED_PROTOCOLS = new Set([
+    'http:',
+    'https:',
+    'mailto:',
+    'tel:'
+]);
+function resolveHyperlinkUrl(rawUrl, baseUrl) {
+    if (typeof rawUrl !== 'string' || rawUrl.trim() === '') {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(rawUrl, baseUrl);
+    } catch (error) {
+        return null;
+    }
+    return ALLOWED_PROTOCOLS.has(url.protocol) ? url.href : null;
+}

package/plugins/formulas/hyperlinkUrl.mjs

@@ -0,0 +1,32 @@
+/**
+ * URL schemes a `HYPERLINK` cell may link to. Everything outside this list is refused, which is what
+ * keeps `javascript:`, `data:` and `vbscript:` payloads out of the anchor's `href`. Default
+ * sanitization is a pass-through in this codebase, so the guard cannot be delegated to a sanitizer.
+ */ const ALLOWED_PROTOCOLS = new Set([
+    'http:',
+    'https:',
+    'mailto:',
+    'tel:'
+]);
+/**
+ * Resolves the URL of a `HYPERLINK` cell against the host document, and refuses anything that is not
+ * a navigable link.
+ *
+ * The URL is parsed instead of pattern-matched, so obfuscations that survive a string comparison
+ * (`JaVaScRiPt:`, `java\tscript:`, leading whitespace) are normalized before the protocol is read.
+ *
+ * @param {string} rawUrl The URL as reported by the formula engine.
+ * @param {string} baseUrl The document URL that relative URLs are resolved against.
+ * @returns {string|null} The resolved absolute URL, or `null` when the cell must not become a link.
+ */ export function resolveHyperlinkUrl(rawUrl, baseUrl) {
+    if (typeof rawUrl !== 'string' || rawUrl.trim() === '') {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(rawUrl, baseUrl);
+    } catch (error) {
+        return null;
+    }
+    return ALLOWED_PROTOCOLS.has(url.protocol) ? url.href : null;
+}

package/plugins/formulas/indexSyncer/axisSyncer.d.ts

@@ -4,6 +4,7 @@ interface AxisIndexMapper {
     getIndexesSequence(): number[];
     getNotTrimmedIndexes(): number[];
     getNumberOfIndexes(): number;
+    addLocalHook(key: string, callback: Function): unknown;
 }
 interface ParentIndexSyncer {
     getEngine(): HyperFormulaEngine | null;

package/plugins/formulas/indexSyncer/axisSyncer.js

@@ -81,6 +81,18 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
    * @private
    * @type {Array<number>}
    */ _removedIndexes = /*#__PURE__*/ new WeakMap(), /**
+   * Cached translation tables between physical, visual, and HF indexes. Built lazily on the first
+   * translation call and invalidated whenever the indexes sequence or the trimmed indexes change.
+   * Keeping the tables makes both translation methods O(1) per call — they are called for every
+   * rendered cell, so a per-call sequence scan would scale with the dataset size.
+   *
+   * @private
+   * @type {HfTranslationCache|null}
+   */ _translationCache = /*#__PURE__*/ new WeakMap(), /**
+   * Gets the cached translation tables between physical, visual, and HF indexes, building them when needed.
+   *
+   * @returns {HfTranslationCache}
+   */ _getTranslationCache = /*#__PURE__*/ new WeakSet(), /**
    * Synchronizes the initial axis order with HF engine. When the IndexMapper's sequence is non-identity at
    * setup time (for example, an initial `manualColumnMove` or `manualRowMove` configuration), HF needs to
    * reorder its data so that HF visual order matches HOT visual order. Without this sync, downstream code
@@ -123,12 +135,13 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
    * @param {number} visualIndex Visual index.
    * @returns {number}
    */ getHfIndexFromVisualIndex(visualIndex) {
-        const indexesSequence = _class_private_field_get(this, _indexMapper).getIndexesSequence();
-        const notTrimmedIndexes = _class_private_field_get(this, _indexMapper).getNotTrimmedIndexes();
-        // Optimization:
-        // notTrimmedIndexes is a subset of indexesSequence,
-        // so for every x indexesSequence.indexOf(x) is always >= notTrimmedIndexes.indexOf(x)
-        return indexesSequence.indexOf(notTrimmedIndexes[visualIndex], visualIndex);
+        const physicalIndex = _class_private_field_get(this, _indexMapper).getNotTrimmedIndexes()[visualIndex];
+        if (physicalIndex === undefined) {
+            return -1;
+        }
+        // The `?? -1` covers a mid-batch state in which the mapper's not-trimmed cache still holds a
+        // physical index that is no longer part of the sequence.
+        return _class_private_method_get(this, _getTranslationCache, getTranslationCache).call(this).hfIndexOfPhysical[physicalIndex] ?? -1;
     }
     /**
    * Gets corresponding visual index for a HyperFormula index. Inverse of {@link getHfIndexFromVisualIndex}.
@@ -137,13 +150,12 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
    * @param {number} hfIndex HyperFormula index.
    * @returns {number}
    */ getVisualIndexFromHfIndex(hfIndex) {
-        const indexesSequence = _class_private_field_get(this, _indexMapper).getIndexesSequence();
-        const notTrimmedIndexes = _class_private_field_get(this, _indexMapper).getNotTrimmedIndexes();
-        const physicalIndex = indexesSequence[hfIndex];
+        const { physicalIndexOfHf, visualIndexOfPhysical } = _class_private_method_get(this, _getTranslationCache, getTranslationCache).call(this);
+        const physicalIndex = physicalIndexOfHf[hfIndex];
         if (physicalIndex === undefined) {
             return -1;
         }
-        return notTrimmedIndexes.indexOf(physicalIndex);
+        return visualIndexOfPhysical[physicalIndex];
     }
     /**
    * Synchronizes moves done on HOT to HF engine (based on previously calculated positions).
@@ -212,7 +224,13 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
             }
             const newSequence = _class_private_field_get(this, _indexMapper).getIndexesSequence();
             if (source === 'update' && newSequence.length > 0) {
-                const relativeTransformation = _class_private_field_get(this, _indexesSequence).map((index)=>newSequence.indexOf(index));
+                // One-pass inverse lookup instead of `newSequence.indexOf` per element, which would make
+                // every sort/unsort quadratic in the number of rows or columns.
+                const positionOfPhysical = new Array(newSequence.length);
+                for(let position = 0; position < newSequence.length; position += 1){
+                    positionOfPhysical[newSequence[position]] = position;
+                }
+                const relativeTransformation = _class_private_field_get(this, _indexesSequence).map((index)=>positionOfPhysical[index] ?? -1);
                 const sheetDimensions = _class_private_field_get(this, _indexSyncer).getEngine().getSheetDimensions(_class_private_field_get(this, _indexSyncer).getSheetId());
                 let sizeForAxis;
                 if (_class_private_field_get(this, _axis) === 'row') {
@@ -241,6 +259,7 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
     /**
    * Initializes the axis syncer for the given axis with the corresponding index mapper and parent index syncer references.
    */ constructor(axis, indexMapper, indexSyncer){
+        _class_private_method_init(this, _getTranslationCache);
         _class_private_method_init(this, _syncInitialOrder);
         /**
    * The axis for which the actions are performed.
@@ -285,14 +304,50 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _translationCache, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_set(this, _indexesSequence, []);
         _class_private_field_set(this, _movedIndexes, []);
         _class_private_field_set(this, _removedIndexes, []);
+        _class_private_field_set(this, _translationCache, null);
         _class_private_field_set(this, _axis, axis);
         _class_private_field_set(this, _indexMapper, indexMapper);
         _class_private_field_set(this, _indexSyncer, indexSyncer);
+        // The sequence hook fires synchronously on every sequence mutation (also mid-batch), the
+        // `cacheUpdated` hook fires when the mapper rebuilds its own `notTrimmedIndexes` cache — the
+        // same moment from which the translation methods would read the new trimming state.
+        _class_private_field_get(this, _indexMapper).addLocalHook('indexesSequenceChange', ()=>{
+            _class_private_field_set(this, _translationCache, null);
+        });
+        _class_private_field_get(this, _indexMapper).addLocalHook('cacheUpdated', (changes)=>{
+            if (changes.trimmedIndexesChanged) {
+                _class_private_field_set(this, _translationCache, null);
+            }
+        });
     }
 }
+function getTranslationCache() {
+    if (_class_private_field_get(this, _translationCache) === null) {
+        const physicalIndexOfHf = _class_private_field_get(this, _indexMapper).getIndexesSequence();
+        const notTrimmedIndexes = _class_private_field_get(this, _indexMapper).getNotTrimmedIndexes();
+        const hfIndexOfPhysical = new Array(physicalIndexOfHf.length);
+        const visualIndexOfPhysical = new Array(physicalIndexOfHf.length).fill(-1);
+        for(let hfIndex = 0; hfIndex < physicalIndexOfHf.length; hfIndex += 1){
+            hfIndexOfPhysical[physicalIndexOfHf[hfIndex]] = hfIndex;
+        }
+        for(let visualIndex = 0; visualIndex < notTrimmedIndexes.length; visualIndex += 1){
+            visualIndexOfPhysical[notTrimmedIndexes[visualIndex]] = visualIndex;
+        }
+        _class_private_field_set(this, _translationCache, {
+            physicalIndexOfHf,
+            hfIndexOfPhysical,
+            visualIndexOfPhysical
+        });
+    }
+    return _class_private_field_get(this, _translationCache);
+}
 function syncInitialOrder() {
     const sequence = _class_private_field_get(this, _indexMapper).getIndexesSequence();
     const isIdentity = sequence.every((value, index)=>value === index);
@@ -310,10 +365,12 @@ function syncInitialOrder() {
     const sizeForAxis = _class_private_field_get(this, _axis) === 'row' ? sheetDimensions.height : sheetDimensions.width;
     // HF currently holds data in physical order ([0..n-1] identity). The transformation tells HF where each
     // currently-held element should move to, so that HF's visual order matches HOT's visual order. For each
-    // current position `i`, the target position is the visual index of physical `i`, i.e. `sequence.indexOf(i)`.
-    const transformation = Array.from({
-        length: sequence.length
-    }, (_, i)=>sequence.indexOf(i));
+    // current position `i`, the target position is the visual index of physical `i` — that is, the inverse
+    // permutation of the sequence, built in one pass.
+    const transformation = new Array(sequence.length);
+    for(let position = 0; position < sequence.length; position += 1){
+        transformation[sequence[position]] = position;
+    }
     for(let i = transformation.length; i < sizeForAxis; i += 1){
         transformation.push(i);
     }

package/plugins/formulas/indexSyncer/axisSyncer.mjs

@@ -71,6 +71,18 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
    * @private
    * @type {Array<number>}
    */ _removedIndexes = /*#__PURE__*/ new WeakMap(), /**
+   * Cached translation tables between physical, visual, and HF indexes. Built lazily on the first
+   * translation call and invalidated whenever the indexes sequence or the trimmed indexes change.
+   * Keeping the tables makes both translation methods O(1) per call — they are called for every
+   * rendered cell, so a per-call sequence scan would scale with the dataset size.
+   *
+   * @private
+   * @type {HfTranslationCache|null}
+   */ _translationCache = /*#__PURE__*/ new WeakMap(), /**
+   * Gets the cached translation tables between physical, visual, and HF indexes, building them when needed.
+   *
+   * @returns {HfTranslationCache}
+   */ _getTranslationCache = /*#__PURE__*/ new WeakSet(), /**
    * Synchronizes the initial axis order with HF engine. When the IndexMapper's sequence is non-identity at
    * setup time (for example, an initial `manualColumnMove` or `manualRowMove` configuration), HF needs to
    * reorder its data so that HF visual order matches HOT visual order. Without this sync, downstream code
@@ -113,12 +125,13 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
    * @param {number} visualIndex Visual index.
    * @returns {number}
    */ getHfIndexFromVisualIndex(visualIndex) {
-        const indexesSequence = _class_private_field_get(this, _indexMapper).getIndexesSequence();
-        const notTrimmedIndexes = _class_private_field_get(this, _indexMapper).getNotTrimmedIndexes();
-        // Optimization:
-        // notTrimmedIndexes is a subset of indexesSequence,
-        // so for every x indexesSequence.indexOf(x) is always >= notTrimmedIndexes.indexOf(x)
-        return indexesSequence.indexOf(notTrimmedIndexes[visualIndex], visualIndex);
+        const physicalIndex = _class_private_field_get(this, _indexMapper).getNotTrimmedIndexes()[visualIndex];
+        if (physicalIndex === undefined) {
+            return -1;
+        }
+        // The `?? -1` covers a mid-batch state in which the mapper's not-trimmed cache still holds a
+        // physical index that is no longer part of the sequence.
+        return _class_private_method_get(this, _getTranslationCache, getTranslationCache).call(this).hfIndexOfPhysical[physicalIndex] ?? -1;
     }
     /**
    * Gets corresponding visual index for a HyperFormula index. Inverse of {@link getHfIndexFromVisualIndex}.
@@ -127,13 +140,12 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
    * @param {number} hfIndex HyperFormula index.
    * @returns {number}
    */ getVisualIndexFromHfIndex(hfIndex) {
-        const indexesSequence = _class_private_field_get(this, _indexMapper).getIndexesSequence();
-        const notTrimmedIndexes = _class_private_field_get(this, _indexMapper).getNotTrimmedIndexes();
-        const physicalIndex = indexesSequence[hfIndex];
+        const { physicalIndexOfHf, visualIndexOfPhysical } = _class_private_method_get(this, _getTranslationCache, getTranslationCache).call(this);
+        const physicalIndex = physicalIndexOfHf[hfIndex];
         if (physicalIndex === undefined) {
             return -1;
         }
-        return notTrimmedIndexes.indexOf(physicalIndex);
+        return visualIndexOfPhysical[physicalIndex];
     }
     /**
    * Synchronizes moves done on HOT to HF engine (based on previously calculated positions).
@@ -202,7 +214,13 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
             }
             const newSequence = _class_private_field_get(this, _indexMapper).getIndexesSequence();
             if (source === 'update' && newSequence.length > 0) {
-                const relativeTransformation = _class_private_field_get(this, _indexesSequence).map((index)=>newSequence.indexOf(index));
+                // One-pass inverse lookup instead of `newSequence.indexOf` per element, which would make
+                // every sort/unsort quadratic in the number of rows or columns.
+                const positionOfPhysical = new Array(newSequence.length);
+                for(let position = 0; position < newSequence.length; position += 1){
+                    positionOfPhysical[newSequence[position]] = position;
+                }
+                const relativeTransformation = _class_private_field_get(this, _indexesSequence).map((index)=>positionOfPhysical[index] ?? -1);
                 const sheetDimensions = _class_private_field_get(this, _indexSyncer).getEngine().getSheetDimensions(_class_private_field_get(this, _indexSyncer).getSheetId());
                 let sizeForAxis;
                 if (_class_private_field_get(this, _axis) === 'row') {
@@ -231,6 +249,7 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
     /**
    * Initializes the axis syncer for the given axis with the corresponding index mapper and parent index syncer references.
    */ constructor(axis, indexMapper, indexSyncer){
+        _class_private_method_init(this, _getTranslationCache);
         _class_private_method_init(this, _syncInitialOrder);
         /**
    * The axis for which the actions are performed.
@@ -275,14 +294,50 @@ var _axis = /*#__PURE__*/ new WeakMap(), _indexMapper = /*#__PURE__*/ new WeakMa
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _translationCache, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_set(this, _indexesSequence, []);
         _class_private_field_set(this, _movedIndexes, []);
         _class_private_field_set(this, _removedIndexes, []);
+        _class_private_field_set(this, _translationCache, null);
         _class_private_field_set(this, _axis, axis);
         _class_private_field_set(this, _indexMapper, indexMapper);
         _class_private_field_set(this, _indexSyncer, indexSyncer);
+        // The sequence hook fires synchronously on every sequence mutation (also mid-batch), the
+        // `cacheUpdated` hook fires when the mapper rebuilds its own `notTrimmedIndexes` cache — the
+        // same moment from which the translation methods would read the new trimming state.
+        _class_private_field_get(this, _indexMapper).addLocalHook('indexesSequenceChange', ()=>{
+            _class_private_field_set(this, _translationCache, null);
+        });
+        _class_private_field_get(this, _indexMapper).addLocalHook('cacheUpdated', (changes)=>{
+            if (changes.trimmedIndexesChanged) {
+                _class_private_field_set(this, _translationCache, null);
+            }
+        });
     }
 }
+function getTranslationCache() {
+    if (_class_private_field_get(this, _translationCache) === null) {
+        const physicalIndexOfHf = _class_private_field_get(this, _indexMapper).getIndexesSequence();
+        const notTrimmedIndexes = _class_private_field_get(this, _indexMapper).getNotTrimmedIndexes();
+        const hfIndexOfPhysical = new Array(physicalIndexOfHf.length);
+        const visualIndexOfPhysical = new Array(physicalIndexOfHf.length).fill(-1);
+        for(let hfIndex = 0; hfIndex < physicalIndexOfHf.length; hfIndex += 1){
+            hfIndexOfPhysical[physicalIndexOfHf[hfIndex]] = hfIndex;
+        }
+        for(let visualIndex = 0; visualIndex < notTrimmedIndexes.length; visualIndex += 1){
+            visualIndexOfPhysical[notTrimmedIndexes[visualIndex]] = visualIndex;
+        }
+        _class_private_field_set(this, _translationCache, {
+            physicalIndexOfHf,
+            hfIndexOfPhysical,
+            visualIndexOfPhysical
+        });
+    }
+    return _class_private_field_get(this, _translationCache);
+}
 function syncInitialOrder() {
     const sequence = _class_private_field_get(this, _indexMapper).getIndexesSequence();
     const isIdentity = sequence.every((value, index)=>value === index);
@@ -300,10 +355,12 @@ function syncInitialOrder() {
     const sizeForAxis = _class_private_field_get(this, _axis) === 'row' ? sheetDimensions.height : sheetDimensions.width;
     // HF currently holds data in physical order ([0..n-1] identity). The transformation tells HF where each
     // currently-held element should move to, so that HF's visual order matches HOT's visual order. For each
-    // current position `i`, the target position is the visual index of physical `i`, i.e. `sequence.indexOf(i)`.
-    const transformation = Array.from({
-        length: sequence.length
-    }, (_, i)=>sequence.indexOf(i));
+    // current position `i`, the target position is the visual index of physical `i` — that is, the inverse
+    // permutation of the sequence, built in one pass.
+    const transformation = new Array(sequence.length);
+    for(let position = 0; position < sequence.length; position += 1){
+        transformation[sequence[position]] = position;
+    }
     for(let i = transformation.length; i < sizeForAxis; i += 1){
         transformation.push(i);
     }

package/plugins/formulas/utils.d.ts

@@ -65,6 +65,15 @@ export declare function getTimeFromHfTimeFraction(numericTime: number): string;
  * @returns {string}
  */
 export declare function getDateFromExcelDate(numericDate: unknown): string;
+/**
+ * Coalesces a list of indexes into an ascending list of contiguous `[startIndex, amount]` spans.
+ * For example, `[5, 1, 2, 3, 9]` becomes `[[1, 3], [5, 1], [9, 1]]`. The input order does not
+ * matter and duplicate indexes are counted once.
+ *
+ * @param {number[]} indexes List of indexes to coalesce.
+ * @returns {Array<Array<number>>} Ascending list of `[startIndex, amount]` spans.
+ */
+export declare function coalesceIndexesToSpans(indexes: number[]): [number, number][];
 /**
  * Converts a Handsontable cell value to a value accepted by HyperFormula.
  * HyperFormula doesn't accept arrays as direct cell values, so they are converted to a

package/plugins/formulas/utils.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get coalesceIndexesToSpans () {
+        return coalesceIndexesToSpans;
+    },
     get getDateFromExcelDate () {
         return getDateFromExcelDate;
     },
@@ -83,6 +86,24 @@ function getDateFromExcelDate(numericDate) {
     const day = String(d.getUTCDate()).padStart(2, '0');
     return `${year}-${month}-${day}`;
 }
+function coalesceIndexesToSpans(indexes) {
+    const sortedIndexes = [
+        ...indexes
+    ].sort((a, b)=>a - b);
+    const spans = [];
+    sortedIndexes.forEach((index)=>{
+        const lastSpan = spans[spans.length - 1];
+        if (lastSpan === undefined || index > lastSpan[0] + lastSpan[1]) {
+            spans.push([
+                index,
+                1
+            ]);
+        } else if (index === lastSpan[0] + lastSpan[1]) {
+            lastSpan[1] += 1;
+        }
+    });
+    return spans;
+}
 function normalizeValueForFormulaEngine(value) {
     if (Array.isArray(value)) {
         return (0, _valueGetter.valueGetter)(value);

package/plugins/formulas/utils.mjs

@@ -90,6 +90,31 @@ import { valueGetter as multiSelectValueGetter } from '../../cellTypes/multiSele
     const day = String(d.getUTCDate()).padStart(2, '0');
     return `${year}-${month}-${day}`;
 }
+/**
+ * Coalesces a list of indexes into an ascending list of contiguous `[startIndex, amount]` spans.
+ * For example, `[5, 1, 2, 3, 9]` becomes `[[1, 3], [5, 1], [9, 1]]`. The input order does not
+ * matter and duplicate indexes are counted once.
+ *
+ * @param {number[]} indexes List of indexes to coalesce.
+ * @returns {Array<Array<number>>} Ascending list of `[startIndex, amount]` spans.
+ */ export function coalesceIndexesToSpans(indexes) {
+    const sortedIndexes = [
+        ...indexes
+    ].sort((a, b)=>a - b);
+    const spans = [];
+    sortedIndexes.forEach((index)=>{
+        const lastSpan = spans[spans.length - 1];
+        if (lastSpan === undefined || index > lastSpan[0] + lastSpan[1]) {
+            spans.push([
+                index,
+                1
+            ]);
+        } else if (index === lastSpan[0] + lastSpan[1]) {
+            lastSpan[1] += 1;
+        }
+    });
+    return spans;
+}
 /**
  * Converts a Handsontable cell value to a value accepted by HyperFormula.
  * HyperFormula doesn't accept arrays as direct cell values, so they are converted to a

package/plugins/hiddenColumns/contextMenuItem/showColumn.js

@@ -113,7 +113,12 @@ function showColumnItem(hiddenColumnsPlugin) {
                 // Collect not trimmed columns if there are some hidden columns in the selection range.
                 if (visualColumnsInRange > renderedColumnsInRange) {
                     const physicalIndexesInRange = notTrimmedColumnIndexes.slice(visualStartColumn, visualEndColumn + 1);
-                    physicalColumnIndexes.push(...physicalIndexesInRange.filter((physicalIndex)=>hiddenPhysicalColumns.includes(physicalIndex)));
+                    const hiddenPhysicalColumnsLookup = new Set(hiddenPhysicalColumns);
+                    physicalIndexesInRange.forEach((physicalIndex)=>{
+                        if (hiddenPhysicalColumnsLookup.has(physicalIndex)) {
+                            physicalColumnIndexes.push(physicalIndex);
+                        }
+                    });
                 }
             // Handled column is the first rendered index and there are some visual indexes before it.
             } else if (renderableStartColumn === 0 && visualStartColumn !== null && renderableStartColumn < visualStartColumn) {

package/plugins/hiddenColumns/contextMenuItem/showColumn.mjs

@@ -62,7 +62,12 @@ import * as C from '../../../i18n/constants.mjs';
                 // Collect not trimmed columns if there are some hidden columns in the selection range.
                 if (visualColumnsInRange > renderedColumnsInRange) {
                     const physicalIndexesInRange = notTrimmedColumnIndexes.slice(visualStartColumn, visualEndColumn + 1);
-                    physicalColumnIndexes.push(...physicalIndexesInRange.filter((physicalIndex)=>hiddenPhysicalColumns.includes(physicalIndex)));
+                    const hiddenPhysicalColumnsLookup = new Set(hiddenPhysicalColumns);
+                    physicalIndexesInRange.forEach((physicalIndex)=>{
+                        if (hiddenPhysicalColumnsLookup.has(physicalIndex)) {
+                            physicalColumnIndexes.push(physicalIndex);
+                        }
+                    });
                 }
             // Handled column is the first rendered index and there are some visual indexes before it.
             } else if (renderableStartColumn === 0 && visualStartColumn !== null && renderableStartColumn < visualStartColumn) {

package/plugins/hiddenColumns/hiddenColumns.js

@@ -27,7 +27,6 @@ const _predefinedItems = require("../contextMenu/predefinedItems");
 const _hooks = require("../../core/hooks");
 const _hideColumn = /*#__PURE__*/ _interop_require_default(require("./contextMenuItem/hideColumn"));
 const _showColumn = /*#__PURE__*/ _interop_require_default(require("./contextMenuItem/showColumn"));
-const _translations = require("../../translations");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -158,9 +157,13 @@ class HiddenColumns extends _base.BasePlugin {
         if (this.enabled) {
             return;
         }
-        _class_private_field_set(this, _hiddenColumnsMap, new _translations.HidingMap());
+        _class_private_field_set(this, _hiddenColumnsMap, this.hot.columnIndexMapper.createAndRegisterIndexMap(this.pluginName ?? '', 'hiding'));
         _class_private_field_get(this, _hiddenColumnsMap).addLocalHook('init', ()=>_class_private_method_get(this, _onMapInit, onMapInit).call(this));
-        this.hot.columnIndexMapper.registerMap(this.pluginName ?? '', _class_private_field_get(this, _hiddenColumnsMap));
+        // `createAndRegisterIndexMap` initializes the map synchronously when the dataset is already
+        // loaded (a plugin re-enable), before the hook above could attach - replay the init handler.
+        if (this.hot.columnIndexMapper.getNumberOfIndexes() > 0) {
+            _class_private_method_get(this, _onMapInit, onMapInit).call(this);
+        }
         this.addHook('afterContextMenuDefaultOptions', _class_private_field_get(this, _onAfterContextMenuDefaultOptions));
         this.addHook('afterGetCellMeta', _class_private_field_get(this, _onAfterGetCellMeta));
         this.addHook('modifyColWidth', _class_private_field_get(this, _onModifyColWidth), 2);

package/plugins/hiddenColumns/hiddenColumns.mjs

@@ -56,7 +56,6 @@ import { SEPARATOR } from '../contextMenu/predefinedItems/index.mjs';
 import { Hooks } from '../../core/hooks/index.mjs';
 import hideColumnItem from './contextMenuItem/hideColumn.mjs';
 import showColumnItem from './contextMenuItem/showColumn.mjs';
-import { HidingMap } from '../../translations/index.mjs';
 Hooks.getSingleton().register('beforeHideColumns');
 Hooks.getSingleton().register('afterHideColumns');
 Hooks.getSingleton().register('beforeUnhideColumns');
@@ -299,9 +298,13 @@ var /**
         if (this.enabled) {
             return;
         }
-        _class_private_field_set(this, _hiddenColumnsMap, new HidingMap());
+        _class_private_field_set(this, _hiddenColumnsMap, this.hot.columnIndexMapper.createAndRegisterIndexMap(this.pluginName ?? '', 'hiding'));
         _class_private_field_get(this, _hiddenColumnsMap).addLocalHook('init', ()=>_class_private_method_get(this, _onMapInit, onMapInit).call(this));
-        this.hot.columnIndexMapper.registerMap(this.pluginName ?? '', _class_private_field_get(this, _hiddenColumnsMap));
+        // `createAndRegisterIndexMap` initializes the map synchronously when the dataset is already
+        // loaded (a plugin re-enable), before the hook above could attach - replay the init handler.
+        if (this.hot.columnIndexMapper.getNumberOfIndexes() > 0) {
+            _class_private_method_get(this, _onMapInit, onMapInit).call(this);
+        }
         this.addHook('afterContextMenuDefaultOptions', _class_private_field_get(this, _onAfterContextMenuDefaultOptions));
         this.addHook('afterGetCellMeta', _class_private_field_get(this, _onAfterGetCellMeta));
         this.addHook('modifyColWidth', _class_private_field_get(this, _onModifyColWidth), 2);

package/plugins/hiddenRows/contextMenuItem/showRow.js

@@ -113,7 +113,12 @@ function showRowItem(hiddenRowsPlugin) {
                 // Collect not trimmed rows if there are some hidden rows in the selection range.
                 if (visualRowsInRange > renderedRowsInRange) {
                     const physicalIndexesInRange = notTrimmedRowIndexes.slice(visualStartRow, visualEndRow + 1);
-                    physicalRowIndexes.push(...physicalIndexesInRange.filter((physicalIndex)=>hiddenPhysicalRows.includes(physicalIndex)));
+                    const hiddenPhysicalRowsLookup = new Set(hiddenPhysicalRows);
+                    physicalIndexesInRange.forEach((physicalIndex)=>{
+                        if (hiddenPhysicalRowsLookup.has(physicalIndex)) {
+                            physicalRowIndexes.push(physicalIndex);
+                        }
+                    });
                 }
             // Handled row is the first rendered index and there are some visual indexes before it.
             } else if (renderableStartRow === 0 && visualStartRow !== null && renderableStartRow < visualStartRow) {

package/plugins/hiddenRows/contextMenuItem/showRow.mjs

@@ -62,7 +62,12 @@ import * as C from '../../../i18n/constants.mjs';
                 // Collect not trimmed rows if there are some hidden rows in the selection range.
                 if (visualRowsInRange > renderedRowsInRange) {
                     const physicalIndexesInRange = notTrimmedRowIndexes.slice(visualStartRow, visualEndRow + 1);
-                    physicalRowIndexes.push(...physicalIndexesInRange.filter((physicalIndex)=>hiddenPhysicalRows.includes(physicalIndex)));
+                    const hiddenPhysicalRowsLookup = new Set(hiddenPhysicalRows);
+                    physicalIndexesInRange.forEach((physicalIndex)=>{
+                        if (hiddenPhysicalRowsLookup.has(physicalIndex)) {
+                            physicalRowIndexes.push(physicalIndex);
+                        }
+                    });
                 }
             // Handled row is the first rendered index and there are some visual indexes before it.
             } else if (renderableStartRow === 0 && visualStartRow !== null && renderableStartRow < visualStartRow) {

package/plugins/hiddenRows/hiddenRows.js

@@ -27,7 +27,6 @@ const _predefinedItems = require("../contextMenu/predefinedItems");
 const _hooks = require("../../core/hooks");
 const _hideRow = /*#__PURE__*/ _interop_require_default(require("./contextMenuItem/hideRow"));
 const _showRow = /*#__PURE__*/ _interop_require_default(require("./contextMenuItem/showRow"));
-const _translations = require("../../translations");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -158,9 +157,13 @@ class HiddenRows extends _base.BasePlugin {
         if (this.enabled) {
             return;
         }
-        _class_private_field_set(this, _hiddenRowsMap, new _translations.HidingMap());
+        _class_private_field_set(this, _hiddenRowsMap, this.hot.rowIndexMapper.createAndRegisterIndexMap(this.pluginName, 'hiding'));
         _class_private_field_get(this, _hiddenRowsMap).addLocalHook('init', ()=>_class_private_method_get(this, _onMapInit, onMapInit).call(this));
-        this.hot.rowIndexMapper.registerMap(this.pluginName, _class_private_field_get(this, _hiddenRowsMap));
+        // `createAndRegisterIndexMap` initializes the map synchronously when the dataset is already
+        // loaded (a plugin re-enable), before the hook above could attach - replay the init handler.
+        if (this.hot.rowIndexMapper.getNumberOfIndexes() > 0) {
+            _class_private_method_get(this, _onMapInit, onMapInit).call(this);
+        }
         this.addHook('afterContextMenuDefaultOptions', _class_private_field_get(this, _onAfterContextMenuDefaultOptions));
         this.addHook('afterGetCellMeta', _class_private_field_get(this, _onAfterGetCellMeta));
         this.addHook('modifyRowHeight', _class_private_field_get(this, _onModifyRowHeight));

package/plugins/hiddenRows/hiddenRows.mjs

@@ -56,7 +56,6 @@ import { SEPARATOR } from '../contextMenu/predefinedItems/index.mjs';
 import { Hooks } from '../../core/hooks/index.mjs';
 import hideRowItem from './contextMenuItem/hideRow.mjs';
 import showRowItem from './contextMenuItem/showRow.mjs';
-import { HidingMap } from '../../translations/index.mjs';
 Hooks.getSingleton().register('beforeHideRows');
 Hooks.getSingleton().register('afterHideRows');
 Hooks.getSingleton().register('beforeUnhideRows');
@@ -299,9 +298,13 @@ var /**
         if (this.enabled) {
             return;
         }
-        _class_private_field_set(this, _hiddenRowsMap, new HidingMap());
+        _class_private_field_set(this, _hiddenRowsMap, this.hot.rowIndexMapper.createAndRegisterIndexMap(this.pluginName, 'hiding'));
         _class_private_field_get(this, _hiddenRowsMap).addLocalHook('init', ()=>_class_private_method_get(this, _onMapInit, onMapInit).call(this));
-        this.hot.rowIndexMapper.registerMap(this.pluginName, _class_private_field_get(this, _hiddenRowsMap));
+        // `createAndRegisterIndexMap` initializes the map synchronously when the dataset is already
+        // loaded (a plugin re-enable), before the hook above could attach - replay the init handler.
+        if (this.hot.rowIndexMapper.getNumberOfIndexes() > 0) {
+            _class_private_method_get(this, _onMapInit, onMapInit).call(this);
+        }
         this.addHook('afterContextMenuDefaultOptions', _class_private_field_get(this, _onAfterContextMenuDefaultOptions));
         this.addHook('afterGetCellMeta', _class_private_field_get(this, _onAfterGetCellMeta));
         this.addHook('modifyRowHeight', _class_private_field_get(this, _onModifyRowHeight));