@rowsncolumns/utils 9.2.35

package/dist/esm/memoize.js

@@ -0,0 +1,95 @@
+import { contentHash } from "./content-hash";
+import { isNil } from "./typeguards";
+export const memoize = (fn) => {
+    const cache = new Map();
+    return (...args) => {
+        const key = String(args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const value = fn.call(undefined, ...args);
+        cache.set(key, value);
+        return value;
+    };
+};
+/**
+ * Mint a stable cellXfs key ("sid") for a CellFormat. The key is
+ * `contentHash` (FNV-1a-64 → 8-char base62) over a delimiter-separated
+ * canonical serialization of the format's defined properties — the
+ * previous 31-bit rolling int hash silently collided two different
+ * formats onto one registry key (first-writer wins, so e.g. a red
+ * format could hijack a blue one on import).
+ *
+ * Sids are minted at import/edit time and persisted in the doc's
+ * cellXfs map together with the cell references that carry them —
+ * readback resolves a stored sid against the stored map, never by
+ * re-hashing. Changing this algorithm therefore only affects newly
+ * minted keys; existing docs keep resolving their old sids.
+ */
+export const getCellXfsKey = (userObj) => {
+    if (userObj === null || userObj === undefined) {
+        return String(0);
+    }
+    const obj = definedProps(userObj);
+    let serialized = "";
+    const hashString = (str) => {
+        // `\u0001` terminates every atom so adjacent strings can't merge
+        // into the same serialization (`{a:"bc"}` vs `{ab:"c"}`).
+        serialized += str + "\u0001";
+    };
+    const hashValue = (value) => {
+        if (value === null || value === undefined)
+            return;
+        if (typeof value === "object") {
+            // Custom serialization for known object types
+            const sortedKeys = Object.keys(value).sort();
+            serialized += "\u0002";
+            for (const key of sortedKeys) {
+                hashString(key);
+                hashValue(value[key]);
+            }
+            serialized += "\u0003";
+        }
+        else {
+            hashString(String(value));
+        }
+    };
+    // Hash each property in a consistent order. The list MUST cover every
+    // field that distinguishes one CellFormat from another — when two
+    // different formats hash to the same key, the cellXfs registry
+    // dedupes them, so cells lose any field that wasn't in this list.
+    const props = [
+        "backgroundColor",
+        "borders",
+        "textFormat",
+        "numberFormat",
+        "horizontalAlignment",
+        "verticalAlignment",
+        "wrapStrategy",
+        "indent",
+        "textRotation",
+        "shrinkToFit",
+        "relativeIndent",
+        "fillPattern",
+        "foregroundColor",
+        "gradient",
+    ];
+    for (const prop of props) {
+        if (obj[prop] !== undefined) {
+            hashString(String(prop)); // Include property name in hash
+            hashValue(obj[prop]);
+        }
+    }
+    return contentHash(serialized);
+};
+export const definedProps = (obj) => {
+    if (isNil(obj))
+        return obj;
+    const result = {};
+    for (const key in obj) {
+        if (!isNil(obj[key])) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+};

package/dist/esm/numbers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Convert number to alphabet
+ * @param i
+ */
+export declare const number2Alpha: (i: number) => string;
+/**
+ * Converts a letter to number
+ * A = 1
+ * B => 2
+ * @param letters
+ */
+export declare const alpha2number: (letters: string) => number;
+/**
+ * Get min max of an array
+ * @param arr
+ */
+export declare const getMinMaxArray: (arr: number[]) => number[];
+export declare const isNumber: (value: any) => value is number;
+//# sourceMappingURL=numbers.d.ts.map

package/dist/esm/numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.d.ts","sourceRoot":"","sources":["../../numbers.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,GAAG,MAAM,KAAG,MAIxC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,KAAG,MAE9C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,EAAE,aAa3C,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,OAAO,GAAG,KAAG,KAAK,IAAI,MAAuB,CAAC"}

package/dist/esm/numbers.js

@@ -0,0 +1,40 @@
+// Pre-compute alphabet string to avoid repeated string access
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+/**
+ * Convert number to alphabet
+ * @param i
+ */
+export const number2Alpha = (i) => {
+    return ((i >= 26 ? number2Alpha(((i / 26) >> 0) - 1) : "") + ALPHABET[i % 26 >> 0]);
+};
+/**
+ * Converts a letter to number
+ * A = 1
+ * B => 2
+ * @param letters
+ */
+export const alpha2number = (letters) => {
+    return letters.split("").reduce((r, a) => r * 26 + parseInt(a, 36) - 9, 0);
+};
+/**
+ * Get min max of an array
+ * @param arr
+ */
+export const getMinMaxArray = (arr) => {
+    if (!arr.length)
+        return [0, 0];
+    // Loop, not spread — passing >~65k elements as call arguments throws
+    // `RangeError: Maximum call stack size exceeded` (selection-sized arrays
+    // reach millions).
+    let min = arr[0];
+    let max = arr[0];
+    for (let i = 1; i < arr.length; i++) {
+        const v = arr[i];
+        if (v < min)
+            min = v;
+        if (v > max)
+            max = v;
+    }
+    return [min, max];
+};
+export const isNumber = (value) => !isNaN(value);

package/dist/esm/selection.d.ts

@@ -0,0 +1,88 @@
+import type { CellInterface, GridRange, SheetRange, SelectionArea } from "@rowsncolumns/common-types";
+import { type ParsedToken } from "@rowsncolumns/calculator";
+export type SelectionWithSheetName = SelectionArea & {
+    sheetName?: string;
+};
+export type SelectionFromTableResolver = (sheetId: number, activeCell?: CellInterface, tableName?: string, columnNames?: string[], thisRow?: boolean, specialItem?: ParsedToken["specialItem"]) => SelectionWithSheetName | undefined;
+export type SelectionFromNamedRangeResolver = (variableName: string) => SelectionWithSheetName | unknown;
+export declare const isSelection: (sel: unknown) => sel is SelectionWithSheetName;
+export declare const MAX_ROW_COUNT = 1048576;
+export declare const MAX_COLUMN_COUNT = 16384;
+export declare const DEFAULT_ROW_COUNT = 1000;
+export declare const DEFAULT_COLUMN_COUNT = 100;
+export declare const DEFAULT_ROW_HEIGHT = 21;
+export declare const DEFAULT_COLUMN_WIDTH = 100;
+export declare const DEFAULT_ACTIVE_CELL: CellInterface;
+export declare const addressToSelection: (address: string, rowCount?: number, columnCount?: number) => SelectionArea | undefined;
+export declare const addressToSheetRange: (address: string, sheetId: number, rowCount?: number, columnCount?: number) => SheetRange | undefined;
+/**
+ * Convert a selection object to A1 address form (optionally sheet-qualified).
+ */
+export declare const selectionToAddress: (selection: SelectionArea | undefined, sheetName?: string, merges?: GridRange[] | null, rowCount?: number, columnCount?: number) => string | undefined;
+export declare const checkIfStringIsReference: (value: string | undefined) => boolean;
+export declare const generateSelectionsFromFormula: (value: string, _sheetId?: number, currentSheetName?: string, activeCell?: CellInterface, rowCount?: number, columnCount?: number, tokenizer?: (value: string | undefined, sheetName?: string) => ParsedToken[], getSelectionFromTable?: SelectionFromTableResolver, getSelectionFromNamedRange?: SelectionFromNamedRangeResolver) => SelectionWithSheetName[];
+/**
+ * Check if two ranges are equal.
+ */
+export declare const isAreasEqual: (area1: GridRange | undefined, area2: GridRange | undefined) => boolean;
+/**
+ * Check if a cell is inside the provided range bounds.
+ */
+export declare const isCellWithinBounds: (cell: CellInterface, bounds?: GridRange) => boolean;
+/**
+ * Return a single-cell selection for the active cell.
+ */
+export declare const selectionFromActiveCell: (activeCell: CellInterface | null) => SelectionArea[];
+/**
+ * Check if two ranges overlap.
+ */
+export declare const areaIntersects: (area1: GridRange, area2: GridRange | undefined) => boolean;
+/**
+ * Check if `needle` range is fully inside `haystack`.
+ */
+export declare const areaInsideArea: (needle: GridRange, haystack: GridRange) => boolean;
+/**
+ * Intersection of two ranges, or `null` when they don't overlap.
+ */
+export declare const areaIntersection: (area1: GridRange, area2: GridRange) => GridRange | null;
+/**
+ * Re-scope a rule's ranges after a drag-move of `from` → `to` on `sheetId`, so
+ * range-scoped rules (conditional formats, data validations) travel with the
+ * moved cells the way Excel and Google Sheets carry them:
+ *
+ * - a range on another sheet, or untouched by the move, is kept as-is
+ * - a range that travelled entirely inside the moved area is shifted with it
+ * - a range that only partially overlaps the moved area keeps its original
+ *   scope (the source cells left behind keep the rule) and gains the shifted
+ *   overlap at the destination — unless one of the rule's ranges already
+ *   covers that destination
+ *
+ * Returns the new ranges, or `null` when the move leaves every range
+ * untouched, so callers can skip the rule update entirely (no history entry,
+ * no re-evaluation).
+ */
+export declare const rescopeSheetRangesOnMove: (ranges: readonly SheetRange[], sheetId: number, from: GridRange, to: GridRange) => SheetRange[] | null;
+/**
+ * Convert a cell coordinate into a single-cell range.
+ */
+export declare const cellToArea: ({ rowIndex, columnIndex, }: CellInterface) => GridRange;
+/**
+ * Convert font size from points to pixels.
+ */
+export declare const pointToPixel: (pt: number) => number;
+/**
+ * Convert font size from pixels to points.
+ */
+export declare const pixelToPoint: (px: number) => number;
+/**
+ * Resolve a table column name to absolute column index.
+ */
+export declare const getColumnIndexFromColumnName: (table: {
+    columns?: Array<{
+        name?: string | null;
+    }> | null;
+    range: {
+        startColumnIndex: number;
+    };
+}, columnName: string | undefined) => number | undefined;
+//# sourceMappingURL=selection.d.ts.map

package/dist/esm/selection.d.ts.map

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

package/dist/esm/selection.js

@@ -0,0 +1,311 @@
+import { desanitizeSheetName } from "./string";
+import { isNil } from "./typeguards";
+import { addressToCell, cellToAddress, sanitizeSheetName, selectionBoundsFromCells, } from "./string";
+export const isSelection = (sel) => {
+    return !!sel?.range;
+};
+export const MAX_ROW_COUNT = 1_048_576;
+export const MAX_COLUMN_COUNT = 16_384;
+export const DEFAULT_ROW_COUNT = 1000;
+export const DEFAULT_COLUMN_COUNT = 100;
+export const DEFAULT_ROW_HEIGHT = 21;
+export const DEFAULT_COLUMN_WIDTH = 100;
+export const DEFAULT_ACTIVE_CELL = Object.freeze({
+    rowIndex: 1,
+    columnIndex: 1,
+});
+export const addressToSelection = (address, rowCount = MAX_ROW_COUNT, columnCount = MAX_COLUMN_COUNT) => {
+    let [from, to] = address.split(":");
+    if (!from)
+        return undefined;
+    if (!to)
+        to = from;
+    const fromCell = addressToCell(from, {
+        position: "start",
+        rowCount,
+        columnCount,
+    });
+    const toCell = addressToCell(to, {
+        position: "end",
+        rowCount,
+        columnCount,
+    });
+    if (!fromCell || !toCell)
+        return undefined;
+    return { range: selectionBoundsFromCells(fromCell, toCell) };
+};
+export const addressToSheetRange = (address, sheetId, rowCount = MAX_ROW_COUNT, columnCount = MAX_COLUMN_COUNT) => {
+    const selection = addressToSelection(address, rowCount, columnCount);
+    if (!selection) {
+        return undefined;
+    }
+    return {
+        sheetId,
+        ...selection.range,
+    };
+};
+/**
+ * Convert a selection object to A1 address form (optionally sheet-qualified).
+ */
+export const selectionToAddress = (selection, sheetName, merges = [], rowCount = MAX_ROW_COUNT, columnCount = MAX_COLUMN_COUNT) => {
+    if (!selection) {
+        return undefined;
+    }
+    const mergedCell = merges?.find((merge) => isAreasEqual(selection.range, merge));
+    const { startRowIndex, startColumnIndex, endRowIndex, endColumnIndex } = mergedCell
+        ? cellToArea({
+            rowIndex: mergedCell.startRowIndex,
+            columnIndex: mergedCell.startColumnIndex,
+        })
+        : selection.range;
+    const isFullColumn = startRowIndex === 1 && endRowIndex === rowCount;
+    const isFullRow = startColumnIndex === 1 && endColumnIndex === columnCount;
+    const from = cellToAddress({
+        rowIndex: startRowIndex,
+        columnIndex: startColumnIndex,
+    }, undefined, undefined, isFullColumn, isFullRow);
+    const to = cellToAddress({
+        rowIndex: endRowIndex,
+        columnIndex: endColumnIndex,
+    }, undefined, undefined, isFullColumn, isFullRow);
+    const cellAddress = from === to && !isFullColumn && !isFullRow ? from : `${from}:${to || ""}`;
+    return `${sheetName ? sanitizeSheetName(sheetName) + "!" : ""}${cellAddress}`;
+};
+export const checkIfStringIsReference = (value) => {
+    if (!value)
+        return false;
+    const v = String(value).trim();
+    const expr = v.startsWith("=") ? v.slice(1) : v;
+    const refRegex = /^(?:[^!]+!)?\$?[A-Z]+\$?\d+(?::\$?[A-Z]+\$?\d+)?$/i;
+    return refRegex.test(expr);
+};
+export const generateSelectionsFromFormula = (value, _sheetId, currentSheetName, activeCell, rowCount = MAX_ROW_COUNT, columnCount = MAX_COLUMN_COUNT, tokenizer, getSelectionFromTable, getSelectionFromNamedRange) => {
+    const selections = [];
+    if (!value)
+        return selections;
+    if (tokenizer && !isNil(_sheetId)) {
+        const sheetId = _sheetId;
+        const tokens = tokenizer(value, currentSheetName) ?? [];
+        for (const token of tokens) {
+            if (token.structured && getSelectionFromTable) {
+                const structuredSelection = getSelectionFromTable(sheetId, activeCell, token.tableName, token.columnNames, token.thisRow, token.specialItem);
+                if (structuredSelection && isSelection(structuredSelection)) {
+                    selections.push(structuredSelection);
+                }
+            }
+            if (token.isNamedRange && getSelectionFromNamedRange) {
+                const namedRangeSelection = getSelectionFromNamedRange(token.image);
+                if (namedRangeSelection && isSelection(namedRangeSelection)) {
+                    selections.push(namedRangeSelection);
+                }
+            }
+            if (token.selection) {
+                const address = token.image.slice(token.image.indexOf("!") + 1);
+                const selectionRange = addressToSelection(address, rowCount, columnCount);
+                if (selectionRange) {
+                    selections.push({
+                        ...selectionRange,
+                        sheetName: desanitizeSheetName(token.sheetName ?? currentSheetName),
+                    });
+                }
+            }
+        }
+        return selections;
+    }
+    const input = value.startsWith("=") ? value.slice(1) : value;
+    const refPattern = /((?:'[^']+'|[^'!,]+)!)?\$?[A-Z]+\$?\d+(?::\$?[A-Z]+\$?\d+)?/g;
+    let m;
+    while ((m = refPattern.exec(input))) {
+        const token = m[0];
+        const [maybeSheet, addr] = token.includes("!")
+            ? [
+                token.slice(0, token.indexOf("!")),
+                token.slice(token.indexOf("!") + 1),
+            ]
+            : [undefined, token];
+        const sel = addressToSelection(addr, rowCount, columnCount);
+        if (sel) {
+            selections.push({
+                ...sel,
+                sheetName: maybeSheet
+                    ? maybeSheet.replace(/!$/, "").replace(/^'|'$/g, "") || undefined
+                    : currentSheetName,
+            });
+        }
+    }
+    return selections;
+};
+/**
+ * Check if two ranges are equal.
+ */
+export const isAreasEqual = (area1, area2) => {
+    if (area1 === undefined || area2 === undefined) {
+        return false;
+    }
+    return (area1.endRowIndex === area2.endRowIndex &&
+        area1.startRowIndex === area2.startRowIndex &&
+        area1.startColumnIndex === area2.startColumnIndex &&
+        area1.endColumnIndex === area2.endColumnIndex);
+};
+/**
+ * Check if a cell is inside the provided range bounds.
+ */
+export const isCellWithinBounds = (cell, bounds) => {
+    if (!bounds) {
+        return false;
+    }
+    if (cell.rowIndex < bounds.startRowIndex ||
+        cell.rowIndex > bounds.endRowIndex) {
+        return false;
+    }
+    if (cell.columnIndex < bounds.startColumnIndex ||
+        cell.columnIndex > bounds.endColumnIndex) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Return a single-cell selection for the active cell.
+ */
+export const selectionFromActiveCell = (activeCell) => {
+    if (!activeCell)
+        return [];
+    return [
+        {
+            range: {
+                startRowIndex: activeCell.rowIndex,
+                startColumnIndex: activeCell.columnIndex,
+                endRowIndex: activeCell.rowIndex,
+                endColumnIndex: activeCell.columnIndex,
+            },
+        },
+    ];
+};
+/**
+ * Check if two ranges overlap.
+ */
+export const areaIntersects = (area1, area2) => {
+    if (!area2) {
+        return false;
+    }
+    if (area1.startColumnIndex > area2.endColumnIndex ||
+        area2.startColumnIndex > area1.endColumnIndex) {
+        return false;
+    }
+    if (area1.startRowIndex > area2.endRowIndex ||
+        area2.startRowIndex > area1.endRowIndex) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Check if `needle` range is fully inside `haystack`.
+ */
+export const areaInsideArea = (needle, haystack) => {
+    return (needle.startRowIndex >= haystack.startRowIndex &&
+        needle.endRowIndex <= haystack.endRowIndex &&
+        needle.startColumnIndex >= haystack.startColumnIndex &&
+        needle.endColumnIndex <= haystack.endColumnIndex);
+};
+/**
+ * Intersection of two ranges, or `null` when they don't overlap.
+ */
+export const areaIntersection = (area1, area2) => {
+    const startRowIndex = Math.max(area1.startRowIndex, area2.startRowIndex);
+    const endRowIndex = Math.min(area1.endRowIndex, area2.endRowIndex);
+    const startColumnIndex = Math.max(area1.startColumnIndex, area2.startColumnIndex);
+    const endColumnIndex = Math.min(area1.endColumnIndex, area2.endColumnIndex);
+    if (startRowIndex > endRowIndex || startColumnIndex > endColumnIndex) {
+        return null;
+    }
+    return { startRowIndex, endRowIndex, startColumnIndex, endColumnIndex };
+};
+/**
+ * Re-scope a rule's ranges after a drag-move of `from` → `to` on `sheetId`, so
+ * range-scoped rules (conditional formats, data validations) travel with the
+ * moved cells the way Excel and Google Sheets carry them:
+ *
+ * - a range on another sheet, or untouched by the move, is kept as-is
+ * - a range that travelled entirely inside the moved area is shifted with it
+ * - a range that only partially overlaps the moved area keeps its original
+ *   scope (the source cells left behind keep the rule) and gains the shifted
+ *   overlap at the destination — unless one of the rule's ranges already
+ *   covers that destination
+ *
+ * Returns the new ranges, or `null` when the move leaves every range
+ * untouched, so callers can skip the rule update entirely (no history entry,
+ * no re-evaluation).
+ */
+export const rescopeSheetRangesOnMove = (ranges, sheetId, from, to) => {
+    const rowDelta = to.startRowIndex - from.startRowIndex;
+    const columnDelta = to.startColumnIndex - from.startColumnIndex;
+    if (rowDelta === 0 && columnDelta === 0) {
+        return null;
+    }
+    const shift = (range) => ({
+        ...range,
+        startRowIndex: range.startRowIndex + rowDelta,
+        endRowIndex: range.endRowIndex + rowDelta,
+        startColumnIndex: range.startColumnIndex + columnDelta,
+        endColumnIndex: range.endColumnIndex + columnDelta,
+    });
+    let changed = false;
+    const next = [];
+    const shiftedOverlaps = [];
+    for (const range of ranges) {
+        if (range.sheetId !== sheetId) {
+            next.push(range);
+            continue;
+        }
+        const overlap = areaIntersection(range, from);
+        if (!overlap) {
+            next.push(range);
+            continue;
+        }
+        if (areaInsideArea(range, from)) {
+            next.push(shift(range));
+            changed = true;
+            continue;
+        }
+        next.push(range);
+        shiftedOverlaps.push(shift({ ...overlap, sheetId: range.sheetId }));
+    }
+    for (const shifted of shiftedOverlaps) {
+        const covered = next.some((range) => range.sheetId === sheetId && areaInsideArea(shifted, range));
+        if (covered) {
+            continue;
+        }
+        next.push(shifted);
+        changed = true;
+    }
+    return changed ? next : null;
+};
+/**
+ * Convert a cell coordinate into a single-cell range.
+ */
+export const cellToArea = ({ rowIndex, columnIndex, }) => {
+    return {
+        startRowIndex: rowIndex,
+        startColumnIndex: columnIndex,
+        endColumnIndex: columnIndex,
+        endRowIndex: rowIndex,
+    };
+};
+/**
+ * Convert font size from points to pixels.
+ */
+export const pointToPixel = (pt) => Math.round((13 / 10) * pt);
+/**
+ * Convert font size from pixels to points.
+ */
+export const pixelToPoint = (px) => Math.round((px / 13) * 10);
+/**
+ * Resolve a table column name to absolute column index.
+ */
+export const getColumnIndexFromColumnName = (table, columnName) => {
+    const fromIndex = table.columns?.findIndex((col) => col.name === columnName);
+    if (fromIndex == null || fromIndex === -1) {
+        return undefined;
+    }
+    return table.range.startColumnIndex + fromIndex;
+};

package/dist/esm/shared-string-canonical.d.ts

@@ -0,0 +1,18 @@
+import type { TextFormatRun } from "@rowsncolumns/common-types";
+/**
+ * Deterministic string form of a (text, runs) pair, suitable as input to
+ * `contentHash` for rich shared-string entries.
+ *
+ * Two rich entries that render identically produce the same canonical string
+ * regardless of property ordering or absent-vs-false boolean variations. The
+ * leading `RICH_MARKER` (control characters) guarantees a rich canonical can
+ * never equal any plain shared-string text, so plain↔rich never collide on
+ * the downstream content hash.
+ *
+ * IMPORTANT: This is the dedup key for shared-string IDs across sessions.
+ * Changing the format, key order, or stripping rules invalidates every
+ * existing rich-string ID. Mirror updates here in any other-language port
+ * (e.g. Python) used in the same collaboration session.
+ */
+export declare const canonicalizeRichSharedString: (text: string, runs: readonly TextFormatRun[]) => string;
+//# sourceMappingURL=shared-string-canonical.d.ts.map

package/dist/esm/shared-string-canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-string-canonical.d.ts","sourceRoot":"","sources":["../../shared-string-canonical.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,aAAa,EACd,MAAM,4BAA4B,CAAC;AAkDpC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,4BAA4B,GACvC,MAAM,MAAM,EACZ,MAAM,SAAS,aAAa,EAAE,KAC7B,MAGF,CAAC"}

package/dist/esm/shared-string-canonical.js

@@ -0,0 +1,68 @@
+// U+0001 (START OF HEADING). Cell text shouldn't contain control chars, so
+// using it as a separator and as the `RICH_MARKER` prefix guarantees the rich
+// canonical string can never collide with any plain shared-string value.
+// Built via fromCharCode rather than a string literal so the control byte is
+// visible in source.
+const SEP = String.fromCharCode(1);
+const RICH_MARKER = `${SEP}RICH${SEP}`;
+const canonicalizeColor = (color) => {
+    if (color == null)
+        return "";
+    if (typeof color === "string")
+        return `s:${color}`;
+    const tint = color.tint == null ? "" : color.tint;
+    return `t:${color.theme}:${tint}`;
+};
+// Fixed key order. Skips null/undefined and false-equivalent booleans so a
+// producer that writes `{ bold: true }` hashes identically to one that writes
+// `{ bold: true, italic: false }`. Any new field added to `TextFormat` MUST be
+// appended here, otherwise rich entries differing only in the new field will
+// collapse and dedup incorrectly.
+const canonicalizeFormat = (format) => {
+    if (!format)
+        return "";
+    const parts = [];
+    if (format.bold)
+        parts.push("b");
+    if (format.italic)
+        parts.push("i");
+    if (format.strikethrough)
+        parts.push("s");
+    if (format.underline)
+        parts.push("u");
+    if (format.color != null)
+        parts.push(`c=${canonicalizeColor(format.color)}`);
+    if (format.fontFamily)
+        parts.push(`ff=${format.fontFamily}`);
+    if (format.fontSize != null)
+        parts.push(`fs=${format.fontSize}`);
+    if (format.baselineOffset)
+        parts.push(`bo=${format.baselineOffset}`);
+    return parts.join(",");
+};
+const canonicalizeMention = (mention) => `v=${mention.value},l=${mention.label}`;
+const canonicalizeRun = (run) => {
+    if (run.nodeType === "mention") {
+        return `M:${run.startIndex}:${run.endIndex}:${canonicalizeMention(run.mention)}`;
+    }
+    return `T:${run.startIndex}:${run.endIndex}:${canonicalizeFormat(run.format)}`;
+};
+/**
+ * Deterministic string form of a (text, runs) pair, suitable as input to
+ * `contentHash` for rich shared-string entries.
+ *
+ * Two rich entries that render identically produce the same canonical string
+ * regardless of property ordering or absent-vs-false boolean variations. The
+ * leading `RICH_MARKER` (control characters) guarantees a rich canonical can
+ * never equal any plain shared-string text, so plain↔rich never collide on
+ * the downstream content hash.
+ *
+ * IMPORTANT: This is the dedup key for shared-string IDs across sessions.
+ * Changing the format, key order, or stripping rules invalidates every
+ * existing rich-string ID. Mirror updates here in any other-language port
+ * (e.g. Python) used in the same collaboration session.
+ */
+export const canonicalizeRichSharedString = (text, runs) => {
+    const runsKey = runs.map(canonicalizeRun).join(";");
+    return `${RICH_MARKER}${text}${SEP}${runsKey}`;
+};

package/dist/esm/sort.d.ts

@@ -0,0 +1,15 @@
+export type BaseSheet = {
+    index?: number | null;
+    title: string;
+    hidden?: boolean | null;
+    sheetId: number;
+} & Record<string, any>;
+/**
+ * Sort sheets by index
+ * @param sheets
+ * @returns
+ */
+export declare const sortSheetsByIndex: <S extends BaseSheet>(sheets: S[], includeHidden?: boolean) => (S & {
+    index: number;
+})[];
+//# sourceMappingURL=sort.d.ts.map

package/dist/esm/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../sort.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACxB;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,SAAS,EACnD,QAAQ,CAAC,EAAE,EACX,gBAAgB,OAAO;;IA0CxB,CAAC"}