@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,1149 @@
+import { __assign, __asyncValues, __awaiter, __generator, __read, __values } from "tslib";
+import { canonicalizeRichSharedString, contentHash } from "@rowsncolumns/utils";
+import { CFBDecryptor, detectCfbContainerKind, LEGACY_XLS_UNSUPPORTED_MESSAGE, } from "./cfb-decryptor";
+import { readExcelFile } from "./helpers";
+import { RequestType, ResponseType } from "./types";
+import { delay } from "./utils";
+import { WorkBook } from "./workbook";
+var workbook = new WorkBook();
+var queuedRowAcks = [];
+var pendingRowAck = null;
+// Shared-string hash mapping. Cells emitted by the plugin layer reference the
+// source SST by numeric index (`ss: "5"`). The worker rewrites those refs to
+// stable content-hash ids before posting to the host so the wire format
+// matches the CSV worker and the host's Map keys are session-stable.
+var sharedStringHashIds = [];
+var sharedStringHashByValue = new Map();
+var sharedStringNextHashIndex = 0;
+var resetSharedStringHashState = function () {
+    sharedStringHashIds = [];
+    sharedStringHashByValue = new Map();
+    sharedStringNextHashIndex = 0;
+};
+var ensureSharedStringHashIds = function (sst, richRuns) {
+    var _a;
+    if (!sst)
+        return;
+    for (var i = sharedStringNextHashIndex; i < sst.length; i += 1) {
+        var value = (_a = sst[i]) !== null && _a !== void 0 ? _a : "";
+        var runs = richRuns === null || richRuns === void 0 ? void 0 : richRuns.get(i);
+        // Plain entries hash text. Rich entries hash the canonical (text + runs)
+        // form so two SST slots with the same text but different runs get
+        // different ids (the bug was both collapsing to contentHash(text)), and
+        // a plain "abc" never collides with a rich `{ text: "abc", runs }`.
+        var hashInput = runs && runs.length > 0
+            ? canonicalizeRichSharedString(value, runs)
+            : value;
+        var id = contentHash(hashInput);
+        var suffix = 0;
+        while (sharedStringHashByValue.has(id) &&
+            sharedStringHashByValue.get(id) !== hashInput) {
+            suffix += 1;
+            id = contentHash("".concat(hashInput, " ").concat(suffix));
+        }
+        if (!sharedStringHashByValue.has(id)) {
+            sharedStringHashByValue.set(id, hashInput);
+        }
+        sharedStringHashIds.push(id);
+    }
+    sharedStringNextHashIndex = sst.length;
+};
+var remapRowCells = function (rows) {
+    var e_1, _a, e_2, _b;
+    if (!rows)
+        return;
+    try {
+        for (var rows_1 = __values(rows), rows_1_1 = rows_1.next(); !rows_1_1.done; rows_1_1 = rows_1.next()) {
+            var row = rows_1_1.value;
+            var values = row === null || row === void 0 ? void 0 : row.values;
+            if (!values)
+                continue;
+            try {
+                for (var values_1 = (e_2 = void 0, __values(values)), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
+                    var cell = values_1_1.value;
+                    if (cell && typeof cell.ss === "string") {
+                        var idx = Number(cell.ss);
+                        if (Number.isInteger(idx) &&
+                            idx >= 0 &&
+                            idx < sharedStringHashIds.length) {
+                            cell.ss = sharedStringHashIds[idx];
+                        }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (values_1_1 && !values_1_1.done && (_b = values_1.return)) _b.call(values_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (rows_1_1 && !rows_1_1.done && (_a = rows_1.return)) _a.call(rows_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+};
+var buildSstValue = function (text, runs) {
+    if (runs && runs.length > 0) {
+        return { text: text !== null && text !== void 0 ? text : "", runs: runs };
+    }
+    return text !== null && text !== void 0 ? text : "";
+};
+var buildSstEntries = function (sst, richRuns) {
+    if (!sst)
+        return [];
+    ensureSharedStringHashIds(sst, richRuns);
+    var entries = new Array(sst.length);
+    for (var i = 0; i < sst.length; i += 1) {
+        entries[i] = [sharedStringHashIds[i], buildSstValue(sst[i], richRuns === null || richRuns === void 0 ? void 0 : richRuns.get(i))];
+    }
+    return entries;
+};
+var buildSstSlice = function (sst, start, richRuns) {
+    ensureSharedStringHashIds(sst, richRuns);
+    var out = [];
+    for (var i = start; i < sst.length; i += 1) {
+        out.push([sharedStringHashIds[i], buildSstValue(sst[i], richRuns === null || richRuns === void 0 ? void 0 : richRuns.get(i))]);
+    }
+    return out;
+};
+// Store file for password retry
+var currentFile = null;
+var currentFileName = null;
+var currentMinRowCount;
+var currentMinColumnCount;
+var isIncorrectPasswordError = function (error) {
+    var message = error.message.toLowerCase();
+    return (message.includes("wrong password") ||
+        message.includes("invalid password") ||
+        message.includes("bad password") ||
+        message.includes("incorrect password"));
+};
+var isEncryptedArchiveError = function (error) {
+    var message = error.message.toLowerCase();
+    return (message.includes("encrypted") ||
+        message.includes("decrypt") ||
+        message.includes("password required") ||
+        message.includes("unsupported_ooxml_encryption") ||
+        message.includes("end of central directory"));
+};
+var CFB_SIGNATURE = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+var isCFBFile = function (source) { return __awaiter(void 0, void 0, void 0, function () {
+    var header, buffer;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(source instanceof File)) return [3 /*break*/, 2];
+                return [4 /*yield*/, source.slice(0, CFB_SIGNATURE.length).arrayBuffer()];
+            case 1:
+                buffer = _a.sent();
+                header = new Uint8Array(buffer);
+                return [3 /*break*/, 3];
+            case 2:
+                header = new Uint8Array(source, 0, CFB_SIGNATURE.length);
+                _a.label = 3;
+            case 3:
+                if (header.length < CFB_SIGNATURE.length) {
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/, CFB_SIGNATURE.every(function (value, index) { return header[index] === value; })];
+        }
+    });
+}); };
+var isSameAck = function (a, b) {
+    var _a, _b;
+    return a.sheetId === b.sheetId &&
+        a.chunkIndex === b.chunkIndex &&
+        ((_a = a.requestId) !== null && _a !== void 0 ? _a : null) === ((_b = b.requestId) !== null && _b !== void 0 ? _b : null);
+};
+var resolveRowAck = function (ack) {
+    if (pendingRowAck && isSameAck(pendingRowAck.key, ack)) {
+        var resolve = pendingRowAck.resolve;
+        pendingRowAck = null;
+        resolve();
+        return;
+    }
+    queuedRowAcks.push(ack);
+};
+var waitForRowAck = function (key) { return __awaiter(void 0, void 0, void 0, function () {
+    var queuedIndex;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                queuedIndex = queuedRowAcks.findIndex(function (ack) { return isSameAck(ack, key); });
+                if (queuedIndex >= 0) {
+                    queuedRowAcks.splice(queuedIndex, 1);
+                    return [2 /*return*/];
+                }
+                return [4 /*yield*/, new Promise(function (resolve) {
+                        pendingRowAck = { key: key, resolve: resolve };
+                    })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+/** Unblock a stream stuck waiting for an ack that will never arrive. */
+var releaseRowAckForRequest = function (requestId) {
+    if (pendingRowAck &&
+        (requestId === undefined || pendingRowAck.key.requestId === requestId)) {
+        var resolve = pendingRowAck.resolve;
+        pendingRowAck = null;
+        resolve();
+    }
+};
+var session = null;
+var disposeSession = function (s) {
+    var e_3, _a;
+    try {
+        for (var _b = __values(s.activeStreams.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var requestId = _c.value;
+            s.cancelledRequests.add(requestId);
+            releaseRowAckForRequest(requestId);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    s.workbook.dispose();
+    if (session === s) {
+        session = null;
+    }
+};
+var postOpenWorkbookComplete = function (s) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _b = (_a = self).postMessage;
+                _c = {
+                    responseType: ResponseType.OPEN_WORKBOOK_COMPLETE,
+                    generation: s.generation
+                };
+                return [4 /*yield*/, s.workbook.getSheetCatalog()];
+            case 1:
+                _b.apply(_a, [(_c.catalog = _d.sent(),
+                        _c.theme = s.workbook.getTheme(),
+                        _c.fonts = s.workbook.getFonts(),
+                        _c.namedRanges = s.workbook.getNamedRanges(),
+                        _c.requiresRecalc = s.workbook.requiresRecalc(),
+                        _c.iterativeCalculationOptions = s.workbook.getIterativeCalculationOptions(),
+                        _c.use1904 = s.workbook.getUse1904Epoch(),
+                        _c)]);
+                return [2 /*return*/];
+        }
+    });
+}); };
+/**
+ * Shared strings newly referenced by this chunk, collected BEFORE
+ * `remapRowCells` rewrites `cell.ss` from source-index strings to
+ * content-hash ids. Only entries whose id hasn't been posted for this
+ * generation are included — the full SST never crosses the boundary.
+ */
+var collectChunkSharedStrings = function (s, rows) {
+    var e_4, _a, e_5, _b;
+    var _c;
+    var sst = s.workbook.sharedStrings;
+    if (!sst || !rows)
+        return undefined;
+    ensureSharedStringHashIds(sst, s.workbook.richSharedStringRuns);
+    var entries = [];
+    try {
+        for (var rows_2 = __values(rows), rows_2_1 = rows_2.next(); !rows_2_1.done; rows_2_1 = rows_2.next()) {
+            var row = rows_2_1.value;
+            var values = row === null || row === void 0 ? void 0 : row.values;
+            if (!values)
+                continue;
+            try {
+                for (var values_2 = (e_5 = void 0, __values(values)), values_2_1 = values_2.next(); !values_2_1.done; values_2_1 = values_2.next()) {
+                    var cell = values_2_1.value;
+                    if (!cell || typeof cell.ss !== "string")
+                        continue;
+                    var idx = Number(cell.ss);
+                    if (!Number.isInteger(idx) ||
+                        idx < 0 ||
+                        idx >= sharedStringHashIds.length) {
+                        continue;
+                    }
+                    var id = sharedStringHashIds[idx];
+                    if (s.sentSharedStringIds.has(id))
+                        continue;
+                    s.sentSharedStringIds.add(id);
+                    entries.push([
+                        id,
+                        buildSstValue(sst[idx], (_c = s.workbook.richSharedStringRuns) === null || _c === void 0 ? void 0 : _c.get(idx)),
+                    ]);
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (values_2_1 && !values_2_1.done && (_b = values_2.return)) _b.call(values_2);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (rows_2_1 && !rows_2_1.done && (_a = rows_2.return)) _a.call(rows_2);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return entries.length ? entries : undefined;
+};
+var runLoadSheet = function (s, msg) { return __awaiter(void 0, void 0, void 0, function () {
+    var requestId, sheetId, isStale, options, enableBackpressure, wb, postProgress, _a, sheet, tables, _b, _c, _d, result, sharedStringsChunk, e_6_1, conditionalFormatting, dataValidations, commentThreads, error_1;
+    var _e, e_6, _f, _g;
+    var _h, _j;
+    return __generator(this, function (_k) {
+        switch (_k.label) {
+            case 0:
+                requestId = msg.requestId, sheetId = msg.sheetId;
+                isStale = function () {
+                    return session !== s ||
+                        s.generation !== msg.generation ||
+                        s.cancelledRequests.has(requestId);
+                };
+                if (isStale()) {
+                    return [2 /*return*/];
+                }
+                options = (_h = msg.options) !== null && _h !== void 0 ? _h : {};
+                enableBackpressure = (_j = options.enableBackpressure) !== null && _j !== void 0 ? _j : false;
+                wb = s.workbook;
+                _k.label = 1;
+            case 1:
+                _k.trys.push([1, 21, 22, 23]);
+                postProgress = function (phase, sheetTitle) {
+                    self.postMessage({
+                        responseType: ResponseType.IMPORT_PROGRESS,
+                        generation: s.generation,
+                        phase: phase,
+                        sheetTitle: sheetTitle,
+                    });
+                };
+                postProgress("sheet-metadata");
+                return [4 /*yield*/, wb.getSheet(sheetId, s.minRowCount, s.minColumnCount)];
+            case 2:
+                _a = __read.apply(void 0, [_k.sent(), 2]), sheet = _a[0], tables = _a[1];
+                if (isStale()) {
+                    return [2 /*return*/];
+                }
+                _k.label = 3;
+            case 3:
+                _k.trys.push([3, 11, 12, 17]);
+                _b = true, _c = __asyncValues(wb.processSheetDataForSheet({
+                    sheetId: sheetId,
+                    chunkSize: options.chunkSize,
+                    enableCellXfsRegistry: options.enableCellXfsRegistry,
+                    enableSharedStrings: options.enableSharedStrings,
+                    onPhase: postProgress,
+                }));
+                _k.label = 4;
+            case 4: return [4 /*yield*/, _c.next()];
+            case 5:
+                if (!(_d = _k.sent(), _e = _d.done, !_e)) return [3 /*break*/, 10];
+                _g = _d.value;
+                _b = false;
+                result = _g;
+                if (isStale()) {
+                    return [2 /*return*/];
+                }
+                sharedStringsChunk = options.enableSharedStrings === false
+                    ? undefined
+                    : collectChunkSharedStrings(s, result.rows);
+                remapRowCells(result.rows);
+                self.postMessage(__assign(__assign({ responseType: ResponseType.SHEET_CHUNK, generation: s.generation, requestId: requestId }, result), { sharedStringsChunk: sharedStringsChunk }));
+                if (!enableBackpressure) return [3 /*break*/, 7];
+                return [4 /*yield*/, waitForRowAck({
+                        sheetId: result.sheetId,
+                        chunkIndex: result.chunkIndex,
+                        requestId: requestId,
+                    })];
+            case 6:
+                _k.sent();
+                _k.label = 7;
+            case 7: return [4 /*yield*/, delay()];
+            case 8:
+                _k.sent();
+                _k.label = 9;
+            case 9:
+                _b = true;
+                return [3 /*break*/, 4];
+            case 10: return [3 /*break*/, 17];
+            case 11:
+                e_6_1 = _k.sent();
+                e_6 = { error: e_6_1 };
+                return [3 /*break*/, 17];
+            case 12:
+                _k.trys.push([12, , 15, 16]);
+                if (!(!_b && !_e && (_f = _c.return))) return [3 /*break*/, 14];
+                return [4 /*yield*/, _f.call(_c)];
+            case 13:
+                _k.sent();
+                _k.label = 14;
+            case 14: return [3 /*break*/, 16];
+            case 15:
+                if (e_6) throw e_6.error;
+                return [7 /*endfinally*/];
+            case 16: return [7 /*endfinally*/];
+            case 17:
+                if (isStale()) {
+                    return [2 /*return*/];
+                }
+                postProgress("conditional-formatting", sheet.title);
+                return [4 /*yield*/, wb.getConditionalFormatting(sheetId)];
+            case 18:
+                conditionalFormatting = _k.sent();
+                postProgress("data-validations", sheet.title);
+                return [4 /*yield*/, wb.getDataValidations(sheetId)];
+            case 19:
+                dataValidations = _k.sent();
+                postProgress("comment-threads", sheet.title);
+                return [4 /*yield*/, wb.getCommentThreads(sheetId)];
+            case 20:
+                commentThreads = _k.sent();
+                if (isStale()) {
+                    return [2 /*return*/];
+                }
+                self.postMessage({
+                    responseType: ResponseType.SHEET_COMPLETE,
+                    generation: s.generation,
+                    requestId: requestId,
+                    sheet: sheet,
+                    tables: tables,
+                    conditionalFormatting: conditionalFormatting,
+                    dataValidations: dataValidations,
+                    commentThreads: commentThreads,
+                    cellXfs: wb.getCellXfs(),
+                });
+                return [3 /*break*/, 23];
+            case 21:
+                error_1 = _k.sent();
+                if (!isStale()) {
+                    console.trace(error_1);
+                    self.postMessage({
+                        responseType: ResponseType.ERROR,
+                        generation: s.generation,
+                        requestId: requestId,
+                        error: error_1 instanceof Error ? error_1.message : String(error_1),
+                    });
+                }
+                return [3 /*break*/, 23];
+            case 22:
+                s.activeStreams.delete(requestId);
+                s.cancelledRequests.delete(requestId);
+                if (session === s) {
+                    wb.releaseSheetCaches(sheetId);
+                }
+                return [7 /*endfinally*/];
+            case 23: return [2 /*return*/];
+        }
+    });
+}); };
+var openSessionWorkbook = function (s, password) { return __awaiter(void 0, void 0, void 0, function () {
+    var buffer, _a, decryptedBuffer, decryptError_1, loadError_1;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (!(s.file instanceof File)) return [3 /*break*/, 1];
+                _a = s.file;
+                return [3 /*break*/, 3];
+            case 1: return [4 /*yield*/, readExcelFile(s.file)];
+            case 2:
+                _a = _b.sent();
+                _b.label = 3;
+            case 3:
+                buffer = _a;
+                return [4 /*yield*/, isCFBFile(buffer)];
+            case 4:
+                if (!_b.sent()) return [3 /*break*/, 12];
+                return [4 /*yield*/, detectCfbContainerKind(buffer)];
+            case 5:
+                if ((_b.sent()) === "legacy-xls") {
+                    self.postMessage({
+                        responseType: ResponseType.ERROR,
+                        generation: s.generation,
+                        error: LEGACY_XLS_UNSUPPORTED_MESSAGE,
+                    });
+                    return [2 /*return*/];
+                }
+                if (!password) {
+                    s.pendingPassword = true;
+                    self.postMessage({
+                        responseType: ResponseType.PASSWORD_REQUIRED,
+                        generation: s.generation,
+                        message: "This file uses Office encryption and requires a password.",
+                    });
+                    return [2 /*return*/];
+                }
+                decryptedBuffer = void 0;
+                _b.label = 6;
+            case 6:
+                _b.trys.push([6, 8, , 9]);
+                return [4 /*yield*/, CFBDecryptor.decrypt(buffer, password)];
+            case 7:
+                decryptedBuffer = _b.sent();
+                return [3 /*break*/, 9];
+            case 8:
+                decryptError_1 = _b.sent();
+                if (decryptError_1 instanceof Error &&
+                    isIncorrectPasswordError(decryptError_1)) {
+                    s.pendingPassword = true;
+                    self.postMessage({
+                        responseType: ResponseType.PASSWORD_REQUIRED,
+                        generation: s.generation,
+                        message: "Incorrect password. Please try again.",
+                    });
+                    return [2 /*return*/];
+                }
+                throw decryptError_1;
+            case 9:
+                resetSharedStringHashState();
+                s.sentSharedStringIds.clear();
+                return [4 /*yield*/, s.workbook.load(decryptedBuffer, s.fileName)];
+            case 10:
+                _b.sent();
+                s.pendingPassword = false;
+                return [4 /*yield*/, postOpenWorkbookComplete(s)];
+            case 11:
+                _b.sent();
+                return [2 /*return*/];
+            case 12:
+                resetSharedStringHashState();
+                s.sentSharedStringIds.clear();
+                _b.label = 13;
+            case 13:
+                _b.trys.push([13, 15, , 16]);
+                return [4 /*yield*/, s.workbook.load(buffer, s.fileName, password)];
+            case 14:
+                _b.sent();
+                return [3 /*break*/, 16];
+            case 15:
+                loadError_1 = _b.sent();
+                if (loadError_1 instanceof Error) {
+                    if (loadError_1.message === "PASSWORD_REQUIRED" ||
+                        (password && isIncorrectPasswordError(loadError_1))) {
+                        s.pendingPassword = true;
+                        self.postMessage({
+                            responseType: ResponseType.PASSWORD_REQUIRED,
+                            generation: s.generation,
+                            message: password
+                                ? "Incorrect password. Please try again."
+                                : "This file is password protected. Please enter the password.",
+                        });
+                        return [2 /*return*/];
+                    }
+                    if (loadError_1.message === "UNSUPPORTED_OOXML_ENCRYPTION") {
+                        self.postMessage({
+                            responseType: ResponseType.ERROR,
+                            generation: s.generation,
+                            error: "This XLSX file uses Office encryption that is not supported yet, so it cannot be opened even with the correct password.",
+                        });
+                        return [2 /*return*/];
+                    }
+                }
+                throw loadError_1;
+            case 16:
+                s.pendingPassword = false;
+                return [4 /*yield*/, postOpenWorkbookComplete(s)];
+            case 17:
+                _b.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+// Handle messages from the main thread
+self.onmessage = function (e) { return __awaiter(void 0, void 0, void 0, function () {
+    var requestType, _a, generation, newSession, error_2, msg_1, s_1, s, s, buffer, _b, loadError_2, _c, sheets, tables, err_1, enableBackpressure, lastSharedStringsLength, postProgress, _d, _e, _f, result, sharedStringsChunk, currentSharedStrings, e_7_1, drawings, charts, slicers, pivotTables, e_8, externalLinks, commentThreads, conditionalFormatting, dataValidations, s, password_1, error_3, password, buffer, _g, isCFB, decryptedBuffer, decryptError_2, loadError_3, _h, sheets, tables, err_2, error_4;
+    var _j, e_7, _k, _l;
+    var _m, _o, _p, _q;
+    return __generator(this, function (_r) {
+        switch (_r.label) {
+            case 0:
+                requestType = e.data.requestType;
+                _r.label = 1;
+            case 1:
+                _r.trys.push([1, 79, , 80]);
+                // Guard against undefined requestType
+                if (!requestType) {
+                    console.error("Received message with undefined requestType:", e.data);
+                    return [2 /*return*/];
+                }
+                if (requestType === RequestType.ACK_ROW_DATA) {
+                    resolveRowAck({
+                        sheetId: e.data.sheetId,
+                        chunkIndex: e.data.chunkIndex,
+                        requestId: e.data.requestId,
+                    });
+                    return [2 /*return*/];
+                }
+                _a = requestType;
+                switch (_a) {
+                    case RequestType.OPEN_WORKBOOK: return [3 /*break*/, 2];
+                    case RequestType.LOAD_SHEET: return [3 /*break*/, 7];
+                    case RequestType.CANCEL_REQUEST: return [3 /*break*/, 8];
+                    case RequestType.DISPOSE_WORKBOOK: return [3 /*break*/, 9];
+                    case RequestType.PARSE_EXCEL: return [3 /*break*/, 10];
+                    case RequestType.GET_SHEET_DATA: return [3 /*break*/, 25];
+                    case RequestType.PROVIDE_PASSWORD: return [3 /*break*/, 52];
+                }
+                return [3 /*break*/, 77];
+            case 2:
+                generation = e.data.generation;
+                if (session) {
+                    disposeSession(session);
+                }
+                newSession = {
+                    generation: generation,
+                    workbook: new WorkBook(),
+                    file: e.data.file,
+                    fileName: e.data.file instanceof File ? e.data.file.name : "unknown.xlsx",
+                    minRowCount: e.data.minRowCount,
+                    minColumnCount: e.data.minColumnCount,
+                    sentSharedStringIds: new Set(),
+                    cancelledRequests: new Set(),
+                    activeStreams: new Map(),
+                    pendingPassword: false,
+                    queue: Promise.resolve(),
+                };
+                session = newSession;
+                _r.label = 3;
+            case 3:
+                _r.trys.push([3, 5, , 6]);
+                return [4 /*yield*/, openSessionWorkbook(newSession)];
+            case 4:
+                _r.sent();
+                return [3 /*break*/, 6];
+            case 5:
+                error_2 = _r.sent();
+                console.trace(error_2);
+                self.postMessage({
+                    responseType: ResponseType.ERROR,
+                    generation: generation,
+                    error: error_2 instanceof Error ? error_2.message : String(error_2),
+                });
+                return [3 /*break*/, 6];
+            case 6: return [3 /*break*/, 78];
+            case 7:
+                {
+                    msg_1 = e.data;
+                    s_1 = session;
+                    if (!s_1 || s_1.generation !== msg_1.generation) {
+                        // Stale request from a previous generation — ignore.
+                        return [3 /*break*/, 78];
+                    }
+                    s_1.activeStreams.set(msg_1.requestId, { sheetId: msg_1.sheetId });
+                    // Serialize streams so two LOAD_SHEETs never interleave chunks.
+                    s_1.queue = s_1.queue.then(function () { return runLoadSheet(s_1, msg_1); });
+                    return [3 /*break*/, 78];
+                }
+                _r.label = 8;
+            case 8:
+                {
+                    s = session;
+                    if (!s || s.generation !== e.data.generation) {
+                        return [3 /*break*/, 78];
+                    }
+                    s.cancelledRequests.add(e.data.requestId);
+                    releaseRowAckForRequest(e.data.requestId);
+                    return [3 /*break*/, 78];
+                }
+                _r.label = 9;
+            case 9:
+                {
+                    s = session;
+                    if (!s || s.generation !== e.data.generation) {
+                        return [3 /*break*/, 78];
+                    }
+                    disposeSession(s);
+                    return [3 /*break*/, 78];
+                }
+                _r.label = 10;
+            case 10:
+                currentFile = e.data.file;
+                currentMinRowCount = e.data.minRowCount;
+                currentMinColumnCount = e.data.minColumnCount;
+                if (!(e.data.file instanceof File)) return [3 /*break*/, 11];
+                _b = e.data.file;
+                return [3 /*break*/, 13];
+            case 11: return [4 /*yield*/, readExcelFile(e.data.file)];
+            case 12:
+                _b = _r.sent();
+                _r.label = 13;
+            case 13:
+                buffer = _b;
+                currentFileName =
+                    e.data.file instanceof File ? e.data.file.name : "unknown.xlsx";
+                return [4 /*yield*/, isCFBFile(buffer)];
+            case 14:
+                if (!_r.sent()) return [3 /*break*/, 16];
+                return [4 /*yield*/, detectCfbContainerKind(buffer)];
+            case 15:
+                if ((_r.sent()) === "legacy-xls") {
+                    self.postMessage({
+                        responseType: ResponseType.ERROR,
+                        error: LEGACY_XLS_UNSUPPORTED_MESSAGE,
+                    });
+                    return [2 /*return*/];
+                }
+                self.postMessage({
+                    responseType: ResponseType.PASSWORD_REQUIRED,
+                    message: "This file uses Office encryption and requires a password.",
+                });
+                return [2 /*return*/];
+            case 16:
+                // Load workbook (fresh state — clear stale hash mappings from prior import)
+                resetSharedStringHashState();
+                _r.label = 17;
+            case 17:
+                _r.trys.push([17, 19, , 20]);
+                return [4 /*yield*/, workbook.load(buffer, currentFileName)];
+            case 18:
+                _r.sent();
+                return [3 /*break*/, 20];
+            case 19:
+                loadError_2 = _r.sent();
+                if (loadError_2 instanceof Error &&
+                    loadError_2.message === "PASSWORD_REQUIRED") {
+                    self.postMessage({
+                        responseType: ResponseType.PASSWORD_REQUIRED,
+                        message: "This file is password protected. Please enter the password.",
+                    });
+                    return [2 /*return*/];
+                }
+                if (loadError_2 instanceof Error &&
+                    loadError_2.message === "UNSUPPORTED_OOXML_ENCRYPTION") {
+                    self.postMessage({
+                        responseType: ResponseType.ERROR,
+                        error: "This XLSX file uses Office encryption that is not supported yet, so it cannot be opened even with the correct password.",
+                    });
+                    return [2 /*return*/];
+                }
+                throw loadError_2;
+            case 20:
+                // Send the result back
+                self.postMessage({
+                    responseType: ResponseType.PARSE_EXCEL_SUCCESS,
+                    requiresRecalc: workbook.requiresRecalc(),
+                    iterativeCalculationOptions: workbook.getIterativeCalculationOptions(),
+                    use1904: workbook.getUse1904Epoch(),
+                });
+                // Pass theme back
+                self.postMessage({
+                    responseType: ResponseType.GET_THEME_SUCCESS,
+                    theme: workbook.getTheme(),
+                });
+                _r.label = 21;
+            case 21:
+                _r.trys.push([21, 23, , 24]);
+                self.postMessage({
+                    responseType: ResponseType.BEGIN_GET_SHEETS,
+                    totalSheets: workbook.getSheetCount(),
+                });
+                return [4 /*yield*/, workbook.getSheets(e.data.minRowCount, e.data.minColumnCount)];
+            case 22:
+                _c = __read.apply(void 0, [_r.sent(), 2]), sheets = _c[0], tables = _c[1];
+                self.postMessage({
+                    responseType: ResponseType.GET_SHEETS_SUCCESS,
+                    sheets: sheets,
+                });
+                self.postMessage({
+                    responseType: ResponseType.GET_TABLES_SUCCESS,
+                    tables: tables,
+                });
+                // Preload fonts
+                self.postMessage({
+                    responseType: ResponseType.GET_FONTS_SUCCESS,
+                    fonts: workbook.getFonts(),
+                });
+                // named ranges
+                self.postMessage({
+                    responseType: ResponseType.GET_NAMEDRANGES_SUCCESS,
+                    namedRanges: workbook.getNamedRanges(),
+                });
+                // shared strings (emit as [hashId, value][] so cells and ids stay
+                // self-consistent across the worker→host boundary).
+                self.postMessage({
+                    responseType: ResponseType.GET_SHARED_STRINGS_SUCCESS,
+                    sharedStrings: buildSstEntries(workbook.sharedStrings, workbook.richSharedStringRuns),
+                });
+                return [3 /*break*/, 24];
+            case 23:
+                err_1 = _r.sent();
+                console.error(err_1);
+                return [3 /*break*/, 24];
+            case 24: return [3 /*break*/, 78];
+            case 25:
+                enableBackpressure = (_m = e.data.enableBackpressure) !== null && _m !== void 0 ? _m : false;
+                lastSharedStringsLength = (_p = (_o = workbook.sharedStrings) === null || _o === void 0 ? void 0 : _o.length) !== null && _p !== void 0 ? _p : 0;
+                // Make sure hash ids exist for any strings loaded before this request
+                // (e.g. XLSX populates the full SST upfront).
+                ensureSharedStringHashIds(workbook.sharedStrings, workbook.richSharedStringRuns);
+                postProgress = function (phase, sheetTitle) {
+                    self.postMessage({
+                        responseType: ResponseType.IMPORT_PROGRESS,
+                        phase: phase,
+                        sheetTitle: sheetTitle,
+                    });
+                };
+                _r.label = 26;
+            case 26:
+                _r.trys.push([26, 34, 35, 40]);
+                _d = true, _e = __asyncValues(workbook.processSheetData(e.data.pageSize, e.data.enableCellXfsRegistry, e.data.enableSharedStrings, postProgress));
+                _r.label = 27;
+            case 27: return [4 /*yield*/, _e.next()];
+            case 28:
+                if (!(_f = _r.sent(), _j = _f.done, !_j)) return [3 /*break*/, 33];
+                _l = _f.value;
+                _d = false;
+                result = _l;
+                sharedStringsChunk = void 0;
+                if (e.data.enableSharedStrings) {
+                    currentSharedStrings = (_q = workbook.sharedStrings) !== null && _q !== void 0 ? _q : [];
+                    if (currentSharedStrings.length > lastSharedStringsLength) {
+                        sharedStringsChunk = buildSstSlice(currentSharedStrings, lastSharedStringsLength, workbook.richSharedStringRuns);
+                        lastSharedStringsLength = currentSharedStrings.length;
+                    }
+                    else {
+                        // Ensure hash ids stay in sync even when no new strings appeared
+                        ensureSharedStringHashIds(currentSharedStrings, workbook.richSharedStringRuns);
+                    }
+                }
+                // Rewrite cell.ss from source-index strings to content-hash ids so
+                // cells the host sees agree with the chunk + final SST it receives.
+                remapRowCells(result.rows);
+                self.postMessage(__assign(__assign({ responseType: ResponseType.ROW_DATA_CHUNK }, result), { sharedStringsChunk: sharedStringsChunk }));
+                if (!enableBackpressure) return [3 /*break*/, 30];
+                return [4 /*yield*/, waitForRowAck({
+                        sheetId: result.sheetId,
+                        chunkIndex: result.chunkIndex,
+                    })];
+            case 29:
+                _r.sent();
+                _r.label = 30;
+            case 30: return [4 /*yield*/, delay()];
+            case 31:
+                _r.sent();
+                _r.label = 32;
+            case 32:
+                _d = true;
+                return [3 /*break*/, 27];
+            case 33: return [3 /*break*/, 40];
+            case 34:
+                e_7_1 = _r.sent();
+                e_7 = { error: e_7_1 };
+                return [3 /*break*/, 40];
+            case 35:
+                _r.trys.push([35, , 38, 39]);
+                if (!(!_d && !_j && (_k = _e.return))) return [3 /*break*/, 37];
+                return [4 /*yield*/, _k.call(_e)];
+            case 36:
+                _r.sent();
+                _r.label = 37;
+            case 37: return [3 /*break*/, 39];
+            case 38:
+                if (e_7) throw e_7.error;
+                return [7 /*endfinally*/];
+            case 39: return [7 /*endfinally*/];
+            case 40:
+                self.postMessage({
+                    responseType: ResponseType.GET_SHEET_DATA_SUCCESS,
+                });
+                // Send cell format registry
+                self.postMessage({
+                    responseType: ResponseType.CELL_XFS,
+                    cellXfs: workbook.getCellXfs(),
+                });
+                // Shared strings — final SST as [id, value][]
+                self.postMessage({
+                    responseType: ResponseType.GET_SHARED_STRINGS_SUCCESS,
+                    sharedStrings: buildSstEntries(workbook.sharedStrings, workbook.richSharedStringRuns),
+                });
+                // Process drawing
+                postProgress("drawings");
+                return [4 /*yield*/, workbook.getDrawings()];
+            case 41:
+                drawings = _r.sent();
+                self.postMessage({
+                    responseType: ResponseType.GET_DRAWINGS_SUCCESS,
+                    drawings: drawings,
+                });
+                // Charts
+                postProgress("charts");
+                return [4 /*yield*/, workbook.getCharts()];
+            case 42:
+                charts = _r.sent();
+                self.postMessage({
+                    responseType: ResponseType.GET_CHARTS_SUCCESS,
+                    charts: charts,
+                });
+                return [4 /*yield*/, workbook.getSlicers()];
+            case 43:
+                slicers = _r.sent();
+                self.postMessage({
+                    responseType: ResponseType.GET_SLICERS_SUCCESS,
+                    slicers: slicers,
+                });
+                // Pivot tables (Phase D1 — import path)
+                postProgress("pivot-tables");
+                _r.label = 44;
+            case 44:
+                _r.trys.push([44, 46, , 47]);
+                return [4 /*yield*/, workbook.getPivotTables()];
+            case 45:
+                pivotTables = _r.sent();
+                self.postMessage({
+                    responseType: ResponseType.GET_PIVOT_TABLES_SUCCESS,
+                    pivotTables: pivotTables,
+                });
+                return [3 /*break*/, 47];
+            case 46:
+                e_8 = _r.sent();
+                // Pivot parsing is best-effort — never block the rest of
+                // the import on a single malformed pivot. Worker emits an
+                // empty list so the host can clear any stale pivots.
+                self.postMessage({
+                    responseType: ResponseType.GET_PIVOT_TABLES_SUCCESS,
+                    pivotTables: [],
+                });
+                // eslint-disable-next-line no-console
+                console.warn("[excel-parser] pivot table import failed:", e_8);
+                return [3 /*break*/, 47];
+            case 47: return [4 /*yield*/, workbook.getExternalLinks()];
+            case 48:
+                externalLinks = _r.sent();
+                self.postMessage({
+                    responseType: ResponseType.GET_EXTERNAL_LINKS_SUCCESS,
+                    externalLinks: externalLinks,
+                });
+                // Threaded comments (anchor cells already carry `commentThreadId`
+                // from the row chunks; this delivers the thread contents).
+                postProgress("comment-threads");
+                return [4 /*yield*/, workbook.getCommentThreads()];
+            case 49:
+                commentThreads = _r.sent();
+                self.postMessage({
+                    responseType: ResponseType.GET_COMMENT_THREADS_SUCCESS,
+                    commentThreads: commentThreads,
+                });
+                // Start conditional formatting
+                self.postMessage({
+                    responseType: ResponseType.GET_CONDITIONAL_FORMATTING,
+                });
+                return [4 /*yield*/, workbook.getConditionalFormatting()];
+            case 50:
+                conditionalFormatting = _r.sent();
+                self.postMessage({
+                    responseType: ResponseType.GET_CONDITIONAL_FORMATTING_SUCCESS,
+                    conditionalFormatting: conditionalFormatting,
+                });
+                // Start data validation
+                self.postMessage({
+                    responseType: ResponseType.GET_DATAVALIDATION,
+                });
+                return [4 /*yield*/, workbook.getDataValidations()];
+            case 51:
+                dataValidations = _r.sent();
+                // data validations ranges
+                self.postMessage({
+                    responseType: ResponseType.GET_DATAVALIDATION_SUCCESS,
+                    dataValidations: dataValidations,
+                });
+                // // Send end
+                self.postMessage({
+                    responseType: ResponseType.PARSE_EXCEL_COMPLETE,
+                });
+                workbook.dispose();
+                return [3 /*break*/, 78];
+            case 52:
+                if (!(session === null || session === void 0 ? void 0 : session.pendingPassword)) return [3 /*break*/, 57];
+                s = session;
+                password_1 = e.data.password;
+                if (!password_1 || password_1.trim() === "") {
+                    self.postMessage({
+                        responseType: ResponseType.PASSWORD_REQUIRED,
+                        generation: s.generation,
+                        message: "Password cannot be empty. Please enter a password.",
+                    });
+                    return [2 /*return*/];
+                }
+                _r.label = 53;
+            case 53:
+                _r.trys.push([53, 55, , 56]);
+                return [4 /*yield*/, openSessionWorkbook(s, password_1)];
+            case 54:
+                _r.sent();
+                return [3 /*break*/, 56];
+            case 55:
+                error_3 = _r.sent();
+                console.trace(error_3);
+                self.postMessage({
+                    responseType: ResponseType.ERROR,
+                    generation: s.generation,
+                    error: error_3 instanceof Error && isEncryptedArchiveError(error_3)
+                        ? "Unable to decrypt this file with the provided password. The file may use an unsupported encryption format."
+                        : error_3 instanceof Error
+                            ? error_3.message
+                            : String(error_3),
+                });
+                return [3 /*break*/, 56];
+            case 56: return [2 /*return*/];
+            case 57:
+                if (!currentFile || !currentFileName) {
+                    throw new Error("No file loaded to retry with password");
+                }
+                password = e.data.password;
+                if (!password || password.trim() === "") {
+                    console.warn("Empty password provided");
+                    self.postMessage({
+                        responseType: ResponseType.PASSWORD_REQUIRED,
+                        message: "Password cannot be empty. Please enter a password.",
+                    });
+                    return [2 /*return*/];
+                }
+                if (!(currentFile instanceof File)) return [3 /*break*/, 58];
+                _g = currentFile;
+                return [3 /*break*/, 60];
+            case 58: return [4 /*yield*/, readExcelFile(currentFile)];
+            case 59:
+                _g = _r.sent();
+                _r.label = 60;
+            case 60:
+                buffer = _g;
+                return [4 /*yield*/, isCFBFile(buffer)];
+            case 61:
+                isCFB = _r.sent();
+                // Fresh hash state for this load attempt.
+                resetSharedStringHashState();
+                _r.label = 62;
+            case 62:
+                _r.trys.push([62, 71, , 72]);
+                if (!isCFB) return [3 /*break*/, 68];
+                _r.label = 63;
+            case 63:
+                _r.trys.push([63, 66, , 67]);
+                return [4 /*yield*/, CFBDecryptor.decrypt(buffer, password)];
+            case 64:
+                decryptedBuffer = _r.sent();
+                // Load the decrypted file (no password needed now)
+                return [4 /*yield*/, workbook.load(decryptedBuffer, currentFileName)];
+            case 65:
+                // Load the decrypted file (no password needed now)
+                _r.sent();
+                return [3 /*break*/, 67];
+            case 66:
+                decryptError_2 = _r.sent();
+                console.error("CFB decryption error:", decryptError_2);
+                if (decryptError_2 instanceof Error && isIncorrectPasswordError(decryptError_2)) {
+                    self.postMessage({
+                        responseType: ResponseType.PASSWORD_REQUIRED,
+                        message: "Incorrect password. Please try again.",
+                    });
+                    return [2 /*return*/];
+                }
+                // Re-throw with more context
+                if (decryptError_2 instanceof Error) {
+                    throw new Error("CFB decryption failed: ".concat(decryptError_2.message));
+                }
+                throw decryptError_2;
+            case 67: return [3 /*break*/, 70];
+            case 68: 
+            // ZIP-encrypted file - pass password to workbook
+            return [4 /*yield*/, workbook.load(buffer, currentFileName, password)];
+            case 69:
+                // ZIP-encrypted file - pass password to workbook
+                _r.sent();
+                _r.label = 70;
+            case 70: return [3 /*break*/, 72];
+            case 71:
+                loadError_3 = _r.sent();
+                if (loadError_3 instanceof Error && isIncorrectPasswordError(loadError_3)) {
+                    self.postMessage({
+                        responseType: ResponseType.PASSWORD_REQUIRED,
+                        message: "Incorrect password. Please try again.",
+                    });
+                    return [2 /*return*/];
+                }
+                if (loadError_3 instanceof Error && isEncryptedArchiveError(loadError_3)) {
+                    self.postMessage({
+                        responseType: ResponseType.ERROR,
+                        error: "Unable to decrypt this file with the provided password. The file may use an unsupported encryption format.",
+                    });
+                    return [2 /*return*/];
+                }
+                throw loadError_3;
+            case 72:
+                // If successful, continue with normal parsing flow
+                self.postMessage({
+                    responseType: ResponseType.PARSE_EXCEL_SUCCESS,
+                    requiresRecalc: workbook.requiresRecalc(),
+                    iterativeCalculationOptions: workbook.getIterativeCalculationOptions(),
+                });
+                self.postMessage({
+                    responseType: ResponseType.GET_THEME_SUCCESS,
+                    theme: workbook.getTheme(),
+                });
+                _r.label = 73;
+            case 73:
+                _r.trys.push([73, 75, , 76]);
+                self.postMessage({
+                    responseType: ResponseType.BEGIN_GET_SHEETS,
+                    totalSheets: workbook.getSheetCount(),
+                });
+                return [4 /*yield*/, workbook.getSheets(currentMinRowCount, currentMinColumnCount)];
+            case 74:
+                _h = __read.apply(void 0, [_r.sent(), 2]), sheets = _h[0], tables = _h[1];
+                self.postMessage({
+                    responseType: ResponseType.GET_SHEETS_SUCCESS,
+                    sheets: sheets,
+                });
+                self.postMessage({
+                    responseType: ResponseType.GET_TABLES_SUCCESS,
+                    tables: tables,
+                });
+                self.postMessage({
+                    responseType: ResponseType.GET_FONTS_SUCCESS,
+                    fonts: workbook.getFonts(),
+                });
+                self.postMessage({
+                    responseType: ResponseType.GET_NAMEDRANGES_SUCCESS,
+                    namedRanges: workbook.getNamedRanges(),
+                });
+                self.postMessage({
+                    responseType: ResponseType.GET_SHARED_STRINGS_SUCCESS,
+                    sharedStrings: buildSstEntries(workbook.sharedStrings, workbook.richSharedStringRuns),
+                });
+                return [3 /*break*/, 76];
+            case 75:
+                err_2 = _r.sent();
+                console.error(err_2);
+                return [3 /*break*/, 76];
+            case 76: return [3 /*break*/, 78];
+            case 77: throw new Error("Unknown action: ".concat(requestType));
+            case 78: return [3 /*break*/, 80];
+            case 79:
+                error_4 = _r.sent();
+                console.trace(error_4);
+                // Send back the error
+                self.postMessage({
+                    responseType: ResponseType.ERROR,
+                    error: error_4 instanceof Error ? error_4.message : String(error_4),
+                });
+                return [3 /*break*/, 80];
+            case 80: return [2 /*return*/];
+        }
+    });
+}); };