handsontable 18.0.0 → 18.1.0-rc1

package/translations/indexMapper.mjs

@@ -4,15 +4,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    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.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    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) {
@@ -39,9 +34,7 @@ function _class_private_field_set(receiver, privateMap, 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");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {
@@ -79,7 +72,15 @@ var /**
    * @param {IndexMap} map The map whose observers to notify.
    */ _notifyMapObservers = /*#__PURE__*/ new WeakSet(), /**
    * Flushes all dirty observed maps collected during a batch, notifying their observers.
-   */ _flushDirtyObservedMaps = /*#__PURE__*/ new WeakSet();
+   */ _flushDirtyObservedMaps = /*#__PURE__*/ new WeakSet(), /**
+   * Returns a `-1`-filled `Int32Array` of the given length, reusing the passed one when its length
+   * matches so a cache rebuild does not allocate a new buffer.
+   *
+   * @private
+   * @param {Int32Array} cache The existing cache to reuse when possible.
+   * @param {number} length The required length.
+   * @returns {Int32Array}
+   */ _allocateIndexCache = /*#__PURE__*/ new WeakSet();
 /**
  * @class IndexMapper
  * @description
@@ -127,8 +128,8 @@ var /**
         }
         return this.hidingChangesObservable.createObserver();
     }
-    createAndRegisterIndexMap(indexName, mapType, initValueOrFn) {
-        return this.registerMap(indexName, createIndexMap(mapType, initValueOrFn));
+    createAndRegisterIndexMap(indexName, mapType, initValueOrFn, options) {
+        return this.registerMap(indexName, createIndexMap(mapType, initValueOrFn, options));
     }
     /* eslint-enable jsdoc/require-jsdoc */ /**
    * Register map which provide some index mappings. Type of map determining to which collection it will be added.
@@ -207,9 +208,15 @@ var /**
    * @param {number} physicalIndex Physical index to search.
    * @returns {number|null} Returns a visual index of the index mapper.
    */ getVisualFromPhysicalIndex(physicalIndex) {
-        const visualIndex = this.fromPhysicalToVisualIndexesCache.get(physicalIndex);
-        // Index in the table boundaries provided by the `DataMap`.
-        return visualIndex ?? null;
+        // The typed-array cache coerces non-integer keys: a string like `'0'` would index slot 0 and
+        // `'__proto__'`/`'constructor'` would return prototype-chain values. The previous `Map` treated those
+        // as misses, so reject any non-integer key here to keep that exact-key semantics.
+        if (!Number.isInteger(physicalIndex)) {
+            return null;
+        }
+        const visualIndex = this.fromPhysicalToVisualIndexesCache[physicalIndex];
+        // Index in the table boundaries provided by the `DataMap`. `-1`/`undefined` means no mapping.
+        return visualIndex === undefined || visualIndex === -1 ? null : visualIndex;
     }
     /**
    * Get a visual index corresponding to the given renderable index.
@@ -225,9 +232,14 @@ var /**
    * @param {number} visualIndex Visual index.
    * @returns {null|number}
    */ getRenderableFromVisualIndex(visualIndex) {
-        const renderableIndex = this.fromVisualToRenderableIndexesCache.get(visualIndex);
-        // Index in the renderable table boundaries.
-        return renderableIndex ?? null;
+        // Reject non-integer keys (string-numeric, `'__proto__'`, etc.) to keep the previous `Map`'s
+        // exact-key semantics — see getVisualFromPhysicalIndex.
+        if (!Number.isInteger(visualIndex)) {
+            return null;
+        }
+        const renderableIndex = this.fromVisualToRenderableIndexesCache[visualIndex];
+        // Index in the renderable table boundaries. `-1`/`undefined` means no mapping.
+        return renderableIndex === undefined || renderableIndex === -1 ? null : renderableIndex;
     }
     /**
    * Search for the nearest not-hidden row or column.
@@ -245,23 +257,25 @@ var /**
         if (physicalIndex === null) {
             return null;
         }
-        if (this.fromVisualToRenderableIndexesCache.has(fromVisualIndex)) {
+        const renderableCache = this.fromVisualToRenderableIndexesCache;
+        const fromRenderableIndex = renderableCache[fromVisualIndex];
+        // The visual index is already visible when it has a renderable mapping. The `typeof number` check
+        // keeps non-integer keys (e.g. `'__proto__'`) from matching prototype-chain values.
+        if (typeof fromRenderableIndex === 'number' && fromRenderableIndex !== -1) {
             return fromVisualIndex;
         }
-        const visibleIndexes = Array.from(this.fromVisualToRenderableIndexesCache.keys());
-        let index = -1;
-        if (searchDirection > 0) {
-            index = visibleIndexes.findIndex((visualIndex)=>visualIndex !== null && visualIndex > fromVisualIndex);
-        } else {
-            index = visibleIndexes.reverse().findIndex((visualIndex)=>visualIndex !== null && visualIndex < fromVisualIndex);
-        }
-        if (index === -1) {
-            if (searchAlsoOtherWayAround) {
-                return this.getNearestNotHiddenIndex(fromVisualIndex, -searchDirection, false);
+        // Scan outward for the nearest visible visual index in the requested direction
+        // (`searchDirection` is `1` or `-1`, so the same loop covers both directions).
+        const length = renderableCache.length;
+        for(let visualIndex = fromVisualIndex + searchDirection; visualIndex >= 0 && visualIndex < length; visualIndex += searchDirection){
+            if (renderableCache[visualIndex] !== -1) {
+                return visualIndex;
             }
-            return null;
         }
-        return visibleIndexes[index];
+        if (searchAlsoOtherWayAround) {
+            return this.getNearestNotHiddenIndex(fromVisualIndex, -searchDirection, false);
+        }
+        return null;
     }
     /**
    * Set default values for all indexes in registered index maps.
@@ -336,7 +350,18 @@ var /**
             return this.notTrimmedIndexesCache;
         }
         const indexesSequence = this.getIndexesSequence();
-        return indexesSequence.filter((physicalIndex)=>this.isTrimmed(physicalIndex) === false);
+        // Read the merged trimming cache directly instead of calling `isTrimmed()` per element (which
+        // resolves through getMergedValueAtIndex → getMergedValues on every index). Same semantics:
+        // `isTrimmed(i) === false` ⟺ the merged value is not strictly `true`.
+        const trimmedValues = this.trimmingMapsCollection.getMergedValues();
+        const notTrimmedIndexes = [];
+        for(let i = 0; i < indexesSequence.length; i += 1){
+            const physicalIndex = indexesSequence[i];
+            if (trimmedValues[physicalIndex] !== true) {
+                notTrimmedIndexes.push(physicalIndex);
+            }
+        }
+        return notTrimmedIndexes;
     }
     /**
    * Get length of all NOT trimmed indexes.
@@ -359,7 +384,15 @@ var /**
             return this.notHiddenIndexesCache;
         }
         const indexesSequence = this.getIndexesSequence();
-        return indexesSequence.filter((physicalIndex)=>this.isHidden(physicalIndex) === false);
+        const hiddenValues = this.hidingMapsCollection.getMergedValues();
+        const notHiddenIndexes = [];
+        for(let i = 0; i < indexesSequence.length; i += 1){
+            const physicalIndex = indexesSequence[i];
+            if (hiddenValues[physicalIndex] !== true) {
+                notHiddenIndexes.push(physicalIndex);
+            }
+        }
+        return notHiddenIndexes;
     }
     /**
    * Get length of all NOT hidden indexes.
@@ -381,7 +414,15 @@ var /**
             return this.renderablePhysicalIndexesCache;
         }
         const notTrimmedIndexes = this.getNotTrimmedIndexes();
-        return notTrimmedIndexes.filter((physicalIndex)=>this.isHidden(physicalIndex) === false);
+        const hiddenValues = this.hidingMapsCollection.getMergedValues();
+        const renderableIndexes = [];
+        for(let i = 0; i < notTrimmedIndexes.length; i += 1){
+            const physicalIndex = notTrimmedIndexes[i];
+            if (hiddenValues[physicalIndex] !== true) {
+                renderableIndexes.push(physicalIndex);
+            }
+        }
+        return renderableIndexes;
     }
     /**
    * Get length of all NOT trimmed and NOT hidden indexes.
@@ -545,13 +586,16 @@ var /**
    * @private
    */ cacheFromPhysicalToVisualIndexes() {
         const nrOfNotTrimmedIndexes = this.getNotTrimmedIndexesLength();
-        this.fromPhysicalToVisualIndexesCache.clear();
+        const cache = _class_private_method_get(this, _allocateIndexCache, allocateIndexCache).call(this, this.fromPhysicalToVisualIndexesCache, this.getNumberOfIndexes());
         for(let visualIndex = 0; visualIndex < nrOfNotTrimmedIndexes; visualIndex += 1){
             const physicalIndex = this.getPhysicalFromVisualIndex(visualIndex);
-            // Every visual index have corresponding physical index, but some physical indexes may don't have
-            // corresponding visual indexes (physical indexes may represent trimmed indexes, beyond the table boundaries)
-            this.fromPhysicalToVisualIndexesCache.set(physicalIndex, visualIndex);
+            // Every visual index has a corresponding physical index. Physical indexes with no visual index
+            // (trimmed indexes, beyond the table boundaries) keep the `-1` sentinel.
+            if (physicalIndex !== null) {
+                cache[physicalIndex] = visualIndex;
+            }
         }
+        this.fromPhysicalToVisualIndexesCache = cache;
     }
     /**
    * Update cache for translations from visual to renderable indexes.
@@ -559,13 +603,17 @@ var /**
    * @private
    */ cacheFromVisualToRenderableIndexes() {
         const nrOfRenderableIndexes = this.getRenderableIndexesLength();
-        this.fromVisualToRenderableIndexesCache.clear();
+        const cache = _class_private_method_get(this, _allocateIndexCache, allocateIndexCache).call(this, this.fromVisualToRenderableIndexesCache, this.getNotTrimmedIndexesLength());
         for(let renderableIndex = 0; renderableIndex < nrOfRenderableIndexes; renderableIndex += 1){
             // Can't use getRenderableFromVisualIndex here because we're building the cache here
             const physicalIndex = this.getPhysicalFromRenderableIndex(renderableIndex);
             const visualIndex = this.getVisualFromPhysicalIndex(physicalIndex);
-            this.fromVisualToRenderableIndexesCache.set(visualIndex, renderableIndex);
+            // Visual indexes with no renderable index (hidden indexes) keep the `-1` sentinel.
+            if (visualIndex !== null) {
+                cache[visualIndex] = renderableIndex;
+            }
         }
+        this.fromVisualToRenderableIndexesCache = cache;
     }
     /**
    * Destroys the IndexMapper instance. Clears all registered map observers
@@ -581,6 +629,7 @@ var /**
         _class_private_method_init(this, _handleObservedMapChange);
         _class_private_method_init(this, _notifyMapObservers);
         _class_private_method_init(this, _flushDirtyObservedMaps);
+        _class_private_method_init(this, _allocateIndexCache);
         _class_private_field_init(this, _mapObservers, {
             writable: true,
             value: void 0
@@ -685,17 +734,21 @@ var /**
    * @type {Array}
    */ this.renderablePhysicalIndexesCache = [];
         /**
-   * Visual indexes (native map's value) corresponding to physical indexes (native map's index).
+   * Visual indexes (typed array value) corresponding to physical indexes (typed array index).
+   * `-1` marks a physical index with no visual index (trimmed). Backed by a typed array instead of a
+   * `Map` to avoid per-rebuild hashing churn on large datasets.
    *
    * @private
-   * @type {Map}
-   */ this.fromPhysicalToVisualIndexesCache = new Map();
+   * @type {Int32Array}
+   */ this.fromPhysicalToVisualIndexesCache = new Int32Array(0);
         /**
-   * Visual indexes (native map's value) corresponding to physical indexes (native map's index).
+   * Renderable indexes (typed array value) corresponding to visual indexes (typed array index).
+   * `-1` marks a visual index with no renderable index (hidden). Backed by a typed array instead of a
+   * `Map` to avoid per-rebuild hashing churn on large datasets.
    *
    * @private
-   * @type {Map}
-   */ this.fromVisualToRenderableIndexesCache = new Map();
+   * @type {Int32Array}
+   */ this.fromVisualToRenderableIndexesCache = new Int32Array(0);
         _class_private_field_set(this, _mapObservers, new WeakMap());
         _class_private_field_set(this, _dirtyObservedMaps, new Set());
         this.indexesSequence.addLocalHook('change', ()=>{
@@ -744,4 +797,11 @@ function flushDirtyObservedMaps() {
         _class_private_field_get(this, _dirtyObservedMaps).clear();
     }
 }
+function allocateIndexCache(cache, length) {
+    if (cache.length === length) {
+        cache.fill(-1);
+        return cache;
+    }
+    return new Int32Array(length).fill(-1);
+}
 mixin(IndexMapper, localHooks);

package/translations/mapCollections/aggregatedCollection.js

@@ -21,45 +21,30 @@ class AggregatedCollection extends _mapCollection.MapCollection {
         if (readFromCache === true) {
             return this.mergedValuesCache;
         }
-        if (this.getLength() === 0) {
+        const maps = this.get();
+        const numberOfMaps = maps.length;
+        if (numberOfMaps === 0) {
             return [];
         }
-        // Below variable stores values for every particular map. Example describing situation when we have 2 registered maps,
-        // with length equal to 5.
-        //
-        // +---------+---------------------------------------------+
-        // |         |                  indexes                    |
-        // +---------+---------------------------------------------+
-        // |   maps  |     0    |   1   |    2  |   3   |    4     |
-        // +---------+----------+-------+-------+-------+----------+
-        // |    0    | [[ value,  value,  value,  value,  value ], |
-        // |    1    | [  value,  value,  value,  value,  value ]] |
-        // +---------+----------+-------+-------+-------+----------+
-        const mapsValuesMatrix = (0, _array.arrayMap)(this.get(), (map)=>map.getValues());
-        // Below variable stores values for every particular index. Example describing situation when we have 2 registered maps,
-        // with length equal to 5.
-        //
-        // +---------+---------------------+
-        // |         |         maps        |
-        // +---------+---------------------+
-        // | indexes |     0    |    1     |
-        // +---------+----------+----------+
-        // |    0    | [[ value,  value ], |
-        // |    1    | [  value,  value ], |
-        // |    2    | [  value,  value ], |
-        // |    3    | [  value,  value ], |
-        // |    4    | [  value,  value ]] |
-        // +---------+----------+----------+
-        const indexesValuesMatrix = [];
-        const mapsLength = (0, _mixed.isDefined)(mapsValuesMatrix[0]) && mapsValuesMatrix[0].length || 0;
-        for(let index = 0; index < mapsLength; index += 1){
-            const valuesForIndex = [];
-            for(let mapIndex = 0; mapIndex < this.getLength(); mapIndex += 1){
-                valuesForIndex.push(mapsValuesMatrix[mapIndex][index]);
+        // Per-map value arrays. For 2 maps of length 5:
+        //   maps 0 | [ value, value, value, value, value ]
+        //   maps 1 | [ value, value, value, value, value ]
+        const mapsValuesMatrix = (0, _array.arrayMap)(maps, (map)=>map.getValues());
+        const indexesLength = (0, _mixed.isDefined)(mapsValuesMatrix[0]) && mapsValuesMatrix[0].length || 0;
+        const mergedValues = new Array(indexesLength);
+        // A single scratch row, reused for every index, is passed to the aggregation function instead
+        // of allocating one `[value, value, ...]` array per index. The previous matrix approach built
+        // O(rows) throwaway sub-arrays on every sort/trim/hide rebuild (the dominant cost of updateCache
+        // on large datasets). The aggregation functions read this array synchronously and never retain
+        // it, so reuse is safe.
+        const valuesForIndex = new Array(numberOfMaps);
+        for(let index = 0; index < indexesLength; index += 1){
+            for(let mapIndex = 0; mapIndex < numberOfMaps; mapIndex += 1){
+                valuesForIndex[mapIndex] = mapsValuesMatrix[mapIndex][index];
             }
-            indexesValuesMatrix.push(valuesForIndex);
+            mergedValues[index] = this.aggregationFunction(valuesForIndex);
         }
-        return (0, _array.arrayMap)(indexesValuesMatrix, this.aggregationFunction);
+        return mergedValues;
     }
     /**
    * Get merged value for particular index.

package/translations/mapCollections/aggregatedCollection.mjs

@@ -14,45 +14,30 @@ import { isDefined } from '../../helpers/mixed.mjs';
         if (readFromCache === true) {
             return this.mergedValuesCache;
         }
-        if (this.getLength() === 0) {
+        const maps = this.get();
+        const numberOfMaps = maps.length;
+        if (numberOfMaps === 0) {
             return [];
         }
-        // Below variable stores values for every particular map. Example describing situation when we have 2 registered maps,
-        // with length equal to 5.
-        //
-        // +---------+---------------------------------------------+
-        // |         |                  indexes                    |
-        // +---------+---------------------------------------------+
-        // |   maps  |     0    |   1   |    2  |   3   |    4     |
-        // +---------+----------+-------+-------+-------+----------+
-        // |    0    | [[ value,  value,  value,  value,  value ], |
-        // |    1    | [  value,  value,  value,  value,  value ]] |
-        // +---------+----------+-------+-------+-------+----------+
-        const mapsValuesMatrix = arrayMap(this.get(), (map)=>map.getValues());
-        // Below variable stores values for every particular index. Example describing situation when we have 2 registered maps,
-        // with length equal to 5.
-        //
-        // +---------+---------------------+
-        // |         |         maps        |
-        // +---------+---------------------+
-        // | indexes |     0    |    1     |
-        // +---------+----------+----------+
-        // |    0    | [[ value,  value ], |
-        // |    1    | [  value,  value ], |
-        // |    2    | [  value,  value ], |
-        // |    3    | [  value,  value ], |
-        // |    4    | [  value,  value ]] |
-        // +---------+----------+----------+
-        const indexesValuesMatrix = [];
-        const mapsLength = isDefined(mapsValuesMatrix[0]) && mapsValuesMatrix[0].length || 0;
-        for(let index = 0; index < mapsLength; index += 1){
-            const valuesForIndex = [];
-            for(let mapIndex = 0; mapIndex < this.getLength(); mapIndex += 1){
-                valuesForIndex.push(mapsValuesMatrix[mapIndex][index]);
+        // Per-map value arrays. For 2 maps of length 5:
+        //   maps 0 | [ value, value, value, value, value ]
+        //   maps 1 | [ value, value, value, value, value ]
+        const mapsValuesMatrix = arrayMap(maps, (map)=>map.getValues());
+        const indexesLength = isDefined(mapsValuesMatrix[0]) && mapsValuesMatrix[0].length || 0;
+        const mergedValues = new Array(indexesLength);
+        // A single scratch row, reused for every index, is passed to the aggregation function instead
+        // of allocating one `[value, value, ...]` array per index. The previous matrix approach built
+        // O(rows) throwaway sub-arrays on every sort/trim/hide rebuild (the dominant cost of updateCache
+        // on large datasets). The aggregation functions read this array synchronously and never retain
+        // it, so reuse is safe.
+        const valuesForIndex = new Array(numberOfMaps);
+        for(let index = 0; index < indexesLength; index += 1){
+            for(let mapIndex = 0; mapIndex < numberOfMaps; mapIndex += 1){
+                valuesForIndex[mapIndex] = mapsValuesMatrix[mapIndex][index];
             }
-            indexesValuesMatrix.push(valuesForIndex);
+            mergedValues[index] = this.aggregationFunction(valuesForIndex);
         }
-        return arrayMap(indexesValuesMatrix, this.aggregationFunction);
+        return mergedValues;
     }
     /**
    * Get merged value for particular index.

package/translations/mapCollections/mapCollection.d.ts

@@ -39,12 +39,18 @@ export declare class MapCollection {
      */
     unregisterAll(): void;
     /**
-     * Get index map for the provided name.
+     * Get all registered index maps.
      *
-     * @param {string} [name] Name of the index map.
-     * @returns {Array|IndexMap}
+     * @returns {IndexMap[]}
      */
-    get(name?: string): IndexMap | IndexMap[] | undefined;
+    get(): IndexMap[];
+    /**
+     * Get the index map registered under the provided name.
+     *
+     * @param {string} name Name of the index map.
+     * @returns {IndexMap | undefined}
+     */
+    get(name: string): IndexMap | undefined;
     /**
      * Get collection size.
      *

package/translations/mapCollections/mapCollection.js

@@ -59,10 +59,10 @@ class MapCollection {
         this.collection.clear();
     }
     /**
-   * Get index map for the provided name.
+   * Get index map(s): all registered maps when called without a name, or a single map by name.
    *
    * @param {string} [name] Name of the index map.
-   * @returns {Array|IndexMap}
+   * @returns {IndexMap[] | IndexMap | undefined}
    */ get(name) {
         if ((0, _mixed.isUndefined)(name)) {
             return Array.from(this.collection.values());

package/translations/mapCollections/mapCollection.mjs

@@ -38,10 +38,10 @@ let registeredMaps = 0;
         this.collection.clear();
     }
     /**
-   * Get index map for the provided name.
+   * Get index map(s): all registered maps when called without a name, or a single map by name.
    *
    * @param {string} [name] Name of the index map.
-   * @returns {Array|IndexMap}
+   * @returns {IndexMap[] | IndexMap | undefined}
    */ get(name) {
         if (isUndefined(name)) {
             return Array.from(this.collection.values());

package/translations/maps/booleanMap.d.mts

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

package/translations/maps/booleanMap.d.ts

@@ -0,0 +1,86 @@
+import { IndexMap, type IndexMapOptions } from './indexMap';
+/**
+ * Map from a physical index to a boolean (hidden/trimmed flags).
+ *
+ * Representation, mirroring `IndexesSequence`'s identity fast path:
+ * - While every value equals the default (the common case — nothing hidden/trimmed) the store is a
+ *   single `length`, not an array. Insert/remove then run in O(1)/O(k) (length change only) instead of
+ *   rebuilding an n-element array, and nothing is retained between operations.
+ * - On the first non-default write the store materializes as a `boolean[]`, kept and returned by
+ *   reference so the merge does not allocate per `updateCache`.
+ *
+ * `getValues()` still returns a plain `boolean[]`, so the merge predicate (`value === true`) and every
+ * other consumer are unchanged.
+ *
+ * (A `Uint8Array` store would cut the materialized footprint ~8×, but exposing it from `getValues()`
+ * forces the same generic-`IndexMap` refactor + contract break as the rejected typed-sequence change,
+ * so the store stays `boolean[]` when populated.)
+ *
+ * @class BooleanMap
+ */
+export declare class BooleanMap extends IndexMap {
+    #private;
+    /**
+     * Initializes the boolean map with a default value or factory (defaults to `false`).
+     */
+    constructor(initValueOrFn?: boolean | ((index: number, ordinalNumber: number) => unknown), options?: IndexMapOptions);
+    /**
+     * Get the full list of boolean values. Returns the materialized array by reference (no per-call copy).
+     *
+     * @returns {boolean[]}
+     */
+    getValues(): boolean[];
+    /**
+     * Get the boolean value at a physical index.
+     *
+     * @param {number} index Physical index.
+     * @returns {T | undefined}
+     */
+    getValueAtIndex<T = unknown>(index: number): T | undefined;
+    /**
+     * Get the number of indexes.
+     *
+     * @returns {number}
+     */
+    getLength(): number;
+    /**
+     * Set new boolean values. Keeps the compact representation when all values equal the default.
+     *
+     * @param {Array} values List of boolean values.
+     */
+    setValues(values: unknown[]): void;
+    /**
+     * Set the boolean value at a single physical index. Materializes the store on the first non-default write.
+     *
+     * @param {number} index Physical index.
+     * @param {*} value The value to set (coerced to boolean).
+     * @returns {boolean}
+     */
+    setValueAtIndex(index: number, value: unknown): boolean;
+    /**
+     * Reset to the all-default state of the given length. O(1) for a constant default — no array is built.
+     *
+     * @private
+     * @param {number} [length] Length of the map.
+     */
+    setDefaultValues(length?: number): void;
+    /**
+     * Add values to the map and reorganize.
+     *
+     * @private
+     * @param {number} insertionIndex Position inside the list.
+     * @param {Array} insertedIndexes List of inserted indexes.
+     */
+    insert(insertionIndex: number, insertedIndexes: number[]): void;
+    /**
+     * Remove values from the map and reorganize.
+     *
+     * @private
+     * @param {Array} removedIndexes List of removed indexes.
+     */
+    remove(removedIndexes: number[]): void;
+    /**
+     * Destroys the map instance.
+     */
+    destroy(): void;
+}