@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-import-session.d.ts

@@ -0,0 +1,51 @@
+import type { WorkerResponse } from "./excel-parser/types";
+import { ResponseType } from "./excel-parser/types";
+type OpenCompleteMessage = Extract<WorkerResponse, {
+    responseType: ResponseType.OPEN_WORKBOOK_COMPLETE;
+}>;
+type SheetChunkMessage = Extract<WorkerResponse, {
+    responseType: ResponseType.SHEET_CHUNK;
+}>;
+type SheetCompleteMessage = Extract<WorkerResponse, {
+    responseType: ResponseType.SHEET_COMPLETE;
+}>;
+export type ExcelSessionOpenSuccess = {
+    status: "open";
+} & Omit<OpenCompleteMessage, "responseType" | "generation">;
+/**
+ * The workbook is encrypted. Prompt the user, then call
+ * `session.providePassword(password)` — it resolves with the same
+ * `ExcelSessionOpenResult` shape (another `password-required` on a wrong
+ * password), mirroring the eager flow's PASSWORD_REQUIRED loop.
+ */
+export type ExcelSessionPasswordRequired = {
+    status: "password-required";
+    message?: string;
+};
+export type ExcelSessionOpenResult = ExcelSessionOpenSuccess | ExcelSessionPasswordRequired;
+export type ExcelSessionSheetChunk = Omit<SheetChunkMessage, "responseType" | "generation" | "requestId">;
+export type ExcelSessionSheetComplete = Omit<SheetCompleteMessage, "responseType" | "generation" | "requestId">;
+export type ExcelSessionLoadSheetOptions = {
+    chunkSize?: number;
+    enableCellXfsRegistry?: boolean;
+    enableSharedStrings?: boolean;
+    signal?: AbortSignal;
+};
+export type ExcelImportSession = {
+    open(): Promise<ExcelSessionOpenResult>;
+    providePassword(password: string): Promise<ExcelSessionOpenResult>;
+    loadSheet(sheetId: number, options?: ExcelSessionLoadSheetOptions): AsyncGenerator<ExcelSessionSheetChunk, ExcelSessionSheetComplete, void>;
+    dispose(): void;
+};
+/**
+ * Typed client for the session import worker protocol (issue #336). Opens
+ * a workbook once, keeps it resident worker-side, and streams individual
+ * sheets on demand with automatic requestId allocation, chunk
+ * acknowledgement backpressure, cancellation, and generation management.
+ */
+export declare const createExcelImportSession: (file: File | ArrayBuffer, options?: {
+    minRowCount?: number;
+    minColumnCount?: number;
+}) => ExcelImportSession;
+export {};
+//# sourceMappingURL=excel-import-session.d.ts.map

package/dist/cjs/excel-import-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excel-import-session.d.ts","sourceRoot":"","sources":["../../excel-import-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAe,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEjE,KAAK,mBAAmB,GAAG,OAAO,CAChC,cAAc,EACd;IAAE,YAAY,EAAE,YAAY,CAAC,sBAAsB,CAAA;CAAE,CACtD,CAAC;AACF,KAAK,iBAAiB,GAAG,OAAO,CAC9B,cAAc,EACd;IAAE,YAAY,EAAE,YAAY,CAAC,WAAW,CAAA;CAAE,CAC3C,CAAC;AACF,KAAK,oBAAoB,GAAG,OAAO,CACjC,cAAc,EACd;IAAE,YAAY,EAAE,YAAY,CAAC,cAAc,CAAA;CAAE,CAC9C,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,IAAI,CAAC,mBAAmB,EAAE,cAAc,GAAG,YAAY,CAAC,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAC9B,uBAAuB,GACvB,4BAA4B,CAAC;AAEjC,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACvC,iBAAiB,EACjB,cAAc,GAAG,YAAY,GAAG,WAAW,CAC5C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,oBAAoB,EACpB,cAAc,GAAG,YAAY,GAAG,WAAW,CAC5C,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACxC,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACnE,SAAS,CACP,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,4BAA4B,GACrC,cAAc,CAAC,sBAAsB,EAAE,yBAAyB,EAAE,IAAI,CAAC,CAAC;IAC3E,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AA2BF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,IAAI,GAAG,WAAW,EACxB,UAAU;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,KAC1D,kBAgRF,CAAC"}

package/dist/cjs/excel-import-session.js

@@ -0,0 +1,307 @@
+import { __assign, __asyncGenerator, __await, __generator, __rest, __values } from "tslib";
+import { RequestType, ResponseType } from "./excel-parser/types";
+// Hosts whose bundlers can't resolve the `new URL(...)` worker specifier
+// (e.g. turbopack) can supply their own worker constructors here — same
+// global and same `excel` slot as `createExcelImportWorker`.
+var createWorkerInstance = function () {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = globalThis.__ATHENA_TOOLKIT_WORKER_FACTORIES) === null || _a === void 0 ? void 0 : _a.excel) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : new Worker(new URL("@rowsncolumns/toolkit/worker", import.meta.url), {
+        type: "module",
+    });
+};
+// The watchdog covers workbook opening only (the worker-never-loaded
+// failure mode). A resident session is expected to sit idle between sheet
+// loads, and a streaming sheet can legitimately pause on host-side
+// consumption, so prolonged silence is not an error outside open().
+var WORKER_OPEN_TIMEOUT_MS = 20000;
+var abortError = function () {
+    var error = new Error("The sheet load was aborted");
+    error.name = "AbortError";
+    return error;
+};
+/**
+ * Typed client for the session import worker protocol (issue #336). Opens
+ * a workbook once, keeps it resident worker-side, and streams individual
+ * sheets on demand with automatic requestId allocation, chunk
+ * acknowledgement backpressure, cancellation, and generation management.
+ */
+export var createExcelImportSession = function (file, options) {
+    var worker = createWorkerInstance();
+    var generation = 0;
+    var requestCounter = 0;
+    var disposed = false;
+    var pendingOpen = null;
+    var streams = new Map();
+    var openWatchdog = null;
+    var clearOpenWatchdog = function () {
+        if (openWatchdog !== null) {
+            clearTimeout(openWatchdog);
+            openWatchdog = null;
+        }
+    };
+    var failEverything = function (error) {
+        var e_1, _a;
+        var _b;
+        clearOpenWatchdog();
+        if (pendingOpen) {
+            var reject = pendingOpen.reject;
+            pendingOpen = null;
+            reject(error);
+        }
+        try {
+            for (var _c = __values(streams.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var state = _d.value;
+                state.failed = error;
+                (_b = state.waiter) === null || _b === void 0 ? void 0 : _b.call(state);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    var settleOpen = function (result) {
+        if (!pendingOpen) {
+            return;
+        }
+        clearOpenWatchdog();
+        var resolve = pendingOpen.resolve;
+        pendingOpen = null;
+        resolve(result);
+    };
+    worker.onmessage = function (e) {
+        var _a, _b, _c;
+        var data = e === null || e === void 0 ? void 0 : e.data;
+        if (!(data === null || data === void 0 ? void 0 : data.responseType)) {
+            return;
+        }
+        var messageGeneration = data.generation;
+        if (messageGeneration !== undefined && messageGeneration !== generation) {
+            return;
+        }
+        switch (data.responseType) {
+            case ResponseType.OPEN_WORKBOOK_COMPLETE: {
+                var _rt = data.responseType, _g = data.generation, rest = __rest(data, ["responseType", "generation"]);
+                settleOpen(__assign({ status: "open" }, rest));
+                break;
+            }
+            case ResponseType.PASSWORD_REQUIRED: {
+                settleOpen({ status: "password-required", message: data.message });
+                break;
+            }
+            case ResponseType.SHEET_CHUNK:
+            case ResponseType.SHEET_COMPLETE: {
+                var state = streams.get(data.requestId);
+                if (state) {
+                    state.queue.push(data);
+                    (_a = state.waiter) === null || _a === void 0 ? void 0 : _a.call(state);
+                }
+                break;
+            }
+            case ResponseType.ERROR: {
+                var error = new Error((_b = data.error) !== null && _b !== void 0 ? _b : "Excel import worker error");
+                var requestId = data.requestId;
+                if (requestId !== undefined) {
+                    var state = streams.get(requestId);
+                    if (state) {
+                        state.failed = error;
+                        (_c = state.waiter) === null || _c === void 0 ? void 0 : _c.call(state);
+                    }
+                    break;
+                }
+                if (pendingOpen) {
+                    clearOpenWatchdog();
+                    var reject = pendingOpen.reject;
+                    pendingOpen = null;
+                    reject(error);
+                }
+                break;
+            }
+            default:
+                // IMPORT_PROGRESS and other liveness messages need no routing.
+                break;
+        }
+    };
+    worker.onerror = function (error) {
+        failEverything(error instanceof ErrorEvent && error.message
+            ? new Error(error.message)
+            : new Error("Worker failed to load or crashed. Check worker URL resolution and browser console/network logs."));
+    };
+    worker.onmessageerror = function () {
+        failEverything(new Error("Worker could not deserialize a message (onmessageerror). It likely failed to load. Check the browser console/network logs."));
+    };
+    var awaitOpenResult = function (send) {
+        return new Promise(function (resolve, reject) {
+            if (disposed) {
+                reject(new Error("The import session has been disposed"));
+                return;
+            }
+            if (pendingOpen) {
+                pendingOpen.reject(new Error("Superseded by a newer open()"));
+            }
+            pendingOpen = { generation: generation, resolve: resolve, reject: reject };
+            send();
+            clearOpenWatchdog();
+            openWatchdog = setTimeout(function () {
+                failEverything(new Error("Worker failed to load or stalled (no response). Check worker URL resolution and browser console/network logs."));
+            }, WORKER_OPEN_TIMEOUT_MS);
+        });
+    };
+    var open = function () {
+        var e_2, _a;
+        var _b;
+        generation += 1;
+        // Streams from the previous generation will never see another message.
+        var superseded = new Error("Superseded by a newer open()");
+        try {
+            for (var _c = __values(streams.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var state = _d.value;
+                state.failed = superseded;
+                (_b = state.waiter) === null || _b === void 0 ? void 0 : _b.call(state);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return awaitOpenResult(function () {
+            worker.postMessage({
+                requestType: RequestType.OPEN_WORKBOOK,
+                generation: generation,
+                file: file,
+                minRowCount: options === null || options === void 0 ? void 0 : options.minRowCount,
+                minColumnCount: options === null || options === void 0 ? void 0 : options.minColumnCount,
+            });
+        });
+    };
+    var providePassword = function (password) {
+        return awaitOpenResult(function () {
+            worker.postMessage({
+                requestType: RequestType.PROVIDE_PASSWORD,
+                password: password,
+            });
+        });
+    };
+    function loadSheet(sheetId, loadOptions) {
+        return __asyncGenerator(this, arguments, function loadSheet_1() {
+            var signal, requestId, requestGeneration, state, done, cancel, onAbort, message, _rt_1, _g_1, _r_1, rest, _rt, _g, _r, chunk;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (disposed) {
+                            throw new Error("The import session has been disposed");
+                        }
+                        if (generation === 0) {
+                            throw new Error("open() must resolve before loading sheets");
+                        }
+                        signal = loadOptions === null || loadOptions === void 0 ? void 0 : loadOptions.signal;
+                        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                            throw abortError();
+                        }
+                        requestCounter += 1;
+                        requestId = "req-".concat(requestCounter);
+                        requestGeneration = generation;
+                        state = { queue: [], waiter: null, failed: null };
+                        streams.set(requestId, state);
+                        done = false;
+                        cancel = function () {
+                            if (done || disposed) {
+                                return;
+                            }
+                            worker.postMessage({
+                                requestType: RequestType.CANCEL_REQUEST,
+                                generation: requestGeneration,
+                                requestId: requestId,
+                            });
+                        };
+                        onAbort = function () {
+                            var _a;
+                            cancel();
+                            state.failed = abortError();
+                            (_a = state.waiter) === null || _a === void 0 ? void 0 : _a.call(state);
+                        };
+                        signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 11, 12]);
+                        worker.postMessage({
+                            requestType: RequestType.LOAD_SHEET,
+                            generation: requestGeneration,
+                            requestId: requestId,
+                            sheetId: sheetId,
+                            options: {
+                                chunkSize: loadOptions === null || loadOptions === void 0 ? void 0 : loadOptions.chunkSize,
+                                enableCellXfsRegistry: loadOptions === null || loadOptions === void 0 ? void 0 : loadOptions.enableCellXfsRegistry,
+                                enableSharedStrings: loadOptions === null || loadOptions === void 0 ? void 0 : loadOptions.enableSharedStrings,
+                                enableBackpressure: true,
+                            },
+                        });
+                        _a.label = 2;
+                    case 2:
+                        if (state.failed) {
+                            throw state.failed;
+                        }
+                        message = state.queue.shift();
+                        if (!!message) return [3 /*break*/, 4];
+                        return [4 /*yield*/, __await(new Promise(function (resolve) {
+                                state.waiter = resolve;
+                            }))];
+                    case 3:
+                        _a.sent();
+                        state.waiter = null;
+                        return [3 /*break*/, 9];
+                    case 4:
+                        if (!(message.responseType === ResponseType.SHEET_COMPLETE)) return [3 /*break*/, 6];
+                        done = true;
+                        _rt_1 = message.responseType, _g_1 = message.generation, _r_1 = message.requestId, rest = __rest(message, ["responseType", "generation", "requestId"]);
+                        return [4 /*yield*/, __await(rest)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                    case 6:
+                        _rt = message.responseType, _g = message.generation, _r = message.requestId, chunk = __rest(message, ["responseType", "generation", "requestId"]);
+                        return [4 /*yield*/, __await(chunk)];
+                    case 7: return [4 /*yield*/, _a.sent()];
+                    case 8:
+                        _a.sent();
+                        // The host consumed the chunk (the generator resumed) — release the
+                        // worker's backpressure gate.
+                        worker.postMessage({
+                            requestType: RequestType.ACK_ROW_DATA,
+                            sheetId: chunk.sheetId,
+                            chunkIndex: chunk.chunkIndex,
+                            requestId: requestId,
+                        });
+                        _a.label = 9;
+                    case 9: return [3 /*break*/, 2];
+                    case 10: return [3 /*break*/, 12];
+                    case 11:
+                        signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", onAbort);
+                        streams.delete(requestId);
+                        // Early generator termination (break / .return()) leaves the worker
+                        // stream running — stop it.
+                        cancel();
+                        return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    var dispose = function () {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        worker.postMessage({
+            requestType: RequestType.DISPOSE_WORKBOOK,
+            generation: generation,
+        });
+        failEverything(new Error("The import session has been disposed"));
+        worker.terminate();
+    };
+    return { open: open, providePassword: providePassword, loadSheet: loadSheet, dispose: dispose };
+};

package/dist/cjs/excel-import-worker.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from "rxjs";
+import type { WorkerResponse } from "./excel-parser/types";
+export declare const createExcelImportWorker: (file: File | ArrayBuffer, minRowCount?: number, minColumnCount?: number) => {
+    observable: Observable<WorkerResponse>;
+    sendMessage: (message: any) => void;
+};
+//# sourceMappingURL=excel-import-worker.d.ts.map

package/dist/cjs/excel-import-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excel-import-worker.d.ts","sourceRoot":"","sources":["../../excel-import-worker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAW,MAAM,MAAM,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAuC3D,eAAO,MAAM,uBAAuB,GAClC,MAAM,IAAI,GAAG,WAAW,EACxB,cAAc,MAAM,EACpB,iBAAiB,MAAM;;2BAyGO,GAAG;CASlC,CAAC"}

package/dist/cjs/excel-import-worker.js

@@ -0,0 +1,119 @@
+import { Observable, Subject } from "rxjs";
+import { RequestType, ResponseType } from "./excel-parser/types";
+var getWorkerErrorMessage = function (error) {
+    if (error instanceof ErrorEvent) {
+        var parts = [error.message || "Worker runtime error"];
+        if (error.filename) {
+            var line = error.lineno ? ":".concat(error.lineno) : "";
+            var col = error.colno ? ":".concat(error.colno) : "";
+            parts.push("(".concat(error.filename).concat(line).concat(col, ")"));
+        }
+        return parts.join(" ");
+    }
+    // Some browsers emit a plain Event for worker load failures.
+    return "Worker failed to load or crashed. Check worker URL resolution and browser console/network logs.";
+};
+var getWorkerFactories = function () {
+    return globalThis.__ATHENA_TOOLKIT_WORKER_FACTORIES;
+};
+// A module worker that fails to load/instantiate (e.g. a transient chunk fetch
+// failure on the first import of a session) can emit neither `onmessage` nor
+// `onerror` in some browsers, so the import promise would hang forever (the
+// "Parsing XLSX" loader never clears). The watchdog converts prolonged silence
+// into the normal ERROR path so callers can recover instead of spinning.
+var WORKER_INACTIVITY_TIMEOUT_MS = 20000;
+export var createExcelImportWorker = function (file, minRowCount, minColumnCount) {
+    var _a, _b, _c;
+    var worker = (_c = (_b = (_a = getWorkerFactories()) === null || _a === void 0 ? void 0 : _a.excel) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : new Worker(new URL("@rowsncolumns/toolkit/worker", import.meta.url), {
+        type: "module",
+    });
+    // Create a subject to emit worker events
+    var subject = new Subject();
+    // Watchdog state: once settled (terminal event or failure) we stop watching.
+    var settled = false;
+    var watchdogTimer = null;
+    var clearWatchdog = function () {
+        if (watchdogTimer !== null) {
+            clearTimeout(watchdogTimer);
+            watchdogTimer = null;
+        }
+    };
+    var failWorker = function (message) {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        clearWatchdog();
+        subject.next({
+            responseType: ResponseType.ERROR,
+            error: message,
+        });
+        subject.complete();
+        worker.terminate();
+    };
+    var armWatchdog = function () {
+        if (settled) {
+            return;
+        }
+        clearWatchdog();
+        watchdogTimer = setTimeout(function () {
+            failWorker("Worker failed to load or stalled (no response). Check worker URL resolution and browser console/network logs.");
+        }, WORKER_INACTIVITY_TIMEOUT_MS);
+    };
+    // Handle worker messages
+    worker.onmessage = function (e) {
+        var _a;
+        if (settled) {
+            return;
+        }
+        var responseType = (_a = e === null || e === void 0 ? void 0 : e.data) === null || _a === void 0 ? void 0 : _a.responseType;
+        if (responseType === ResponseType.PARSE_EXCEL_COMPLETE ||
+            responseType === ResponseType.ERROR) {
+            // Terminal event from the worker — stop watching.
+            settled = true;
+            clearWatchdog();
+        }
+        else {
+            // A healthy import streams messages continuously; reset the inactivity
+            // timer so only a real stall (or a worker that never starts) trips it.
+            armWatchdog();
+        }
+        subject.next(e.data);
+    };
+    // Handle worker errors
+    worker.onerror = function (error) {
+        failWorker(getWorkerErrorMessage(error));
+    };
+    // Some browsers surface a failed module instantiation via onmessageerror.
+    worker.onmessageerror = function () {
+        failWorker("Worker could not deserialize a message (onmessageerror). It likely failed to load. Check the browser console/network logs.");
+    };
+    // Initiate the parsing process
+    worker.postMessage({
+        requestType: RequestType.PARSE_EXCEL,
+        file: file,
+        minRowCount: minRowCount,
+        minColumnCount: minColumnCount,
+    });
+    // Start watching as soon as parsing is kicked off.
+    armWatchdog();
+    // Create an observable that completes and cleans up when unsubscribed
+    var observable = new Observable(function (observer) {
+        var subscription = subject.subscribe(observer);
+        // Clean up function that runs when unsubscribed
+        return function () {
+            clearWatchdog();
+            subscription.unsubscribe();
+            worker.terminate();
+        };
+    });
+    // Create a function to send messages to the worker
+    var sendMessage = function (message) {
+        worker.postMessage(message);
+    };
+    // Return both the observable and the send function
+    return {
+        observable: observable,
+        sendMessage: sendMessage,
+    };
+};

package/dist/cjs/excel-parser/builtin-numfmts.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Canonical Excel built-in number-format dictionary (numFmtId 0–49) per
+ * ECMA-376 §18.8.30. Single source of truth shared by both the importer
+ * (`excel-parser/plugins/xlsx`) and the exporter (`exporter/xlsx`) so a
+ * built-in numFmt survives round-trips through our data layer.
+ *
+ * IDs 23–36 are reserved / locale-specific and intentionally omitted —
+ * Excel substitutes them per locale on render; we don't materialize them.
+ *
+ * Currency patterns (5–8) and accounting patterns (41–44) use the quoted
+ * `"$"` literal form, which is what Excel's own writer emits in xlsx
+ * files. Pattern 47 is `mmss.0` (no colon) per ECMA-376 — Excel writes
+ * this without a colon despite some third-party tools using `mm:ss.0`.
+ */
+export type BuiltinNumFmtEntry = readonly [id: number, pattern: string];
+export declare const BUILTIN_NUMFMTS: readonly BuiltinNumFmtEntry[];
+/** Map: numFmtId → pattern. Used by the importer. */
+export declare const BUILTIN_NUMFMT_BY_ID: ReadonlyMap<number, string>;
+/**
+ * Map: pattern → numFmtId. Used by the exporter to emit a built-in
+ * reference instead of registering a custom numFmt.
+ */
+export declare const BUILTIN_NUMFMT_BY_PATTERN: ReadonlyMap<string, number>;
+//# sourceMappingURL=builtin-numfmts.d.ts.map

package/dist/cjs/excel-parser/builtin-numfmts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-numfmts.d.ts","sourceRoot":"","sources":["../../../excel-parser/builtin-numfmts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAExE,eAAO,MAAM,eAAe,EAAE,SAAS,kBAAkB,EAqCxD,CAAC;AAEF,qDAAqD;AACrD,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAE5D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAEjE,CAAC"}

package/dist/cjs/excel-parser/builtin-numfmts.js

@@ -0,0 +1,63 @@
+/**
+ * Canonical Excel built-in number-format dictionary (numFmtId 0–49) per
+ * ECMA-376 §18.8.30. Single source of truth shared by both the importer
+ * (`excel-parser/plugins/xlsx`) and the exporter (`exporter/xlsx`) so a
+ * built-in numFmt survives round-trips through our data layer.
+ *
+ * IDs 23–36 are reserved / locale-specific and intentionally omitted —
+ * Excel substitutes them per locale on render; we don't materialize them.
+ *
+ * Currency patterns (5–8) and accounting patterns (41–44) use the quoted
+ * `"$"` literal form, which is what Excel's own writer emits in xlsx
+ * files. Pattern 47 is `mmss.0` (no colon) per ECMA-376 — Excel writes
+ * this without a colon despite some third-party tools using `mm:ss.0`.
+ */
+import { __read } from "tslib";
+export var BUILTIN_NUMFMTS = [
+    [0, "General"],
+    [1, "0"],
+    [2, "0.00"],
+    [3, "#,##0"],
+    [4, "#,##0.00"],
+    [5, '"$"#,##0_);("$"#,##0)'],
+    [6, '"$"#,##0_);[Red]("$"#,##0)'],
+    [7, '"$"#,##0.00_);("$"#,##0.00)'],
+    [8, '"$"#,##0.00_);[Red]("$"#,##0.00)'],
+    [9, "0%"],
+    [10, "0.00%"],
+    [11, "0.00E+00"],
+    [12, "# ?/?"],
+    [13, "# ??/??"],
+    [14, "m/d/yyyy"],
+    [15, "d-mmm-yy"],
+    [16, "d-mmm"],
+    [17, "mmm-yy"],
+    [18, "h:mm AM/PM"],
+    [19, "h:mm:ss AM/PM"],
+    [20, "h:mm"],
+    [21, "h:mm:ss"],
+    [22, "m/d/yyyy h:mm"],
+    [37, "#,##0_);(#,##0)"],
+    [38, "#,##0_);[Red](#,##0)"],
+    [39, "#,##0.00_);(#,##0.00)"],
+    [40, "#,##0.00_);[Red](#,##0.00)"],
+    [41, '_(* #,##0_);_(* (#,##0);_(* "-"_);_(@_)'],
+    [42, '_("$"* #,##0_);_("$"* (#,##0);_("$"* "-"_);_(@_)'],
+    [43, '_(* #,##0.00_);_(* (#,##0.00);_(* "-"??_);_(@_)'],
+    [44, '_("$"* #,##0.00_);_("$"* (#,##0.00);_("$"* "-"??_);_(@_)'],
+    [45, "mm:ss"],
+    [46, "[h]:mm:ss"],
+    [47, "mmss.0"],
+    [48, "##0.0E+0"],
+    [49, "@"],
+];
+/** Map: numFmtId → pattern. Used by the importer. */
+export var BUILTIN_NUMFMT_BY_ID = new Map(BUILTIN_NUMFMTS);
+/**
+ * Map: pattern → numFmtId. Used by the exporter to emit a built-in
+ * reference instead of registering a custom numFmt.
+ */
+export var BUILTIN_NUMFMT_BY_PATTERN = new Map(BUILTIN_NUMFMTS.map(function (_a) {
+    var _b = __read(_a, 2), id = _b[0], pattern = _b[1];
+    return [pattern, id];
+}));

package/dist/cjs/excel-parser/cfb-decryptor.d.ts

@@ -0,0 +1,53 @@
+/**
+ * What a CFB (Compound File Binary) container actually holds. Both encrypted
+ * OOXML workbooks and legacy BIFF `.xls` workbooks share the same CFB magic
+ * bytes, so the outer signature alone cannot distinguish them.
+ */
+export type CfbContainerKind = "encrypted-ooxml" | "legacy-xls" | "unknown";
+export declare const LEGACY_XLS_UNSUPPORTED_MESSAGE = "This file is a legacy Excel 97-2003 (.xls) workbook, which is not supported. Please open it in Excel and save it as .xlsx, then try again.";
+/**
+ * Inspects a CFB container's directory to decide whether it is an
+ * Office-encrypted OOXML package (`EncryptionInfo` stream present) or an
+ * unencrypted legacy BIFF `.xls` workbook (`Workbook`/`Book` stream present
+ * without `EncryptionInfo`). Returns "unknown" for anything else, including
+ * containers that fail to parse — callers should fall back to their existing
+ * behavior in that case.
+ */
+export declare const detectCfbContainerKind: (source: File | ArrayBuffer) => Promise<CfbContainerKind>;
+export declare class CFBDecryptor {
+    /**
+     * Decrypts a CFB-encrypted XLSX file
+     * @param source The encrypted file or array buffer
+     * @param password The password to decrypt with
+     * @returns The decrypted XLSX data as ArrayBuffer
+     */
+    static decrypt(source: File | ArrayBuffer, password: string): Promise<ArrayBuffer>;
+    private static decryptAgile;
+    private static getEncryptionInfoContent;
+    private static decryptStandardFamily;
+    /** Standard key derivation (MS-OFFCRYPTO §2.3.4.7): iterated SHA1 then the X1‖X2 final block. */
+    private static standardKey;
+    private static decryptStandardPackage;
+    /** RC4 CryptoAPI key derivation (MS-OFFCRYPTO §2.3.5.2). */
+    private static rc4CryptoApiKey;
+    private static decryptRc4Package;
+    /** AES-ECB block decrypt (no padding). Trailing sub-block bytes are ignored. */
+    private static aesEcbDecrypt;
+    /** RC4 stream cipher (KSA + PRGA). Symmetric — the same op encrypts and decrypts. */
+    private static rc4;
+    private static le32;
+    private static bytesEqual;
+    private static parseEncryptionInfo;
+    private static parseAgileEncryptionXml;
+    private static deriveKey;
+    private static decryptEncryptedKey;
+    private static verifyPassword;
+    private static getEncryptedPackage;
+    private static decryptPackage;
+    private static decryptAESNoPadding;
+    private static deriveAgileBlockKey;
+    private static hash;
+    private static stringToUtf16LE;
+    private static concatArrays;
+}
+//# sourceMappingURL=cfb-decryptor.d.ts.map

package/dist/cjs/excel-parser/cfb-decryptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cfb-decryptor.d.ts","sourceRoot":"","sources":["../../../excel-parser/cfb-decryptor.ts"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,GAAG,YAAY,GAAG,SAAS,CAAC;AAE5E,eAAO,MAAM,8BAA8B,+IACmG,CAAC;AAE/I;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GACjC,QAAQ,IAAI,GAAG,WAAW,KACzB,OAAO,CAAC,gBAAgB,CAiB1B,CAAC;AAEF,qBAAa,YAAY;IACvB;;;;;OAKG;WACU,OAAO,CAClB,MAAM,EAAE,IAAI,GAAG,WAAW,EAC1B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,WAAW,CAAC;IAiCvB,OAAO,CAAC,MAAM,CAAC,YAAY;IA6B3B,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAiBvC,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAsEpC,iGAAiG;IACjG,OAAO,CAAC,MAAM,CAAC,WAAW;IAyB1B,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAiBrC,4DAA4D;IAC5D,OAAO,CAAC,MAAM,CAAC,eAAe;IAmB9B,OAAO,CAAC,MAAM,CAAC,iBAAiB;IA4BhC,gFAAgF;IAChF,OAAO,CAAC,MAAM,CAAC,aAAa;IAM5B,qFAAqF;IACrF,OAAO,CAAC,MAAM,CAAC,GAAG;IAwBlB,OAAO,CAAC,MAAM,CAAC,IAAI;IAMnB,OAAO,CAAC,MAAM,CAAC,UAAU;IAQzB,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA4ClC,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAoGtC,OAAO,CAAC,MAAM,CAAC,SAAS;IAuBxB,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAoBlC,OAAO,CAAC,MAAM,CAAC,cAAc;IAuD7B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAclC,OAAO,CAAC,MAAM,CAAC,cAAc;IAwD7B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IASlC,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAWlC,OAAO,CAAC,MAAM,CAAC,IAAI;IAenB,OAAO,CAAC,MAAM,CAAC,eAAe;IAU9B,OAAO,CAAC,MAAM,CAAC,YAAY;CAW5B"}