@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,4654 @@
+import { addressToCell, addressToSelection, alpha2number, checkIfStringIsReference, findMatchingBandProperty, generateSelectionsFromFormula, getCellXfsKey, isAFormula, isBareFormulaExpression, isNil, uuid, } from "@rowsncolumns/utils";
+import { XMLParser } from "fast-xml-parser";
+import { get } from "lodash-es";
+import { Parser as HtmlParser } from "htmlparser2";
+import { createFilterSpecsFromAutoFilter, excelColumnWidthToPixels, findMax, getRangeFromAddressRef, } from "../../helpers";
+import { defaultSpreadsheetTheme } from "../../theme-default";
+import { Unescape } from "../../utils";
+import { StreamingZipParser } from "../../zip-parser-streaming";
+import { SheetDataValidationStamper } from "../../dv-cell-stamp";
+import { BaseWorkbookPlugin } from "../base/index";
+import { processChart } from "./charts";
+import { customFiltersToCondition, dynamicFilterToCondition, } from "../../../autofilter-condition";
+import { getConditionalFormattingFromSheet } from "./conditional-formatting";
+import { getDataValidationsForSheet as parseDataValidationsFromSheetData } from "./data-validations";
+import { processAnchors } from "./drawing";
+import { getRelationsById } from "./relationships";
+import { hasPowerQueryParts, } from "../../../power-query";
+import { extractSheetViewProperties } from "./sheet-views";
+import { EMPTY_SHEET_THREADED_COMMENTS, parsePersons, parseThreadedComments, } from "./threaded-comments";
+import { extractColor, fontNodeToTextFormat, getCellDataForStyleIndex, getCellValueAndFormat, } from "./styles";
+import { extractThemeColors, extractThemeFonts, generateDarkThemeColors, } from "./theme";
+export const XMLTagProcessor = (name, value) => Unescape(value);
+function getWithFallback(source, paths) {
+    for (const path of paths) {
+        const value = get(source, path);
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Pull the literal text out of a single `<r>` block produced by
+ * fast-xml-parser. The parser inlines `<t>` text either as a string
+ * value, an object `{ t$: "...", a$: { ... } }` (when the element
+ * carries attributes like `xml:space="preserve"`), or as a raw
+ * primitive. Plain strings (no enclosing `<r>` element) are also
+ * handled — they appear when fast-xml-parser collapses a leaf node.
+ */
+const extractRunText = (part) => {
+    if (typeof part === "string")
+        return part;
+    const node = part?.t ?? part?.["x:t"];
+    if (node === undefined)
+        return "";
+    if (typeof node === "string")
+        return node;
+    if (typeof node === "object") {
+        if (typeof node.t$ === "string")
+            return node.t$;
+        if (typeof node["#text"] === "string")
+            return node["#text"];
+    }
+    return typeof node === "number" || typeof node === "boolean"
+        ? String(node)
+        : "";
+};
+/**
+ * Convert an `<rPr>` block to a `TextFormat` partial. Supports the
+ * subset OOXML uses for rich-text shared strings — bold, italic,
+ * underline, strikethrough, font size, font family, color (rgb +
+ * theme). Properties absent from the source remain undefined so the
+ * cell's base format keeps winning.
+ */
+const extractRunFormat = (part) => {
+    const rPr = part?.rPr ?? part?.["x:rPr"];
+    if (!rPr || typeof rPr !== "object")
+        return undefined;
+    const format = {};
+    const readAttr = (node, key) => {
+        if (!node)
+            return undefined;
+        return (node?.[`a$.${key}`] ??
+            node?.a$?.[key] ??
+            node?.[`@_${key}`] ??
+            node?.[key]);
+    };
+    // Boolean toggles. OOXML uses presence-as-true (`<b/>`) or a `val`
+    // attribute. fast-xml-parser emits `<b/>` as either `b: ""` or
+    // `b: { a$: { val: "1" } }`; the heuristic accepts both.
+    const truthy = (node) => {
+        if (node === undefined || node === null)
+            return false;
+        const val = readAttr(node, "val");
+        if (val === undefined)
+            return true; // presence-as-true
+        return val === "1" || val === "true" || val === 1 || val === true;
+    };
+    if (truthy(rPr.b ?? rPr["x:b"]))
+        format.bold = true;
+    if (truthy(rPr.i ?? rPr["x:i"]))
+        format.italic = true;
+    if (truthy(rPr.u ?? rPr["x:u"]))
+        format.underline = true;
+    if (truthy(rPr.strike ?? rPr["x:strike"]))
+        format.strikethrough = true;
+    const vertAlignVal = readAttr(rPr.vertAlign ?? rPr["x:vertAlign"], "val");
+    if (vertAlignVal === "superscript") {
+        format.baselineOffset = "superscript";
+    }
+    else if (vertAlignVal === "subscript") {
+        format.baselineOffset = "subscript";
+    }
+    const szVal = readAttr(rPr.sz ?? rPr["x:sz"], "val");
+    if (typeof szVal === "string" || typeof szVal === "number") {
+        const n = Number(szVal);
+        if (Number.isFinite(n) && n > 0)
+            format.fontSize = n;
+    }
+    const rFontVal = readAttr(rPr.rFont ?? rPr["x:rFont"], "val");
+    if (typeof rFontVal === "string" && rFontVal) {
+        format.fontFamily = rFontVal;
+    }
+    const colorNode = rPr.color ?? rPr["x:color"];
+    if (colorNode) {
+        const rgb = readAttr(colorNode, "rgb");
+        const theme = readAttr(colorNode, "theme");
+        const tint = readAttr(colorNode, "tint");
+        if (typeof rgb === "string" && rgb) {
+            // Strip Excel's leading alpha byte ("FFRRGGBB" -> "#RRGGBB")
+            const hex = rgb.length === 8 ? rgb.slice(2) : rgb;
+            // Stored as a plain CSS string; TextFormat's `color` accepts it.
+            format.color = `#${hex.toUpperCase()}`;
+        }
+        else if (theme !== undefined && theme !== null) {
+            const themeNum = Number(theme);
+            if (Number.isFinite(themeNum)) {
+                const tintNum = tint !== undefined && tint !== null ? Number(tint) : undefined;
+                format.color = {
+                    theme: themeNum,
+                    tint: Number.isFinite(tintNum) ? tintNum : undefined,
+                };
+            }
+        }
+    }
+    return format;
+};
+const hasAnyFormatKey = (format) => {
+    return (format.bold === true ||
+        format.italic === true ||
+        format.underline === true ||
+        format.strikethrough === true ||
+        format.color != null ||
+        format.fontFamily != null ||
+        format.fontSize != null ||
+        format.baselineOffset != null);
+};
+export function getChartReferenceFromAnchor(anchor) {
+    const graphicFrame = getWithFallback(anchor, [
+        "xdr:graphicFrame",
+        "graphicFrame",
+    ]);
+    if (!graphicFrame) {
+        return undefined;
+    }
+    return getWithFallback(graphicFrame, [
+        "a:graphic.a:graphicData.c:chart",
+        "a:graphic.a:graphicData.chart",
+        "a:graphic.graphicData.c:chart",
+        "graphic.a:graphicData.c:chart",
+        "graphic.graphicData.c:chart",
+        "graphic.graphicData.chart",
+        "graphicData.c:chart",
+        "graphicData.chart",
+        "c:chart",
+        "chart",
+    ]);
+}
+const XMLOptions2 = {
+    ignoreAttributes: false,
+    attributesGroupName: "a$",
+    attributeNamePrefix: "",
+    textNodeName: "t$",
+    trimValues: false,
+    ignoreDeclaration: true,
+    isArray: (tagName) => {
+        return /Relationship$/.test(tagName);
+    },
+    tagValueProcessor: XMLTagProcessor,
+    attributeValueProcessor: XMLTagProcessor,
+    // Disable entity processing to avoid expansion limits on large Excel files
+    processEntities: false,
+};
+export class WorkbookStyles {
+    styles;
+    fills;
+    numFmts;
+    borders;
+    cellXfs;
+    cellStyleXfs;
+    fonts;
+    dxfs;
+    tableStyles;
+    /**
+     * Workbook-wide named cell styles parsed from `<cellStyles>` in
+     * styles.xml. Each entry references a `cellStyleXfs` index. Used
+     * primarily for round-trip preservation; consumers that want to
+     * surface a "Cell Styles" gallery can iterate this map.
+     */
+    namedCellStyles;
+    indexedColors;
+    /**
+     * The workbook theme's `<a:fontScheme>` typefaces (major = headings,
+     * minor = body), used to resolve `<font><scheme val="major|minor"/>`
+     * references that carry no concrete `<name>`. Populated after the
+     * theme part is parsed; stays `undefined` when the workbook has no
+     * theme, in which case scheme references remain unresolved (mirrors
+     * `rnc-import`'s `resolve_scheme_fonts`).
+     */
+    themeFonts;
+    constructor(styleSheet) {
+        this.styles = styleSheet ?? {};
+        const fillsNode = getWithFallback(this.styles, [
+            "fills.fill",
+            "fills.x:fill",
+            "x:fills.fill",
+            "x:fills.x:fill",
+        ]);
+        this.fills = fillsNode
+            ? Array.isArray(fillsNode)
+                ? fillsNode
+                : [fillsNode]
+            : [];
+        const numFmtsNode = getWithFallback(this.styles, [
+            "numFmts.numFmt",
+            "numFmts.x:numFmt",
+            "x:numFmts.numFmt",
+            "x:numFmts.x:numFmt",
+        ]);
+        this.numFmts = numFmtsNode
+            ? Array.isArray(numFmtsNode)
+                ? numFmtsNode
+                : [numFmtsNode]
+            : [];
+        const bordersNode = getWithFallback(this.styles, [
+            "borders.border",
+            "borders.x:border",
+            "x:borders.border",
+            "x:borders.x:border",
+        ]);
+        this.borders = bordersNode
+            ? Array.isArray(bordersNode)
+                ? bordersNode
+                : [bordersNode]
+            : [];
+        const cellXfsNode = getWithFallback(this.styles, [
+            "cellXfs.xf",
+            "cellXfs.x:xf",
+            "x:cellXfs.xf",
+            "x:cellXfs.x:xf",
+        ]);
+        this.cellXfs = cellXfsNode
+            ? Array.isArray(cellXfsNode)
+                ? cellXfsNode
+                : [cellXfsNode]
+            : [];
+        const cellStyleXfsNode = getWithFallback(this.styles, [
+            "cellStyleXfs.xf",
+            "cellStyleXfs.x:xf",
+            "x:cellStyleXfs.xf",
+            "x:cellStyleXfs.x:xf",
+        ]);
+        this.cellStyleXfs = cellStyleXfsNode
+            ? Array.isArray(cellStyleXfsNode)
+                ? cellStyleXfsNode
+                : [cellStyleXfsNode]
+            : [];
+        const fontsNode = getWithFallback(this.styles, [
+            "fonts.font",
+            "fonts.x:font",
+            "x:fonts.font",
+            "x:fonts.x:font",
+        ]);
+        this.fonts = fontsNode
+            ? Array.isArray(fontsNode)
+                ? fontsNode
+                : [fontsNode]
+            : [];
+        // Parse differential formatting (used by conditional formatting and table styles)
+        const dxfsNode = getWithFallback(this.styles, [
+            "dxfs.dxf",
+            "dxfs.x:dxf",
+            "x:dxfs.dxf",
+            "x:dxfs.x:dxf",
+        ]);
+        this.dxfs = dxfsNode
+            ? Array.isArray(dxfsNode)
+                ? dxfsNode
+                : [dxfsNode]
+            : [];
+        // Parse custom table styles
+        this.tableStyles = this.extractTableStyles();
+        // Parse the workbook-wide named cell styles ("Heading 1", "Accent 1",
+        // "Total", etc.) — the OOXML `<cellStyles>` block maps a friendly
+        // name to a `cellStyleXfs` entry. Used by the exporter to round-
+        // trip the named-style list. The actual formatting flows through
+        // the existing `buildEffectiveXf` inheritance path (a cell whose
+        // xf carries `xfId="N"` inherits from `cellStyleXfs[N]`).
+        this.namedCellStyles = this.extractNamedCellStyles();
+        this.indexedColors = this.extractIndexedColors();
+    }
+    /**
+     * Extract custom table styles from styles.xml
+     * Returns a map of style name -> tableStyleElements
+     */
+    extractTableStyles() {
+        const result = new Map();
+        const tableStylesNode = getWithFallback(this.styles, [
+            "tableStyles.tableStyle",
+            "tableStyles.x:tableStyle",
+            "x:tableStyles.tableStyle",
+            "x:tableStyles.x:tableStyle",
+        ]);
+        if (!tableStylesNode)
+            return result;
+        const stylesArray = Array.isArray(tableStylesNode)
+            ? tableStylesNode
+            : [tableStylesNode];
+        for (const style of stylesArray) {
+            const name = style.a$?.name;
+            if (!name)
+                continue;
+            // Get tableStyleElements
+            const elementsNode = getWithFallback(style, [
+                "tableStyleElement",
+                "x:tableStyleElement",
+            ]);
+            const elements = elementsNode
+                ? Array.isArray(elementsNode)
+                    ? elementsNode
+                    : [elementsNode]
+                : [];
+            result.set(name, {
+                name,
+                // Preserve the raw `pivot` attribute so the exporter can flag
+                // a style as pivot-targeted on round-trip. Excel sets
+                // `pivot="0"` to mean the style applies to tables only;
+                // `pivot="1"` for pivot tables.
+                pivot: style.a$?.pivot === "1" || style.a$?.pivot === "true" || false,
+                elements,
+            });
+        }
+        return result;
+    }
+    /**
+     * Parse the `<cellStyles>` block from styles.xml — each `<cellStyle>`
+     * is a name + xfId (pointing into `cellStyleXfs`) plus optional
+     * builtinId / iLevel / hidden / customBuiltin attributes.
+     */
+    extractNamedCellStyles() {
+        const node = getWithFallback(this.styles, [
+            "cellStyles.cellStyle",
+            "cellStyles.x:cellStyle",
+            "x:cellStyles.cellStyle",
+            "x:cellStyles.x:cellStyle",
+        ]);
+        if (!node)
+            return [];
+        const styles = Array.isArray(node) ? node : [node];
+        const out = [];
+        for (const s of styles) {
+            const attrs = s.a$ ?? {};
+            const name = attrs.name;
+            if (!name)
+                continue;
+            const xfIdRaw = attrs.xfId;
+            const xfId = xfIdRaw != null ? parseInt(xfIdRaw) : 0;
+            if (Number.isNaN(xfId))
+                continue;
+            const entry = {
+                name: String(name),
+                xfId,
+            };
+            if (attrs.builtinId != null) {
+                const bi = parseInt(attrs.builtinId);
+                if (!Number.isNaN(bi))
+                    entry.builtinId = bi;
+            }
+            if (attrs.iLevel != null) {
+                const il = parseInt(attrs.iLevel);
+                if (!Number.isNaN(il))
+                    entry.iLevel = il;
+            }
+            if (attrs.hidden === "1" || attrs.hidden === "true") {
+                entry.hidden = true;
+            }
+            if (attrs.customBuiltin === "1" || attrs.customBuiltin === "true") {
+                entry.customBuiltin = true;
+            }
+            out.push(entry);
+        }
+        return out;
+    }
+    /**
+     * Get banded definition for a custom table style
+     */
+    getCustomTableStyleBanding(styleName) {
+        const style = this.tableStyles.get(styleName);
+        if (!style)
+            return undefined;
+        const bandedDef = {
+            rowProperties: {},
+            columnProperties: {},
+        };
+        for (const element of style.elements) {
+            const type = element.a$?.type;
+            const dxfId = element.a$?.dxfId;
+            if (type === undefined || dxfId === undefined)
+                continue;
+            const dxfIndex = parseInt(dxfId);
+            if (isNaN(dxfIndex) || dxfIndex < 0 || dxfIndex >= this.dxfs.length) {
+                continue;
+            }
+            const dxf = this.dxfs[dxfIndex];
+            const color = this.extractDxfColor(dxf);
+            // Map tableStyleElement types to bandedDefinition properties
+            switch (type) {
+                case "headerRow":
+                    if (color)
+                        bandedDef.rowProperties.headerColor = color;
+                    break;
+                case "totalRow":
+                    if (color)
+                        bandedDef.rowProperties.totalRowColor = color;
+                    break;
+                case "firstRowStripe":
+                    if (color)
+                        bandedDef.rowProperties.firstBandColor = color;
+                    break;
+                case "secondRowStripe":
+                    if (color)
+                        bandedDef.rowProperties.secondBandColor = color;
+                    break;
+                case "firstColumnStripe":
+                    if (color)
+                        bandedDef.columnProperties.firstBandColor = color;
+                    break;
+                case "secondColumnStripe":
+                    if (color)
+                        bandedDef.columnProperties.secondBandColor = color;
+                    break;
+            }
+        }
+        // Only return if we found any properties
+        const hasRowProps = Object.keys(bandedDef.rowProperties).length > 0;
+        const hasColProps = Object.keys(bandedDef.columnProperties).length > 0;
+        if (!hasRowProps && !hasColProps)
+            return undefined;
+        if (!hasRowProps)
+            delete bandedDef.rowProperties;
+        if (!hasColProps)
+            delete bandedDef.columnProperties;
+        return bandedDef;
+    }
+    /**
+     * Walk every custom table style and return a self-contained
+     * representation where each element carries its resolved dxf
+     * format (so the exporter can re-register the dxfs into its own
+     * table without keeping a back-reference to this WorkbookStyles
+     * instance). Used for `customTableStyles` round-trip — the OOXML
+     * tableStyle name + element list survives a save with the same
+     * banding colors / font overrides.
+     */
+    getCustomTableStyleExports() {
+        const out = [];
+        for (const [name, style] of this.tableStyles) {
+            const pivot = !!style.pivot;
+            const elements = [];
+            for (const element of style.elements ?? []) {
+                const attrs = element.a$ ?? {};
+                const type = attrs.type;
+                const dxfIdRaw = attrs.dxfId;
+                if (!type || dxfIdRaw == null)
+                    continue;
+                const dxfIndex = parseInt(dxfIdRaw);
+                if (isNaN(dxfIndex) ||
+                    dxfIndex < 0 ||
+                    dxfIndex >= this.dxfs.length) {
+                    continue;
+                }
+                const dxf = this.dxfs[dxfIndex];
+                const entry = { type };
+                const sizeRaw = attrs.size;
+                if (sizeRaw != null) {
+                    const size = parseInt(sizeRaw);
+                    if (!isNaN(size))
+                        entry.size = size;
+                }
+                const bg = this.extractDxfColor(dxf);
+                if (bg)
+                    entry.backgroundColor = bg;
+                const font = dxf?.font || dxf?.["x:font"];
+                if (font) {
+                    // Font color — first <color> child inside <font>.
+                    const colorNode = font.color || font["x:color"];
+                    if (colorNode) {
+                        const fAttrs = colorNode.a$ ?? colorNode;
+                        if (fAttrs.theme !== undefined) {
+                            const theme = parseInt(fAttrs.theme);
+                            const tint = fAttrs.tint ? parseFloat(fAttrs.tint) : undefined;
+                            entry.textColor = { theme, tint };
+                        }
+                        else if (fAttrs.rgb) {
+                            const rgb = fAttrs.rgb;
+                            entry.textColor =
+                                rgb.length === 8 ? "#" + rgb.slice(2) : "#" + rgb;
+                        }
+                    }
+                    if (font.b !== undefined || font["x:b"] !== undefined) {
+                        entry.bold = true;
+                    }
+                    if (font.i !== undefined || font["x:i"] !== undefined) {
+                        entry.italic = true;
+                    }
+                }
+                // Skip elements that contribute nothing — keeps the output
+                // clean when a dxf has only properties we don't yet extract
+                // (borders, alignment, etc.).
+                if (!entry.backgroundColor &&
+                    !entry.textColor &&
+                    !entry.bold &&
+                    !entry.italic &&
+                    entry.size == null) {
+                    continue;
+                }
+                elements.push(entry);
+            }
+            if (elements.length === 0)
+                continue;
+            out.push({ name, ...(pivot ? { pivot: true } : {}), elements });
+        }
+        return out;
+    }
+    /**
+     * Extract color from dxf fill
+     */
+    extractDxfColor(dxf) {
+        const fill = dxf?.fill || dxf?.["x:fill"];
+        if (!fill)
+            return undefined;
+        const patternFill = fill.patternFill || fill["x:patternFill"];
+        if (!patternFill)
+            return undefined;
+        // Try bgColor first, then fgColor
+        const colorNode = patternFill.bgColor ||
+            patternFill["x:bgColor"] ||
+            patternFill.fgColor ||
+            patternFill["x:fgColor"];
+        if (!colorNode)
+            return undefined;
+        const attrs = colorNode.a$ || colorNode;
+        // Handle theme color
+        if (attrs.theme !== undefined) {
+            const theme = parseInt(attrs.theme);
+            const tint = attrs.tint ? parseFloat(attrs.tint) : undefined;
+            return { theme, tint };
+        }
+        // Handle RGB color
+        if (attrs.rgb) {
+            const rgb = attrs.rgb;
+            // Convert ARGB to #RGB
+            if (rgb.length === 8) {
+                return "#" + rgb.slice(2);
+            }
+            return "#" + rgb;
+        }
+        // Handle indexed color
+        if (attrs.indexed !== undefined) {
+            const idx = parseInt(attrs.indexed);
+            if (this.indexedColors && this.indexedColors[idx]) {
+                return this.indexedColors[idx];
+            }
+        }
+        return undefined;
+    }
+    static async load(zipParser, xmlParser) {
+        try {
+            const content = await zipParser.getText("xl/styles.xml");
+            const xmlContent = xmlParser.parse(content);
+            const styleSheet = getWithFallback(xmlContent, [
+                "styleSheet",
+                "x:styleSheet",
+            ]);
+            return new WorkbookStyles(styleSheet);
+        }
+        catch {
+            // Some XLSM/XLSX files omit styles.xml or include malformed style sheets.
+            // Continue with empty defaults instead of crashing import.
+            return new WorkbookStyles({});
+        }
+    }
+    getFont(fontId) {
+        return this.fonts[fontId];
+    }
+    getFill(fillId) {
+        return this.fills[fillId];
+    }
+    getCellXfs(styleIndex) {
+        return this.cellXfs[styleIndex];
+    }
+    getCellStyleXf(xfId) {
+        return this.cellStyleXfs[xfId];
+    }
+    extractIndexedColors() {
+        const indexedColorsNode = getWithFallback(this.styles, [
+            "colors.indexedColors.rgbColor",
+            "colors.indexedColors.x:rgbColor",
+            "x:colors.x:indexedColors.x:rgbColor",
+            "x:colors.indexedColors.rgbColor",
+        ]);
+        if (!indexedColorsNode) {
+            return undefined;
+        }
+        const indexedColorsArray = Array.isArray(indexedColorsNode)
+            ? indexedColorsNode
+            : [indexedColorsNode];
+        const colors = indexedColorsArray.map((entry) => {
+            const rgb = (typeof entry?.a$?.rgb === "string" && entry.a$.rgb) ||
+                (typeof entry?.rgb === "string" && entry.rgb);
+            if (!rgb) {
+                return undefined;
+            }
+            const normalized = rgb.trim();
+            if (normalized.length === 8) {
+                return "#" + normalized.slice(2);
+            }
+            if (normalized.length === 6) {
+                return "#" + normalized;
+            }
+            return undefined;
+        });
+        return colors.length > 0 ? colors : undefined;
+    }
+}
+/**
+ * Bounds for materializing row/column default styles as phantom cells.
+ * Excel paints `<row customFormat="1" s="N">` and `<col style="N">` across
+ * the entire row/column, but the sheet model has no row/column format slot,
+ * so the importer writes format-only cells instead — clamped to the sheet's
+ * used column extent (never past MAX_COLUMNS) with a per-sheet cell budget
+ * so a catch-all `<col min="1" max="16384" style="N">` on a million-row
+ * sheet can't explode memory.
+ */
+const STYLE_MATERIALIZE_MAX_COLUMNS = 4096;
+const STYLE_MATERIALIZE_CELL_BUDGET = 200_000;
+/** The namespace marker identifying a `customXml` item as a Power Query DataMashup part. */
+const DATA_MASHUP_MARKER = "schemas.microsoft.com/DataMashup";
+/**
+ * Resolve a relationship `Target` (relative to the directory of the part that owns the rels)
+ * into a package-absolute part name, normalizing `.`/`..` segments. A leading `/` is
+ * package-absolute (e.g. base `xl` + `../customXml/item1.xml` → `customXml/item1.xml`).
+ */
+const resolveRelTarget = (baseDir, target) => {
+    if (target.startsWith("/")) {
+        return target.substring(1);
+    }
+    const parts = baseDir ? baseDir.split("/") : [];
+    for (const segment of target.split("/")) {
+        if (segment === "" || segment === ".")
+            continue;
+        if (segment === "..") {
+            parts.pop();
+        }
+        else {
+            parts.push(segment);
+        }
+    }
+    return parts.join("/");
+};
+/** `xl/tables/table1.xml` → `xl/tables/_rels/table1.xml.rels`. */
+const relsPathFor = (part) => {
+    const slash = part.lastIndexOf("/");
+    return slash === -1
+        ? `_rels/${part}.rels`
+        : `${part.substring(0, slash)}/_rels/${part.substring(slash + 1)}.rels`;
+};
+/** The directory of a part name (`xl/tables/table1.xml` → `xl/tables`). */
+const dirOf = (part) => {
+    const slash = part.lastIndexOf("/");
+    return slash === -1 ? "" : part.substring(0, slash);
+};
+export class XlsxPlugin extends BaseWorkbookPlugin {
+    zipParser;
+    xmlParser;
+    theme;
+    sharedStrings;
+    /**
+     * Per-shared-string-index runs captured from `<si><r>...</r></si>`.
+     * Only present for entries that actually carry rich-text segments.
+     * Populated by `loadSharedStrings`; consumed by `styles.ts` to set
+     * `tf` on cells whose `ss` points at a rich entry.
+     */
+    richSharedStringRuns;
+    sharedFormulaMap;
+    workbookStyles;
+    relations;
+    cellXfs;
+    fonts;
+    namedRanges;
+    xmlPreserveValueParser;
+    sheetCommentsCache;
+    sheetThreadedCommentsCache;
+    /** Lazy `xl/persons/person.xml` parse, shared by every sheet's threads. */
+    personsPromise = null;
+    workbookXml;
+    workSheets = [];
+    calcPr;
+    workbookPr;
+    currentSheetTotalRows;
+    /**
+     * Per-sheet feature presence recorded during the hyperlink SAX pass.
+     * Lets the post-row extractors skip their full-DOM `getSheetData` parse
+     * (prohibitively large on big worksheets) when a sheet has none of the
+     * relevant elements. Absent entry ⇒ unknown ⇒ extractors parse as before.
+     */
+    sheetFeatures = new Map();
+    /**
+     * Single-entry memo for `getSheetData`: consecutive extractor calls for
+     * the same sheet reuse one parsed DOM instead of re-decompressing and
+     * re-parsing the worksheet XML per extractor. Bounded to one sheet so a
+     * multi-sheet workbook never retains more than one worksheet DOM.
+     */
+    lastSheetDataCache = null;
+    /** workbook.xml sheet elements indexed by sheetId (sheet-scoped API). */
+    worksheetBySheetId = new Map();
+    /**
+     * Per-rid memo for `getSheetMetadata` so `getSheet` + a subsequent
+     * per-sheet row stream scan the worksheet XML once. Entries are deleted
+     * as soon as their consumer finishes (metadata holds a per-row entries
+     * map, which is not small on dense sheets), so the eager all-sheet path
+     * never accumulates more than one sheet's metadata.
+     */
+    sheetMetadataCache = new Map();
+    /**
+     * Per-sheet memo for data validations. Rule ids are minted per parse
+     * (`uuid()`), and the row stream stamps those ids onto covered cells — so
+     * the stamping pass and the `getDataValidations()` consumers MUST observe
+     * the SAME parse or the per-cell references dangle. The workbook-wide
+     * `getDataValidations()` aggregates these per-sheet caches, keeping ids
+     * stable across per-sheet and workbook-wide callers.
+     */
+    dataValidationsBySheetCache = new Map();
+    /** Per-sheet memo for conditional formatting, mirroring the DV cache. */
+    conditionalFormattingBySheetCache = new Map();
+    buildMergeRangesByRow(merges) {
+        const rangesByRow = new Map();
+        for (const range of merges) {
+            for (let row = range.startRowIndex; row <= range.endRowIndex; row++) {
+                const rowRanges = rangesByRow.get(row);
+                if (rowRanges) {
+                    rowRanges.push(range);
+                }
+                else {
+                    rangesByRow.set(row, [range]);
+                }
+            }
+        }
+        return rangesByRow;
+    }
+    getSheetMetadata(rid) {
+        let cached = this.sheetMetadataCache.get(rid);
+        if (!cached) {
+            cached = this.parseSheetMetadata(rid);
+            this.sheetMetadataCache.set(rid, cached);
+        }
+        return cached;
+    }
+    async parseSheetMetadata(rid) {
+        const path = this.getSheetPathByRid(rid);
+        const merges = [];
+        const rowEntries = new Map();
+        let outlineSummaryBelow;
+        let outlineSummaryRight;
+        const columnMetadata = {};
+        const colStyleRanges = [];
+        let maxRowIndex = 0;
+        let maxColumnIndex = 0;
+        let dimensionRange;
+        let sheetHasFilterMode = false;
+        let zeroHeight = false;
+        let defaultRowHeightPx;
+        let defaultColumnWidthPx;
+        let sheetViewAttrs;
+        let paneAttrs;
+        let tabColor;
+        let autoFilterRef;
+        const filterColumns = new Map();
+        const getOrCreateFilterColumn = (colId) => {
+            let entry = filterColumns.get(colId);
+            if (!entry) {
+                entry = { visibleValues: [] };
+                filterColumns.set(colId, entry);
+            }
+            return entry;
+        };
+        let currentFilterColumn = null;
+        const tablePartIds = [];
+        // ECMA-376 makes row/@r and c/@r optional (streaming writers omit them);
+        // when absent, position = previous + 1. Track sequential fallbacks so
+        // r-less sheets still report real extents instead of 0.
+        let lastScannedRowIndex = 0;
+        let scanSeqColIndex = 1;
+        const normalizeTag = (name) => name.includes(":") ? name.split(":")[1] : name;
+        const parser = new HtmlParser({
+            onopentag(tagName, attrs) {
+                const name = normalizeTag(tagName);
+                if (name === "dimension") {
+                    const ref = attrs?.ref;
+                    if (typeof ref === "string") {
+                        dimensionRange = getRangeFromAddressRef(ref);
+                    }
+                }
+                if (name === "sheetPr") {
+                    sheetHasFilterMode =
+                        attrs?.filterMode === "1" || attrs?.filterMode === "true";
+                }
+                // <outlinePr summaryBelow summaryRight/> lives inside sheetPr;
+                // it's a sibling element, so it surfaces here as its own event.
+                if (name === "outlinePr") {
+                    if (attrs?.summaryBelow !== undefined) {
+                        outlineSummaryBelow =
+                            attrs.summaryBelow === "1" || attrs.summaryBelow === "true";
+                    }
+                    if (attrs?.summaryRight !== undefined) {
+                        outlineSummaryRight =
+                            attrs.summaryRight === "1" || attrs.summaryRight === "true";
+                    }
+                }
+                if (name === "sheetFormatPr") {
+                    zeroHeight =
+                        attrs?.zeroHeight === "1" || attrs?.zeroHeight === "true";
+                    // OOXML row heights are in points; cells / row metadata in this
+                    // codebase are pixels. 1pt = 96/72 px = 1.333…px.
+                    if (attrs?.defaultRowHeight !== undefined) {
+                        const pts = parseFloat(attrs.defaultRowHeight);
+                        if (Number.isFinite(pts) && pts > 0) {
+                            defaultRowHeightPx = pts * 1.33;
+                        }
+                    }
+                    // OOXML column widths are in characters; convert through the
+                    // same helper used for individual column widths.
+                    if (attrs?.defaultColWidth !== undefined) {
+                        const chars = parseFloat(attrs.defaultColWidth);
+                        if (Number.isFinite(chars) && chars > 0) {
+                            defaultColumnWidthPx = excelColumnWidthToPixels(chars);
+                        }
+                    }
+                }
+                if (name === "tabColor") {
+                    tabColor = { a$: { ...attrs } };
+                }
+                if (name === "sheetView" && !sheetViewAttrs) {
+                    sheetViewAttrs = { ...attrs };
+                }
+                if (name === "pane" && sheetViewAttrs && !paneAttrs) {
+                    paneAttrs = { ...attrs };
+                }
+                if (name === "cols") {
+                    return;
+                }
+                if (name === "col") {
+                    const min = parseInt(attrs.min ?? "0", 10);
+                    const max = parseInt(attrs.max ?? "0", 10);
+                    // Column default style: cells in these columns without an
+                    // explicit `s` (including cells never written to the XML)
+                    // inherit this xf. Collected separately from DimensionProperties
+                    // (which has no format slot) and materialized onto cells during
+                    // processSheetData.
+                    const colStyleIndex = attrs.style
+                        ? parseInt(attrs.style, 10)
+                        : NaN;
+                    if (Number.isFinite(colStyleIndex) && colStyleIndex > 0) {
+                        colStyleRanges.push({ min, max, styleIndex: colStyleIndex });
+                    }
+                    const isHidden = attrs.hidden === "1" || attrs.hidden === "true";
+                    const size = attrs.width !== undefined
+                        ? excelColumnWidthToPixels(parseFloat(attrs.width))
+                        : undefined;
+                    const customWidth = attrs.customWidth === "1" ||
+                        attrs.custom === "1" ||
+                        attrs.customWidth === "true";
+                    const outlineLevel = attrs.outlineLevel
+                        ? parseInt(attrs.outlineLevel, 10) || 0
+                        : 0;
+                    const isCollapsed = attrs.collapsed === "1" || attrs.collapsed === "true";
+                    if (!isHidden &&
+                        isNil(size) &&
+                        !customWidth &&
+                        outlineLevel === 0 &&
+                        !isCollapsed) {
+                        return;
+                    }
+                    for (let columnIndex = min; columnIndex <= max; columnIndex++) {
+                        const dimensionProps = {};
+                        // `hidden` on a grouped column means it's hidden because
+                        // its parent group is collapsed — route into hiddenByGroup
+                        // so a future "Expand" can clear it without touching any
+                        // separate user-driven hide.
+                        if (isHidden) {
+                            if (outlineLevel > 0) {
+                                dimensionProps.hiddenByGroup = true;
+                            }
+                            else {
+                                dimensionProps.hiddenByUser = true;
+                            }
+                        }
+                        if (!isNil(size)) {
+                            if (customWidth) {
+                                dimensionProps.resizedByUser = true;
+                            }
+                            dimensionProps.size = size;
+                        }
+                        if (outlineLevel > 0) {
+                            dimensionProps.outlineLevel = outlineLevel;
+                        }
+                        if (isCollapsed)
+                            dimensionProps.collapsed = true;
+                        columnMetadata[columnIndex] = dimensionProps;
+                    }
+                }
+                if (name === "row") {
+                    const parsedRowIndex = parseInt(attrs.r ?? "0", 10);
+                    const rowIndex = parsedRowIndex > 0 ? parsedRowIndex : lastScannedRowIndex + 1;
+                    lastScannedRowIndex = rowIndex;
+                    scanSeqColIndex = 1;
+                    if (rowIndex) {
+                        maxRowIndex = Math.max(maxRowIndex, rowIndex);
+                        const isHidden = attrs.hidden === "1" || attrs.hidden === "true";
+                        const size = attrs.ht ? parseFloat(attrs.ht) * 1.33 : undefined;
+                        const customHeight = attrs.customHeight === "1" ||
+                            attrs.custom === "1" ||
+                            attrs.customHeight === "true";
+                        const outlineLevel = attrs.outlineLevel
+                            ? parseInt(attrs.outlineLevel, 10) || 0
+                            : 0;
+                        const isCollapsed = attrs.collapsed === "1" || attrs.collapsed === "true";
+                        rowEntries.set(rowIndex, {
+                            hidden: isHidden,
+                            size,
+                            custom: customHeight,
+                            outlineLevel: outlineLevel > 0 ? outlineLevel : undefined,
+                            collapsed: isCollapsed ? true : undefined,
+                        });
+                    }
+                }
+                if (name === "c") {
+                    const cellRef = attrs.r;
+                    if (typeof cellRef === "string") {
+                        const colStr = cellRef.replace(/[0-9]/g, "");
+                        const columnIndex = alpha2number(colStr);
+                        maxColumnIndex = Math.max(maxColumnIndex, columnIndex);
+                        scanSeqColIndex = columnIndex + 1;
+                    }
+                    else {
+                        maxColumnIndex = Math.max(maxColumnIndex, scanSeqColIndex);
+                        scanSeqColIndex++;
+                    }
+                }
+                if (name === "mergeCell") {
+                    const ref = attrs.ref;
+                    if (typeof ref === "string") {
+                        const range = addressToSelection(ref)?.range;
+                        if (range)
+                            merges.push(range);
+                    }
+                }
+                if (name === "autoFilter") {
+                    const ref = attrs.ref;
+                    if (typeof ref === "string") {
+                        autoFilterRef = ref;
+                    }
+                }
+                if (name === "filterColumn") {
+                    const colId = parseInt(attrs.colId ?? "0", 10);
+                    currentFilterColumn = Number.isNaN(colId) ? null : colId;
+                }
+                if (name === "filter" && currentFilterColumn !== null) {
+                    const val = attrs.val;
+                    if (typeof val === "string") {
+                        getOrCreateFilterColumn(currentFilterColumn).visibleValues.push(val);
+                    }
+                }
+                if (name === "colorFilter" && currentFilterColumn !== null) {
+                    const entry = getOrCreateFilterColumn(currentFilterColumn);
+                    const dxfIdRaw = attrs.dxfId;
+                    if (typeof dxfIdRaw === "string" && dxfIdRaw.length) {
+                        const dxfId = parseInt(dxfIdRaw, 10);
+                        if (Number.isFinite(dxfId)) {
+                            entry.colorFilterDxfId = dxfId;
+                        }
+                    }
+                    // OOXML default for cellColor is "1" (true). The attribute is
+                    // absent when defaulting, so undefined → cellColor mode.
+                    const cellColorRaw = attrs.cellColor;
+                    entry.colorFilterCellColor =
+                        cellColorRaw !== "0" && cellColorRaw !== "false";
+                }
+                if (name === "iconFilter" && currentFilterColumn !== null) {
+                    const entry = getOrCreateFilterColumn(currentFilterColumn);
+                    const iconSetRaw = attrs.iconSet;
+                    if (typeof iconSetRaw === "string" && iconSetRaw.length) {
+                        entry.iconFilterSet = iconSetRaw;
+                    }
+                    // iconId is optional in OOXML; absent means "any non-blank".
+                    // We treat absent as 0 to match Excel's default.
+                    const iconIdRaw = attrs.iconId;
+                    const iconId = typeof iconIdRaw === "string" ? parseInt(iconIdRaw, 10) : 0;
+                    entry.iconFilterId = Number.isFinite(iconId) ? iconId : 0;
+                }
+                // <customFilters and="1"> wrapping one or two <customFilter
+                // operator= val=>. Records the AND flag, then each child below.
+                if (name === "customFilters" && currentFilterColumn !== null) {
+                    const entry = getOrCreateFilterColumn(currentFilterColumn);
+                    entry.customFilters = entry.customFilters ?? [];
+                    entry.customFiltersAnd =
+                        attrs.and === "1" || attrs.and === "true";
+                }
+                if (name === "customFilter" && currentFilterColumn !== null) {
+                    const entry = getOrCreateFilterColumn(currentFilterColumn);
+                    entry.customFilters = entry.customFilters ?? [];
+                    entry.customFilters.push({
+                        operator: attrs.operator,
+                        val: attrs.val,
+                    });
+                }
+                // <dynamicFilter type="thisMonth"/> (relative dates, above/below avg)
+                if (name === "dynamicFilter" && currentFilterColumn !== null) {
+                    const entry = getOrCreateFilterColumn(currentFilterColumn);
+                    if (typeof attrs.type === "string") {
+                        entry.dynamicFilterType = attrs.type;
+                    }
+                }
+                if (name === "tablePart") {
+                    const rid = attrs["r:id"];
+                    if (typeof rid === "string") {
+                        tablePartIds.push(rid);
+                    }
+                }
+            },
+            onclosetag(tagName) {
+                const name = normalizeTag(tagName);
+                if (name === "filterColumn") {
+                    currentFilterColumn = null;
+                }
+            },
+            onerror(err) {
+                console.error("Streaming sheet metadata parse error", err);
+            },
+        }, { xmlMode: true });
+        await this.zipParser.streamText(path, (chunk) => parser.write(chunk));
+        parser.end();
+        if (dimensionRange) {
+            maxRowIndex = Math.max(maxRowIndex, dimensionRange.endRowIndex);
+            maxColumnIndex = Math.max(maxColumnIndex, dimensionRange.endColumnIndex);
+        }
+        const filterSpecs = Array.from(filterColumns.entries()).map(([columnIndex, raw]) => {
+            const criteria = {};
+            if (raw.visibleValues.length) {
+                criteria.visibleValues = raw.visibleValues;
+            }
+            if (raw.colorFilterDxfId !== undefined) {
+                const color = this.resolveDxfColor(raw.colorFilterDxfId, raw.colorFilterCellColor !== false);
+                if (color) {
+                    criteria.colorFilter = {
+                        color,
+                        mode: raw.colorFilterCellColor !== false ? "cellColor" : "fontColor",
+                    };
+                }
+            }
+            if (raw.iconFilterSet) {
+                criteria.iconFilter = {
+                    iconSet: raw.iconFilterSet,
+                    iconId: raw.iconFilterId ?? 0,
+                };
+            }
+            if (raw.customFilters?.length) {
+                const condition = customFiltersToCondition(raw.customFilters, raw.customFiltersAnd === true);
+                if (condition)
+                    criteria.condition = condition;
+            }
+            else if (raw.dynamicFilterType) {
+                const condition = dynamicFilterToCondition(raw.dynamicFilterType);
+                if (condition)
+                    criteria.condition = condition;
+            }
+            return { columnIndex, filterCriteria: criteria };
+        });
+        const sheetViewData = sheetViewAttrs || paneAttrs
+            ? {
+                sheetView: {
+                    a$: sheetViewAttrs ?? {},
+                    pane: { a$: paneAttrs ?? {} },
+                },
+            }
+            : undefined;
+        const autoFilterRange = autoFilterRef
+            ? getRangeFromAddressRef(autoFilterRef)
+            : undefined;
+        return {
+            merges,
+            rowEntries,
+            columnMetadata,
+            colStyleRanges,
+            maxRowIndex,
+            maxColumnIndex,
+            autoFilterRange,
+            filterSpecs,
+            sheetViewData,
+            tabColor,
+            sheetHasFilterMode,
+            zeroHeight,
+            defaultRowHeightPx,
+            defaultColumnWidthPx,
+            tablePartIds,
+            outlineSummaryBelow,
+            outlineSummaryRight,
+        };
+    }
+    /**
+     * Resolve a dxfId (differential format index, used by color filters and
+     * conditional formatting) to a hex color string. When `cellColor` is
+     * true the dxf's fill color is returned; otherwise the font color.
+     * Returns undefined when the dxfId is out of range or the dxf has no
+     * matching color in the requested layer.
+     */
+    resolveDxfColor(dxfId, cellColor) {
+        const dxfs = get(this.workbookStyles?.styles, "dxfs.dxf") ?? [];
+        const dxfsArray = Array.isArray(dxfs) ? dxfs : [dxfs];
+        if (dxfId < 0 || dxfId >= dxfsArray.length)
+            return undefined;
+        const dxf = dxfsArray[dxfId];
+        if (!dxf)
+            return undefined;
+        const indexedColors = this.workbookStyles?.indexedColors;
+        if (cellColor) {
+            // Excel's color filter uses the fill's foreground (fgColor) for the
+            // solid-pattern case, but historically fgColor and bgColor have been
+            // used interchangeably across writers. Try both.
+            const patternFill = dxf.fill?.patternFill ?? dxf.fill;
+            const colorNode = patternFill?.fgColor ?? patternFill?.bgColor;
+            if (!colorNode)
+                return undefined;
+            const color = extractColor(colorNode, indexedColors);
+            return typeof color === "string" ? color : color?.toString?.();
+        }
+        const colorNode = dxf.font?.color;
+        if (!colorNode)
+            return undefined;
+        const color = extractColor(colorNode, indexedColors);
+        return typeof color === "string" ? color : color?.toString?.();
+    }
+    /**
+     * Get the maximum column and row indices covered by drawings (charts, images, etc.)
+     * This is used to extend sheet dimensions when drawings extend beyond cell data bounds.
+     * @param rid Sheet relationship ID
+     * @returns Object with maxColumnIndex and maxRowIndex from drawings
+     */
+    async getDrawingBounds(rid) {
+        const DEFAULT_COLUMN_WIDTH_PX = 100;
+        const DEFAULT_ROW_HEIGHT_PX = 21;
+        let maxColumnIndex = 0;
+        let maxRowIndex = 0;
+        try {
+            const relation = this.relations[rid];
+            if (!relation) {
+                return { maxColumnIndex, maxRowIndex };
+            }
+            const sheetPath = this.resolveSheetPath(relation.target);
+            const sheetRelPath = sheetPath.replace("worksheets", "worksheets/_rels") + ".rels";
+            const sheetRelContent = await this.zipParser.getText(sheetRelPath);
+            if (!sheetRelContent) {
+                return { maxColumnIndex, maxRowIndex };
+            }
+            const sheetRels = this.xmlParser.parse(sheetRelContent);
+            const relationships = get(sheetRels, "Relationships.Relationship");
+            if (!relationships) {
+                return { maxColumnIndex, maxRowIndex };
+            }
+            const relArray = Array.isArray(relationships)
+                ? relationships
+                : [relationships];
+            // Find drawing relationships
+            const drawingRels = relArray.filter((rel) => rel.a$?.Target?.includes("drawing") ||
+                rel.a$?.Type?.includes("drawing"));
+            for (const drawingRel of drawingRels) {
+                let drawingPath = drawingRel.a$.Target;
+                if (drawingPath.startsWith("../")) {
+                    drawingPath = `xl/${drawingPath.replace("../", "")}`;
+                }
+                else if (!drawingPath.startsWith("/")) {
+                    drawingPath = `xl/worksheets/${drawingPath}`;
+                }
+                else {
+                    drawingPath = drawingPath.startsWith("/")
+                        ? drawingPath.substring(1)
+                        : `xl/${drawingPath}`;
+                }
+                const drawingContent = await this.zipParser.getText(drawingPath);
+                if (!drawingContent)
+                    continue;
+                const drawing = this.xmlParser.parse(drawingContent);
+                // Process twoCellAnchor - these have explicit "to" cell positions
+                const twoCellAnchors = get(drawing, "xdr:wsDr.xdr:twoCellAnchor") ||
+                    get(drawing, "wsDr.twoCellAnchor");
+                if (twoCellAnchors) {
+                    const anchorArray = Array.isArray(twoCellAnchors)
+                        ? twoCellAnchors
+                        : [twoCellAnchors];
+                    for (const anchor of anchorArray) {
+                        // For twoCellAnchor, the "to" cell defines the end position directly
+                        const toCol = parseInt(get(anchor, "xdr:to.xdr:col.t$") ||
+                            get(anchor, "to.col.t$") ||
+                            get(anchor, "xdr:to.xdr:col") ||
+                            get(anchor, "to.col") ||
+                            "0");
+                        const toRow = parseInt(get(anchor, "xdr:to.xdr:row.t$") ||
+                            get(anchor, "to.row.t$") ||
+                            get(anchor, "xdr:to.xdr:row") ||
+                            get(anchor, "to.row") ||
+                            "0");
+                        // Convert from 0-based XML to 1-based and add 1 for the cell itself
+                        const endColumn = toCol + 2;
+                        const endRow = toRow + 2;
+                        maxColumnIndex = Math.max(maxColumnIndex, endColumn);
+                        maxRowIndex = Math.max(maxRowIndex, endRow);
+                    }
+                }
+                // Process oneCellAnchor - these have extent (size) in EMUs
+                const oneCellAnchors = get(drawing, "xdr:wsDr.xdr:oneCellAnchor") ||
+                    get(drawing, "wsDr.oneCellAnchor");
+                if (oneCellAnchors) {
+                    const anchorArray = Array.isArray(oneCellAnchors)
+                        ? oneCellAnchors
+                        : [oneCellAnchors];
+                    for (const anchor of anchorArray) {
+                        // Get anchor cell position (0-based in XML)
+                        const fromCol = parseInt(get(anchor, "xdr:from.xdr:col.t$") ||
+                            get(anchor, "from.col.t$") ||
+                            get(anchor, "xdr:from.xdr:col") ||
+                            get(anchor, "from.col") ||
+                            "0");
+                        const fromRow = parseInt(get(anchor, "xdr:from.xdr:row.t$") ||
+                            get(anchor, "from.row.t$") ||
+                            get(anchor, "xdr:from.xdr:row") ||
+                            get(anchor, "from.row") ||
+                            "0");
+                        // Get extent (size) in EMUs and convert to pixels
+                        const EMU_PER_PIXEL = 9525;
+                        const cxEmu = parseInt(get(anchor, "xdr:ext.a$.cx") ||
+                            get(anchor, "ext.a$.cx") ||
+                            get(anchor, "xdr:pic.xdr:spPr.a:xfrm.a:ext.a$.cx") ||
+                            get(anchor, "pic.spPr.xfrm.ext.a$.cx") ||
+                            "0");
+                        const cyEmu = parseInt(get(anchor, "xdr:ext.a$.cy") ||
+                            get(anchor, "ext.a$.cy") ||
+                            get(anchor, "xdr:pic.xdr:spPr.a:xfrm.a:ext.a$.cy") ||
+                            get(anchor, "pic.spPr.xfrm.ext.a$.cy") ||
+                            "0");
+                        const widthPx = Math.round(cxEmu / EMU_PER_PIXEL);
+                        const heightPx = Math.round(cyEmu / EMU_PER_PIXEL);
+                        // Calculate columns and rows spanned
+                        const columnsSpanned = Math.ceil(widthPx / DEFAULT_COLUMN_WIDTH_PX);
+                        const rowsSpanned = Math.ceil(heightPx / DEFAULT_ROW_HEIGHT_PX);
+                        // Calculate max indices (convert from 0-based XML to 1-based)
+                        const endColumn = fromCol + 1 + columnsSpanned;
+                        const endRow = fromRow + 1 + rowsSpanned;
+                        maxColumnIndex = Math.max(maxColumnIndex, endColumn);
+                        maxRowIndex = Math.max(maxRowIndex, endRow);
+                    }
+                }
+            }
+        }
+        catch {
+            // If we can't parse drawings, just return 0 bounds
+        }
+        return { maxColumnIndex, maxRowIndex };
+    }
+    async getHyperlinksForSheet(rId) {
+        const hyperlinksByRow = new Map();
+        const relation = this.relations[rId];
+        if (!relation) {
+            return hyperlinksByRow;
+        }
+        // This SAX pass already scans the whole worksheet XML, so piggyback
+        // feature detection on it: the post-row extractors (sparklines, drawings,
+        // charts, conditional formatting, data validations) each need a full
+        // fast-xml-parser DOM of the sheet — ~4.6GB transient on a 228MB
+        // worksheet — and can be skipped entirely when the sheet has none of the
+        // corresponding elements.
+        const features = {
+            extLst: false,
+            conditionalFormatting: false,
+            dataValidations: false,
+            drawing: false,
+        };
+        const sheetPath = this.resolveSheetPath(relation.target);
+        const sheetRelPath = sheetPath.replace("worksheets", "worksheets/_rels") + ".rels";
+        let sheetRelationships = {};
+        try {
+            const sheetRelContent = await this.zipParser.getText(sheetRelPath);
+            const sheetRels = this.xmlParser.parse(sheetRelContent);
+            sheetRelationships = getRelationsById(sheetRels);
+        }
+        catch {
+            sheetRelationships = {};
+        }
+        const normalizeTag = (name) => name.includes(":") ? name.split(":")[1] : name;
+        const addHyperlinkForRef = (ref, hyperlink) => {
+            if (ref.includes(":")) {
+                const range = addressToSelection(ref)?.range;
+                if (!range) {
+                    return;
+                }
+                for (let row = range.startRowIndex; row <= range.endRowIndex; row++) {
+                    const rowMap = hyperlinksByRow.get(row) ?? new Map();
+                    for (let column = range.startColumnIndex; column <= range.endColumnIndex; column++) {
+                        rowMap.set(column, hyperlink);
+                    }
+                    hyperlinksByRow.set(row, rowMap);
+                }
+                return;
+            }
+            const cellPosition = addressToCell(ref);
+            if (!cellPosition) {
+                return;
+            }
+            const rowMap = hyperlinksByRow.get(cellPosition.rowIndex) ??
+                new Map();
+            rowMap.set(cellPosition.columnIndex, hyperlink);
+            hyperlinksByRow.set(cellPosition.rowIndex, rowMap);
+        };
+        const parser = new HtmlParser({
+            onopentag(tagName, attrs) {
+                const name = normalizeTag(tagName);
+                switch (name) {
+                    case "extLst":
+                        features.extLst = true;
+                        break;
+                    case "conditionalFormatting":
+                        features.conditionalFormatting = true;
+                        break;
+                    case "dataValidations":
+                        features.dataValidations = true;
+                        break;
+                    case "drawing":
+                        features.drawing = true;
+                        break;
+                }
+                if (name !== "hyperlink") {
+                    return;
+                }
+                const ref = attrs?.ref;
+                if (typeof ref !== "string") {
+                    return;
+                }
+                const display = attrs.display;
+                const tooltip = attrs.tooltip;
+                const location = attrs.location;
+                if (typeof location === "string" && location.length) {
+                    const hyperlink = {
+                        kind: "internal",
+                        location,
+                        ...(display ? { display } : {}),
+                        ...(tooltip ? { tooltip } : {}),
+                    };
+                    addHyperlinkForRef(ref, hyperlink);
+                    return;
+                }
+                const relId = attrs["r:id"] ?? attrs.id;
+                if (typeof relId !== "string") {
+                    return;
+                }
+                const rel = sheetRelationships[relId];
+                if (!rel?.target) {
+                    return;
+                }
+                const hyperlink = {
+                    kind: "external",
+                    url: rel.target,
+                    ...(display ? { display } : {}),
+                    ...(tooltip ? { tooltip } : {}),
+                };
+                addHyperlinkForRef(ref, hyperlink);
+            },
+            onerror(err) {
+                console.error("Streaming sheet hyperlink parse error", err);
+            },
+        }, { xmlMode: true });
+        await this.zipParser.streamText(sheetPath, (chunk) => parser.write(chunk));
+        parser.end();
+        this.sheetFeatures.set(rId, features);
+        return hyperlinksByRow;
+    }
+    /**
+     * Parse sparklines from a worksheet's extLst and return a map of cell references to SPARKLINE formulas.
+     * Sparklines are stored in x14:sparklineGroups within the worksheet's extension list.
+     */
+    async getSparklinesForSheet(rId, sheetName) {
+        const sparklinesByRow = new Map();
+        // Sparklines live in the worksheet extLst; skip the full-DOM parse when
+        // the hyperlink SAX pass saw no extLst on this sheet.
+        const features = this.sheetFeatures.get(rId);
+        if (features && !features.extLst) {
+            return sparklinesByRow;
+        }
+        try {
+            const sheetData = await this.getSheetData(rId);
+            const worksheet = get(sheetData, "worksheet") || get(sheetData, "x:worksheet");
+            if (!worksheet) {
+                return sparklinesByRow;
+            }
+            // Look for extLst with sparklineGroups
+            const extList = getWithFallback(worksheet, [
+                "extLst.ext",
+                "x:extLst.x:ext",
+            ]);
+            if (!extList) {
+                return sparklinesByRow;
+            }
+            const toArray = (value) => Array.isArray(value) ? value : value ? [value] : [];
+            const extArray = toArray(extList);
+            // Find the sparkline extension (URI: {05C60535-1F16-4fd2-B633-F4F36F0B64E0})
+            for (const ext of extArray) {
+                const uri = ext?.a$?.uri;
+                if (uri !== "{05C60535-1F16-4fd2-B633-F4F36F0B64E0}") {
+                    continue;
+                }
+                // Get sparklineGroups - handle both namespaced and non-namespaced
+                const sparklineGroupsContainer = getWithFallback(ext, [
+                    "x14:sparklineGroups",
+                    "sparklineGroups",
+                ]);
+                const sparklineGroups = sparklineGroupsContainer
+                    ? getWithFallback(sparklineGroupsContainer, [
+                        "x14:sparklineGroup",
+                        "sparklineGroup",
+                    ])
+                    : undefined;
+                if (!sparklineGroups) {
+                    continue;
+                }
+                const groupsArray = toArray(sparklineGroups);
+                for (const group of groupsArray) {
+                    // Get type: line, column, or stacked (win/loss)
+                    const type = group?.a$?.type || "line";
+                    const chartType = type === "stacked" ? "winloss" : type;
+                    // Get color from colorSeries (RGB format without #). Excel
+                    // also emits sibling `<x14:colorHigh>`, `<x14:colorLow>` etc.
+                    // for the per-point highlights (max/min/first/last/negative).
+                    // The renderer + exporter both round-trip these so workbooks
+                    // that highlight columns in custom colors don't lose them.
+                    const extractColor = (paths) => {
+                        const node = getWithFallback(group, paths);
+                        const rgb = node?.a$?.rgb;
+                        return rgb ? `#${String(rgb).slice(2)}` : undefined;
+                    };
+                    const color = extractColor(["x14:colorSeries", "colorSeries"]);
+                    const colorHigh = extractColor(["x14:colorHigh", "colorHigh"]);
+                    const colorLow = extractColor(["x14:colorLow", "colorLow"]);
+                    const colorFirst = extractColor(["x14:colorFirst", "colorFirst"]);
+                    const colorLast = extractColor(["x14:colorLast", "colorLast"]);
+                    const colorMarkers = extractColor([
+                        "x14:colorMarkers",
+                        "colorMarkers",
+                    ]);
+                    const colorNegative = extractColor([
+                        "x14:colorNegative",
+                        "colorNegative",
+                    ]);
+                    // Axis / display attrs. Each maps 1:1 to a SPARKLINE option
+                    // key; the renderer + the exporter both pick them up from
+                    // the formula source.
+                    const groupAttrs = group?.a$ ?? {};
+                    const truthy = (v) => v === "1" || v === "true" || v === true;
+                    const numAttr = (v) => {
+                        if (v == null)
+                            return undefined;
+                        const n = typeof v === "number" ? v : parseFloat(v);
+                        return Number.isFinite(n) ? n : undefined;
+                    };
+                    const emptyCellsAs = groupAttrs.displayEmptyCellsAs === "zero" ||
+                        groupAttrs.displayEmptyCellsAs === "span" ||
+                        groupAttrs.displayEmptyCellsAs === "gap"
+                        ? groupAttrs.displayEmptyCellsAs
+                        : undefined;
+                    const dateAxis = truthy(groupAttrs.dateAxis) ? true : undefined;
+                    const markers = truthy(groupAttrs.markers) ? true : undefined;
+                    const high = truthy(groupAttrs.high) ? true : undefined;
+                    const low = truthy(groupAttrs.low) ? true : undefined;
+                    const first = truthy(groupAttrs.first) ? true : undefined;
+                    const last = truthy(groupAttrs.last) ? true : undefined;
+                    const negative = truthy(groupAttrs.negative) ? true : undefined;
+                    const displayXAxis = truthy(groupAttrs.displayXAxis)
+                        ? true
+                        : undefined;
+                    const displayHidden = truthy(groupAttrs.displayHidden)
+                        ? true
+                        : undefined;
+                    const rightToLeft = truthy(groupAttrs.rightToLeft)
+                        ? true
+                        : undefined;
+                    const lineWeight = numAttr(groupAttrs.lineWeight);
+                    const manualMax = numAttr(groupAttrs.manualMax);
+                    const manualMin = numAttr(groupAttrs.manualMin);
+                    const minAxisType = groupAttrs.minAxisType === "group" ||
+                        groupAttrs.minAxisType === "custom" ||
+                        groupAttrs.minAxisType === "individual"
+                        ? groupAttrs.minAxisType
+                        : undefined;
+                    const maxAxisType = groupAttrs.maxAxisType === "group" ||
+                        groupAttrs.maxAxisType === "custom" ||
+                        groupAttrs.maxAxisType === "individual"
+                        ? groupAttrs.maxAxisType
+                        : undefined;
+                    // Get sparklines container then sparkline elements
+                    const sparklinesContainer = getWithFallback(group, [
+                        "x14:sparklines",
+                        "sparklines",
+                    ]);
+                    const sparklines = sparklinesContainer
+                        ? getWithFallback(sparklinesContainer, [
+                            "x14:sparkline",
+                            "sparkline",
+                        ])
+                        : undefined;
+                    if (!sparklines) {
+                        continue;
+                    }
+                    const sparklinesArray = toArray(sparklines);
+                    for (const sparkline of sparklinesArray) {
+                        // Get data range (xm:f or f) - e.g., "Sheet1!A1:F1"
+                        // The value might be in t$ (text content) or directly as a property
+                        const dataRangeNode = sparkline?.["xm:f"] || sparkline?.f;
+                        const dataRange = typeof dataRangeNode === "string"
+                            ? dataRangeNode
+                            : dataRangeNode?.t$ || dataRangeNode;
+                        // Get cell reference (xm:sqref or sqref) - e.g., "G1"
+                        const cellRefNode = sparkline?.["xm:sqref"] || sparkline?.sqref;
+                        const cellRef = typeof cellRefNode === "string"
+                            ? cellRefNode
+                            : cellRefNode?.t$ || cellRefNode;
+                        if (!dataRange || !cellRef) {
+                            continue;
+                        }
+                        // Parse the cell reference to get row and column indices
+                        const cellPosition = addressToCell(cellRef);
+                        if (!cellPosition) {
+                            continue;
+                        }
+                        // addressToCell returns 1-indexed positions (from alpha2number)
+                        // which matches how existing cells are stored in rowData.values
+                        const rowIdx = cellPosition.rowIndex;
+                        const colIdx = cellPosition.columnIndex;
+                        // Normalize the data range - remove sheet name if it matches current sheet
+                        let normalizedRange = dataRange;
+                        if (dataRange.includes("!")) {
+                            const [rangeSheetName, rangeRef] = dataRange.split("!");
+                            // Remove quotes from sheet name if present
+                            const cleanSheetName = rangeSheetName.replace(/^'|'$/g, "");
+                            if (cleanSheetName === sheetName) {
+                                normalizedRange = rangeRef;
+                            }
+                        }
+                        // Build the SPARKLINE formula
+                        let formula = `=SPARKLINE(${normalizedRange}`;
+                        const options = [];
+                        const pushKV = (key, value) => {
+                            if (typeof value === "boolean") {
+                                options.push(`"${key}"`, value ? "TRUE" : "FALSE");
+                            }
+                            else if (typeof value === "number") {
+                                options.push(`"${key}"`, String(value));
+                            }
+                            else {
+                                options.push(`"${key}"`, `"${value}"`);
+                            }
+                        };
+                        // Option key names match `SparkLineResultOptions` so the
+                        // renderer can read them straight from `options`. The
+                        // exporter's `parseSparklineFormula` understands both these
+                        // names and the legacy `highpoint`/`lowpoint`/… aliases.
+                        if (chartType !== "line")
+                            pushKV("charttype", chartType);
+                        if (color)
+                            pushKV("color", color);
+                        if (colorHigh)
+                            pushKV("colorHigh", colorHigh);
+                        if (colorLow)
+                            pushKV("colorLow", colorLow);
+                        if (colorFirst)
+                            pushKV("colorFirst", colorFirst);
+                        if (colorLast)
+                            pushKV("colorLast", colorLast);
+                        if (colorMarkers)
+                            pushKV("colorMarkers", colorMarkers);
+                        if (colorNegative)
+                            pushKV("colorNegative", colorNegative);
+                        if (emptyCellsAs)
+                            pushKV("emptycells", emptyCellsAs);
+                        if (dateAxis)
+                            pushKV("dateaxis", true);
+                        if (markers)
+                            pushKV("markers", true);
+                        if (high)
+                            pushKV("high", true);
+                        if (low)
+                            pushKV("low", true);
+                        if (first)
+                            pushKV("first", true);
+                        if (last)
+                            pushKV("last", true);
+                        if (negative)
+                            pushKV("negative", true);
+                        if (displayXAxis)
+                            pushKV("axis", true);
+                        if (displayHidden)
+                            pushKV("displayhidden", true);
+                        if (rightToLeft)
+                            pushKV("rtl", true);
+                        if (lineWeight != null)
+                            pushKV("lineweight", lineWeight);
+                        if (manualMax != null)
+                            pushKV("max", manualMax);
+                        if (manualMin != null)
+                            pushKV("min", manualMin);
+                        if (minAxisType)
+                            pushKV("minaxistype", minAxisType);
+                        if (maxAxisType)
+                            pushKV("maxaxistype", maxAxisType);
+                        if (options.length > 0) {
+                            formula += `,{${options.join(",")}}`;
+                        }
+                        formula += ")";
+                        // Add to map with metadata for building effective value
+                        const rowMap = sparklinesByRow.get(rowIdx) ?? new Map();
+                        rowMap.set(colIdx, {
+                            formula,
+                            dataRange: normalizedRange,
+                            chartType: chartType,
+                            color,
+                            ...(colorHigh ? { colorHigh } : {}),
+                            ...(colorLow ? { colorLow } : {}),
+                            ...(colorFirst ? { colorFirst } : {}),
+                            ...(colorLast ? { colorLast } : {}),
+                            ...(colorMarkers ? { colorMarkers } : {}),
+                            ...(colorNegative ? { colorNegative } : {}),
+                            ...(emptyCellsAs ? { emptyCellsAs } : {}),
+                            ...(dateAxis ? { dateAxis } : {}),
+                            ...(markers ? { markers } : {}),
+                            ...(high ? { high } : {}),
+                            ...(low ? { low } : {}),
+                            ...(first ? { first } : {}),
+                            ...(last ? { last } : {}),
+                            ...(negative ? { negative } : {}),
+                            ...(displayXAxis ? { displayXAxis } : {}),
+                            ...(displayHidden ? { displayHidden } : {}),
+                            ...(rightToLeft ? { rightToLeft } : {}),
+                            ...(lineWeight != null ? { lineWeight } : {}),
+                            ...(manualMax != null ? { manualMax } : {}),
+                            ...(manualMin != null ? { manualMin } : {}),
+                            ...(minAxisType ? { minAxisType } : {}),
+                            ...(maxAxisType ? { maxAxisType } : {}),
+                        });
+                        sparklinesByRow.set(rowIdx, rowMap);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error("Error parsing sparklines:", error);
+        }
+        return sparklinesByRow;
+    }
+    constructor() {
+        super();
+        this.xmlParser = new XMLParser(XMLOptions2);
+        this.xmlPreserveValueParser = new XMLParser({
+            ...XMLOptions2,
+            parseTagValue: false,
+        });
+        this.zipParser = new StreamingZipParser();
+        this.sheetCommentsCache = new Map();
+        this.sheetThreadedCommentsCache = new Map();
+    }
+    async loadWorkbookXml() {
+        const data = await this.zipParser.getText("xl/workbook.xml");
+        this.workbookXml = this.xmlParser.parse(data);
+        this.workSheets = this.extractSheetsFromWorkbook(this.workbookXml);
+        this.worksheetBySheetId = new Map();
+        for (const element of this.workSheets) {
+            const sheetId = Number(element?.a$?.sheetId);
+            if (Number.isFinite(sheetId)) {
+                this.worksheetBySheetId.set(sheetId, element);
+            }
+        }
+        this.calcPr =
+            get(this.workbookXml, "workbook.calcPr") ||
+                get(this.workbookXml, "x:workbook.x:calcPr");
+        this.workbookPr =
+            get(this.workbookXml, "workbook.workbookPr") ||
+                get(this.workbookXml, "x:workbook.x:workbookPr");
+    }
+    extractSheetsFromWorkbook(workbookXml) {
+        let workSheets = get(workbookXml, "workbook.sheets.sheet") ||
+            get(workbookXml, "x:workbook.x:sheets.x:sheet");
+        workSheets = Array.isArray(workSheets) ? workSheets : [workSheets];
+        return workSheets.filter(Boolean);
+    }
+    async loadTheme() {
+        try {
+            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, majorFontFamily, minorFontFamily, } = extractThemeFonts(themeXml);
+            // Raw scheme typefaces feed `<font><scheme val>` resolution in
+            // styles.ts; absent theme fonts stay undefined (unresolved).
+            this.workbookStyles.themeFonts = {
+                major: majorFontFamily,
+                minor: minorFontFamily,
+            };
+            const themeColors = extractThemeColors(themeXml, defaultSpreadsheetTheme);
+            const darkThemeColors = generateDarkThemeColors(themeColors);
+            return {
+                name: themeName,
+                primaryFontFamily,
+                headingFontFamily,
+                themeColors,
+                darkThemeColors,
+            };
+        }
+        catch (err) {
+            return defaultSpreadsheetTheme;
+        }
+    }
+    async loadSharedStrings() {
+        try {
+            const sharedStringsData = await this.zipParser.getText("xl/sharedStrings.xml");
+            if (!sharedStringsData) {
+                this.richSharedStringRuns = new Map();
+                return [];
+            }
+            const parsedStrings = this.xmlPreserveValueParser.parse(sharedStringsData);
+            const sst = getWithFallback(parsedStrings, [
+                "sst.si",
+                "sst.x:si",
+                "x:sst.si",
+                "x:sst.x:si",
+            ]) || [];
+            const stringArray = Array.isArray(sst) ? sst : [sst];
+            const sharedStrings = new Array(stringArray.length);
+            const richRuns = new Map();
+            stringArray.forEach((item, index) => {
+                const textNode = item?.t ?? item?.["x:t"];
+                if (textNode !== undefined) {
+                    if (typeof textNode === "string") {
+                        sharedStrings[index] = textNode;
+                    }
+                    else if (textNode?.t$) {
+                        sharedStrings[index] = textNode.t$;
+                    }
+                    else {
+                        sharedStrings[index] = String(textNode);
+                    }
+                }
+                else if (item?.r || item?.["x:r"]) {
+                    const richNode = item.r ?? item["x:r"];
+                    const partsArray = Array.isArray(richNode) ? richNode : [richNode];
+                    // Build both the flattened text AND the per-run format
+                    // metadata so the cell can carry `tf` back into the model.
+                    let runningIndex = 0;
+                    const runs = [];
+                    const concatenated = partsArray
+                        .map((part) => {
+                        const text = extractRunText(part);
+                        if (!text)
+                            return "";
+                        const format = extractRunFormat(part);
+                        const startIndex = runningIndex;
+                        runningIndex += text.length;
+                        if (format && hasAnyFormatKey(format)) {
+                            runs.push({
+                                startIndex,
+                                endIndex: runningIndex,
+                                format,
+                                nodeType: "text",
+                            });
+                        }
+                        return text;
+                    })
+                        .join("");
+                    sharedStrings[index] = concatenated;
+                    if (runs.length > 0) {
+                        richRuns.set(index, runs);
+                    }
+                }
+                else {
+                    sharedStrings[index] = "";
+                }
+            });
+            this.richSharedStringRuns = richRuns;
+            return sharedStrings;
+        }
+        catch (err) {
+            this.richSharedStringRuns = new Map();
+            return [];
+        }
+    }
+    async load(buffer, password) {
+        await this.zipParser.load(buffer, password);
+        this.sharedFormulaMap = new Map();
+        this.sheetCommentsCache.clear();
+        this.sheetThreadedCommentsCache.clear();
+        this.personsPromise = null;
+        this.sheetFeatures.clear();
+        this.lastSheetDataCache = null;
+        this.sheetMetadataCache.clear();
+        this.dataValidationsBySheetCache.clear();
+        this.conditionalFormattingBySheetCache.clear();
+        await this.loadWorkbookXml();
+        this.relations = await this.getRelations();
+        this.workbookStyles = await WorkbookStyles.load(this.zipParser, this.xmlParser);
+        this.theme = await this.loadTheme();
+        this.sharedStrings = await this.loadSharedStrings();
+        this.cellXfs = new Map();
+        this.fonts = this.getFonts();
+        this.namedRanges = this._getNamedRanges();
+    }
+    dispose() {
+        void this.zipParser.dispose();
+        this.sheetCommentsCache.clear();
+        this.sheetThreadedCommentsCache.clear();
+        this.personsPromise = null;
+        this.sheetFeatures.clear();
+        this.lastSheetDataCache = null;
+        this.sheetMetadataCache.clear();
+        this.dataValidationsBySheetCache.clear();
+        this.conditionalFormattingBySheetCache.clear();
+        this.worksheetBySheetId.clear();
+    }
+    clearSharedFormula() {
+        if (!this.sharedFormulaMap) {
+            this.sharedFormulaMap = new Map();
+        }
+        this.sharedFormulaMap.clear();
+    }
+    registerFormat(format) {
+        // Create a serialized version of the format to use as a hash key
+        const formatKey = getCellXfsKey(format);
+        // Check if this format already exists
+        if (this.cellXfs.has(formatKey)) {
+            return formatKey;
+        }
+        this.cellXfs.set(formatKey, format);
+        return formatKey;
+    }
+    getConditionaFormattingFromSheet(sheetId, sheetData) {
+        // Get conditional formatting rules for this sheet
+        const sheetRules = getConditionalFormattingFromSheet(sheetData, sheetId, this.workbookStyles.styles, this.workbookStyles.indexedColors);
+        return sheetRules;
+    }
+    async getTablesFromSheet(sheetId, rId, tablePartIds) {
+        const tables = [];
+        if (!tablePartIds.length) {
+            return tables;
+        }
+        // Get sheet relationships to find table files
+        const target = this.relations[rId].target;
+        const sheetPath = target.startsWith("/xl")
+            ? target.replace(/^\//gi, "")
+            : `xl/${this.relations[rId].target}`;
+        const sheetRelPath = sheetPath.replace("worksheets", "worksheets/_rels") + ".rels";
+        try {
+            const sheetRelContent = await this.zipParser.getText(sheetRelPath);
+            const sheetRels = this.xmlParser.parse(sheetRelContent);
+            const tableRelations = get(sheetRels, "Relationships.Relationship");
+            const tableRelationsArray = Array.isArray(tableRelations)
+                ? tableRelations
+                : [tableRelations];
+            // Process each table in the sheet
+            for (const tableRId of tablePartIds) {
+                // Find this table's relationship
+                const tableRel = tableRelationsArray.find((rel) => rel.a$.Id === tableRId);
+                if (!tableRel)
+                    continue;
+                // Get table file path
+                let tablePath = tableRel.a$.Target;
+                if (tablePath.startsWith("../")) {
+                    tablePath = `xl/${tablePath.replace("../", "")}`;
+                }
+                else if (!tablePath.startsWith("/")) {
+                    tablePath = `xl/worksheets/${tablePath}`;
+                }
+                else {
+                    tablePath = tablePath.startsWith("/")
+                        ? tablePath.substring(1)
+                        : `xl/${tablePath}`;
+                }
+                // Parse table definition
+                const tableContent = await this.zipParser.getText(tablePath);
+                const tableData = this.xmlParser.parse(tableContent || "");
+                // Handle both with and without namespace prefix
+                const tableDefinition = get(tableData, "table") || get(tableData, "x:table");
+                if (tableDefinition) {
+                    // Extract table attributes
+                    const attrs = tableDefinition.a$ || {};
+                    const displayName = attrs.displayName || attrs.name || `Table${tables.length + 1}`;
+                    // Clean the title to remove spaces and special characters
+                    // const title = displayName.replace(/[^a-zA-Z0-9]/g, "");
+                    // Parse table settings
+                    const headerRow = attrs.headerRowCount !== "0";
+                    const totalRow = attrs.totalsRowCount === "1";
+                    const showFirstColumn = attrs.showFirstColumn === "1";
+                    const showLastColumn = attrs.showLastColumn === "1";
+                    const showRowStripes = attrs.showRowStripes !== "0";
+                    const showColumnStripes = attrs.showColumnStripes === "1";
+                    // Parse table columns
+                    // Handle both with and without namespace prefix
+                    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 columnObj = { name };
+                        // Check for calculated column
+                        // Handle both with and without namespace prefix
+                        const calculatedColumnFormula = get(colDef, "calculatedColumnFormula") ||
+                            get(colDef, "x:calculatedColumnFormula");
+                        if (calculatedColumnFormula) {
+                            return {
+                                ...columnObj,
+                                formula: calculatedColumnFormula,
+                            };
+                        }
+                        return columnObj;
+                    });
+                    // Parse table style information
+                    // Handle both with and without namespace prefix
+                    const tableStyle = get(tableDefinition, "tableStyleInfo") ||
+                        get(tableDefinition, "x:tableStyleInfo") ||
+                        {};
+                    const tableStyleAttrs = tableStyle.a$ || {};
+                    // Extract filter button settings
+                    const filterButton = attrs.filterButton !== "0";
+                    const range = getRangeFromAddressRef(attrs.ref);
+                    if (range) {
+                        // Handle both with and without namespace prefix
+                        const autoFilter = tableDefinition.autoFilter ?? tableDefinition["x:autoFilter"];
+                        const filterSpecs = createFilterSpecsFromAutoFilter(autoFilter, (dxfId, cellColor) => this.resolveDxfColor(dxfId, cellColor));
+                        // Create the table view object
+                        const tableView = {
+                            id: attrs.id,
+                            title: attrs.name,
+                            sheetId,
+                            headerRow,
+                            totalRow,
+                            showRowStripes,
+                            showColumnStripes,
+                            showFirstColumn,
+                            showLastColumn,
+                            filterButton,
+                            columns,
+                            range,
+                            filterSpecs,
+                        };
+                        // Add table theme if available
+                        if (tableStyleAttrs.name) {
+                            const fullStyleName = tableStyleAttrs.name;
+                            // Extract base style name (handle custom styles like "TableStyleMedium4 2")
+                            const styleName = fullStyleName.split(" ")[0];
+                            tableView.theme = styleName;
+                            // First try to get custom table style from styles.xml
+                            let bandedRange = this.workbookStyles.getCustomTableStyleBanding(fullStyleName);
+                            // Fall back to standard table styles
+                            if (!bandedRange) {
+                                bandedRange = findMatchingBandProperty(styleName, showRowStripes, showColumnStripes);
+                            }
+                            if (bandedRange) {
+                                // Only include row/column properties based on stripe settings
+                                if (!showRowStripes && bandedRange.rowProperties) {
+                                    // Keep header and total row styling even if stripes are off
+                                    const { headerColor, headerBorder, totalRowColor, totalRowBorder, } = bandedRange.rowProperties;
+                                    if (headerColor ||
+                                        headerBorder ||
+                                        totalRowColor ||
+                                        totalRowBorder) {
+                                        bandedRange.rowProperties = {
+                                            headerColor,
+                                            headerBorder,
+                                            totalRowColor,
+                                            totalRowBorder,
+                                        };
+                                    }
+                                    else {
+                                        delete bandedRange.rowProperties;
+                                    }
+                                }
+                                if (!showColumnStripes) {
+                                    delete bandedRange.columnProperties;
+                                }
+                                tableView.bandedRange = bandedRange;
+                            }
+                        }
+                        tables.push(tableView);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // Skip if relation file doesn't exist or has issues
+            console.log("Error parsing table", err);
+        }
+        return tables;
+    }
+    resolveSheetPath(target) {
+        if (target.startsWith("/")) {
+            return target.replace(/^\//, "");
+        }
+        if (target.startsWith("xl/")) {
+            return target;
+        }
+        return `xl/${target}`;
+    }
+    resolveRelationshipTarget(basePath, target) {
+        if (target.startsWith("/")) {
+            return target.replace(/^\//, "");
+        }
+        if (target.startsWith("../")) {
+            return `xl/${target.replace("../", "")}`;
+        }
+        if (target.startsWith("xl/")) {
+            return target;
+        }
+        const baseDir = basePath.substring(0, basePath.lastIndexOf("/"));
+        return `${baseDir}/${target}`;
+    }
+    getSheetPathByRid(rid) {
+        const relation = this.relations[rid];
+        if (!relation) {
+            throw new Error(`Missing worksheet relation for ${rid}`);
+        }
+        return this.resolveSheetPath(relation.target);
+    }
+    async *streamSheetRows(rid) {
+        const path = this.getSheetPathByRid(rid);
+        let inSheetData = false;
+        let currentRow = null;
+        let currentCell = null;
+        let currentValueText = "";
+        let currentFormulaText = "";
+        let currentInlineText = "";
+        let currentFormulaAttrs = null;
+        let currentTag = null;
+        let inInlineStr = false;
+        let inInlineRun = false;
+        let inInlineRunProps = false;
+        let inlineRunStart = 0;
+        let inlineRunText = "";
+        let inlineRunFormat = {};
+        let inlineRuns = [];
+        const normalizeTag = (name) => name.includes(":") ? name.split(":")[1] : name;
+        const normalizeAttrs = (attrs) => Object.keys(attrs).length ? { ...attrs } : {};
+        const truthyAttr = (attrs) => {
+            const val = attrs.val;
+            return val == null || val === "1" || val === "true";
+        };
+        const commitInlineRun = () => {
+            const endIndex = inlineRunStart + inlineRunText.length;
+            if (inlineRunText && hasAnyFormatKey(inlineRunFormat)) {
+                inlineRuns.push({
+                    startIndex: inlineRunStart,
+                    endIndex,
+                    format: { ...inlineRunFormat },
+                    nodeType: "text",
+                });
+            }
+            inInlineRun = false;
+            inInlineRunProps = false;
+            inlineRunStart = currentInlineText.length;
+            inlineRunText = "";
+            inlineRunFormat = {};
+        };
+        const applyInlineRunProperty = (name, attrs) => {
+            switch (name) {
+                case "b":
+                    if (truthyAttr(attrs))
+                        inlineRunFormat.bold = true;
+                    break;
+                case "i":
+                    if (truthyAttr(attrs))
+                        inlineRunFormat.italic = true;
+                    break;
+                case "u":
+                    if (attrs.val !== "none")
+                        inlineRunFormat.underline = true;
+                    break;
+                case "strike":
+                    if (truthyAttr(attrs))
+                        inlineRunFormat.strikethrough = true;
+                    break;
+                case "sz": {
+                    const fontSize = Number(attrs.val);
+                    if (Number.isFinite(fontSize) && fontSize > 0) {
+                        inlineRunFormat.fontSize = fontSize;
+                    }
+                    break;
+                }
+                case "rFont":
+                    if (attrs.val)
+                        inlineRunFormat.fontFamily = attrs.val;
+                    break;
+                case "color":
+                    if (attrs.rgb) {
+                        const hex = attrs.rgb.length === 8 ? attrs.rgb.slice(2) : attrs.rgb;
+                        inlineRunFormat.color = `#${hex.toUpperCase()}`;
+                    }
+                    else if (attrs.theme != null) {
+                        const theme = Number(attrs.theme);
+                        const tint = attrs.tint != null && attrs.tint !== ""
+                            ? Number(attrs.tint)
+                            : undefined;
+                        if (Number.isFinite(theme)) {
+                            inlineRunFormat.color = {
+                                theme,
+                                tint: Number.isFinite(tint) ? tint : undefined,
+                            };
+                        }
+                    }
+                    break;
+                case "vertAlign":
+                    if (attrs.val === "superscript") {
+                        inlineRunFormat.baselineOffset = "superscript";
+                    }
+                    else if (attrs.val === "subscript") {
+                        inlineRunFormat.baselineOffset = "subscript";
+                    }
+                    break;
+            }
+        };
+        // Bounded producer/consumer queue. The zip stream pauses (via the async
+        // onChunk backpressure in StreamingZipParser.streamText) whenever the
+        // consumer falls behind by more than HIGH_WATER_ROWS, so worker memory
+        // stays flat regardless of sheet size instead of buffering every parsed
+        // row before the first yield.
+        const HIGH_WATER_ROWS = 1024;
+        const queue = [];
+        let queueHead = 0;
+        let done = false;
+        let pendingResolve = null;
+        let drainResolve = null;
+        const queuedRows = () => queue.length - queueHead;
+        const releaseDrain = () => {
+            if (drainResolve) {
+                const resolve = drainResolve;
+                drainResolve = null;
+                resolve();
+            }
+        };
+        const notifyDrained = () => {
+            if (queuedRows() < HIGH_WATER_ROWS / 2) {
+                releaseDrain();
+            }
+        };
+        const pushRow = (row) => {
+            if (pendingResolve) {
+                const resolve = pendingResolve;
+                pendingResolve = null;
+                resolve(row);
+                return;
+            }
+            queue.push(row);
+        };
+        const closeQueue = () => {
+            done = true;
+            if (pendingResolve) {
+                const resolve = pendingResolve;
+                pendingResolve = null;
+                resolve(null);
+            }
+        };
+        // Need to capture `this` for use inside parser handlers
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const parser = new HtmlParser({
+            onopentag(tagName, attrs) {
+                const name = normalizeTag(tagName);
+                if (!self.currentSheetTotalRows && name === "dimension") {
+                    const ref = attrs?.ref;
+                    if (typeof ref === "string") {
+                        const range = getRangeFromAddressRef(ref);
+                        if (range) {
+                            self.currentSheetTotalRows = range.endRowIndex;
+                        }
+                    }
+                }
+                if (name === "sheetData") {
+                    inSheetData = true;
+                    return;
+                }
+                if (!inSheetData)
+                    return;
+                if (name === "row") {
+                    currentRow = { a$: normalizeAttrs(attrs), c: [] };
+                    return;
+                }
+                if (name === "c" && currentRow) {
+                    currentCell = { a$: normalizeAttrs(attrs) };
+                    currentRow.c.push(currentCell);
+                    return;
+                }
+                if (name === "v" && currentCell) {
+                    currentValueText = "";
+                    currentTag = "v";
+                    return;
+                }
+                if (name === "f" && currentCell) {
+                    currentFormulaText = "";
+                    currentFormulaAttrs = normalizeAttrs(attrs);
+                    currentTag = "f";
+                    return;
+                }
+                if (name === "is" && currentCell) {
+                    currentInlineText = "";
+                    inlineRuns = [];
+                    inInlineStr = true;
+                    return;
+                }
+                if (name === "r" && currentCell && inInlineStr) {
+                    inInlineRun = true;
+                    inlineRunStart = currentInlineText.length;
+                    inlineRunText = "";
+                    inlineRunFormat = {};
+                    return;
+                }
+                if (name === "rPr" && inInlineRun) {
+                    inInlineRunProps = true;
+                    return;
+                }
+                if (inInlineRunProps) {
+                    applyInlineRunProperty(name, normalizeAttrs(attrs));
+                    return;
+                }
+                if (name === "t" && currentCell && inInlineStr) {
+                    currentTag = "inline";
+                }
+            },
+            ontext(text) {
+                if (currentTag === "v") {
+                    currentValueText += text;
+                    return;
+                }
+                if (currentTag === "f") {
+                    currentFormulaText += text;
+                    return;
+                }
+                if (currentTag === "inline") {
+                    currentInlineText += text;
+                    if (inInlineRun) {
+                        inlineRunText += text;
+                    }
+                }
+            },
+            onclosetag(tagName) {
+                const name = normalizeTag(tagName);
+                if (name === "v" && currentCell) {
+                    currentCell.v = { t$: currentValueText };
+                    currentValueText = "";
+                    currentTag = null;
+                    return;
+                }
+                if (name === "f" && currentCell) {
+                    currentCell.f = currentFormulaAttrs
+                        ? { a$: currentFormulaAttrs, t$: currentFormulaText }
+                        : currentFormulaText;
+                    currentFormulaText = "";
+                    currentFormulaAttrs = null;
+                    currentTag = null;
+                    return;
+                }
+                if (name === "t") {
+                    currentTag = null;
+                    return;
+                }
+                if (name === "rPr") {
+                    inInlineRunProps = false;
+                    return;
+                }
+                if (name === "r" && inInlineRun) {
+                    commitInlineRun();
+                    return;
+                }
+                if (name === "is" && currentCell) {
+                    if (currentInlineText) {
+                        if (inlineRuns.length > 0) {
+                            const stringIndex = self.sharedStrings.length;
+                            self.sharedStrings.push(currentInlineText);
+                            if (!self.richSharedStringRuns) {
+                                self.richSharedStringRuns = new Map();
+                            }
+                            self.richSharedStringRuns.set(stringIndex, inlineRuns);
+                            currentCell.a$ = { ...(currentCell.a$ ?? {}), t: "s" };
+                            currentCell.v = { t$: String(stringIndex) };
+                        }
+                        else {
+                            currentCell.is = { t: { t$: currentInlineText } };
+                        }
+                    }
+                    currentInlineText = "";
+                    inlineRuns = [];
+                    inInlineStr = false;
+                    return;
+                }
+                if (name === "c") {
+                    currentCell = null;
+                    return;
+                }
+                if (name === "row" && currentRow) {
+                    pushRow(currentRow);
+                    currentRow = null;
+                    return;
+                }
+                if (name === "sheetData") {
+                    inSheetData = false;
+                }
+            },
+            onerror(err) {
+                console.error("Streaming XML parse error", err);
+            },
+        }, { xmlMode: true });
+        // Start the zip → SAX pipeline WITHOUT awaiting it so rows are yielded
+        // while decompression is still in flight. Awaiting streamText here first
+        // (the previous behavior) buffered the entire sheet's rows in `queue`
+        // before yield #1 — ~1.3GB on a 5.9M-cell sheet.
+        let aborted = false;
+        let producerError = null;
+        const producerDone = (async () => {
+            try {
+                await this.zipParser.streamText(path, (chunk) => {
+                    if (aborted)
+                        return;
+                    parser.write(chunk);
+                    if (queuedRows() >= HIGH_WATER_ROWS) {
+                        return new Promise((resolve) => (drainResolve = resolve));
+                    }
+                });
+                if (!aborted) {
+                    parser.end();
+                }
+            }
+            catch (err) {
+                producerError = err;
+            }
+            finally {
+                closeQueue();
+            }
+        })();
+        try {
+            while (true) {
+                if (queueHead < queue.length) {
+                    const row = queue[queueHead];
+                    queue[queueHead] = undefined;
+                    queueHead++;
+                    // Compact consumed slots so the array doesn't grow to sheet length.
+                    if (queueHead >= 2048 && queueHead * 2 >= queue.length) {
+                        queue.splice(0, queueHead);
+                        queueHead = 0;
+                    }
+                    notifyDrained();
+                    yield row;
+                    continue;
+                }
+                if (done) {
+                    break;
+                }
+                const row = await new Promise((resolve) => (pendingResolve = resolve));
+                if (row === null) {
+                    break;
+                }
+                yield row;
+            }
+            await producerDone;
+            if (producerError) {
+                throw producerError;
+            }
+        }
+        finally {
+            // Unstick the producer if the consumer exits early so the stream
+            // callback's pending drain promise can't leak.
+            aborted = true;
+            releaseDrain();
+        }
+    }
+    extractCommentText(comment) {
+        const textNode = getWithFallback(comment, ["text", "x:text"]);
+        if (!textNode) {
+            return "";
+        }
+        const runs = getWithFallback(textNode, ["r", "x:r"]) ??
+            (Array.isArray(textNode) ? textNode : undefined);
+        if (runs) {
+            const runArray = Array.isArray(runs) ? runs : [runs];
+            return runArray
+                .map((run) => {
+                const textValue = getWithFallback(run, ["t", "x:t"]);
+                if (typeof textValue === "string") {
+                    return textValue;
+                }
+                if (textValue && typeof textValue === "object") {
+                    return getWithFallback(textValue, ["t$", "_", "#text"]) ?? "";
+                }
+                return "";
+            })
+                .join("");
+        }
+        const textValue = getWithFallback(textNode, ["t", "x:t"]);
+        if (typeof textValue === "string") {
+            return textValue;
+        }
+        if (textValue && typeof textValue === "object") {
+            return getWithFallback(textValue, ["t$", "_", "#text"]) ?? "";
+        }
+        return "";
+    }
+    async getCommentsForSheet(rId) {
+        if (this.sheetCommentsCache.has(rId)) {
+            return this.sheetCommentsCache.get(rId);
+        }
+        const comments = {};
+        const relation = this.relations[rId];
+        if (!relation) {
+            this.sheetCommentsCache.set(rId, comments);
+            return comments;
+        }
+        const sheetPath = this.resolveSheetPath(relation.target);
+        const sheetRelPath = sheetPath.replace("worksheets", "worksheets/_rels") + ".rels";
+        let sheetRelContent;
+        try {
+            sheetRelContent = await this.zipParser.getText(sheetRelPath);
+        }
+        catch {
+            this.sheetCommentsCache.set(rId, comments);
+            return comments;
+        }
+        const sheetRels = this.xmlParser.parse(sheetRelContent);
+        const relationships = get(sheetRels, "Relationships.Relationship");
+        const relationshipsArray = Array.isArray(relationships)
+            ? relationships
+            : relationships
+                ? [relationships]
+                : [];
+        const commentRel = relationshipsArray.find((rel) => rel?.a$?.Type?.includes("/comments"));
+        if (!commentRel) {
+            this.sheetCommentsCache.set(rId, comments);
+            return comments;
+        }
+        const commentsPath = this.resolveRelationshipTarget(sheetPath, commentRel.a$.Target);
+        try {
+            const commentsContent = await this.zipParser.getText(commentsPath);
+            const parsedComments = this.xmlPreserveValueParser.parse(commentsContent);
+            const commentList = get(parsedComments, "comments.commentList.comment") ||
+                get(parsedComments, "x:comments.x:commentList.x:comment");
+            const commentArray = Array.isArray(commentList)
+                ? commentList
+                : commentList
+                    ? [commentList]
+                    : [];
+            for (const comment of commentArray) {
+                const ref = comment?.a$?.ref;
+                if (!ref)
+                    continue;
+                const text = this.extractCommentText(comment);
+                if (text) {
+                    comments[ref] = text;
+                }
+            }
+        }
+        catch {
+            // Ignore missing comment files
+        }
+        this.sheetCommentsCache.set(rId, comments);
+        return comments;
+    }
+    /**
+     * Workbook-level author list from `xl/persons/person.xml` (located via the
+     * workbook rels' `.../person` relationship). Empty map when the workbook
+     * has no threaded comments.
+     */
+    getPersons() {
+        if (!this.personsPromise) {
+            this.personsPromise = (async () => {
+                try {
+                    const personRel = Object.values(this.relations ?? {}).find((rel) => rel?.type?.endsWith("/person"));
+                    if (!personRel) {
+                        return new Map();
+                    }
+                    const personsContent = await this.zipParser.getText(this.resolveSheetPath(personRel.target));
+                    return parsePersons(this.xmlPreserveValueParser.parse(personsContent));
+                }
+                catch {
+                    // Missing/corrupt persons part — authors resolve to "Unknown".
+                    return new Map();
+                }
+            })();
+        }
+        return this.personsPromise;
+    }
+    /**
+     * Modern threaded comments for one sheet, parsed from the sheet's
+     * `.../threadedComment` relationship part. Threads are returned in the
+     * exporter's model (`CommentThread[]` + per-cell anchor addresses); the
+     * row stream stamps `commentThreadId` onto the anchor cells and skips
+     * their legacy `tc=` shadow notes. Empty result (and legacy notes kept as
+     * a fallback) when the part is absent or unreadable.
+     */
+    async getThreadedCommentsForSheet(rId) {
+        const cached = this.sheetThreadedCommentsCache.get(rId);
+        if (cached) {
+            return cached;
+        }
+        let result = EMPTY_SHEET_THREADED_COMMENTS;
+        const relation = this.relations[rId];
+        if (!relation) {
+            this.sheetThreadedCommentsCache.set(rId, result);
+            return result;
+        }
+        const sheetPath = this.resolveSheetPath(relation.target);
+        const sheetRelPath = sheetPath.replace("worksheets", "worksheets/_rels") + ".rels";
+        try {
+            const sheetRelContent = await this.zipParser.getText(sheetRelPath);
+            const sheetRels = this.xmlParser.parse(sheetRelContent);
+            const relationships = get(sheetRels, "Relationships.Relationship");
+            const relationshipsArray = Array.isArray(relationships)
+                ? relationships
+                : relationships
+                    ? [relationships]
+                    : [];
+            const threadedRel = relationshipsArray.find((rel) => rel?.a$?.Type?.endsWith("/threadedComment"));
+            if (threadedRel) {
+                const threadedPath = this.resolveRelationshipTarget(sheetPath, threadedRel.a$.Target);
+                const threadedContent = await this.zipParser.getText(threadedPath);
+                result = parseThreadedComments(this.xmlPreserveValueParser.parse(threadedContent), await this.getPersons());
+            }
+        }
+        catch {
+            // Missing/corrupt threaded parts — the legacy shadow notes still
+            // import as plain notes, so nothing is lost outright.
+        }
+        this.sheetThreadedCommentsCache.set(rId, result);
+        return result;
+    }
+    /**
+     * Comment threads for one sheet (or the whole workbook when `sheetId` is
+     * omitted), in the model `createExcelFile({ comments })` consumes. Cells
+     * anchor threads via the `commentThreadId` the row stream stamped.
+     */
+    async getCommentThreads(sheetId) {
+        const elements = sheetId === undefined
+            ? this._getSheets()
+            : [this.worksheetBySheetId.get(sheetId)];
+        const threads = [];
+        for (const element of elements) {
+            const rid = element?.a$?.["r:id"];
+            if (!rid)
+                continue;
+            const sheetThreads = await this.getThreadedCommentsForSheet(rid);
+            threads.push(...sheetThreads.threads);
+        }
+        return threads;
+    }
+    getFonts() {
+        const fontSet = new Set();
+        // The Fonts array contains all font definitions used in the workbook.
+        // `<name>` may be namespaced (`<x:name>`), and a font may carry only a
+        // `<scheme val="major|minor"/>` theme reference instead of a concrete
+        // name — resolve those against the theme typefaces so the preload
+        // list is complete.
+        const fonts = this.workbookStyles?.fonts;
+        if (fonts) {
+            const fontArray = Array.isArray(fonts) ? fonts : [fonts];
+            const themeFonts = this.workbookStyles?.themeFonts;
+            for (const font of fontArray) {
+                const name = getWithFallback(font, [
+                    "name.a$.val",
+                    "x:name.a$.val",
+                ]);
+                if (name) {
+                    fontSet.add(name);
+                    continue;
+                }
+                const scheme = getWithFallback(font, [
+                    "scheme.a$.val",
+                    "x:scheme.a$.val",
+                ]);
+                const resolved = scheme === "major"
+                    ? themeFonts?.major
+                    : scheme === "minor"
+                        ? themeFonts?.minor
+                        : undefined;
+                if (resolved) {
+                    fontSet.add(resolved);
+                }
+            }
+        }
+        // Rich-text shared-string runs carry per-run `<rPr><rFont val>` fonts
+        // that never appear in styles.xml's `<fonts>` table.
+        if (this.richSharedStringRuns) {
+            for (const runs of this.richSharedStringRuns.values()) {
+                for (const run of runs) {
+                    const family = run.nodeType === "text" ? run.format?.fontFamily : undefined;
+                    if (family) {
+                        fontSet.add(family);
+                    }
+                }
+            }
+        }
+        return [...fontSet];
+    }
+    getCellXfs() {
+        return this.cellXfs;
+    }
+    /**
+     * Extract column widths and row heights from sheet XML for chart positioning
+     */
+    _extractSheetDimensions(sheetData) {
+        const columnWidths = new Map();
+        const rowHeights = new Map();
+        // Extract column widths from cols/col elements
+        const cols = get(sheetData, "worksheet.cols.col") ||
+            get(sheetData, "worksheet.cols") ||
+            get(sheetData, "x:worksheet.x:cols.x:col") ||
+            [];
+        const colsArray = Array.isArray(cols) ? cols : cols?.col ? [cols.col] : [];
+        for (const col of colsArray) {
+            const attrs = col.a$ || col;
+            if (!attrs)
+                continue;
+            const min = parseInt(attrs.min ?? "0", 10);
+            const max = parseInt(attrs.max ?? attrs.min ?? "0", 10);
+            const width = attrs.width !== undefined
+                ? excelColumnWidthToPixels(parseFloat(attrs.width))
+                : undefined;
+            if (width !== undefined) {
+                for (let i = min; i <= max; i++) {
+                    columnWidths.set(i, width);
+                }
+            }
+        }
+        // Extract row heights from sheetData/row elements
+        const rows = get(sheetData, "worksheet.sheetData.row") ||
+            get(sheetData, "x:worksheet.x:sheetData.x:row") ||
+            [];
+        const rowsArray = Array.isArray(rows) ? rows : rows ? [rows] : [];
+        // Sequential fallback for rows without the optional @r attribute
+        // (position = previous row + 1 per ECMA-376).
+        let lastHeightRowIndex = 0;
+        for (const row of rowsArray) {
+            const attrs = row.a$ || row;
+            if (!attrs)
+                continue;
+            const parsedRowIndex = parseInt(attrs.r ?? "0", 10);
+            const rowIndex = parsedRowIndex > 0 ? parsedRowIndex : lastHeightRowIndex + 1;
+            lastHeightRowIndex = rowIndex;
+            // Check if row is hidden - hidden rows have 0 height for chart calculations
+            const isHidden = attrs.hidden === "1" ||
+                attrs.hidden === "true" ||
+                attrs.hidden === true;
+            if (isHidden) {
+                rowHeights.set(rowIndex, 0);
+                continue;
+            }
+            // Get explicit height if defined
+            const height = attrs.ht ? parseFloat(attrs.ht) * 1.33 : undefined; // Convert points to pixels
+            if (height !== undefined) {
+                rowHeights.set(rowIndex, height);
+            }
+        }
+        // Also check for hidden columns
+        for (const col of colsArray) {
+            const attrs = col.a$ || col;
+            if (!attrs)
+                continue;
+            const min = parseInt(attrs.min ?? "0", 10);
+            const max = parseInt(attrs.max ?? attrs.min ?? "0", 10);
+            const isHidden = attrs.hidden === "1" ||
+                attrs.hidden === "true" ||
+                attrs.hidden === true;
+            if (isHidden) {
+                for (let i = min; i <= max; i++) {
+                    columnWidths.set(i, 0);
+                }
+            }
+        }
+        return {
+            columnWidths: columnWidths.size > 0 ? columnWidths : undefined,
+            rowHeights: rowHeights.size > 0 ? rowHeights : undefined,
+            defaultColumnWidth: 64,
+            defaultRowHeight: 20,
+        };
+    }
+    async _getCharts(rid, sheetId, sheetData) {
+        const charts = [];
+        const sheetDimensions = this._extractSheetDimensions(sheetData);
+        const target = this.relations[rid].target;
+        const path = target.startsWith("/xl")
+            ? target.replace(/^\//gi, "")
+            : `xl/${this.relations[rid].target}`;
+        // Build a sheet-name → sheetId map so chart series with cross-sheet
+        // refs (e.g. `'Data for the Chart'!$A$7:$A$26` on a chart that
+        // lives on Sheet1) get pinned to the actual data sheet, not the
+        // host sheet. Without this every series source resolves to the
+        // chart's host sheet — empty data, broken chart.
+        const sheetIdByName = {};
+        for (const sheet of this._getSheets()) {
+            const name = sheet?.a$?.name;
+            const sId = sheet?.a$?.sheetId;
+            if (name && sId !== undefined) {
+                sheetIdByName[String(name)] = Number(sId);
+            }
+        }
+        const resolveSheetId = (sheetName) => sheetName ? sheetIdByName[String(sheetName)] : undefined;
+        // Handle both with and without namespace prefix
+        const drawing = get(sheetData, "worksheet.drawing") ||
+            get(sheetData, "drawing") ||
+            get(sheetData, "x:worksheet.x:drawing");
+        if (!drawing) {
+            return [];
+        }
+        const drawings = Array.isArray(drawing) ? drawing : [drawing];
+        try {
+            // Get the sheet's relationships to find drawing relationship
+            const sheetRelPath = path.replace("worksheets", "worksheets/_rels") + ".rels";
+            const sheetRelContent = await this.zipParser.getText(sheetRelPath);
+            const sheetRels = this.xmlParser.parse(sheetRelContent);
+            const drawingRelations = get(sheetRels, "Relationships.Relationship");
+            const drawingRelationsArray = Array.isArray(drawingRelations)
+                ? drawingRelations
+                : [drawingRelations];
+            for (const drawingElement of drawings) {
+                // Get the drawing relationship ID
+                const drawingId = get(drawingElement, "a$.r:id") || get(drawingElement, "a$.id");
+                // Find the drawing relationship
+                const drawingRel = drawingRelationsArray.find((rel) => rel.a$.Id === drawingId ||
+                    rel.a$.id === drawingId ||
+                    rel.a$.ID === drawingId);
+                if (!drawingRel)
+                    continue;
+                // Build drawing path
+                let drawingPath = drawingRel.a$.Target;
+                if (drawingPath.startsWith("../")) {
+                    drawingPath = `xl/${drawingPath.replace("../", "")}`;
+                }
+                else if (!drawingPath.startsWith("/")) {
+                    drawingPath = `xl/worksheets/${drawingPath}`;
+                }
+                else {
+                    drawingPath = drawingPath.startsWith("/")
+                        ? drawingPath.substring(1)
+                        : `xl/${drawingPath}`;
+                }
+                const drawingContent = await this.zipParser.getText(drawingPath);
+                if (!drawingContent)
+                    continue;
+                // Parse drawing XML
+                const drawingXml = this.xmlParser.parse(drawingContent);
+                // Get drawing relationships to resolve chart references
+                const drawingDir = drawingPath.substring(0, drawingPath.lastIndexOf("/"));
+                const drawingRelsPath = `${drawingDir}/_rels/${drawingPath
+                    .split("/")
+                    .pop()}.rels`;
+                const drawingRelsContent = await this.zipParser.getText(drawingRelsPath);
+                if (!drawingRelsContent) {
+                    console.log("Drawing relationships file not found:", drawingRelsPath);
+                    continue;
+                }
+                const drawingRelsXml = this.xmlParser.parse(drawingRelsContent);
+                const drawingRelsList = get(drawingRelsXml, "Relationships.Relationship") || [];
+                const drawingRelsArray = Array.isArray(drawingRelsList)
+                    ? drawingRelsList
+                    : [drawingRelsList];
+                // Extract anchors
+                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]),
+                    ...(Array.isArray(twoCellAnchors)
+                        ? twoCellAnchors
+                        : [twoCellAnchors]),
+                ].filter(Boolean);
+                for (const anchor of anchors) {
+                    const chartRef = getChartReferenceFromAnchor(anchor);
+                    if (!chartRef) {
+                        continue;
+                    }
+                    const chartRId = get(chartRef, "a$.r:id") ||
+                        get(chartRef, "a$.id") ||
+                        get(chartRef, "a$.rId") ||
+                        get(chartRef, "a$.Id");
+                    if (!chartRId) {
+                        continue;
+                    }
+                    // Find the chart file using the relationship ID
+                    const chartRel = drawingRelsArray.find((rel) => get(rel, "a$.Id") === chartRId || get(rel, "a$.id") === chartRId);
+                    if (chartRel) {
+                        const chart = await processChart(chartRel.a$.Target, drawingPath, anchor, sheetId, this.zipParser, this.xmlParser, sheetDimensions, resolveSheetId);
+                        if (chart) {
+                            charts.push(chart);
+                        }
+                    }
+                }
+            }
+            return charts;
+        }
+        catch (err) {
+            return charts;
+        }
+    }
+    /**
+     * Get drawing of a sheet from sheet data
+     * @param rid
+     * @param sheetData
+     * @returns
+     */
+    async _getDrawings(rid, sheetId, sheetData) {
+        const images = [];
+        const target = this.relations[rid].target;
+        const path = target.startsWith("/xl")
+            ? target.replace(/^\//gi, "")
+            : `xl/${this.relations[rid].target}`;
+        // Handle both with and without namespace prefix
+        const drawing = get(sheetData, "worksheet.drawing") ||
+            get(sheetData, "drawing") ||
+            get(sheetData, "x:worksheet.x:drawing");
+        if (!drawing) {
+            return [];
+        }
+        const drawings = Array.isArray(drawing) ? drawing : [drawing];
+        // Get the sheet's relationships to find drawing relationship
+        // Modified to handle both patterns of relationship files
+        const sheetRelPath = path.replace("worksheets", "worksheets/_rels") + ".rels";
+        const sheetRelContent = await this.zipParser.getText(sheetRelPath);
+        const sheetRels = this.xmlParser.parse(sheetRelContent);
+        const drawingRelations = get(sheetRels, "Relationships.Relationship");
+        const drawingRelationsArray = Array.isArray(drawingRelations)
+            ? drawingRelations
+            : [drawingRelations];
+        for (const drawingElement of drawings) {
+            // Get the drawing relationship ID
+            const drawingId = get(drawingElement, "a$.r:id") || get(drawingElement, "a$.id");
+            // Find the drawing relationship
+            // Consider both Id and Target properties, and handle different attribute naming patterns
+            const drawingRels = drawingRelationsArray.filter((rel) => rel.a$.Id === drawingId ||
+                rel.a$.id === drawingId ||
+                rel.a$.ID === drawingId ||
+                (rel.a$.Target && rel.a$.Target.includes("drawing")));
+            // 2. For each drawing, get the drawing file and its relationships
+            for (const drawingRel of drawingRels) {
+                let drawingPath = drawingRel.a$.Target;
+                if (drawingPath.startsWith("../")) {
+                    // We're in xl/worksheets/, so '../' takes us back to xl/
+                    drawingPath = `xl/${drawingPath.replace("../", "")}`;
+                }
+                else if (!drawingPath.startsWith("/")) {
+                    // If it's a relative path without '../', it's relative to the worksheets folder
+                    drawingPath = `xl/worksheets/${drawingPath}`;
+                }
+                else {
+                    // If it starts with '/', remove the leading slash
+                    drawingPath = drawingPath.startsWith("/")
+                        ? drawingPath.substring(1)
+                        : `xl/${drawingPath}`;
+                }
+                const drawingContent = await this.zipParser.getText(drawingPath);
+                // Parse drawing XML
+                const drawing = this.xmlParser.parse(drawingContent ?? "");
+                // Extract image anchors - both absolute and cell anchors
+                // Handle different XML namespaces that might be used
+                const twoCellAnchors = get(drawing, "xdr:wsDr.xdr:twoCellAnchor") ||
+                    get(drawing, "wsDr.twoCellAnchor");
+                const oneCellAnchors = get(drawing, "xdr:wsDr.xdr:oneCellAnchor") ||
+                    get(drawing, "wsDr.oneCellAnchor");
+                const absoluteAnchors = get(drawing, "xdr:wsDr.xdr:absoluteAnchor") ||
+                    get(drawing, "wsDr.absoluteAnchor");
+                // One cell
+                for (const image of await processAnchors(oneCellAnchors, "oneCellAnchor", drawingPath, sheetId, this.zipParser, this.xmlParser)) {
+                    images.push(image);
+                }
+                // Two cell
+                for (const image of await processAnchors(twoCellAnchors, "twoCellAnchors", drawingPath, sheetId, this.zipParser, this.xmlParser)) {
+                    images.push(image);
+                }
+                // absoluteAnchors
+                for (const image of await processAnchors(absoluteAnchors, "absoluteAnchors", drawingPath, sheetId, this.zipParser, this.xmlParser)) {
+                    images.push(image);
+                }
+            }
+        }
+        return images;
+    }
+    async getSheetData(rid) {
+        if (this.lastSheetDataCache?.rid === rid) {
+            return this.lastSheetDataCache.data;
+        }
+        const target = this.relations[rid].target;
+        const path = target.startsWith("/xl")
+            ? target.replace(/^\//gi, "")
+            : `xl/${this.relations[rid].target}`;
+        const data = await this.zipParser.getText(path);
+        const sheet_data = this.xmlParser.parse(data || "");
+        this.lastSheetDataCache = { rid, data: sheet_data };
+        return sheet_data;
+    }
+    getStyles() {
+        return this.workbookStyles?.styles;
+    }
+    getTheme() {
+        return this.theme ?? defaultSpreadsheetTheme;
+    }
+    /**
+     * The workbook default font — styles.xml fonts[0], the font every cell
+     * without an explicit font inherits. Exporters pass this through so the
+     * output workbook keeps the source default instead of a hardcoded one.
+     */
+    getDefaultFont() {
+        const font = this.workbookStyles?.fonts?.[0];
+        if (!font || !this.workbookStyles)
+            return null;
+        return fontNodeToTextFormat(font, this.workbookStyles);
+    }
+    /**
+     * Get shared strings
+     * @returns
+     */
+    getSharedStrings() {
+        return this.sharedStrings ?? [];
+    }
+    async getRelations() {
+        const relData = await this.zipParser.getText("xl/_rels/workbook.xml.rels");
+        return getRelationsById(this.xmlParser.parse(relData));
+    }
+    _getSheets() {
+        return this.workSheets;
+    }
+    _getNamedRanges() {
+        const xml = this.workbookXml;
+        const sheetIdBySheetName = this._getSheets().reduce((acc, element) => {
+            if (element) {
+                const name = element.a$?.name;
+                const sheetId = Number(element.a$.sheetId);
+                acc[name] = sheetId;
+            }
+            return acc;
+        }, {});
+        const namedRanges = [];
+        // Handle both with and without namespace prefix
+        const definedName = get(xml, "workbook.definedNames.definedName") ||
+            get(xml, "x:workbook.x:definedNames.x:definedName");
+        if (definedName) {
+            const defined_names = Array.isArray(definedName)
+                ? definedName
+                : [definedName];
+            for (const defined_name of defined_names) {
+                const name = defined_name.a$?.name;
+                const expression = defined_name.t$ || "";
+                const hidden = defined_name.a$.hidden === "1";
+                // Empty defined names are noise; nothing useful to round-trip.
+                // Hidden defined names ARE preserved — Excel uses them as scratch
+                // names for features like print areas and add-ins, and dropping
+                // them silently breaks those features on a round-trip.
+                if (!expression) {
+                    continue;
+                }
+                const isBrokenRef = typeof expression === "string" && expression.includes("#REF!");
+                const isRef = !isBrokenRef && checkIfStringIsReference(expression);
+                if (isRef) {
+                    // Cater to string, number, formula and boolean values as named range
+                    const selections = generateSelectionsFromFormula(expression);
+                    let pushedRange = false;
+                    if (selections.length) {
+                        for (const selection of selections) {
+                            const sheetId = selection.sheetName
+                                ? sheetIdBySheetName[selection.sheetName]
+                                : undefined;
+                            if (!isNil(sheetId)) {
+                                namedRanges.push({
+                                    namedRangeId: uuid(),
+                                    name,
+                                    range: {
+                                        ...selection.range,
+                                        sheetId,
+                                    },
+                                    ...(hidden ? { hidden: true } : {}),
+                                });
+                                pushedRange = true;
+                            }
+                        }
+                    }
+                    // Reference parsed but no selection bound to a known sheet — most
+                    // commonly an external-workbook reference like `'[1]Revenue'!$A$17`
+                    // where the `[1]` indexes a linked workbook we can't resolve.
+                    // Preserve the original expression as value-only so the name
+                    // survives the round-trip.
+                    if (!pushedRange) {
+                        namedRanges.push({
+                            name,
+                            namedRangeId: uuid(),
+                            value: isAFormula(expression) ? `=${expression}` : expression,
+                            ...(hidden ? { hidden: true } : {}),
+                        });
+                    }
+                }
+                else {
+                    // Broken ref, formula, or non-reference value. OOXML stores
+                    // defined-name expressions WITHOUT the leading "=", so
+                    // formula-shaped expressions (e.g. `OFFSET(...)`) get the
+                    // "=" prefix the calculator expects; static literals and
+                    // broken refs are preserved verbatim.
+                    namedRanges.push({
+                        name,
+                        namedRangeId: uuid(),
+                        value: isAFormula(expression) || isBareFormulaExpression(expression)
+                            ? `=${expression}`
+                            : expression,
+                        ...(hidden ? { hidden: true } : {}),
+                    });
+                }
+            }
+        }
+        return namedRanges;
+    }
+    /**
+     * Returns true if the workbook signals that Excel should perform a full
+     * recalculation when opened (fullCalcOnLoad/forceFullCalc on calcPr).
+     */
+    requiresRecalc() {
+        const attrs = this.calcPr?.a$;
+        return attrs?.fullCalcOnLoad === "1" || attrs?.forceFullCalc === "1";
+    }
+    /**
+     * `<workbookPr date1904="1"/>` shifts every date serial by 1462 days
+     * relative to the default 1900 epoch. If the workbook isn't explicitly
+     * 1904-anchored we treat it as 1900.
+     */
+    getUse1904Epoch() {
+        const v = this.workbookPr?.a$?.date1904;
+        return v === "1" || v === "true" || v === true;
+    }
+    getIterativeCalculationOptions() {
+        const attrs = this.calcPr?.a$;
+        if (!attrs)
+            return undefined;
+        const enabledAttr = attrs.iterate;
+        const maxIterationsAttr = attrs.iterateCount;
+        const maxChangeAttr = attrs.iterateDelta;
+        if (enabledAttr === undefined &&
+            maxIterationsAttr === undefined &&
+            maxChangeAttr === undefined) {
+            return undefined;
+        }
+        const enabled = enabledAttr === "1" || enabledAttr === "true" || enabledAttr === true;
+        const options = { enabled };
+        if (maxIterationsAttr !== undefined) {
+            const parsed = Number(maxIterationsAttr);
+            if (!Number.isNaN(parsed)) {
+                options.maxIterations = parsed;
+            }
+        }
+        if (maxChangeAttr !== undefined) {
+            const parsed = Number(maxChangeAttr);
+            if (!Number.isNaN(parsed)) {
+                options.maxChange = parsed;
+            }
+        }
+        return options;
+    }
+    getSheetCount() {
+        return this.workSheets.length;
+    }
+    // INTERFACE IMPLEMENTATION METHODS
+    async getSheets(minRowCount = 0, minColumnCount = 0) {
+        const workSheets = this._getSheets();
+        const sheets = [];
+        const tables = [];
+        for (const element of workSheets) {
+            const built = await this.buildSheetFromElement(element, minRowCount, minColumnCount);
+            if (!built) {
+                continue;
+            }
+            sheets.push(built.sheet);
+            tables.push(...built.tables);
+            // The eager all-sheet scan must not retain every sheet's metadata at
+            // once; the row stream re-populates the entry when it needs it.
+            this.sheetMetadataCache.delete(element.a$?.["r:id"]);
+        }
+        return [sheets, tables];
+    }
+    getSheetCatalog() {
+        const catalog = [];
+        this._getSheets().forEach((element, index) => {
+            const name = element?.a$?.name;
+            if (!name) {
+                return;
+            }
+            const state = element.a$.state;
+            const visibility = state === "veryHidden"
+                ? "veryHidden"
+                : state === "hidden"
+                    ? "hidden"
+                    : "visible";
+            catalog.push({
+                sheetId: Number(element.a$.sheetId),
+                title: name,
+                visibility,
+                hidden: visibility !== "visible",
+                index,
+            });
+        });
+        return catalog;
+    }
+    async getSheet(sheetId, minRowCount = 0, minColumnCount = 0) {
+        const element = this.worksheetBySheetId.get(sheetId);
+        if (!element) {
+            throw new Error(`Unknown sheetId: ${sheetId}`);
+        }
+        const built = await this.buildSheetFromElement(element, minRowCount, minColumnCount);
+        if (!built) {
+            throw new Error(`Unknown sheetId: ${sheetId}`);
+        }
+        // Metadata stays cached so a following per-sheet row stream reuses this
+        // scan; `releaseSheetCaches(sheetId)` drops it when the sheet is done.
+        return [built.sheet, built.tables];
+    }
+    async buildSheetFromElement(element, minRowCount = 0, minColumnCount = 0) {
+        const name = element.a$?.name;
+        if (name) {
+            const state = element.a$.state;
+            const sheetId = Number(element.a$.sheetId);
+            const rid = element.a$["r:id"];
+            const visibility = state === "veryHidden"
+                ? "veryHidden"
+                : state === "hidden"
+                    ? "hidden"
+                    : "visible";
+            const hidden = visibility !== "visible";
+            const sheet = {
+                sheetId,
+                title: name,
+                hidden,
+                rowMetadata: [],
+                columnMetadata: [],
+                merges: [],
+            };
+            if (visibility !== "visible") {
+                sheet.visibility = visibility;
+            }
+            const metadata = await this.getSheetMetadata(rid);
+            const { merges, rowEntries, columnMetadata, maxRowIndex, maxColumnIndex, autoFilterRange, filterSpecs, sheetViewData, tabColor, sheetHasFilterMode, zeroHeight, defaultRowHeightPx, defaultColumnWidthPx, tablePartIds, outlineSummaryBelow, outlineSummaryRight, } = metadata;
+            if (defaultRowHeightPx !== undefined) {
+                sheet.defaultRowHeight = defaultRowHeightPx;
+            }
+            if (defaultColumnWidthPx !== undefined) {
+                sheet.defaultColumnWidth = defaultColumnWidthPx;
+            }
+            // Only persist `outlinePr` when the workbook diverges from the
+            // Excel defaults (summaryBelow=true, summaryRight=true). Avoids
+            // bloating the model for every imported sheet.
+            if (outlineSummaryBelow === false || outlineSummaryRight === false) {
+                sheet.outlinePr = {
+                    ...(outlineSummaryBelow !== undefined && {
+                        summaryBelow: outlineSummaryBelow,
+                    }),
+                    ...(outlineSummaryRight !== undefined && {
+                        summaryRight: outlineSummaryRight,
+                    }),
+                };
+            }
+            const rowCount = findMax([minRowCount, maxRowIndex || 0]);
+            // Tables
+            const sheetTables = await this.getTablesFromSheet(sheetId, rid, tablePartIds);
+            // Create an efficient O(1) lookup map for table ranges
+            const rowInTableMap = {};
+            // Populate the lookup map
+            sheetTables.forEach((table) => {
+                const range = table.range;
+                if (range) {
+                    for (let i = range.startRowIndex; i <= range.endRowIndex; i++) {
+                        rowInTableMap[i] = true;
+                    }
+                }
+            });
+            // Check if hidden by filter vs. hidden by user
+            // Excel uses the 'filterMode' attribute at the sheet level and 'dynamicFilter' or 'customFilter'
+            // at the column filter level, but the rows hidden by filter are marked with hidden="1" just like
+            // manually hidden rows. The difference is in the context of the filter settings.
+            // counts
+            let columnCount = 0;
+            // gridlines / headers / zeros / zoom
+            const { frozenRowCount, frozenColumnCount, paneTopLeftCell, showGridLines, showRowColHeaders, showZeros, zoomScale, } = extractSheetViewProperties(sheetViewData);
+            sheet.frozenRowCount = frozenRowCount;
+            sheet.frozenColumnCount = frozenColumnCount;
+            if (paneTopLeftCell) {
+                sheet.paneTopLeftCell = paneTopLeftCell;
+            }
+            sheet.showGridLines = showGridLines;
+            // Persist only when not at Excel's defaults so we don't pollute
+            // round-trips for sheets that never customised these.
+            if (!showRowColHeaders)
+                sheet.showRowColHeaders = false;
+            if (!showZeros)
+                sheet.showZeros = false;
+            if (zoomScale !== undefined && zoomScale !== 100) {
+                sheet.zoomScale = zoomScale;
+            }
+            // tab color
+            if (tabColor) {
+                sheet.tabColor = extractColor(tabColor, this.workbookStyles.indexedColors);
+            }
+            // Auto filter
+            if (autoFilterRange) {
+                sheet.basicFilter = {
+                    id: uuid(),
+                    range: autoFilterRange,
+                    filterSpecs,
+                };
+            }
+            // Add merges
+            for (const range of merges) {
+                sheet.merges.push(range);
+            }
+            columnCount = findMax([maxColumnIndex, minColumnCount]);
+            rowEntries.forEach((entry, rowIndex) => {
+                const customHeight = entry.custom === true;
+                // If zeroHeight is set and the row has no custom height *and*
+                // no explicit `ht` value, the row inherits the sheet-level
+                // zero height (collapsed). Rows that carry an explicit `ht`
+                // should keep their height even when the sheet has
+                // `zeroHeight="1"` — Excel treats explicit `ht` as an
+                // override regardless of whether `customHeight="1"` is set.
+                const hasExplicitSize = entry.size != null;
+                const size = zeroHeight && !customHeight && !hasExplicitSize ? 0 : entry.size;
+                const isResized = !isNil(size);
+                const isHidden = entry.hidden === true;
+                const isInFilteredRange = autoFilterRange &&
+                    rowIndex >= autoFilterRange.startRowIndex &&
+                    rowIndex <= autoFilterRange.endRowIndex;
+                const isInTableRange = !!rowInTableMap[rowIndex];
+                const isHiddenByFilter = isHidden &&
+                    ((sheetHasFilterMode && isInFilteredRange) || isInTableRange);
+                const isHiddenByUser = isHidden && !isHiddenByFilter;
+                const outlineLevel = entry.outlineLevel ?? 0;
+                const isCollapsed = entry.collapsed === true;
+                if (!isHidden &&
+                    !size &&
+                    !isResized &&
+                    outlineLevel === 0 &&
+                    !isCollapsed) {
+                    return;
+                }
+                const dimensionProps = {};
+                // `hidden` on a row inside an outline group is the
+                // "collapsed-parent" hide — keep it on hiddenByGroup so
+                // expanding the group doesn't fight any user/filter hide.
+                if (isHiddenByUser) {
+                    if (outlineLevel > 0) {
+                        dimensionProps.hiddenByGroup = true;
+                    }
+                    else {
+                        dimensionProps.hiddenByUser = true;
+                    }
+                }
+                if (isHiddenByFilter)
+                    dimensionProps.hiddenByFilter = true;
+                if (!isNil(size)) {
+                    if (customHeight) {
+                        dimensionProps.resizedByUser = true;
+                        // Keep an immutable record of the source-side `customHeight="1"`
+                        // marker so the exporter can emit it back even when the height
+                        // equals the sheet default. `resizedByUser` is shared with
+                        // runtime engine state and isn't safe as the export gate.
+                        dimensionProps.customHeight = true;
+                    }
+                    dimensionProps.size = size;
+                }
+                if (outlineLevel > 0)
+                    dimensionProps.outlineLevel = outlineLevel;
+                if (isCollapsed)
+                    dimensionProps.collapsed = true;
+                sheet.rowMetadata[rowIndex] = dimensionProps;
+            });
+            sheet.columnMetadata = [];
+            Object.entries(columnMetadata).forEach(([key, value]) => {
+                sheet.columnMetadata[Number(key)] = value;
+            });
+            // Get drawing bounds to extend sheet dimensions if charts/images extend beyond cell data
+            const drawingBounds = await this.getDrawingBounds(rid);
+            // Update counts, extending if drawings go beyond cell data
+            const finalRowCount = findMax([rowCount, drawingBounds.maxRowIndex]);
+            const finalColumnCount = findMax([
+                columnCount,
+                drawingBounds.maxColumnIndex,
+            ]);
+            if (finalRowCount)
+                sheet.rowCount = finalRowCount;
+            if (finalColumnCount)
+                sheet.columnCount = finalColumnCount;
+            return { sheet, tables: sheetTables };
+        }
+        return undefined;
+    }
+    async *processSheetData(chunkSize = 100, enableCellXfsRegistry = false, _enableSharedStrings = true, onPhase) {
+        const workSheets = this._getSheets();
+        const totalSheets = workSheets.length;
+        let currentSheetIndex = 0;
+        // Process each worksheet
+        for (const element of workSheets) {
+            yield* this.processOneSheet(element, {
+                chunkSize,
+                enableCellXfsRegistry,
+                enableSharedStrings: _enableSharedStrings,
+                onPhase,
+                currentSheetIndex,
+                totalSheets,
+            });
+            // Per-sheet transients must not accumulate across the eager pass.
+            this.releaseSheetCaches(Number(element.a$?.sheetId));
+            currentSheetIndex++;
+        }
+    }
+    async *processSheetDataForSheet(options) {
+        const element = this.worksheetBySheetId.get(options.sheetId);
+        if (!element) {
+            throw new Error(`Unknown sheetId: ${options.sheetId}`);
+        }
+        yield* this.processOneSheet(element, {
+            chunkSize: options.chunkSize ?? 100,
+            enableCellXfsRegistry: options.enableCellXfsRegistry ?? false,
+            enableSharedStrings: options.enableSharedStrings ?? true,
+            onPhase: options.onPhase,
+            currentSheetIndex: 0,
+            totalSheets: 1,
+        });
+    }
+    releaseSheetCaches(sheetId) {
+        const element = this.worksheetBySheetId.get(sheetId);
+        const rid = element?.a$?.["r:id"];
+        if (!rid) {
+            return;
+        }
+        this.sheetMetadataCache.delete(rid);
+        this.sheetCommentsCache.delete(rid);
+        this.sheetThreadedCommentsCache.delete(rid);
+        if (this.lastSheetDataCache?.rid === rid) {
+            this.lastSheetDataCache = null;
+        }
+    }
+    async *processOneSheet(element, { chunkSize, enableCellXfsRegistry, enableSharedStrings: _enableSharedStrings, onPhase, currentSheetIndex, totalSheets, }) {
+        // Shared formulas (`si` ids) are sheet-local in OOXML; reset per sheet
+        // so one sheet's leaders never leak into another sheet's followers.
+        this.clearSharedFormula();
+        {
+            const name = element.a$?.name;
+            const sheetId = Number(element.a$.sheetId);
+            const rid = element.a$["r:id"];
+            this.currentSheetTotalRows = undefined;
+            // The per-sheet scans below can be long and silent on large sheets;
+            // report phases so the host's inactivity watchdog sees liveness.
+            onPhase?.("sheet-metadata", name);
+            const metadata = await this.getSheetMetadata(rid);
+            // Row/column default styles are materialized as phantom format-only
+            // cells (see STYLE_MATERIALIZE_* above). Width is clamped to the
+            // sheet's used extent so trailing catch-all `<col>` ranges don't
+            // paint 16384 columns per row.
+            const materializeMaxColumn = Math.min(metadata.maxColumnIndex, STYLE_MATERIALIZE_MAX_COLUMNS);
+            const colStyleByColumn = new Map();
+            for (const { min, max, styleIndex } of metadata.colStyleRanges) {
+                const clampedMax = Math.min(max, materializeMaxColumn);
+                for (let col = Math.max(min, 1); col <= clampedMax; col++) {
+                    colStyleByColumn.set(col, styleIndex);
+                }
+            }
+            const styleCellTemplates = new Map();
+            const getTemplateForStyleIndex = (styleIndex) => {
+                let template = styleCellTemplates.get(styleIndex);
+                if (template === undefined) {
+                    template = getCellDataForStyleIndex(styleIndex, this, enableCellXfsRegistry);
+                    styleCellTemplates.set(styleIndex, template);
+                }
+                return template;
+            };
+            let styleMaterializeBudget = STYLE_MATERIALIZE_CELL_BUDGET;
+            const mergeRangesByRow = this.buildMergeRangesByRow(metadata.merges);
+            const getMergeRangeForCell = (rowIndex, columnIndex) => {
+                const ranges = mergeRangesByRow.get(rowIndex);
+                if (!ranges)
+                    return undefined;
+                for (const range of ranges) {
+                    if (columnIndex >= range.startColumnIndex &&
+                        columnIndex <= range.endColumnIndex) {
+                        return range;
+                    }
+                }
+                return undefined;
+            };
+            const sheetComments = await this.getCommentsForSheet(rid);
+            const sheetThreadedComments = await this.getThreadedCommentsForSheet(rid);
+            const commentsByRow = new Map();
+            const threadsByRow = new Map();
+            onPhase?.("sheet-hyperlinks", name);
+            const hyperlinksByRow = await this.getHyperlinksForSheet(rid);
+            onPhase?.("sheet-sparklines", name);
+            const sparklinesByRow = await this.getSparklinesForSheet(rid, name);
+            // Data-validation refs are stamped onto covered cells while rows stream
+            // (see dv-cell-stamp.ts) — hosts resolve a cell's rule ONLY through
+            // `cellData.dataValidation`, so consumers that persist these rows
+            // directly (server-side conversion) need the stamp baked in. Gated on
+            // the SAX feature flags: a sheet with no <dataValidations> and no
+            // extLst can't contribute rules, so DV-free sheets skip the (memoized)
+            // full-DOM validation parse entirely.
+            const dvFeatures = this.sheetFeatures.get(rid);
+            const dvStamper = dvFeatures && !dvFeatures.dataValidations && !dvFeatures.extLst
+                ? null
+                : new SheetDataValidationStamper(await this.getDataValidationsForSheet(sheetId), sheetId);
+            onPhase?.("sheet-rows", name);
+            // Create comments by row. A cell whose comment is the legacy `tc=`
+            // shadow of an imported thread must NOT also get a plain note —
+            // the thread (stamped below via `commentThreadId`) supersedes it.
+            Object.entries(sheetComments).forEach(([ref, text]) => {
+                if (sheetThreadedComments.threadIdByAddress.has(ref)) {
+                    return;
+                }
+                const cellPosition = addressToCell(ref);
+                if (!cellPosition) {
+                    return;
+                }
+                const rowMap = commentsByRow.get(cellPosition.rowIndex) ?? new Map();
+                rowMap.set(cellPosition.columnIndex, text);
+                commentsByRow.set(cellPosition.rowIndex, rowMap);
+            });
+            // Thread anchors by row, mirroring commentsByRow.
+            sheetThreadedComments.threadIdByAddress.forEach((threadId, ref) => {
+                const cellPosition = addressToCell(ref);
+                if (!cellPosition) {
+                    return;
+                }
+                const rowMap = threadsByRow.get(cellPosition.rowIndex) ?? new Map();
+                rowMap.set(cellPosition.columnIndex, threadId);
+                threadsByRow.set(cellPosition.rowIndex, rowMap);
+            });
+            // Constants
+            const CHUNK_SIZE = chunkSize;
+            let chunkIndex = 0;
+            let totalRowsProcessed = 0;
+            let totalRowsKnown = this.currentSheetTotalRows;
+            // ECMA-376 makes row/@r optional (streaming writers omit it); when
+            // absent, a row's position is the previous row's + 1. Track it so
+            // r-less rows don't all land on index NaN and render an empty sheet.
+            let lastRowIndex = 0;
+            let currentChunk = [];
+            let currentChunkRowIndices = [];
+            let startRowIndex = -1;
+            let endRowIndex = -1;
+            const flushChunk = (isLastChunk) => {
+                if (!currentChunk.length) {
+                    return;
+                }
+                const result = {
+                    sheetId,
+                    title: name,
+                    currentSheetIndex,
+                    totalSheets,
+                    chunkIndex,
+                    rows: currentChunk,
+                    rowIndices: currentChunkRowIndices,
+                    startRowIndex,
+                    endRowIndex,
+                    totalRows: totalRowsKnown ?? (isLastChunk ? totalRowsProcessed : -1),
+                    isLastChunk,
+                    cellXfs: this.cellXfs,
+                };
+                currentChunk = [];
+                currentChunkRowIndices = [];
+                startRowIndex = -1;
+                endRowIndex = -1;
+                chunkIndex++;
+                return result;
+            };
+            for await (const row of this.streamSheetRows(rid)) {
+                const parsedRowIndex = Number(row.a$?.r);
+                const rowIndex = Number.isFinite(parsedRowIndex) && parsedRowIndex > 0
+                    ? parsedRowIndex
+                    : lastRowIndex + 1;
+                lastRowIndex = rowIndex;
+                totalRowsProcessed += 1;
+                if (totalRowsKnown === undefined && this.currentSheetTotalRows) {
+                    totalRowsKnown = this.currentSheetTotalRows;
+                }
+                if (currentChunk.length === 0) {
+                    startRowIndex = rowIndex;
+                }
+                const rowData = {
+                    values: [],
+                };
+                // Row default style: `<row customFormat="1" s="N">` — every cell
+                // of the row without its own `s` inherits xf N (Excel paints the
+                // whole row with it, e.g. full-width banner rows). Takes
+                // precedence over any column default style.
+                const rowAttrs = row.a$ ?? {};
+                const hasRowCustomFormat = rowAttrs.customFormat === "1" || rowAttrs.customFormat === "true";
+                const parsedRowStyle = hasRowCustomFormat && rowAttrs.s !== undefined
+                    ? parseInt(rowAttrs.s, 10)
+                    : NaN;
+                const rowStyleIndex = Number.isFinite(parsedRowStyle) && parsedRowStyle > 0
+                    ? parsedRowStyle
+                    : undefined;
+                const getInheritedStyleIndex = (columnIndex) => rowStyleIndex ?? colStyleByColumn.get(columnIndex);
+                const cells = row.c ?? row["x:c"];
+                const rowComments = commentsByRow.get(rowIndex);
+                const rowThreads = threadsByRow.get(rowIndex);
+                const rowHyperlinks = hyperlinksByRow.get(rowIndex);
+                const rowCellsByColumnIndex = new Map();
+                if (cells) {
+                    const cellArray = Array.isArray(cells) ? cells : [cells];
+                    // First pass: build map of cells by column index
+                    // Track sequential index for cells without explicit reference (1-based)
+                    let seqColIndex = 1;
+                    for (const cell of cellArray) {
+                        if (!cell || !cell.a$) {
+                            seqColIndex++;
+                            continue;
+                        }
+                        const cellRef = cell.a$?.r;
+                        let columnIndex;
+                        if (cellRef) {
+                            const colStr = cellRef.replace(/[0-9]/g, "");
+                            columnIndex = alpha2number(colStr);
+                            seqColIndex = columnIndex + 1;
+                        }
+                        else {
+                            columnIndex = seqColIndex;
+                            seqColIndex++;
+                        }
+                        // A `<c>` without `s` inherits the row/column default style.
+                        if (cell.a$.s === undefined) {
+                            const inherited = getInheritedStyleIndex(columnIndex);
+                            if (inherited !== undefined) {
+                                cell.a$.s = String(inherited);
+                            }
+                        }
+                        rowCellsByColumnIndex.set(columnIndex, cell);
+                    }
+                    // Second pass: process each cell
+                    seqColIndex = 1;
+                    for (let k = 0; k < cellArray.length; k++) {
+                        const cell = cellArray[k];
+                        if (!cell || !cell.a$) {
+                            seqColIndex++;
+                            continue;
+                        }
+                        const cellRef = cell.a$.r;
+                        let columnIndex;
+                        if (cellRef) {
+                            const colStr = cellRef.replace(/[0-9]/g, "");
+                            columnIndex = alpha2number(colStr);
+                            seqColIndex = columnIndex + 1;
+                        }
+                        else {
+                            columnIndex = seqColIndex;
+                            seqColIndex++;
+                        }
+                        const mergeRange = getMergeRangeForCell(rowIndex, columnIndex);
+                        let cellValue = getCellValueAndFormat(cell, this, enableCellXfsRegistry, _enableSharedStrings, name, mergeRange
+                            ? { range: mergeRange, rowCellsByColumnIndex }
+                            : undefined);
+                        const hyperlink = rowHyperlinks?.get(columnIndex);
+                        if (hyperlink) {
+                            if (cellValue) {
+                                cellValue = { ...cellValue, hyperlink };
+                            }
+                            else {
+                                cellValue = { hyperlink };
+                            }
+                        }
+                        const comment = rowComments?.get(columnIndex);
+                        if (comment) {
+                            if (cellValue) {
+                                cellValue = { ...cellValue, note: comment };
+                            }
+                            else {
+                                cellValue = { note: comment };
+                            }
+                        }
+                        const threadId = rowThreads?.get(columnIndex);
+                        if (threadId) {
+                            if (cellValue) {
+                                cellValue = { ...cellValue, commentThreadId: threadId };
+                            }
+                            else {
+                                cellValue = { commentThreadId: threadId };
+                            }
+                        }
+                        rowData.values[columnIndex] = cellValue;
+                    }
+                }
+                // Materialize the row/column default style onto columns that have
+                // no `<c>` element at all — Excel still paints them. Skips columns
+                // whose cell existed in the XML (its explicit style already won).
+                if (rowStyleIndex !== undefined || colStyleByColumn.size > 0) {
+                    for (let columnIndex = 1; columnIndex <= materializeMaxColumn && styleMaterializeBudget > 0; columnIndex++) {
+                        if (rowCellsByColumnIndex.has(columnIndex))
+                            continue;
+                        const inherited = getInheritedStyleIndex(columnIndex);
+                        if (inherited === undefined)
+                            continue;
+                        const template = getTemplateForStyleIndex(inherited);
+                        if (!template)
+                            continue;
+                        rowData.values[columnIndex] = template;
+                        styleMaterializeBudget--;
+                    }
+                }
+                if (rowHyperlinks) {
+                    for (const [columnIndex, hyperlink] of rowHyperlinks.entries()) {
+                        if (rowData.values[columnIndex]) {
+                            if (!rowData.values[columnIndex]?.hyperlink) {
+                                rowData.values[columnIndex] = {
+                                    ...rowData.values[columnIndex],
+                                    hyperlink,
+                                };
+                            }
+                        }
+                        else {
+                            rowData.values[columnIndex] = { hyperlink };
+                        }
+                    }
+                    hyperlinksByRow.delete(rowIndex);
+                }
+                if (rowComments) {
+                    for (const [columnIndex, text] of rowComments.entries()) {
+                        if (rowData.values[columnIndex]) {
+                            if (!rowData.values[columnIndex]?.note) {
+                                rowData.values[columnIndex] = {
+                                    ...rowData.values[columnIndex],
+                                    note: text,
+                                };
+                            }
+                        }
+                        else {
+                            rowData.values[columnIndex] = { note: text };
+                        }
+                    }
+                    commentsByRow.delete(rowIndex);
+                }
+                if (rowThreads) {
+                    for (const [columnIndex, threadId] of rowThreads.entries()) {
+                        if (rowData.values[columnIndex]) {
+                            if (!rowData.values[columnIndex]?.commentThreadId) {
+                                rowData.values[columnIndex] = {
+                                    ...rowData.values[columnIndex],
+                                    commentThreadId: threadId,
+                                };
+                            }
+                        }
+                        else {
+                            rowData.values[columnIndex] = {
+                                commentThreadId: threadId,
+                            };
+                        }
+                    }
+                    threadsByRow.delete(rowIndex);
+                }
+                // Inject sparkline formulas with effective values
+                // Both sparklinesByRow and rowData.values use 1-indexed column positions
+                const rowSparklines = sparklinesByRow.get(rowIndex);
+                if (rowSparklines) {
+                    for (const [columnIndex, sparkline] of rowSparklines.entries()) {
+                        const existingCell = rowData.values[columnIndex];
+                        // Only set formula if cell doesn't already have one
+                        if (existingCell?.ue?.fv) {
+                            continue;
+                        }
+                        // Try to extract data values from the data range for effective value
+                        // Skip cross-sheet references (contain "!") - we don't have access to other sheets
+                        // When the group carries displayEmptyCellsAs, keep empty
+                        // cells as nulls so the renderer can apply gap/zero/span;
+                        // otherwise compact them out (legacy shape).
+                        const preserveGaps = sparkline.emptyCellsAs != null;
+                        const sparklineData = [];
+                        if (!sparkline.dataRange.includes("!")) {
+                            // Parse range using addressToSelection for robust handling
+                            const selection = addressToSelection(sparkline.dataRange);
+                            if (selection) {
+                                const { startRowIndex, endRowIndex, startColumnIndex, endColumnIndex, } = selection.range;
+                                // Only extract data for same-row horizontal ranges (most common case)
+                                // rowIndex is 1-indexed, selection indices are also 1-indexed
+                                if (startRowIndex === endRowIndex &&
+                                    startRowIndex === rowIndex) {
+                                    for (let col = startColumnIndex; col <= endColumnIndex; col++) {
+                                        const cell = rowData.values[col];
+                                        const value = cell?.ev?.nv ?? cell?.ue?.nv;
+                                        if (typeof value === "number" && !isNaN(value)) {
+                                            sparklineData.push(value);
+                                        }
+                                        else if (preserveGaps) {
+                                            sparklineData.push(null);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // Build options object for sparkline result. Keys map 1:1
+                        // onto `SparkLineResultOptions` so the renderer doesn't
+                        // have to translate between Excel's XML attributes and our
+                        // formula option names — it reads straight from `options`.
+                        const sparklineOptions = {};
+                        if (sparkline.chartType !== "line") {
+                            sparklineOptions.charttype = sparkline.chartType;
+                        }
+                        if (sparkline.color)
+                            sparklineOptions.color = sparkline.color;
+                        if (sparkline.colorHigh)
+                            sparklineOptions.colorHigh = sparkline.colorHigh;
+                        if (sparkline.colorLow)
+                            sparklineOptions.colorLow = sparkline.colorLow;
+                        if (sparkline.colorFirst)
+                            sparklineOptions.colorFirst = sparkline.colorFirst;
+                        if (sparkline.colorLast)
+                            sparklineOptions.colorLast = sparkline.colorLast;
+                        if (sparkline.colorMarkers)
+                            sparklineOptions.colorMarkers = sparkline.colorMarkers;
+                        if (sparkline.colorNegative)
+                            sparklineOptions.colorNegative = sparkline.colorNegative;
+                        if (sparkline.markers)
+                            sparklineOptions.markers = true;
+                        if (sparkline.high)
+                            sparklineOptions.high = true;
+                        if (sparkline.low)
+                            sparklineOptions.low = true;
+                        if (sparkline.first)
+                            sparklineOptions.first = true;
+                        if (sparkline.last)
+                            sparklineOptions.last = true;
+                        if (sparkline.negative)
+                            sparklineOptions.negative = true;
+                        // x14 axis / display options — same lowercase keys the
+                        // SPARKLINE() formula literal uses.
+                        if (sparkline.emptyCellsAs)
+                            sparklineOptions.emptycells = sparkline.emptyCellsAs;
+                        if (sparkline.dateAxis)
+                            sparklineOptions.dateaxis = true;
+                        if (sparkline.displayXAxis)
+                            sparklineOptions.axis = true;
+                        if (sparkline.displayHidden)
+                            sparklineOptions.displayhidden = true;
+                        if (sparkline.rightToLeft)
+                            sparklineOptions.rtl = true;
+                        if (sparkline.lineWeight != null)
+                            sparklineOptions.lineweight = sparkline.lineWeight;
+                        if (sparkline.manualMax != null)
+                            sparklineOptions.max = sparkline.manualMax;
+                        if (sparkline.manualMin != null)
+                            sparklineOptions.min = sparkline.manualMin;
+                        if (sparkline.minAxisType)
+                            sparklineOptions.minaxistype = sparkline.minAxisType;
+                        if (sparkline.maxAxisType)
+                            sparklineOptions.maxaxistype = sparkline.maxAxisType;
+                        // Only set effective value if we have enough data points
+                        const cellData = {
+                            ...existingCell,
+                            ue: { fv: sparkline.formula },
+                        };
+                        if (sparklineData.filter((v) => v != null).length >= 2) {
+                            cellData.ev = {
+                                structuredValue: {
+                                    kind: "sparkline",
+                                    data: sparklineData,
+                                    options: sparklineOptions,
+                                },
+                            };
+                        }
+                        rowData.values[columnIndex] = cellData;
+                    }
+                    sparklinesByRow.delete(rowIndex);
+                }
+                dvStamper?.stampRow(rowIndex, rowData.values);
+                currentChunk.push(rowData);
+                currentChunkRowIndices.push(rowIndex);
+                endRowIndex = rowIndex;
+                if (currentChunk.length >= CHUNK_SIZE) {
+                    const payload = flushChunk(false);
+                    if (payload) {
+                        yield payload;
+                    }
+                }
+            }
+            // Rows fully absent from the file but covered by a (bounded) DV range
+            // still need phantom `{ dataValidation }` cells or blank template rows
+            // lose their dropdowns.
+            if (dvStamper?.hasRules) {
+                for (const trailing of dvStamper.trailingRows()) {
+                    if (currentChunk.length === 0) {
+                        startRowIndex = trailing.rowIndex;
+                    }
+                    currentChunk.push({ values: trailing.values });
+                    currentChunkRowIndices.push(trailing.rowIndex);
+                    endRowIndex = trailing.rowIndex;
+                    totalRowsProcessed += 1;
+                    if (currentChunk.length >= CHUNK_SIZE) {
+                        const payload = flushChunk(false);
+                        if (payload) {
+                            yield payload;
+                        }
+                    }
+                }
+            }
+            const finalPayload = flushChunk(true);
+            if (finalPayload) {
+                yield finalPayload;
+            }
+        }
+    }
+    async getDrawings() {
+        const workSheets = this._getSheets();
+        const allDrawings = [];
+        // Process each worksheet
+        for (const element of workSheets) {
+            const sheetId = Number(element.a$.sheetId);
+            const rid = element.a$["r:id"];
+            // Drawings are referenced from a worksheet-level <drawing> element;
+            // skip the full-DOM parse when the SAX pass saw none.
+            const features = this.sheetFeatures.get(rid);
+            if (features && !features.drawing) {
+                continue;
+            }
+            const sheet_data = await this.getSheetData(rid);
+            const drawings = await this._getDrawings(rid, sheetId, sheet_data);
+            allDrawings.push(...drawings);
+        }
+        return allDrawings;
+    }
+    async getCharts() {
+        const allCharts = [];
+        const workSheets = this._getSheets();
+        // Process each worksheet
+        for (const element of workSheets) {
+            const sheetId = Number(element.a$.sheetId);
+            const rid = element.a$["r:id"];
+            // Charts are anchored inside drawing parts, which the worksheet
+            // references via a <drawing> element; skip when the sheet has none.
+            const features = this.sheetFeatures.get(rid);
+            if (features && !features.drawing) {
+                continue;
+            }
+            const sheet_data = await this.getSheetData(rid);
+            const charts = await this._getCharts(rid, sheetId, sheet_data);
+            allCharts.push(...charts);
+        }
+        return allCharts;
+    }
+    /**
+     * Phase D1 — extract every pivot table across every worksheet.
+     * Walks worksheet rels for `pivotTable` relationships, parses
+     * the pivot XML + cacheDefinition, and returns flat PivotTable[]
+     * suitable for `onChangePivotTables`.
+     */
+    async getPivotTables() {
+        const { parsePivotTablesForSheet } = await import("./pivots");
+        const all = [];
+        const workSheets = this._getSheets();
+        // Cache sheet-name → sheetId mapping (cacheSource refs sheet
+        // by name; PivotTable wants numeric sheetId).
+        const sheetNameToId = new Map();
+        for (const ws of workSheets) {
+            const name = ws.a$?.name;
+            const id = Number(ws.a$?.sheetId);
+            if (name && Number.isFinite(id))
+                sheetNameToId.set(name, id);
+        }
+        let pivotIdCounter = 1;
+        const nextPivotId = () => `imported-pivot-${pivotIdCounter++}`;
+        for (const element of workSheets) {
+            const sheetId = Number(element.a$.sheetId);
+            const rid = element.a$["r:id"];
+            // Find pivotTable rels for this sheet. Sheet rels link to
+            // pivot tables with Type ending in `pivotTable`.
+            const target = this.relations[rid]?.target;
+            if (!target)
+                continue;
+            const path = target.startsWith("/xl")
+                ? target.replace(/^\//gi, "")
+                : `xl/${target}`;
+            const sheetRelPath = path.replace("worksheets", "worksheets/_rels") + ".rels";
+            // Sheets without a rels part (common for plain data sheets) must not
+            // abort pivot extraction for the remaining sheets.
+            let sheetRelContent;
+            try {
+                sheetRelContent = await this.zipParser.getText(sheetRelPath);
+            }
+            catch {
+                continue;
+            }
+            if (!sheetRelContent)
+                continue;
+            const sheetRels = this.xmlParser.parse(sheetRelContent);
+            const relList = get(sheetRels, "Relationships.Relationship");
+            const relArray = Array.isArray(relList) ? relList : relList ? [relList] : [];
+            const pivotRels = relArray
+                .filter((r) => {
+                const type = r?.a$?.Type ?? r?.["@_Type"] ?? "";
+                return typeof type === "string" && type.endsWith("pivotTable");
+            })
+                .map((r) => ({
+                target: String(r?.a$?.Target ?? r?.["@_Target"] ?? ""),
+            }));
+            if (!pivotRels.length)
+                continue;
+            const pivots = await parsePivotTablesForSheet({
+                zipParser: this.zipParser,
+                xmlParser: this.xmlParser,
+                sheetRels: pivotRels,
+                nextPivotId,
+                getSheetId: (name) => sheetNameToId.get(name),
+                defaultSheetId: sheetId,
+            });
+            all.push(...pivots);
+        }
+        return all;
+    }
+    /**
+     * Power Query preservation — read the workbook's Get & Transform machinery verbatim so the
+     * exporter can re-emit it and a round-tripped file keeps its queries: the DataMashup
+     * `customXml` items (+itemProps), `xl/connections.xml`, and each query-backed table's
+     * `queryTable` part with the original column ids / `queryTableFieldId`s. Everything is opaque
+     * XML strings — no QDEFF/M parsing. Mirrors the Rust engine's `rnc-import` `queries` module
+     * (same envelope wire shape). `undefined` when the workbook carries none.
+     */
+    async getPowerQuery() {
+        const customXmlParts = [];
+        let connectionsXml;
+        // Workbook-level parts via the already-parsed workbook rels (targets relative to `xl/`).
+        for (const rel of Object.values(this.relations)) {
+            const type = rel?.type ?? "";
+            if (type.endsWith("/customXml")) {
+                const itemPath = resolveRelTarget("xl", rel.target);
+                if (!this.zipParser.has(itemPath))
+                    continue;
+                const itemXml = await this.zipParser.getText(itemPath);
+                // Only DataMashup items are Power Query; other customXml stays dropped, as before.
+                if (!itemXml.includes(DATA_MASHUP_MARKER))
+                    continue;
+                let propsXml;
+                const itemRelsPath = relsPathFor(itemPath);
+                if (this.zipParser.has(itemRelsPath)) {
+                    const itemRels = this.xmlParser.parse(await this.zipParser.getText(itemRelsPath));
+                    const relList = get(itemRels, "Relationships.Relationship");
+                    const relArray = Array.isArray(relList)
+                        ? relList
+                        : relList
+                            ? [relList]
+                            : [];
+                    const propsRel = relArray.find((r) => String(r?.a$?.Type ?? "").endsWith("/customXmlProps"));
+                    if (propsRel) {
+                        const propsPath = resolveRelTarget(dirOf(itemPath), String(propsRel.a$.Target));
+                        if (this.zipParser.has(propsPath)) {
+                            propsXml = await this.zipParser.getText(propsPath);
+                        }
+                    }
+                }
+                customXmlParts.push(propsXml ? { itemXml, propsXml } : { itemXml });
+            }
+            else if (type.endsWith("/connections")) {
+                const path = resolveRelTarget("xl", rel.target);
+                if (this.zipParser.has(path)) {
+                    connectionsXml = await this.zipParser.getText(path);
+                }
+            }
+        }
+        // Query tables: sheet rels → table parts → each table's own rels → its queryTable part.
+        const queryTables = [];
+        for (const element of this._getSheets()) {
+            const rid = element.a$?.["r:id"];
+            const target = rid ? this.relations[rid]?.target : undefined;
+            if (!target)
+                continue;
+            const sheetPath = resolveRelTarget("xl", target);
+            const sheetRelsPath = relsPathFor(sheetPath);
+            if (!this.zipParser.has(sheetRelsPath))
+                continue;
+            const sheetRels = this.xmlParser.parse(await this.zipParser.getText(sheetRelsPath));
+            const relList = get(sheetRels, "Relationships.Relationship");
+            const relArray = Array.isArray(relList) ? relList : relList ? [relList] : [];
+            for (const r of relArray) {
+                const relType = String(r?.a$?.Type ?? "");
+                if (!relType.endsWith("/table"))
+                    continue;
+                const tablePath = resolveRelTarget(dirOf(sheetPath), String(r.a$.Target));
+                const tableRelsPath = relsPathFor(tablePath);
+                if (!this.zipParser.has(tablePath) || !this.zipParser.has(tableRelsPath)) {
+                    continue;
+                }
+                const tableRels = this.xmlParser.parse(await this.zipParser.getText(tableRelsPath));
+                const tableRelList = get(tableRels, "Relationships.Relationship");
+                const tableRelArray = Array.isArray(tableRelList)
+                    ? tableRelList
+                    : tableRelList
+                        ? [tableRelList]
+                        : [];
+                const qtRel = tableRelArray.find((t) => String(t?.a$?.Type ?? "").endsWith("/queryTable"));
+                if (!qtRel)
+                    continue;
+                const qtPath = resolveRelTarget(dirOf(tablePath), String(qtRel.a$.Target));
+                if (!this.zipParser.has(qtPath))
+                    continue;
+                const partXml = await this.zipParser.getText(qtPath);
+                const tableData = this.xmlParser.parse(await this.zipParser.getText(tablePath));
+                const tableDefinition = get(tableData, "table") || get(tableData, "x:table");
+                const attrs = tableDefinition?.a$ ?? {};
+                const tableTitle = String(attrs.displayName || attrs.name || "");
+                if (!tableTitle)
+                    continue;
+                const colDefs = get(tableDefinition, "tableColumns.tableColumn") ||
+                    get(tableDefinition, "x:tableColumns.x:tableColumn");
+                const colArray = Array.isArray(colDefs) ? colDefs : colDefs ? [colDefs] : [];
+                const columns = colArray.map((c) => {
+                    const column = {
+                        name: String(c?.a$?.name ?? ""),
+                        id: String(c?.a$?.id ?? ""),
+                    };
+                    if (c?.a$?.queryTableFieldId != null) {
+                        column.queryTableFieldId = String(c.a$.queryTableFieldId);
+                    }
+                    return column;
+                });
+                queryTables.push({ tableTitle, partXml, columns });
+            }
+        }
+        const parts = {};
+        if (customXmlParts.length)
+            parts.customXmlParts = customXmlParts;
+        if (connectionsXml)
+            parts.connectionsXml = connectionsXml;
+        if (queryTables.length)
+            parts.queryTables = queryTables;
+        return hasPowerQueryParts(parts) ? parts : undefined;
+    }
+    async getConditionalFormatting() {
+        // Workbook-wide view is an aggregation over the per-sheet caches so
+        // per-sheet and workbook-wide callers observe the same rule objects.
+        const conditionalFormatting = [];
+        for (const element of this._getSheets()) {
+            conditionalFormatting.push(...(await this.getConditionalFormattingForSheet(Number(element.a$.sheetId))));
+        }
+        return conditionalFormatting;
+    }
+    getConditionalFormattingForSheet(sheetId) {
+        let cached = this.conditionalFormattingBySheetCache.get(sheetId);
+        if (!cached) {
+            cached = this.parseConditionalFormattingForSheet(sheetId);
+            this.conditionalFormattingBySheetCache.set(sheetId, cached);
+        }
+        return cached;
+    }
+    async parseConditionalFormattingForSheet(sheetId) {
+        const element = this.worksheetBySheetId.get(sheetId);
+        if (!element) {
+            return [];
+        }
+        const rid = element.a$["r:id"];
+        // x14 conditional formatting lives in extLst, classic rules in
+        // <conditionalFormatting>; skip the full-DOM parse when neither exists.
+        const features = this.sheetFeatures.get(rid);
+        if (features && !features.conditionalFormatting && !features.extLst) {
+            return [];
+        }
+        const sheet_data = await this.getSheetData(rid);
+        return this.getConditionaFormattingFromSheet(sheetId, sheet_data);
+    }
+    async getDataValidations() {
+        // Workbook-wide view is an aggregation over the per-sheet caches.
+        // The row stream stamps these rules' ids onto covered cells, so every
+        // caller must see the SAME minted ids (see the
+        // `dataValidationsBySheetCache` field doc).
+        const dataValidations = [];
+        for (const element of this._getSheets()) {
+            dataValidations.push(...(await this.getDataValidationsForSheet(Number(element.a$.sheetId))));
+        }
+        return dataValidations;
+    }
+    getDataValidationsForSheet(sheetId) {
+        let cached = this.dataValidationsBySheetCache.get(sheetId);
+        if (!cached) {
+            cached = this.parseDataValidationsForSheet(sheetId);
+            this.dataValidationsBySheetCache.set(sheetId, cached);
+        }
+        return cached;
+    }
+    async parseDataValidationsForSheet(sheetId) {
+        const element = this.worksheetBySheetId.get(sheetId);
+        if (!element) {
+            return [];
+        }
+        const rid = element.a$["r:id"];
+        const sheetName = element.a$?.name;
+        // x14 data validations live in extLst, classic ones in
+        // <dataValidations>; skip the full-DOM parse when neither exists.
+        const features = this.sheetFeatures.get(rid);
+        if (features && !features.dataValidations && !features.extLst) {
+            return [];
+        }
+        const sheet_data = await this.getSheetData(rid);
+        return parseDataValidationsFromSheetData(this, sheetId, sheet_data, sheetName);
+    }
+    getNamedRanges() {
+        return this.namedRanges;
+    }
+    /**
+     * Parse the workbook's metadata files (docProps/core.xml + docProps/app.xml)
+     * and return a flat properties object. Returns undefined if neither file
+     * exists (won't happen for files written by Excel, but possible for
+     * minimal workbooks crafted by other tools).
+     */
+    async getProperties() {
+        const props = {};
+        const tryRead = async (path) => {
+            try {
+                return await this.zipParser.getText(path);
+            }
+            catch {
+                return undefined;
+            }
+        };
+        const coreXml = await tryRead("docProps/core.xml");
+        if (coreXml) {
+            const parsed = this.xmlParser.parse(coreXml);
+            const root = parsed?.["cp:coreProperties"] ??
+                parsed?.coreProperties ??
+                parsed?.["coreProperties"];
+            // Elements with attributes (e.g. <dcterms:created xsi:type="...">VALUE)
+            // are parsed into `{a$: {...}, t$: "VALUE"}` with this config — see
+            // XMLOptions2 (`textNodeName: "t$"`). Bare text nodes come through as
+            // plain strings. Read both shapes.
+            const textOf = (val) => {
+                if (val == null)
+                    return undefined;
+                if (typeof val === "string")
+                    return val;
+                if (typeof val === "number")
+                    return String(val);
+                if (typeof val === "object") {
+                    const obj = val;
+                    if ("t$" in obj)
+                        return textOf(obj["t$"]);
+                    if ("#text" in obj)
+                        return textOf(obj["#text"]);
+                }
+                return undefined;
+            };
+            if (root && typeof root === "object") {
+                props.title = textOf(root["dc:title"] ?? root.title);
+                props.subject = textOf(root["dc:subject"] ?? root.subject);
+                props.creator = textOf(root["dc:creator"] ?? root.creator);
+                props.keywords = textOf(root["cp:keywords"] ?? root.keywords);
+                props.description = textOf(root["dc:description"] ?? root.description);
+                props.lastModifiedBy = textOf(root["cp:lastModifiedBy"] ?? root.lastModifiedBy);
+                props.category = textOf(root["cp:category"] ?? root.category);
+                props.created = textOf(root["dcterms:created"] ?? root.created);
+                props.modified = textOf(root["dcterms:modified"] ?? root.modified);
+            }
+        }
+        const appXml = await tryRead("docProps/app.xml");
+        if (appXml) {
+            const parsed = this.xmlParser.parse(appXml);
+            const root = parsed?.Properties ?? parsed?.properties;
+            if (root && typeof root === "object") {
+                const textOf = (val) => {
+                    if (typeof val === "string")
+                        return val;
+                    if (typeof val === "number")
+                        return String(val);
+                    return undefined;
+                };
+                props.company = textOf(root.Company);
+                props.manager = textOf(root.Manager);
+                props.application = textOf(root.Application);
+            }
+        }
+        // Strip empty fields so callers can spread cleanly.
+        for (const key of Object.keys(props)) {
+            if (props[key] === undefined || props[key] === "") {
+                delete props[key];
+            }
+        }
+        return Object.keys(props).length ? props : undefined;
+    }
+    async getSlicers() {
+        return this.getSlicersForWorkbook();
+    }
+    async getSlicersForWorkbook() {
+        const slicers = [];
+        try {
+            // Read workbook relationships to find slicer files
+            const workbookRelsPath = "xl/_rels/workbook.xml.rels";
+            const workbookRelsContent = await this.zipParser.getText(workbookRelsPath);
+            const workbookRels = this.xmlParser.parse(workbookRelsContent);
+            const relationships = get(workbookRels, "Relationships.Relationship");
+            const relationshipsArray = Array.isArray(relationships)
+                ? relationships
+                : relationships
+                    ? [relationships]
+                    : [];
+            // Find slicer and slicerCache relationships
+            const slicerRels = relationshipsArray.filter((rel) => rel.a$.Type ===
+                "http://schemas.microsoft.com/office/2007/relationships/slicer");
+            const slicerCacheRels = relationshipsArray.filter((rel) => rel.a$.Type ===
+                "http://schemas.microsoft.com/office/2007/relationships/slicerCache");
+            const toArray = (value) => Array.isArray(value) ? value : value ? [value] : [];
+            const slicerPathToSheetIds = new Map();
+            const addSlicerPath = (path, sheetId) => {
+                const existing = slicerPathToSheetIds.get(path) ?? new Set();
+                if (typeof sheetId === "number") {
+                    existing.add(sheetId);
+                }
+                slicerPathToSheetIds.set(path, existing);
+            };
+            for (const slicerRel of slicerRels) {
+                const target = slicerRel?.a$?.Target;
+                if (!target)
+                    continue;
+                addSlicerPath(this.resolveSheetPath(target));
+            }
+            // Read worksheet relationship files to discover slicer relationships.
+            // Some Excel files only declare slicers at sheet level (not workbook rels).
+            const workSheets = this._getSheets();
+            const sheetRelContext = new Map();
+            for (const sheet of workSheets) {
+                const rid = sheet?.a$?.["r:id"];
+                const currentSheetId = Number(sheet?.a$?.sheetId);
+                if (!rid || Number.isNaN(currentSheetId))
+                    continue;
+                const relation = this.relations[rid];
+                if (!relation?.target)
+                    continue;
+                const sheetPath = this.resolveSheetPath(relation.target);
+                const sheetRelPath = sheetPath.replace("worksheets", "worksheets/_rels") + ".rels";
+                try {
+                    const sheetRelContent = await this.zipParser.getText(sheetRelPath);
+                    if (!sheetRelContent)
+                        continue;
+                    const sheetRels = this.xmlParser.parse(sheetRelContent);
+                    const sheetRelations = get(sheetRels, "Relationships.Relationship");
+                    const sheetRelationsArray = toArray(sheetRelations);
+                    const drawingRel = sheetRelationsArray.find((rel) => rel?.a$?.Type ===
+                        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing");
+                    const drawingPath = drawingRel?.a$?.Target
+                        ? this.resolveRelationshipTarget(sheetRelPath, drawingRel.a$.Target)
+                        : undefined;
+                    sheetRelContext.set(currentSheetId, { drawingPath });
+                    const sheetSlicerRels = sheetRelationsArray.filter((rel) => rel?.a$?.Type ===
+                        "http://schemas.microsoft.com/office/2007/relationships/slicer");
+                    for (const rel of sheetSlicerRels) {
+                        const target = rel?.a$?.Target;
+                        if (!target)
+                            continue;
+                        addSlicerPath(this.resolveRelationshipTarget(sheetRelPath, target), currentSheetId);
+                    }
+                }
+                catch {
+                    // Sheet may not have a relationship part.
+                    continue;
+                }
+            }
+            if (slicerPathToSheetIds.size === 0) {
+                return slicers;
+            }
+            // Parse slicer cache files to build a map of cache to table IDs
+            const slicerCacheMap = new Map();
+            for (const cacheRel of slicerCacheRels) {
+                try {
+                    let cachePath = cacheRel.a$.Target;
+                    if (cachePath.startsWith("/")) {
+                        cachePath = cachePath.substring(1);
+                    }
+                    else if (!cachePath.startsWith("xl/")) {
+                        cachePath = `xl/${cachePath}`;
+                    }
+                    const cacheContent = await this.zipParser.getText(cachePath);
+                    if (!cacheContent)
+                        continue;
+                    const cacheXml = this.xmlParser.parse(cacheContent);
+                    const cacheDefinition = get(cacheXml, "x14:slicerCacheDefinition") ||
+                        get(cacheXml, "slicerCacheDefinition");
+                    if (!cacheDefinition)
+                        continue;
+                    // Extract cache name
+                    const cacheName = cacheDefinition.a$?.name || "";
+                    // Extract title (sourceName is the column name)
+                    const title = cacheDefinition.a$?.sourceName || cacheName;
+                    // Look for tableSlicerCache extension
+                    const extList = getWithFallback(cacheDefinition, [
+                        "x14:extLst.x14:ext",
+                        "x14:extLst.ext",
+                        "extLst.x14:ext",
+                        "extLst.ext",
+                        "extLst.x:ext",
+                    ]);
+                    const extArray = toArray(extList);
+                    for (const ext of extArray) {
+                        const tableSlicerCache = getWithFallback(ext, [
+                            "x15:tableSlicerCache",
+                            "tableSlicerCache",
+                            "x:tableSlicerCache",
+                        ]);
+                        if (tableSlicerCache) {
+                            const tableIdRaw = tableSlicerCache.a$?.tableId;
+                            const tableId = String(tableIdRaw ?? "");
+                            const columnIndex = Number(tableSlicerCache.a$?.column) - 1; // Convert to 0-based
+                            if (tableId && !isNaN(columnIndex)) {
+                                slicerCacheMap.set(cacheName, { tableId, columnIndex, title });
+                            }
+                            break;
+                        }
+                    }
+                }
+                catch (err) {
+                    console.log("Error parsing slicer cache:", err);
+                }
+            }
+            // Parse slicer files and match them with worksheet positions
+            for (const [slicerPath, linkedSheetIds] of slicerPathToSheetIds) {
+                try {
+                    const slicerContent = await this.zipParser.getText(slicerPath);
+                    if (!slicerContent)
+                        continue;
+                    const slicerXml = this.xmlParser.parse(slicerContent);
+                    const slicerDefinitionNode = getWithFallback(slicerXml, [
+                        "x14:slicer",
+                        "slicer",
+                        "x14:slicers.x14:slicer",
+                        "x14:slicers.slicer",
+                        "slicers.x14:slicer",
+                        "slicers.slicer",
+                    ]);
+                    const slicerDefinition = Array.isArray(slicerDefinitionNode)
+                        ? slicerDefinitionNode[0]
+                        : slicerDefinitionNode;
+                    if (!slicerDefinition)
+                        continue;
+                    const slicerAttrs = slicerDefinition.a$ || {};
+                    const cacheName = slicerAttrs.cache || slicerAttrs.name;
+                    const caption = slicerAttrs.caption || cacheName;
+                    // Look up cache information
+                    const cacheInfo = slicerCacheMap.get(cacheName);
+                    if (!cacheInfo) {
+                        continue;
+                    }
+                    // Find the slicer position by checking worksheet relationships
+                    let position = null;
+                    let sheetId;
+                    for (const sheet of workSheets) {
+                        const currentSheetId = Number(sheet?.a$?.sheetId);
+                        if (Number.isNaN(currentSheetId))
+                            continue;
+                        if (linkedSheetIds.size && !linkedSheetIds.has(currentSheetId)) {
+                            continue;
+                        }
+                        const context = sheetRelContext.get(currentSheetId);
+                        if (!context)
+                            continue;
+                        sheetId = currentSheetId;
+                        if (context.drawingPath) {
+                            const drawingContent = await this.zipParser.getText(context.drawingPath);
+                            if (drawingContent) {
+                                const drawingXml = this.xmlParser.parse(drawingContent);
+                                const wsDr = getWithFallback(drawingXml, ["xdr:wsDr", "wsDr"]);
+                                if (wsDr) {
+                                    const anchors = [
+                                        ...toArray(wsDr["xdr:oneCellAnchor"] || wsDr["oneCellAnchor"]),
+                                        ...toArray(wsDr["xdr:twoCellAnchor"] || wsDr["twoCellAnchor"]),
+                                    ];
+                                    let firstSlicerAnchor = null;
+                                    for (const anchor of anchors) {
+                                        const alternateContent = getWithFallback(anchor, [
+                                            "mc:AlternateContent",
+                                            "AlternateContent",
+                                        ]);
+                                        const choices = toArray(alternateContent?.["mc:Choice"] ??
+                                            alternateContent?.["Choice"]);
+                                        const graphicFrames = [
+                                            ...toArray(getWithFallback(anchor, [
+                                                "xdr:graphicFrame",
+                                                "graphicFrame",
+                                            ])),
+                                            ...choices.flatMap((choice) => toArray(getWithFallback(choice, [
+                                                "xdr:graphicFrame",
+                                                "graphicFrame",
+                                            ]))),
+                                        ];
+                                        for (const graphicFrame of graphicFrames) {
+                                            const graphicData = getWithFallback(graphicFrame, [
+                                                "a:graphic.a:graphicData",
+                                                "a:graphic.graphicData",
+                                                "graphic.a:graphicData",
+                                                "graphic.graphicData",
+                                                "a:graphicData",
+                                                "graphicData",
+                                            ]);
+                                            const uri = graphicData?.a$?.uri;
+                                            const isSlicerGraphic = typeof uri === "string" && uri.includes("/slicer");
+                                            if (!isSlicerGraphic) {
+                                                continue;
+                                            }
+                                            const nvGraphicFramePr = getWithFallback(graphicFrame, [
+                                                "xdr:nvGraphicFramePr",
+                                                "nvGraphicFramePr",
+                                            ]);
+                                            const cNvPr = getWithFallback(nvGraphicFramePr, [
+                                                "xdr:cNvPr",
+                                                "cNvPr",
+                                            ]);
+                                            const shapeName = cNvPr?.a$?.name;
+                                            if (!firstSlicerAnchor) {
+                                                firstSlicerAnchor = anchor;
+                                            }
+                                            if (shapeName === caption || shapeName === cacheName) {
+                                                position = this.extractSlicerPosition(anchor, currentSheetId);
+                                                break;
+                                            }
+                                        }
+                                        if (position)
+                                            break;
+                                    }
+                                    if (!position && firstSlicerAnchor) {
+                                        position = this.extractSlicerPosition(firstSlicerAnchor, currentSheetId);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    // Create default position if we couldn't find one
+                    if (!position && sheetId !== undefined) {
+                        position = {
+                            sheetId,
+                            overlayPosition: {
+                                anchorCell: {
+                                    rowIndex: 1,
+                                    columnIndex: 1,
+                                },
+                                offsetXPixels: 0,
+                                offsetYPixels: 0,
+                                widthPixels: 200,
+                                heightPixels: 300,
+                            },
+                        };
+                    }
+                    if (position) {
+                        const slicer = {
+                            slicerId: uuid(),
+                            spec: {
+                                type: "table",
+                                tableIds: [cacheInfo.tableId],
+                                columnIndex: cacheInfo.columnIndex,
+                                title: caption || cacheInfo.title,
+                            },
+                            position,
+                        };
+                        slicers.push(slicer);
+                    }
+                }
+                catch (err) {
+                    console.log("Error parsing slicer:", err);
+                }
+            }
+        }
+        catch (err) {
+            console.log("Error getting slicers from workbook:", err);
+        }
+        return slicers;
+    }
+    extractSlicerPosition(anchor, sheetId) {
+        try {
+            // Handle oneCellAnchor
+            const oneCellFrom = get(anchor, "xdr:from") || get(anchor, "from");
+            const hasTwoCellTarget = get(anchor, "xdr:to") || get(anchor, "to");
+            if (oneCellFrom && !hasTwoCellTarget) {
+                const extNode = get(anchor, "xdr:ext") || get(anchor, "ext");
+                const extAttributes = (extNode && (extNode.a$ ?? extNode)) || {};
+                const col = this.parseIntSafe(get(oneCellFrom, "xdr:col") || get(oneCellFrom, "col"));
+                const row = this.parseIntSafe(get(oneCellFrom, "xdr:row") || get(oneCellFrom, "row"));
+                const colOff = this.parseIntSafe(get(oneCellFrom, "xdr:colOff") || get(oneCellFrom, "colOff"));
+                const rowOff = this.parseIntSafe(get(oneCellFrom, "xdr:rowOff") || get(oneCellFrom, "rowOff"));
+                // Convert EMU to pixels (1 EMU = 1/9525 pixels)
+                const width = extAttributes.cx
+                    ? Math.round(parseInt(String(extAttributes.cx), 10) / 9525)
+                    : 200;
+                const height = extAttributes.cy
+                    ? Math.round(parseInt(String(extAttributes.cy), 10) / 9525)
+                    : 300;
+                return {
+                    sheetId,
+                    overlayPosition: {
+                        anchorCell: {
+                            rowIndex: row + 1,
+                            columnIndex: col + 1,
+                        },
+                        offsetXPixels: Math.round(colOff / 9525),
+                        offsetYPixels: Math.round(rowOff / 9525),
+                        widthPixels: width,
+                        heightPixels: height,
+                    },
+                };
+            }
+            // Handle twoCellAnchor
+            const fromCell = get(anchor, "xdr:from") || get(anchor, "from");
+            const toCell = get(anchor, "xdr:to") || get(anchor, "to");
+            if (fromCell && toCell) {
+                const col = this.parseIntSafe(get(fromCell, "xdr:col") || get(fromCell, "col"));
+                const row = this.parseIntSafe(get(fromCell, "xdr:row") || get(fromCell, "row"));
+                const colOff = this.parseIntSafe(get(fromCell, "xdr:colOff") || get(fromCell, "colOff"));
+                const rowOff = this.parseIntSafe(get(fromCell, "xdr:rowOff") || get(fromCell, "rowOff"));
+                const toCol = this.parseIntSafe(get(toCell, "xdr:col") || get(toCell, "col"));
+                const toRow = this.parseIntSafe(get(toCell, "xdr:row") || get(toCell, "row"));
+                // Estimate size based on cell span
+                const width = Math.max((toCol - col) * 64, 100);
+                const height = Math.max((toRow - row) * 20, 100);
+                return {
+                    sheetId,
+                    overlayPosition: {
+                        anchorCell: {
+                            rowIndex: row + 1,
+                            columnIndex: col + 1,
+                        },
+                        offsetXPixels: Math.round(colOff / 9525),
+                        offsetYPixels: Math.round(rowOff / 9525),
+                        widthPixels: width,
+                        heightPixels: height,
+                    },
+                };
+            }
+            return null;
+        }
+        catch (err) {
+            console.log("Error extracting slicer position:", err);
+            return null;
+        }
+    }
+    parseIntSafe(value) {
+        const parsed = parseInt(typeof value === "number" ? String(value) : value ?? "0", 10);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    }
+    /**
+     * Get external workbook links from the XLSX file.
+     * These are needed to preserve formulas that reference other workbooks like [1]Sheet!A1
+     */
+    async getExternalLinks() {
+        const externalLinks = [];
+        try {
+            // Read workbook relationships to find external link files
+            const workbookRelsPath = "xl/_rels/workbook.xml.rels";
+            const workbookRelsContent = await this.zipParser.getText(workbookRelsPath);
+            if (!workbookRelsContent) {
+                return externalLinks;
+            }
+            const workbookRels = this.xmlParser.parse(workbookRelsContent);
+            const relationships = get(workbookRels, "Relationships.Relationship");
+            const relationshipsArray = Array.isArray(relationships)
+                ? relationships
+                : relationships
+                    ? [relationships]
+                    : [];
+            // Find external link relationships
+            const externalLinkRels = relationshipsArray.filter((rel) => rel.a$?.Type ===
+                "http://schemas.openxmlformats.org/officeDocument/2006/relationships/externalLink");
+            // Process each external link
+            for (let i = 0; i < externalLinkRels.length; i++) {
+                const rel = externalLinkRels[i];
+                const target = rel.a$?.Target;
+                if (!target)
+                    continue;
+                // Resolve the path
+                const externalLinkPath = target.startsWith("/")
+                    ? target.substring(1)
+                    : `xl/${target}`;
+                try {
+                    // Read the external link XML
+                    const xmlContent = await this.zipParser.getText(externalLinkPath);
+                    if (!xmlContent)
+                        continue;
+                    // Parse to extract sheet names and target
+                    const parsed = this.xmlParser.parse(xmlContent);
+                    const externalBook = get(parsed, "externalLink.externalBook") ||
+                        get(parsed, "externalLink.x:externalBook");
+                    // Extract sheet names if available
+                    const sheetNamesNode = get(externalBook, "sheetNames.sheetName") ||
+                        get(externalBook, "x:sheetNames.x:sheetName");
+                    const sheetNamesArray = Array.isArray(sheetNamesNode)
+                        ? sheetNamesNode
+                        : sheetNamesNode
+                            ? [sheetNamesNode]
+                            : [];
+                    const sheetNames = sheetNamesArray
+                        .map((sn) => sn?.a$?.val)
+                        .filter(Boolean);
+                    // Read the relationship file for the external link to get the target path
+                    const externalLinkDir = externalLinkPath.substring(0, externalLinkPath.lastIndexOf("/"));
+                    const externalLinkName = externalLinkPath.substring(externalLinkPath.lastIndexOf("/") + 1);
+                    const relsPath = `${externalLinkDir}/_rels/${externalLinkName}.rels`;
+                    let targetPath = "";
+                    let relsContent;
+                    const relsXml = await this.zipParser.getText(relsPath);
+                    if (relsXml) {
+                        relsContent = relsXml;
+                        const relsData = this.xmlParser.parse(relsXml);
+                        const extRels = get(relsData, "Relationships.Relationship");
+                        const extRelsArray = Array.isArray(extRels)
+                            ? extRels
+                            : extRels
+                                ? [extRels]
+                                : [];
+                        // Find the external book relationship
+                        const bookRel = extRelsArray.find((r) => r.a$?.Type ===
+                            "http://schemas.openxmlformats.org/officeDocument/2006/relationships/externalLinkPath");
+                        if (bookRel?.a$?.Target) {
+                            targetPath = bookRel.a$.Target;
+                        }
+                    }
+                    // The link index is 1-based (matches [1], [2], etc. in formulas)
+                    const linkIndex = i + 1;
+                    externalLinks.push({
+                        linkIndex,
+                        target: targetPath,
+                        sheetNames: sheetNames.length > 0 ? sheetNames : undefined,
+                        xmlContent,
+                        relsContent,
+                    });
+                }
+                catch (err) {
+                    console.log(`Error parsing external link ${externalLinkPath}:`, err);
+                }
+            }
+        }
+        catch (err) {
+            console.log("Error getting external links:", err);
+        }
+        return externalLinks;
+    }
+}