@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

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

@@ -0,0 +1,7 @@
+export * from './Runtime';
+export * from './Range';
+export * from './ReferenceRange';
+export * from './RangeStats';
+export * from './CompositeRangeStats';
+export * as PrimitiveUtils from './PrimitiveUtils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,OAAO,KAAK,cAAc,MAAM,kBAAkB,CAAC"}

package/types/src/primitives/stats/AggregateStats.d.ts

@@ -0,0 +1,119 @@
+import { IRange, ScalarType, IRangeStats, Scalar, IRuntime } from '@sheetxl/primitives';
+import { IListLike, ISparseGrid } from '../../collections';
+/**
+ * Mutable accumulator used during iteration.
+ * A concrete (non-nullable) shape of `IRangeStats.Aggregates` plus `sumSq` for
+ * variance/stdDev computation. Not exposed outside this module.
+ */
+export type AggResults = {
+    count: number;
+    /** `undefined` until the first numeric value is aggregated. */
+    min: number | undefined;
+    max: number | undefined;
+    numericalCount: number;
+    sum: number;
+    sumSq: number;
+    /**
+     * Raw value counts keyed by {@link ScalarType} — recorded BEFORE coercion, so segment
+     * caches stay valid across callers with differing `IteratorOptions` (unlike
+     * `numericalCount`, which counts post-coercion).
+     */
+    typed: Record<ScalarType, number>;
+};
+/**
+ * Shared segment-cache holder.
+ *
+ * @remarks
+ * Cached segment CONTENT depends on exactly one iterator option: `coerce` (it changes which
+ * values aggregate numerically). A caller with a different `coerce` flushes and rebuilds —
+ * recalc-on-change rather than options-keying: one flavor cached at a time matches real usage
+ * (options rarely alternate over the same data). `onError` deliberately does NOT participate:
+ * every policy produces identical content (non-numbers never aggregate); throw/notify are side
+ * effects, replayed at merge time by rescanning cached segments that may contain errors.
+ *
+ * Shared BY REFERENCE across every stats instance over the same grid lineage (see
+ * {@link resolveAggSegmentCache}), so a flush here is observed by all of them.
+ */
+export type AggSegmentCache = {
+    coerce: unknown;
+    byRun: WeakMap<IListLike<Scalar>, AggResults[]>;
+};
+export declare const createAggSegmentCache: () => AggSegmentCache;
+export declare const resolveAggSegmentCache: (grid: ISparseGrid<Scalar>, inherit?: AggSegmentCache) => AggSegmentCache;
+/**
+ * The default minor zone size for segment caching.
+ *
+ * @remarks
+ * Zone sizes should be:
+ * - Powers of 2 (enables bit-shift division at floor/modulo sites)
+ * - Ideally matched to maxRow for column-oriented grids
+ */
+export declare const DefaultZoneSizeMinor: number;
+/**
+ * Returned by `getAggregates()` when the range is empty or contains no values.
+ *
+ * @remarks
+ * Every `IRangeStats.Aggregate` key is present — the shape is stable, never sparse.
+ */
+export declare const EmptyAggregates: Readonly<IRangeStats.Aggregates>;
+/**
+ * Iterates the grid over the given coords and returns raw aggregation results.
+ *
+ * @remarks
+ * Results are built using a segment cache keyed by run identity (`segmentsByRun`).
+ * The cache is shared across all coord shapes that derive from the same root `RangeStats`
+ * instance (via `toLocalCoords`), so segment aggregates computed for one shape are reused
+ * by any other shape that overlaps the same run segments.
+ *
+ * Returns `null` when the grid is empty.
+ */
+export declare function iterateAndCollectStats(runtime: IRuntime, grid: ISparseGrid<Scalar>, range: IRange | null, localCoords: readonly (IRange.Coords | null)[], optionsIterator: IRange.IteratorOptions | undefined, segmentCache: AggSegmentCache, zoneSizeMinor: number): AggResults | null;
+/**
+ * The value Excel added LAST — the final numeric member in ROW-major order, which is the
+ * traversal Excel's accumulators use (measured: `probe-sum-cancel-order.ps1`, two mirrored 2-D
+ * layouts). Coerces exactly as the aggregate scan does, so `AVERAGEA`'s text-counts-as-zero
+ * agrees here and a trailing text cell defeats the cancellation snap just as a trailing `0`
+ * does.
+ *
+ * Returns `undefined` when the query holds no numbers.
+ *
+ * @remarks
+ * Deliberately NOT part of `AggResults` and NOT segment-cached. Row-major "last" is a position
+ * comparison, and segments merge in GRID-axis order, so carrying it through the cache would mean
+ * tracking `(row, col)` per value in `_doAggregateValue` — a cost on the hottest loop in the
+ * engine, paid by every caller, to serve a rule that fires only on catastrophic cancellation.
+ * Instead this is a separate scan behind {@link mayCancel}'s gate, which rejects any ordinary
+ * total using `min`/`max` the aggregates already carry. A forward scan tracking the maximum
+ * `(row, col)` is used rather than reverse iteration because the grid's run iterator has no
+ * reverse, and this way the result is independent of the grid's axis.
+ */
+export declare function findLastNumber(runtime: IRuntime, grid: ISparseGrid<Scalar>, range: IRange | null, localCoords: readonly (IRange.Coords | null)[], optionsIterator: IRange.IteratorOptions | undefined): number | undefined;
+/**
+ * Resolves an iterator's `coerce` option into the callable pair the scans use.
+ *
+ * @remarks
+ * Shared by {@link iterateAndCollectStats} and {@link findLastNumber} so the two can never
+ * disagree about which values count as numbers — they answer about the same population, and a
+ * drift between them would show up only as a wrong cancellation snap. Called once per scan,
+ * never per value.
+ */
+export declare function resolveCoerce(runtime: IRuntime, optionsIterator: IRange.IteratorOptions | undefined): {
+    coerce: ((value: any, fromType: ScalarType, defaultCoerce: (fromValue: Scalar, fromType: ScalarType) => Scalar, range: IRange) => Scalar) | null;
+    defaultCoerce: ((fromValue: Scalar, fromType: ScalarType) => Scalar) | null;
+};
+/**
+ * Builds the final frozen `IRangeStats.Aggregates` from a raw `AggResults` accumulator.
+ * Computes derived fields (average, variance, stdDev) and normalizes missing-number fields to null.
+ */
+export declare function buildAggregates(raw: AggResults | null): Readonly<IRangeStats.Aggregates>;
+/**
+ * Calculates an optimal zone size for a given grid minor dimension.
+ *
+ * @remarks
+ * Strategy: target ~128 segments per full column/row to balance cache granularity
+ * (smaller = better reuse for small queries) vs. iteration overhead (fewer = faster
+ * full-column scans). Result is rounded up to the nearest power of 2 and clamped to
+ * [256, 16384].
+ */
+export declare function calculateZoneSize(maxMinorDimension: number): number;
+//# sourceMappingURL=AggregateStats.d.ts.map

package/types/src/primitives/stats/AggregateStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AggregateStats.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/stats/AggregateStats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAE,UAAU,EAAqB,KAAK,WAAW,EAAE,KAAK,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAExI,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMrE;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;CACnC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;CACjD,CAAC;AAEF,eAAO,MAAM,qBAAqB,QAAO,eAGvC,CAAC;AAkBH,eAAO,MAAM,sBAAsB,GACjC,MAAM,WAAW,CAAC,MAAM,CAAC,EACzB,UAAU,eAAe,KACxB,eAOF,CAAC;AAIF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,QAAkB,CAAC;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAAC,UAAU,CAW3D,CAAC;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EACzB,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,WAAW,EAAE,SAAS,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAC9C,eAAe,EAAE,MAAM,CAAC,eAAe,GAAG,SAAS,EACnD,YAAY,EAAE,eAAe,EAC7B,aAAa,EAAE,MAAM,GACpB,UAAU,GAAG,IAAI,CAsNnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EACzB,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,WAAW,EAAE,SAAS,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAC9C,eAAe,EAAE,MAAM,CAAC,eAAe,GAAG,SAAS,GAClD,MAAM,GAAG,SAAS,CAsEpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,QAAQ,EACjB,eAAe,EAAE,MAAM,CAAC,eAAe,GAAG,SAAS,GAClD;IACD,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,KAAK,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,IAAI,CAAC;IACjJ,aAAa,EAAE,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,KAAK,MAAM,CAAC,GAAG,IAAI,CAAC;CAC7E,CAcA;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,GAAG,QAAQ,CAAC,WAAW,CAAC,UAAU,CAAC,CAkCxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAKnE"}

package/types/src/primitives/stats/Cancellation.d.ts

@@ -0,0 +1,43 @@
+import { IRangeStats } from '@sheetxl/primitives';
+/**
+ * The largest absolute value an aggregate saw — `0` if it saw no numbers.
+ *
+ * `max(|min|, |max|)` is exact and free: `min` is the most negative member and `max` the most
+ * positive, so the biggest magnitude is necessarily one of those two, and both are already in
+ * every `Aggregates`. This is what made "carry `max(|value|)` in the aggregate accumulator"
+ * unnecessary — no hot-loop cost was added for this rule.
+ *
+ * NOT the reference the snap compares against — see {@link snapCancelledSum}.
+ */
+export declare const largestMagnitude: (agg: Readonly<IRangeStats.Aggregates>) => number;
+/**
+ * Cheap necessary condition for {@link snapCancelledSum}, computed from aggregates already in
+ * hand. False for every ordinary total, so callers can skip finding the last value — the only
+ * part of the rule that costs a range read.
+ *
+ * It cannot reject anything the real test would snap. The last add gives
+ * `accBefore = sum - last`, hence `|accBefore| <= |last| + |sum| <= largestMag + |sum|`, which
+ * is the bound below.
+ *
+ * A non-finite total has to be rejected EXPLICITLY. NaN falls out of the bound on its own
+ * (`NaN <= x` is false) but an overflowed one does not — `Infinity <= Infinity` is true, so an
+ * accumulator that overflowed sailed through both this gate and the snap and came back as a
+ * confident `0`. `SUM(9E+307,9E+307,-9E+307)` returned 0 where Excel returns #NUM!; silently
+ * answering zero for a sum that blew past the double range is the worst of the options. An
+ * overflow is not a cancellation, so it is left alone for `minCoerce` to report.
+ */
+export declare const mayCancel: (sum: number, largestMag: number) => boolean;
+/**
+ * Applies the rule to a total, given the value that was added last.
+ *
+ * @param sum The accumulated total.
+ * @param lastNumber The final addend — the last numeric member in row-major order, from the
+ *   last range that contributed one. `undefined` (no numbers) leaves `sum` untouched.
+ *
+ * @remarks
+ * `sum - lastNumber` reconstructs the accumulator as it stood before the final add, which is the
+ * reference. A range holding a single number therefore never snaps (`accBefore` is 0) — matching
+ * `SUM(1E-20)` → `1E-20`.
+ */
+export declare const snapCancelledSum: (sum: number, lastNumber: number | undefined) => number;
+//# sourceMappingURL=Cancellation.d.ts.map

package/types/src/primitives/stats/Cancellation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cancellation.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/stats/Cancellation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AA6DvD;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,QAAQ,CAAC,WAAW,CAAC,UAAU,CAAC,KAAG,MAIxE,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,YAAY,MAAM,KAAG,OAI3D,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,EAAE,YAAY,MAAM,GAAG,SAAS,KAAG,MAG9E,CAAC"}

package/types/src/primitives/stats/FrequencyStats.d.ts

@@ -0,0 +1,94 @@
+import { IRange, IRangeStats, Scalar } from '@sheetxl/primitives';
+import { ISparseGrid } from '../../collections';
+/**
+ * One distinct value's accumulated state. Exported so {@link CompositeRangeStats} can build a
+ * merged map with {@link FrequencyStats.fromGroups} without reaching into this file's privates.
+ */
+export interface FrequencyGroup {
+    readonly value: Scalar;
+    count: number;
+}
+/**
+ * Implements {@link IRangeStats.IFrequency}.
+ *
+ * @remarks
+ * Built in a single forward pass into one `Map` — no zone-segment caching (contrast
+ * {@link AggregateStats}'s `AggSegmentCache`). That is deliberate: none of the current callers
+ * (the `Unique`/`TopN` condition operators, AutoFilter dropdowns, per-region agent summaries)
+ * call this at the per-cell-per-calc-cycle rate the zone cache exists to amortize — each builds
+ * one instance, queries it, and discards it. A `Map` accumulator is composable across zones
+ * exactly the way `AggResults` is (both are just "merge two counts"), so zone-caching frequency
+ * data later is a drop-in extension of the existing pattern, not a new one — it just isn't
+ * justified by any current call site.
+ *
+ * Instances are read-time snapshots: per-instance results (`getUniqueValues` order) are computed
+ * lazily and cached for the instance's lifetime, never invalidated by later data changes.
+ */
+export declare class FrequencyStats implements IRangeStats.IFrequency {
+    private readonly _groups;
+    private readonly _keyFn;
+    private readonly _compareFn;
+    private readonly _reverseBuild;
+    private readonly _visitedCount;
+    private readonly _totalCount;
+    private readonly _truncated;
+    /** Lazy — ascending by `_compareFn`, `_reverseBuild` NOT applied (applied at read time only,
+     *  so it can never compound with `getValueCounts`' own independent `descending` flag). */
+    private _valueOrderAscending;
+    private constructor();
+    /** @inheritdoc IRangeStats.IFrequency.getUniqueValues */
+    getUniqueValues(): IterableIterator<Scalar>;
+    /** @inheritdoc IRangeStats.IFrequency.getFrequency */
+    getFrequency(value: Scalar): number;
+    /** @inheritdoc IRangeStats.IFrequency.getValueCounts */
+    getValueCounts(options?: {
+        sortBy?: 'value' | 'frequency';
+        descending?: boolean;
+    }): IterableIterator<[Scalar, number]>;
+    /** @inheritdoc IRangeStats.IFrequency.getUniqueCount */
+    getUniqueCount(): number;
+    /** @inheritdoc IRangeStats.IFrequency.getVisitedCount */
+    getVisitedCount(): number;
+    /** @inheritdoc IRangeStats.IFrequency.getTotalCount */
+    getTotalCount(): number;
+    /** @inheritdoc IRangeStats.IFrequency.isTruncated */
+    isTruncated(): boolean;
+    private _getValueOrderAscending;
+    /**
+     * Collects distinct-value frequencies from a grid and returns an instance over them.
+     *
+     * @remarks
+     * Single forward pass over the run-backed (non-blank) population. When `options.limit` caps
+     * the distinct-group count, the scan stops the instant a cell would need to open a group
+     * beyond the cap — repeats of already-known groups keep being counted right up to that point,
+     * so every group present in the result is exact, never an undercount; only completeness
+     * ("are there more distinct values out there") is given up, which is what `isTruncated()` says.
+     *
+     * `totalCount` is taken from the caller rather than derived here: `RangeStats` already has a
+     * cheap, cached population count (`getCount()`/`getSize()`) independent of this scan, which
+     * stays correct even when this scan stops early. Pass `undefined` when no such source exists
+     * (a custom `filterFn` restricts the population in a way nothing else already counts) and the
+     * scan's own `visitedCount` is used — exact when not truncated, an undercount when truncated.
+     */
+    static fromGrid(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined, options: IRangeStats.GetFrequenciesOptions | undefined, defaultCompareFn: (a: Scalar, b: Scalar) => number, blankCount: number, totalCount: number | undefined): FrequencyStats;
+    /**
+     * Builds an instance directly from an already-merged group map — used by
+     * {@link CompositeRangeStats}, which merges its children's own (already-scanned) frequencies
+     * rather than re-scanning a grid.
+     */
+    static fromGroups(groups: ReadonlyMap<string | number, FrequencyGroup>, keyFn: (v: Scalar) => string | number, options: IRangeStats.GetFrequenciesOptions | undefined, defaultCompareFn: (a: Scalar, b: Scalar) => number, visitedCount: number, totalCount: number, truncated: boolean): FrequencyStats;
+}
+/**
+ * The default distinctness key: type-tagged so `0` (number), `"0"` (string) and `FALSE`
+ * (boolean) never collide, and string comparison folds case/accents/expansions the same way
+ * `UNIQUE()` does — {@link toCompareKey} is "the hashing side" of the same Excel equality rule
+ * `ScalarCollation` implements for comparisons (see its docs), and the two are meant to agree on
+ * what "the same value" means. Numbers use exact `toString()` identity, matching `UNIQUE()`'s
+ * measured behavior (no 15-significant-digit comparison tolerance for distinctness).
+ *
+ * `null` (blank) gets its own tag rather than falling to the rich-data catch-all — `typeof null`
+ * is `'object'`, so without this branch it would key on `String(null)` ("null"), one string form
+ * away from colliding with an actual rich-data value whose own string form happened to match.
+ */
+export declare function defaultFrequencyKey(value: Scalar): string;
+//# sourceMappingURL=FrequencyStats.d.ts.map

package/types/src/primitives/stats/FrequencyStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrequencyStats.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/stats/FrequencyStats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAE,KAAK,WAAW,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAI1F,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAe,YAAW,WAAW,CAAC,UAAU;IAC3D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+C;IACvE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmC;IAC9D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IAErC;8FAC0F;IAC1F,OAAO,CAAC,oBAAoB,CAA2C;IAEvE,OAAO;IAkBP,yDAAyD;IACxD,eAAe,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAU5C,sDAAsD;IACtD,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAInC,wDAAwD;IACvD,cAAc,CAAC,OAAO,CAAC,EAAE;QACxB,MAAM,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;QAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,GAAG,gBAAgB,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IA0BtC,wDAAwD;IACxD,cAAc,IAAI,MAAM;IAIxB,yDAAyD;IACzD,eAAe,IAAI,MAAM;IAIzB,uDAAuD;IACvD,aAAa,IAAI,MAAM;IAIvB,qDAAqD;IACrD,WAAW,IAAI,OAAO;IAItB,OAAO,CAAC,uBAAuB;IAa/B;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,QAAQ,CACb,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,SAAS,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAC9C,eAAe,EAAE,MAAM,CAAC,eAAe,GAAG,SAAS,EACnD,OAAO,EAAE,WAAW,CAAC,qBAAqB,GAAG,SAAS,EACtD,gBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,EAClD,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,cAAc;IAoFjB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,WAAW,CAAC,MAAM,GAAG,MAAM,EAAE,cAAc,CAAC,EACpD,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,EACrC,OAAO,EAAE,WAAW,CAAC,qBAAqB,GAAG,SAAS,EACtD,gBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,EAClD,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,OAAO,GACjB,cAAc;CAWlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQzD"}

package/types/src/primitives/stats/Ranked.d.ts

@@ -0,0 +1,26 @@
+import { IRange, IRangeStats, Scalar } from '@sheetxl/primitives';
+import { ISparseGrid } from '../../collections';
+/**
+ * Collects the top-`limit` values from a grid — the scanning half of `RangeStats.getRanked`.
+ *
+ * @remarks
+ * A true bounded selection (`_TopK`, O(log limit) per candidate), not a full sort-then-slice —
+ * `getRanked`'s whole reason to exist alongside `getSortedNumbers` is that it never materializes
+ * the full population. Blanks never appear in the grid's runs (they are gaps, not members), so
+ * `includeBlanks` is handled separately: one synthetic `null` candidate is offered per blank
+ * cell, capped at `limit` offers (any beyond that can never displace a kept member).
+ */
+export declare function collectRanked(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined, options: IRangeStats.GetRankedOptions | undefined, defaultCompareFn: (a: Scalar, b: Scalar) => number): readonly Scalar[];
+/**
+ * Merges each child's own top-`limit` into the composite's true top-`limit`.
+ *
+ * @remarks
+ * Exact, not approximate: if a value belongs in the GLOBAL top-`limit`, at most `limit - 1`
+ * values outrank it across every child combined — so at most `limit - 1` of them can be in the
+ * SAME child as that value, which means the value is within ITS OWN child's top-`limit` too.
+ * Every global winner therefore survives into the union this merges, as long as every child
+ * ranks with the same `options` (same `compareFn`/`reverse`/`distinct`/`filterFn`/`includeBlanks`
+ * and the same `limit`) — which passing `options` through unchanged guarantees.
+ */
+export declare function mergeRanked(children: readonly IRangeStats[], options: IRangeStats.GetRankedOptions | undefined, defaultCompareFn: (a: Scalar, b: Scalar) => number): readonly Scalar[];
+//# sourceMappingURL=Ranked.d.ts.map

package/types/src/primitives/stats/Ranked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ranked.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/stats/Ranked.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE5E,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAsErD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,SAAS,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAC9C,eAAe,EAAE,MAAM,CAAC,eAAe,GAAG,SAAS,EACnD,OAAO,EAAE,WAAW,CAAC,gBAAgB,GAAG,SAAS,EACjD,gBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GACjD,SAAS,MAAM,EAAE,CAiEnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,OAAO,EAAE,WAAW,CAAC,gBAAgB,GAAG,SAAS,EACjD,gBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GACjD,SAAS,MAAM,EAAE,CAkBnB"}

package/types/src/primitives/stats/ScalarOrder.d.ts

@@ -0,0 +1,18 @@
+import { Scalar } from '@sheetxl/primitives';
+/**
+ * A basic cross-type {@link Scalar} order — number < string < boolean < error <
+ * rich data, then a plain `<`/`>`/code-point compare within a type.
+ *
+ * @remarks
+ * This is the fallback `compareFn` for {@link IRangeStats.getRanked} and
+ * `IRangeStats.IFrequency.getValueCounts({ sortBy: 'value' })` wherever no locale-aware
+ * comparator is available — {@link CompositeRangeStats} has no single runtime to collate
+ * against, since its children may span sheets with different locales.
+ *
+ * `RangeStats` prefers `ScalarCollation.compare` (the same rule behind `=`/`<`/`SORT`/`SORTBY`/
+ * `IRange.argsort`) whenever it has a runtime to collate with, and only falls back to this for
+ * text order across sheets. A caller that needs exact collation anywhere should pass its own
+ * `compareFn`.
+ */
+export declare function basicScalarCompare(a: Scalar, b: Scalar): number;
+//# sourceMappingURL=ScalarOrder.d.ts.map

package/types/src/primitives/stats/ScalarOrder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarOrder.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/stats/ScalarOrder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAEhE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAU/D"}

package/types/src/primitives/stats/SortedNumbers.d.ts

@@ -0,0 +1,48 @@
+import { FormulaError, IRange, IRangeStats } from '@sheetxl/primitives';
+import { ISparseGrid } from '../../collections';
+/**
+ * Implements {@link IRangeStats.ISortedNumbers}.
+ *
+ * @remarks
+ * Constructed once per {@link RangeStats} instance — lazy, cached on the instance itself.
+ * All methods are pure reads over the immutable sorted array; no further allocation occurs
+ * after construction except in `getPercentile` (a single numeric return).
+ *
+ * Binary search helpers (`_bisectLeft`, `_bisectRight`) use the standard half-open interval
+ * idiom — O(log n), no string keys, no Maps.
+ */
+export declare class SortedNumbers implements IRangeStats.ISortedNumbers {
+    private readonly _sorted;
+    /**
+     * @param sorted The full numeric population, already sorted ascending. Use
+     * {@link SortedNumbers.fromGrid} to collect from a grid.
+     */
+    constructor(sorted: readonly number[]);
+    /**
+     * Collects the numeric values within `localCoords` from the grid and returns an instance
+     * over them (sorted ascending).
+     */
+    static fromGrid(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined): SortedNumbers;
+    /** @inheritdoc IRangeStats.ISortedNumbers.getLarge */
+    getLarge(k: number): number | null;
+    /** @inheritdoc IRangeStats.ISortedNumbers.getSmall */
+    getSmall(k: number): number | null;
+    /** @inheritdoc IRangeStats.ISortedNumbers.getPercentile */
+    getPercentile(k: number, exclusive?: boolean): number | null;
+    /** @inheritdoc IRangeStats.ISortedNumbers.getRankOf */
+    getRankOf(x: number, descending?: boolean, average?: boolean): number | null;
+    /** @inheritdoc IRangeStats.ISortedNumbers.getPercentRankOf */
+    getPercentRankOf(x: number, exclusive?: boolean, significance?: number): number | FormulaError.Known | null;
+    /** @inheritdoc IRangeStats.ISortedNumbers.getValues */
+    getValues(): readonly number[];
+    /** @inheritdoc IRangeStats.ISortedNumbers.findFloor */
+    findFloor(x: number): number | null;
+    /** @inheritdoc IRangeStats.ISortedNumbers.findCeiling */
+    findCeiling(x: number): number | null;
+    /**
+     * Collects all numeric values from the range coords and returns them sorted ascending.
+     * Called at most once per instance lifetime (result is cached on `_sortedNumbers`).
+     */
+    protected static _collectNumbers(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined): readonly number[];
+}
+//# sourceMappingURL=SortedNumbers.d.ts.map

package/types/src/primitives/stats/SortedNumbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SortedNumbers.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/stats/SortedNumbers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAE7E,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;;;;GAUG;AACH,qBAAa,aAAc,YAAW,WAAW,CAAC,cAAc;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAE5C;;;OAGG;gBACS,MAAM,EAAE,SAAS,MAAM,EAAE;IAIrC;;;OAGG;IACH,MAAM,CAAC,QAAQ,CACb,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,SAAS,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAC9C,eAAe,EAAE,MAAM,CAAC,eAAe,GAAG,SAAS,GAClD,aAAa;IAMhB,sDAAsD;IACtD,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAQlC,sDAAsD;IACtD,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAUlC,2DAA2D;IAC3D,aAAa,CACX,CAAC,EAAE,MAAM,EACT,SAAS,GAAE,OAAa,GACvB,MAAM,GAAG,IAAI;IAqBhB,uDAAuD;IACvD,SAAS,CACP,CAAC,EAAE,MAAM,EACT,UAAU,GAAE,OAAY,EACxB,OAAO,GAAE,OAAa,GACrB,MAAM,GAAG,IAAI;IAoBhB,8DAA8D;IAC9D,gBAAgB,CACd,CAAC,EAAE,MAAM,EACT,SAAS,GAAE,OAAa,EACxB,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,GAAG,YAAY,CAAC,KAAK,GAAG,IAAI;IAoCrC,uDAAuD;IACvD,SAAS,IAAI,SAAS,MAAM,EAAE;IAM9B,uDAAuD;IACvD,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAQnC,yDAAyD;IACzD,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAQrC;;;OAGG;IACH,SAAS,CAAC,MAAM,CAAC,eAAe,CAC9B,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,SAAS,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAC9C,eAAe,EAAE,MAAM,CAAC,eAAe,GAAG,SAAS,GAClD,SAAS,MAAM,EAAE;CA+CrB"}

package/types/src/primitives/stats/index.d.ts

@@ -0,0 +1,7 @@
+export * from './AggregateStats';
+export * from './Cancellation';
+export * from './FrequencyStats';
+export * from './Ranked';
+export * from './ScalarOrder';
+export * from './SortedNumbers';
+//# sourceMappingURL=index.d.ts.map

package/types/src/primitives/stats/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/stats/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/types/src/print/IPrint.d.ts

@@ -0,0 +1,234 @@
+import { IRange } from '@sheetxl/primitives';
+/**
+ * Namespace for print-related configurations and settings.
+ */
+export declare namespace IPrint {
+    /**
+     * Interface representing multi-page print options.
+     */
+    interface MultiPage {
+        /**
+         * Whether content should be aligned with the page margins.
+         */
+        alignWithMargins?: boolean;
+        /**
+         * Specifies if the first page is different from subsequent pages.
+         */
+        differentFirst?: boolean;
+        /**
+         * Specifies if odd and even pages should have different settings.
+         */
+        differentOddEven?: boolean;
+        /**
+         * Whether the content should scale proportionally with the document.
+         */
+        scaleWithDoc?: boolean;
+    }
+    /**
+     * Interface for configuring headers and footers for print, supporting
+     * different settings for first, odd, and even pages.
+     */
+    interface HeaderFooter extends MultiPage {
+        /**
+         * Configuration for general header and footer settings.
+         */
+        headerFooter?: MultiPage;
+        /**
+         * Configuration for the footer on even pages.
+         */
+        evenFooter?: MultiPage;
+        /**
+         * Configuration for the header on even pages.
+         */
+        evenHeader?: MultiPage;
+        /**
+         * Configuration for the footer on the first page.
+         */
+        firstFooter?: MultiPage;
+        /**
+         * Configuration for the header on the first page.
+         */
+        firstHeader?: MultiPage;
+        /**
+         * Configuration for the footer on odd pages.
+         */
+        oddFooter?: MultiPage;
+        /**
+         * Configuration for the header on odd pages.
+         */
+        oddHeader?: MultiPage;
+    }
+    /**
+     * Interface representing the margins of a printed page, specified in inches.
+     */
+    interface PageMargin {
+        /**
+         * Margin from the bottom of the page.
+         */
+        bottom?: number;
+        /**
+         * Distance of the footer from the bottom of the page.
+         */
+        footer: number;
+        /**
+         * Distance of the header from the top of the page.
+         */
+        header: number;
+        /**
+         * Margin from the left side of the page.
+         */
+        left: number;
+        /**
+         * Margin from the right side of the page.
+         */
+        right: number;
+        /**
+         * Margin from the top of the page.
+         */
+        top: number;
+    }
+    /**
+     * Interface for configuring page setup options for print.
+     */
+    interface PageSetup {
+        /**
+         * Whether to print in black and white.
+         */
+        blackAndWhite?: boolean;
+        /**
+         * Specifies how cell comments are printed.
+         * @see {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_CellComments_topic_ID0EXMDFB.html#topic_ID0EXMDFB}
+         */
+        cellComments?: string;
+        /**
+         * The number of copies to print.
+         */
+        copies?: number;
+        /**
+         * Whether to print in draft mode for quicker printing.
+         */
+        draft?: boolean;
+        /**
+         * Specifies how errors should be displayed in the print.
+         * @see {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_PrintError_topic_ID0EUTTFB.html#topic_ID0EUTTFB}
+         */
+        errors?: string;
+        /**
+         * The page number to start printing from.
+         */
+        firstPageNumber?: number;
+        /**
+         * The number of pages to fit vertically.
+         */
+        fitToHeight?: number;
+        /**
+         * The number of pages to fit horizontally.
+         */
+        fitToWidth?: number;
+        /**
+         * The horizontal DPI (dots per inch) for printing.
+         */
+        horizontalDpi?: number;
+        /**
+         * The orientation of the page (portrait or landscape).
+         * @see
+         * {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_Orientation_topic_ID0E4XPFB.html#topic_ID0E4XPFB}
+         */
+        orientation?: string;
+        /**
+         * Specifies the order of pages when printed.
+         * @see
+         * {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_PageOrder_topic_ID0EN5PFB.html#topic_ID0EN5PFB}
+         */
+        pageOrder?: string;
+        /**
+         * Specifies the paper size for printing (enum values 1-68).
+         * @see
+         * {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_pageSetup_topic_ID0EHZ54.html#topic_ID0EHZ54}
+         */
+        paperSize?: number;
+        /**
+         * Specifies the scaling factor for printing (between 10 and 400).
+         */
+        scale?: number;
+        /**
+         * Whether to use the first page number specified in `firstPageNumber`.
+         */
+        useFirstPageNumber?: boolean;
+        /**
+         * Whether to use the printer's default settings for the print job.
+         */
+        usePrinterDefaults?: boolean;
+        /**
+         * The vertical DPI (dots per inch) for printing.
+         */
+        verticalDpi?: number;
+    }
+    /**
+     * Interface for additional properties of page setup,
+     * such as auto page breaks and fitting content to a page.
+     */
+    interface PageSetUpProperties {
+        /**
+         * Whether to automatically break pages when content overflows.
+         */
+        autoPageBreak?: boolean;
+        /**
+         * Whether content should fit to a single page when printed.
+         */
+        fitToPage?: boolean;
+    }
+    /**
+     * Interface for configuring print options, such as grid lines
+     * and content alignment.
+     */
+    interface PrintOptions {
+        /**
+         * Whether to print grid lines on the sheet.
+         */
+        gridLines?: boolean;
+        /**
+         * Whether grid lines are explicitly set for printing.
+         */
+        gridLinesSet?: boolean;
+        /**
+         * Whether to print row and column headings.
+         */
+        headings?: boolean;
+        /**
+         * Whether content should be horizontally centered on the page.
+         */
+        horizontalCentered?: boolean;
+        /**
+         * Whether content should be vertically centered on the page.
+         */
+        verticalCentered?: boolean;
+    }
+    /**
+     * Interface for outline properties used in print, such as
+     * the summary position and style application.
+     */
+    interface OutlineProperties {
+        /**
+         * Whether to apply styles to outline symbols.
+         */
+        applyStyles?: boolean;
+        /**
+         * Whether to display outline symbols in the print.
+         */
+        showOutlineSymbols?: boolean;
+        /**
+         * Whether the summary rows are displayed below the details.
+         */
+        summaryBelow?: boolean;
+        /**
+         * Whether the summary columns are displayed to the right of the details.
+         */
+        summaryRight?: boolean;
+    }
+    type Break = IRange.JSONReference<{
+        man?: boolean;
+        pt?: boolean;
+    }>;
+}
+//# sourceMappingURL=IPrint.d.ts.map

package/types/src/print/IPrint.d.ts.map

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

package/types/src/print/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IPrint';
+//# sourceMappingURL=index.d.ts.map