@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

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

@@ -0,0 +1,41 @@
+/**
+ * Provides write operations to an ordered collection of items, similar to an {@link Array}
+ * but with the option to set an array values and to clone.
+ */
+export interface IWritableList<T = any> {
+    /**
+     * Sets a value at the given index.
+     *
+     * @param index The offset location for the values to be placed.
+     * @param value The value.
+     */
+    setAt(index: number, value: T): boolean;
+    /**
+     * This acts similar to Array.splice but without the option to insert.
+     *
+     * To add items use {@link IReadableList.concat}.
+     *
+     * @param start The index to start.
+     * @param amount If omitted then all items to the end of the list will be removed.
+     * @see
+     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice}
+     */
+    delete(start: number, amount?: number): boolean;
+    /**
+     * Shift values in a given direction.
+     *
+     * @param index The start of the shift.
+     * @param amount The amount to shift. A positive number is an insert and a negative number is a delete.
+     * @returns true is data was shifted.
+     */
+    shift(index: number, amount: number): boolean;
+    /**
+     * Creates a logical copy of the current values.
+     *
+     * Undo and branching works by creating 'copies' and then rolling back or commit these later.
+     * @remarks
+     * If this is not available then undo does not work for values.
+     */
+    clone?(): this;
+}
+//# sourceMappingURL=IWritableList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IWritableList.d.ts","sourceRoot":"","sources":["../../../../src/collections/IWritableList.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,GAAC,GAAG;IAClC;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IACxC;;;;;;;;;OASG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAChD;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9C;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,IAAI,CAAC;CAChB"}

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

@@ -0,0 +1,52 @@
+import { IListLike } from './IList';
+import { IReadableList } from './IReadableList';
+/**
+ * Wraps an {@link Array} to implement {@link IReadableList}.
+
+ * This assumes all records are immutable.
+ *
+ * By assuming all objects are immutable we can make significant performance optimizations
+ * using a similar strategy to SlicedStrings and only perform logical copies.
+ *
+ * @remarks
+ * The full {@link Array} interface is not supported.
+ *
+ * @see
+ * * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice}
+ * * {@link https://stackoverflow.com/questions/72540410/time-complexity-of-slice-in-javascript-v8-runtime}
+ */
+export declare class ImmutableList<T> implements IReadableList<T> {
+    /** Single backing list — set when no slicing has occurred. */
+    private _single;
+    /** Sliced run array — set after slice() or concat() produces multiple segments. */
+    private _runs;
+    private _length;
+    /** Single-entry cache of the last-accessed run, to skip binary search on sequential reads. */
+    private _runCache;
+    constructor(values?: T[] | IListLike<T>);
+    /**
+     * Returns the value at a given index.
+     *
+     * @param index The index to retrieve.
+     * @returns The value
+     */
+    at(index: number): T | undefined;
+    /** {@inheritDoc IReadableList.toArray} */
+    toArray(maxLength?: number): T[];
+    /** {@inheritDoc IReadableList.entries} */
+    entries(options?: IReadableList.IteratorOptions): IReadableList.EntryIterator<T>;
+    /** {@inheritDoc IReadableList.slice} */
+    slice(start: number, end?: number): IReadableList<T>;
+    /** {@inheritDoc IReadableList.concat} */
+    concat(list: IListLike<T>): IReadableList<T>;
+    /** {@inheritDoc IReadableList.length} */
+    get length(): number;
+    [Symbol.iterator](): IterableIterator<T>;
+    /** {@inheritDoc IReadableList.isIReadableList} */
+    get isIReadableList(): true;
+    /** {@inheritDoc IList.isIList} */
+    get isIList(): true;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+}
+//# sourceMappingURL=ImmutableList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImmutableList.d.ts","sourceRoot":"","sources":["../../../../src/collections/ImmutableList.ts"],"names":[],"mappings":"AAGA,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IACvD,8DAA8D;IAC9D,OAAO,CAAC,OAAO,CAA6B;IAC5C,mFAAmF;IACnF,OAAO,CAAC,KAAK,CAAsD;IACnE,OAAO,CAAC,OAAO,CAAa;IAC5B,8FAA8F;IAC9F,OAAO,CAAC,SAAS,CAAoD;gBAEzD,MAAM,CAAC,EAAE,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC;IASvC;;;;;OAKG;IACH,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAC,SAAS;IAwB9B,0CAA0C;IAC1C,OAAO,CAAC,SAAS,GAAE,MAA8B,GAAG,CAAC,EAAE;IAavD,0CAA0C;IAC1C,OAAO,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,eAAe,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;IAiHhF,wCAAwC;IACxC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC;IA6DpD,yCAAyC;IACzC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC;IAgH5C,yCAAyC;IACzC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAIxC,kDAAkD;IAClD,IAAI,eAAe,IAAI,IAAI,CAE1B;IAED,kCAAkC;IAClC,IAAI,OAAO,IAAI,IAAI,CAElB;IAED,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,QAAQ,IAAI,MAAM;CAanB"}

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

@@ -0,0 +1,91 @@
+import { RunCoords } from '@sheetxl/utils';
+import { IReadableList } from './IReadableList';
+export interface DisposableIterableIterator<T> extends IterableIterator<T>, Disposable {
+    [Symbol.iterator](): DisposableIterableIterator<T>;
+}
+/**
+ * Perform a forEach over an iterable. Honors {@link Iterator.return} and {@link Iterator.throw}.
+ *
+ * @param iterable The iterable to visit.
+ * @param callbackfn The forEach function.
+ * @param map The Map interface.
+ * @param _thisArg If provided, this will bind `this` to the callback function.
+ */
+export declare function doForEach<K = any, V = any, M = any>(iterator: Iterator<[K, V]>, callbackfn: (value: V, key: K, map: M) => void, map?: M, _thisArg?: any): void;
+/**
+ * Wraps an iterator in an Iterable.
+ *
+ * @param iterator The iterator to wrap.
+ * @see
+ * * {@link https://patrickdesjardins.com/blog/understand-typeScript-iterator-and-iterable}
+ * * {@link https://github.com/leebyron/iterall}
+ */
+export declare function iteratorToIterable<T, TReturn, TNext>(iterator: Iterator<T, TReturn, TNext>): DisposableIterableIterator<T>;
+/**
+ * Visits all iterators and adds to an array.
+ */
+export declare function pushIteratorToArray<T, TReturn, TNext>(iterator: Iterator<T, TReturn, TNext>, array: (T | TReturn)[]): void;
+/**
+ * Wrap entries iterator in an Iterable
+ */
+export declare function entriesToIterable<T>(iterator: Iterator<IReadableList.Entry<T>, IReadableList.Entry<T>, number>): IterableIterator<T>;
+/**
+ * Creates a processSkip callback from a valid set of RunCoords.
+ *
+ * @param skipRuns A valid set of RunCoords.
+ * @returns A callback that can be used with {@link IReadableList.IteratorOptions.processSkip}.
+ *
+ * @remarks
+ * * For performance reasons RunCoords are not validated; If validation is not certain use `RunUtils.validateRuns`.
+ * * Returns a state function so createSkipProcessor should be called for each createIterator.
+ */
+export declare function createSkipProcessor(skipRuns: readonly RunCoords[]): (index: number, reverse?: boolean) => number;
+/**
+ * Sharable iterator used when the Iterator is complete.
+ */
+export declare const DoneIteratorResult: IteratorResult<any, any>;
+/**
+ * Sharable IterableIterator that return no results.
+ */
+export declare const DoneIterator: IterableIterator<any>;
+/**
+ * Sharable IteratorResult for not done.
+ */
+export declare const ReusableResults: IteratorResult<any>;
+/**
+ * A utility class that provides an iterable iterator for 2D arrays
+ */
+export declare class Array2DIterator<T> implements IterableIterator<T> {
+    private readonly array;
+    private row;
+    private col;
+    private readonly rowEnd;
+    private readonly colEnd;
+    /**
+     * Creates a new 2D array iterator
+     *
+     * @param array The 2D array to iterate
+     * @param rowStart Starting row index (default: 0)
+     * @param colStart Starting column index (default: 0)
+     * @param rowEnd Ending row index (default: array.length)
+     * @param colEnd Ending column index (default: max column length)
+     */
+    constructor(array: T[][], colStart?: number, rowStart?: number, colEnd?: number, rowEnd?: number);
+    /**
+     * Returns the iterator itself
+     */
+    [Symbol.iterator](): IterableIterator<T>;
+    /**
+     * Gets the next value in the iteration sequence
+     */
+    next(): IteratorResult<T>;
+}
+/**
+ * Creates a new iterator that maps values from a source iterator through a callback function
+ *
+ * @param sourceIterator The source iterator to map values from
+ * @param mapFn The mapping function to apply to each value
+ * @returns A new iterator with mapped values
+ */
+export declare function mapIterator<T, U>(sourceIterator: Iterator<T>, mapFn: (value: T) => U): IterableIterator<U>;
+//# sourceMappingURL=IteratorUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IteratorUtils.d.ts","sourceRoot":"","sources":["../../../../src/collections/IteratorUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAIpD,MAAM,WAAW,0BAA0B,CAAC,CAAC,CAAE,SAC7C,gBAAgB,CAAC,CAAC,CAAC,EAAE,UAAU;IAE/B,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,0BAA0B,CAAC,CAAC,CAAC,CAAC;CACpD;AAED;;;;;;;GAOG;AAEH,wBAAgB,SAAS,CAAC,CAAC,GAAC,GAAG,EAAE,CAAC,GAAC,GAAG,EAAE,CAAC,GAAC,GAAG,EAC3C,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAC1B,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,EAC9C,GAAG,CAAC,EAAE,CAAC,EACP,QAAQ,CAAC,EAAE,GAAG,GACb,IAAI,CAsBN;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAClD,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,GACpC,0BAA0B,CAAC,CAAC,CAAC,CAW/B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EACnD,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EACrC,KAAK,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,EAAE,GACrB,IAAI,CAMN;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,GACzE,gBAAgB,CAAC,CAAC,CAAC,CAerB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,SAAS,SAAS,EAAE,GAC7B,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,MAAM,CAuC9C;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAGtD,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,gBAAgB,CAAC,GAAG,CAK7C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,GAAG,CAG9C,CAAC;AAGH;;GAEG;AACH,qBAAa,eAAe,CAAC,CAAC,CAAE,YAAW,gBAAgB,CAAC,CAAC,CAAC;IAC5D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC;;;;;;;;OAQG;gBAED,KAAK,EAAE,CAAC,EAAE,EAAE,EACZ,QAAQ,GAAE,MAAU,EACpB,QAAQ,GAAE,MAAU,EACpB,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM;IAkBjB;;OAEG;IACH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAIxC;;OAEG;IACH,IAAI,IAAI,cAAc,CAAC,CAAC,CAAC;CAsB1B;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAC9B,cAAc,EAAE,QAAQ,CAAC,CAAC,CAAC,EAC3B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GACrB,gBAAgB,CAAC,CAAC,CAAC,CAqBrB"}

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

@@ -0,0 +1,140 @@
+import { IListLike } from './IList';
+/**
+ * Stores mixed value types in an ArrayBuffer or a SharedArrayBuffer.
+ *
+ * Enable more efficient storage of mixed types in a single array.
+ * Supports fully shared between threads without copy.
+ *
+ * @remarks
+ * * Implements {@link IListLike} — expects all values to be immutable.
+ * * Supports numbers (int32, float32, float64, bigint), booleans, null, and undefined natively.
+ * * Strings and errors are stored as ordinal references; provide `getCoercedValue` to resolve them.
+ * * Custom types (128–255) are supported via `getCoercedKey` / `getCoercedValue` callbacks.
+ */
+export declare class MixedTypedArrayList<T = any> implements IListLike<T> {
+    private _l;
+    private _at;
+    private _dt;
+    private _a32;
+    private _a64;
+    private _cv;
+    private _vt;
+    private _vi32;
+    private _vi64;
+    private _vf32;
+    private _vf64;
+    constructor(options: MixTypedArrayListConstructorOptions);
+    /**
+     * Returns constructor options that can used to recreate the MixedTypedArrayList.
+     */
+    getConstructorOptions(): MixTypedArrayListConstructorOptions;
+    /** {@inheritDoc IListLike.at} */
+    at(index: number): T | undefined;
+    /** {@inheritDoc IListLike.toArray} */
+    toArray(maxLength: number): T[];
+    /** {@inheritDoc IListLike.length} */
+    get length(): number;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    protected static _createArrayBuffer(length: number): ArrayBufferLike;
+    /**
+     * Creates a MixedTypedArrayList from an array.
+     *
+     * @param array The array to convert.
+     * @param getCoercedKey A function that returns a key for a complex value.
+     * @param getCoercedValue A function that returns a coerced value for a given key.
+     * @param getCoerceType A function that returns a type for a given value.
+     * @returns A MixedTypedArrayList.
+     *
+     * @remarks
+     * - `getCoercedKey` will generally be a map id.
+     */
+    static fromArray<T = any>(array: T[], getCoercedKey?: (type: number, value: T) => number, getCoercedValue?: (type: number, key: number) => T, getCoerceType?: (value: T) => number, threshold64?: number): MixedTypedArrayList;
+}
+export interface MixTypedArrayListConstructorOptions<T = any> {
+    /**
+     * The length of the array.
+     */
+    length: number;
+    /**
+      * The array used for storing types.
+      *
+      * @remarks
+      * This is the default type if types is not provided.
+      */
+    type: number;
+    /**
+     * The array used for storing types.
+     *
+     * @remarks
+     * This must be a Uint8Array. This or type must be provided.
+     */
+    types?: ArrayBufferLike | null;
+    /**
+     * Stores 32bit values.
+     *
+     * @remarks
+     * If this is not provided then all values stored in values64.
+     * * Must be 32bit aligned
+     */
+    values32?: ArrayBufferLike | null;
+    /**
+     * Stores 64 bit overflow values or all 64 bit values if is64Bit is `true`.
+     *
+     * @remarks
+     * * This behave different depending on if the values32 is provided.
+     * * * values32 is provided - This stores 32 bit values and 32 bit references to 64 bit values.
+     * * * values32 is NOT provided - Then this is used for all values and values32 is not used.
+     * * Must be 64bit aligned
+     */
+    values64?: ArrayBufferLike | null;
+    /**
+     *
+     * Returns a value for a given type The default implementation auto coerces ints/floats/boolean and 'null'.
+     *
+     * @param type An 8bit number. Will always be between 0 and 255.
+     * @param key The key as either a 32bit or 64bit integer.
+     * @returns Returns a coerced value.
+     *
+     * @remarks
+     * This is used for returning string lookup, error lookup, or custom.
+     */
+    getCoercedValue?: ((type: number, key: number) => T) | null;
+}
+/**
+ * Defines the list of Known valid type codes for a MixedTypedArrayList.
+ *
+ * @remarks
+ * MixedTypedArray stores a type using an Uint8Array. The first
+ * 127 bits are reserved for known types. The last 128-255 are
+ * reserved for custom types.
+ *
+ * @see
+ * {@link MixTypedArrayListConstructorOptions.coerceType}
+ */
+export declare const KnownType: {
+    readonly Null: 0;
+    readonly Boolean: 1;
+    readonly Integer: 2;
+    readonly Float: 3;
+    readonly Integer64: 4;
+    readonly Float64: 5;
+    readonly String: 6;
+    readonly Error: 7;
+    readonly PosInfinity: 16;
+    readonly NegInfinity: 17;
+    readonly NaN: 18;
+    readonly MaxSafeInteger: 19;
+    readonly MinSafeInteger: 20;
+    readonly Undefined: 15;
+    readonly Unknown: 127;
+};
+/**
+ * Return a 8 bit int that represents the type to using in the type array.
+ *
+ * @param value The value of the type. Only the type is used
+ * @param custom If provided this will be called if the type is not well known. Must return a value between '128' and '255'.
+ * @returns a number representing a type between '0' and '255'.
+ */
+export declare function getBuiltinCoerceType<T = any>(value: T, custom?: (T: any) => number): number;
+//# sourceMappingURL=MixedTypedArrayList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MixedTypedArrayList.d.ts","sourceRoot":"","sources":["../../../../src/collections/MixedTypedArrayList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;;GAWG;AAaH,qBAAa,mBAAmB,CAAC,CAAC,GAAC,GAAG,CAAE,YAAW,SAAS,CAAC,CAAC,CAAC;IAC7D,OAAO,CAAC,EAAE,CAAa;IACvB,OAAO,CAAC,GAAG,CAAgC;IAC3C,OAAO,CAAC,GAAG,CAA+B;IAC1C,OAAO,CAAC,IAAI,CAAgC;IAC5C,OAAO,CAAC,IAAI,CAAgC;IAE5C,OAAO,CAAC,GAAG,CAAqD;IAGhE,OAAO,CAAC,GAAG,CAA2B;IACtC,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,KAAK,CAA6B;gBAE9B,OAAO,EAAE,mCAAmC;IA+BxD;;OAEG;IACH,qBAAqB,IAAI,mCAAmC;IAW5D,iCAAiC;IACjC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAmDhC,sCAAsC;IACtC,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,EAAE;IAU/B,qCAAqC;IACrC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,QAAQ,IAAI,MAAM;IAclB,SAAS,CAAC,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe;IASpE;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,SAAS,CAAC,CAAC,GAAC,GAAG,EACpB,KAAK,EAAE,CAAC,EAAE,EACV,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,EAClD,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,EAClD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,EACpC,WAAW,GAAE,MAA4B,GAExC,mBAAmB;CA6JvB;AAED,MAAM,WAAW,mCAAmC,CAAC,CAAC,GAAC,GAAG;IACxD;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;QAKI;IACJ,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,KAAK,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAClC;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAClC;;;;;;;;;;OAUG;IACH,eAAe,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC;CAC7D;AA6BD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;CAiBZ,CAAC;AAEX;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAC,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,MAAM,GAAG,MAAM,CAiEzF"}

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

@@ -0,0 +1,91 @@
+import { RangeAxis, RangeCoords, CellCoords, RangeCoordValue } from '@sheetxl/utils';
+/**
+ * Iterate over a collection of overlapping RangeCoords.
+ *
+ * This will iterator over CellCoords or RangeCoords.
+ */
+type ESIterator<T, TReturn = any, TNext = undefined> = Iterator<T, TReturn, TNext>;
+export declare namespace OverlappingRange {
+    interface IteratorOptions {
+        /**
+         * The direction of the scan.
+         * @defaultValue RangeAxis.Row
+         */
+        axis?: RangeAxis;
+        /**
+         * Set iterator to increment by cells within an intersection.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * Depending on the range intersect it is possible that some scan lines will be duplicated.
+         * This is desired as it makes merging ranges easier/possible.
+         */
+        byCell?: boolean;
+        /**
+         * Iterate in reverse order.
+         * @defaultValue false
+         */
+        reverse?: boolean;
+        /**
+         * If provided then iterator results will reuse the return results.
+         *
+         * @defaultValue `undefined` (Creates new instances for each iterator)
+         *
+         * @remarks
+         * - **Performance:** Setting this to `true` can drastically improve performance for large ranges,
+         *   but it will modify the original range data.
+         * - **Safety:**  If you need to preserve the original range data, set this to `false`.
+         */
+        reuseIterator?: boolean | IteratorResult<OverlappingRange.Intersection>;
+    }
+    /**
+     * When iterating a cursor is used to track the
+     * current location. The coords will always move forward.
+     */
+    interface Intersection {
+        /**
+         * The current coords.
+         */
+        cell: CellCoords;
+        /**
+         * This is a non-overlapping virtual range.
+         *
+         * @remarks
+         * This is not guaranteed to be the smallest packing size.
+         */
+        range: RangeCoords;
+        /**
+         * All ranges at the intersection. This may be a single range.
+         */
+        overlaps: RangeCoordValue[];
+    }
+    type Iterator = ESIterator<Intersection, Intersection, CellCoords>;
+    class IteratorInstance implements Iterator, IterableIterator<Intersection> {
+        private _isColumn;
+        private _isByCell;
+        private _isReverse;
+        private _cursor;
+        private _reuse;
+        private _localReuse;
+        private _eventsMajor;
+        private _eventMajorIndex;
+        private _majorStart;
+        private _majorEnd;
+        private _eventsMinor;
+        private _eventsMinorIterator;
+        private _eventMinorPeek;
+        private _minorStart;
+        private _minorEnd;
+        constructor(ranges: readonly RangeCoordValue[], options?: IteratorOptions);
+        /**
+         * Returns the next Intersection as a IteratorResult.
+         */
+        next(nextCell?: CellCoords): IteratorResult<Intersection>;
+        return(_value?: Intersection): IteratorResult<Intersection>;
+        throw(_e?: any): IteratorResult<Intersection>;
+        [Symbol.iterator](): IterableIterator<Intersection>;
+    }
+}
+export {};
+//# sourceMappingURL=OverlappingRangeIterator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OverlappingRangeIterator.d.ts","sourceRoot":"","sources":["../../../../src/collections/OverlappingRangeIterator.ts"],"names":[],"mappings":"AAAA,OAAO,EACO,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,eAAe,EAC/E,MAAM,gBAAgB,CAAC;AAMxB;;;;GAIG;AAUH,KAAK,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,GAAG,EAAE,KAAK,GAAG,SAAS,IAAI,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;AAEnF,yBAAiB,gBAAgB,CAAC;IAChC,UAAiB,eAAe;QAC9B;;;WAGG;QACH,IAAI,CAAC,EAAE,SAAS,CAAC;QACjB;;;;;;;;WAQG;QACH,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB;;;WAGG;QACH,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB;;;;;;;;;WASG;QACH,aAAa,CAAC,EAAE,OAAO,GAAG,cAAc,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;KACzE;IAED;;;OAGG;IACH,UAAiB,YAAY;QAC3B;;WAEG;QACH,IAAI,EAAE,UAAU,CAAC;QACjB;;;;;WAKG;QACH,KAAK,EAAE,WAAW,CAAC;QACnB;;WAEG;QACH,QAAQ,EAAE,eAAe,EAAE,CAAC;KAC7B;IAED,KAAY,QAAQ,GAAG,UAAU,CAAC,YAAY,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IAkJ1E,MAAa,gBAAiB,YAAW,QAAQ,EAAE,gBAAgB,CAAC,YAAY,CAAC;QAC/E,OAAO,CAAC,SAAS,CAAe;QAChC,OAAO,CAAC,SAAS,CAAgB;QACjC,OAAO,CAAC,UAAU,CAAgB;QAGlC,OAAO,CAAC,OAAO,CAA6B;QAE5C,OAAO,CAAC,MAAM,CAA6C;QAE3D,OAAO,CAAC,WAAW,CAAoF;QAEvG,OAAO,CAAC,YAAY,CAA6B;QACjD,OAAO,CAAC,gBAAgB,CAAa;QAErC,OAAO,CAAC,WAAW,CAAa;QAChC,OAAO,CAAC,SAAS,CAAa;QAE9B,OAAO,CAAC,YAAY,CAA+B;QACnD,OAAO,CAAC,oBAAoB,CAA0C;QACtE,OAAO,CAAC,eAAe,CAAqD;QAE5E,OAAO,CAAC,WAAW,CAAa;QAChC,OAAO,CAAC,SAAS,CAAa;oBAElB,MAAM,EAAE,SAAS,eAAe,EAAE,EAAE,OAAO,CAAC,EAAE,eAAe;QAqGzE;;WAEG;QACH,IAAI,CAAC,QAAQ,CAAC,EAAE,UAAU,GAAG,cAAc,CAAC,YAAY,CAAC;QAuazD,MAAM,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,cAAc,CAAC,YAAY,CAAC;QAI3D,KAAK,CAAC,EAAE,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC,YAAY,CAAC;QAK7C,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,YAAY,CAAC;KAGpD;CACF"}

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

@@ -0,0 +1,111 @@
+import { RangeCoordValue, RangeCoords } from '@sheetxl/utils';
+/**
+ * 2D spatial index for range-coordinate items.
+ *
+ * Use this to answer "which items overlap this region?" without a linear scan.
+ *
+ * @typeParam T must extend `RangeCoordValue` (carries `colStart/rowStart/colEnd/rowEnd`)
+ *
+ * @TODO See RTree-REDESIGN.md for planned structural changes.
+ */
+export declare class RTree<T extends RangeCoordValue> {
+    protected _maxEntries: number;
+    protected _minEntries: number;
+    protected _data: Node<T>;
+    /**
+     * Constructs an `RTree`, a high-performance 2D spatial index for points and
+     * rectangles. Based on an optimized __R-tree__ data structure with
+     * __bulk-insertion__ support.
+     *
+     * @param maxEntries An optional argument to RTree defines the maximum
+     *                   number of entries in a tree node. `9` (used by default)
+     *                   is a reasonable choice for most applications. Higher
+     *                   value means faster insertion and slower search, and
+     *                   vice versa.
+     */
+    constructor(maxEntries?: number);
+    /** Returns all items contained in the tree. */
+    all(result?: T[]): T[];
+    /**
+     * Returns an array of data items (points or rectangles) that the given
+     * bounding box intersects.
+     */
+    search(coords: RangeCoords, results?: T[]): T[];
+    /**
+     * Returns `true` if there are any items intersecting the given bounding
+     * box, otherwise `false`.
+     */
+    collides(coords: RangeCoords): boolean;
+    /**
+     * Quick check to see if there are any elements.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the bounding box of all items in the tree, or `null` if the tree is empty.
+     */
+    getBoundingRange(): RangeCoords | null;
+    /**
+     * Bulk-inserts the given items into the tree.
+     *
+     * Bulk insertion is usually ~2-3 times faster than inserting items one by one.
+     * After bulk loading (bulk insertion into an empty tree), subsequent query
+     * performance is also ~20-30% better.
+     */
+    load(items: readonly T[]): RTree<T>;
+    /**
+     * Removes multiple items in a single tree traversal.
+     * Without `equals`, items are matched by reference — O(1) per leaf, same identity
+     * as objects returned by `search()`.
+     * Pass `equals` to match by value instead — O(M) per leaf, same semantics as `remove()`.
+     * Either way, more efficient than calling `remove()` in a loop for M > ~10 items.
+     */
+    removeAll(items: T[], equals?: (a: T, b: T) => boolean): RTree<T>;
+    /**
+     * Removes all items.
+     */
+    clear(): RTree<T>;
+    /**
+     * Inserts an item. To insert many items at once, use `load()`.
+     */
+    insert(item: T): RTree<T>;
+    /**
+     * Removes a previously inserted item, comparing by reference.
+     * Pass `equals` to compare by value instead.
+     */
+    remove(item: T, equals?: (a: T, b: T) => boolean): RTree<T>;
+    protected _all(node: Node<T>, result: T[]): T[];
+    protected _build(items: T[], left: number, right: number, height: number): Node<T>;
+    protected _chooseSubtree(coords: RangeCoordValue, node: Node<T>, level: number, path: Node<T>[]): Node<T>;
+    protected _insert(node: Node<T>, level: number): void;
+    protected _split(insertPath: Node<T>[], level: number): void;
+    protected _splitRoot(node: Node<T>, newNode: Node<T>): void;
+    protected _chooseSplitIndex(node: Node<T>, min: number, length: number): number;
+    protected _chooseSplitAxis(node: Node<T>, min: number, length: number): void;
+    protected _allDistMargin(node: Node<T>, min: number, length: number, compare: (a: Node<T>, b: Node<T>) => number): number;
+}
+/**
+ * Internal R-tree node.
+ *
+ * - Leaf nodes: `children === null`, `range` is a cast of the user item (`T`), `height === 0`.
+ * - Internal nodes: `children` is an array of child nodes, `range` is the mutable aggregate
+ *   bounding box of all descendants, `height >= 1`.
+ */
+interface Node<T> {
+    range: RangeCoordValue<T>;
+    children: Node<T>[] | null;
+    height: number;
+}
+/**
+ * Rearranges items so that all items in the [left, k] are the smallest.
+ * The k-th element will have the (k - left + 1)-th smallest value in [left, right].
+ *
+ * @template T
+ * @param arr the array to partially sort (in place)
+ * @param k middle index for partial sorting (as defined above)
+ * @param left left index of the range to sort
+ * @param right right index
+ * @param compare compare function
+ */
+export declare function quickSelect<T>(arr: T[], k: number, left?: number | undefined, right?: number | undefined, compare?: ((a: T, b: T) => number) | undefined): void;
+export {};
+//# sourceMappingURL=RTree.d.ts.map

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

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

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

@@ -0,0 +1,20 @@
+import { IList, IListLike } from './IList';
+/**
+ * Implements a virtual list {@link IListLike} by repeating the values of an underlying list.
+ *
+ * This is done to allow for compressions of values in memory.
+ */
+export declare class RepeatingList<T> implements IList<T> {
+    private _u;
+    private _l;
+    constructor(underlyingList: IListLike<T>, virtualLength: number);
+    /** {@inheritDoc IListLike.at} */
+    at(index: number): T | undefined;
+    toArray(maxLength?: number): T[];
+    /** {@inheritDoc IListLike.length} */
+    get length(): number;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc IList.isIList} */
+    get isIList(): true;
+}
+//# sourceMappingURL=RepeatingList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RepeatingList.d.ts","sourceRoot":"","sources":["../../../../src/collections/RepeatingList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAErD;;;;GAIG;AACH,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,KAAK,CAAC,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,CAA2B;IACrC,OAAO,CAAC,EAAE,CAAa;gBAEX,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM;IAO/D,iCAAiC;IACjC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAOhC,OAAO,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE;IAYhC,qCAAqC;IACrC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,kCAAkC;IAClC,IAAI,OAAO,IAAI,IAAI,CAAiB;CACrC"}