@rowsncolumns/toolkit 24.4.1

package/dist/esm/excel-parser/cfb-encryptor.js

@@ -0,0 +1,181 @@
+/// <reference path="../xlsx.d.ts" />
+import { CFB } from "xlsx/xlsx.mjs";
+import { sha512 } from "@noble/hashes/sha512";
+import { hmac } from "@noble/hashes/hmac";
+import { cbc } from "@noble/ciphers/aes";
+const BLOCK_SIZE = 16;
+const KEY_SIZE = 32; // AES-256
+const HASH_SIZE = 64; // SHA-512
+const SEGMENT_LENGTH = 4096;
+const SPIN_COUNT_DEFAULT = 100000;
+const BLOCK_KEY_VERIFIER_INPUT = new Uint8Array([
+    0xfe, 0xa7, 0xd2, 0x76, 0x3b, 0x4b, 0x9e, 0x79,
+]);
+const BLOCK_KEY_VERIFIER_HASH = new Uint8Array([
+    0xd7, 0xaa, 0x0f, 0x6d, 0x30, 0x61, 0x34, 0x4e,
+]);
+const BLOCK_KEY_ENCRYPTION_KEY = new Uint8Array([
+    0x14, 0x6e, 0x0b, 0xe7, 0xab, 0xac, 0xd0, 0xd6,
+]);
+const BLOCK_KEY_DATA_INTEGRITY_KEY = new Uint8Array([
+    0x5f, 0xb2, 0xad, 0x01, 0x0c, 0xb9, 0xe1, 0xf6,
+]);
+const BLOCK_KEY_DATA_INTEGRITY_VALUE = new Uint8Array([
+    0xa0, 0x67, 0x7f, 0x02, 0xb2, 0x2c, 0x84, 0x33,
+]);
+export class CFBEncryptor {
+    static async encrypt(source, password, options = {}) {
+        const packageData = source instanceof Uint8Array ? source : new Uint8Array(source);
+        const spinCount = options.spinCount ?? SPIN_COUNT_DEFAULT;
+        const passwordSalt = this.randomBytes(BLOCK_SIZE);
+        const packageSalt = this.randomBytes(BLOCK_SIZE);
+        const verifierInput = this.randomBytes(BLOCK_SIZE);
+        const encryptionKey = this.randomBytes(KEY_SIZE);
+        const hmacKey = this.randomBytes(HASH_SIZE);
+        const passwordDerivedKey = this.derivePasswordKey(password, passwordSalt, spinCount);
+        const keyForVerifierInput = this.deriveAgileBlockKey(passwordDerivedKey, BLOCK_KEY_VERIFIER_INPUT);
+        const keyForVerifierHash = this.deriveAgileBlockKey(passwordDerivedKey, BLOCK_KEY_VERIFIER_HASH);
+        const keyForEncryptionKey = this.deriveAgileBlockKey(passwordDerivedKey, BLOCK_KEY_ENCRYPTION_KEY);
+        const verifierHash = this.sha512Hash(verifierInput);
+        const encryptedVerifierHashInput = this.encryptAESNoPadding(verifierInput, keyForVerifierInput, passwordSalt);
+        const encryptedVerifierHashValue = this.encryptAESNoPadding(verifierHash, keyForVerifierHash, passwordSalt);
+        const encryptedKeyValue = this.encryptAESNoPadding(encryptionKey, keyForEncryptionKey, passwordSalt);
+        const encryptedPackageData = this.encryptPackage(packageData, encryptionKey, packageSalt);
+        const encryptedPackageStream = this.buildEncryptedPackageStream(packageData.length, encryptedPackageData);
+        const encryptedHmacKey = this.encryptDataIntegrityValue(hmacKey, encryptionKey, packageSalt, BLOCK_KEY_DATA_INTEGRITY_KEY);
+        const hmacValue = this.hmacSha512(encryptedPackageStream, hmacKey);
+        const encryptedHmacValue = this.encryptDataIntegrityValue(hmacValue, encryptionKey, packageSalt, BLOCK_KEY_DATA_INTEGRITY_VALUE);
+        const encryptionXml = this.buildEncryptionXml({
+            spinCount,
+            passwordSalt,
+            packageSalt,
+            encryptedVerifierHashInput,
+            encryptedVerifierHashValue,
+            encryptedKeyValue,
+            encryptedHmacKey,
+            encryptedHmacValue,
+        });
+        const encryptionInfo = this.buildEncryptionInfoStream(encryptionXml);
+        const cfb = CFB.utils.cfb_new({ root: "Root Entry" });
+        CFB.utils.cfb_add(cfb, "EncryptionInfo", encryptionInfo);
+        CFB.utils.cfb_add(cfb, "EncryptedPackage", encryptedPackageStream);
+        const result = CFB.write(cfb, { type: "array" });
+        return result instanceof Uint8Array ? result : new Uint8Array(result);
+    }
+    static buildEncryptionInfoStream(xml) {
+        const xmlBytes = new TextEncoder().encode(xml);
+        const info = new Uint8Array(8 + xmlBytes.length);
+        const view = new DataView(info.buffer);
+        view.setUint16(0, 4, true); // vMajor
+        view.setUint16(2, 4, true); // vMinor (Agile)
+        view.setUint32(4, 0x40, true); // reserved
+        info.set(xmlBytes, 8);
+        return info;
+    }
+    static buildEncryptedPackageStream(originalSize, encryptedData) {
+        const out = new Uint8Array(8 + encryptedData.length);
+        const view = new DataView(out.buffer);
+        view.setBigUint64(0, BigInt(originalSize), true);
+        out.set(encryptedData, 8);
+        return out;
+    }
+    static encryptPackage(data, key, packageSalt) {
+        const chunks = [];
+        for (let index = 0; index * SEGMENT_LENGTH < data.length; index++) {
+            const start = index * SEGMENT_LENGTH;
+            const end = Math.min(start + SEGMENT_LENGTH, data.length);
+            const segment = data.slice(start, end);
+            const paddedSegment = this.padToBlockSize(segment, BLOCK_SIZE);
+            const blockNumber = new Uint8Array(4);
+            new DataView(blockNumber.buffer).setUint32(0, index, true);
+            const iv = this.sha512Hash(this.concatArrays(packageSalt, blockNumber)).slice(0, BLOCK_SIZE);
+            chunks.push(this.encryptAESNoPadding(paddedSegment, key, iv));
+        }
+        return this.concatArrays(...chunks);
+    }
+    static buildEncryptionXml({ spinCount, passwordSalt, packageSalt, encryptedVerifierHashInput, encryptedVerifierHashValue, encryptedKeyValue, encryptedHmacKey, encryptedHmacValue, }) {
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<encryption xmlns="http://schemas.microsoft.com/office/2006/encryption" xmlns:p="http://schemas.microsoft.com/office/2006/keyEncryptor/password" xmlns:c="http://schemas.microsoft.com/office/2006/keyEncryptor/certificate">
+  <keyData saltSize="${BLOCK_SIZE}" blockSize="${BLOCK_SIZE}" keyBits="${KEY_SIZE * 8}" hashSize="${HASH_SIZE}" cipherAlgorithm="AES" cipherChaining="ChainingModeCBC" hashAlgorithm="SHA512" saltValue="${this.toBase64(packageSalt)}"/>
+  <dataIntegrity encryptedHmacKey="${this.toBase64(encryptedHmacKey)}" encryptedHmacValue="${this.toBase64(encryptedHmacValue)}"/>
+  <keyEncryptors>
+    <keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/password">
+      <p:encryptedKey spinCount="${spinCount}" saltSize="${BLOCK_SIZE}" blockSize="${BLOCK_SIZE}" keyBits="${KEY_SIZE * 8}" hashSize="${HASH_SIZE}" cipherAlgorithm="AES" cipherChaining="ChainingModeCBC" hashAlgorithm="SHA512" saltValue="${this.toBase64(passwordSalt)}" encryptedVerifierHashInput="${this.toBase64(encryptedVerifierHashInput)}" encryptedVerifierHashValue="${this.toBase64(encryptedVerifierHashValue)}" encryptedKeyValue="${this.toBase64(encryptedKeyValue)}"/>
+    </keyEncryptor>
+  </keyEncryptors>
+</encryption>`;
+    }
+    static derivePasswordKey(password, passwordSalt, spinCount) {
+        const passwordBytes = this.stringToUtf16LE(password);
+        let hash = this.sha512Hash(this.concatArrays(passwordSalt, passwordBytes));
+        for (let i = 0; i < spinCount; i++) {
+            const iterator = new Uint8Array(4);
+            new DataView(iterator.buffer).setUint32(0, i, true);
+            hash = this.sha512Hash(this.concatArrays(iterator, hash));
+        }
+        return hash;
+    }
+    static deriveAgileBlockKey(passwordDerivedKey, blockKey) {
+        return this.sha512Hash(this.concatArrays(passwordDerivedKey, blockKey)).slice(0, KEY_SIZE);
+    }
+    static encryptDataIntegrityValue(data, encryptionKey, packageSalt, blockKey) {
+        const iv = this.sha512Hash(this.concatArrays(packageSalt, blockKey)).slice(0, BLOCK_SIZE);
+        return this.encryptAESNoPadding(this.padToBlockSize(data, BLOCK_SIZE), encryptionKey, iv);
+    }
+    static encryptAESNoPadding(data, key, iv) {
+        const cipher = cbc(key, iv, { disablePadding: true });
+        return cipher.encrypt(data);
+    }
+    static sha512Hash(data) {
+        return sha512(data);
+    }
+    static hmacSha512(data, key) {
+        return hmac(sha512, key, data);
+    }
+    static toBase64(data) {
+        let binary = "";
+        for (let i = 0; i < data.length; i++) {
+            binary += String.fromCharCode(data[i]);
+        }
+        return btoa(binary);
+    }
+    static padToBlockSize(data, blockSize) {
+        const remainder = data.length % blockSize;
+        if (remainder === 0)
+            return data;
+        const out = new Uint8Array(data.length + (blockSize - remainder));
+        out.set(data);
+        return out;
+    }
+    static stringToUtf16LE(value) {
+        const bytes = new Uint8Array(value.length * 2);
+        for (let i = 0; i < value.length; i++) {
+            const code = value.charCodeAt(i);
+            bytes[i * 2] = code & 0xff;
+            bytes[i * 2 + 1] = (code >> 8) & 0xff;
+        }
+        return bytes;
+    }
+    static concatArrays(...arrays) {
+        const total = arrays.reduce((sum, arr) => sum + arr.length, 0);
+        const out = new Uint8Array(total);
+        let offset = 0;
+        for (const arr of arrays) {
+            out.set(arr, offset);
+            offset += arr.length;
+        }
+        return out;
+    }
+    static randomBytes(length) {
+        const out = new Uint8Array(length);
+        if (typeof globalThis.crypto !== "undefined" &&
+            globalThis.crypto.getRandomValues) {
+            globalThis.crypto.getRandomValues(out);
+            return out;
+        }
+        for (let i = 0; i < length; i++) {
+            out[i] = Math.floor(Math.random() * 256);
+        }
+        return out;
+    }
+}

package/dist/esm/excel-parser/dv-cell-stamp.d.ts

@@ -0,0 +1,29 @@
+import type { CellData, DataValidationRuleRecord } from "@rowsncolumns/spreadsheet";
+export declare class SheetDataValidationStamper {
+    private readonly rules;
+    private materializeBudget;
+    /** Rows that streamed out of the parser (only tracked when rules exist),
+     * so trailing materialization doesn't duplicate them. */
+    private readonly emittedRows;
+    constructor(allRules: DataValidationRuleRecord[], sheetId: number);
+    get hasRules(): boolean;
+    /** First rule (rule-list order, matching `updateRule`/grid semantics) whose
+     * ranges contain the cell. */
+    private ruleIdAt;
+    /**
+     * Stamp an emitted row in place: covered existing cells get
+     * `dataValidation: <ruleId>`, and covered holes inside small ranges get a
+     * phantom `{ dataValidation }` cell (budget-capped).
+     */
+    stampRow(rowIndex: number, values: (CellData | null | undefined)[]): void;
+    /**
+     * Rows covered by small ranges that never streamed out of the file at all
+     * (fully blank template rows). Returns sparse phantom rows to append to the
+     * sheet's final chunk, in ascending row order.
+     */
+    trailingRows(): Array<{
+        rowIndex: number;
+        values: (CellData | null | undefined)[];
+    }>;
+}
+//# sourceMappingURL=dv-cell-stamp.d.ts.map

package/dist/esm/excel-parser/dv-cell-stamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dv-cell-stamp.d.ts","sourceRoot":"","sources":["../../../excel-parser/dv-cell-stamp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,wBAAwB,EACzB,MAAM,2BAA2B,CAAC;AA+CnC,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,iBAAiB,CAA8B;IACvD;6DACyD;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;gBAG/C,QAAQ,EAAE,wBAAwB,EAAE,EACpC,OAAO,EAAE,MAAM;IAsCjB,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;kCAC8B;IAC9B,OAAO,CAAC,QAAQ;IAmBhB;;;;OAIG;IACH,QAAQ,CACN,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GACtC,IAAI;IAgCP;;;;OAIG;IACH,YAAY,IAAI,KAAK,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;KACzC,CAAC;CAmCH"}

package/dist/esm/excel-parser/dv-cell-stamp.js

@@ -0,0 +1,155 @@
+/**
+ * Per-sheet stamping of `cellData.dataValidation` during `processSheetData`
+ * streaming.
+ *
+ * Spreadsheet files store validations at the worksheet level (a rule + the
+ * ranges it applies to), but `useSpreadsheetState.getDataValidation` resolves a
+ * cell's rule ONLY through the per-cell `cellData.dataValidation` reference —
+ * there is no range-membership fallback. Consumers that build documents
+ * straight from `processSheetData` (e.g. server-side xlsx→Y.Doc conversion)
+ * therefore need the streamed cells to already carry the rule id, or the grid
+ * never shows dropdown arrows / enforces the rule even though the rule list
+ * itself round-tripped.
+ *
+ * The stamped id MUST be the id of the same rule object the plugin returns
+ * from `getDataValidations()` (ids are minted per parse), so plugins must
+ * feed this class from a single cached parse shared with that API.
+ */
+/** A cell is only materialized (created solely to carry the stamp) for ranges
+ * up to this many cells — whole-column/row sqrefs would otherwise bloat the
+ * output with millions of phantom cells. Cells that exist anyway are stamped
+ * regardless of range size. */
+const DV_MATERIALIZE_RANGE_CELL_CAP = 20_000;
+/** Upper bound on phantom cells materialized per sheet across all ranges. */
+const DV_MATERIALIZE_CELL_BUDGET = 100_000;
+const isFiniteIndex = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
+export class SheetDataValidationStamper {
+    rules = [];
+    materializeBudget = DV_MATERIALIZE_CELL_BUDGET;
+    /** Rows that streamed out of the parser (only tracked when rules exist),
+     * so trailing materialization doesn't duplicate them. */
+    emittedRows = new Set();
+    constructor(allRules, sheetId) {
+        for (const rule of allRules) {
+            if (rule.id === undefined || rule.id === null)
+                continue;
+            const ranges = [];
+            const materialize = [];
+            for (const range of rule.ranges ?? []) {
+                if (range.sheetId !== sheetId)
+                    continue;
+                const { startRowIndex, endRowIndex, startColumnIndex, endColumnIndex } = range;
+                if (!isFiniteIndex(startRowIndex) ||
+                    !isFiniteIndex(endRowIndex) ||
+                    !isFiniteIndex(startColumnIndex) ||
+                    !isFiniteIndex(endColumnIndex) ||
+                    endRowIndex < startRowIndex ||
+                    endColumnIndex < startColumnIndex) {
+                    continue;
+                }
+                ranges.push({
+                    startRowIndex,
+                    endRowIndex,
+                    startColumnIndex,
+                    endColumnIndex,
+                });
+                materialize.push((endRowIndex - startRowIndex + 1) *
+                    (endColumnIndex - startColumnIndex + 1) <=
+                    DV_MATERIALIZE_RANGE_CELL_CAP);
+            }
+            if (ranges.length) {
+                this.rules.push({ id: rule.id, ranges, materialize });
+            }
+        }
+    }
+    get hasRules() {
+        return this.rules.length > 0;
+    }
+    /** First rule (rule-list order, matching `updateRule`/grid semantics) whose
+     * ranges contain the cell. */
+    ruleIdAt(rowIndex, columnIndex) {
+        for (const rule of this.rules) {
+            for (const range of rule.ranges) {
+                if (rowIndex >= range.startRowIndex &&
+                    rowIndex <= range.endRowIndex &&
+                    columnIndex >= range.startColumnIndex &&
+                    columnIndex <= range.endColumnIndex) {
+                    return rule.id;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Stamp an emitted row in place: covered existing cells get
+     * `dataValidation: <ruleId>`, and covered holes inside small ranges get a
+     * phantom `{ dataValidation }` cell (budget-capped).
+     */
+    stampRow(rowIndex, values) {
+        if (!this.hasRules)
+            return;
+        this.emittedRows.add(rowIndex);
+        // Existing cells first — bounded by real data, so range size is irrelevant.
+        values.forEach((cell, columnIndex) => {
+            if (!cell || cell.dataValidation != null)
+                return;
+            const id = this.ruleIdAt(rowIndex, columnIndex);
+            if (id !== undefined) {
+                values[columnIndex] = { ...cell, dataValidation: id };
+            }
+        });
+        // Then materialize covered holes (first rule wins via the null check).
+        for (const rule of this.rules) {
+            for (let i = 0; i < rule.ranges.length; i++) {
+                if (!rule.materialize[i])
+                    continue;
+                const range = rule.ranges[i];
+                if (rowIndex < range.startRowIndex || rowIndex > range.endRowIndex) {
+                    continue;
+                }
+                for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex && this.materializeBudget > 0; columnIndex++) {
+                    if (values[columnIndex] != null)
+                        continue;
+                    values[columnIndex] = { dataValidation: rule.id };
+                    this.materializeBudget--;
+                }
+            }
+        }
+    }
+    /**
+     * Rows covered by small ranges that never streamed out of the file at all
+     * (fully blank template rows). Returns sparse phantom rows to append to the
+     * sheet's final chunk, in ascending row order.
+     */
+    trailingRows() {
+        if (!this.hasRules)
+            return [];
+        const rowsByIndex = new Map();
+        for (const rule of this.rules) {
+            for (let i = 0; i < rule.ranges.length; i++) {
+                if (!rule.materialize[i])
+                    continue;
+                const range = rule.ranges[i];
+                for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                    if (this.emittedRows.has(rowIndex))
+                        continue;
+                    let values = rowsByIndex.get(rowIndex);
+                    if (!values) {
+                        values = [];
+                        rowsByIndex.set(rowIndex, values);
+                    }
+                    for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex && this.materializeBudget > 0; columnIndex++) {
+                        if (values[columnIndex] != null)
+                            continue;
+                        values[columnIndex] = { dataValidation: rule.id };
+                        this.materializeBudget--;
+                    }
+                }
+            }
+        }
+        return [...rowsByIndex.entries()]
+            .filter(([, values]) => values.length > 0)
+            .sort(([a], [b]) => a - b)
+            .map(([rowIndex, values]) => ({ rowIndex, values }));
+    }
+}

package/dist/esm/excel-parser/helpers.d.ts

@@ -0,0 +1,28 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+import type { FilterSpec } from "@rowsncolumns/spreadsheet";
+export declare const getRangeFromAddressRef: (ref: string) => GridRange | undefined;
+/**
+ * Convert an xlsx column width (in units of max-digit-width of the
+ * default workbook font, Calibri 11 → MDW=7px) to pixels.
+ *
+ * Excel's effective rendered pixel count includes a 5-pixel padding
+ * baked into the column box: `pixels = floor(width × MDW + padding)`.
+ * The default width "8.43" renders as 64 px (8.43 × 7 + 5 ≈ 64.01),
+ * matching Excel exactly. The "pure" ECMA-376 §18.3.1.13 formula omits
+ * the 5px padding; we keep the +5 form so our pixel output matches
+ * Excel's rendered widths and round-trips with our exporter.
+ */
+export declare function excelColumnWidthToPixels(width: number): number;
+export declare function findMax(arr: number[]): number;
+export declare function createFilterSpecsFromAutoFilter(autoFilter: any, 
+/**
+ * Optional dxf resolver — called with (dxfId, cellColor) to return a
+ * hex color string. When omitted, `<colorFilter>` entries are skipped
+ * (caller doesn't have access to workbook dxfs).
+ */
+resolveDxfColor?: (dxfId: number, cellColor: boolean) => string | undefined): FilterSpec[];
+/**
+ * Reads an Excel file and extracts sheet metadata
+ */
+export declare function readExcelFile(file: File | ArrayBuffer): Promise<ArrayBuffer>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/esm/excel-parser/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../excel-parser/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAY,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAStE,eAAO,MAAM,sBAAsB,GAAI,KAAK,MAAM,KAAG,SAAS,GAAG,SAIhE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,UAIrD;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,UAMpC;AAuBD,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,GAAG;AACf;;;;GAIG;AACH,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,gBA8F5E;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,WAAW,wBAkB3D"}

package/dist/esm/excel-parser/helpers.js

@@ -0,0 +1,160 @@
+import { customFiltersToCondition, dynamicFilterToCondition, } from "../autofilter-condition";
+import { addressToSelection } from "@rowsncolumns/utils";
+export const getRangeFromAddressRef = (ref) => {
+    const selection = addressToSelection(ref);
+    if (!selection)
+        return undefined;
+    return selection.range;
+};
+/**
+ * Convert an xlsx column width (in units of max-digit-width of the
+ * default workbook font, Calibri 11 → MDW=7px) to pixels.
+ *
+ * Excel's effective rendered pixel count includes a 5-pixel padding
+ * baked into the column box: `pixels = floor(width × MDW + padding)`.
+ * The default width "8.43" renders as 64 px (8.43 × 7 + 5 ≈ 64.01),
+ * matching Excel exactly. The "pure" ECMA-376 §18.3.1.13 formula omits
+ * the 5px padding; we keep the +5 form so our pixel output matches
+ * Excel's rendered widths and round-trips with our exporter.
+ */
+export function excelColumnWidthToPixels(width) {
+    const padding = 5;
+    const charWidth = 7;
+    return Math.floor(width * charWidth + padding);
+}
+export function findMax(arr) {
+    let max = arr[0];
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i] > max)
+            max = arr[i];
+    }
+    return max;
+}
+const getNodeText = (node) => {
+    if (node === undefined || node === null) {
+        return undefined;
+    }
+    if (typeof node === "object") {
+        if ("t$" in node && node.t$ !== undefined) {
+            return node.t$;
+        }
+        if ("_" in node && node._ !== undefined) {
+            return node._;
+        }
+        if ("#text" in node && node["#text"] !== undefined) {
+            return node["#text"];
+        }
+        return undefined;
+    }
+    return String(node);
+};
+export function createFilterSpecsFromAutoFilter(autoFilter, 
+/**
+ * Optional dxf resolver — called with (dxfId, cellColor) to return a
+ * hex color string. When omitted, `<colorFilter>` entries are skipped
+ * (caller doesn't have access to workbook dxfs).
+ */
+resolveDxfColor) {
+    const filterSpecs = [];
+    // Handle both with and without namespace prefix
+    const filterColumn = autoFilter?.filterColumn ?? autoFilter?.["x:filterColumn"];
+    if (!filterColumn) {
+        return filterSpecs;
+    }
+    const filterColumns = Array.isArray(filterColumn)
+        ? filterColumn
+        : [filterColumn];
+    for (const col of filterColumns) {
+        const columnIndex = parseInt(col.a$.colId);
+        const criteria = {};
+        // <filters><filter val=…/></filters>
+        const filtersObj = col.filters ?? col["x:filters"];
+        const filter = filtersObj?.filter ?? filtersObj?.["x:filter"];
+        if (filter) {
+            const filterArray = Array.isArray(filter) ? filter : [filter];
+            criteria.visibleValues = filterArray.map((f) => f.a$.val);
+        }
+        // <colorFilter dxfId="…" cellColor="1|0"/>
+        const colorFilterNode = col.colorFilter ?? col["x:colorFilter"];
+        if (colorFilterNode && resolveDxfColor) {
+            const attrs = colorFilterNode.a$ ?? colorFilterNode;
+            const dxfIdRaw = attrs?.dxfId;
+            if (dxfIdRaw !== undefined) {
+                const dxfId = parseInt(String(dxfIdRaw), 10);
+                const cellColor = attrs?.cellColor !== "0" && attrs?.cellColor !== "false";
+                if (Number.isFinite(dxfId)) {
+                    const color = resolveDxfColor(dxfId, cellColor);
+                    if (color) {
+                        criteria.colorFilter = {
+                            color,
+                            mode: cellColor ? "cellColor" : "fontColor",
+                        };
+                    }
+                }
+            }
+        }
+        // <iconFilter iconSet="…" iconId="…"/>
+        const iconFilterNode = col.iconFilter ?? col["x:iconFilter"];
+        if (iconFilterNode) {
+            const attrs = iconFilterNode.a$ ?? iconFilterNode;
+            const iconSet = attrs?.iconSet;
+            if (typeof iconSet === "string" && iconSet.length) {
+                const iconIdRaw = attrs?.iconId;
+                const iconId = typeof iconIdRaw === "string" || typeof iconIdRaw === "number"
+                    ? parseInt(String(iconIdRaw), 10)
+                    : 0;
+                criteria.iconFilter = {
+                    iconSet,
+                    iconId: Number.isFinite(iconId) ? iconId : 0,
+                };
+            }
+        }
+        // <customFilters and="1"><customFilter operator=… val=…/></customFilters>
+        const customFiltersNode = col.customFilters ?? col["x:customFilters"];
+        if (customFiltersNode) {
+            const cfAttrs = customFiltersNode.a$ ?? customFiltersNode;
+            const and = cfAttrs?.and === "1" || cfAttrs?.and === "true";
+            const cfRaw = customFiltersNode.customFilter ?? customFiltersNode["x:customFilter"];
+            const cfArray = (Array.isArray(cfRaw) ? cfRaw : cfRaw ? [cfRaw] : []).map((f) => {
+                const a = f.a$ ?? f;
+                return { operator: a?.operator, val: a?.val };
+            });
+            const condition = customFiltersToCondition(cfArray, and);
+            if (condition)
+                criteria.condition = condition;
+        }
+        // <dynamicFilter type="thisMonth"/> etc.
+        const dynamicNode = col.dynamicFilter ?? col["x:dynamicFilter"];
+        if (dynamicNode && !criteria.condition) {
+            const dynAttrs = dynamicNode.a$ ?? dynamicNode;
+            const condition = dynamicFilterToCondition(dynAttrs?.type);
+            if (condition)
+                criteria.condition = condition;
+        }
+        if (Object.keys(criteria).length > 0) {
+            filterSpecs.push({ columnIndex, filterCriteria: criteria });
+        }
+    }
+    return filterSpecs.sort((a, b) => a.columnIndex - b.columnIndex);
+}
+/**
+ * Reads an Excel file and extracts sheet metadata
+ */
+export async function readExcelFile(file) {
+    try {
+        // Read file as ArrayBuffer
+        const buffer = file instanceof File
+            ? await new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => resolve(reader.result);
+                reader.onerror = reject;
+                reader.readAsArrayBuffer(file);
+            })
+            : file;
+        return buffer;
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+}