@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,862 @@
+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";
+const workbook = new WorkBook();
+const queuedRowAcks = [];
+let 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.
+let sharedStringHashIds = [];
+let sharedStringHashByValue = new Map();
+let sharedStringNextHashIndex = 0;
+const resetSharedStringHashState = () => {
+    sharedStringHashIds = [];
+    sharedStringHashByValue = new Map();
+    sharedStringNextHashIndex = 0;
+};
+const ensureSharedStringHashIds = (sst, richRuns) => {
+    if (!sst)
+        return;
+    for (let i = sharedStringNextHashIndex; i < sst.length; i += 1) {
+        const value = sst[i] ?? "";
+        const runs = 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 }`.
+        const hashInput = runs && runs.length > 0
+            ? canonicalizeRichSharedString(value, runs)
+            : value;
+        let id = contentHash(hashInput);
+        let suffix = 0;
+        while (sharedStringHashByValue.has(id) &&
+            sharedStringHashByValue.get(id) !== hashInput) {
+            suffix += 1;
+            id = contentHash(`${hashInput} ${suffix}`);
+        }
+        if (!sharedStringHashByValue.has(id)) {
+            sharedStringHashByValue.set(id, hashInput);
+        }
+        sharedStringHashIds.push(id);
+    }
+    sharedStringNextHashIndex = sst.length;
+};
+const remapRowCells = (rows) => {
+    if (!rows)
+        return;
+    for (const row of rows) {
+        const values = row?.values;
+        if (!values)
+            continue;
+        for (const cell of values) {
+            if (cell && typeof cell.ss === "string") {
+                const idx = Number(cell.ss);
+                if (Number.isInteger(idx) &&
+                    idx >= 0 &&
+                    idx < sharedStringHashIds.length) {
+                    cell.ss = sharedStringHashIds[idx];
+                }
+            }
+        }
+    }
+};
+const buildSstValue = (text, runs) => {
+    if (runs && runs.length > 0) {
+        return { text: text ?? "", runs };
+    }
+    return text ?? "";
+};
+const buildSstEntries = (sst, richRuns) => {
+    if (!sst)
+        return [];
+    ensureSharedStringHashIds(sst, richRuns);
+    const entries = new Array(sst.length);
+    for (let i = 0; i < sst.length; i += 1) {
+        entries[i] = [sharedStringHashIds[i], buildSstValue(sst[i], richRuns?.get(i))];
+    }
+    return entries;
+};
+const buildSstSlice = (sst, start, richRuns) => {
+    ensureSharedStringHashIds(sst, richRuns);
+    const out = [];
+    for (let i = start; i < sst.length; i += 1) {
+        out.push([sharedStringHashIds[i], buildSstValue(sst[i], richRuns?.get(i))]);
+    }
+    return out;
+};
+// Store file for password retry
+let currentFile = null;
+let currentFileName = null;
+let currentMinRowCount;
+let currentMinColumnCount;
+const isIncorrectPasswordError = (error) => {
+    const message = error.message.toLowerCase();
+    return (message.includes("wrong password") ||
+        message.includes("invalid password") ||
+        message.includes("bad password") ||
+        message.includes("incorrect password"));
+};
+const isEncryptedArchiveError = (error) => {
+    const 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"));
+};
+const CFB_SIGNATURE = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+const isCFBFile = async (source) => {
+    let header;
+    if (source instanceof File) {
+        const buffer = await source.slice(0, CFB_SIGNATURE.length).arrayBuffer();
+        header = new Uint8Array(buffer);
+    }
+    else {
+        header = new Uint8Array(source, 0, CFB_SIGNATURE.length);
+    }
+    if (header.length < CFB_SIGNATURE.length) {
+        return false;
+    }
+    return CFB_SIGNATURE.every((value, index) => header[index] === value);
+};
+const isSameAck = (a, b) => a.sheetId === b.sheetId &&
+    a.chunkIndex === b.chunkIndex &&
+    (a.requestId ?? null) === (b.requestId ?? null);
+const resolveRowAck = (ack) => {
+    if (pendingRowAck && isSameAck(pendingRowAck.key, ack)) {
+        const { resolve } = pendingRowAck;
+        pendingRowAck = null;
+        resolve();
+        return;
+    }
+    queuedRowAcks.push(ack);
+};
+const waitForRowAck = async (key) => {
+    const queuedIndex = queuedRowAcks.findIndex((ack) => isSameAck(ack, key));
+    if (queuedIndex >= 0) {
+        queuedRowAcks.splice(queuedIndex, 1);
+        return;
+    }
+    await new Promise((resolve) => {
+        pendingRowAck = { key, resolve };
+    });
+};
+/** Unblock a stream stuck waiting for an ack that will never arrive. */
+const releaseRowAckForRequest = (requestId) => {
+    if (pendingRowAck &&
+        (requestId === undefined || pendingRowAck.key.requestId === requestId)) {
+        const { resolve } = pendingRowAck;
+        pendingRowAck = null;
+        resolve();
+    }
+};
+let session = null;
+const disposeSession = (s) => {
+    for (const requestId of s.activeStreams.keys()) {
+        s.cancelledRequests.add(requestId);
+        releaseRowAckForRequest(requestId);
+    }
+    s.workbook.dispose();
+    if (session === s) {
+        session = null;
+    }
+};
+const postOpenWorkbookComplete = async (s) => {
+    self.postMessage({
+        responseType: ResponseType.OPEN_WORKBOOK_COMPLETE,
+        generation: s.generation,
+        catalog: await s.workbook.getSheetCatalog(),
+        theme: s.workbook.getTheme(),
+        fonts: s.workbook.getFonts(),
+        namedRanges: s.workbook.getNamedRanges(),
+        requiresRecalc: s.workbook.requiresRecalc(),
+        iterativeCalculationOptions: s.workbook.getIterativeCalculationOptions(),
+        use1904: s.workbook.getUse1904Epoch(),
+    });
+};
+/**
+ * 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.
+ */
+const collectChunkSharedStrings = (s, rows) => {
+    const sst = s.workbook.sharedStrings;
+    if (!sst || !rows)
+        return undefined;
+    ensureSharedStringHashIds(sst, s.workbook.richSharedStringRuns);
+    const entries = [];
+    for (const row of rows) {
+        const values = row?.values;
+        if (!values)
+            continue;
+        for (const cell of values) {
+            if (!cell || typeof cell.ss !== "string")
+                continue;
+            const idx = Number(cell.ss);
+            if (!Number.isInteger(idx) ||
+                idx < 0 ||
+                idx >= sharedStringHashIds.length) {
+                continue;
+            }
+            const id = sharedStringHashIds[idx];
+            if (s.sentSharedStringIds.has(id))
+                continue;
+            s.sentSharedStringIds.add(id);
+            entries.push([
+                id,
+                buildSstValue(sst[idx], s.workbook.richSharedStringRuns?.get(idx)),
+            ]);
+        }
+    }
+    return entries.length ? entries : undefined;
+};
+const runLoadSheet = async (s, msg) => {
+    const { requestId, sheetId } = msg;
+    const isStale = () => session !== s ||
+        s.generation !== msg.generation ||
+        s.cancelledRequests.has(requestId);
+    if (isStale()) {
+        return;
+    }
+    const options = msg.options ?? {};
+    const enableBackpressure = options.enableBackpressure ?? false;
+    const wb = s.workbook;
+    try {
+        const postProgress = (phase, sheetTitle) => {
+            self.postMessage({
+                responseType: ResponseType.IMPORT_PROGRESS,
+                generation: s.generation,
+                phase,
+                sheetTitle,
+            });
+        };
+        postProgress("sheet-metadata");
+        const [sheet, tables] = await wb.getSheet(sheetId, s.minRowCount, s.minColumnCount);
+        if (isStale()) {
+            return;
+        }
+        for await (const result of wb.processSheetDataForSheet({
+            sheetId,
+            chunkSize: options.chunkSize,
+            enableCellXfsRegistry: options.enableCellXfsRegistry,
+            enableSharedStrings: options.enableSharedStrings,
+            onPhase: postProgress,
+        })) {
+            if (isStale()) {
+                return;
+            }
+            const sharedStringsChunk = options.enableSharedStrings === false
+                ? undefined
+                : collectChunkSharedStrings(s, result.rows);
+            remapRowCells(result.rows);
+            self.postMessage({
+                responseType: ResponseType.SHEET_CHUNK,
+                generation: s.generation,
+                requestId,
+                ...result,
+                sharedStringsChunk,
+            });
+            if (enableBackpressure) {
+                await waitForRowAck({
+                    sheetId: result.sheetId,
+                    chunkIndex: result.chunkIndex,
+                    requestId,
+                });
+            }
+            await delay();
+        }
+        if (isStale()) {
+            return;
+        }
+        postProgress("conditional-formatting", sheet.title);
+        const conditionalFormatting = await wb.getConditionalFormatting(sheetId);
+        postProgress("data-validations", sheet.title);
+        const dataValidations = await wb.getDataValidations(sheetId);
+        postProgress("comment-threads", sheet.title);
+        const commentThreads = await wb.getCommentThreads(sheetId);
+        if (isStale()) {
+            return;
+        }
+        self.postMessage({
+            responseType: ResponseType.SHEET_COMPLETE,
+            generation: s.generation,
+            requestId,
+            sheet,
+            tables,
+            conditionalFormatting,
+            dataValidations,
+            commentThreads,
+            cellXfs: wb.getCellXfs(),
+        });
+    }
+    catch (error) {
+        if (!isStale()) {
+            console.trace(error);
+            self.postMessage({
+                responseType: ResponseType.ERROR,
+                generation: s.generation,
+                requestId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    finally {
+        s.activeStreams.delete(requestId);
+        s.cancelledRequests.delete(requestId);
+        if (session === s) {
+            wb.releaseSheetCaches(sheetId);
+        }
+    }
+};
+const openSessionWorkbook = async (s, password) => {
+    const buffer = s.file instanceof File ? s.file : await readExcelFile(s.file);
+    if (await isCFBFile(buffer)) {
+        if ((await detectCfbContainerKind(buffer)) === "legacy-xls") {
+            self.postMessage({
+                responseType: ResponseType.ERROR,
+                generation: s.generation,
+                error: LEGACY_XLS_UNSUPPORTED_MESSAGE,
+            });
+            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;
+        }
+        let decryptedBuffer;
+        try {
+            decryptedBuffer = await CFBDecryptor.decrypt(buffer, password);
+        }
+        catch (decryptError) {
+            if (decryptError instanceof Error &&
+                isIncorrectPasswordError(decryptError)) {
+                s.pendingPassword = true;
+                self.postMessage({
+                    responseType: ResponseType.PASSWORD_REQUIRED,
+                    generation: s.generation,
+                    message: "Incorrect password. Please try again.",
+                });
+                return;
+            }
+            throw decryptError;
+        }
+        resetSharedStringHashState();
+        s.sentSharedStringIds.clear();
+        await s.workbook.load(decryptedBuffer, s.fileName);
+        s.pendingPassword = false;
+        await postOpenWorkbookComplete(s);
+        return;
+    }
+    resetSharedStringHashState();
+    s.sentSharedStringIds.clear();
+    try {
+        await s.workbook.load(buffer, s.fileName, password);
+    }
+    catch (loadError) {
+        if (loadError instanceof Error) {
+            if (loadError.message === "PASSWORD_REQUIRED" ||
+                (password && isIncorrectPasswordError(loadError))) {
+                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;
+            }
+            if (loadError.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;
+            }
+        }
+        throw loadError;
+    }
+    s.pendingPassword = false;
+    await postOpenWorkbookComplete(s);
+};
+// Handle messages from the main thread
+self.onmessage = async (e) => {
+    const { requestType } = e.data;
+    try {
+        // Guard against undefined requestType
+        if (!requestType) {
+            console.error("Received message with undefined requestType:", e.data);
+            return;
+        }
+        if (requestType === RequestType.ACK_ROW_DATA) {
+            resolveRowAck({
+                sheetId: e.data.sheetId,
+                chunkIndex: e.data.chunkIndex,
+                requestId: e.data.requestId,
+            });
+            return;
+        }
+        // Process different action types
+        switch (requestType) {
+            case RequestType.OPEN_WORKBOOK: {
+                const { generation } = e.data;
+                if (session) {
+                    disposeSession(session);
+                }
+                const newSession = {
+                    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;
+                try {
+                    await openSessionWorkbook(newSession);
+                }
+                catch (error) {
+                    console.trace(error);
+                    self.postMessage({
+                        responseType: ResponseType.ERROR,
+                        generation,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                break;
+            }
+            case RequestType.LOAD_SHEET: {
+                const msg = e.data;
+                const s = session;
+                if (!s || s.generation !== msg.generation) {
+                    // Stale request from a previous generation — ignore.
+                    break;
+                }
+                s.activeStreams.set(msg.requestId, { sheetId: msg.sheetId });
+                // Serialize streams so two LOAD_SHEETs never interleave chunks.
+                s.queue = s.queue.then(() => runLoadSheet(s, msg));
+                break;
+            }
+            case RequestType.CANCEL_REQUEST: {
+                const s = session;
+                if (!s || s.generation !== e.data.generation) {
+                    break;
+                }
+                s.cancelledRequests.add(e.data.requestId);
+                releaseRowAckForRequest(e.data.requestId);
+                break;
+            }
+            case RequestType.DISPOSE_WORKBOOK: {
+                const s = session;
+                if (!s || s.generation !== e.data.generation) {
+                    break;
+                }
+                disposeSession(s);
+                break;
+            }
+            case RequestType.PARSE_EXCEL: {
+                currentFile = e.data.file;
+                currentMinRowCount = e.data.minRowCount;
+                currentMinColumnCount = e.data.minColumnCount;
+                const buffer = e.data.file instanceof File
+                    ? e.data.file
+                    : await readExcelFile(e.data.file);
+                currentFileName =
+                    e.data.file instanceof File ? e.data.file.name : "unknown.xlsx";
+                // Check if file uses Office encryption (CFB format)
+                if (await isCFBFile(buffer)) {
+                    if ((await detectCfbContainerKind(buffer)) === "legacy-xls") {
+                        self.postMessage({
+                            responseType: ResponseType.ERROR,
+                            error: LEGACY_XLS_UNSUPPORTED_MESSAGE,
+                        });
+                        return;
+                    }
+                    self.postMessage({
+                        responseType: ResponseType.PASSWORD_REQUIRED,
+                        message: "This file uses Office encryption and requires a password.",
+                    });
+                    return;
+                }
+                // Load workbook (fresh state — clear stale hash mappings from prior import)
+                resetSharedStringHashState();
+                try {
+                    await workbook.load(buffer, currentFileName);
+                }
+                catch (loadError) {
+                    if (loadError instanceof Error &&
+                        loadError.message === "PASSWORD_REQUIRED") {
+                        self.postMessage({
+                            responseType: ResponseType.PASSWORD_REQUIRED,
+                            message: "This file is password protected. Please enter the password.",
+                        });
+                        return;
+                    }
+                    if (loadError instanceof Error &&
+                        loadError.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;
+                    }
+                    throw loadError;
+                }
+                // 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(),
+                });
+                try {
+                    self.postMessage({
+                        responseType: ResponseType.BEGIN_GET_SHEETS,
+                        totalSheets: workbook.getSheetCount(),
+                    });
+                    const [sheets, tables] = await workbook.getSheets(e.data.minRowCount, e.data.minColumnCount);
+                    self.postMessage({
+                        responseType: ResponseType.GET_SHEETS_SUCCESS,
+                        sheets,
+                    });
+                    self.postMessage({
+                        responseType: ResponseType.GET_TABLES_SUCCESS,
+                        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),
+                    });
+                }
+                catch (err) {
+                    console.error(err);
+                }
+                break;
+            }
+            case RequestType.GET_SHEET_DATA: {
+                const enableBackpressure = e.data.enableBackpressure ?? false;
+                let lastSharedStringsLength = workbook.sharedStrings?.length ?? 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);
+                // Long silent phases (per-sheet scans, feature extraction) would trip
+                // the host bridge's inactivity watchdog on large files; emit liveness
+                // heartbeats the host can ignore.
+                const postProgress = (phase, sheetTitle) => {
+                    self.postMessage({
+                        responseType: ResponseType.IMPORT_PROGRESS,
+                        phase,
+                        sheetTitle,
+                    });
+                };
+                // Process sheet data
+                for await (const result of workbook.processSheetData(e.data.pageSize, e.data.enableCellXfsRegistry, e.data.enableSharedStrings, postProgress)) {
+                    let sharedStringsChunk;
+                    if (e.data.enableSharedStrings) {
+                        const currentSharedStrings = workbook.sharedStrings ?? [];
+                        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({
+                        responseType: ResponseType.ROW_DATA_CHUNK,
+                        ...result,
+                        sharedStringsChunk,
+                    });
+                    if (enableBackpressure) {
+                        await waitForRowAck({
+                            sheetId: result.sheetId,
+                            chunkIndex: result.chunkIndex,
+                        });
+                    }
+                    await delay();
+                }
+                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");
+                const drawings = await workbook.getDrawings();
+                self.postMessage({
+                    responseType: ResponseType.GET_DRAWINGS_SUCCESS,
+                    drawings,
+                });
+                // Charts
+                postProgress("charts");
+                const charts = await workbook.getCharts();
+                self.postMessage({
+                    responseType: ResponseType.GET_CHARTS_SUCCESS,
+                    charts,
+                });
+                // Slicers
+                const slicers = await workbook.getSlicers();
+                self.postMessage({
+                    responseType: ResponseType.GET_SLICERS_SUCCESS,
+                    slicers,
+                });
+                // Pivot tables (Phase D1 — import path)
+                postProgress("pivot-tables");
+                try {
+                    const pivotTables = await workbook.getPivotTables();
+                    self.postMessage({
+                        responseType: ResponseType.GET_PIVOT_TABLES_SUCCESS,
+                        pivotTables,
+                    });
+                }
+                catch (e) {
+                    // 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);
+                }
+                // External links (for formulas referencing other workbooks)
+                const externalLinks = await workbook.getExternalLinks();
+                self.postMessage({
+                    responseType: ResponseType.GET_EXTERNAL_LINKS_SUCCESS,
+                    externalLinks,
+                });
+                // Threaded comments (anchor cells already carry `commentThreadId`
+                // from the row chunks; this delivers the thread contents).
+                postProgress("comment-threads");
+                const commentThreads = await workbook.getCommentThreads();
+                self.postMessage({
+                    responseType: ResponseType.GET_COMMENT_THREADS_SUCCESS,
+                    commentThreads,
+                });
+                // Start conditional formatting
+                self.postMessage({
+                    responseType: ResponseType.GET_CONDITIONAL_FORMATTING,
+                });
+                // Conditional formatting
+                const conditionalFormatting = await workbook.getConditionalFormatting();
+                self.postMessage({
+                    responseType: ResponseType.GET_CONDITIONAL_FORMATTING_SUCCESS,
+                    conditionalFormatting,
+                });
+                // Start data validation
+                self.postMessage({
+                    responseType: ResponseType.GET_DATAVALIDATION,
+                });
+                // Data validations
+                const dataValidations = await workbook.getDataValidations();
+                // data validations ranges
+                self.postMessage({
+                    responseType: ResponseType.GET_DATAVALIDATION_SUCCESS,
+                    dataValidations: dataValidations,
+                });
+                // // Send end
+                self.postMessage({
+                    responseType: ResponseType.PARSE_EXCEL_COMPLETE,
+                });
+                workbook.dispose();
+                break;
+            }
+            case RequestType.PROVIDE_PASSWORD: {
+                // Session-mode retry — an OPEN_WORKBOOK hit an encrypted file.
+                if (session?.pendingPassword) {
+                    const s = session;
+                    const password = e.data.password;
+                    if (!password || password.trim() === "") {
+                        self.postMessage({
+                            responseType: ResponseType.PASSWORD_REQUIRED,
+                            generation: s.generation,
+                            message: "Password cannot be empty. Please enter a password.",
+                        });
+                        return;
+                    }
+                    try {
+                        await openSessionWorkbook(s, password);
+                    }
+                    catch (error) {
+                        console.trace(error);
+                        self.postMessage({
+                            responseType: ResponseType.ERROR,
+                            generation: s.generation,
+                            error: error instanceof Error && isEncryptedArchiveError(error)
+                                ? "Unable to decrypt this file with the provided password. The file may use an unsupported encryption format."
+                                : error instanceof Error
+                                    ? error.message
+                                    : String(error),
+                        });
+                    }
+                    return;
+                }
+                if (!currentFile || !currentFileName) {
+                    throw new Error("No file loaded to retry with password");
+                }
+                // Validate password was provided
+                const 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;
+                }
+                const buffer = currentFile instanceof File
+                    ? currentFile
+                    : await readExcelFile(currentFile);
+                // Check if file uses Office encryption (CFB format)
+                const isCFB = await isCFBFile(buffer);
+                // Fresh hash state for this load attempt.
+                resetSharedStringHashState();
+                // Retry loading with password
+                try {
+                    if (isCFB) {
+                        // Decrypt CFB-encrypted file
+                        try {
+                            const decryptedBuffer = await CFBDecryptor.decrypt(buffer, password);
+                            // Load the decrypted file (no password needed now)
+                            await workbook.load(decryptedBuffer, currentFileName);
+                        }
+                        catch (decryptError) {
+                            console.error("CFB decryption error:", decryptError);
+                            if (decryptError instanceof Error && isIncorrectPasswordError(decryptError)) {
+                                self.postMessage({
+                                    responseType: ResponseType.PASSWORD_REQUIRED,
+                                    message: "Incorrect password. Please try again.",
+                                });
+                                return;
+                            }
+                            // Re-throw with more context
+                            if (decryptError instanceof Error) {
+                                throw new Error(`CFB decryption failed: ${decryptError.message}`);
+                            }
+                            throw decryptError;
+                        }
+                    }
+                    else {
+                        // ZIP-encrypted file - pass password to workbook
+                        await workbook.load(buffer, currentFileName, password);
+                    }
+                }
+                catch (loadError) {
+                    if (loadError instanceof Error && isIncorrectPasswordError(loadError)) {
+                        self.postMessage({
+                            responseType: ResponseType.PASSWORD_REQUIRED,
+                            message: "Incorrect password. Please try again.",
+                        });
+                        return;
+                    }
+                    if (loadError instanceof Error && isEncryptedArchiveError(loadError)) {
+                        self.postMessage({
+                            responseType: ResponseType.ERROR,
+                            error: "Unable to decrypt this file with the provided password. The file may use an unsupported encryption format.",
+                        });
+                        return;
+                    }
+                    throw loadError;
+                }
+                // 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(),
+                });
+                try {
+                    self.postMessage({
+                        responseType: ResponseType.BEGIN_GET_SHEETS,
+                        totalSheets: workbook.getSheetCount(),
+                    });
+                    const [sheets, tables] = await workbook.getSheets(currentMinRowCount, currentMinColumnCount);
+                    self.postMessage({
+                        responseType: ResponseType.GET_SHEETS_SUCCESS,
+                        sheets,
+                    });
+                    self.postMessage({
+                        responseType: ResponseType.GET_TABLES_SUCCESS,
+                        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),
+                    });
+                }
+                catch (err) {
+                    console.error(err);
+                }
+                break;
+            }
+            default:
+                throw new Error(`Unknown action: ${requestType}`);
+        }
+    }
+    catch (error) {
+        console.trace(error);
+        // Send back the error
+        self.postMessage({
+            responseType: ResponseType.ERROR,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+};