@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-parser/plugins/xlsb/index.js

@@ -0,0 +1,2972 @@
+import { __assign, __asyncGenerator, __await, __awaiter, __extends, __generator, __read, __rest, __spreadArray, __values } from "tslib";
+import { getCellXfsKey, ssfFormat, uuid } from "@rowsncolumns/utils";
+import { IndexedColors } from "@rowsncolumns/utils";
+import { XMLParser } from "fast-xml-parser";
+import { get } from "lodash-es";
+import { parseRgce } from "./rgce-parser";
+import { StreamingZipParser } from "../../zip-parser-streaming";
+import { createFilterSpecsFromAutoFilter, excelColumnWidthToPixels, getRangeFromAddressRef, } from "../../helpers";
+import { defaultSpreadsheetTheme } from "../../theme-default";
+import { BaseWorkbookPlugin } from "../base/index";
+import { processChart } from "../xlsx/charts";
+import { processAnchors } from "../xlsx/drawing";
+import { readAllRecordHeaders } from "./biff-record-reader";
+import { standardExcelFormatCodeById } from "../xlsx/numfmt";
+import { extractThemeColors, extractThemeFonts, generateDarkThemeColors, } from "../xlsx/theme";
+var RT = {
+    BrtCellRk: 0x0002,
+    BrtCellBlank: 0x0001,
+    BrtCellError: 0x0003,
+    BrtCellBool: 0x0004,
+    BrtCellReal: 0x0005,
+    BrtCellSt: 0x0006,
+    BrtCellIsst: 0x0007,
+    BrtFmlaString: 0x0008,
+    BrtFmlaNum: 0x0009,
+    BrtFmlaBool: 0x000a,
+    BrtFmlaError: 0x000b,
+    BrtShortBlank: 0x000c,
+    BrtShortRk: 0x000d,
+    BrtShortError: 0x000e,
+    BrtShortBool: 0x000f,
+    BrtShortReal: 0x0010,
+    BrtShortSt: 0x0011,
+    BrtShortIsst: 0x0012,
+    BrtSSTItem: 0x0013,
+    BrtRowHdr: 0x0000,
+    BrtMergeCell: 0x00b0,
+    BrtFmt: 0x002c,
+    BrtFont: 0x002b,
+    BrtFill: 0x002d,
+    BrtBorder: 0x002e,
+    BrtXF: 0x002f,
+    BrtColInfo: 0x003c,
+    BrtBeginFonts: 0x0263,
+    BrtEndFonts: 0x0264,
+    BrtBeginFills: 0x025b,
+    BrtEndFills: 0x025c,
+    BrtBeginBorders: 0x0265,
+    BrtEndBorders: 0x0266,
+    BrtBeginFmts: 0x0267,
+    BrtEndFmts: 0x0268,
+    BrtBeginCellStyleXFs: 0x0272,
+    BrtEndCellStyleXFs: 0x0273,
+    BrtBeginCellXFs: 0x0269,
+    BrtEndCellXFs: 0x026a,
+    BrtBundleSh: 0x009c,
+    BrtSupBookSrc: 0x0163,
+    BrtSupSelf: 0x0165,
+    BrtSupSame: 0x0166,
+    BrtExternSheet: 0x016a,
+    BrtDrawing: 0x0226,
+    BrtBeginAFilter: 0x00a1,
+    BrtListPart: 0x0295,
+    BrtWsView: 0x0089,
+    BrtPane: 0x0097,
+    BrtName: 0x0027,
+    BrtBeginConditionalFormatting: 0x01e5,
+    BrtEndConditionalFormatting: 0x01e6,
+    BrtBeginCFRule: 0x01e7,
+    BrtEndCFRule: 0x01e8,
+    BrtBeginDVals: 0x0105,
+    BrtEndDVals: 0x0106,
+    BrtBeginDVal: 0x0103,
+    BrtEndDVal: 0x0104,
+    BrtWbProp: 0x0099,
+    BrtCalcProp: 0x009d,
+    BrtShrFmla: 0x0018,
+    BrtCFRule: 0x01df,
+    BrtDVal: 0x0103,
+};
+var Reader = /** @class */ (function () {
+    function Reader(bytes) {
+        this.offset = 0;
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    Reader.prototype.readUInt8 = function () {
+        var value = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    };
+    Reader.prototype.readUInt16LE = function () {
+        var value = this.view.getUint16(this.offset, true);
+        this.offset += 2;
+        return value;
+    };
+    Reader.prototype.readInt16LE = function () {
+        var value = this.view.getInt16(this.offset, true);
+        this.offset += 2;
+        return value;
+    };
+    Reader.prototype.readUInt32LE = function () {
+        var value = this.view.getUint32(this.offset, true);
+        this.offset += 4;
+        return value;
+    };
+    Reader.prototype.readInt32LE = function () {
+        var value = this.view.getInt32(this.offset, true);
+        this.offset += 4;
+        return value;
+    };
+    Reader.prototype.readFloat64LE = function () {
+        var value = this.view.getFloat64(this.offset, true);
+        this.offset += 8;
+        return value;
+    };
+    Reader.prototype.readUtf16Chars = function (charCount) {
+        if (charCount <= 0)
+            return "";
+        var byteCount = charCount * 2;
+        var slice = this.bytes.subarray(this.offset, this.offset + byteCount);
+        this.offset += byteCount;
+        return new TextDecoder("utf-16le").decode(slice);
+    };
+    Reader.prototype.readXLWideString = function () {
+        var cch = this.readUInt32LE();
+        return cch === 0 ? "" : this.readUtf16Chars(cch);
+    };
+    Reader.prototype.readXLNullableWideString = function () {
+        var cch = this.readUInt32LE();
+        return cch === 0 || cch === 0xffffffff ? "" : this.readUtf16Chars(cch);
+    };
+    return Reader;
+}());
+var normalizePath = function (path) {
+    return path.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\/+/, "");
+};
+var resolveRelativePath = function (basePath, target) {
+    var e_1, _a;
+    if (target.startsWith("/")) {
+        return normalizePath(target);
+    }
+    var baseParts = normalizePath(basePath).split("/");
+    baseParts.pop();
+    var parts = target.split("/");
+    try {
+        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
+            var part = parts_1_1.value;
+            if (!part || part === ".")
+                continue;
+            if (part === "..") {
+                baseParts.pop();
+            }
+            else {
+                baseParts.push(part);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return normalizePath(baseParts.join("/"));
+};
+var parseBundleSheet = function (payload) {
+    var reader = new Reader(payload);
+    var hidden = reader.readUInt32LE();
+    var tabId = reader.readUInt32LE();
+    var rid = reader.readXLNullableWideString();
+    var title = reader.readXLWideString();
+    return { hidden: hidden, tabId: tabId, rid: rid, title: title };
+};
+var parseRowHeader = function (payload) {
+    var reader = new Reader(payload);
+    var row = reader.readUInt32LE() + 1;
+    reader.readUInt32LE(); // ixfe
+    var miyRw = reader.readUInt16LE();
+    reader.readUInt8(); // top/bottom padding
+    var flags = reader.readUInt8();
+    return {
+        row: row,
+        hidden: Boolean(flags & 0x10),
+        hpt: Boolean(flags & 0x20) ? miyRw / 20 : undefined,
+    };
+};
+var parseMergeRange = function (payload) {
+    var reader = new Reader(payload);
+    var sRow = reader.readUInt32LE() + 1;
+    var eRow = reader.readUInt32LE() + 1;
+    var sCol = reader.readUInt32LE() + 1;
+    var eCol = reader.readUInt32LE() + 1;
+    return {
+        startRowIndex: sRow,
+        endRowIndex: eRow,
+        startColumnIndex: sCol,
+        endColumnIndex: eCol,
+    };
+};
+var parseRange = function (payload) { return parseMergeRange(payload); };
+var normalizeSheetTabIndex = function (value) {
+    return value === 0xffff || value === 0xffffffff ? -1 : value;
+};
+var parseBrtExternSheet = function (payload) {
+    var parseEntries = function (startOffset, entrySize, readEntry) {
+        if (startOffset > payload.length)
+            return [];
+        var bytes = payload.subarray(startOffset);
+        if (bytes.length === 0 || bytes.length % entrySize !== 0) {
+            return [];
+        }
+        var reader = new Reader(bytes);
+        var out = [];
+        while (reader.offset + entrySize <= reader.bytes.length) {
+            out.push(readEntry(reader));
+        }
+        return out;
+    };
+    var read12 = function (reader) { return ({
+        iSupBook: reader.readUInt32LE(),
+        itabFirst: normalizeSheetTabIndex(reader.readUInt32LE()),
+        itabLast: normalizeSheetTabIndex(reader.readUInt32LE()),
+    }); };
+    var read6 = function (reader) { return ({
+        iSupBook: reader.readUInt16LE(),
+        itabFirst: normalizeSheetTabIndex(reader.readUInt16LE()),
+        itabLast: normalizeSheetTabIndex(reader.readUInt16LE()),
+    }); };
+    var direct12 = parseEntries(0, 12, read12);
+    if (direct12.length > 0)
+        return direct12;
+    if (payload.length >= 4) {
+        var reader = new Reader(payload);
+        var count = reader.readUInt32LE();
+        var withCount12 = parseEntries(4, 12, read12);
+        if (withCount12.length === count && withCount12.length > 0) {
+            return withCount12;
+        }
+    }
+    var direct6 = parseEntries(0, 6, read6);
+    if (direct6.length > 0)
+        return direct6;
+    if (payload.length >= 2) {
+        var reader = new Reader(payload);
+        var count = reader.readUInt16LE();
+        var withCount6 = parseEntries(2, 6, read6);
+        if (withCount6.length === count && withCount6.length > 0) {
+            return withCount6;
+        }
+    }
+    return [];
+};
+var parseBrtShrFmla = function (payload) {
+    var e_2, _a;
+    if (payload.length < 20)
+        return null;
+    var reader = new Reader(payload);
+    var startRowZero = reader.readUInt32LE();
+    var endRowZero = reader.readUInt32LE();
+    var startColZero = reader.readUInt32LE();
+    var endColZero = reader.readUInt32LE();
+    // cce can be preceded by small metadata in some files; try a few offsets.
+    var candidateOffsets = [16, 18, 20, 24];
+    var rgceBytes;
+    try {
+        for (var candidateOffsets_1 = __values(candidateOffsets), candidateOffsets_1_1 = candidateOffsets_1.next(); !candidateOffsets_1_1.done; candidateOffsets_1_1 = candidateOffsets_1.next()) {
+            var offset = candidateOffsets_1_1.value;
+            if (offset + 4 > payload.length)
+                continue;
+            var cce = new DataView(payload.buffer, payload.byteOffset + offset, 4).getUint32(0, true);
+            if (cce <= 0)
+                continue;
+            var start = offset + 4;
+            var end = start + cce;
+            if (end <= payload.length) {
+                rgceBytes = payload.subarray(start, end);
+                break;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (candidateOffsets_1_1 && !candidateOffsets_1_1.done && (_a = candidateOffsets_1.return)) _a.call(candidateOffsets_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (!rgceBytes || rgceBytes.length === 0)
+        return null;
+    return {
+        startRow: startRowZero + 1,
+        endRow: endRowZero + 1,
+        startCol: startColZero + 1,
+        endCol: endColZero + 1,
+        rgceBytes: rgceBytes,
+    };
+};
+var parseWsView = function (payload) {
+    var reader = new Reader(payload);
+    var flags = reader.readUInt16LE();
+    // Bit 1 (0x0002): fShowGridLines - if 0, gridlines are hidden
+    var showGridLines = (flags & 0x0002) !== 0;
+    return { showGridLines: showGridLines };
+};
+var parsePane = function (payload) {
+    var reader = new Reader(payload);
+    var xSplit = reader.readFloat64LE();
+    var ySplit = reader.readFloat64LE();
+    reader.readUInt32LE(); // rwTop
+    reader.readUInt32LE(); // colLeft
+    var pnnAcct = reader.readUInt8();
+    // Frozen panes have pnnAcct set to specific values
+    var isFrozen = pnnAcct > 0;
+    return {
+        frozenColumnCount: isFrozen && xSplit > 0 ? Math.round(xSplit) : 0,
+        frozenRowCount: isFrozen && ySplit > 0 ? Math.round(ySplit) : 0,
+    };
+};
+export var parseBrtNamePayload = function (payload, resolveSheetNameByXti) {
+    try {
+        var reader = new Reader(payload);
+        var flags = reader.readUInt32LE();
+        var fHidden = (flags & 0x00000001) !== 0;
+        reader.readUInt8(); // chKey
+        var itab = reader.readUInt32LE(); // sheet index (0xFFFFFFFF for workbook scope)
+        // Read the name string
+        if (reader.offset + 4 > payload.length) {
+            return null; // Not enough data
+        }
+        var name_1 = reader.readXLWideString();
+        // NameParsedFormula: cce (UInt32) followed by cce bytes of Rgce
+        var formula = "";
+        if (reader.offset + 4 <= payload.length) {
+            var cce = reader.readUInt32LE();
+            if (cce > 0 && reader.offset + cce <= payload.length) {
+                var rgceBytes = payload.subarray(reader.offset, reader.offset + cce);
+                formula = parseRgce(rgceBytes, resolveSheetNameByXti);
+            }
+        }
+        return {
+            name: name_1,
+            formula: formula,
+            hidden: fHidden,
+            sheetIndex: itab === 0xffffffff ? undefined : itab,
+        };
+    }
+    catch (err) {
+        // If parsing fails, return null to skip this named range
+        return null;
+    }
+};
+/**
+ * Parse the `BrtWbProp` workbook-properties record (MS-XLSB 2.4.312).
+ * The payload starts with a 32-bit flags field; `fDate1904` is bit 0 of the
+ * first flag byte and switches the workbook's date serials to the 1904 epoch
+ * (Mac-origin workbooks), shifting every date by 1462 days.
+ */
+export var parseBrtWbPropPayload = function (payload) {
+    if (payload.length < 1) {
+        return null;
+    }
+    return {
+        use1904: (payload[0] & 0x01) !== 0,
+    };
+};
+var parseBrtCalcPropPayload = function (payload) {
+    try {
+        var reader = new Reader(payload);
+        reader.readUInt32LE(); // recalcID
+        var flags = reader.readUInt16LE();
+        var fFullCalcOnLoad = (flags & 0x0002) !== 0;
+        var fIter = (flags & 0x0008) !== 0;
+        var fForceFullCalc = (flags & 0x0100) !== 0;
+        var cCalcCount = reader.readUInt32LE(); // iteration count
+        var xnumDelta = reader.readFloat64LE(); // iteration delta
+        return {
+            fullCalcOnLoad: fFullCalcOnLoad || fForceFullCalc,
+            iterate: fIter,
+            iterateCount: cCalcCount,
+            iterateDelta: xnumDelta,
+        };
+    }
+    catch (err) {
+        // If parsing fails, return default values
+        return null;
+    }
+};
+/**
+ * Parse conditional formatting range and rules from BrtBeginConditionalFormatting
+ */
+var parseBrtBeginConditionalFormatting = function (payload) {
+    try {
+        var reader = new Reader(payload);
+        // Read the range reference (sqref)
+        var sqref = reader.readXLWideString();
+        return { sqref: sqref };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+/**
+ * Parse CF rule from BrtCFRule / BrtBeginCFRule
+ */
+var parseBrtCFRule = function (payload) {
+    try {
+        var reader = new Reader(payload);
+        var flags = reader.readUInt32LE();
+        var ruleType = reader.readUInt8(); // CF rule type
+        var dxfId = reader.readInt32LE(); // DXF format ID (-1 if none)
+        var priority = reader.readUInt32LE();
+        // Parse flags
+        var stopIfTrue = (flags & 0x02) !== 0;
+        // For now, return basic structure
+        // Full implementation would parse formulas, operators, values based on rule type
+        return {
+            ruleType: ruleType,
+            dxfId: dxfId >= 0 ? dxfId : undefined,
+            priority: priority,
+            stopIfTrue: stopIfTrue,
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+/**
+ * Parse data validation from BrtBeginDVal
+ */
+var parseBrtBeginDVal = function (payload) {
+    try {
+        var reader = new Reader(payload);
+        var flags = reader.readUInt32LE();
+        // Parse validation type and operator
+        var valType = reader.readUInt8(); // 0=none, 1=whole, 2=decimal, 3=list, 4=date, 5=time, 6=textLength, 7=custom
+        var operator = reader.readUInt8(); // 0=between, 1=notBetween, 2=equal, 3=notEqual, etc.
+        // Parse flags
+        var ignoreBlank = (flags & 0x01) !== 0;
+        var inCellDropdown = (flags & 0x02) === 0; // Inverted logic
+        var showInputMessage = (flags & 0x04) !== 0;
+        var showErrorMessage = (flags & 0x08) !== 0;
+        // Error style: 0=stop, 1=warning, 2=information
+        var errorStyle = (flags >> 4) & 0x03;
+        // Read strings
+        var promptTitle = reader.readXLWideString();
+        var errorTitle = reader.readXLWideString();
+        var prompt_1 = reader.readXLWideString();
+        var error = reader.readXLWideString();
+        // Range would be in the parent record or following data
+        // For now, return parsed data
+        return {
+            valType: valType,
+            operator: operator,
+            ignoreBlank: ignoreBlank,
+            inCellDropdown: inCellDropdown,
+            showInputMessage: showInputMessage,
+            showErrorMessage: showErrorMessage,
+            errorStyle: errorStyle,
+            promptTitle: promptTitle,
+            errorTitle: errorTitle,
+            prompt: prompt_1,
+            error: error,
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+var parseRkNumber = function (payload, offset) {
+    var b0 = payload[offset];
+    var fX100 = (b0 & 1) !== 0;
+    var fInt = (b0 & 2) !== 0;
+    var value;
+    if (fInt) {
+        var view = new DataView(payload.buffer, payload.byteOffset + offset, payload.byteLength - offset);
+        value = (view.getInt32(0, true) >> 2);
+    }
+    else {
+        var out = new Uint8Array(8);
+        out.set(payload.subarray(offset, offset + 4), 4);
+        out[4] &= 0xfc;
+        value = new DataView(out.buffer).getFloat64(0, true);
+    }
+    return fX100 ? value / 100 : value;
+};
+var XLSB_FILL_PATTERN_NAMES = [
+    "none",
+    "solid",
+    "mediumGray",
+    "darkGray",
+    "lightGray",
+    "darkHorizontal",
+    "darkVertical",
+    "darkDown",
+    "darkUp",
+    "darkGrid",
+    "darkTrellis",
+    "lightHorizontal",
+    "lightVertical",
+    "lightDown",
+    "lightUp",
+    "lightGrid",
+    "lightTrellis",
+    "gray125",
+    "gray0625",
+];
+var getNumberFormatType = function (pattern) {
+    var lower = pattern.toLowerCase();
+    if (lower.includes("yy") || lower.includes("dd"))
+        return "DATE";
+    if (lower.includes("h:") || lower.includes("am/pm"))
+        return "TIME";
+    if (lower.includes("%"))
+        return "PERCENT";
+    if (lower.includes("$") ||
+        lower.includes("€") ||
+        lower.includes("£") ||
+        lower.includes("¥")) {
+        return "CURRENCY";
+    }
+    if (lower.includes("0") || lower.includes("#"))
+        return "NUMBER";
+    return "GENERAL";
+};
+var parseCellFromRecord = function (type, payload, row, prevCol, resolveSheetNameByXti, resolveSharedFormula, parseFormula) {
+    if (parseFormula === void 0) { parseFormula = true; }
+    if (row <= 0)
+        return null;
+    var reader = new Reader(payload);
+    var colZero;
+    var styleRef;
+    var isShort = type === RT.BrtShortRk ||
+        type === RT.BrtShortError ||
+        type === RT.BrtShortBool ||
+        type === RT.BrtShortReal ||
+        type === RT.BrtShortSt ||
+        type === RT.BrtShortIsst;
+    if (isShort) {
+        styleRef = reader.readUInt16LE() + (reader.readUInt8() << 16);
+        reader.readUInt8();
+        colZero = prevCol + 1;
+    }
+    else {
+        colZero = reader.readUInt32LE();
+        styleRef = reader.readUInt16LE() + (reader.readUInt8() << 16);
+        reader.readUInt8();
+    }
+    if (type === RT.BrtCellIsst || type === RT.BrtShortIsst) {
+        var sharedStringIndex = reader.readUInt32LE();
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "s",
+            value: sharedStringIndex,
+            sharedStringIndex: sharedStringIndex,
+        };
+    }
+    if (type === RT.BrtCellBlank || type === RT.BrtShortBlank) {
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "blank",
+            value: "",
+        };
+    }
+    var readFormula = function () {
+        var e_3, _a, e_4, _b;
+        if (!parseFormula)
+            return undefined;
+        var candidateStarts = [
+            reader.offset - 2,
+            reader.offset,
+            reader.offset + 2,
+            reader.offset + 4,
+            reader.offset + 6,
+            reader.offset + 8,
+            reader.offset + 10,
+            reader.offset + 12,
+        ].filter(function (start, idx, arr) { return start >= 0 && arr.indexOf(start) === idx; });
+        var decodeAt = function (start, cceSize) {
+            if (cceSize === 4) {
+                if (start + 4 > payload.length)
+                    return undefined;
+                var cce_1 = new DataView(payload.buffer, payload.byteOffset + start, 4).getUint32(0, true);
+                if (cce_1 <= 0)
+                    return undefined;
+                var rgceStart_1 = start + 4;
+                var rgceEnd_1 = rgceStart_1 + cce_1;
+                if (rgceEnd_1 > payload.length)
+                    return undefined;
+                return payload.subarray(rgceStart_1, rgceEnd_1);
+            }
+            if (start + 2 > payload.length)
+                return undefined;
+            var cce = new DataView(payload.buffer, payload.byteOffset + start, 2).getUint16(0, true);
+            if (cce <= 0)
+                return undefined;
+            var rgceStart = start + 2;
+            var rgceEnd = rgceStart + cce;
+            if (rgceEnd > payload.length)
+                return undefined;
+            return payload.subarray(rgceStart, rgceEnd);
+        };
+        var tryResolve = function (parsed) {
+            var expMatch = parsed.match(/^__PTGEXP__:(\d+):(\d+)$/);
+            if (!expMatch)
+                return parsed;
+            if (!resolveSharedFormula)
+                return undefined;
+            var sourceRow = Number(expMatch[1]);
+            var sourceCol = Number(expMatch[2]);
+            return resolveSharedFormula(sourceRow, sourceCol, row, colZero + 1);
+        };
+        try {
+            for (var candidateStarts_1 = __values(candidateStarts), candidateStarts_1_1 = candidateStarts_1.next(); !candidateStarts_1_1.done; candidateStarts_1_1 = candidateStarts_1.next()) {
+                var start = candidateStarts_1_1.value;
+                try {
+                    for (var _c = (e_4 = void 0, __values([4, 2])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var cceSize = _d.value;
+                        var rgceBytes = decodeAt(start, cceSize);
+                        if (!rgceBytes || rgceBytes.length === 0)
+                            continue;
+                        var parsed = parseRgce(rgceBytes, resolveSheetNameByXti, { row: row, col: colZero + 1 }, true);
+                        if (!parsed)
+                            continue;
+                        var resolved = tryResolve(parsed);
+                        if (resolved && resolved.length > 0) {
+                            return resolved;
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (candidateStarts_1_1 && !candidateStarts_1_1.done && (_a = candidateStarts_1.return)) _a.call(candidateStarts_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return undefined;
+    };
+    if (type === RT.BrtFmlaNum) {
+        var value = reader.readFloat64LE();
+        reader.readUInt16LE(); // flags
+        var formula = readFormula();
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "n",
+            value: value,
+            formula: formula,
+        };
+    }
+    if (type === RT.BrtFmlaString) {
+        var value = reader.readXLWideString();
+        reader.readUInt16LE(); // flags
+        var formula = readFormula();
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "str",
+            value: value,
+            formula: formula,
+        };
+    }
+    if (type === RT.BrtFmlaBool) {
+        var value = reader.readUInt8() !== 0;
+        reader.readUInt8(); // padding
+        reader.readUInt16LE(); // flags
+        var formula = readFormula();
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "b",
+            value: value,
+            formula: formula,
+        };
+    }
+    if (type === RT.BrtFmlaError) {
+        var value = reader.readUInt8();
+        reader.readUInt8(); // padding
+        reader.readUInt16LE(); // flags
+        var formula = readFormula();
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "e",
+            value: value,
+            formula: formula,
+        };
+    }
+    if (type === RT.BrtCellSt || type === RT.BrtShortSt) {
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "str",
+            value: reader.readXLWideString(),
+        };
+    }
+    if (type === RT.BrtCellReal || type === RT.BrtShortReal) {
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "n",
+            value: reader.readFloat64LE(),
+        };
+    }
+    if (type === RT.BrtCellRk || type === RT.BrtShortRk) {
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "n",
+            value: parseRkNumber(payload, reader.offset),
+        };
+    }
+    if (type === RT.BrtCellBool || type === RT.BrtShortBool) {
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "b",
+            value: reader.readUInt8() !== 0,
+        };
+    }
+    if (type === RT.BrtCellError || type === RT.BrtShortError) {
+        return {
+            row: row,
+            col: colZero + 1,
+            styleRef: styleRef,
+            kind: "e",
+            value: reader.readUInt8(),
+        };
+    }
+    return null;
+};
+var parseBrtColor = function (reader) {
+    var d = reader.readUInt8();
+    var xColorType = d >>> 1;
+    var index = reader.readUInt8();
+    var tintRaw = reader.readInt16LE();
+    var r = reader.readUInt8();
+    var g = reader.readUInt8();
+    var b = reader.readUInt8();
+    reader.readUInt8(); // alpha
+    var tint = tintRaw === 0 ? undefined : tintRaw > 0 ? tintRaw / 32767 : tintRaw / 32768;
+    if (xColorType === 2) {
+        return "#".concat([r, g, b]
+            .map(function (v) { return v.toString(16).padStart(2, "0"); })
+            .join("")
+            .toUpperCase());
+    }
+    if (xColorType === 3) {
+        return __assign({ theme: index }, (tint != null ? { tint: tint } : {}));
+    }
+    if (xColorType === 1 && index === 64) {
+        return { theme: 1 };
+    }
+    if (xColorType === 1) {
+        return IndexedColors[index];
+    }
+    return undefined;
+};
+var parseBrtFill = function (payload) {
+    var _a;
+    var reader = new Reader(payload);
+    var fill = reader.readUInt32LE();
+    var result = {
+        patternType: (_a = XLSB_FILL_PATTERN_NAMES[fill]) !== null && _a !== void 0 ? _a : (fill === 0x28 ? "gradient" : undefined),
+    };
+    if (fill !== 0x28 && payload.length >= 20) {
+        result.fgColor = parseBrtColor(reader);
+        parseBrtColor(reader);
+    }
+    return result;
+};
+var parseBrtFmt = function (payload) {
+    var reader = new Reader(payload);
+    var id = reader.readUInt16LE();
+    var formatCode = reader.readXLWideString();
+    return { id: id, formatCode: formatCode };
+};
+var parseBrtXf = function (payload) {
+    var reader = new Reader(payload);
+    var parentId = reader.readUInt16LE();
+    var numFmtId = reader.readUInt16LE();
+    var fontId = reader.readUInt16LE();
+    var fillId = reader.readUInt16LE();
+    var borderId = payload.length >= 10 ? reader.readUInt16LE() : 0;
+    var result = { parentId: parentId, numFmtId: numFmtId, fontId: fontId, fillId: fillId, borderId: borderId };
+    // Parse alignment if enough data is available
+    if (payload.length >= 14) {
+        var trot = reader.readUInt8(); // text rotation
+        var indent = reader.readUInt8();
+        var flags = reader.readUInt16LE();
+        // Extract alignment from flags (bits 0-2: horizontal, bits 3-5: vertical)
+        var alH = flags & 0x07; // bits 0-2
+        var alV = (flags >> 3) & 0x07; // bits 3-5
+        var fWrap = (flags >> 6) & 0x01; // bit 6
+        // Map horizontal alignment
+        var horizontalAlignments = [
+            "general",
+            "left",
+            "center",
+            "right",
+            "fill",
+            "justify",
+            "centerContinuous",
+            "distributed",
+        ];
+        if (alH > 0 && alH < horizontalAlignments.length) {
+            result.horizontalAlignment = horizontalAlignments[alH];
+        }
+        // Map vertical alignment
+        var verticalAlignments = [
+            "top",
+            "middle",
+            "bottom",
+            "justify",
+            "distributed",
+        ];
+        if (alV > 0 && alV < verticalAlignments.length) {
+            var mapped = verticalAlignments[alV];
+            result.verticalAlignment = mapped === "middle" ? "middle" : mapped;
+        }
+        // Wrap text
+        if (fWrap) {
+            result.wrapText = true;
+        }
+        // Text rotation
+        if (trot === 0xff) {
+            result.textRotation = "vertical";
+        }
+        else if (trot > 0 && trot <= 90) {
+            result.textRotation = trot;
+        }
+        else if (trot >= 91 && trot <= 180) {
+            result.textRotation = -(trot - 90);
+        }
+        // Indent
+        if (indent > 0) {
+            result.indent = indent;
+        }
+    }
+    return result;
+};
+var parseBrtColInfo = function (payload) {
+    var reader = new Reader(payload);
+    var startCol = reader.readUInt32LE() + 1;
+    var endCol = reader.readUInt32LE() + 1;
+    var coldx = reader.readUInt32LE();
+    reader.readUInt32LE(); // ixfe/style
+    var flags = reader.readUInt16LE();
+    var hidden = (flags & 0x01) !== 0;
+    var customWidth = (flags & 0x02) !== 0;
+    var widthChars = coldx / 256;
+    var size = excelColumnWidthToPixels(widthChars);
+    return { startCol: startCol, endCol: endCol, hidden: hidden, customWidth: customWidth, size: size };
+};
+var parseBrtListPartRelId = function (payload) {
+    var reader = new Reader(payload);
+    return reader.readXLNullableWideString();
+};
+var parseBrtFont = function (payload) {
+    var reader = new Reader(payload);
+    var size = reader.readUInt16LE() / 20;
+    var flags = reader.readUInt8();
+    reader.readUInt8(); // reserved
+    reader.readUInt16LE(); // bold weight
+    reader.readUInt16LE(); // script style
+    var underline = reader.readUInt8();
+    reader.readUInt8(); // family
+    reader.readUInt8(); // charset
+    reader.readUInt8(); // reserved
+    var color = parseBrtColor(reader);
+    reader.readUInt8(); // scheme
+    var name = reader.readXLWideString();
+    return __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (name ? { name: name } : {})), (Number.isFinite(size) ? { size: size } : {})), (flags & 0x01 ? { bold: true } : {})), (flags & 0x02 ? { italic: true } : {})), (flags & 0x08 ? { strikethrough: true } : {})), (underline !== 0 ? { underline: true } : {})), (color ? { color: color } : {}));
+};
+var XLSB_BORDER_STYLE_MAP = {
+    1: { style: "solid", width: 1 },
+    2: { style: "solid_medium", width: 2 },
+    3: { style: "dashed", width: 1 },
+    4: { style: "dotted", width: 1 },
+    5: { style: "solid_thick", width: 3 },
+    6: { style: "double", width: 2 },
+    7: { style: "thin", width: 1 },
+    8: { style: "dashed", width: 2 },
+    9: { style: "dashed", width: 1 },
+    10: { style: "dashed", width: 2 },
+    11: { style: "dotted", width: 1 },
+    12: { style: "dotted", width: 2 },
+    13: { style: "dashed", width: 2 },
+};
+var parseBrtBorder = function (payload) {
+    if (payload.length < 41)
+        return {};
+    var reader = new Reader(payload);
+    reader.readUInt8(); // diagonal flags
+    var side = function () {
+        var styleId = reader.readUInt8();
+        reader.readUInt8(); // reserved
+        var color = parseBrtColor(reader);
+        var mapped = XLSB_BORDER_STYLE_MAP[styleId];
+        if (!mapped)
+            return undefined;
+        return __assign({ style: mapped.style, width: mapped.width }, (color ? { color: color } : {}));
+    };
+    var top = side();
+    var bottom = side();
+    var left = side();
+    var right = side();
+    side(); // diagonal, unused
+    return __assign(__assign(__assign(__assign({}, (top ? { top: top } : {})), (right ? { right: right } : {})), (bottom ? { bottom: bottom } : {})), (left ? { left: left } : {}));
+};
+var resolveXf = function (styles, xfIndex) {
+    var _a, _b, _c, _d, _e;
+    var xf = styles.cellXfs[xfIndex];
+    if (!xf)
+        return undefined;
+    var parent = styles.styleXfs[xf.parentId];
+    if (!parent)
+        return xf;
+    var inheritIndex = function (child, base) { return child !== null && child !== void 0 ? child : base; };
+    // Special handling for numFmtId: when child is 0 and parent has a non-zero format,
+    // inherit from parent. This handles cases where minimal XF records (without apply flags)
+    // use 0 to indicate "inherit from parent" rather than explicitly using format 0 (General).
+    var inheritNumFmtId = function (child, base) {
+        if (child === 0 && base !== 0) {
+            return base;
+        }
+        return child !== null && child !== void 0 ? child : base;
+    };
+    return {
+        parentId: xf.parentId,
+        numFmtId: inheritNumFmtId(xf.numFmtId, parent.numFmtId),
+        fontId: inheritIndex(xf.fontId, parent.fontId),
+        fillId: inheritIndex(xf.fillId, parent.fillId),
+        borderId: inheritIndex(xf.borderId, parent.borderId),
+        horizontalAlignment: (_a = xf.horizontalAlignment) !== null && _a !== void 0 ? _a : parent.horizontalAlignment,
+        verticalAlignment: (_b = xf.verticalAlignment) !== null && _b !== void 0 ? _b : parent.verticalAlignment,
+        wrapText: (_c = xf.wrapText) !== null && _c !== void 0 ? _c : parent.wrapText,
+        textRotation: (_d = xf.textRotation) !== null && _d !== void 0 ? _d : parent.textRotation,
+        indent: (_e = xf.indent) !== null && _e !== void 0 ? _e : parent.indent,
+    };
+};
+var toCellData = function (parsed, styles, sharedStrings, enableCellXfsRegistry, enableSharedStrings, cellXfs) {
+    var _a, _b, _c, _d, _e;
+    var xf = resolveXf(styles, parsed.styleRef);
+    var format = {};
+    var pattern = xf
+        ? (_a = styles.numberFormats.get(xf.numFmtId)) !== null && _a !== void 0 ? _a : standardExcelFormatCodeById.get(xf.numFmtId)
+        : undefined;
+    if (pattern) {
+        format.numberFormat = {
+            type: getNumberFormatType(pattern),
+            pattern: pattern,
+        };
+    }
+    if ((xf === null || xf === void 0 ? void 0 : xf.fillId) != null) {
+        var fill = styles.fills[xf.fillId];
+        if ((fill === null || fill === void 0 ? void 0 : fill.fgColor) && fill.patternType === "solid") {
+            format.backgroundColor = fill.fgColor;
+        }
+    }
+    if ((xf === null || xf === void 0 ? void 0 : xf.fontId) != null) {
+        var font = styles.fonts[xf.fontId];
+        if (font) {
+            var textFormat = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (font.name ? { fontFamily: font.name } : {})), (font.size != null ? { fontSize: font.size } : {})), (font.bold ? { bold: true } : {})), (font.italic ? { italic: true } : {})), (font.underline ? { underline: true } : {})), (font.strikethrough ? { strikethrough: true } : {})), (font.color ? { color: font.color } : {}));
+            if (Object.keys(textFormat).length > 0) {
+                format.textFormat = textFormat;
+            }
+        }
+    }
+    if ((xf === null || xf === void 0 ? void 0 : xf.borderId) != null) {
+        var border = styles.borders[xf.borderId];
+        if (border && Object.keys(border).length > 0) {
+            format.borders = border;
+        }
+    }
+    // Apply alignment properties
+    // Only set valid alignment values (left, right, center for horizontal; top, middle, bottom for vertical)
+    if (xf === null || xf === void 0 ? void 0 : xf.horizontalAlignment) {
+        var validHorizontal = ["left", "right", "center"];
+        if (validHorizontal.includes(xf.horizontalAlignment)) {
+            format.horizontalAlignment = xf.horizontalAlignment;
+        }
+    }
+    if (xf === null || xf === void 0 ? void 0 : xf.verticalAlignment) {
+        var validVertical = ["top", "middle", "bottom"];
+        if (validVertical.includes(xf.verticalAlignment)) {
+            format.verticalAlignment = xf.verticalAlignment;
+        }
+    }
+    if (xf === null || xf === void 0 ? void 0 : xf.wrapText) {
+        format.wrapStrategy = "wrap";
+    }
+    if ((xf === null || xf === void 0 ? void 0 : xf.textRotation) !== undefined) {
+        format.textRotation = xf.textRotation;
+    }
+    if ((xf === null || xf === void 0 ? void 0 : xf.indent) !== undefined && xf.indent > 0) {
+        format.indent = xf.indent;
+    }
+    var hasFormat = Object.keys(format).length > 0;
+    var style = enableCellXfsRegistry && hasFormat
+        ? { sid: "xlsb:".concat(parsed.styleRef) }
+        : undefined;
+    if (style && !cellXfs.has(style.sid)) {
+        cellXfs.set(style.sid, format);
+    }
+    if (parsed.kind === "s") {
+        var idx = (_b = parsed.sharedStringIndex) !== null && _b !== void 0 ? _b : Number(parsed.value);
+        var text = (_c = sharedStrings[idx]) !== null && _c !== void 0 ? _c : "";
+        if (enableSharedStrings) {
+            return __assign(__assign({}, (style
+                ? { ef: style, uf: style }
+                : hasFormat
+                    ? { ef: format, uf: format }
+                    : {})), { ss: String(idx) });
+        }
+        return __assign(__assign({}, (style
+            ? { ef: style, uf: style }
+            : hasFormat
+                ? { ef: format, uf: format }
+                : {})), { ue: { sv: text }, ev: { sv: text }, fv: text });
+    }
+    if (parsed.kind === "str") {
+        var text = String(parsed.value);
+        // If there's a formula, use it in ue.fv, otherwise use the text value
+        var ue = parsed.formula ? { fv: "=".concat(parsed.formula) } : { sv: text };
+        return __assign(__assign(__assign({}, (style
+            ? { ef: style, uf: style }
+            : hasFormat
+                ? { ef: format, uf: format }
+                : {})), { ue: ue, ev: { sv: text } }), (parsed.formula ? {} : { fv: text }));
+    }
+    if (parsed.kind === "n") {
+        var value = Number(parsed.value);
+        var pattern_1 = (_e = (_d = format.numberFormat) === null || _d === void 0 ? void 0 : _d.pattern) !== null && _e !== void 0 ? _e : "GENERAL";
+        var fv = ssfFormat(pattern_1, value);
+        // If there's a formula, use it in ue.fv, otherwise use the numeric value
+        var ue = parsed.formula ? { fv: "=".concat(parsed.formula) } : { nv: value };
+        return __assign(__assign(__assign({}, (style
+            ? { ef: style, uf: style }
+            : hasFormat
+                ? { ef: format, uf: format }
+                : {})), { ue: ue, ev: { nv: value } }), (parsed.formula ? {} : { fv: fv }));
+    }
+    if (parsed.kind === "b") {
+        var value = Boolean(parsed.value);
+        // If there's a formula, use it in ue.fv, otherwise use the boolean value
+        var ue = parsed.formula ? { fv: "=".concat(parsed.formula) } : { bv: value };
+        return __assign(__assign(__assign({}, (style
+            ? { ef: style, uf: style }
+            : hasFormat
+                ? { ef: format, uf: format }
+                : {})), { ue: ue, ev: { bv: value } }), (parsed.formula ? {} : { fv: value ? "TRUE" : "FALSE" }));
+    }
+    if (parsed.kind === "e") {
+        // Error value
+        var errorCodes = {
+            0x00: "#NULL!",
+            0x07: "#DIV/0!",
+            0x0f: "#VALUE!",
+            0x17: "#REF!",
+            0x1d: "#NAME?",
+            0x24: "#NUM!",
+            0x2a: "#N/A",
+            0x2b: "#GETTING_DATA",
+        };
+        var code = errorCodes[Number(parsed.value)] || "#VALUE!";
+        var errorExtendedValue = {
+            ev: { type: "Error", name: code, message: code },
+        };
+        // If there's a formula, use it in ue.fv. Errors get a typed
+        // `ev.ev` (not `sv`) so formula propagation treats them as errors.
+        var ue = parsed.formula
+            ? { fv: "=".concat(parsed.formula) }
+            : errorExtendedValue;
+        return __assign(__assign(__assign({}, (style
+            ? { ef: style, uf: style }
+            : hasFormat
+                ? { ef: format, uf: format }
+                : {})), { ue: ue, ev: errorExtendedValue }), (parsed.formula ? {} : { fv: code }));
+    }
+    if (parsed.kind === "blank") {
+        if (!hasFormat && !style)
+            return null;
+        return __assign({}, (style
+            ? { ef: style, uf: style }
+            : hasFormat
+                ? { ef: format, uf: format }
+                : {}));
+    }
+    return __assign(__assign({}, (style
+        ? { ef: style, uf: style }
+        : hasFormat
+            ? { ef: format, uf: format }
+            : {})), { ue: { sv: "#VALUE!" }, ev: { sv: "#VALUE!" }, fv: "#VALUE!" });
+};
+var isCellRecord = function (type) {
+    return type === RT.BrtCellBlank ||
+        type === RT.BrtCellRk ||
+        type === RT.BrtCellError ||
+        type === RT.BrtCellBool ||
+        type === RT.BrtCellReal ||
+        type === RT.BrtCellSt ||
+        type === RT.BrtCellIsst ||
+        type === RT.BrtFmlaString ||
+        type === RT.BrtFmlaNum ||
+        type === RT.BrtFmlaBool ||
+        type === RT.BrtFmlaError ||
+        type === RT.BrtShortBlank ||
+        type === RT.BrtShortRk ||
+        type === RT.BrtShortError ||
+        type === RT.BrtShortBool ||
+        type === RT.BrtShortReal ||
+        type === RT.BrtShortSt ||
+        type === RT.BrtShortIsst;
+};
+var XlsbPlugin = /** @class */ (function (_super) {
+    __extends(XlsbPlugin, _super);
+    function XlsbPlugin() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.zipParser = new StreamingZipParser();
+        _this.xmlParser = new XMLParser({
+            ignoreAttributes: false,
+            attributesGroupName: "a$",
+            attributeNamePrefix: "",
+            textNodeName: "t$",
+            trimValues: false,
+            ignoreDeclaration: true,
+        });
+        _this.sheets = [];
+        _this.sharedStrings = [];
+        _this.sharedFormulaMap = new Map();
+        _this.cellXfs = new Map();
+        _this.styles = {
+            numberFormats: new Map(standardExcelFormatCodeById),
+            styleXfs: [],
+            cellXfs: [],
+            fills: [],
+            fonts: [],
+            borders: [],
+        };
+        _this.theme = defaultSpreadsheetTheme;
+        _this.namedRanges = [];
+        _this.calcProp = {};
+        _this.supportingLinks = [];
+        _this.externSheetRefs = [];
+        _this.use1904 = false;
+        return _this;
+    }
+    XlsbPlugin.prototype.load = function (buffer, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var workbookBinary, records, workbookRels, sheets, namedRanges, supportingLinks, externSheetRefs, records_1, records_1_1, record, payload, parsed, relTarget, path, parsed, namedRange, parsed, _a, _b, _c, _d, _e, sheet, stats, e_5_1;
+            var e_6, _f, e_5, _g;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0: return [4 /*yield*/, this.zipParser.load(buffer, password)];
+                    case 1:
+                        _h.sent();
+                        if (!this.zipParser.has("xl/workbook.bin")) {
+                            throw new Error("Invalid XLSB file: xl/workbook.bin not found");
+                        }
+                        // Initialize shared formula map
+                        if (!this.sharedFormulaMap) {
+                            this.sharedFormulaMap = new Map();
+                        }
+                        this.sharedFormulaMap.clear();
+                        return [4 /*yield*/, this.zipParser.getBinary("xl/workbook.bin")];
+                    case 2:
+                        workbookBinary = _h.sent();
+                        records = readAllRecordHeaders(workbookBinary);
+                        return [4 /*yield*/, this.loadWorkbookRelationships()];
+                    case 3:
+                        workbookRels = _h.sent();
+                        sheets = [];
+                        namedRanges = [];
+                        supportingLinks = [];
+                        externSheetRefs = [];
+                        try {
+                            for (records_1 = __values(records), records_1_1 = records_1.next(); !records_1_1.done; records_1_1 = records_1.next()) {
+                                record = records_1_1.value;
+                                payload = workbookBinary.subarray(record.dataOffset, record.nextOffset);
+                                if (record.type === RT.BrtBundleSh) {
+                                    parsed = parseBundleSheet(payload);
+                                    // Skip veryHidden sheets (hidden === 2) - these are internal sheets not meant for users
+                                    if (parsed.hidden === 2) {
+                                        continue;
+                                    }
+                                    relTarget = workbookRels.get(parsed.rid);
+                                    path = relTarget
+                                        ? resolveRelativePath("xl/workbook.bin", relTarget)
+                                        : undefined;
+                                    sheets.push({
+                                        sheetId: parsed.tabId || sheets.length + 1,
+                                        title: parsed.title || "Sheet".concat(sheets.length + 1),
+                                        hidden: parsed.hidden === 1,
+                                        rid: parsed.rid,
+                                        path: path,
+                                        rowCount: 0,
+                                        columnCount: 0,
+                                        tablePartRelIds: [],
+                                        merges: [],
+                                        rowMetadata: [],
+                                        columnMetadata: [],
+                                    });
+                                }
+                                else if (record.type === RT.BrtSupSelf) {
+                                    supportingLinks.push("self");
+                                }
+                                else if (record.type === RT.BrtSupSame) {
+                                    supportingLinks.push("same");
+                                }
+                                else if (record.type === RT.BrtSupBookSrc) {
+                                    supportingLinks.push("external");
+                                }
+                                else if (record.type === RT.BrtExternSheet) {
+                                    parsed = parseBrtExternSheet(payload);
+                                    if (parsed.length > 0) {
+                                        externSheetRefs = parsed;
+                                    }
+                                }
+                                else if (record.type === RT.BrtName) {
+                                    namedRange = this.parseBrtName(payload, sheets);
+                                    if (namedRange) {
+                                        namedRanges.push(namedRange);
+                                    }
+                                }
+                                else if (record.type === RT.BrtCalcProp) {
+                                    this.parseBrtCalcProp(payload);
+                                }
+                                else if (record.type === RT.BrtWbProp) {
+                                    parsed = parseBrtWbPropPayload(payload);
+                                    if (parsed) {
+                                        this.use1904 = parsed.use1904;
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                        finally {
+                            try {
+                                if (records_1_1 && !records_1_1.done && (_f = records_1.return)) _f.call(records_1);
+                            }
+                            finally { if (e_6) throw e_6.error; }
+                        }
+                        this.namedRanges = namedRanges;
+                        this.supportingLinks = supportingLinks;
+                        this.externSheetRefs = externSheetRefs;
+                        this.sheets = sheets;
+                        _a = this;
+                        return [4 /*yield*/, this.loadSharedStrings()];
+                    case 4:
+                        _a.sharedStrings = _h.sent();
+                        _b = this;
+                        return [4 /*yield*/, this.loadStyles()];
+                    case 5:
+                        _b.styles = _h.sent();
+                        _c = this;
+                        return [4 /*yield*/, this.loadTheme()];
+                    case 6:
+                        _c.theme = _h.sent();
+                        _h.label = 7;
+                    case 7:
+                        _h.trys.push([7, 12, 13, 14]);
+                        _d = __values(this.sheets), _e = _d.next();
+                        _h.label = 8;
+                    case 8:
+                        if (!!_e.done) return [3 /*break*/, 11];
+                        sheet = _e.value;
+                        if (!sheet.path || !this.zipParser.has(sheet.path))
+                            return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.scanSheetStats(sheet.path)];
+                    case 9:
+                        stats = _h.sent();
+                        sheet.rowCount = stats.rowCount;
+                        sheet.columnCount = stats.columnCount;
+                        sheet.merges = stats.merges;
+                        sheet.rowMetadata = stats.rowMetadata;
+                        sheet.columnMetadata = stats.columnMetadata;
+                        sheet.showGridLines = stats.showGridLines;
+                        sheet.frozenRowCount = stats.frozenRowCount;
+                        sheet.frozenColumnCount = stats.frozenColumnCount;
+                        sheet.basicFilterRange = stats.basicFilterRange;
+                        sheet.tablePartRelIds = stats.tablePartRelIds;
+                        _h.label = 10;
+                    case 10:
+                        _e = _d.next();
+                        return [3 /*break*/, 8];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
+                        e_5_1 = _h.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.dispose = function () {
+        void this.zipParser.dispose();
+    };
+    XlsbPlugin.prototype.loadWorkbookRelationships = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var relsPath, relMap, relText, rels, relations, list, list_1, list_1_1, rel, id, target;
+            var e_7, _a;
+            var _b, _c, _d, _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        relsPath = "xl/_rels/workbook.bin.rels";
+                        relMap = new Map();
+                        if (!this.zipParser.has(relsPath)) {
+                            return [2 /*return*/, relMap];
+                        }
+                        return [4 /*yield*/, this.zipParser.getText(relsPath)];
+                    case 1:
+                        relText = _g.sent();
+                        rels = this.xmlParser.parse(relText);
+                        relations = (_b = get(rels, "Relationships.Relationship")) !== null && _b !== void 0 ? _b : [];
+                        list = Array.isArray(relations) ? relations : [relations];
+                        try {
+                            for (list_1 = __values(list), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
+                                rel = list_1_1.value;
+                                id = (_d = (_c = rel === null || rel === void 0 ? void 0 : rel.a$) === null || _c === void 0 ? void 0 : _c.Id) !== null && _d !== void 0 ? _d : rel === null || rel === void 0 ? void 0 : rel.Id;
+                                target = (_f = (_e = rel === null || rel === void 0 ? void 0 : rel.a$) === null || _e === void 0 ? void 0 : _e.Target) !== null && _f !== void 0 ? _f : rel === null || rel === void 0 ? void 0 : rel.Target;
+                                if (typeof id === "string" && typeof target === "string") {
+                                    relMap.set(id, target);
+                                }
+                            }
+                        }
+                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                        finally {
+                            try {
+                                if (list_1_1 && !list_1_1.done && (_a = list_1.return)) _a.call(list_1);
+                            }
+                            finally { if (e_7) throw e_7.error; }
+                        }
+                        return [2 /*return*/, relMap];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.loadSharedStrings = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var path, binary, records, result, records_2, records_2_1, record, payload, reader;
+            var e_8, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        path = "xl/sharedStrings.bin";
+                        if (!this.zipParser.has(path))
+                            return [2 /*return*/, []];
+                        return [4 /*yield*/, this.zipParser.getBinary(path)];
+                    case 1:
+                        binary = _b.sent();
+                        records = readAllRecordHeaders(binary);
+                        result = [];
+                        try {
+                            for (records_2 = __values(records), records_2_1 = records_2.next(); !records_2_1.done; records_2_1 = records_2.next()) {
+                                record = records_2_1.value;
+                                if (record.type !== RT.BrtSSTItem)
+                                    continue;
+                                payload = binary.subarray(record.dataOffset, record.nextOffset);
+                                reader = new Reader(payload);
+                                reader.readUInt8(); // flags
+                                result.push(reader.readXLWideString());
+                            }
+                        }
+                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                        finally {
+                            try {
+                                if (records_2_1 && !records_2_1.done && (_a = records_2.return)) _a.call(records_2);
+                            }
+                            finally { if (e_8) throw e_8.error; }
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.loadStyles = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var path, styles, binary, records, inCellXfs, inStyleXfs, inFonts, inFills, inBorders, inFmts, records_3, records_3_1, record, payload, _a, id, formatCode;
+            var e_9, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        path = "xl/styles.bin";
+                        styles = {
+                            numberFormats: new Map(standardExcelFormatCodeById),
+                            styleXfs: [],
+                            cellXfs: [],
+                            fills: [],
+                            fonts: [],
+                            borders: [],
+                        };
+                        if (!this.zipParser.has(path))
+                            return [2 /*return*/, styles];
+                        return [4 /*yield*/, this.zipParser.getBinary(path)];
+                    case 1:
+                        binary = _c.sent();
+                        records = readAllRecordHeaders(binary);
+                        inCellXfs = false;
+                        inStyleXfs = false;
+                        inFonts = false;
+                        inFills = false;
+                        inBorders = false;
+                        inFmts = false;
+                        try {
+                            for (records_3 = __values(records), records_3_1 = records_3.next(); !records_3_1.done; records_3_1 = records_3.next()) {
+                                record = records_3_1.value;
+                                payload = binary.subarray(record.dataOffset, record.nextOffset);
+                                if (record.type === RT.BrtBeginFonts) {
+                                    inFonts = true;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtEndFonts) {
+                                    inFonts = false;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtBeginFills) {
+                                    inFills = true;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtEndFills) {
+                                    inFills = false;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtBeginBorders) {
+                                    inBorders = true;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtEndBorders) {
+                                    inBorders = false;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtBeginFmts) {
+                                    inFmts = true;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtEndFmts) {
+                                    inFmts = false;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtBeginCellXFs) {
+                                    inCellXfs = true;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtEndCellXFs) {
+                                    inCellXfs = false;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtBeginCellStyleXFs) {
+                                    inStyleXfs = true;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtEndCellStyleXFs) {
+                                    inStyleXfs = false;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtFmt && inFmts) {
+                                    _a = parseBrtFmt(payload), id = _a.id, formatCode = _a.formatCode;
+                                    styles.numberFormats.set(id, formatCode);
+                                    continue;
+                                }
+                                if (record.type === RT.BrtFont && inFonts) {
+                                    styles.fonts.push(parseBrtFont(payload));
+                                    continue;
+                                }
+                                if (record.type === RT.BrtFill && inFills) {
+                                    styles.fills.push(parseBrtFill(payload));
+                                    continue;
+                                }
+                                if (record.type === RT.BrtBorder && inBorders) {
+                                    styles.borders.push(parseBrtBorder(payload));
+                                    continue;
+                                }
+                                if (record.type === RT.BrtXF && inStyleXfs) {
+                                    styles.styleXfs.push(parseBrtXf(payload));
+                                    continue;
+                                }
+                                if (record.type === RT.BrtXF && inCellXfs) {
+                                    styles.cellXfs.push(parseBrtXf(payload));
+                                }
+                            }
+                        }
+                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                        finally {
+                            try {
+                                if (records_3_1 && !records_3_1.done && (_b = records_3.return)) _b.call(records_3);
+                            }
+                            finally { if (e_9) throw e_9.error; }
+                        }
+                        return [2 /*return*/, styles];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.loadTheme = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var themeContent, themeXml, themeName, _a, primaryFontFamily, headingFontFamily, themeColors, darkThemeColors, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 2, , 3]);
+                        if (!this.zipParser.has("xl/theme/theme1.xml")) {
+                            return [2 /*return*/, defaultSpreadsheetTheme];
+                        }
+                        return [4 /*yield*/, this.zipParser.getText("xl/theme/theme1.xml")];
+                    case 1:
+                        themeContent = _c.sent();
+                        themeXml = this.xmlParser.parse(themeContent);
+                        themeName = get(themeXml, "a:theme.a$.name") || "Office";
+                        _a = extractThemeFonts(themeXml), primaryFontFamily = _a.primaryFontFamily, headingFontFamily = _a.headingFontFamily;
+                        themeColors = extractThemeColors(themeXml, defaultSpreadsheetTheme);
+                        darkThemeColors = generateDarkThemeColors(themeColors);
+                        return [2 /*return*/, {
+                                name: themeName,
+                                primaryFontFamily: primaryFontFamily,
+                                headingFontFamily: headingFontFamily,
+                                themeColors: themeColors,
+                                darkThemeColors: darkThemeColors,
+                            }];
+                    case 2:
+                        _b = _c.sent();
+                        return [2 /*return*/, defaultSpreadsheetTheme];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.getTheme = function () {
+        var _a;
+        return (_a = this.theme) !== null && _a !== void 0 ? _a : defaultSpreadsheetTheme;
+    };
+    XlsbPlugin.prototype.parseRelIdFromPayload = function (payload) {
+        var reader = new Reader(payload);
+        var relId = reader.readXLNullableWideString();
+        return relId || undefined;
+    };
+    XlsbPlugin.prototype.loadRelationshipsForPart = function (basePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var base, name, dir, relsPath, relText, rels, relations, list, out, list_2, list_2_1, rel, id, target;
+            var e_10, _a;
+            var _b, _c, _d, _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        base = normalizePath(basePath);
+                        name = base.split("/").pop();
+                        if (!name)
+                            return [2 /*return*/, new Map()];
+                        dir = base.substring(0, base.lastIndexOf("/"));
+                        relsPath = "".concat(dir, "/_rels/").concat(name, ".rels");
+                        if (!this.zipParser.has(relsPath))
+                            return [2 /*return*/, new Map()];
+                        return [4 /*yield*/, this.zipParser.getText(relsPath)];
+                    case 1:
+                        relText = _g.sent();
+                        rels = this.xmlParser.parse(relText);
+                        relations = (_b = get(rels, "Relationships.Relationship")) !== null && _b !== void 0 ? _b : [];
+                        list = Array.isArray(relations) ? relations : [relations];
+                        out = new Map();
+                        try {
+                            for (list_2 = __values(list), list_2_1 = list_2.next(); !list_2_1.done; list_2_1 = list_2.next()) {
+                                rel = list_2_1.value;
+                                id = (_d = (_c = rel === null || rel === void 0 ? void 0 : rel.a$) === null || _c === void 0 ? void 0 : _c.Id) !== null && _d !== void 0 ? _d : rel === null || rel === void 0 ? void 0 : rel.Id;
+                                target = (_f = (_e = rel === null || rel === void 0 ? void 0 : rel.a$) === null || _e === void 0 ? void 0 : _e.Target) !== null && _f !== void 0 ? _f : rel === null || rel === void 0 ? void 0 : rel.Target;
+                                if (typeof id === "string" && typeof target === "string") {
+                                    out.set(id, target);
+                                }
+                            }
+                        }
+                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                        finally {
+                            try {
+                                if (list_2_1 && !list_2_1.done && (_a = list_2.return)) _a.call(list_2);
+                            }
+                            finally { if (e_10) throw e_10.error; }
+                        }
+                        return [2 /*return*/, out];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.getDrawingPathsForSheet = function (sheet) {
+        return __awaiter(this, void 0, void 0, function () {
+            var binary, records, relIds, records_4, records_4_1, record, payload, relId, relMap, paths, relIds_1, relIds_1_1, relId, target;
+            var e_11, _a, e_12, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!sheet.path || !this.zipParser.has(sheet.path))
+                            return [2 /*return*/, []];
+                        return [4 /*yield*/, this.zipParser.getBinary(sheet.path)];
+                    case 1:
+                        binary = _c.sent();
+                        records = readAllRecordHeaders(binary);
+                        relIds = [];
+                        try {
+                            for (records_4 = __values(records), records_4_1 = records_4.next(); !records_4_1.done; records_4_1 = records_4.next()) {
+                                record = records_4_1.value;
+                                if (record.type !== RT.BrtDrawing)
+                                    continue;
+                                payload = binary.subarray(record.dataOffset, record.nextOffset);
+                                relId = this.parseRelIdFromPayload(payload);
+                                if (relId)
+                                    relIds.push(relId);
+                            }
+                        }
+                        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                        finally {
+                            try {
+                                if (records_4_1 && !records_4_1.done && (_a = records_4.return)) _a.call(records_4);
+                            }
+                            finally { if (e_11) throw e_11.error; }
+                        }
+                        if (relIds.length === 0)
+                            return [2 /*return*/, []];
+                        return [4 /*yield*/, this.loadRelationshipsForPart(sheet.path)];
+                    case 2:
+                        relMap = _c.sent();
+                        paths = [];
+                        try {
+                            for (relIds_1 = __values(relIds), relIds_1_1 = relIds_1.next(); !relIds_1_1.done; relIds_1_1 = relIds_1.next()) {
+                                relId = relIds_1_1.value;
+                                target = relMap.get(relId);
+                                if (!target)
+                                    continue;
+                                paths.push(resolveRelativePath(sheet.path, target));
+                            }
+                        }
+                        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                        finally {
+                            try {
+                                if (relIds_1_1 && !relIds_1_1.done && (_b = relIds_1.return)) _b.call(relIds_1);
+                            }
+                            finally { if (e_12) throw e_12.error; }
+                        }
+                        return [2 /*return*/, Array.from(new Set(paths))];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.getTablesFromSheet = function (sheet) {
+        return __awaiter(this, void 0, void 0, function () {
+            var relMap, tables, _a, _b, tableRelId, target, tablePath, tableContent, tableData, tableDefinition, attrs, range, columnDefinitions, columnDefsArray, columns, autoFilter, filterSpecs, tableStyle, tableStyleAttrs, tableView, e_13_1;
+            var e_13, _c;
+            var _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (!sheet.path || !sheet.tablePartRelIds.length)
+                            return [2 /*return*/, []];
+                        return [4 /*yield*/, this.loadRelationshipsForPart(sheet.path)];
+                    case 1:
+                        relMap = _e.sent();
+                        tables = [];
+                        _e.label = 2;
+                    case 2:
+                        _e.trys.push([2, 7, 8, 9]);
+                        _a = __values(sheet.tablePartRelIds), _b = _a.next();
+                        _e.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        tableRelId = _b.value;
+                        target = relMap.get(tableRelId);
+                        if (!target)
+                            return [3 /*break*/, 5];
+                        tablePath = resolveRelativePath(sheet.path, target);
+                        if (!this.zipParser.has(tablePath))
+                            return [3 /*break*/, 5];
+                        // XLSB workbooks written by Excel store table parts as BIFF12
+                        // binaries (xl/tables/tableN.bin) — those need a binary parser and
+                        // must not be fed to the XML parser. Only XML table parts (produced
+                        // by some third-party writers) are handled here; anything else is
+                        // skipped so one table part can never fail the whole import.
+                        if (tablePath.endsWith(".bin"))
+                            return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.zipParser.getText(tablePath)];
+                    case 4:
+                        tableContent = _e.sent();
+                        tableData = void 0;
+                        try {
+                            tableData = this.xmlParser.parse(tableContent || "");
+                        }
+                        catch (_f) {
+                            return [3 /*break*/, 5];
+                        }
+                        tableDefinition = get(tableData, "table") || get(tableData, "x:table");
+                        if (!tableDefinition)
+                            return [3 /*break*/, 5];
+                        attrs = tableDefinition.a$ || {};
+                        range = getRangeFromAddressRef(attrs.ref);
+                        if (!range)
+                            return [3 /*break*/, 5];
+                        columnDefinitions = get(tableDefinition, "tableColumns.tableColumn") ||
+                            get(tableDefinition, "x:tableColumns.x:tableColumn");
+                        columnDefsArray = Array.isArray(columnDefinitions)
+                            ? columnDefinitions
+                            : columnDefinitions
+                                ? [columnDefinitions]
+                                : [];
+                        columns = columnDefsArray.map(function (colDef) {
+                            var _a;
+                            var name = ((_a = colDef === null || colDef === void 0 ? void 0 : colDef.a$) === null || _a === void 0 ? void 0 : _a.name) || "";
+                            var calculatedColumnFormula = get(colDef, "calculatedColumnFormula") ||
+                                get(colDef, "x:calculatedColumnFormula");
+                            if (calculatedColumnFormula) {
+                                return { name: name, formula: calculatedColumnFormula };
+                            }
+                            return { name: name };
+                        });
+                        autoFilter = (_d = tableDefinition.autoFilter) !== null && _d !== void 0 ? _d : tableDefinition["x:autoFilter"];
+                        filterSpecs = createFilterSpecsFromAutoFilter(autoFilter);
+                        tableStyle = get(tableDefinition, "tableStyleInfo") ||
+                            get(tableDefinition, "x:tableStyleInfo") ||
+                            {};
+                        tableStyleAttrs = tableStyle.a$ || {};
+                        tableView = {
+                            id: attrs.id || uuid(),
+                            title: attrs.name || attrs.displayName || "Table_".concat(tables.length + 1),
+                            sheetId: sheet.sheetId,
+                            headerRow: attrs.headerRowCount !== "0",
+                            totalRow: attrs.totalsRowCount === "1",
+                            showRowStripes: attrs.showRowStripes !== "0",
+                            showColumnStripes: attrs.showColumnStripes === "1",
+                            showFirstColumn: attrs.showFirstColumn === "1",
+                            showLastColumn: attrs.showLastColumn === "1",
+                            filterButton: attrs.filterButton !== "0",
+                            columns: columns,
+                            range: range,
+                            filterSpecs: filterSpecs,
+                        };
+                        if (tableStyleAttrs.name) {
+                            tableView.theme = tableStyleAttrs.name;
+                        }
+                        tables.push(tableView);
+                        _e.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_13_1 = _e.sent();
+                        e_13 = { error: e_13_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_13) throw e_13.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/, tables];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.scanSheetStats = function (path) {
+        return __awaiter(this, void 0, void 0, function () {
+            var binary, records, currentRow, maxRow, maxCol, prevCol, merges, rowMetadata, columnMetadata, showGridLines, frozenRowCount, frozenColumnCount, basicFilterRange, tablePartRelIds, records_5, records_5_1, record, payload, view, pane, relId, parsedRow, parsedCol, col, dimensionProps, merge, parsed;
+            var e_14, _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.zipParser.getBinary(path)];
+                    case 1:
+                        binary = _b.sent();
+                        records = readAllRecordHeaders(binary);
+                        currentRow = 0;
+                        maxRow = 0;
+                        maxCol = 0;
+                        prevCol = -1;
+                        merges = [];
+                        rowMetadata = [];
+                        columnMetadata = [];
+                        tablePartRelIds = [];
+                        try {
+                            for (records_5 = __values(records), records_5_1 = records_5.next(); !records_5_1.done; records_5_1 = records_5.next()) {
+                                record = records_5_1.value;
+                                payload = binary.subarray(record.dataOffset, record.nextOffset);
+                                if (record.type === RT.BrtWsView) {
+                                    view = parseWsView(payload);
+                                    showGridLines = view.showGridLines;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtPane) {
+                                    pane = parsePane(payload);
+                                    if (pane.frozenRowCount > 0)
+                                        frozenRowCount = pane.frozenRowCount;
+                                    if (pane.frozenColumnCount > 0)
+                                        frozenColumnCount = pane.frozenColumnCount;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtBeginAFilter) {
+                                    basicFilterRange = parseRange(payload);
+                                    continue;
+                                }
+                                if (record.type === RT.BrtListPart) {
+                                    relId = parseBrtListPartRelId(payload);
+                                    if (relId)
+                                        tablePartRelIds.push(relId);
+                                    continue;
+                                }
+                                if (record.type === RT.BrtRowHdr) {
+                                    parsedRow = parseRowHeader(payload);
+                                    currentRow = parsedRow.row;
+                                    prevCol = -1;
+                                    if (currentRow > maxRow)
+                                        maxRow = currentRow;
+                                    if (parsedRow.hidden || parsedRow.hpt != null) {
+                                        rowMetadata[currentRow] = __assign(__assign({}, (parsedRow.hidden ? { hiddenByUser: true } : {})), (parsedRow.hpt != null
+                                            ? {
+                                                size: Math.round((parsedRow.hpt * 96) / 72),
+                                                resizedByUser: true,
+                                            }
+                                            : {}));
+                                    }
+                                    continue;
+                                }
+                                if (record.type === RT.BrtColInfo) {
+                                    parsedCol = parseBrtColInfo(payload);
+                                    for (col = parsedCol.startCol; col <= parsedCol.endCol; col++) {
+                                        dimensionProps = {};
+                                        if (parsedCol.hidden)
+                                            dimensionProps.hiddenByUser = true;
+                                        if (parsedCol.size > 0) {
+                                            dimensionProps.size = parsedCol.size;
+                                            if (parsedCol.customWidth) {
+                                                dimensionProps.resizedByUser = true;
+                                            }
+                                        }
+                                        if (Object.keys(dimensionProps).length > 0) {
+                                            columnMetadata[col] = dimensionProps;
+                                        }
+                                    }
+                                    continue;
+                                }
+                                if (record.type === RT.BrtMergeCell) {
+                                    merge = parseMergeRange(payload);
+                                    merges.push(merge);
+                                    if (merge.endRowIndex > maxRow)
+                                        maxRow = merge.endRowIndex;
+                                    if (merge.endColumnIndex > maxCol)
+                                        maxCol = merge.endColumnIndex;
+                                    continue;
+                                }
+                                if (!isCellRecord(record.type))
+                                    continue;
+                                parsed = parseCellFromRecord(record.type, payload, currentRow, prevCol, function (ixti) { return _this.resolveSheetNameByXti(ixti); }, undefined, false);
+                                if (!parsed)
+                                    continue;
+                                prevCol = parsed.col - 1;
+                                if (parsed.row > maxRow)
+                                    maxRow = parsed.row;
+                                if (parsed.col > maxCol)
+                                    maxCol = parsed.col;
+                            }
+                        }
+                        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                        finally {
+                            try {
+                                if (records_5_1 && !records_5_1.done && (_a = records_5.return)) _a.call(records_5);
+                            }
+                            finally { if (e_14) throw e_14.error; }
+                        }
+                        return [2 /*return*/, {
+                                rowCount: maxRow,
+                                columnCount: maxCol,
+                                merges: merges,
+                                rowMetadata: rowMetadata,
+                                columnMetadata: columnMetadata,
+                                showGridLines: showGridLines,
+                                frozenRowCount: frozenRowCount,
+                                frozenColumnCount: frozenColumnCount,
+                                basicFilterRange: basicFilterRange,
+                                tablePartRelIds: tablePartRelIds,
+                            }];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.getSheetCount = function () {
+        return this.sheets.length;
+    };
+    XlsbPlugin.prototype.getSheetNames = function () {
+        return this.sheets.map(function (s) { return s.title; });
+    };
+    XlsbPlugin.prototype.resolveSheetNameByXti = function (ixti) {
+        var _a;
+        var sheetNames = this.getSheetNames();
+        var fallback = (_a = sheetNames[ixti]) !== null && _a !== void 0 ? _a : sheetNames[ixti - 1];
+        var xti = this.externSheetRefs[ixti];
+        if (!xti)
+            return fallback;
+        var linkType = this.supportingLinks[xti.iSupBook];
+        if (linkType !== "self" && linkType !== "same") {
+            return fallback;
+        }
+        var first = xti.itabFirst;
+        var last = xti.itabLast;
+        if (first < 0 || first >= sheetNames.length)
+            return fallback;
+        if (last < 0 || last >= sheetNames.length)
+            return sheetNames[first];
+        if (first === last)
+            return sheetNames[first];
+        return "".concat(sheetNames[first], ":").concat(sheetNames[last]);
+    };
+    XlsbPlugin.prototype.getSheets = function () {
+        return __awaiter(this, arguments, void 0, function (minRowCount, minColumnCount) {
+            var tables, sheets, _loop_1, this_1, _a, _b, sheet, e_15_1;
+            var e_15, _c;
+            var _d;
+            if (minRowCount === void 0) { minRowCount = 0; }
+            if (minColumnCount === void 0) { minColumnCount = 0; }
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        tables = [];
+                        sheets = [];
+                        _loop_1 = function (sheet) {
+                            var sheetTables, matchedFilterSpecs;
+                            return __generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0: return [4 /*yield*/, this_1.getTablesFromSheet(sheet)];
+                                    case 1:
+                                        sheetTables = _f.sent();
+                                        tables.push.apply(tables, __spreadArray([], __read(sheetTables), false));
+                                        matchedFilterSpecs = (_d = sheetTables.find(function (t) {
+                                            return sheet.basicFilterRange &&
+                                                t.range.startRowIndex === sheet.basicFilterRange.startRowIndex &&
+                                                t.range.endRowIndex === sheet.basicFilterRange.endRowIndex &&
+                                                t.range.startColumnIndex ===
+                                                    sheet.basicFilterRange.startColumnIndex &&
+                                                t.range.endColumnIndex === sheet.basicFilterRange.endColumnIndex;
+                                        })) === null || _d === void 0 ? void 0 : _d.filterSpecs;
+                                        sheets.push(__assign(__assign(__assign(__assign({ sheetId: sheet.sheetId, title: sheet.title, hidden: sheet.hidden, rowCount: Math.max(minRowCount, sheet.rowCount), columnCount: Math.max(minColumnCount, sheet.columnCount), rowMetadata: sheet.rowMetadata, columnMetadata: sheet.columnMetadata, merges: sheet.merges }, (sheet.showGridLines !== undefined
+                                            ? { showGridLines: sheet.showGridLines }
+                                            : {})), (sheet.frozenRowCount !== undefined && sheet.frozenRowCount > 0
+                                            ? { frozenRowCount: sheet.frozenRowCount }
+                                            : {})), (sheet.frozenColumnCount !== undefined && sheet.frozenColumnCount > 0
+                                            ? { frozenColumnCount: sheet.frozenColumnCount }
+                                            : {})), (sheet.basicFilterRange
+                                            ? {
+                                                basicFilter: {
+                                                    id: uuid(),
+                                                    range: sheet.basicFilterRange,
+                                                    filterSpecs: matchedFilterSpecs !== null && matchedFilterSpecs !== void 0 ? matchedFilterSpecs : [],
+                                                },
+                                            }
+                                            : {})));
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 6, 7, 8]);
+                        _a = __values(this.sheets), _b = _a.next();
+                        _e.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        sheet = _b.value;
+                        return [5 /*yield**/, _loop_1(sheet)];
+                    case 3:
+                        _e.sent();
+                        _e.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_15_1 = _e.sent();
+                        e_15 = { error: e_15_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_15) throw e_15.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, [sheets, tables]];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.getSharedStrings = function () {
+        return this.sharedStrings;
+    };
+    XlsbPlugin.prototype.getStyles = function () {
+        return this.styles;
+    };
+    XlsbPlugin.prototype.getFonts = function () {
+        var e_16, _a;
+        var out = new Set();
+        try {
+            for (var _b = __values(this.styles.fonts), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var font = _c.value;
+                if (font.name)
+                    out.add(font.name);
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+        return __spreadArray([], __read(out), false);
+    };
+    XlsbPlugin.prototype.getCellXfs = function () {
+        return this.cellXfs;
+    };
+    XlsbPlugin.prototype.registerFormat = function (format) {
+        var key = getCellXfsKey(format);
+        if (!this.cellXfs.has(key)) {
+            this.cellXfs.set(key, format);
+        }
+        return key;
+    };
+    XlsbPlugin.prototype.processSheetData = function () {
+        return __asyncGenerator(this, arguments, function processSheetData_1(chunkSize, enableCellXfsRegistry, enableSharedStrings) {
+            var totalSheets, _loop_2, this_2, index;
+            var _this = this;
+            var _a;
+            if (chunkSize === void 0) { chunkSize = 100; }
+            if (enableCellXfsRegistry === void 0) { enableCellXfsRegistry = false; }
+            if (enableSharedStrings === void 0) { enableSharedStrings = true; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        totalSheets = this.sheets.length;
+                        _loop_2 = function (index) {
+                            var sheet, binary, records, sharedFormulaBytes, sharedFormulaRanges, records_6, records_6_1, record, payload, parsedShared, currentRow, prevCol, rows, _loop_3, records_7, records_7_1, record, _c, _d, merge, topLeftRow, topLeftCell, sourceFormat, r, c, row, format, _e, borders, formatWithoutBorders, existingCell, _f, ef, uf, cellContent, sortedRows, chunkRows, chunkRowIndices, chunkIndex, startRowIndex, endRowIndex, sortedRows_1, sortedRows_1_1, _g, rowIndex, rowData, e_17_1;
+                            var e_18, _h, e_19, _j, e_20, _k, e_17, _l;
+                            return __generator(this, function (_m) {
+                                switch (_m.label) {
+                                    case 0:
+                                        sheet = this_2.sheets[index];
+                                        if (!sheet.path || !this_2.zipParser.has(sheet.path))
+                                            return [2 /*return*/, "continue"];
+                                        return [4 /*yield*/, __await(this_2.zipParser.getBinary(sheet.path))];
+                                    case 1:
+                                        binary = _m.sent();
+                                        records = readAllRecordHeaders(binary);
+                                        sharedFormulaBytes = new Map();
+                                        sharedFormulaRanges = [];
+                                        try {
+                                            // Pre-scan shared formulas so PtgExp can resolve even when BrtShrFmla
+                                            // appears later in the record stream.
+                                            for (records_6 = (e_18 = void 0, __values(records)), records_6_1 = records_6.next(); !records_6_1.done; records_6_1 = records_6.next()) {
+                                                record = records_6_1.value;
+                                                if (record.type !== RT.BrtShrFmla)
+                                                    continue;
+                                                payload = binary.subarray(record.dataOffset, record.nextOffset);
+                                                parsedShared = parseBrtShrFmla(payload);
+                                                if (!parsedShared)
+                                                    continue;
+                                                sharedFormulaBytes.set("".concat(parsedShared.startRow, ":").concat(parsedShared.startCol), parsedShared.rgceBytes);
+                                                sharedFormulaRanges.push(parsedShared);
+                                            }
+                                        }
+                                        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                                        finally {
+                                            try {
+                                                if (records_6_1 && !records_6_1.done && (_h = records_6.return)) _h.call(records_6);
+                                            }
+                                            finally { if (e_18) throw e_18.error; }
+                                        }
+                                        currentRow = 0;
+                                        prevCol = -1;
+                                        rows = new Map();
+                                        _loop_3 = function (record) {
+                                            var payload = binary.subarray(record.dataOffset, record.nextOffset);
+                                            if (record.type === RT.BrtShrFmla) {
+                                                return "continue";
+                                            }
+                                            if (record.type === RT.BrtRowHdr) {
+                                                var parsedRow = parseRowHeader(payload);
+                                                currentRow = parsedRow.row;
+                                                prevCol = -1;
+                                                if (!rows.has(currentRow)) {
+                                                    rows.set(currentRow, { values: [] });
+                                                }
+                                                return "continue";
+                                            }
+                                            if (!isCellRecord(record.type))
+                                                return "continue";
+                                            var parsed = parseCellFromRecord(record.type, payload, currentRow, prevCol, function (ixti) { return _this.resolveSheetNameByXti(ixti); }, function (sourceRow, sourceCol, targetRow, targetCol) {
+                                                var rgce = sharedFormulaBytes.get("".concat(sourceRow, ":").concat(sourceCol));
+                                                if (!rgce) {
+                                                    var sourceRange = sharedFormulaRanges.find(function (range) {
+                                                        return sourceRow >= range.startRow &&
+                                                            sourceRow <= range.endRow &&
+                                                            sourceCol >= range.startCol &&
+                                                            sourceCol <= range.endCol;
+                                                    });
+                                                    rgce = sourceRange === null || sourceRange === void 0 ? void 0 : sourceRange.rgceBytes;
+                                                }
+                                                if (!rgce)
+                                                    return undefined;
+                                                return parseRgce(rgce, function (ixti) { return _this.resolveSheetNameByXti(ixti); }, {
+                                                    row: targetRow,
+                                                    col: targetCol,
+                                                }, true); // Enable debug logging
+                                            });
+                                            if (!parsed)
+                                                return "continue";
+                                            if (!parsed.formula && sharedFormulaRanges.length > 0) {
+                                                var sharedRange = sharedFormulaRanges.find(function (range) {
+                                                    return parsed.row >= range.startRow &&
+                                                        parsed.row <= range.endRow &&
+                                                        parsed.col >= range.startCol &&
+                                                        parsed.col <= range.endCol;
+                                                });
+                                                if (sharedRange) {
+                                                    var resolved = parseRgce(sharedRange.rgceBytes, function (ixti) { return _this.resolveSheetNameByXti(ixti); }, { row: parsed.row, col: parsed.col }, true);
+                                                    if (resolved) {
+                                                        parsed.formula = resolved;
+                                                    }
+                                                }
+                                            }
+                                            prevCol = parsed.col - 1;
+                                            var row = rows.get(parsed.row);
+                                            if (!row) {
+                                                row = { values: [] };
+                                                rows.set(parsed.row, row);
+                                            }
+                                            row.values[parsed.col] = toCellData(parsed, this_2.styles, this_2.sharedStrings, enableCellXfsRegistry, enableSharedStrings, this_2.cellXfs);
+                                        };
+                                        try {
+                                            for (records_7 = (e_19 = void 0, __values(records)), records_7_1 = records_7.next(); !records_7_1.done; records_7_1 = records_7.next()) {
+                                                record = records_7_1.value;
+                                                _loop_3(record);
+                                            }
+                                        }
+                                        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+                                        finally {
+                                            try {
+                                                if (records_7_1 && !records_7_1.done && (_j = records_7.return)) _j.call(records_7);
+                                            }
+                                            finally { if (e_19) throw e_19.error; }
+                                        }
+                                        try {
+                                            // Apply merge cell formatting
+                                            // In Excel, merged cells should have formatting from the top-left (anchor) cell
+                                            // propagated to all cells in the merge range, but borders need special handling
+                                            for (_c = (e_20 = void 0, __values(sheet.merges)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                                merge = _d.value;
+                                                topLeftRow = rows.get(merge.startRowIndex);
+                                                topLeftCell = (_a = topLeftRow === null || topLeftRow === void 0 ? void 0 : topLeftRow.values) === null || _a === void 0 ? void 0 : _a[merge.startColumnIndex];
+                                                sourceFormat = (topLeftCell === null || topLeftCell === void 0 ? void 0 : topLeftCell.ef) || (topLeftCell === null || topLeftCell === void 0 ? void 0 : topLeftCell.uf);
+                                                // Process all cells in the merge range
+                                                // This ensures the merge structure exists even if there's no explicit formatting
+                                                for (r = merge.startRowIndex; r <= merge.endRowIndex; r++) {
+                                                    for (c = merge.startColumnIndex; c <= merge.endColumnIndex; c++) {
+                                                        // Skip the top-left cell as it already has its data/format
+                                                        if (r === merge.startRowIndex && c === merge.startColumnIndex) {
+                                                            continue;
+                                                        }
+                                                        row = rows.get(r);
+                                                        if (!row) {
+                                                            row = { values: [] };
+                                                            rows.set(r, row);
+                                                        }
+                                                        format = sourceFormat;
+                                                        if (format && typeof format === "object" && "borders" in format) {
+                                                            _e = format, borders = _e.borders, formatWithoutBorders = __rest(_e, ["borders"]);
+                                                            format =
+                                                                Object.keys(formatWithoutBorders).length > 0
+                                                                    ? formatWithoutBorders
+                                                                    : undefined;
+                                                        }
+                                                        existingCell = row.values[c];
+                                                        if (existingCell) {
+                                                            _f = existingCell, ef = _f.ef, uf = _f.uf, cellContent = __rest(_f, ["ef", "uf"]);
+                                                            if (format) {
+                                                                // Apply the format without borders
+                                                                row.values[c] = __assign(__assign({}, cellContent), { ef: format, uf: format });
+                                                            }
+                                                            else {
+                                                                // No format to apply, but remove any existing formatting to clear borders
+                                                                row.values[c] = cellContent;
+                                                            }
+                                                        }
+                                                        else {
+                                                            // Create a blank cell with format (if available) for proper merge rendering
+                                                            if (format) {
+                                                                row.values[c] = {
+                                                                    ef: format,
+                                                                    uf: format,
+                                                                };
+                                                            }
+                                                            else {
+                                                                // Create a blank cell even without format to preserve merge structure
+                                                                row.values[c] = {};
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                                        finally {
+                                            try {
+                                                if (_d && !_d.done && (_k = _c.return)) _k.call(_c);
+                                            }
+                                            finally { if (e_20) throw e_20.error; }
+                                        }
+                                        sortedRows = Array.from(rows.entries()).sort(function (a, b) { return a[0] - b[0]; });
+                                        chunkRows = [];
+                                        chunkRowIndices = [];
+                                        chunkIndex = 0;
+                                        startRowIndex = -1;
+                                        endRowIndex = -1;
+                                        _m.label = 2;
+                                    case 2:
+                                        _m.trys.push([2, 8, 9, 10]);
+                                        sortedRows_1 = (e_17 = void 0, __values(sortedRows)), sortedRows_1_1 = sortedRows_1.next();
+                                        _m.label = 3;
+                                    case 3:
+                                        if (!!sortedRows_1_1.done) return [3 /*break*/, 7];
+                                        _g = __read(sortedRows_1_1.value, 2), rowIndex = _g[0], rowData = _g[1];
+                                        if (chunkRows.length === 0) {
+                                            startRowIndex = rowIndex;
+                                        }
+                                        chunkRows.push(rowData);
+                                        chunkRowIndices.push(rowIndex);
+                                        endRowIndex = rowIndex;
+                                        if (!(chunkRows.length >= chunkSize)) return [3 /*break*/, 6];
+                                        return [4 /*yield*/, __await({
+                                                sheetId: sheet.sheetId,
+                                                title: sheet.title,
+                                                currentSheetIndex: index,
+                                                totalSheets: totalSheets,
+                                                chunkIndex: chunkIndex,
+                                                rows: chunkRows,
+                                                rowIndices: chunkRowIndices,
+                                                startRowIndex: startRowIndex,
+                                                endRowIndex: endRowIndex,
+                                                totalRows: sheet.rowCount,
+                                                isLastChunk: false,
+                                                cellXfs: this_2.cellXfs,
+                                            })];
+                                    case 4: return [4 /*yield*/, _m.sent()];
+                                    case 5:
+                                        _m.sent();
+                                        chunkRows = [];
+                                        chunkRowIndices = [];
+                                        chunkIndex += 1;
+                                        startRowIndex = -1;
+                                        endRowIndex = -1;
+                                        _m.label = 6;
+                                    case 6:
+                                        sortedRows_1_1 = sortedRows_1.next();
+                                        return [3 /*break*/, 3];
+                                    case 7: return [3 /*break*/, 10];
+                                    case 8:
+                                        e_17_1 = _m.sent();
+                                        e_17 = { error: e_17_1 };
+                                        return [3 /*break*/, 10];
+                                    case 9:
+                                        try {
+                                            if (sortedRows_1_1 && !sortedRows_1_1.done && (_l = sortedRows_1.return)) _l.call(sortedRows_1);
+                                        }
+                                        finally { if (e_17) throw e_17.error; }
+                                        return [7 /*endfinally*/];
+                                    case 10:
+                                        if (!chunkRows.length) return [3 /*break*/, 13];
+                                        return [4 /*yield*/, __await({
+                                                sheetId: sheet.sheetId,
+                                                title: sheet.title,
+                                                currentSheetIndex: index,
+                                                totalSheets: totalSheets,
+                                                chunkIndex: chunkIndex,
+                                                rows: chunkRows,
+                                                rowIndices: chunkRowIndices,
+                                                startRowIndex: startRowIndex,
+                                                endRowIndex: endRowIndex,
+                                                totalRows: sheet.rowCount,
+                                                isLastChunk: true,
+                                                cellXfs: this_2.cellXfs,
+                                            })];
+                                    case 11: return [4 /*yield*/, _m.sent()];
+                                    case 12:
+                                        _m.sent();
+                                        _m.label = 13;
+                                    case 13: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_2 = this;
+                        index = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(index < this.sheets.length)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_2(index)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        index++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.getDrawings = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var drawings, _a, _b, sheet, drawingPaths, drawingPaths_1, drawingPaths_1_1, drawingPath, drawingContent, drawingXml, oneCellAnchors, twoCellAnchors, absoluteAnchors, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, e_21_1, e_22_1;
+            var e_22, _q, e_21, _r;
+            return __generator(this, function (_s) {
+                switch (_s.label) {
+                    case 0:
+                        drawings = [];
+                        _s.label = 1;
+                    case 1:
+                        _s.trys.push([1, 18, 19, 20]);
+                        _a = __values(this.sheets), _b = _a.next();
+                        _s.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 17];
+                        sheet = _b.value;
+                        return [4 /*yield*/, this.getDrawingPathsForSheet(sheet)];
+                    case 3:
+                        drawingPaths = _s.sent();
+                        _s.label = 4;
+                    case 4:
+                        _s.trys.push([4, 14, 15, 16]);
+                        drawingPaths_1 = (e_21 = void 0, __values(drawingPaths)), drawingPaths_1_1 = drawingPaths_1.next();
+                        _s.label = 5;
+                    case 5:
+                        if (!!drawingPaths_1_1.done) return [3 /*break*/, 13];
+                        drawingPath = drawingPaths_1_1.value;
+                        if (!this.zipParser.has(drawingPath))
+                            return [3 /*break*/, 12];
+                        return [4 /*yield*/, this.zipParser.getText(drawingPath)];
+                    case 6:
+                        drawingContent = _s.sent();
+                        if (!drawingContent)
+                            return [3 /*break*/, 12];
+                        drawingXml = this.xmlParser.parse(drawingContent);
+                        oneCellAnchors = get(drawingXml, "xdr:wsDr.xdr:oneCellAnchor") ||
+                            get(drawingXml, "wsDr.oneCellAnchor");
+                        twoCellAnchors = get(drawingXml, "xdr:wsDr.xdr:twoCellAnchor") ||
+                            get(drawingXml, "wsDr.twoCellAnchor");
+                        absoluteAnchors = get(drawingXml, "xdr:wsDr.xdr:absoluteAnchor") ||
+                            get(drawingXml, "wsDr.absoluteAnchor");
+                        if (!oneCellAnchors) return [3 /*break*/, 8];
+                        _d = (_c = drawings.push).apply;
+                        _e = [drawings];
+                        _f = [[]];
+                        return [4 /*yield*/, processAnchors(oneCellAnchors, "oneCellAnchor", drawingPath, sheet.sheetId, this.zipParser, this.xmlParser)];
+                    case 7:
+                        _d.apply(_c, _e.concat([__spreadArray.apply(void 0, _f.concat([__read.apply(void 0, [(_s.sent())]), false]))]));
+                        _s.label = 8;
+                    case 8:
+                        if (!twoCellAnchors) return [3 /*break*/, 10];
+                        _h = (_g = drawings.push).apply;
+                        _j = [drawings];
+                        _k = [[]];
+                        return [4 /*yield*/, processAnchors(twoCellAnchors, "twoCellAnchors", drawingPath, sheet.sheetId, this.zipParser, this.xmlParser)];
+                    case 9:
+                        _h.apply(_g, _j.concat([__spreadArray.apply(void 0, _k.concat([__read.apply(void 0, [(_s.sent())]), false]))]));
+                        _s.label = 10;
+                    case 10:
+                        if (!absoluteAnchors) return [3 /*break*/, 12];
+                        _m = (_l = drawings.push).apply;
+                        _o = [drawings];
+                        _p = [[]];
+                        return [4 /*yield*/, processAnchors(absoluteAnchors, "absoluteAnchors", drawingPath, sheet.sheetId, this.zipParser, this.xmlParser)];
+                    case 11:
+                        _m.apply(_l, _o.concat([__spreadArray.apply(void 0, _p.concat([__read.apply(void 0, [(_s.sent())]), false]))]));
+                        _s.label = 12;
+                    case 12:
+                        drawingPaths_1_1 = drawingPaths_1.next();
+                        return [3 /*break*/, 5];
+                    case 13: return [3 /*break*/, 16];
+                    case 14:
+                        e_21_1 = _s.sent();
+                        e_21 = { error: e_21_1 };
+                        return [3 /*break*/, 16];
+                    case 15:
+                        try {
+                            if (drawingPaths_1_1 && !drawingPaths_1_1.done && (_r = drawingPaths_1.return)) _r.call(drawingPaths_1);
+                        }
+                        finally { if (e_21) throw e_21.error; }
+                        return [7 /*endfinally*/];
+                    case 16:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 17: return [3 /*break*/, 20];
+                    case 18:
+                        e_22_1 = _s.sent();
+                        e_22 = { error: e_22_1 };
+                        return [3 /*break*/, 20];
+                    case 19:
+                        try {
+                            if (_b && !_b.done && (_q = _a.return)) _q.call(_a);
+                        }
+                        finally { if (e_22) throw e_22.error; }
+                        return [7 /*endfinally*/];
+                    case 20: return [2 /*return*/, drawings];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.getCharts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var charts, sheetIdByName, _a, _b, sheet, resolveSheetId, _c, _d, sheet, drawingPaths, drawingPaths_2, drawingPaths_2_1, drawingPath, drawingContent, drawingXml, drawingDir, drawingName, drawingRelsPath, drawingRelsContent, drawingRelsXml, drawingRelsList, drawingRelsArray, oneCellAnchors, twoCellAnchors, anchors, _loop_4, this_3, anchors_1, anchors_1_1, anchor, e_23_1, e_24_1, e_25_1;
+            var e_26, _e, e_25, _f, e_24, _g, e_23, _h;
+            var _j;
+            return __generator(this, function (_k) {
+                switch (_k.label) {
+                    case 0:
+                        charts = [];
+                        sheetIdByName = {};
+                        try {
+                            for (_a = __values(this.sheets), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                sheet = _b.value;
+                                if ((sheet === null || sheet === void 0 ? void 0 : sheet.title) && (sheet === null || sheet === void 0 ? void 0 : sheet.sheetId) !== undefined) {
+                                    sheetIdByName[String(sheet.title)] = Number(sheet.sheetId);
+                                }
+                            }
+                        }
+                        catch (e_26_1) { e_26 = { error: e_26_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                            }
+                            finally { if (e_26) throw e_26.error; }
+                        }
+                        resolveSheetId = function (sheetName) {
+                            return sheetName ? sheetIdByName[String(sheetName)] : undefined;
+                        };
+                        _k.label = 1;
+                    case 1:
+                        _k.trys.push([1, 21, 22, 23]);
+                        _c = __values(this.sheets), _d = _c.next();
+                        _k.label = 2;
+                    case 2:
+                        if (!!_d.done) return [3 /*break*/, 20];
+                        sheet = _d.value;
+                        return [4 /*yield*/, this.getDrawingPathsForSheet(sheet)];
+                    case 3:
+                        drawingPaths = _k.sent();
+                        _k.label = 4;
+                    case 4:
+                        _k.trys.push([4, 17, 18, 19]);
+                        drawingPaths_2 = (e_24 = void 0, __values(drawingPaths)), drawingPaths_2_1 = drawingPaths_2.next();
+                        _k.label = 5;
+                    case 5:
+                        if (!!drawingPaths_2_1.done) return [3 /*break*/, 16];
+                        drawingPath = drawingPaths_2_1.value;
+                        if (!this.zipParser.has(drawingPath))
+                            return [3 /*break*/, 15];
+                        return [4 /*yield*/, this.zipParser.getText(drawingPath)];
+                    case 6:
+                        drawingContent = _k.sent();
+                        if (!drawingContent)
+                            return [3 /*break*/, 15];
+                        drawingXml = this.xmlParser.parse(drawingContent);
+                        drawingDir = drawingPath.substring(0, drawingPath.lastIndexOf("/"));
+                        drawingName = drawingPath.split("/").pop();
+                        if (!drawingName)
+                            return [3 /*break*/, 15];
+                        drawingRelsPath = "".concat(drawingDir, "/_rels/").concat(drawingName, ".rels");
+                        if (!this.zipParser.has(drawingRelsPath))
+                            return [3 /*break*/, 15];
+                        return [4 /*yield*/, this.zipParser.getText(drawingRelsPath)];
+                    case 7:
+                        drawingRelsContent = _k.sent();
+                        drawingRelsXml = this.xmlParser.parse(drawingRelsContent);
+                        drawingRelsList = get(drawingRelsXml, "Relationships.Relationship") || [];
+                        drawingRelsArray = Array.isArray(drawingRelsList)
+                            ? drawingRelsList
+                            : [drawingRelsList];
+                        oneCellAnchors = get(drawingXml, "xdr:wsDr.xdr:oneCellAnchor") ||
+                            get(drawingXml, "wsDr.oneCellAnchor");
+                        twoCellAnchors = get(drawingXml, "xdr:wsDr.xdr:twoCellAnchor") ||
+                            get(drawingXml, "wsDr.twoCellAnchor");
+                        anchors = __spreadArray(__spreadArray([], __read((Array.isArray(oneCellAnchors)
+                            ? oneCellAnchors
+                            : oneCellAnchors
+                                ? [oneCellAnchors]
+                                : [])), false), __read((Array.isArray(twoCellAnchors)
+                            ? twoCellAnchors
+                            : twoCellAnchors
+                                ? [twoCellAnchors]
+                                : [])), false);
+                        _loop_4 = function (anchor) {
+                            var chartId, chartRel, chart;
+                            return __generator(this, function (_l) {
+                                switch (_l.label) {
+                                    case 0:
+                                        chartId = get(anchor, "xdr:graphicFrame.a:graphic.a:graphicData.c:chart.a$.r:id") || get(anchor, "graphicFrame.graphic.graphicData.chart.a$.r:id");
+                                        if (!chartId)
+                                            return [2 /*return*/, "continue"];
+                                        chartRel = drawingRelsArray.find(function (rel) {
+                                            var _a, _b, _c;
+                                            return ((_a = rel === null || rel === void 0 ? void 0 : rel.a$) === null || _a === void 0 ? void 0 : _a.Id) === chartId ||
+                                                ((_b = rel === null || rel === void 0 ? void 0 : rel.a$) === null || _b === void 0 ? void 0 : _b.id) === chartId ||
+                                                ((_c = rel === null || rel === void 0 ? void 0 : rel.a$) === null || _c === void 0 ? void 0 : _c.ID) === chartId;
+                                        });
+                                        if (!((_j = chartRel === null || chartRel === void 0 ? void 0 : chartRel.a$) === null || _j === void 0 ? void 0 : _j.Target))
+                                            return [2 /*return*/, "continue"];
+                                        return [4 /*yield*/, processChart(chartRel.a$.Target, drawingPath, anchor, sheet.sheetId, this_3.zipParser, this_3.xmlParser, undefined, resolveSheetId)];
+                                    case 1:
+                                        chart = _l.sent();
+                                        if (chart)
+                                            charts.push(chart);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_3 = this;
+                        _k.label = 8;
+                    case 8:
+                        _k.trys.push([8, 13, 14, 15]);
+                        anchors_1 = (e_23 = void 0, __values(anchors)), anchors_1_1 = anchors_1.next();
+                        _k.label = 9;
+                    case 9:
+                        if (!!anchors_1_1.done) return [3 /*break*/, 12];
+                        anchor = anchors_1_1.value;
+                        return [5 /*yield**/, _loop_4(anchor)];
+                    case 10:
+                        _k.sent();
+                        _k.label = 11;
+                    case 11:
+                        anchors_1_1 = anchors_1.next();
+                        return [3 /*break*/, 9];
+                    case 12: return [3 /*break*/, 15];
+                    case 13:
+                        e_23_1 = _k.sent();
+                        e_23 = { error: e_23_1 };
+                        return [3 /*break*/, 15];
+                    case 14:
+                        try {
+                            if (anchors_1_1 && !anchors_1_1.done && (_h = anchors_1.return)) _h.call(anchors_1);
+                        }
+                        finally { if (e_23) throw e_23.error; }
+                        return [7 /*endfinally*/];
+                    case 15:
+                        drawingPaths_2_1 = drawingPaths_2.next();
+                        return [3 /*break*/, 5];
+                    case 16: return [3 /*break*/, 19];
+                    case 17:
+                        e_24_1 = _k.sent();
+                        e_24 = { error: e_24_1 };
+                        return [3 /*break*/, 19];
+                    case 18:
+                        try {
+                            if (drawingPaths_2_1 && !drawingPaths_2_1.done && (_g = drawingPaths_2.return)) _g.call(drawingPaths_2);
+                        }
+                        finally { if (e_24) throw e_24.error; }
+                        return [7 /*endfinally*/];
+                    case 19:
+                        _d = _c.next();
+                        return [3 /*break*/, 2];
+                    case 20: return [3 /*break*/, 23];
+                    case 21:
+                        e_25_1 = _k.sent();
+                        e_25 = { error: e_25_1 };
+                        return [3 /*break*/, 23];
+                    case 22:
+                        try {
+                            if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                        }
+                        finally { if (e_25) throw e_25.error; }
+                        return [7 /*endfinally*/];
+                    case 23: return [2 /*return*/, charts];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.getConditionalFormatting = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var rules, ruleIdCounter, _a, _b, sheet, binary, records, inCF, currentCFRanges, cfRuleIndex, records_8, records_8_1, record, payload, parsed, cfRule, rangeAddresses, ranges, rangeAddresses_1, rangeAddresses_1_1, address, range, rule, err_1, e_27_1;
+            var e_27, _c, e_28, _d, e_29, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        rules = [];
+                        ruleIdCounter = 0;
+                        _f.label = 1;
+                    case 1:
+                        _f.trys.push([1, 8, 9, 10]);
+                        _a = __values(this.sheets), _b = _a.next();
+                        _f.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        sheet = _b.value;
+                        if (!sheet.path || !this.zipParser.has(sheet.path))
+                            return [3 /*break*/, 6];
+                        _f.label = 3;
+                    case 3:
+                        _f.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, this.zipParser.getBinary(sheet.path)];
+                    case 4:
+                        binary = _f.sent();
+                        records = readAllRecordHeaders(binary);
+                        inCF = false;
+                        currentCFRanges = null;
+                        cfRuleIndex = 0;
+                        try {
+                            for (records_8 = (e_28 = void 0, __values(records)), records_8_1 = records_8.next(); !records_8_1.done; records_8_1 = records_8.next()) {
+                                record = records_8_1.value;
+                                payload = binary.subarray(record.dataOffset, record.nextOffset);
+                                if (record.type === RT.BrtBeginConditionalFormatting) {
+                                    inCF = true;
+                                    cfRuleIndex = 0;
+                                    parsed = parseBrtBeginConditionalFormatting(payload);
+                                    currentCFRanges = (parsed === null || parsed === void 0 ? void 0 : parsed.sqref) || null;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtEndConditionalFormatting) {
+                                    inCF = false;
+                                    currentCFRanges = null;
+                                    continue;
+                                }
+                                if (inCF && record.type === RT.BrtBeginCFRule && currentCFRanges) {
+                                    cfRule = parseBrtCFRule(payload);
+                                    if (cfRule) {
+                                        rangeAddresses = currentCFRanges.split(" ");
+                                        ranges = [];
+                                        try {
+                                            for (rangeAddresses_1 = (e_29 = void 0, __values(rangeAddresses)), rangeAddresses_1_1 = rangeAddresses_1.next(); !rangeAddresses_1_1.done; rangeAddresses_1_1 = rangeAddresses_1.next()) {
+                                                address = rangeAddresses_1_1.value;
+                                                range = getRangeFromAddressRef(address);
+                                                if (range) {
+                                                    ranges.push(__assign(__assign({}, range), { sheetId: sheet.sheetId }));
+                                                }
+                                            }
+                                        }
+                                        catch (e_29_1) { e_29 = { error: e_29_1 }; }
+                                        finally {
+                                            try {
+                                                if (rangeAddresses_1_1 && !rangeAddresses_1_1.done && (_e = rangeAddresses_1.return)) _e.call(rangeAddresses_1);
+                                            }
+                                            finally { if (e_29) throw e_29.error; }
+                                        }
+                                        if (ranges.length > 0) {
+                                            rule = {
+                                                id: "".concat(sheet.sheetId, "_").concat(ruleIdCounter++, "_").concat(cfRuleIndex++),
+                                                ranges: ranges,
+                                                priority: cfRule.priority,
+                                            };
+                                            if (cfRule.stopIfTrue) {
+                                                rule.stopIfTrue = true;
+                                            }
+                                            // Note: Full implementation would parse:
+                                            // - Rule type and convert to booleanRule/gradientRule/topBottomRule/distinctRule
+                                            // - DXF styles for formatting
+                                            // - Formulas and values from Rgce data
+                                            // This is a basic implementation that captures the structure
+                                            rules.push(rule);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_28_1) { e_28 = { error: e_28_1 }; }
+                        finally {
+                            try {
+                                if (records_8_1 && !records_8_1.done && (_d = records_8.return)) _d.call(records_8);
+                            }
+                            finally { if (e_28) throw e_28.error; }
+                        }
+                        return [3 /*break*/, 6];
+                    case 5:
+                        err_1 = _f.sent();
+                        // Skip sheet if parsing fails
+                        console.warn("Failed to parse CF for sheet ".concat(sheet.title, ":"), err_1);
+                        return [3 /*break*/, 6];
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_27_1 = _f.sent();
+                        e_27 = { error: e_27_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_27) throw e_27.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/, rules];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.getDataValidations = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var validations, _a, _b, sheet, binary, records, inDVals, inDVal, currentDVal, currentRanges, records_9, records_9_1, record, payload, reader, maybeRange, rangeAddresses, ranges, rangeAddresses_2, rangeAddresses_2_1, address, range, typeMap, validation, conditionType, alertStyles, err_2, e_30_1;
+            var e_30, _c, e_31, _d, e_32, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        validations = [];
+                        _f.label = 1;
+                    case 1:
+                        _f.trys.push([1, 8, 9, 10]);
+                        _a = __values(this.sheets), _b = _a.next();
+                        _f.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        sheet = _b.value;
+                        if (!sheet.path || !this.zipParser.has(sheet.path))
+                            return [3 /*break*/, 6];
+                        _f.label = 3;
+                    case 3:
+                        _f.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, this.zipParser.getBinary(sheet.path)];
+                    case 4:
+                        binary = _f.sent();
+                        records = readAllRecordHeaders(binary);
+                        inDVals = false;
+                        inDVal = false;
+                        currentDVal = null;
+                        currentRanges = null;
+                        try {
+                            for (records_9 = (e_31 = void 0, __values(records)), records_9_1 = records_9.next(); !records_9_1.done; records_9_1 = records_9.next()) {
+                                record = records_9_1.value;
+                                payload = binary.subarray(record.dataOffset, record.nextOffset);
+                                if (record.type === RT.BrtBeginDVals) {
+                                    inDVals = true;
+                                    continue;
+                                }
+                                if (record.type === RT.BrtEndDVals) {
+                                    inDVals = false;
+                                    continue;
+                                }
+                                if (inDVals && record.type === RT.BrtBeginDVal) {
+                                    inDVal = true;
+                                    currentDVal = parseBrtBeginDVal(payload);
+                                    // Next record should contain the range
+                                    continue;
+                                }
+                                if (inDVal && currentDVal) {
+                                    // Try to parse range from payload
+                                    // In XLSB, the range typically follows in the same or next record
+                                    try {
+                                        reader = new Reader(payload);
+                                        maybeRange = reader.readXLWideString();
+                                        if (maybeRange && maybeRange.includes(":")) {
+                                            currentRanges = maybeRange;
+                                        }
+                                    }
+                                    catch (_g) {
+                                        // Not a range, continue
+                                    }
+                                }
+                                if (record.type === RT.BrtEndDVal) {
+                                    inDVal = false;
+                                    if (currentDVal && currentRanges) {
+                                        rangeAddresses = currentRanges.split(" ");
+                                        ranges = [];
+                                        try {
+                                            for (rangeAddresses_2 = (e_32 = void 0, __values(rangeAddresses)), rangeAddresses_2_1 = rangeAddresses_2.next(); !rangeAddresses_2_1.done; rangeAddresses_2_1 = rangeAddresses_2.next()) {
+                                                address = rangeAddresses_2_1.value;
+                                                range = getRangeFromAddressRef(address);
+                                                if (range) {
+                                                    ranges.push(__assign(__assign({}, range), { sheetId: sheet.sheetId }));
+                                                }
+                                            }
+                                        }
+                                        catch (e_32_1) { e_32 = { error: e_32_1 }; }
+                                        finally {
+                                            try {
+                                                if (rangeAddresses_2_1 && !rangeAddresses_2_1.done && (_e = rangeAddresses_2.return)) _e.call(rangeAddresses_2);
+                                            }
+                                            finally { if (e_32) throw e_32.error; }
+                                        }
+                                        if (ranges.length > 0) {
+                                            typeMap = {
+                                                1: "NUMBER", // whole
+                                                2: "NUMBER", // decimal
+                                                3: "LIST", // list
+                                                4: "DATE", // date
+                                                5: "TIME", // time
+                                                6: "TEXT_LENGTH", // textLength
+                                                7: "CUSTOM_FORMULA", // custom
+                                            };
+                                            validation = {
+                                                id: uuid(),
+                                                ranges: ranges,
+                                            };
+                                            conditionType = typeMap[currentDVal.valType];
+                                            if (conditionType && currentDVal.operator !== undefined) {
+                                                // Note: Full implementation would parse formulas and create proper BooleanCondition
+                                                // This is a basic structure
+                                            }
+                                            // Add allow blank flag
+                                            if (currentDVal.ignoreBlank) {
+                                                validation.allowBlank = true;
+                                            }
+                                            // Add input message if present
+                                            if (currentDVal.showInputMessage &&
+                                                (currentDVal.promptTitle || currentDVal.prompt)) {
+                                                validation.inputMessage = __assign(__assign({}, (currentDVal.promptTitle
+                                                    ? { title: currentDVal.promptTitle }
+                                                    : {})), (currentDVal.prompt
+                                                    ? { message: currentDVal.prompt }
+                                                    : {}));
+                                            }
+                                            // Add error alert if present. showErrorMessage without any
+                                            // custom title/text still means "reject invalid input with
+                                            // the default alert", so keep the style-only alert.
+                                            if (currentDVal.showErrorMessage) {
+                                                alertStyles = [
+                                                    "stop",
+                                                    "warning",
+                                                    "information",
+                                                ];
+                                                validation.alert = __assign({ style: alertStyles[currentDVal.errorStyle] || "stop" }, (currentDVal.errorTitle || currentDVal.error
+                                                    ? {
+                                                        message: __assign(__assign({}, (currentDVal.errorTitle
+                                                            ? { title: currentDVal.errorTitle }
+                                                            : {})), (currentDVal.error
+                                                            ? { message: currentDVal.error }
+                                                            : {})),
+                                                    }
+                                                    : {}));
+                                            }
+                                            validations.push(validation);
+                                        }
+                                    }
+                                    currentDVal = null;
+                                    currentRanges = null;
+                                }
+                            }
+                        }
+                        catch (e_31_1) { e_31 = { error: e_31_1 }; }
+                        finally {
+                            try {
+                                if (records_9_1 && !records_9_1.done && (_d = records_9.return)) _d.call(records_9);
+                            }
+                            finally { if (e_31) throw e_31.error; }
+                        }
+                        return [3 /*break*/, 6];
+                    case 5:
+                        err_2 = _f.sent();
+                        // Skip sheet if parsing fails
+                        console.warn("Failed to parse DV for sheet ".concat(sheet.title, ":"), err_2);
+                        return [3 /*break*/, 6];
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_30_1 = _f.sent();
+                        e_30 = { error: e_30_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_30) throw e_30.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/, validations];
+                }
+            });
+        });
+    };
+    XlsbPlugin.prototype.parseBrtName = function (payload, sheets) {
+        var _this = this;
+        var parsed = parseBrtNamePayload(payload, function (ixti) {
+            return _this.resolveSheetNameByXti(ixti);
+        });
+        // Skip if parsing failed or hidden names
+        if (!parsed || parsed.hidden) {
+            return undefined;
+        }
+        // Try to parse the formula as a range reference
+        var gridRange = getRangeFromAddressRef(parsed.formula);
+        // Determine the sheet ID if this is a sheet-scoped name
+        var sheetId;
+        if (parsed.sheetIndex !== undefined && parsed.sheetIndex < sheets.length) {
+            sheetId = sheets[parsed.sheetIndex].sheetId;
+        }
+        // Create the NamedRange object
+        var namedRange = {
+            namedRangeId: uuid(),
+            name: parsed.name,
+        };
+        // Set either range or value depending on what we parsed
+        if (gridRange) {
+            // Convert GridRange to SheetRange by adding sheetId
+            // Use the sheet-scoped sheetId if available, otherwise use the first sheet
+            var rangeSheetId = sheetId !== null && sheetId !== void 0 ? sheetId : (sheets.length > 0 ? sheets[0].sheetId : 1);
+            namedRange.range = __assign(__assign({}, gridRange), { sheetId: rangeSheetId });
+        }
+        else if (parsed.formula) {
+            // If we can't parse it as a range, store it as a formula value
+            namedRange.value = parsed.formula;
+        }
+        return namedRange;
+    };
+    XlsbPlugin.prototype.parseBrtCalcProp = function (payload) {
+        var parsed = parseBrtCalcPropPayload(payload);
+        if (!parsed) {
+            return; // Skip if parsing failed
+        }
+        this.calcProp = {
+            fullCalcOnLoad: parsed.fullCalcOnLoad,
+            iterate: parsed.iterate,
+            iterateCount: parsed.iterateCount,
+            iterateDelta: parsed.iterateDelta,
+        };
+    };
+    XlsbPlugin.prototype.getNamedRanges = function () {
+        return this.namedRanges;
+    };
+    XlsbPlugin.prototype.requiresRecalc = function () {
+        var _a;
+        return (_a = this.calcProp.fullCalcOnLoad) !== null && _a !== void 0 ? _a : false;
+    };
+    /**
+     * `BrtWbProp.fDate1904` shifts every date serial by 1462 days
+     * (Mac-origin workbooks). Defaults to the 1900 epoch when the record is
+     * absent, matching Excel's default behavior for newly-created workbooks.
+     */
+    XlsbPlugin.prototype.getUse1904Epoch = function () {
+        return this.use1904;
+    };
+    XlsbPlugin.prototype.getIterativeCalculationOptions = function () {
+        var _a, _b;
+        if (!this.calcProp.iterate) {
+            return undefined;
+        }
+        return {
+            enabled: true,
+            maxIterations: (_a = this.calcProp.iterateCount) !== null && _a !== void 0 ? _a : 100,
+            maxChange: (_b = this.calcProp.iterateDelta) !== null && _b !== void 0 ? _b : 0.001,
+        };
+    };
+    return XlsbPlugin;
+}(BaseWorkbookPlugin));
+export { XlsbPlugin };