@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

package/types/src/primitives/Range.d.ts

@@ -0,0 +1,221 @@
+import { IRange, FormulaError, ScalarType, MaybeError, Scalar, IRangeStats, IRuntime } from '@sheetxl/primitives';
+import { Tuple, IGrid, ISparseGrid, ISpatialMap } from '../collections';
+export declare class Range<T extends Scalar = Scalar> implements IRange<T> {
+    protected _runtime: IRuntime;
+    protected _values: ISparseGrid<Scalar>;
+    protected _coords: IRange.Coords | null;
+    protected _optionsIterator: Omit<IRange.IteratorOptions, 'axis'> & {
+        axis?: IRange.Axis;
+    };
+    /**
+     * Excel has 'special' logic around parsing of literals for both literal ranges and
+     * literal scalars.
+     * Because we auto-marshall to Ranges but want to have this logic we need to
+     * create special flags.
+     */
+    protected _isLiteral: boolean;
+    protected _isDirectScalar: boolean;
+    protected _localRangeStats: IRangeStats | null;
+    /** The `options` {@link _localRangeStats} was built for — the memo's key. See `getStats`. */
+    protected _localRangeStatsOptions: IRange.IteratorOptions | undefined;
+    constructor(runtime: IRuntime, values: ISparseGrid<Scalar>, coords: IRange.Coords | null, optionsIterator?: IRange.IteratorOptions | null, isLiteral?: boolean, isDirectScalar?: boolean);
+    /** @inheritdoc IRange.argsort */
+    argsort(keyRanges?: IRange | IRange[], orders?: number | number[], axis?: IRange.Axis): number[];
+    /** @inheritdoc IRange.uniqueIndices */
+    uniqueIndices(axis?: IRange.Axis, exactlyOnce?: boolean): number[];
+    /** @inheritdoc IRange.broadcast */
+    broadcast<TS extends Scalar = T>(other: IRange | TS, callbackFn: (a: TS, b: TS, coords: IRange.CellCoords, range: IRange<T>) => TS, options?: IRange.BroadcastOptions): this;
+    /**
+     * {@link broadcast} against a scalar operand: this range's OWN entries, with every empty position
+     * written as a run of one computed value. See the call site for why the general path cannot.
+     *
+     * @remarks
+     * Reached only for a coord-blind callback, so the single empty call carries the origin coords.
+     */
+    private _broadcastScalar;
+    /** @inheritdoc IRange.choose */
+    choose<TS extends Scalar = T>(from: (IRange<TS> | TS)[], selectFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => MaybeError<number>, options?: IRange.ValuesOptions): this;
+    /** @inheritdoc IRange.clear */
+    clear(): this;
+    /** @inheritdoc IRange.clone */
+    clone(options?: IRange.IteratorOptions, isLiteral?: boolean, isDirectScalar?: boolean): this;
+    /** @inheritdoc IRange.compute */
+    compute(fn: (range: IRange) => IRange): this;
+    /** @inheritdoc IRange.concat */
+    concat(other: IRange, axis?: IRange.Axis, padWith?: Scalar): this;
+    /** @inheritdoc IRange.empty */
+    empty(): this;
+    /** @inheritdoc IRange.entries */
+    entries<TS extends Scalar = T>(options?: IRange.IteratorOptions): IterableIterator<IRange.Entry<TS>>;
+    /** @inheritdoc IRange.errors */
+    errors(options?: Pick<IRange.IteratorOptions, 'axis' | 'bounds' | 'reverse'>): IterableIterator<IRange.Entry<FormulaError.Known>>;
+    /** @inheritdoc IRange.every */
+    every<TS extends Scalar = T>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => boolean, options?: IRange.IteratorOptions): boolean;
+    /** @inheritdoc IRange.fill */
+    fill(value: Scalar, coords?: Partial<IRange.Coords>): this;
+    /** @inheritdoc IRange.fillEmpty */
+    fillEmpty(value: Scalar, coords?: Partial<IRange.Coords>): this;
+    /** @inheritdoc IRange.filter */
+    filter<TS extends Scalar = T>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => boolean, options?: IRange.IteratorOptions): this;
+    /** @inheritdoc IRange.flatten */
+    flatten<TS extends Scalar = T>(options?: IRange.IteratorOptions): TS[];
+    /** @inheritdoc IRange.forEach */
+    forEach<TS extends Scalar = T, B = any>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => {
+        break: B;
+    } | void, options?: IRange.IteratorOptions): B | void;
+    /** @inheritdoc IRange.getColumnCount */
+    getColumnCount(): number;
+    /** @inheritdoc IRange.getRowCount */
+    getRowCount(): number;
+    /** {@inheritDoc IRange.getShape} */
+    getShape(): {
+        rows: number;
+        columns: number;
+    };
+    /** @inheritdoc IRange.getStats */
+    getStats(options?: IRange.IteratorOptions): IRangeStats;
+    /** @inheritdoc IRange.hasError */
+    hasError(): boolean;
+    /** {@inheritDoc IRange.getType} */
+    getType(): ScalarType | undefined;
+    /** @inheritdoc IRange.getValueAt */
+    getValueAt<TS extends Scalar = T>(rowIndex: number, colIndex: number, options?: IRange.ValueOptions): TS;
+    /** @inheritdoc IRange.getValues */
+    getValues<TS extends Scalar = T>(options?: IRange.GetValuesOptions): TS[][];
+    /** @inheritdoc IRange.map */
+    map<TS extends Scalar = T>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => TS, options?: IRange.IteratorOptions): this;
+    /** @inheritdoc IRange.mask */
+    mask<TS extends Scalar = T>(conditions: IRange | TS, isTrues?: IRange | TS, options?: IRange.MaskOptions): this;
+    /** @inheritdoc IRange.alignValues */
+    alignValues<TS extends Scalar = T>(others: (IRange | null)[], options?: IRange.IteratorOptions): IterableIterator<[values: (TS | null)[], coords: IRange.CellCoords]>;
+    /** @inheritdoc IRange.alignReduce */
+    alignReduce<TS extends Scalar = T, U = TS>(others: IRange | null | (IRange | null)[], callbackFn: (accumulator: U, values: (TS | null)[], coords: IRange.CellCoords, range: IRange<T>) => U, initialValue: U, options?: IRange.ReduceOptions<U>): U;
+    /** @inheritdoc IRange.reduce */
+    reduce<TS extends Scalar = T, U = TS>(callbackFn: (accumulator: U, value: TS, coords: IRange.CellCoords, range: IRange<T>) => U, initialValue: U, options?: IRange.IteratorOptions): U;
+    /** @inheritdoc IRange.repeat */
+    repeat(rows: number, columns: number): this;
+    /** @inheritdoc IRange.reshape */
+    reshape(rows: number, columns: number): this;
+    /** @inheritdoc IRange.replace */
+    replace<TS extends Scalar = T>(other: IRange | TS[][], coords?: IRange.CellCoords): this;
+    /** @inheritdoc IRange.resize */
+    resize(rows: number, cols: number, fillValue?: Scalar): this;
+    /** @inheritdoc IRange.select */
+    select<TS extends Scalar = T>(match: IRange<TS> | TS | (IRange<TS> | TS)[], from: (IRange<TS> | TS)[], defaultValue?: IRange<TS> | TS, selectFn?: (value: TS, coords: IRange.CellCoords, matchValue: TS, matchCoords: IRange.CellCoords, range: IRange<T>) => MaybeError<boolean>, options?: IRange.ValuesOptions): this;
+    /** @inheritdoc IRange.slice */
+    slice(coords: Partial<IRange.Coords>): this;
+    /** @inheritdoc IRange.some */
+    some<TS extends Scalar = T>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => boolean, options?: IRange.IteratorOptions): boolean;
+    /** @inheritdoc IRange.sort */
+    sort(order?: number, axis?: IRange.Axis): this;
+    /** @inheritdoc IRange.sparseBuilder */
+    sparseBuilder<TS extends Scalar = T>(options?: IRange.TraversalAxis | IRange.SparseBuilderOptions): IRange.SparseBuilder<TS>;
+    /**
+     * Use to collect values when the indices are small relative to the size of the data to avoid materialization overhead.
+     * @internal
+     */
+    protected _takeSparse(indices: readonly number[], axis: IRange.Axis): this;
+    /**
+     * When the indices are close to the size of the data we materialize and iterate.
+     * @internal
+     */
+    protected _takeDense(indices: readonly number[], axis: IRange.Axis): this;
+    /** @inheritdoc IRange.take */
+    take(indices: readonly number[], axis?: IRange.Axis): this;
+    /** @inheritdoc IRange.tile */
+    tile(rows: number, columns: number): this;
+    /** @inheritdoc IRange.toScalar */
+    toScalar(): Scalar;
+    /** @inheritdoc IRange.toType */
+    toType(type: ScalarType | IRange.ValueOptions): this;
+    /** @inheritdoc IRange.transpose */
+    transpose(): this;
+    /** @inheritdoc IRange.values */
+    values<T extends Scalar = Scalar>(options?: IRange.IteratorOptions): IterableIterator<T>;
+    /** @inheritdoc IRange.zip */
+    zip(others: (IRange | Scalar)[], callbackFn: (values: Scalar[], coords: IRange.CellCoords, range: IRange<T>) => Scalar, options?: IRange.IteratorOptions): this;
+    /** {@inheritDoc IRange.isLiteral} */
+    isLiteral(): boolean;
+    /** Not on IRange — the boxed-bare-scalar flag; see `_isDirectScalar`. */
+    isDirectScalar(): boolean;
+    /** {@inheritDoc IRange.isScalar} */
+    isScalar(): boolean;
+    /** {@inheritDoc IRange.isEmpty} */
+    isEmpty(): boolean;
+    /** {@inheritDoc IRange.isVector} */
+    isVector(): boolean;
+    /** @inheritdoc IRange.size */
+    get size(): number;
+    /** {@inheritDoc IRange[Symbol.iterator]} */
+    [Symbol.iterator](): IterableIterator<Scalar>;
+    /** {@inheritDoc IRange.toString} */
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+    protected _validateCoords(coords: Partial<IRange.Coords>): void;
+    protected _axisFromOptions(options?: IRange.TraversalAxisOptions | IRange.TraversalAxis): IRange.Axis;
+    protected _toStringValues(stopLength?: number): string;
+    protected _entries(options?: IRange.IteratorOptions & {
+        reuseResult?: boolean;
+    }): IGrid.EntryIterator<Scalar>;
+    /**
+     * Finds an absolute intersection given a relative coord.
+     */
+    protected _absoluteCoords(coordsRel: Partial<IRange.Coords>, reuse?: IRange.Coords): IRange.Coords | null;
+    /**
+     * Returns self but accounts for literal status.
+     */
+    protected _self(): this;
+    /**
+     * Returns this range with its read type dropped, or `this` when there is nothing to drop.
+     *
+     * @remarks
+     * For a range whose values are no longer the ones the type described — see `map`. `coerce` goes
+     * with it: it is inert without a `type` (both `_entries` and `_coerceValue` gate on one), and
+     * leaving it behind would let the SOURCE's coercion rules apply to a later `toType` on values
+     * the source never held.
+     *
+     * **The contract, so this stays consistent.** A read type is a claim about the values a range
+     * HOLDS. It survives exactly as long as those values do:
+     *
+     * | operation | type | why |
+     * | --- | --- | --- |
+     * | `map` · `broadcast` · `zip` | **dropped** | a callback produced new values; the range cannot know what they are. A caller that DOES know retypes after — `TypedFunction` does, from the declared return type. |
+     * | `filter` · `slice` · `sort` · `resize` | **kept** | selection and rearrangement only. Every surviving member is one the source already held, so the claim is still true — a filtered `number` range is still a `number` range. |
+     * | `replace` · `fillEmpty` · `fill` · `mask` | **kept** | substitution with CALLER-supplied values. Kept deliberately (these are overwhelmingly used to write same-typed values), but it is the one row that is a judgement rather than a consequence: a caller that substitutes a differently-typed value re-reads it through the old type. Unaudited; no instance found.
+     *
+     * Note this is NOT "any operation returning a range drops its type" — only the three that run
+     * a callback do. Getting that wrong in either direction is a silent value bug: dropping too
+     * eagerly loses `MONTH`'s number-ness, keeping too eagerly is CALC-ISSUES item 36
+     * (`SUMPRODUCT(--ISNUMBER(SEARCH(...)))` → 0).
+     */
+    protected _untyped(): this;
+    protected _createBuilder(axis?: IRange.Axis): Tuple.IBuilder;
+    protected _applyBuilder(values: ISparseGrid<Scalar>, builder: Tuple.IBuilder, clone?: boolean): ISparseGrid<Scalar>;
+    protected _cloneFromBuilder(builder: Tuple.IBuilder | undefined, deletes?: ISpatialMap.IConflatingEntries | null): this;
+    protected _coerceValue<TS extends Scalar>(fromValue: Scalar, toType: ScalarType, options?: IRange.ValueOptions, fromType?: ScalarType): TS;
+    protected _mergeIterators<T = Scalar>(that: Range, callbackFn?: (a: T, b: T, coords: IRange.CellCoords, range: IRange) => T, options?: IRange.IteratorOptions): Tuple.IBuilder;
+    protected _newRange(values: ISparseGrid<Scalar>, coords: IRange.Coords | null, optionsIterator?: IRange.IteratorOptions | null, isLiteral?: boolean, isDirectScalar?: boolean): this;
+    /** @inheritdoc IRange.isIRange */
+    get isIRange(): true;
+}
+/**
+ * A `Range` whose `getCoords()`/shape is unchanged, but whose `getStats()` is rescoped to
+ * `visibleCoords` — used by `condition/_ConditionUtils.ts` so `AverageOperator`/`TopNOperator`
+ * get correct order-dependent Top N / Average semantics under a running filter mask
+ * (`condition/DESIGN-FILTER.md` §2), via `RangeStats.toLocalCoords`.
+ *
+ * Lives here (rather than in `condition/`, where it's used) so `extends Range` is resolved by
+ * plain source order within this file, not cross-module import order: `condition/` sits deep in
+ * an import cycle that reaches back into `primitives/` through `PrimitiveUtils.ts` →
+ * `sheet/_SheetUtils.ts` → … → `condition/Condition.ts`, and a top-level `extends Range` declared
+ * in `condition/` can execute before that cycle has finished defining `Range`
+ * (`ReferenceError: Cannot access 'Range' before initialization` — reproduced 2026-08-18 by
+ * running the actual bundle; see git history).
+ */
+export declare class _VisibleScopedRange extends Range {
+    protected _visibleCoords: readonly IRange.Coords[];
+    constructor(runtime: IRuntime, values: ISparseGrid<Scalar>, coords: IRange.Coords, visibleCoords: readonly IRange.Coords[]);
+    /** {@inheritDoc IRange.getStats} */
+    getStats(options?: IRange.IteratorOptions): IRangeStats;
+}
+//# sourceMappingURL=Range.d.ts.map

package/types/src/primitives/Range.d.ts.map

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

package/types/src/primitives/RangeStats.d.ts

@@ -0,0 +1,48 @@
+import { ScalarType, IRange, IRuntime, IRangeStats, Scalar } from '@sheetxl/primitives';
+import { ISparseGrid } from '../collections';
+import { SortedNumbers, AggSegmentCache } from './stats';
+export declare class RangeStats implements IRangeStats {
+    protected _runtime: IRuntime;
+    protected _grid: ISparseGrid<Scalar>;
+    protected _range: IRange | null;
+    protected _localCoords: readonly (IRange.Coords | null)[];
+    protected _iteratorOptions?: IRange.IteratorOptions;
+    protected _segmentCache: AggSegmentCache;
+    protected _ZoneSizeMinor: number;
+    protected _sortedNumbers: SortedNumbers | undefined;
+    protected _aggregates: IRangeStats.Aggregates | undefined;
+    protected _typedCounts: Readonly<Record<ScalarType, number>> | undefined;
+    protected _frequencies: Readonly<IRangeStats.IFrequency> | undefined;
+    protected _ranked: readonly Scalar[] | undefined;
+    protected _lastNumber: number | null | undefined;
+    constructor(runtime: IRuntime, grid: ISparseGrid<Scalar>, range: IRange | null, localCoords?: readonly (IRange.Coords | null)[], options?: IRange.IteratorOptions, segmentCache?: AggSegmentCache, zoneSizeMinor?: number);
+    clone(grid?: ISparseGrid<Scalar>, localCoords?: readonly (IRange.Coords | null)[]): this;
+    clear(): void;
+    /** Lazily resolved, then held for this instance's lifetime like the other per-instance results. */
+    protected _getLastNumber(): number | undefined;
+    toLocalCoords(coords: IRange.Coords | readonly IRange.Coords[], iteratorOptions?: IRange.IteratorOptions): IRangeStats;
+    /** @inheritdoc IRangeStats.getSize */
+    getSize(): number;
+    /** @inheritdoc IRangeStats.getCount */
+    getCount(): number;
+    /** @inheritdoc IRangeStats.getAggregates */
+    getAggregates(options?: IRange.IteratorOptions): Readonly<IRangeStats.Aggregates>;
+    /** @inheritdoc IRangeStats.getSnappedSum */
+    getSnappedSum(total?: number): number;
+    /** @inheritdoc IRangeStats.getSortedNumbers */
+    getSortedNumbers(): IRangeStats.ISortedNumbers;
+    /** @inheritdoc IRangeStats.getRanked */
+    getRanked(options?: IRangeStats.GetRankedOptions): IterableIterator<Scalar>;
+    /** @inheritdoc IRangeStats.getFrequencies */
+    getFrequencies(options?: IRangeStats.GetFrequenciesOptions): Readonly<IRangeStats.IFrequency>;
+    protected _buildFrequencies(options?: IRangeStats.GetFrequenciesOptions): Readonly<IRangeStats.IFrequency>;
+    /** The workbook's own comparison rule — the same one behind `=`/`<`/`SORT`/`argsort`. */
+    protected _defaultCompare(): (a: Scalar, b: Scalar) => number;
+    /** @inheritdoc IRangeStats.getTypedCounts */
+    getTypedCounts(types?: readonly ScalarType[]): {
+        [key in ScalarType]?: number;
+    };
+    /** {@inheritDoc IRangeStats.isIRangeStats} */
+    get isIRangeStats(): true;
+}
+//# sourceMappingURL=RangeStats.d.ts.map

package/types/src/primitives/RangeStats.d.ts.map

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

package/types/src/primitives/ReferenceRange.d.ts

@@ -0,0 +1,19 @@
+import { Scalar, ScalarType, IReferenceRange, IRange, IRuntime } from '@sheetxl/primitives';
+import { ISparseGrid } from '../collections';
+import { Range } from './Range';
+export declare class ReferenceRange extends Range implements IReferenceRange {
+    protected _getEntireCoords: () => IRange.Coords;
+    protected _resolveScope: (scope: string) => string | undefined;
+    constructor(runtime: IRuntime, values: ISparseGrid<Scalar>, coords: IRange.Coords, options: IRange.ValueOptions | null | undefined, getEntireCoords: (() => IRange.Coords) | undefined, resolveScope: (scope: string) => string | undefined);
+    /** @inheritdoc IReferenceRange.getCoords */
+    getCoords(): Readonly<IRange.Coords>;
+    /** @inheritdoc IReferenceRange.isIReferenceRange */
+    get isIReferenceRange(): true;
+    /** @inheritdoc IRange.toType */
+    toType(type: ScalarType | IRange.ValueOptions): this;
+    protected _validateCoords(coords: Partial<IRange.Coords>): void;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc IRange.toString} */
+    toString(): string;
+}
+//# sourceMappingURL=ReferenceRange.d.ts.map

package/types/src/primitives/ReferenceRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReferenceRange.d.ts","sourceRoot":"","sources":["../../../../src/primitives/ReferenceRange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,UAAU,EAAgB,KAAK,eAAe,EAAE,KAAK,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAMnI,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAMlD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,cAAe,SAAQ,KAAM,YAAW,eAAe;IAElE,SAAS,CAAC,gBAAgB,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC;IAEhD,SAAS,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;gBAK7D,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,EAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EACrB,OAAO,EAAE,MAAM,CAAC,YAAY,GAAG,IAAI,GAAG,SAAS,EAC/C,eAAe,EAAE,CAAC,MAAM,MAAM,CAAC,MAAM,CAAC,GAAG,SAAS,EAClD,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS;IAUrD,4CAA4C;IAC5C,SAAS,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;IAYpC,oDAAoD;IACpD,IAAI,iBAAiB,IAAI,IAAI,CAE5B;IAED,gCAAgC;IAChC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC,YAAY,GAAG,IAAI;IAapD,SAAS,CAAC,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI;IAa/D,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,oCAAoC;IACpC,QAAQ,IAAI,MAAM;CAenB"}

package/types/src/primitives/Runtime.d.ts

@@ -0,0 +1,55 @@
+import { IRuntime, LocaleProfile, LocaleProfileOverrides } from '@sheetxl/primitives';
+import { LicenseDetails } from '../license';
+export interface RuntimeOptions {
+    isDate1904?: () => boolean;
+    isR1C1?: () => boolean;
+    /**
+     * Returns the locale as a BCP 47 tag, e.g. "de-DE".
+     *
+     * @remarks
+     * Defaults to the environment locale. A workbook supplies its own persisted
+     * locale here so that regional behavior travels with the document.
+     */
+    getLocale?: () => string;
+    /**
+     * Returns the workbook's locale-profile overrides (the regional-override patch), or
+     * `null`/`undefined` for none. Patched literally over the `Intl`-derived profile.
+     */
+    getLocaleOverrides?: () => LocaleProfileOverrides | null;
+    /**
+     * Returns now as a long date time.
+     *
+     * @remarks
+     * This is not a serial date here.
+     */
+    getNow?: () => number;
+}
+export declare const defaultLocale: () => string;
+export declare const languageLocale: () => string | null;
+export declare class Runtime implements IRuntime {
+    protected _description: string;
+    protected _options: RuntimeOptions;
+    protected _license: LicenseDetails | undefined;
+    constructor(description?: string, options?: RuntimeOptions, license?: LicenseDetails);
+    /** @inheritdoc IRuntime.getDescription */
+    getDescription(): string;
+    /** @inheritdoc IRuntime.getLocale */
+    getLocale(): string;
+    /** @inheritdoc IRuntime.getNow */
+    getNow(): number;
+    /** @inheritdoc IRuntime.getLocaleProfile */
+    getLocaleProfile(): LocaleProfile;
+    /** @inheritdoc IRuntime.isDate1904 */
+    isDate1904(): boolean;
+    /** @inheritdoc IRuntime.isR1C1 */
+    isR1C1(): boolean;
+    /** @inheritdoc IRuntime.getLocation */
+    getLocation(): string;
+    /** @inheritdoc IRuntime.getVersion */
+    getVersion(): string;
+    /** @inheritdoc IRuntime.getOS */
+    getOS(): string;
+    /** @inheritdoc IRuntime.getUser */
+    getUser(): string | null;
+}
+//# sourceMappingURL=Runtime.d.ts.map

package/types/src/primitives/Runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Runtime.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAMrG,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD,MAAM,WAAW,cAAc;IAC7B,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC;IACvB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;IACzB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,sBAAsB,GAAG,IAAI,CAAC;IACzD;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAGD,eAAO,MAAM,aAAa,QAAO,MAMhC,CAAA;AAmBD,eAAO,MAAM,cAAc,QAAO,MAAM,GAAG,IAgB1C,CAAA;AAED,qBAAa,OAAQ,YAAW,QAAQ;IAEtC,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,QAAQ,EAAE,cAAc,CAAC;IACnC,SAAS,CAAC,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAC;gBAG7C,WAAW,GAAE,MAAwB,EACrC,OAAO,CAAC,EAAE,cAAc,EACxB,OAAO,CAAC,EAAE,cAAc;IAU1B,0CAA0C;IAC1C,cAAc,IAAI,MAAM;IAIxB,qCAAqC;IACrC,SAAS,IAAI,MAAM;IAInB,kCAAkC;IAClC,MAAM,IAAI,MAAM;IAIhB,4CAA4C;IAC5C,gBAAgB,IAAI,aAAa;IAIjC,sCAAsC;IACtC,UAAU,IAAI,OAAO;IAIrB,kCAAkC;IAClC,MAAM,IAAI,OAAO;IAIjB,uCAAuC;IACvC,WAAW,IAAI,MAAM;IAKrB,sCAAsC;IACtC,UAAU,IAAI,MAAM;IAcpB,iCAAiC;IACjC,KAAK,IAAI,MAAM;IAIf,mCAAmC;IACnC,OAAO,IAAI,MAAM,GAAG,IAAI;CAGzB"}

package/types/src/primitives/ScalarCollation.d.ts

@@ -0,0 +1,174 @@
+import { Scalar, LocaleProfile } from '@sheetxl/primitives';
+/**
+ * Excel's comparison rule for {@link Scalar} values, as one total order.
+ *
+ * @remarks
+ * This is the rule behind `=`, `<>`, `<`, `<=`, `>`, `>=`, behind the criteria comparisons in
+ * `COUNTIF`/`SUMIF`/`DSUM`, and behind `SORT`/`SORTBY`/`IRange.argsort`.
+ *
+ * ### Not public API
+ *
+ * `@sheetxl/primitives` declares the rule as `IFormulaContext.compare` and stubs it with a basic
+ * ordering; THIS is the Excel one, and it is deliberately not exported from the package barrel.
+ * Callers -- including `@sheetxl/formulas`, which sits BELOW this package and cannot import it at
+ * all -- reach it by way of the calculation context they are handed, which is what binds the rule
+ * to the workbook's locale. Only `CalculationContext` and the sort collators call in here directly;
+ * anything reading the global `FormulaContext` singleton outside an installed scope gets the basic
+ * ordering instead, which is a bug at the call site.
+ *
+ * ### Cross-type: rank, never coerce
+ *
+ * Excel does not coerce across types to compare; it ranks them, so **every** number is less than
+ * **every** text, and every text is less than every logical:
+ *
+ * > `number` &lt; `text` &lt; `FALSE` &lt; `TRUE`
+ *
+ * Hence `=1<"0"` is `TRUE` and `="9">TRUE` is `FALSE`. Errors sort last here so the order stays
+ * total. The OPERATORS never reach that case -- an error operand propagates before any comparison
+ * happens -- but a criteria does: `COUNTIF(A1:A9,">=#N/A")` counts the `#N/A` rows, and the code
+ * order below is Excel's, #NULL! &lt; #DIV/0! &lt; #VALUE! &lt; #REF! &lt; #NAME? &lt; #NUM! &lt;
+ * #N/A (measured, `formula-tests/probe-criteria-empty-operand2.ps1`).
+ *
+ * A criteria does NOT rank across types the way an operator does, though: it only considers values
+ * of the operand's own type, so `COUNTIF` with `"<TRUE"` counts no number even though `=1<TRUE` is
+ * `TRUE`. That partition lives in `Criteria`, not here.
+ *
+ * ### Blank
+ *
+ * A blank cell takes the *other* operand's type -- `0`, `""`, or `FALSE` -- so `=A1=0`, `=A1=""`
+ * and `=A1=FALSE` are all `TRUE` for an empty `A1`. Blank against blank is equal. (This is why
+ * `ISBLANK` exists: no comparison can distinguish a blank from those three values.)
+ *
+ * ### Numbers
+ *
+ * Equal when they agree to 15 SIGNIFICANT digits -- the same clamp Excel uses for display, which
+ * is what makes `=(0.1+0.2)=0.3` report `TRUE` while `=1E-12=2E-12` reports `FALSE`. Being
+ * relative matters at both ends: `=2^60=1152921504606850000` is `TRUE` even though subtracting
+ * them gives `-3072`. Excel forgives float noise at the COMPARISON, never in the arithmetic.
+ *
+ * ### Text
+ *
+ * Case-INSENSITIVE (`="PM"="pm"` is `TRUE`; `EXACT` is the case-sensitive form) and COLLATED in
+ * the workbook locale, so `="a"<"B"` is `TRUE` and `="ä"<"z"` is `TRUE`. Accents and punctuation
+ * are real differences: `="a"="ä"` and `="co-op"="coop"` are both `FALSE`.
+ *
+ * Case is folded OUT of the operands and the collator then runs at FULL strength, rather than the
+ * collator being weakened to `sensitivity: 'accent'`. The two are not the same: in ICU, case, WIDTH
+ * and KANA are all tertiary differences, so a strength low enough to ignore case also ties
+ * fullwidth `Ａ` with `A` -- which Excel does not (`probe-text-equality-nls.ps1`). Folding case
+ * separately is the only way to ignore one tertiary difference and keep the others.
+ *
+ * The case toggle is therefore what a caller's `sensitivity` selects: `accent`/`base` fold, and
+ * `variant`/`case` do not. That is the user-facing switch the **sort** feature exposes
+ * (`Sort.CaseSensitiveOptions` / `LocaleProfile.collator`); the word sort below, the expansions,
+ * and the collation locale are shared either way. Sort does use a different TYPE order (errors and
+ * blanks last, blanks last even descending).
+ *
+ * ### Expansions
+ *
+ * A closed set of characters compares EQUAL to a letter sequence -- `="straße"="strasse"` and
+ * `="æ"="ae"` are both `TRUE`, and so are the ligatures and the LJ/NJ/DZ digraphs. This is Windows
+ * NLS behavior that ICU does not reproduce at any strength: at `accent` these are all unequal, and
+ * at `base`, where they do fold, accents fold away with them. They are therefore rewritten before
+ * collating, by `foldForCompare` in `./TextFold` -- which is also where the measured membership is
+ * documented, and which `UNIQUE` shares for the hashing side of the same rule.
+ *
+ * ### Word sort
+ *
+ * On top of the collator, Excel applies the "word sort" its Sort dialog documents -- and, measured,
+ * the operators apply it too. Dashes and apostrophes do not count when ordering; they only break a
+ * tie, where the string carrying them sorts LAST:
+ *
+ * > `"coop"` &lt; `"co-op"` &lt; `"cop"`
+ *
+ * A plain collator gives `"co-op" < "coop"` instead (`-` outranks `o`), which is the bug this
+ * exists to avoid. Equality is untouched -- the tiebreak never returns 0 for distinct strings, so
+ * `="co-op"="coop"` stays `FALSE`. Other punctuation is ordinary and still sorts before letters
+ * (`="a_b"<"ab"` is `TRUE`), which is why the collator stays non-ignorable.
+ *
+ * The ignorable set is the one Excel 16.0 actually uses, not a Unicode category -- notably U+2019
+ * (the "smart" apostrophe Word autocorrects to) is NOT in it, while U+02BC is. See
+ * `formula-tests/probe-wordsort.ps1`.
+ *
+ * ### Punctuation
+ *
+ * Every other mark is ordered by {@link _compareOrdered} rather than by the collator, because ICU
+ * and Windows NLS disagree about punctuation almost completely -- 191 of 741 measured pairs invert.
+ * `="*"<"?"` is `TRUE` in Excel and `FALSE` from a bare collator. Three classes, code-point order
+ * inside each: ordinary punctuation, then `+ < = >`, then digits and letters (where ICU is already
+ * right and still decides). See that function for what is measured and what is generalized.
+ *
+ * ### Determinism
+ *
+ * Collation is ICU data and varies by host. The locale is always the workbook's persisted tag,
+ * never the ambient host locale (passing `undefined` to `localeCompare` is a bug -- it reads the
+ * host). Note that a `small-icu` Node build carries `en-US` only and will silently collate a
+ * `de-DE` workbook as English; ship `full-icu` for non-English workbooks.
+ */
+export declare const ScalarCollation: {
+    /**
+     * The fixed `Intl.Collator` options for Excel's text comparison.
+     *
+     * @remarks
+     * `sensitivity: 'variant'` -- FULL strength -- because case is folded out of the operands
+     * instead (see the Text section above); weakening the collator to ignore case would tie
+     * fullwidth and kana forms along with it.
+     *
+     * `numeric: false` because Excel collates text lexicographically (`"Item10" < "Item2"`), and
+     * `ignorePunctuation: false` because `="co-op"="coop"` is `FALSE` and `="a_b"<"ab"` is `TRUE`.
+     * The narrower dash/apostrophe rule is the word sort in `compareTextWith`, not this flag --
+     * `ignorePunctuation: true` would drop whitespace and every other mark along with them.
+     */
+    Options: Intl.CollatorOptions;
+    /**
+     * Whether a caller's collator options mean "ignore case". Default (no options) is the operator
+     * rule, which does.
+     *
+     * @remarks
+     * The strength a caller asks for is read as the case TOGGLE, since that is the only thing the
+     * sort feature varies -- the collator itself always runs at full strength.
+     */
+    isCaseInsensitive: (options?: Intl.CollatorOptions) => boolean;
+    /**
+     * The (memoized) collator for a profile's locale.
+     *
+     * @remarks
+     * `Intl.Collator` construction is expensive and this sits in the calculation hot path, so
+     * collators are cached on the profile's identity -- no key to build per compare. Profiles are
+     * stable, derived objects (`getLocaleProfile` caches per tag), which is what makes the cache
+     * effective. Use {@link ScalarCollation.collatorFor} when the locale is not a profile.
+     */
+    collator: (profile: LocaleProfile) => Intl.Collator;
+    /**
+     * The (memoized) collator for an explicit locale.
+     *
+     * @remarks
+     * For sort, which carries a locale string rather than a profile. `options` contributes only
+     * `numeric`/`caseFirst`/`ignorePunctuation` -- its `sensitivity` is the case toggle, applied by
+     * folding rather than by strength, so it is deliberately NOT part of the key. Keyed by string
+     * because the options objects are caller-supplied and not stable by identity; that costs a key
+     * build per lookup, which is why the operator path uses `collator` instead.
+     */
+    collatorFor: (locale: string, options?: Intl.CollatorOptions) => Intl.Collator;
+    /**
+     * Order two strings by Excel's text rule, against a caller-supplied collator.
+     *
+     * @param caseInsensitive Whether case is folded out. Default `true`, the operator rule; sort
+     * passes {@link ScalarCollation.isCaseInsensitive} of its own options.
+     *
+     * @remarks
+     * Only the case toggle is the caller's; the expansions and the word sort layered over the
+     * collator are Excel's rule either way, so every path lands here rather than calling
+     * `Intl.Collator.compare` directly.
+     */
+    compareTextWith: (a: string, b: string, collator: Intl.Collator, caseInsensitive?: boolean) => number;
+    /**
+     * Order two scalars by Excel's comparison rule. Negative / zero / positive.
+     *
+     * @remarks
+     * Equality is `compare(a, b, profile) === 0` -- there is deliberately no separate equality
+     * entry point, so `=` and `<` cannot drift apart.
+     */
+    compare: (a: Scalar, b: Scalar, profile: LocaleProfile, options?: Intl.CollatorOptions) => number;
+};
+//# sourceMappingURL=ScalarCollation.d.ts.map

package/types/src/primitives/ScalarCollation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarCollation.d.ts","sourceRoot":"","sources":["../../../../src/primitives/ScalarCollation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;;;;;;OAYG;aAKG,IAAI,CAAC,eAAe;IAE1B;;;;;;;OAOG;kCAC2B,IAAI,CAAC,eAAe,KAAG,OAAO;IAK5D;;;;;;;;OAQG;wBACiB,aAAa,KAAG,IAAI,CAAC,QAAQ;IASjD;;;;;;;;;OASG;0BACmB,MAAM,YAAY,IAAI,CAAC,eAAe,KAAG,IAAI,CAAC,QAAQ;IAW5E;;;;;;;;;;OAUG;yBACkB,MAAM,KAAK,MAAM,YAAY,IAAI,CAAC,QAAQ,oBAAmB,OAAO,KAAU,MAAM;IAczG;;;;;;OAMG;iBACU,MAAM,KAAK,MAAM,WAAW,aAAa,YAAY,IAAI,CAAC,eAAe,KAAG,MAAM;CAoChG,CAAC"}

package/types/src/primitives/TextFold.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The character-level folding Excel applies before it compares two pieces of text.
+ *
+ * @remarks
+ * This is the part of the comparison rule that is pure character rewriting, with no locale and no
+ * collator involved. Two very different consumers need the same table: `ScalarCollation` folds its
+ * operands before collating them, and callers that must HASH text rather than compare it pairwise --
+ * `UNIQUE` dedupes a whole column through a `Map` -- need a key built from the same rule. A
+ * comparator cannot serve the second, and a key cannot serve the first (collation order is not
+ * derivable from a fold), so the shared piece is the fold.
+ *
+ * @see {@link foldForCompare} for the comparison side and {@link toCompareKey} for the hashing side.
+ */
+/**
+ * The form the collator should see: {@link Expansions} rewritten, then case folded out.
+ *
+ * @param text The text to fold.
+ * @param caseInsensitive Whether to fold case. `true` for Excel's comparison operators — `EXACT` is
+ * the case-sensitive form — and for a sort whose case toggle is off.
+ *
+ * @remarks
+ * Case is folded HERE rather than by weakening the collator because in ICU case, WIDTH and KANA are
+ * all tertiary differences: a strength low enough to ignore case also ties fullwidth `Ａ` with `A`,
+ * which Excel does not. Folding case out of the operands and collating at full strength is the only
+ * way to ignore one tertiary difference and keep the others.
+ *
+ * Deliberately NOT memoized. The shape every caller has — one fixed operand against a whole column —
+ * looks memoizable, but the calls alternate `(cell, target)`, so a one-slot cache is evicted before
+ * the fixed operand asks again, and a measured two-slot version cost as much to consult as the fold
+ * costs to do (`replace` returns the input unchanged when nothing matches, so the expansion pass is
+ * a scan with no allocation). A caller with a genuinely fixed operand should hoist
+ * {@link toCompareKey} instead, as `UNIQUE` does.
+ */
+export declare function foldForCompare(text: string, caseInsensitive?: boolean): string;
+/**
+ * A hashable identity for text: two strings compare EQUAL if and only if their keys are `===`.
+ *
+ * @remarks
+ * For callers that must dedupe rather than order — `UNIQUE` builds one key per cell and hashes
+ * them, which no pairwise comparator can do at that size. `normalize('NFC')` stands in for the
+ * canonical equivalence the collator would apply, so a composed `é` and a decomposed `e`+`◌́` share
+ * a key.
+ *
+ * "If and only if" holds for everything a fold can express. It does NOT carry a locale's collation
+ * tailorings, so a pair that only some locale ties will hash apart. Order is not derivable from a
+ * key at all — use `IFormulaContext.compare` whenever a comparison will do.
+ */
+export declare function toCompareKey(text: string): string;
+/**
+ * Case-only fold — lowercases, but does NOT apply {@link Expansions}.
+ *
+ * @remarks
+ * AutoFilter's text-filter family (`Contains`/`StartsWith`/`EndsWith`/`EqualTo`'s string branch) is
+ * case-insensitive, but — verified against Excel COM (`Range.AutoFilter` wildcard/equal criteria) —
+ * it does NOT treat `"ß"` as equivalent to `"ss"` the way {@link foldForCompare} does for the `=`
+ * operator/collator: a criteria string typed with plain `"ss"` does not match a cell containing
+ * `"straße"`, and vice versa. So AutoFilter's text filters need this narrower, case-only rule rather
+ * than `foldForCompare` — same shared home in this file since it's still "the folding a text
+ * comparison applies before comparing," just a different comparison than `=`'s.
+ */
+export declare function foldCase(text: string): string;
+//# sourceMappingURL=TextFold.d.ts.map

package/types/src/primitives/TextFold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextFold.d.ts","sourceRoot":"","sources":["../../../../src/primitives/TextFold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAwBH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,GAAE,OAAc,GAAG,MAAM,CAGpF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C"}

package/types/src/primitives/_PrimitiveMessages.d.ts

@@ -0,0 +1,3 @@
+export declare const ERROR_FUNCTION_REQUIRED = "Item must be specified.";
+export declare const ERROR_NO_FUNCTION_SCOPE = "FunctionContext can only be used in a function.";
+//# sourceMappingURL=_PrimitiveMessages.d.ts.map

package/types/src/primitives/_PrimitiveMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_PrimitiveMessages.d.ts","sourceRoot":"","sources":["../../../../src/primitives/_PrimitiveMessages.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AAGjE,eAAO,MAAM,uBAAuB,oDAAoD,CAAC"}