@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

package/types/src/collections/SortedMap.d.ts

@@ -0,0 +1,396 @@
+import { ISortedMap } from './ISortedMap';
+/**
+ * {@inheritDoc ISortedMap}
+ *
+ * B+ tree implementation. Nodes split at `maxNodeSize` (default 32). Cloning is O(1)
+ * via copy-on-write structural sharing — only the path to a mutated node is copied.
+ * Supports `freeze()` to make the map immutable at runtime.
+ *
+ * @remarks
+ * - TODO: Test performance of preallocating values array at max size
+ * - TODO: Add fast initialization when a sorted array is provided to constructor
+ *
+ * Adapted from {@link https://github.com/qwertie/btree-typescript | btree-typescript} (MIT).
+ */
+export declare class SortedMap<K = any, V = any> implements ISortedMap<K, V> {
+    protected _root: BNode<K, V>;
+    _size: number;
+    _maxNodeSize: number;
+    /**
+     * Provides a total order over keys (and a strict partial order over the type K)
+     * @returns A negative value if a < b, 0 if a === b and a positive value if a > b
+     */
+    _compare: (a: K, b: K) => number;
+    /**
+     * Initializes an SortedMap.
+     *
+     * @param compare Custom function to compare pairs of elements in the map.
+     *        If not specified, defaultComparator will be used which is valid as long as K extends DefaultComparable.
+     * @param entries A set of key-value pairs to initialize the map
+     * @param maxNodeSize Branching factor (maximum items or children per node)
+     *        Must be in range 4..256. If undefined or <4 then 32 is used; if >256 then 256.
+     */
+    constructor(entries?: [K, V][], compare?: (a: K, b: K) => number, maxNodeSize?: number);
+    /** {@inheritDoc ISortedMap.size} */
+    get size(): number;
+    /**
+     * Returns the number of key-value pairs in the map.
+     *
+     * @remarks
+     * This is the same as size.
+     */
+    get length(): number;
+    /**
+     * Returns true iff the map contains no key-value pairs.
+     */
+    isEmpty(): boolean;
+    /** {@inheritDoc ISortedMap.clear} */
+    clear(): void;
+    /**
+     * {@inheritDoc ISortedMap.forEach}
+     * @remarks
+     * For ES6 Map compatibility, argument order to the callback is `(value, key)` — the
+     * reverse of `forEachPair`. Use `forEachPair` if you want key first.
+     */
+    forEach<R = number>(callback: (v: V, k: K, map: ISortedMap<K, V>) => {
+        break?: R;
+    } | void, thisArg?: any): R | number;
+    /**
+     * Runs a function for each key-value pair, in order from smallest to
+     * largest key. The callback can return {break: R} (where R is any value
+     * except undefined) to stop immediately and return R from forEachPair.
+     *
+     * @param onFound A function that is called for each key-value pair. This
+     *        function can return {break: R} to stop early with result R.
+     *        The reason that you must return {break: R} instead of simply R
+     *        itself is for consistency with editRange(), which allows
+     *        multiple actions, not just breaking.
+     * @param initialCounter This is the value of the third argument of
+     *        `onFound` the first time it is called. The counter increases
+     *        by one each time `onFound` is called. Default value: 0
+     * @returns The number of pairs sent to the callback (plus initialCounter,
+     *        if you provided one). If the callback returned {break: R} then
+     *        the R value is returned instead.
+     */
+    forEachPair<R = number>(callback: (k: K, v: V, counter: number) => {
+        break?: R;
+    } | void, initialCounter?: number): R | number;
+    /**
+     * {@inheritDoc ISortedMap.get}
+     * @remarks
+     * Also accepts an optional `defaultValue` returned when the key is not found.
+     * Complexity: O(log size).
+     */
+    get(key: K, defaultValue?: V): V | undefined;
+    /**
+     * {@inheritDoc ISortedMap.set}
+     * @remarks
+     * When overwriting an existing key, the key itself is also updated — no visible
+     * effect unless the new key has data that does not affect sort order.
+     * Complexity: O(log size).
+     */
+    set(key: K, value: V, overwrite?: boolean | ISortedMap.SetPairCallback<K, V>): boolean;
+    /**
+     * {@inheritDoc ISortedMap.has}
+     * @remarks
+     * Use `get()` when you also need the value — it is faster. Use `has()` only when you
+     * need to distinguish "undefined value" from "key not present".
+     * Complexity: O(log size).
+     */
+    has(key: K): boolean;
+    /**
+     * {@inheritDoc ISortedMap.delete}
+     * @remarks
+     * Complexity: O(log size).
+     */
+    delete(key: K): boolean;
+    /** {@inheritDoc ISortedMap.filter} */
+    filter(callback: (k: K, v: V, counter: number) => boolean, returnThisIfUnchanged?: boolean): ISortedMap<K, V>;
+    /** {@inheritDoc ISortedMap.mapValues} */
+    mapValues<R>(callback: (v: V, k: K, counter: number) => R): ISortedMap<K, R>;
+    /**
+     * {@inheritDoc ISortedMap.reduce}
+     * @remarks
+     * The same `currentPair` array is reused on every callback invocation — do not
+     * hold a reference to it between iterations.
+     */
+    reduce<R>(callback: (previous: R, currentPair: [K, V], counter: number) => R, initialValue: R): R;
+    reduce<R>(callback: (previous: R | undefined, currentPair: [K, V], counter: number) => R): R | undefined;
+    /**
+     * {@inheritDoc ISortedMap.entries}
+     * @remarks
+     * If `firstKey` does not exist, iteration starts at the next higher key.
+     * Pass `reusedResults` to reuse the iterator result object on each step and avoid
+     * per-iteration allocations — do not hold a reference to the result between calls.
+     */
+    entries(lowestKey?: K, reusedResults?: IteratorResult<[K, V], any>): IterableIterator<[K, V]>;
+    /** {@inheritDoc ISortedMap.entriesReversed} */
+    entriesReversed(highestKey?: K, reusedResults?: IteratorResult<[K, V], any>, skipHighest?: boolean): IterableIterator<[K, V]>;
+    private findPath;
+    /**
+     * Computes the differences between `this` and `other`.
+     * For efficiency, the diff is returned via invocations of supplied handlers.
+     * The computation is optimized for the case in which the two trees have large amounts
+     * of shared data (obtained by calling the `clone` or `with` APIs) and will avoid
+     * any iteration of shared state.
+     * The handlers can cause computation to early exit by returning {break: R}.
+     * Neither of the collections should be changed during the comparison process (in your callbacks), as this method assumes they will not be mutated.
+     *
+     * @param other The map to compute a diff against.
+     * @param onlyThis Callback invoked for all keys only present in `this`.
+     * @param onlyOther Callback invoked for all keys only present in `other`.
+     * @param different Callback invoked for all keys with differing values.
+     */
+    diffAgainst<R>(other: SortedMap<K, V>, onlyThis?: (k: K, v: V) => {
+        break?: R;
+    } | void, onlyOther?: (k: K, v: V) => {
+        break?: R;
+    } | void, different?: (k: K, vThis: V, vOther: V) => {
+        break?: R;
+    } | void): R | undefined;
+    private static finishCursorWalk;
+    private static stepToEnd;
+    private static makeDiffCursor;
+    /**
+     * Advances the cursor to the next step in the walk of its map.
+     * Cursors are walked backwards in sort order, as this allows them to leverage maxKey() in order to be compared in O(1).
+     *
+     * @param cursor The cursor to step
+     * @param stepToNode If true, the cursor will be advanced to the next node (skipping values)
+     * @returns `true` if the step was completed and false if the step would have caused the cursor to move beyond the end of the map.
+     */
+    private static step;
+    /**
+     * Compares the two cursors. Returns a value indicating which cursor is ahead in a walk.
+     * Note that cursors are advanced in reverse sorting order.
+     */
+    private static compare;
+    /** {@inheritDoc ISortedMap.keys} */
+    keys(firstKey?: K, reusedResults?: IteratorResult<[K, V], any>): IterableIterator<K>;
+    /** {@inheritDoc ISortedMap.values} */
+    values(firstKey?: K, reusedResults?: IteratorResult<[K, V], any>): IterableIterator<V>;
+    /** Returns the maximum number of children/values before nodes will split. */
+    getMaxNodeSize(): number;
+    /** {@inheritDoc ISortedMap.minKey} */
+    minKey(): K | undefined;
+    /** {@inheritDoc ISortedMap.maxKey} */
+    maxKey(): K | undefined;
+    /**
+     * {@inheritDoc ISortedMap.clone}
+     * @remarks
+     * Marks the root node as shared (copy-on-write). Both copies remain editable;
+     * only the path to a mutated node is cloned when a write occurs.
+     */
+    clone(): SortedMap<K, V>;
+    /**
+     * Performs a greedy clone, immediately duplicating any nodes that are
+     * not currently marked as shared, in order to avoid marking any
+     * additional nodes as shared.
+     *
+     * @param force Clone all nodes, even shared ones.
+     */
+    greedyClone(force?: boolean): SortedMap<K, V>;
+    /**
+     * Gets an array filled with the contents of the map, sorted by key.
+     */
+    toArray(maxLength?: number): [K, V][];
+    /**
+     * Gets an array of all keys, sorted.
+     */
+    keysArray(): K[];
+    /**
+     * Gets an array of all values, sorted by key.
+     */
+    valuesArray(): V[];
+    /**
+     * Gets a string representing the map's data based on toArray().
+     */
+    toString(): string;
+    /**
+     * Stores a key-value pair only if the key doesn't already exist in the map.
+     *
+     * @returns `true` if a new key was added
+     */
+    setIfNotPresent(key: K, value: V): boolean;
+    /**
+     * {@inheritDoc ISortedMap.nextHigherPair}
+     * @remarks
+     * Pass `reusedPair` to reuse the result array across calls and avoid per-call allocations.
+     */
+    nextHigherPair(key: K | undefined, reusedPair?: [K, V]): [K, V] | undefined;
+    /** {@inheritDoc ISortedMap.nextHigherKey} */
+    nextHigherKey(key: K | undefined, reusedPair?: [K, V]): K | undefined;
+    /**
+     * {@inheritDoc ISortedMap.nextLowerPair}
+     * @remarks
+     * Pass `reusedPair` to reuse the result array across calls and avoid per-call allocations.
+     */
+    nextLowerPair(key: K | undefined, reusedPair?: [K, V]): [K, V] | undefined;
+    /** {@inheritDoc ISortedMap.nextLowerKey} */
+    nextLowerKey(key: K | undefined, reusedPair?: [K, V]): K | undefined;
+    /** {@inheritDoc ISortedMap.getPairOrNextLower} */
+    getPairOrNextLower(key: K, reusedPair?: [K, V]): [K, V] | undefined;
+    /** {@inheritDoc ISortedMap.getPairOrNextHigher} */
+    getPairOrNextHigher(key: K, reusedPair?: [K, V]): [K, V] | undefined;
+    /**
+     * Edits the value associated with a key in the map, if it already exists.
+     *
+     * @returns `true` if the key existed, false if not.
+     */
+    changeIfPresent(key: K, value: V): boolean;
+    /**
+     * {@inheritDoc ISortedMap.getRange}
+     * @remarks
+     * Complexity: O(result.length + log size).
+     */
+    getRange(low: K, high: K, includeHigh?: boolean, maxLength?: number): [K, V][];
+    /**
+     * {@inheritDoc ISortedMap.setPairs}
+     * @remarks
+     * Duplicate keys in `pairs`: later entries overwrite earlier ones.
+     * If `overwrite` is a `SetPairCallback`, it is called on both inserts and updates.
+     * Complexity: O(pairs.length × log(size + pairs.length)).
+     */
+    setPairs(pairs: [K, V][], overwrite?: boolean | ISortedMap.SetPairCallback<K, V>): number;
+    /**
+     * {@inheritDoc ISortedMap.forRange}
+     * @remarks
+     * The callback must not insert or remove items — doing so may cause incorrect results.
+     * Returns `R` if the callback returned `{break: R}` to stop early.
+     * Complexity: O(items scanned + log size).
+     */
+    forRange<R = number>(low: K, high: K, includeHigh: boolean, onFound?: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): R | number;
+    /**
+     * {@inheritDoc ISortedMap.editRange}
+     * @remarks
+     * Any shared nodes (from a prior `clone()`) are copied before the callback is called —
+     * O(n) extra work proportional to the shared data scanned.
+     */
+    editRange<R = V>(low: K, high: K, includeHigh: boolean, onFound: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): R | number;
+    /**
+     * Same as `editRange` except that the callback is called for all pairs.
+     */
+    editAll<R = V>(onFound: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): R | number;
+    /**
+     * {@inheritDoc ISortedMap.deleteRange}
+     * @remarks
+     * Complexity: O(log size + items deleted).
+     */
+    deleteRange(low: K, high: K, includeHigh: boolean): number;
+    /** {@inheritDoc ISortedMap.deleteKeys} */
+    deleteKeys(keys: K[]): number;
+    /**
+     * Gets the height of the tree: the number of internal nodes between the
+     * SortedMap object and its leaf nodes (zero if there are no internal nodes).
+    */
+    getHeight(): number;
+    /**
+     * Makes the object read-only to ensure it is not accidentally modified.
+     * Freezing does not have to be permanent; unfreeze() reverses the effect.
+     * This is accomplished by replacing mutator functions with a function
+     * that throws an Error. Compared to using a property (e.g. this.isFrozen)
+     * this implementation gives better performance in non-frozen SortedMaps.
+     */
+    freeze(): void;
+    /** Ensures mutations are allowed, reversing the effect of freeze(). */
+    unfreeze(): void;
+    /**
+     * Returns true if the map appears to be frozen.
+     */
+    isFrozen(): boolean;
+    /**
+     * Scans the tree for signs of serious bugs (e.g. this.size doesn't match
+     * number of elements, internal nodes not caching max element properly...)
+     * Computational complexity: O(number of nodes), i.e. O(size). This method
+     * skips the most expensive test - whether all keys are sorted - but it
+     * does check that maxKey() of the children of internal nodes are sorted.
+    */
+    checkValid(): void;
+}
+/** Leaf node / base class. **************************************************/
+declare class BNode<K, V> {
+    keys: K[];
+    values: V[];
+    isShared: true | undefined;
+    readonly isLeaf: boolean;
+    constructor(isLeaf: boolean, keys?: K[], values?: V[]);
+    maxKey(): K;
+    indexOf(key: K, failXor: number, cmp: (a: K, b: K) => number): index;
+    minKey(): K | undefined;
+    minPair(reusedPair?: [K, V]): [K, V] | undefined;
+    maxPair(reusedPair?: [K, V]): [K, V] | undefined;
+    clone(): BNode<K, V>;
+    greedyClone(force?: boolean): BNode<K, V>;
+    get(key: K, defaultValue: V | undefined, map: SortedMap<K, V>): V | undefined;
+    getPairOrNextLower(key: K, compare: (a: K, b: K) => number, inclusive: boolean, reusedPair?: [K, V]): [K, V] | undefined;
+    getPairOrNextHigher(key: K, compare: (a: K, b: K) => number, inclusive: boolean, reusedPair?: [K, V]): [K, V] | undefined;
+    checkValid(depth: number, map: SortedMap<K, V>, baseIndex: number): number;
+    set(key: K, value: V, overwrite: boolean | ISortedMap.SetPairCallback<K, V> | undefined, map: SortedMap<K, V>): boolean | BNode<K, V>;
+    reifyValues(): V[];
+    insertInLeaf(i: index, key: K, value: V, overwrite: boolean | ISortedMap.SetPairCallback<K, V> | undefined, map: SortedMap<K, V>): boolean;
+    takeFromRight(rhs: BNode<K, V>): void;
+    takeFromLeft(lhs: BNode<K, V>): void;
+    splitOffRightSide(): BNode<K, V>;
+    forRange<R>(low: K, high: K, includeHigh: boolean | undefined, editMode: boolean, map: SortedMap<K, V>, count: number, onFound?: ISortedMap.EditRangeCallback<K, V, R>): ISortedMap.EditRangeResult<V, R> | number;
+    /**
+     * Adds entire contents of right-hand sibling (rhs is left unchanged)
+     */
+    mergeSibling(rhs: BNode<K, V>, _: number): void;
+}
+type index = number;
+/**
+ * {@inheritDoc SortedMap}
+ * @see
+ * ### **Interface**
+ *
+ * {@link SortedMap}
+ */
+export declare namespace SortedMap {
+    const DeleteValue: Readonly<{
+        delete: true;
+    }>;
+    const Break: Readonly<{
+        break: true;
+    }>;
+    const DeleteRange: () => Readonly<{
+        delete: true;
+    }>;
+    /**
+     * Types that SortedMap supports by default
+     */
+    type DefaultComparable = number | string | Date | boolean | null | undefined | (number | string)[] | {
+        valueOf: () => number | string | Date | boolean | null | undefined | (number | string)[];
+    };
+    /** A SortedMap frozen in the empty state. */
+    const EmptySortedMap: SortedMap<any, any>;
+    /**
+     * Compares DefaultComparables to form a strict partial ordering.
+     *
+     * Handles +/-0 and NaN like Map: NaN is equal to NaN, and -0 is equal to +0.
+     *
+     * Arrays are compared using '<' and '>', which may cause unexpected equality:
+     * for example [1] will be considered equal to ['1'].
+     *
+     * Two objects with equal valueOf compare the same, but compare unequal to
+     * primitives that have the same value.
+     */
+    function defaultComparator(a: DefaultComparable, b: DefaultComparable): number;
+    /**
+     * Compares items using the < and > operators. This function is probably slightly
+     * faster than the defaultComparator for Dates and strings, but has not been benchmarked.
+     * Unlike defaultComparator, this comparator doesn't support mixed types correctly,
+     * i.e. use it with `SortedMap<string>` or `SortedMap<number>` but not `SortedMap<string|number>`.
+     *
+     * NaN is not supported.
+     *
+     * Note: null is treated like 0 when compared with numbers or Date, but in general
+     *   null is not ordered with respect to strings (neither greater nor less), and
+     *   undefined is not ordered with other types.
+     */
+    function simpleComparator(a: string, b: string): number;
+    function simpleComparator(a: number | null, b: number | null): number;
+    function simpleComparator(a: Date | null, b: Date | null): number;
+    function simpleComparator(a: (number | string)[], b: (number | string)[]): number;
+}
+export {};
+//# sourceMappingURL=SortedMap.d.ts.map

package/types/src/collections/SortedMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SortedMap.d.ts","sourceRoot":"","sources":["../../../../src/collections/SortedMap.ts"],"names":[],"mappings":"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"}

package/types/src/collections/SparseGrid.d.ts

@@ -0,0 +1,99 @@
+import { CellCoords, Direction, RangeAxis, RangeCoords } from '@sheetxl/utils';
+import { Tuple } from './Tuple';
+import { IReadableList } from './IReadableList';
+import { IGrid } from './IGrid';
+import { ISparseGrid } from './ISparseGrid';
+/**
+ * Implementation of {@link IGrid} that uses a ISparseList of ISparseList.
+ */
+export declare class SparseGrid<T = any> implements ISparseGrid<T> {
+    private _major;
+    private _dataCoords;
+    private _count;
+    private _isColumn;
+    private _lastMajor;
+    private _lastMinorSpan;
+    private _maxCoords;
+    private _options;
+    private _optionsMinor;
+    private _isShared;
+    private _createRun;
+    constructor(options?: SparseGrid.ConstructorOptions);
+    /**
+     * Returns an IterableIterator over all the runs in the sparse grid.
+     * Each run is a contiguous list of values in the grid.
+     *
+     * @returns An iterator that yields [majorIndex, minorIndex, IReadableList] entries
+     */
+    /** {@inheritDoc ISparseGrid.getMaxCoords} */
+    getRuns(options?: ISparseGrid.RunIteratorOptions): ISparseGrid.RunIterableIterator<T>;
+    /** {@inheritDoc IGrid.getAxis} */
+    getAxis(): RangeAxis;
+    /** {@inheritDoc IGrid.entries} */
+    entries(options?: IGrid.IteratorOptions): IGrid.EntryIterator<T>;
+    /** {@inheritDoc IGrid.values} */
+    values(options?: IGrid.IteratorOptions): IGrid.ValueIterator;
+    /** {@inheritDoc IGrid.keys} */
+    keys(options?: IGrid.IteratorOptions): IGrid.KeyIterator;
+    private _updateMajorSpan;
+    /** {@inheritDoc IGrid.setValues} */
+    setValues(values: Tuple.GridTuple<T>): this;
+    /** {@inheritDoc IGrid.getValues} */
+    getValues(coords?: RangeCoords): Tuple.BoundedTuples<T> | null;
+    private _updateCountAndCoords;
+    /** {@inheritDoc IGrid.clear} */
+    clear(): void;
+    /** {@inheritDoc IGrid.delete} */
+    delete(range: RangeCoords | null): boolean;
+    /** {@inheritDoc IGrid.shift} */
+    shift(range: RangeCoords, direction: Direction): boolean;
+    /** {@inheritDoc IGrid.getCount} */
+    getCount(): number;
+    /** {@inheritDoc IGrid.getValueAt} */
+    getValueAt(row: number, column: number): T;
+    /** {@inheritDoc IGrid.setValueAt} */
+    setValueAt(row: number, column: number, value: T): void;
+    /** {@inheritDoc IGrid.copyTo} */
+    copyTo(destination: IGrid, topLeft: CellCoords, from: RangeCoords): void;
+    /** {@inheritDoc IGrid.getCoords} */
+    getCoords(): RangeCoords | null;
+    /** {@inheritDoc IGrid.clone} */
+    clone(cloneKey?: string): this;
+    /** {@inheritDoc IGrid.cloneEmpty} */
+    cloneEmpty(cloneKey?: string): this;
+    /** {@inheritDoc IGrid.getMaxCoords} */
+    getMaxCoords(): RangeCoords | null;
+    get [Symbol.toStringTag](): string;
+}
+/**
+ * {@inheritDoc SparseGrid}
+ * @see
+ * ### **Interface**
+ *
+ * {@link SparseGrid}
+ */
+export declare namespace SparseGrid {
+    /**
+     * For constructing a SparseGrid.
+     */
+    interface ConstructorOptions<T = any> {
+        /**
+         * If not specified then unlimited bounds.
+         * @defaultValue undefined
+         */
+        maxCoords?: Partial<RangeCoords>;
+        /**
+         * Determines the axis that cells are visited.
+         *
+         * @defaultValue RangeAxis.Column
+         */
+        axis?: RangeAxis;
+        /**
+         * Hook to allow for custom storing of contiguous values.
+         *
+         * @param values The values to wrap in a List.
+         */
+        createRun?: (values: T[]) => IReadableList<T>;
+    }
+}
+//# sourceMappingURL=SparseGrid.d.ts.map

package/types/src/collections/SparseGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparseGrid.d.ts","sourceRoot":"","sources":["../../../../src/collections/SparseGrid.ts"],"names":[],"mappings":"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"}

package/types/src/collections/SparseList.d.ts

@@ -0,0 +1,90 @@
+import { RunCoords } from '@sheetxl/utils';
+import { IListLike } from './IList';
+import { IReadableList } from './IReadableList';
+import { ISparseList } from './ISparseList';
+/**
+ * A SparseList implemented using a SortedMap of contiguous ReadableLists/WritableLists.
+ */
+export declare class SparseList<T = any> implements ISparseList<T> {
+    private _options;
+    private _runs;
+    private _dataCoords;
+    private _count;
+    private _length;
+    private _maxCoords;
+    private _reuseRunsIterator;
+    private _reuseRunsEntry;
+    private _lastRunsRead;
+    private _lastListRead;
+    constructor(options?: SparseList.ConstructorOptions);
+    private _validateBounds;
+    /** {@inheritDoc IReadableList.entries} */
+    entries(options?: IReadableList.IteratorOptions): IReadableList.EntryIterator<T>;
+    /** {@inheritDoc ISparseList.runs} */
+    runs(options?: ISparseList.RunIteratorOptions): ISparseList.RunIterator<T>;
+    /** {@inheritDoc IReadableList.slice} */
+    slice(start: number, end?: number): ISparseList<T>;
+    /** {@inheritDoc IReadableList.concat} */
+    concat(list: IListLike<T>): ISparseList<T>;
+    /** {@inheritDoc IReadableList.toArray} */
+    toArray(maxLength?: number, includeEmpty?: boolean): T[];
+    /** {@inheritDoc IReadableList.isIReadableList} */
+    get isIReadableList(): true;
+    /** {@inheritDoc IListLike.length} */
+    get length(): number;
+    /** {@inheritDoc ISparseList.clear} */
+    getCoords(): RunCoords | null;
+    /** {@inheritDoc ISparseList.clear} */
+    clear(): void;
+    /** {@inheritDoc ISparseList.isISparseList} */
+    get isISparseList(): true;
+    /** {@inheritDoc IList.isIList} */
+    get isIList(): true;
+    private _updateCount;
+    private _update;
+    /** {@inheritDoc IWritableList.setAt} */
+    setAt(index: number, value: T): boolean;
+    /** {@inheritDoc ISparseList.setRunAt} */
+    setRunAt(index: number, list: IReadableList<T>): boolean;
+    /** {@inheritDoc IWritableList.delete} */
+    delete(start: number, amount?: number): boolean;
+    /** {@inheritDoc IWritableList.shift} */
+    shift(index: number, amount: number): boolean;
+    /** {@inheritDoc IListLike.at} */
+    at(index: number): T | undefined;
+    [Symbol.iterator](): IterableIterator<T>;
+    /** {@inheritDoc IWritableList.clone} */
+    clone(): this;
+    /** {@inheritDoc ISparseList.getMaxCoords} */
+    getMaxCoords(): RunCoords | null;
+    /** {@inheritDoc ISparseList.getCount} */
+    getCount(): number;
+    /** {@inheritDoc ISparseList.getRunsCount} */
+    getRunsCount(): number;
+    get [Symbol.toStringTag](): string;
+}
+/**
+ * {@inheritDoc SparseList}
+ * @see
+ * ### **Interface**
+ *
+ * {@link SparseList}
+ */
+export declare namespace SparseList {
+    /**
+     * For constructing a SparseList.
+     */
+    interface ConstructorOptions {
+        /**
+         * If not specified then unlimited bounds.
+         *
+         * @defaultValue undefined
+         */
+        maxCoords?: RunCoords;
+        /**
+         * @defaultValue 4
+         */
+        nodeSize?: number;
+    }
+}
+//# sourceMappingURL=SparseList.d.ts.map

package/types/src/collections/SparseList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparseList.d.ts","sourceRoot":"","sources":["../../../../src/collections/SparseList.ts"],"names":[],"mappings":"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"}