@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,2339 @@
+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";
+const 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,
+};
+class Reader {
+    view;
+    offset = 0;
+    bytes;
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    readUInt8() {
+        const value = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+    readUInt16LE() {
+        const value = this.view.getUint16(this.offset, true);
+        this.offset += 2;
+        return value;
+    }
+    readInt16LE() {
+        const value = this.view.getInt16(this.offset, true);
+        this.offset += 2;
+        return value;
+    }
+    readUInt32LE() {
+        const value = this.view.getUint32(this.offset, true);
+        this.offset += 4;
+        return value;
+    }
+    readInt32LE() {
+        const value = this.view.getInt32(this.offset, true);
+        this.offset += 4;
+        return value;
+    }
+    readFloat64LE() {
+        const value = this.view.getFloat64(this.offset, true);
+        this.offset += 8;
+        return value;
+    }
+    readUtf16Chars(charCount) {
+        if (charCount <= 0)
+            return "";
+        const byteCount = charCount * 2;
+        const slice = this.bytes.subarray(this.offset, this.offset + byteCount);
+        this.offset += byteCount;
+        return new TextDecoder("utf-16le").decode(slice);
+    }
+    readXLWideString() {
+        const cch = this.readUInt32LE();
+        return cch === 0 ? "" : this.readUtf16Chars(cch);
+    }
+    readXLNullableWideString() {
+        const cch = this.readUInt32LE();
+        return cch === 0 || cch === 0xffffffff ? "" : this.readUtf16Chars(cch);
+    }
+}
+const normalizePath = (path) => path.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\/+/, "");
+const resolveRelativePath = (basePath, target) => {
+    if (target.startsWith("/")) {
+        return normalizePath(target);
+    }
+    const baseParts = normalizePath(basePath).split("/");
+    baseParts.pop();
+    const parts = target.split("/");
+    for (const part of parts) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..") {
+            baseParts.pop();
+        }
+        else {
+            baseParts.push(part);
+        }
+    }
+    return normalizePath(baseParts.join("/"));
+};
+const parseBundleSheet = (payload) => {
+    const reader = new Reader(payload);
+    const hidden = reader.readUInt32LE();
+    const tabId = reader.readUInt32LE();
+    const rid = reader.readXLNullableWideString();
+    const title = reader.readXLWideString();
+    return { hidden, tabId, rid, title };
+};
+const parseRowHeader = (payload) => {
+    const reader = new Reader(payload);
+    const row = reader.readUInt32LE() + 1;
+    reader.readUInt32LE(); // ixfe
+    const miyRw = reader.readUInt16LE();
+    reader.readUInt8(); // top/bottom padding
+    const flags = reader.readUInt8();
+    return {
+        row,
+        hidden: Boolean(flags & 0x10),
+        hpt: Boolean(flags & 0x20) ? miyRw / 20 : undefined,
+    };
+};
+const parseMergeRange = (payload) => {
+    const reader = new Reader(payload);
+    const sRow = reader.readUInt32LE() + 1;
+    const eRow = reader.readUInt32LE() + 1;
+    const sCol = reader.readUInt32LE() + 1;
+    const eCol = reader.readUInt32LE() + 1;
+    return {
+        startRowIndex: sRow,
+        endRowIndex: eRow,
+        startColumnIndex: sCol,
+        endColumnIndex: eCol,
+    };
+};
+const parseRange = (payload) => parseMergeRange(payload);
+const normalizeSheetTabIndex = (value) => value === 0xffff || value === 0xffffffff ? -1 : value;
+const parseBrtExternSheet = (payload) => {
+    const parseEntries = (startOffset, entrySize, readEntry) => {
+        if (startOffset > payload.length)
+            return [];
+        const bytes = payload.subarray(startOffset);
+        if (bytes.length === 0 || bytes.length % entrySize !== 0) {
+            return [];
+        }
+        const reader = new Reader(bytes);
+        const out = [];
+        while (reader.offset + entrySize <= reader.bytes.length) {
+            out.push(readEntry(reader));
+        }
+        return out;
+    };
+    const read12 = (reader) => ({
+        iSupBook: reader.readUInt32LE(),
+        itabFirst: normalizeSheetTabIndex(reader.readUInt32LE()),
+        itabLast: normalizeSheetTabIndex(reader.readUInt32LE()),
+    });
+    const read6 = (reader) => ({
+        iSupBook: reader.readUInt16LE(),
+        itabFirst: normalizeSheetTabIndex(reader.readUInt16LE()),
+        itabLast: normalizeSheetTabIndex(reader.readUInt16LE()),
+    });
+    const direct12 = parseEntries(0, 12, read12);
+    if (direct12.length > 0)
+        return direct12;
+    if (payload.length >= 4) {
+        const reader = new Reader(payload);
+        const count = reader.readUInt32LE();
+        const withCount12 = parseEntries(4, 12, read12);
+        if (withCount12.length === count && withCount12.length > 0) {
+            return withCount12;
+        }
+    }
+    const direct6 = parseEntries(0, 6, read6);
+    if (direct6.length > 0)
+        return direct6;
+    if (payload.length >= 2) {
+        const reader = new Reader(payload);
+        const count = reader.readUInt16LE();
+        const withCount6 = parseEntries(2, 6, read6);
+        if (withCount6.length === count && withCount6.length > 0) {
+            return withCount6;
+        }
+    }
+    return [];
+};
+const parseBrtShrFmla = (payload) => {
+    if (payload.length < 20)
+        return null;
+    const reader = new Reader(payload);
+    const startRowZero = reader.readUInt32LE();
+    const endRowZero = reader.readUInt32LE();
+    const startColZero = reader.readUInt32LE();
+    const endColZero = reader.readUInt32LE();
+    // cce can be preceded by small metadata in some files; try a few offsets.
+    const candidateOffsets = [16, 18, 20, 24];
+    let rgceBytes;
+    for (const offset of candidateOffsets) {
+        if (offset + 4 > payload.length)
+            continue;
+        const cce = new DataView(payload.buffer, payload.byteOffset + offset, 4).getUint32(0, true);
+        if (cce <= 0)
+            continue;
+        const start = offset + 4;
+        const end = start + cce;
+        if (end <= payload.length) {
+            rgceBytes = payload.subarray(start, end);
+            break;
+        }
+    }
+    if (!rgceBytes || rgceBytes.length === 0)
+        return null;
+    return {
+        startRow: startRowZero + 1,
+        endRow: endRowZero + 1,
+        startCol: startColZero + 1,
+        endCol: endColZero + 1,
+        rgceBytes,
+    };
+};
+const parseWsView = (payload) => {
+    const reader = new Reader(payload);
+    const flags = reader.readUInt16LE();
+    // Bit 1 (0x0002): fShowGridLines - if 0, gridlines are hidden
+    const showGridLines = (flags & 0x0002) !== 0;
+    return { showGridLines };
+};
+const parsePane = (payload) => {
+    const reader = new Reader(payload);
+    const xSplit = reader.readFloat64LE();
+    const ySplit = reader.readFloat64LE();
+    reader.readUInt32LE(); // rwTop
+    reader.readUInt32LE(); // colLeft
+    const pnnAcct = reader.readUInt8();
+    // Frozen panes have pnnAcct set to specific values
+    const isFrozen = pnnAcct > 0;
+    return {
+        frozenColumnCount: isFrozen && xSplit > 0 ? Math.round(xSplit) : 0,
+        frozenRowCount: isFrozen && ySplit > 0 ? Math.round(ySplit) : 0,
+    };
+};
+export const parseBrtNamePayload = (payload, resolveSheetNameByXti) => {
+    try {
+        const reader = new Reader(payload);
+        const flags = reader.readUInt32LE();
+        const fHidden = (flags & 0x00000001) !== 0;
+        reader.readUInt8(); // chKey
+        const itab = reader.readUInt32LE(); // sheet index (0xFFFFFFFF for workbook scope)
+        // Read the name string
+        if (reader.offset + 4 > payload.length) {
+            return null; // Not enough data
+        }
+        const name = reader.readXLWideString();
+        // NameParsedFormula: cce (UInt32) followed by cce bytes of Rgce
+        let formula = "";
+        if (reader.offset + 4 <= payload.length) {
+            const cce = reader.readUInt32LE();
+            if (cce > 0 && reader.offset + cce <= payload.length) {
+                const rgceBytes = payload.subarray(reader.offset, reader.offset + cce);
+                formula = parseRgce(rgceBytes, resolveSheetNameByXti);
+            }
+        }
+        return {
+            name,
+            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 const parseBrtWbPropPayload = (payload) => {
+    if (payload.length < 1) {
+        return null;
+    }
+    return {
+        use1904: (payload[0] & 0x01) !== 0,
+    };
+};
+const parseBrtCalcPropPayload = (payload) => {
+    try {
+        const reader = new Reader(payload);
+        reader.readUInt32LE(); // recalcID
+        const flags = reader.readUInt16LE();
+        const fFullCalcOnLoad = (flags & 0x0002) !== 0;
+        const fIter = (flags & 0x0008) !== 0;
+        const fForceFullCalc = (flags & 0x0100) !== 0;
+        const cCalcCount = reader.readUInt32LE(); // iteration count
+        const 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
+ */
+const parseBrtBeginConditionalFormatting = (payload) => {
+    try {
+        const reader = new Reader(payload);
+        // Read the range reference (sqref)
+        const sqref = reader.readXLWideString();
+        return { sqref };
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Parse CF rule from BrtCFRule / BrtBeginCFRule
+ */
+const parseBrtCFRule = (payload) => {
+    try {
+        const reader = new Reader(payload);
+        const flags = reader.readUInt32LE();
+        const ruleType = reader.readUInt8(); // CF rule type
+        const dxfId = reader.readInt32LE(); // DXF format ID (-1 if none)
+        const priority = reader.readUInt32LE();
+        // Parse flags
+        const stopIfTrue = (flags & 0x02) !== 0;
+        // For now, return basic structure
+        // Full implementation would parse formulas, operators, values based on rule type
+        return {
+            ruleType,
+            dxfId: dxfId >= 0 ? dxfId : undefined,
+            priority,
+            stopIfTrue,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Parse data validation from BrtBeginDVal
+ */
+const parseBrtBeginDVal = (payload) => {
+    try {
+        const reader = new Reader(payload);
+        const flags = reader.readUInt32LE();
+        // Parse validation type and operator
+        const valType = reader.readUInt8(); // 0=none, 1=whole, 2=decimal, 3=list, 4=date, 5=time, 6=textLength, 7=custom
+        const operator = reader.readUInt8(); // 0=between, 1=notBetween, 2=equal, 3=notEqual, etc.
+        // Parse flags
+        const ignoreBlank = (flags & 0x01) !== 0;
+        const inCellDropdown = (flags & 0x02) === 0; // Inverted logic
+        const showInputMessage = (flags & 0x04) !== 0;
+        const showErrorMessage = (flags & 0x08) !== 0;
+        // Error style: 0=stop, 1=warning, 2=information
+        const errorStyle = (flags >> 4) & 0x03;
+        // Read strings
+        const promptTitle = reader.readXLWideString();
+        const errorTitle = reader.readXLWideString();
+        const prompt = reader.readXLWideString();
+        const error = reader.readXLWideString();
+        // Range would be in the parent record or following data
+        // For now, return parsed data
+        return {
+            valType,
+            operator,
+            ignoreBlank,
+            inCellDropdown,
+            showInputMessage,
+            showErrorMessage,
+            errorStyle,
+            promptTitle,
+            errorTitle,
+            prompt,
+            error,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const parseRkNumber = (payload, offset) => {
+    const b0 = payload[offset];
+    const fX100 = (b0 & 1) !== 0;
+    const fInt = (b0 & 2) !== 0;
+    let value;
+    if (fInt) {
+        const view = new DataView(payload.buffer, payload.byteOffset + offset, payload.byteLength - offset);
+        value = (view.getInt32(0, true) >> 2);
+    }
+    else {
+        const 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;
+};
+const XLSB_FILL_PATTERN_NAMES = [
+    "none",
+    "solid",
+    "mediumGray",
+    "darkGray",
+    "lightGray",
+    "darkHorizontal",
+    "darkVertical",
+    "darkDown",
+    "darkUp",
+    "darkGrid",
+    "darkTrellis",
+    "lightHorizontal",
+    "lightVertical",
+    "lightDown",
+    "lightUp",
+    "lightGrid",
+    "lightTrellis",
+    "gray125",
+    "gray0625",
+];
+const getNumberFormatType = (pattern) => {
+    const 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";
+};
+const parseCellFromRecord = (type, payload, row, prevCol, resolveSheetNameByXti, resolveSharedFormula, parseFormula = true) => {
+    if (row <= 0)
+        return null;
+    const reader = new Reader(payload);
+    let colZero;
+    let styleRef;
+    const 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) {
+        const sharedStringIndex = reader.readUInt32LE();
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "s",
+            value: sharedStringIndex,
+            sharedStringIndex,
+        };
+    }
+    if (type === RT.BrtCellBlank || type === RT.BrtShortBlank) {
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "blank",
+            value: "",
+        };
+    }
+    const readFormula = () => {
+        if (!parseFormula)
+            return undefined;
+        const 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((start, idx, arr) => start >= 0 && arr.indexOf(start) === idx);
+        const decodeAt = (start, cceSize) => {
+            if (cceSize === 4) {
+                if (start + 4 > payload.length)
+                    return undefined;
+                const cce = new DataView(payload.buffer, payload.byteOffset + start, 4).getUint32(0, true);
+                if (cce <= 0)
+                    return undefined;
+                const rgceStart = start + 4;
+                const rgceEnd = rgceStart + cce;
+                if (rgceEnd > payload.length)
+                    return undefined;
+                return payload.subarray(rgceStart, rgceEnd);
+            }
+            if (start + 2 > payload.length)
+                return undefined;
+            const cce = new DataView(payload.buffer, payload.byteOffset + start, 2).getUint16(0, true);
+            if (cce <= 0)
+                return undefined;
+            const rgceStart = start + 2;
+            const rgceEnd = rgceStart + cce;
+            if (rgceEnd > payload.length)
+                return undefined;
+            return payload.subarray(rgceStart, rgceEnd);
+        };
+        const tryResolve = (parsed) => {
+            const expMatch = parsed.match(/^__PTGEXP__:(\d+):(\d+)$/);
+            if (!expMatch)
+                return parsed;
+            if (!resolveSharedFormula)
+                return undefined;
+            const sourceRow = Number(expMatch[1]);
+            const sourceCol = Number(expMatch[2]);
+            return resolveSharedFormula(sourceRow, sourceCol, row, colZero + 1);
+        };
+        for (const start of candidateStarts) {
+            for (const cceSize of [4, 2]) {
+                const rgceBytes = decodeAt(start, cceSize);
+                if (!rgceBytes || rgceBytes.length === 0)
+                    continue;
+                const parsed = parseRgce(rgceBytes, resolveSheetNameByXti, { row, col: colZero + 1 }, true);
+                if (!parsed)
+                    continue;
+                const resolved = tryResolve(parsed);
+                if (resolved && resolved.length > 0) {
+                    return resolved;
+                }
+            }
+        }
+        return undefined;
+    };
+    if (type === RT.BrtFmlaNum) {
+        const value = reader.readFloat64LE();
+        reader.readUInt16LE(); // flags
+        const formula = readFormula();
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "n",
+            value,
+            formula,
+        };
+    }
+    if (type === RT.BrtFmlaString) {
+        const value = reader.readXLWideString();
+        reader.readUInt16LE(); // flags
+        const formula = readFormula();
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "str",
+            value,
+            formula,
+        };
+    }
+    if (type === RT.BrtFmlaBool) {
+        const value = reader.readUInt8() !== 0;
+        reader.readUInt8(); // padding
+        reader.readUInt16LE(); // flags
+        const formula = readFormula();
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "b",
+            value,
+            formula,
+        };
+    }
+    if (type === RT.BrtFmlaError) {
+        const value = reader.readUInt8();
+        reader.readUInt8(); // padding
+        reader.readUInt16LE(); // flags
+        const formula = readFormula();
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "e",
+            value,
+            formula,
+        };
+    }
+    if (type === RT.BrtCellSt || type === RT.BrtShortSt) {
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "str",
+            value: reader.readXLWideString(),
+        };
+    }
+    if (type === RT.BrtCellReal || type === RT.BrtShortReal) {
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "n",
+            value: reader.readFloat64LE(),
+        };
+    }
+    if (type === RT.BrtCellRk || type === RT.BrtShortRk) {
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "n",
+            value: parseRkNumber(payload, reader.offset),
+        };
+    }
+    if (type === RT.BrtCellBool || type === RT.BrtShortBool) {
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "b",
+            value: reader.readUInt8() !== 0,
+        };
+    }
+    if (type === RT.BrtCellError || type === RT.BrtShortError) {
+        return {
+            row,
+            col: colZero + 1,
+            styleRef,
+            kind: "e",
+            value: reader.readUInt8(),
+        };
+    }
+    return null;
+};
+const parseBrtColor = (reader) => {
+    const d = reader.readUInt8();
+    const xColorType = d >>> 1;
+    const index = reader.readUInt8();
+    const tintRaw = reader.readInt16LE();
+    const r = reader.readUInt8();
+    const g = reader.readUInt8();
+    const b = reader.readUInt8();
+    reader.readUInt8(); // alpha
+    const tint = tintRaw === 0 ? undefined : tintRaw > 0 ? tintRaw / 32767 : tintRaw / 32768;
+    if (xColorType === 2) {
+        return `#${[r, g, b]
+            .map((v) => v.toString(16).padStart(2, "0"))
+            .join("")
+            .toUpperCase()}`;
+    }
+    if (xColorType === 3) {
+        return {
+            theme: index,
+            ...(tint != null ? { tint } : {}),
+        };
+    }
+    if (xColorType === 1 && index === 64) {
+        return { theme: 1 };
+    }
+    if (xColorType === 1) {
+        return IndexedColors[index];
+    }
+    return undefined;
+};
+const parseBrtFill = (payload) => {
+    const reader = new Reader(payload);
+    const fill = reader.readUInt32LE();
+    const result = {
+        patternType: XLSB_FILL_PATTERN_NAMES[fill] ?? (fill === 0x28 ? "gradient" : undefined),
+    };
+    if (fill !== 0x28 && payload.length >= 20) {
+        result.fgColor = parseBrtColor(reader);
+        parseBrtColor(reader);
+    }
+    return result;
+};
+const parseBrtFmt = (payload) => {
+    const reader = new Reader(payload);
+    const id = reader.readUInt16LE();
+    const formatCode = reader.readXLWideString();
+    return { id, formatCode };
+};
+const parseBrtXf = (payload) => {
+    const reader = new Reader(payload);
+    const parentId = reader.readUInt16LE();
+    const numFmtId = reader.readUInt16LE();
+    const fontId = reader.readUInt16LE();
+    const fillId = reader.readUInt16LE();
+    const borderId = payload.length >= 10 ? reader.readUInt16LE() : 0;
+    const result = { parentId, numFmtId, fontId, fillId, borderId };
+    // Parse alignment if enough data is available
+    if (payload.length >= 14) {
+        const trot = reader.readUInt8(); // text rotation
+        const indent = reader.readUInt8();
+        const flags = reader.readUInt16LE();
+        // Extract alignment from flags (bits 0-2: horizontal, bits 3-5: vertical)
+        const alH = flags & 0x07; // bits 0-2
+        const alV = (flags >> 3) & 0x07; // bits 3-5
+        const fWrap = (flags >> 6) & 0x01; // bit 6
+        // Map horizontal alignment
+        const horizontalAlignments = [
+            "general",
+            "left",
+            "center",
+            "right",
+            "fill",
+            "justify",
+            "centerContinuous",
+            "distributed",
+        ];
+        if (alH > 0 && alH < horizontalAlignments.length) {
+            result.horizontalAlignment = horizontalAlignments[alH];
+        }
+        // Map vertical alignment
+        const verticalAlignments = [
+            "top",
+            "middle",
+            "bottom",
+            "justify",
+            "distributed",
+        ];
+        if (alV > 0 && alV < verticalAlignments.length) {
+            const 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;
+};
+const parseBrtColInfo = (payload) => {
+    const reader = new Reader(payload);
+    const startCol = reader.readUInt32LE() + 1;
+    const endCol = reader.readUInt32LE() + 1;
+    const coldx = reader.readUInt32LE();
+    reader.readUInt32LE(); // ixfe/style
+    const flags = reader.readUInt16LE();
+    const hidden = (flags & 0x01) !== 0;
+    const customWidth = (flags & 0x02) !== 0;
+    const widthChars = coldx / 256;
+    const size = excelColumnWidthToPixels(widthChars);
+    return { startCol, endCol, hidden, customWidth, size };
+};
+const parseBrtListPartRelId = (payload) => {
+    const reader = new Reader(payload);
+    return reader.readXLNullableWideString();
+};
+const parseBrtFont = (payload) => {
+    const reader = new Reader(payload);
+    const size = reader.readUInt16LE() / 20;
+    const flags = reader.readUInt8();
+    reader.readUInt8(); // reserved
+    reader.readUInt16LE(); // bold weight
+    reader.readUInt16LE(); // script style
+    const underline = reader.readUInt8();
+    reader.readUInt8(); // family
+    reader.readUInt8(); // charset
+    reader.readUInt8(); // reserved
+    const color = parseBrtColor(reader);
+    reader.readUInt8(); // scheme
+    const name = reader.readXLWideString();
+    return {
+        ...(name ? { name } : {}),
+        ...(Number.isFinite(size) ? { size } : {}),
+        ...(flags & 0x01 ? { bold: true } : {}),
+        ...(flags & 0x02 ? { italic: true } : {}),
+        ...(flags & 0x08 ? { strikethrough: true } : {}),
+        ...(underline !== 0 ? { underline: true } : {}),
+        ...(color ? { color } : {}),
+    };
+};
+const 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 },
+};
+const parseBrtBorder = (payload) => {
+    if (payload.length < 41)
+        return {};
+    const reader = new Reader(payload);
+    reader.readUInt8(); // diagonal flags
+    const side = () => {
+        const styleId = reader.readUInt8();
+        reader.readUInt8(); // reserved
+        const color = parseBrtColor(reader);
+        const mapped = XLSB_BORDER_STYLE_MAP[styleId];
+        if (!mapped)
+            return undefined;
+        return {
+            style: mapped.style,
+            width: mapped.width,
+            ...(color ? { color } : {}),
+        };
+    };
+    const top = side();
+    const bottom = side();
+    const left = side();
+    const right = side();
+    side(); // diagonal, unused
+    return {
+        ...(top ? { top } : {}),
+        ...(right ? { right } : {}),
+        ...(bottom ? { bottom } : {}),
+        ...(left ? { left } : {}),
+    };
+};
+const resolveXf = (styles, xfIndex) => {
+    const xf = styles.cellXfs[xfIndex];
+    if (!xf)
+        return undefined;
+    const parent = styles.styleXfs[xf.parentId];
+    if (!parent)
+        return xf;
+    const inheritIndex = (child, base) => 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).
+    const inheritNumFmtId = (child, base) => {
+        if (child === 0 && base !== 0) {
+            return base;
+        }
+        return 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: xf.horizontalAlignment ?? parent.horizontalAlignment,
+        verticalAlignment: xf.verticalAlignment ?? parent.verticalAlignment,
+        wrapText: xf.wrapText ?? parent.wrapText,
+        textRotation: xf.textRotation ?? parent.textRotation,
+        indent: xf.indent ?? parent.indent,
+    };
+};
+const toCellData = (parsed, styles, sharedStrings, enableCellXfsRegistry, enableSharedStrings, cellXfs) => {
+    const xf = resolveXf(styles, parsed.styleRef);
+    const format = {};
+    const pattern = xf
+        ? styles.numberFormats.get(xf.numFmtId) ??
+            standardExcelFormatCodeById.get(xf.numFmtId)
+        : undefined;
+    if (pattern) {
+        format.numberFormat = {
+            type: getNumberFormatType(pattern),
+            pattern,
+        };
+    }
+    if (xf?.fillId != null) {
+        const fill = styles.fills[xf.fillId];
+        if (fill?.fgColor && fill.patternType === "solid") {
+            format.backgroundColor = fill.fgColor;
+        }
+    }
+    if (xf?.fontId != null) {
+        const font = styles.fonts[xf.fontId];
+        if (font) {
+            const textFormat = {
+                ...(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?.borderId != null) {
+        const 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?.horizontalAlignment) {
+        const validHorizontal = ["left", "right", "center"];
+        if (validHorizontal.includes(xf.horizontalAlignment)) {
+            format.horizontalAlignment = xf.horizontalAlignment;
+        }
+    }
+    if (xf?.verticalAlignment) {
+        const validVertical = ["top", "middle", "bottom"];
+        if (validVertical.includes(xf.verticalAlignment)) {
+            format.verticalAlignment = xf.verticalAlignment;
+        }
+    }
+    if (xf?.wrapText) {
+        format.wrapStrategy = "wrap";
+    }
+    if (xf?.textRotation !== undefined) {
+        format.textRotation = xf.textRotation;
+    }
+    if (xf?.indent !== undefined && xf.indent > 0) {
+        format.indent = xf.indent;
+    }
+    const hasFormat = Object.keys(format).length > 0;
+    const style = enableCellXfsRegistry && hasFormat
+        ? { sid: `xlsb:${parsed.styleRef}` }
+        : undefined;
+    if (style && !cellXfs.has(style.sid)) {
+        cellXfs.set(style.sid, format);
+    }
+    if (parsed.kind === "s") {
+        const idx = parsed.sharedStringIndex ?? Number(parsed.value);
+        const text = sharedStrings[idx] ?? "";
+        if (enableSharedStrings) {
+            return {
+                ...(style
+                    ? { ef: style, uf: style }
+                    : hasFormat
+                        ? { ef: format, uf: format }
+                        : {}),
+                ss: String(idx),
+            };
+        }
+        return {
+            ...(style
+                ? { ef: style, uf: style }
+                : hasFormat
+                    ? { ef: format, uf: format }
+                    : {}),
+            ue: { sv: text },
+            ev: { sv: text },
+            fv: text,
+        };
+    }
+    if (parsed.kind === "str") {
+        const text = String(parsed.value);
+        // If there's a formula, use it in ue.fv, otherwise use the text value
+        const ue = parsed.formula ? { fv: `=${parsed.formula}` } : { sv: text };
+        return {
+            ...(style
+                ? { ef: style, uf: style }
+                : hasFormat
+                    ? { ef: format, uf: format }
+                    : {}),
+            ue,
+            ev: { sv: text },
+            // Skip `fv` for formula cells; renderer derives at paint time.
+            ...(parsed.formula ? {} : { fv: text }),
+        };
+    }
+    if (parsed.kind === "n") {
+        const value = Number(parsed.value);
+        const pattern = format.numberFormat?.pattern ?? "GENERAL";
+        const fv = ssfFormat(pattern, value);
+        // If there's a formula, use it in ue.fv, otherwise use the numeric value
+        const ue = parsed.formula ? { fv: `=${parsed.formula}` } : { nv: value };
+        return {
+            ...(style
+                ? { ef: style, uf: style }
+                : hasFormat
+                    ? { ef: format, uf: format }
+                    : {}),
+            ue,
+            ev: { nv: value },
+            ...(parsed.formula ? {} : { fv }),
+        };
+    }
+    if (parsed.kind === "b") {
+        const value = Boolean(parsed.value);
+        // If there's a formula, use it in ue.fv, otherwise use the boolean value
+        const ue = parsed.formula ? { fv: `=${parsed.formula}` } : { bv: value };
+        return {
+            ...(style
+                ? { ef: style, uf: style }
+                : hasFormat
+                    ? { ef: format, uf: format }
+                    : {}),
+            ue,
+            ev: { bv: value },
+            ...(parsed.formula ? {} : { fv: value ? "TRUE" : "FALSE" }),
+        };
+    }
+    if (parsed.kind === "e") {
+        // Error value
+        const errorCodes = {
+            0x00: "#NULL!",
+            0x07: "#DIV/0!",
+            0x0f: "#VALUE!",
+            0x17: "#REF!",
+            0x1d: "#NAME?",
+            0x24: "#NUM!",
+            0x2a: "#N/A",
+            0x2b: "#GETTING_DATA",
+        };
+        const code = errorCodes[Number(parsed.value)] || "#VALUE!";
+        const 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.
+        const ue = parsed.formula
+            ? { fv: `=${parsed.formula}` }
+            : errorExtendedValue;
+        return {
+            ...(style
+                ? { ef: style, uf: style }
+                : hasFormat
+                    ? { ef: format, uf: format }
+                    : {}),
+            ue,
+            ev: errorExtendedValue,
+            ...(parsed.formula ? {} : { fv: code }),
+        };
+    }
+    if (parsed.kind === "blank") {
+        if (!hasFormat && !style)
+            return null;
+        return {
+            ...(style
+                ? { ef: style, uf: style }
+                : hasFormat
+                    ? { ef: format, uf: format }
+                    : {}),
+        };
+    }
+    return {
+        ...(style
+            ? { ef: style, uf: style }
+            : hasFormat
+                ? { ef: format, uf: format }
+                : {}),
+        ue: { sv: "#VALUE!" },
+        ev: { sv: "#VALUE!" },
+        fv: "#VALUE!",
+    };
+};
+const isCellRecord = (type) => 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;
+export class XlsbPlugin extends BaseWorkbookPlugin {
+    zipParser = new StreamingZipParser();
+    xmlParser = new XMLParser({
+        ignoreAttributes: false,
+        attributesGroupName: "a$",
+        attributeNamePrefix: "",
+        textNodeName: "t$",
+        trimValues: false,
+        ignoreDeclaration: true,
+    });
+    sheets = [];
+    sharedStrings = [];
+    sharedFormulaMap = new Map();
+    cellXfs = new Map();
+    styles = {
+        numberFormats: new Map(standardExcelFormatCodeById),
+        styleXfs: [],
+        cellXfs: [],
+        fills: [],
+        fonts: [],
+        borders: [],
+    };
+    theme = defaultSpreadsheetTheme;
+    namedRanges = [];
+    calcProp = {};
+    supportingLinks = [];
+    externSheetRefs = [];
+    use1904 = false;
+    async load(buffer, password) {
+        await this.zipParser.load(buffer, password);
+        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();
+        const workbookBinary = await this.zipParser.getBinary("xl/workbook.bin");
+        const records = readAllRecordHeaders(workbookBinary);
+        const workbookRels = await this.loadWorkbookRelationships();
+        const sheets = [];
+        const namedRanges = [];
+        const supportingLinks = [];
+        let externSheetRefs = [];
+        for (const record of records) {
+            const payload = workbookBinary.subarray(record.dataOffset, record.nextOffset);
+            if (record.type === RT.BrtBundleSh) {
+                const parsed = parseBundleSheet(payload);
+                // Skip veryHidden sheets (hidden === 2) - these are internal sheets not meant for users
+                if (parsed.hidden === 2) {
+                    continue;
+                }
+                const relTarget = workbookRels.get(parsed.rid);
+                const path = relTarget
+                    ? resolveRelativePath("xl/workbook.bin", relTarget)
+                    : undefined;
+                sheets.push({
+                    sheetId: parsed.tabId || sheets.length + 1,
+                    title: parsed.title || `Sheet${sheets.length + 1}`,
+                    hidden: parsed.hidden === 1,
+                    rid: parsed.rid,
+                    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) {
+                const parsed = parseBrtExternSheet(payload);
+                if (parsed.length > 0) {
+                    externSheetRefs = parsed;
+                }
+            }
+            else if (record.type === RT.BrtName) {
+                const 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) {
+                const parsed = parseBrtWbPropPayload(payload);
+                if (parsed) {
+                    this.use1904 = parsed.use1904;
+                }
+            }
+        }
+        this.namedRanges = namedRanges;
+        this.supportingLinks = supportingLinks;
+        this.externSheetRefs = externSheetRefs;
+        this.sheets = sheets;
+        this.sharedStrings = await this.loadSharedStrings();
+        this.styles = await this.loadStyles();
+        this.theme = await this.loadTheme();
+        for (const sheet of this.sheets) {
+            if (!sheet.path || !this.zipParser.has(sheet.path))
+                continue;
+            const stats = await this.scanSheetStats(sheet.path);
+            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;
+        }
+    }
+    dispose() {
+        void this.zipParser.dispose();
+    }
+    async loadWorkbookRelationships() {
+        const relsPath = "xl/_rels/workbook.bin.rels";
+        const relMap = new Map();
+        if (!this.zipParser.has(relsPath)) {
+            return relMap;
+        }
+        const relText = await this.zipParser.getText(relsPath);
+        const rels = this.xmlParser.parse(relText);
+        const relations = get(rels, "Relationships.Relationship") ?? [];
+        const list = Array.isArray(relations) ? relations : [relations];
+        for (const rel of list) {
+            const id = rel?.a$?.Id ?? rel?.Id;
+            const target = rel?.a$?.Target ?? rel?.Target;
+            if (typeof id === "string" && typeof target === "string") {
+                relMap.set(id, target);
+            }
+        }
+        return relMap;
+    }
+    async loadSharedStrings() {
+        const path = "xl/sharedStrings.bin";
+        if (!this.zipParser.has(path))
+            return [];
+        const binary = await this.zipParser.getBinary(path);
+        const records = readAllRecordHeaders(binary);
+        const result = [];
+        for (const record of records) {
+            if (record.type !== RT.BrtSSTItem)
+                continue;
+            const payload = binary.subarray(record.dataOffset, record.nextOffset);
+            const reader = new Reader(payload);
+            reader.readUInt8(); // flags
+            result.push(reader.readXLWideString());
+        }
+        return result;
+    }
+    async loadStyles() {
+        const path = "xl/styles.bin";
+        const styles = {
+            numberFormats: new Map(standardExcelFormatCodeById),
+            styleXfs: [],
+            cellXfs: [],
+            fills: [],
+            fonts: [],
+            borders: [],
+        };
+        if (!this.zipParser.has(path))
+            return styles;
+        const binary = await this.zipParser.getBinary(path);
+        const records = readAllRecordHeaders(binary);
+        let inCellXfs = false;
+        let inStyleXfs = false;
+        let inFonts = false;
+        let inFills = false;
+        let inBorders = false;
+        let inFmts = false;
+        for (const record of records) {
+            const 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) {
+                const { id, formatCode } = parseBrtFmt(payload);
+                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));
+            }
+        }
+        return styles;
+    }
+    async loadTheme() {
+        try {
+            if (!this.zipParser.has("xl/theme/theme1.xml")) {
+                return defaultSpreadsheetTheme;
+            }
+            const themeContent = await this.zipParser.getText("xl/theme/theme1.xml");
+            const themeXml = this.xmlParser.parse(themeContent);
+            const themeName = get(themeXml, "a:theme.a$.name") || "Office";
+            const { primaryFontFamily, headingFontFamily } = extractThemeFonts(themeXml);
+            const themeColors = extractThemeColors(themeXml, defaultSpreadsheetTheme);
+            const darkThemeColors = generateDarkThemeColors(themeColors);
+            return {
+                name: themeName,
+                primaryFontFamily,
+                headingFontFamily,
+                themeColors,
+                darkThemeColors,
+            };
+        }
+        catch {
+            return defaultSpreadsheetTheme;
+        }
+    }
+    getTheme() {
+        return this.theme ?? defaultSpreadsheetTheme;
+    }
+    parseRelIdFromPayload(payload) {
+        const reader = new Reader(payload);
+        const relId = reader.readXLNullableWideString();
+        return relId || undefined;
+    }
+    async loadRelationshipsForPart(basePath) {
+        const base = normalizePath(basePath);
+        const name = base.split("/").pop();
+        if (!name)
+            return new Map();
+        const dir = base.substring(0, base.lastIndexOf("/"));
+        const relsPath = `${dir}/_rels/${name}.rels`;
+        if (!this.zipParser.has(relsPath))
+            return new Map();
+        const relText = await this.zipParser.getText(relsPath);
+        const rels = this.xmlParser.parse(relText);
+        const relations = get(rels, "Relationships.Relationship") ?? [];
+        const list = Array.isArray(relations) ? relations : [relations];
+        const out = new Map();
+        for (const rel of list) {
+            const id = rel?.a$?.Id ?? rel?.Id;
+            const target = rel?.a$?.Target ?? rel?.Target;
+            if (typeof id === "string" && typeof target === "string") {
+                out.set(id, target);
+            }
+        }
+        return out;
+    }
+    async getDrawingPathsForSheet(sheet) {
+        if (!sheet.path || !this.zipParser.has(sheet.path))
+            return [];
+        const binary = await this.zipParser.getBinary(sheet.path);
+        const records = readAllRecordHeaders(binary);
+        const relIds = [];
+        for (const record of records) {
+            if (record.type !== RT.BrtDrawing)
+                continue;
+            const payload = binary.subarray(record.dataOffset, record.nextOffset);
+            const relId = this.parseRelIdFromPayload(payload);
+            if (relId)
+                relIds.push(relId);
+        }
+        if (relIds.length === 0)
+            return [];
+        const relMap = await this.loadRelationshipsForPart(sheet.path);
+        const paths = [];
+        for (const relId of relIds) {
+            const target = relMap.get(relId);
+            if (!target)
+                continue;
+            paths.push(resolveRelativePath(sheet.path, target));
+        }
+        return Array.from(new Set(paths));
+    }
+    async getTablesFromSheet(sheet) {
+        if (!sheet.path || !sheet.tablePartRelIds.length)
+            return [];
+        const relMap = await this.loadRelationshipsForPart(sheet.path);
+        const tables = [];
+        for (const tableRelId of sheet.tablePartRelIds) {
+            const target = relMap.get(tableRelId);
+            if (!target)
+                continue;
+            const tablePath = resolveRelativePath(sheet.path, target);
+            if (!this.zipParser.has(tablePath))
+                continue;
+            // 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"))
+                continue;
+            const tableContent = await this.zipParser.getText(tablePath);
+            let tableData;
+            try {
+                tableData = this.xmlParser.parse(tableContent || "");
+            }
+            catch {
+                continue;
+            }
+            const tableDefinition = get(tableData, "table") || get(tableData, "x:table");
+            if (!tableDefinition)
+                continue;
+            const attrs = tableDefinition.a$ || {};
+            const range = getRangeFromAddressRef(attrs.ref);
+            if (!range)
+                continue;
+            const columnDefinitions = get(tableDefinition, "tableColumns.tableColumn") ||
+                get(tableDefinition, "x:tableColumns.x:tableColumn");
+            const columnDefsArray = Array.isArray(columnDefinitions)
+                ? columnDefinitions
+                : columnDefinitions
+                    ? [columnDefinitions]
+                    : [];
+            const columns = columnDefsArray.map((colDef) => {
+                const name = colDef?.a$?.name || "";
+                const calculatedColumnFormula = get(colDef, "calculatedColumnFormula") ||
+                    get(colDef, "x:calculatedColumnFormula");
+                if (calculatedColumnFormula) {
+                    return { name, formula: calculatedColumnFormula };
+                }
+                return { name };
+            });
+            const autoFilter = tableDefinition.autoFilter ?? tableDefinition["x:autoFilter"];
+            const filterSpecs = createFilterSpecsFromAutoFilter(autoFilter);
+            const tableStyle = get(tableDefinition, "tableStyleInfo") ||
+                get(tableDefinition, "x:tableStyleInfo") ||
+                {};
+            const tableStyleAttrs = tableStyle.a$ || {};
+            const tableView = {
+                id: attrs.id || uuid(),
+                title: attrs.name || attrs.displayName || `Table_${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,
+                filterSpecs,
+            };
+            if (tableStyleAttrs.name) {
+                tableView.theme = tableStyleAttrs.name;
+            }
+            tables.push(tableView);
+        }
+        return tables;
+    }
+    async scanSheetStats(path) {
+        const binary = await this.zipParser.getBinary(path);
+        const records = readAllRecordHeaders(binary);
+        let currentRow = 0;
+        let maxRow = 0;
+        let maxCol = 0;
+        let prevCol = -1;
+        const merges = [];
+        const rowMetadata = [];
+        const columnMetadata = [];
+        let showGridLines;
+        let frozenRowCount;
+        let frozenColumnCount;
+        let basicFilterRange;
+        const tablePartRelIds = [];
+        for (const record of records) {
+            const payload = binary.subarray(record.dataOffset, record.nextOffset);
+            if (record.type === RT.BrtWsView) {
+                const view = parseWsView(payload);
+                showGridLines = view.showGridLines;
+                continue;
+            }
+            if (record.type === RT.BrtPane) {
+                const 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) {
+                const relId = parseBrtListPartRelId(payload);
+                if (relId)
+                    tablePartRelIds.push(relId);
+                continue;
+            }
+            if (record.type === RT.BrtRowHdr) {
+                const parsedRow = parseRowHeader(payload);
+                currentRow = parsedRow.row;
+                prevCol = -1;
+                if (currentRow > maxRow)
+                    maxRow = currentRow;
+                if (parsedRow.hidden || parsedRow.hpt != null) {
+                    rowMetadata[currentRow] = {
+                        ...(parsedRow.hidden ? { hiddenByUser: true } : {}),
+                        ...(parsedRow.hpt != null
+                            ? {
+                                size: Math.round((parsedRow.hpt * 96) / 72),
+                                resizedByUser: true,
+                            }
+                            : {}),
+                    };
+                }
+                continue;
+            }
+            if (record.type === RT.BrtColInfo) {
+                const parsedCol = parseBrtColInfo(payload);
+                for (let col = parsedCol.startCol; col <= parsedCol.endCol; col++) {
+                    const 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) {
+                const 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;
+            const parsed = parseCellFromRecord(record.type, payload, currentRow, prevCol, (ixti) => 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;
+        }
+        return {
+            rowCount: maxRow,
+            columnCount: maxCol,
+            merges,
+            rowMetadata,
+            columnMetadata,
+            showGridLines,
+            frozenRowCount,
+            frozenColumnCount,
+            basicFilterRange,
+            tablePartRelIds,
+        };
+    }
+    getSheetCount() {
+        return this.sheets.length;
+    }
+    getSheetNames() {
+        return this.sheets.map((s) => s.title);
+    }
+    resolveSheetNameByXti(ixti) {
+        const sheetNames = this.getSheetNames();
+        const fallback = sheetNames[ixti] ?? sheetNames[ixti - 1];
+        const xti = this.externSheetRefs[ixti];
+        if (!xti)
+            return fallback;
+        const linkType = this.supportingLinks[xti.iSupBook];
+        if (linkType !== "self" && linkType !== "same") {
+            return fallback;
+        }
+        const first = xti.itabFirst;
+        const 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 `${sheetNames[first]}:${sheetNames[last]}`;
+    }
+    async getSheets(minRowCount = 0, minColumnCount = 0) {
+        const tables = [];
+        const sheets = [];
+        for (const sheet of this.sheets) {
+            const sheetTables = await this.getTablesFromSheet(sheet);
+            tables.push(...sheetTables);
+            const matchedFilterSpecs = sheetTables.find((t) => 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)?.filterSpecs;
+            sheets.push({
+                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 ?? [],
+                        },
+                    }
+                    : {}),
+            });
+        }
+        return [sheets, tables];
+    }
+    getSharedStrings() {
+        return this.sharedStrings;
+    }
+    getStyles() {
+        return this.styles;
+    }
+    getFonts() {
+        const out = new Set();
+        for (const font of this.styles.fonts) {
+            if (font.name)
+                out.add(font.name);
+        }
+        return [...out];
+    }
+    getCellXfs() {
+        return this.cellXfs;
+    }
+    registerFormat(format) {
+        const key = getCellXfsKey(format);
+        if (!this.cellXfs.has(key)) {
+            this.cellXfs.set(key, format);
+        }
+        return key;
+    }
+    async *processSheetData(chunkSize = 100, enableCellXfsRegistry = false, enableSharedStrings = true) {
+        const totalSheets = this.sheets.length;
+        for (let index = 0; index < this.sheets.length; index++) {
+            const sheet = this.sheets[index];
+            if (!sheet.path || !this.zipParser.has(sheet.path))
+                continue;
+            const binary = await this.zipParser.getBinary(sheet.path);
+            const records = readAllRecordHeaders(binary);
+            const sharedFormulaBytes = new Map();
+            const sharedFormulaRanges = [];
+            // Pre-scan shared formulas so PtgExp can resolve even when BrtShrFmla
+            // appears later in the record stream.
+            for (const record of records) {
+                if (record.type !== RT.BrtShrFmla)
+                    continue;
+                const payload = binary.subarray(record.dataOffset, record.nextOffset);
+                const parsedShared = parseBrtShrFmla(payload);
+                if (!parsedShared)
+                    continue;
+                sharedFormulaBytes.set(`${parsedShared.startRow}:${parsedShared.startCol}`, parsedShared.rgceBytes);
+                sharedFormulaRanges.push(parsedShared);
+            }
+            let currentRow = 0;
+            let prevCol = -1;
+            const rows = new Map();
+            for (const record of records) {
+                const payload = binary.subarray(record.dataOffset, record.nextOffset);
+                if (record.type === RT.BrtShrFmla) {
+                    continue;
+                }
+                if (record.type === RT.BrtRowHdr) {
+                    const parsedRow = parseRowHeader(payload);
+                    currentRow = parsedRow.row;
+                    prevCol = -1;
+                    if (!rows.has(currentRow)) {
+                        rows.set(currentRow, { values: [] });
+                    }
+                    continue;
+                }
+                if (!isCellRecord(record.type))
+                    continue;
+                const parsed = parseCellFromRecord(record.type, payload, currentRow, prevCol, (ixti) => this.resolveSheetNameByXti(ixti), (sourceRow, sourceCol, targetRow, targetCol) => {
+                    let rgce = sharedFormulaBytes.get(`${sourceRow}:${sourceCol}`);
+                    if (!rgce) {
+                        const sourceRange = sharedFormulaRanges.find((range) => sourceRow >= range.startRow &&
+                            sourceRow <= range.endRow &&
+                            sourceCol >= range.startCol &&
+                            sourceCol <= range.endCol);
+                        rgce = sourceRange?.rgceBytes;
+                    }
+                    if (!rgce)
+                        return undefined;
+                    return parseRgce(rgce, (ixti) => this.resolveSheetNameByXti(ixti), {
+                        row: targetRow,
+                        col: targetCol,
+                    }, true); // Enable debug logging
+                });
+                if (!parsed)
+                    continue;
+                if (!parsed.formula && sharedFormulaRanges.length > 0) {
+                    const sharedRange = sharedFormulaRanges.find((range) => parsed.row >= range.startRow &&
+                        parsed.row <= range.endRow &&
+                        parsed.col >= range.startCol &&
+                        parsed.col <= range.endCol);
+                    if (sharedRange) {
+                        const resolved = parseRgce(sharedRange.rgceBytes, (ixti) => this.resolveSheetNameByXti(ixti), { row: parsed.row, col: parsed.col }, true);
+                        if (resolved) {
+                            parsed.formula = resolved;
+                        }
+                    }
+                }
+                prevCol = parsed.col - 1;
+                let row = rows.get(parsed.row);
+                if (!row) {
+                    row = { values: [] };
+                    rows.set(parsed.row, row);
+                }
+                row.values[parsed.col] = toCellData(parsed, this.styles, this.sharedStrings, enableCellXfsRegistry, enableSharedStrings, this.cellXfs);
+            }
+            // 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 (const merge of sheet.merges) {
+                const topLeftRow = rows.get(merge.startRowIndex);
+                const topLeftCell = topLeftRow?.values?.[merge.startColumnIndex];
+                // Get the format from the top-left cell (if it exists)
+                const sourceFormat = topLeftCell?.ef || topLeftCell?.uf;
+                // Process all cells in the merge range
+                // This ensures the merge structure exists even if there's no explicit formatting
+                for (let r = merge.startRowIndex; r <= merge.endRowIndex; r++) {
+                    for (let 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;
+                        }
+                        // Ensure row exists
+                        let row = rows.get(r);
+                        if (!row) {
+                            row = { values: [] };
+                            rows.set(r, row);
+                        }
+                        // Create format without borders for non-anchor cells
+                        // Borders should only appear on the outer edges of merged cells, not internally
+                        let format = sourceFormat;
+                        if (format && typeof format === "object" && "borders" in format) {
+                            const { borders, ...formatWithoutBorders } = format;
+                            format =
+                                Object.keys(formatWithoutBorders).length > 0
+                                    ? formatWithoutBorders
+                                    : undefined;
+                        }
+                        const existingCell = row.values[c];
+                        if (existingCell) {
+                            // Cell exists - we need to remove borders even if there's no other format
+                            // Preserve cell content (values, formulas, etc.) but update formatting
+                            const { ef, uf, ...cellContent } = existingCell;
+                            if (format) {
+                                // Apply the format without borders
+                                row.values[c] = {
+                                    ...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] = {};
+                            }
+                        }
+                    }
+                }
+            }
+            const sortedRows = Array.from(rows.entries()).sort((a, b) => a[0] - b[0]);
+            let chunkRows = [];
+            let chunkRowIndices = [];
+            let chunkIndex = 0;
+            let startRowIndex = -1;
+            let endRowIndex = -1;
+            for (const [rowIndex, rowData] of sortedRows) {
+                if (chunkRows.length === 0) {
+                    startRowIndex = rowIndex;
+                }
+                chunkRows.push(rowData);
+                chunkRowIndices.push(rowIndex);
+                endRowIndex = rowIndex;
+                if (chunkRows.length >= chunkSize) {
+                    yield {
+                        sheetId: sheet.sheetId,
+                        title: sheet.title,
+                        currentSheetIndex: index,
+                        totalSheets,
+                        chunkIndex,
+                        rows: chunkRows,
+                        rowIndices: chunkRowIndices,
+                        startRowIndex,
+                        endRowIndex,
+                        totalRows: sheet.rowCount,
+                        isLastChunk: false,
+                        cellXfs: this.cellXfs,
+                    };
+                    chunkRows = [];
+                    chunkRowIndices = [];
+                    chunkIndex += 1;
+                    startRowIndex = -1;
+                    endRowIndex = -1;
+                }
+            }
+            if (chunkRows.length) {
+                yield {
+                    sheetId: sheet.sheetId,
+                    title: sheet.title,
+                    currentSheetIndex: index,
+                    totalSheets,
+                    chunkIndex,
+                    rows: chunkRows,
+                    rowIndices: chunkRowIndices,
+                    startRowIndex,
+                    endRowIndex,
+                    totalRows: sheet.rowCount,
+                    isLastChunk: true,
+                    cellXfs: this.cellXfs,
+                };
+            }
+        }
+    }
+    async getDrawings() {
+        const drawings = [];
+        for (const sheet of this.sheets) {
+            const drawingPaths = await this.getDrawingPathsForSheet(sheet);
+            for (const drawingPath of drawingPaths) {
+                if (!this.zipParser.has(drawingPath))
+                    continue;
+                const drawingContent = await this.zipParser.getText(drawingPath);
+                if (!drawingContent)
+                    continue;
+                const drawingXml = this.xmlParser.parse(drawingContent);
+                const oneCellAnchors = get(drawingXml, "xdr:wsDr.xdr:oneCellAnchor") ||
+                    get(drawingXml, "wsDr.oneCellAnchor");
+                const twoCellAnchors = get(drawingXml, "xdr:wsDr.xdr:twoCellAnchor") ||
+                    get(drawingXml, "wsDr.twoCellAnchor");
+                const absoluteAnchors = get(drawingXml, "xdr:wsDr.xdr:absoluteAnchor") ||
+                    get(drawingXml, "wsDr.absoluteAnchor");
+                if (oneCellAnchors) {
+                    drawings.push(...(await processAnchors(oneCellAnchors, "oneCellAnchor", drawingPath, sheet.sheetId, this.zipParser, this.xmlParser)));
+                }
+                if (twoCellAnchors) {
+                    drawings.push(...(await processAnchors(twoCellAnchors, "twoCellAnchors", drawingPath, sheet.sheetId, this.zipParser, this.xmlParser)));
+                }
+                if (absoluteAnchors) {
+                    drawings.push(...(await processAnchors(absoluteAnchors, "absoluteAnchors", drawingPath, sheet.sheetId, this.zipParser, this.xmlParser)));
+                }
+            }
+        }
+        return drawings;
+    }
+    async getCharts() {
+        const charts = [];
+        // sheet-name → sheetId map for cross-sheet ref resolution in chart
+        // formulas (mirrors the xlsx plugin).
+        const sheetIdByName = {};
+        for (const sheet of this.sheets) {
+            if (sheet?.title && sheet?.sheetId !== undefined) {
+                sheetIdByName[String(sheet.title)] = Number(sheet.sheetId);
+            }
+        }
+        const resolveSheetId = (sheetName) => sheetName ? sheetIdByName[String(sheetName)] : undefined;
+        for (const sheet of this.sheets) {
+            const drawingPaths = await this.getDrawingPathsForSheet(sheet);
+            for (const drawingPath of drawingPaths) {
+                if (!this.zipParser.has(drawingPath))
+                    continue;
+                const drawingContent = await this.zipParser.getText(drawingPath);
+                if (!drawingContent)
+                    continue;
+                const drawingXml = this.xmlParser.parse(drawingContent);
+                const drawingDir = drawingPath.substring(0, drawingPath.lastIndexOf("/"));
+                const drawingName = drawingPath.split("/").pop();
+                if (!drawingName)
+                    continue;
+                const drawingRelsPath = `${drawingDir}/_rels/${drawingName}.rels`;
+                if (!this.zipParser.has(drawingRelsPath))
+                    continue;
+                const drawingRelsContent = await this.zipParser.getText(drawingRelsPath);
+                const drawingRelsXml = this.xmlParser.parse(drawingRelsContent);
+                const drawingRelsList = get(drawingRelsXml, "Relationships.Relationship") || [];
+                const drawingRelsArray = Array.isArray(drawingRelsList)
+                    ? drawingRelsList
+                    : [drawingRelsList];
+                const oneCellAnchors = get(drawingXml, "xdr:wsDr.xdr:oneCellAnchor") ||
+                    get(drawingXml, "wsDr.oneCellAnchor");
+                const twoCellAnchors = get(drawingXml, "xdr:wsDr.xdr:twoCellAnchor") ||
+                    get(drawingXml, "wsDr.twoCellAnchor");
+                const anchors = [
+                    ...(Array.isArray(oneCellAnchors)
+                        ? oneCellAnchors
+                        : oneCellAnchors
+                            ? [oneCellAnchors]
+                            : []),
+                    ...(Array.isArray(twoCellAnchors)
+                        ? twoCellAnchors
+                        : twoCellAnchors
+                            ? [twoCellAnchors]
+                            : []),
+                ];
+                for (const anchor of anchors) {
+                    const 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)
+                        continue;
+                    const chartRel = drawingRelsArray.find((rel) => rel?.a$?.Id === chartId ||
+                        rel?.a$?.id === chartId ||
+                        rel?.a$?.ID === chartId);
+                    if (!chartRel?.a$?.Target)
+                        continue;
+                    const chart = await processChart(chartRel.a$.Target, drawingPath, anchor, sheet.sheetId, this.zipParser, this.xmlParser, undefined, resolveSheetId);
+                    if (chart)
+                        charts.push(chart);
+                }
+            }
+        }
+        return charts;
+    }
+    async getConditionalFormatting() {
+        const rules = [];
+        let ruleIdCounter = 0;
+        for (const sheet of this.sheets) {
+            if (!sheet.path || !this.zipParser.has(sheet.path))
+                continue;
+            try {
+                const binary = await this.zipParser.getBinary(sheet.path);
+                const records = readAllRecordHeaders(binary);
+                let inCF = false;
+                let currentCFRanges = null;
+                let cfRuleIndex = 0;
+                for (const record of records) {
+                    const payload = binary.subarray(record.dataOffset, record.nextOffset);
+                    if (record.type === RT.BrtBeginConditionalFormatting) {
+                        inCF = true;
+                        cfRuleIndex = 0;
+                        const parsed = parseBrtBeginConditionalFormatting(payload);
+                        currentCFRanges = parsed?.sqref || null;
+                        continue;
+                    }
+                    if (record.type === RT.BrtEndConditionalFormatting) {
+                        inCF = false;
+                        currentCFRanges = null;
+                        continue;
+                    }
+                    if (inCF && record.type === RT.BrtBeginCFRule && currentCFRanges) {
+                        const cfRule = parseBrtCFRule(payload);
+                        if (cfRule) {
+                            // Parse ranges
+                            const rangeAddresses = currentCFRanges.split(" ");
+                            const ranges = [];
+                            for (const address of rangeAddresses) {
+                                const range = getRangeFromAddressRef(address);
+                                if (range) {
+                                    ranges.push({
+                                        ...range,
+                                        sheetId: sheet.sheetId,
+                                    });
+                                }
+                            }
+                            if (ranges.length > 0) {
+                                const rule = {
+                                    id: `${sheet.sheetId}_${ruleIdCounter++}_${cfRuleIndex++}`,
+                                    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 (err) {
+                // Skip sheet if parsing fails
+                console.warn(`Failed to parse CF for sheet ${sheet.title}:`, err);
+            }
+        }
+        return rules;
+    }
+    async getDataValidations() {
+        const validations = [];
+        for (const sheet of this.sheets) {
+            if (!sheet.path || !this.zipParser.has(sheet.path))
+                continue;
+            try {
+                const binary = await this.zipParser.getBinary(sheet.path);
+                const records = readAllRecordHeaders(binary);
+                let inDVals = false;
+                let inDVal = false;
+                let currentDVal = null;
+                let currentRanges = null;
+                for (const record of records) {
+                    const 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 {
+                            const reader = new Reader(payload);
+                            const maybeRange = reader.readXLWideString();
+                            if (maybeRange && maybeRange.includes(":")) {
+                                currentRanges = maybeRange;
+                            }
+                        }
+                        catch {
+                            // Not a range, continue
+                        }
+                    }
+                    if (record.type === RT.BrtEndDVal) {
+                        inDVal = false;
+                        if (currentDVal && currentRanges) {
+                            // Parse ranges
+                            const rangeAddresses = currentRanges.split(" ");
+                            const ranges = [];
+                            for (const address of rangeAddresses) {
+                                const range = getRangeFromAddressRef(address);
+                                if (range) {
+                                    ranges.push({
+                                        ...range,
+                                        sheetId: sheet.sheetId,
+                                    });
+                                }
+                            }
+                            if (ranges.length > 0) {
+                                // Map validation type to condition type
+                                const typeMap = {
+                                    1: "NUMBER", // whole
+                                    2: "NUMBER", // decimal
+                                    3: "LIST", // list
+                                    4: "DATE", // date
+                                    5: "TIME", // time
+                                    6: "TEXT_LENGTH", // textLength
+                                    7: "CUSTOM_FORMULA", // custom
+                                };
+                                const validation = {
+                                    id: uuid(),
+                                    ranges,
+                                };
+                                // Add condition if we have a recognized type
+                                const 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 = {
+                                        ...(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) {
+                                    const alertStyles = [
+                                        "stop",
+                                        "warning",
+                                        "information",
+                                    ];
+                                    validation.alert = {
+                                        style: alertStyles[currentDVal.errorStyle] || "stop",
+                                        ...(currentDVal.errorTitle || currentDVal.error
+                                            ? {
+                                                message: {
+                                                    ...(currentDVal.errorTitle
+                                                        ? { title: currentDVal.errorTitle }
+                                                        : {}),
+                                                    ...(currentDVal.error
+                                                        ? { message: currentDVal.error }
+                                                        : {}),
+                                                },
+                                            }
+                                            : {}),
+                                    };
+                                }
+                                validations.push(validation);
+                            }
+                        }
+                        currentDVal = null;
+                        currentRanges = null;
+                    }
+                }
+            }
+            catch (err) {
+                // Skip sheet if parsing fails
+                console.warn(`Failed to parse DV for sheet ${sheet.title}:`, err);
+            }
+        }
+        return validations;
+    }
+    parseBrtName(payload, sheets) {
+        const parsed = parseBrtNamePayload(payload, (ixti) => 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
+        const gridRange = getRangeFromAddressRef(parsed.formula);
+        // Determine the sheet ID if this is a sheet-scoped name
+        let sheetId;
+        if (parsed.sheetIndex !== undefined && parsed.sheetIndex < sheets.length) {
+            sheetId = sheets[parsed.sheetIndex].sheetId;
+        }
+        // Create the NamedRange object
+        const 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
+            const rangeSheetId = sheetId ?? (sheets.length > 0 ? sheets[0].sheetId : 1);
+            namedRange.range = {
+                ...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;
+    }
+    parseBrtCalcProp(payload) {
+        const parsed = parseBrtCalcPropPayload(payload);
+        if (!parsed) {
+            return; // Skip if parsing failed
+        }
+        this.calcProp = {
+            fullCalcOnLoad: parsed.fullCalcOnLoad,
+            iterate: parsed.iterate,
+            iterateCount: parsed.iterateCount,
+            iterateDelta: parsed.iterateDelta,
+        };
+    }
+    getNamedRanges() {
+        return this.namedRanges;
+    }
+    requiresRecalc() {
+        return this.calcProp.fullCalcOnLoad ?? 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.
+     */
+    getUse1904Epoch() {
+        return this.use1904;
+    }
+    getIterativeCalculationOptions() {
+        if (!this.calcProp.iterate) {
+            return undefined;
+        }
+        return {
+            enabled: true,
+            maxIterations: this.calcProp.iterateCount ?? 100,
+            maxChange: this.calcProp.iterateDelta ?? 0.001,
+        };
+    }
+}