@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,2896 @@
+import { addressToCell, cellToAddress, getCellXfsKey, uuid, } from "@rowsncolumns/utils";
+import { XMLParser } from "fast-xml-parser";
+import { get } from "lodash-es";
+import { Unescape } from "../../utils";
+import { ZipParser } from "../../zip-parser";
+import { SheetDataValidationStamper } from "../../dv-cell-stamp";
+import { BaseWorkbookPlugin } from "../base/index";
+import { detectValueTypeAndPattern } from "../xlsx/value-type-detection";
+import { extractConditionalFormats } from "./conditional-formatting";
+import { extractDataValidations } from "./data-validations";
+import { convertOdsFormulaToExcel } from "./formula";
+import { extractSparklines, extractSparklineData, } from "./sparklines";
+import { OdsStyles } from "./styles";
+const ODS_XML_OPTIONS = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    ignoreDeclaration: true,
+    // We keep namespaces because ODS relies on them (table:, office:, text:)
+    removeNSPrefix: false,
+    // Disable entity processing to avoid expansion limits on large files,
+    // then decode the bounded set of entities ourselves (same approach as
+    // the XLSX plugin's XMLTagProcessor) so text and attribute values don't
+    // keep literal &/</
 sequences.
+    processEntities: false,
+    tagValueProcessor: (_name, value) => Unescape(value),
+    attributeValueProcessor: (_name, value) => Unescape(value),
+};
+const ODS_ORDERED_XML_OPTIONS = {
+    ...ODS_XML_OPTIONS,
+    preserveOrder: true,
+};
+const DISPLAY_CURRENCY_REGEX = /[$€¥£₹]/;
+function findChild(children, tagName) {
+    return children?.find((child) => child[tagName]);
+}
+function getChildren(node, tagName) {
+    const found = findChild(node, tagName);
+    return found ? found[tagName] : undefined;
+}
+function getAttribute(node, attributeName) {
+    if (!node)
+        return undefined;
+    if (node[`@_${attributeName}`] !== undefined) {
+        return node[`@_${attributeName}`];
+    }
+    if (node[":@"] && node[":@"][`@_${attributeName}`] !== undefined) {
+        return node[":@"][`@_${attributeName}`];
+    }
+    return undefined;
+}
+function fastMergeCellFormats(...formats) {
+    let result;
+    for (const format of formats) {
+        if (!format)
+            continue;
+        if (!result) {
+            result = { ...format };
+            continue;
+        }
+        // Merge properties
+        if (format.backgroundColor !== undefined)
+            result.backgroundColor = format.backgroundColor;
+        if (format.horizontalAlignment !== undefined)
+            result.horizontalAlignment = format.horizontalAlignment;
+        if (format.verticalAlignment !== undefined)
+            result.verticalAlignment = format.verticalAlignment;
+        if (format.wrapStrategy !== undefined)
+            result.wrapStrategy = format.wrapStrategy;
+        if (format.textRotation !== undefined)
+            result.textRotation = format.textRotation;
+        if (format.indent !== undefined)
+            result.indent = format.indent;
+        // Objects
+        if (format.textFormat) {
+            result.textFormat = result.textFormat
+                ? { ...result.textFormat, ...format.textFormat }
+                : { ...format.textFormat };
+        }
+        if (format.numberFormat) {
+            result.numberFormat = { ...format.numberFormat };
+        }
+        if (format.borders) {
+            result.borders = result.borders
+                ? { ...result.borders }
+                : { ...format.borders };
+            if (format.borders.top)
+                result.borders.top = format.borders.top;
+            if (format.borders.bottom)
+                result.borders.bottom = format.borders.bottom;
+            if (format.borders.left)
+                result.borders.left = format.borders.left;
+            if (format.borders.right)
+                result.borders.right = format.borders.right;
+        }
+    }
+    return result;
+}
+// Inverse of the exporter's mapConditionToFilterCondition: ODS
+// <table:filter-condition table:operator> -> in-app condition type. "=" is
+// intentionally absent — it round-trips as a value-list (the common case),
+// which yields the same visible rows as NUMBER_EQ.
+const ODS_OPERATOR_TO_CONDITION = {
+    "!=": "NUMBER_NOT_EQ",
+    "<>": "NUMBER_NOT_EQ",
+    ">": "NUMBER_GREATER",
+    ">=": "NUMBER_GREATER_THAN_EQ",
+    "<": "NUMBER_LESS",
+    "<=": "NUMBER_LESS_THAN_EQ",
+    between: "NUMBER_BETWEEN",
+    "not-between": "NUMBER_NOT_BETWEEN",
+    contains: "TEXT_CONTAINS",
+    "does-not-contain": "TEXT_NOT_CONTAINS",
+    "begins-with": "TEXT_STARTS_WITH",
+    begins: "TEXT_STARTS_WITH",
+    "ends-with": "TEXT_ENDS_WITH",
+    endswith: "TEXT_ENDS_WITH",
+    empty: "BLANK",
+    "non-empty": "NOT_BLANK",
+};
+export class OdsPlugin extends BaseWorkbookPlugin {
+    zipParser;
+    xmlParser;
+    xmlOrderedParser;
+    contentXml;
+    contentXmlOrdered;
+    settingsXml;
+    odsStyles;
+    cellXfs = new Map();
+    sharedStrings = [];
+    richSharedStringRuns = new Map();
+    sharedStringIndexByValue = new Map();
+    sheetCache = null;
+    sparklinesBySheet = new Map();
+    constructor() {
+        super();
+        this.zipParser = new ZipParser();
+        this.xmlParser = new XMLParser(ODS_XML_OPTIONS);
+        this.xmlOrderedParser = new XMLParser(ODS_ORDERED_XML_OPTIONS);
+        this.odsStyles = new OdsStyles();
+    }
+    async load(buffer, password) {
+        const source = buffer instanceof File ? await buffer.arrayBuffer() : buffer;
+        await this.zipParser.load(source, password);
+        this.cellXfs.clear();
+        this.odsStyles.reset();
+        this.sharedStrings = [];
+        this.richSharedStringRuns = new Map();
+        this.sharedStringIndexByValue.clear();
+        this.sheetCache = null;
+        this.sparklinesBySheet = new Map();
+        this.settingsXml = null;
+        try {
+            const content = this.zipParser.Get("content.xml");
+            if (content) {
+                this.contentXml = this.xmlParser.parse(content);
+                this.contentXmlOrdered = this.xmlOrderedParser.parse(content);
+                this.odsStyles.parseContentXml(this.contentXml);
+            }
+            const styles = this.zipParser.Get("styles.xml");
+            if (styles) {
+                const parsedStyles = this.xmlParser.parse(styles);
+                this.odsStyles.parseStylesXml(parsedStyles);
+            }
+            const settings = this.zipParser.Get("settings.xml");
+            if (settings) {
+                this.settingsXml = this.xmlParser.parse(settings);
+            }
+        }
+        catch (e) {
+            console.error("Failed to parse ODS content.xml", e);
+        }
+    }
+    getCellXfs() {
+        return this.cellXfs;
+    }
+    getSharedStrings() {
+        return this.sharedStrings;
+    }
+    getOrCreateSharedStringIndex(value, runs) {
+        const key = runs?.length ? JSON.stringify({ value, runs }) : value;
+        const existing = this.sharedStringIndexByValue.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.sharedStrings.length;
+        this.sharedStrings.push(value);
+        if (runs?.length) {
+            this.richSharedStringRuns.set(index, runs);
+        }
+        this.sharedStringIndexByValue.set(key, index);
+        return index;
+    }
+    registerFormat(format) {
+        const key = getCellXfsKey(format);
+        if (!this.cellXfs.has(key)) {
+            this.cellXfs.set(key, format);
+        }
+        return key;
+    }
+    dispose() {
+        this.zipParser.Dispose();
+        this.contentXml = null;
+        this.contentXmlOrdered = null;
+        this.settingsXml = null;
+        this.sheetCache = null;
+    }
+    getSpreadsheetNode() {
+        if (!this.contentXml)
+            return undefined;
+        return (get(this.contentXml, "office:document-content.office:body.office:spreadsheet") || get(this.contentXml, "document-content.body.spreadsheet"));
+    }
+    getTables() {
+        const body = this.getSpreadsheetNode();
+        if (!body)
+            return [];
+        const tables = get(body, "table:table") || get(body, "table");
+        return Array.isArray(tables) ? tables : tables ? [tables] : [];
+    }
+    getSheetCount() {
+        return this.getTables().length;
+    }
+    ensureSheetCache() {
+        if (this.sheetCache) {
+            return this.sheetCache;
+        }
+        const cache = this.buildSheetCache();
+        this.sheetCache = cache;
+        return cache;
+    }
+    buildSheetCache() {
+        const tables = this.getTables();
+        const sheets = [];
+        const sheetContexts = [];
+        tables.forEach((table, index) => {
+            const name = table["@_table:name"] ||
+                table["@_name"] ||
+                table["table:name"] ||
+                table["name"] ||
+                `Sheet${index + 1}`;
+            const sheet = {
+                sheetId: index + 1,
+                title: name,
+                hidden: table["@_table:style-name"]?.includes("hidden") ||
+                    table["table:style-name"]?.includes("hidden") ||
+                    false,
+                rowMetadata: [],
+                columnMetadata: [],
+                merges: [],
+            };
+            // Column metadata from table-column elements
+            const columnNodes = get(table, "table:table-column") || get(table, "table-column") || [];
+            const allColumns = Array.isArray(columnNodes)
+                ? columnNodes
+                : columnNodes
+                    ? [columnNodes]
+                    : [];
+            let currentColumnIndex = 1;
+            let detectedColumnCount = 0;
+            let defaultColumnWidth;
+            let defaultColumnStyleName;
+            for (const column of allColumns) {
+                if (!column)
+                    continue;
+                const colsRepeated = parseInt(getAttribute(column, "table:number-columns-repeated") ||
+                    getAttribute(column, "number-columns-repeated") ||
+                    "1", 10);
+                const styleName = getAttribute(column, "table:style-name") ||
+                    getAttribute(column, "style-name");
+                const visibility = getAttribute(column, "table:visibility") ||
+                    getAttribute(column, "visibility");
+                const columnStyle = styleName
+                    ? this.odsStyles.getColumnStyle(styleName)
+                    : undefined;
+                const width = columnStyle?.width;
+                const isHidden = visibility === "collapse" ||
+                    visibility === "hidden" ||
+                    visibility === "none" ||
+                    columnStyle?.hidden;
+                for (let c = 0; c < colsRepeated; c++) {
+                    const props = {};
+                    let shouldAssign = false;
+                    if (typeof width === "number") {
+                        props.size = width;
+                        if (defaultColumnWidth === undefined) {
+                            defaultColumnWidth = width;
+                            defaultColumnStyleName = styleName;
+                        }
+                        const widthDiffers = defaultColumnWidth === undefined
+                            ? true
+                            : Math.abs(width - defaultColumnWidth) > 0.5;
+                        const styleDiffers = styleName &&
+                            defaultColumnStyleName &&
+                            styleName !== defaultColumnStyleName;
+                        if (widthDiffers || styleDiffers) {
+                            props.resizedByUser = true;
+                        }
+                        shouldAssign = true;
+                    }
+                    if (isHidden) {
+                        props.hiddenByUser = true;
+                        shouldAssign = true;
+                    }
+                    if (shouldAssign) {
+                        sheet.columnMetadata[currentColumnIndex] = props;
+                    }
+                    currentColumnIndex++;
+                }
+                detectedColumnCount = Math.max(detectedColumnCount, currentColumnIndex - 1);
+            }
+            // Row metadata from table-row elements
+            const rowNodes = get(table, "table:table-row") || get(table, "table-row") || [];
+            const allRows = Array.isArray(rowNodes) ? rowNodes : [rowNodes];
+            // DO NOT DELETE
+            // console.log("allRows", allRows);
+            let currentRowIndex = 1;
+            let defaultRowHeight;
+            let defaultRowStyleName;
+            let detectedRowCount = 0;
+            for (const row of allRows) {
+                if (!row)
+                    continue;
+                const rowsRepeated = parseInt(getAttribute(row, "table:number-rows-repeated") ||
+                    getAttribute(row, "number-rows-repeated") ||
+                    "1", 10);
+                const styleName = getAttribute(row, "table:style-name") ||
+                    getAttribute(row, "style-name");
+                const visibility = getAttribute(row, "table:visibility") ||
+                    getAttribute(row, "visibility");
+                const rowStyle = styleName
+                    ? this.odsStyles.getRowStyle(styleName)
+                    : undefined;
+                const height = rowStyle?.height;
+                const isHidden = visibility === "collapse" ||
+                    visibility === "hidden" ||
+                    visibility === "none" ||
+                    rowStyle?.hidden;
+                const effectiveRepeats = Math.min(rowsRepeated, 10000);
+                const shouldProcessRowMetadata = typeof height === "number" || isHidden;
+                if (!shouldProcessRowMetadata) {
+                    currentRowIndex += effectiveRepeats;
+                    detectedRowCount = Math.max(detectedRowCount, currentRowIndex - 1);
+                    continue;
+                }
+                for (let r = 0; r < effectiveRepeats; r++) {
+                    const props = {};
+                    let shouldAssign = false;
+                    if (typeof height === "number") {
+                        props.size = height;
+                        if (defaultRowHeight === undefined) {
+                            defaultRowHeight = height;
+                            defaultRowStyleName = styleName;
+                        }
+                        const heightDiffers = defaultRowHeight === undefined
+                            ? true
+                            : Math.abs(height - defaultRowHeight) > 0.5;
+                        const styleDiffers = styleName &&
+                            defaultRowStyleName &&
+                            styleName !== defaultRowStyleName;
+                        if (heightDiffers || styleDiffers) {
+                            props.resizedByUser = true;
+                        }
+                        shouldAssign = true;
+                    }
+                    if (isHidden) {
+                        props.hiddenByUser = true;
+                        shouldAssign = true;
+                    }
+                    if (shouldAssign) {
+                        sheet.rowMetadata[currentRowIndex] = props;
+                    }
+                    currentRowIndex++;
+                }
+                detectedRowCount = Math.max(detectedRowCount, currentRowIndex - 1);
+            }
+            if (detectedRowCount > 0) {
+                sheet.rowCount = Math.max(sheet.rowCount ?? 0, detectedRowCount);
+            }
+            if (detectedColumnCount > 0) {
+                sheet.columnCount = Math.max(sheet.columnCount ?? 0, detectedColumnCount);
+            }
+            sheets.push(sheet);
+            sheetContexts.push({ node: table, sheetId: sheet.sheetId, name });
+        });
+        const sheetNameMap = this.buildSheetNameMap(sheetContexts);
+        const spreadsheetNode = this.getSpreadsheetNode();
+        const tableViews = this.extractTableViews(sheetContexts);
+        const conditionalFormatting = extractConditionalFormats({
+            sheetContexts,
+            sheetNameMap,
+            odsStyles: this.odsStyles,
+            getAttributes: this.getAttributes.bind(this),
+            parseRangeList: this.parseRangeList.bind(this),
+            normalizeExpression: this.normalizeExpression.bind(this),
+            normalizeConditionExpression: this.normalizeConditionExpression.bind(this),
+            toArray: this.toArray.bind(this),
+        });
+        const dataValidations = extractDataValidations({
+            sheetContexts,
+            sheetNameMap,
+            spreadsheetNode,
+            getAttributes: this.getAttributes.bind(this),
+            parseRangeList: this.parseRangeList.bind(this),
+            normalizeConditionExpression: this.normalizeConditionExpression.bind(this),
+            parseBooleanAttribute: this.parseBooleanAttribute.bind(this),
+            mapAlertStyle: this.mapAlertStyle.bind(this),
+            toArray: this.toArray.bind(this),
+        });
+        const namedRanges = this.extractNamedRanges(sheetContexts);
+        const { drawings, charts } = this.extractEmbeddedObjects(sheetContexts, sheetNameMap);
+        // Extract LibreOffice sparklines (calcext:sparkline-groups)
+        this.sparklinesBySheet = extractSparklines({
+            sheetContexts,
+            sheetNameMap,
+            getAttributes: this.getAttributes.bind(this),
+            toArray: this.toArray.bind(this),
+        });
+        const mergesMap = this.extractMerges(sheetContexts);
+        this.extractOutlineGroups(sheets);
+        const sheetSettings = this.extractSheetSettings(sheetContexts);
+        const basicFilters = this.extractBasicFilters(sheetContexts, sheetNameMap, spreadsheetNode);
+        for (const sheet of sheets) {
+            sheet.merges = mergesMap.get(sheet.sheetId) ?? sheet.merges ?? [];
+            const settings = sheetSettings.get(sheet.sheetId);
+            if (settings) {
+                if (settings.frozenRowCount !== undefined) {
+                    sheet.frozenRowCount = settings.frozenRowCount;
+                }
+                if (settings.frozenColumnCount !== undefined) {
+                    sheet.frozenColumnCount = settings.frozenColumnCount;
+                }
+                if (settings.showGridLines !== undefined) {
+                    sheet.showGridLines = settings.showGridLines;
+                }
+                if (settings.tabColor) {
+                    sheet.tabColor = settings.tabColor;
+                }
+            }
+            const filter = basicFilters.get(sheet.sheetId);
+            if (filter) {
+                sheet.basicFilter = filter;
+            }
+        }
+        return {
+            sheets,
+            tables: tableViews,
+            conditionalFormatting,
+            dataValidations,
+            namedRanges,
+            drawings,
+            charts,
+        };
+    }
+    extractTableViews(sheetContexts) {
+        if (!sheetContexts.length)
+            return [];
+        const spreadsheet = this.getSpreadsheetNode();
+        if (!spreadsheet)
+            return [];
+        const sheetNameMap = this.buildSheetNameMap(sheetContexts);
+        const tableViews = [];
+        const globalRanges = this.toArray(get(spreadsheet, "table:database-ranges.table:database-range") ||
+            get(spreadsheet, "database-ranges.database-range"));
+        for (const node of globalRanges) {
+            const tableView = this.convertDatabaseRangeNode(node, sheetNameMap, undefined, sheetContexts);
+            if (tableView) {
+                tableViews.push(tableView);
+            }
+        }
+        for (const context of sheetContexts) {
+            const inlineRanges = this.toArray(get(context.node, "table:database-range") ||
+                get(context.node, "database-range"));
+            for (const node of inlineRanges) {
+                const tableView = this.convertDatabaseRangeNode(node, sheetNameMap, context, sheetContexts);
+                if (tableView) {
+                    tableViews.push(tableView);
+                }
+            }
+        }
+        return tableViews;
+    }
+    convertDatabaseRangeNode(node, sheetNameMap, context, sheetContexts) {
+        const attrs = this.getAttributes(node);
+        if (!attrs)
+            return undefined;
+        const rangeAttr = attrs["@_table:target-range-address"] ||
+            attrs["@_target-range-address"] ||
+            attrs["@_table:cell-range-address"];
+        const ranges = this.parseRangeList(rangeAttr, sheetNameMap, context);
+        if (!ranges.length)
+            return undefined;
+        const [range] = ranges;
+        const title = attrs["@_table:display-label"] ||
+            attrs["@_table:name"] ||
+            attrs["@_name"] ||
+            `Table${range.sheetId}`;
+        const tableView = {
+            id: attrs["@_table:id"] || attrs["@_id"] || title,
+            sheetId: range.sheetId,
+            title,
+            range,
+        };
+        const headerRow = this.parseBooleanAttribute(attrs["@_table:contains-header"] || attrs["@_contains-header"]);
+        if (headerRow !== undefined) {
+            tableView.headerRow = headerRow;
+        }
+        const totalRow = this.parseBooleanAttribute(attrs["@_table:contains-total-row"] || attrs["@_contains-total-row"]);
+        if (totalRow !== undefined) {
+            tableView.totalRow = totalRow;
+        }
+        const filterButton = this.parseBooleanAttribute(attrs["@_table:display-filter-buttons"] ||
+            attrs["@_display-filter-buttons"]);
+        if (filterButton !== undefined) {
+            tableView.filterButton = filterButton;
+        }
+        const showRowStripes = this.parseBooleanAttribute(attrs["@_table:use-banding-rows"] || attrs["@_use-banding-rows"]);
+        if (showRowStripes !== undefined) {
+            tableView.showRowStripes = showRowStripes;
+        }
+        const showColumnStripes = this.parseBooleanAttribute(attrs["@_table:use-banding-columns"] || attrs["@_use-banding-columns"]);
+        if (showColumnStripes !== undefined) {
+            tableView.showColumnStripes = showColumnStripes;
+        }
+        const effectiveContext = context ??
+            sheetContexts?.find((entry) => entry.sheetId === range.sheetId);
+        const columns = this.extractTableColumnsFromHeader(range, effectiveContext, tableView.headerRow !== false);
+        if (columns?.length) {
+            tableView.columns = columns;
+        }
+        return tableView;
+    }
+    extractNamedRanges(sheetContexts) {
+        const spreadsheet = this.getSpreadsheetNode();
+        if (!spreadsheet)
+            return [];
+        const sheetNameMap = this.buildSheetNameMap(sheetContexts);
+        const namedRanges = [];
+        const processContainer = (container, context) => {
+            if (!container)
+                return;
+            const rangeNodes = this.toArray(get(container, "table:named-range") || get(container, "named-range"));
+            for (const node of rangeNodes) {
+                const attrs = this.getAttributes(node);
+                if (!attrs)
+                    continue;
+                const name = attrs["@_table:name"] ||
+                    attrs["@_name"] ||
+                    attrs["@_table:display-name"];
+                if (!name)
+                    continue;
+                const addressAttr = attrs["@_table:cell-range-address"] ||
+                    attrs["@_cell-range-address"] ||
+                    attrs["@_table:base-cell-address"] ||
+                    attrs["@_base-cell-address"];
+                const ranges = this.parseRangeList(addressAttr, sheetNameMap, context);
+                for (const range of ranges) {
+                    namedRanges.push({
+                        namedRangeId: uuid(),
+                        name,
+                        range,
+                    });
+                }
+            }
+            const expressionNodes = this.toArray(get(container, "table:named-expression") ||
+                get(container, "named-expression"));
+            for (const node of expressionNodes) {
+                const attrs = this.getAttributes(node);
+                if (!attrs)
+                    continue;
+                const name = attrs["@_table:name"] ||
+                    attrs["@_name"] ||
+                    attrs["@_table:display-name"];
+                if (!name)
+                    continue;
+                const expressionAttr = attrs["@_table:expression"] || attrs["@_expression"];
+                const excelFormula = this.normalizeExpression(expressionAttr);
+                if (excelFormula) {
+                    namedRanges.push({
+                        namedRangeId: uuid(),
+                        name,
+                        value: excelFormula,
+                    });
+                }
+            }
+        };
+        const globalContainers = this.toArray(get(spreadsheet, "table:named-expressions") ||
+            get(spreadsheet, "named-expressions"));
+        for (const container of globalContainers) {
+            processContainer(container);
+        }
+        for (const context of sheetContexts) {
+            const containers = this.toArray(get(context.node, "table:named-expressions") ||
+                get(context.node, "named-expressions"));
+            for (const container of containers) {
+                processContainer(container, context);
+            }
+        }
+        return namedRanges;
+    }
+    extractBasicFilters(sheetContexts, sheetNameMap, spreadsheetNode) {
+        const filters = new Map();
+        if (!sheetContexts.length) {
+            return filters;
+        }
+        const processNode = (node, context) => {
+            if (!node)
+                return;
+            const filterNode = get(node, "table:filter") || get(node, "filter");
+            if (!filterNode)
+                return;
+            const attrs = this.getAttributes(node);
+            if (!attrs)
+                return;
+            const rangeAttr = attrs["@_table:target-range-address"] ||
+                attrs["@_target-range-address"] ||
+                attrs["@_table:cell-range-address"] ||
+                attrs["@_cell-range-address"];
+            const ranges = this.parseRangeList(rangeAttr, sheetNameMap, context);
+            if (!ranges.length)
+                return;
+            const filterSpecs = this.convertFilterNodeToSpecs(filterNode);
+            if (!filterSpecs.length)
+                return;
+            const [range] = ranges;
+            const filterView = {
+                id: attrs["@_table:name"] || attrs["@_name"] || uuid(),
+                title: attrs["@_table:display-label"] ||
+                    attrs["@_table:name"] ||
+                    attrs["@_name"],
+                range,
+                filterSpecs,
+            };
+            filters.set(range.sheetId, filterView);
+        };
+        if (spreadsheetNode) {
+            const globalRanges = this.toArray(get(spreadsheetNode, "table:database-ranges.table:database-range") ||
+                get(spreadsheetNode, "database-ranges.database-range"));
+            for (const node of globalRanges) {
+                processNode(node);
+            }
+        }
+        for (const context of sheetContexts) {
+            const inlineRanges = this.toArray(get(context.node, "table:database-range") ||
+                get(context.node, "database-range"));
+            for (const node of inlineRanges) {
+                processNode(node, context);
+            }
+        }
+        return filters;
+    }
+    convertFilterNodeToSpecs(filterNode) {
+        const specMap = new Map();
+        const addConditions = (container) => {
+            const conditions = this.toArray(get(container, "table:filter-condition") ||
+                get(container, "filter-condition"));
+            for (const condition of conditions) {
+                this.applyFilterCondition(condition, specMap);
+            }
+        };
+        addConditions(filterNode);
+        const andNodes = this.toArray(get(filterNode, "table:filter-and") || get(filterNode, "filter-and"));
+        for (const node of andNodes) {
+            addConditions(node);
+        }
+        const orNodes = this.toArray(get(filterNode, "table:filter-or") || get(filterNode, "filter-or"));
+        for (const node of orNodes) {
+            addConditions(node);
+        }
+        return Array.from(specMap.values()).sort((a, b) => a.columnIndex - b.columnIndex);
+    }
+    applyFilterCondition(node, specMap) {
+        const attrs = this.getAttributes(node);
+        if (!attrs)
+            return;
+        const field = attrs["@_table:field-number"] ||
+            attrs["@_field-number"] ||
+            attrs["@_table:column-number"] ||
+            attrs["@_column-number"];
+        if (field === undefined)
+            return;
+        const columnIndex = parseInt(field, 10);
+        if (isNaN(columnIndex))
+            return;
+        const operator = String(attrs["@_table:operator"] ?? attrs["@_operator"] ?? "=");
+        const value = attrs["@_table:value"] ?? attrs["@_value"];
+        const value2 = attrs["@_table:value2"] ?? attrs["@_value2"];
+        let spec = specMap.get(columnIndex);
+        if (!spec) {
+            spec = {
+                columnIndex,
+                filterCriteria: {},
+            };
+            specMap.set(columnIndex, spec);
+        }
+        // A non-"=" operator is a CONDITION filter (greater-than / contains /
+        // between / blank / …). Map it back to filterCriteria.condition so it
+        // survives the round-trip instead of being flattened into a value list.
+        const conditionType = ODS_OPERATOR_TO_CONDITION[operator];
+        if (conditionType) {
+            const conditionValues = [];
+            if (value !== undefined) {
+                conditionValues.push({ userEnteredValue: String(value) });
+            }
+            if (value2 !== undefined) {
+                conditionValues.push({ userEnteredValue: String(value2) });
+            }
+            spec.filterCriteria.condition = {
+                type: conditionType,
+                values: conditionValues,
+            };
+            return;
+        }
+        // operator "=" (or unknown) -> value-list entry.
+        if (value === undefined)
+            return;
+        if (!spec.filterCriteria.visibleValues) {
+            spec.filterCriteria.visibleValues = [];
+        }
+        spec.filterCriteria.visibleValues.push(String(value));
+    }
+    extractTextContent(node) {
+        if (node === null || node === undefined)
+            return "";
+        const primitiveTypes = ["string", "number", "boolean"];
+        if (primitiveTypes.includes(typeof node)) {
+            return String(node);
+        }
+        if (Array.isArray(node)) {
+            return node.map((entry) => this.extractTextContent(entry)).join("");
+        }
+        let result = "";
+        if (node["text:s"]) {
+            result += this.extractSpaceNodes(node["text:s"], node);
+        }
+        if (node["text:line-break"]) {
+            const breaks = this.toArray(node["text:line-break"]);
+            result += "\n".repeat(breaks.length || 1);
+        }
+        if (node["text:span"]) {
+            result += this.extractTextContent(node["text:span"]);
+        }
+        if (node["text:a"]) {
+            result += this.extractTextContent(node["text:a"]);
+        }
+        if (node["text:p"]) {
+            result += this.extractTextContent(node["text:p"]);
+        }
+        if (node["#text"] !== undefined && node["#text"] !== null) {
+            const textValue = node["#text"];
+            if (typeof textValue === "string" ||
+                typeof textValue === "number" ||
+                typeof textValue === "boolean") {
+                result += String(textValue);
+            }
+        }
+        return result;
+    }
+    extractTextContentWithRuns(node) {
+        let text = "";
+        const runs = [];
+        const hasFormat = (format) => !!format && Object.keys(format).length > 0;
+        const mergeFormat = (base, next) => (base || next ? { ...(base ?? {}), ...(next ?? {}) } : undefined);
+        const appendText = (value) => {
+            if (typeof value === "string" ||
+                typeof value === "number" ||
+                typeof value === "boolean") {
+                text += String(value);
+            }
+        };
+        const walk = (value, inherited) => {
+            if (value === null || value === undefined)
+                return;
+            if (Array.isArray(value)) {
+                value.forEach((entry) => walk(entry, inherited));
+                return;
+            }
+            if (typeof value === "string" ||
+                typeof value === "number" ||
+                typeof value === "boolean") {
+                appendText(value);
+                return;
+            }
+            if (value["text:s"]) {
+                text += this.extractSpaceNodes(value["text:s"], value);
+            }
+            if (value["text:line-break"]) {
+                const breaks = this.toArray(value["text:line-break"]);
+                text += "\n".repeat(breaks.length || 1);
+            }
+            if (value["#text"] !== undefined && value["#text"] !== null) {
+                appendText(value["#text"]);
+            }
+            const spanNodes = value["text:span"];
+            if (spanNodes) {
+                for (const span of this.toArray(spanNodes)) {
+                    const attrs = this.getAttributes(span) ?? {};
+                    const styleName = attrs["@_text:style-name"] || attrs["@_style-name"];
+                    const spanFormat = mergeFormat(inherited, this.odsStyles.getTextFormat(styleName));
+                    const startIndex = text.length;
+                    walk(span, spanFormat);
+                    if (hasFormat(spanFormat) && text.length > startIndex) {
+                        const format = spanFormat;
+                        runs.push({
+                            startIndex,
+                            endIndex: text.length,
+                            format,
+                            nodeType: "text",
+                        });
+                    }
+                }
+            }
+            if (value["text:a"]) {
+                walk(value["text:a"], inherited);
+            }
+            if (value["text:p"]) {
+                walk(value["text:p"], inherited);
+            }
+        };
+        walk(node);
+        return { text, runs };
+    }
+    normalizeInternalHyperlinkLocation(href) {
+        let location = href.trim();
+        if (location.startsWith("#")) {
+            location = location.slice(1);
+        }
+        else if (location.startsWith("sheet://")) {
+            location = location.slice("sheet://".length);
+        }
+        else if (location.startsWith("vnd.sun.star.sheet:")) {
+            location = location.slice("vnd.sun.star.sheet:".length);
+        }
+        if (location.includes("!")) {
+            return location;
+        }
+        const match = location.match(/^(.*)\.([A-Za-z]+[0-9].*)$/);
+        if (match) {
+            return `${match[1]}!${match[2]}`;
+        }
+        return location;
+    }
+    extractHyperlinkValue(node) {
+        if (node === null || node === undefined)
+            return undefined;
+        if (Array.isArray(node)) {
+            for (const entry of node) {
+                const result = this.extractHyperlinkValue(entry);
+                if (result)
+                    return result;
+            }
+            return undefined;
+        }
+        if (typeof node !== "object") {
+            return undefined;
+        }
+        if (node["text:a"]) {
+            const anchors = Array.isArray(node["text:a"])
+                ? node["text:a"]
+                : [node["text:a"]];
+            for (const anchor of anchors) {
+                const attrs = anchor?.[":@"] || anchor;
+                const href = attrs?.["@_xlink:href"] || attrs?.["@_href"];
+                if (!href) {
+                    continue;
+                }
+                const display = this.extractTextContent(anchor);
+                if (href.startsWith("#") ||
+                    href.startsWith("sheet://") ||
+                    href.startsWith("vnd.sun.star.sheet:")) {
+                    return {
+                        kind: "internal",
+                        location: this.normalizeInternalHyperlinkLocation(href),
+                        ...(display ? { display } : {}),
+                    };
+                }
+                return {
+                    kind: "external",
+                    url: href,
+                    ...(display ? { display } : {}),
+                };
+            }
+        }
+        for (const value of Object.values(node)) {
+            const result = this.extractHyperlinkValue(value);
+            if (result)
+                return result;
+        }
+        return undefined;
+    }
+    extractSpaceNodes(node, fallback) {
+        const nodes = this.toArray(node);
+        if (!nodes.length) {
+            const fallbackAttrs = this.getAttributes(fallback);
+            if (!fallbackAttrs)
+                return " ";
+            const repeat = this.getSpaceRepeatCount(fallbackAttrs);
+            return " ".repeat(repeat);
+        }
+        return nodes
+            .map((entry) => {
+            const attrs = this.getAttributes(entry);
+            const repeat = this.getSpaceRepeatCount(attrs);
+            return " ".repeat(repeat);
+        })
+            .join("");
+    }
+    getSpaceRepeatCount(attrs) {
+        if (!attrs)
+            return 1;
+        const rawCount = attrs["@_text:c"] || attrs["@_c"] || attrs["@_text:count"];
+        if (rawCount === undefined) {
+            return 1;
+        }
+        const count = parseInt(rawCount, 10);
+        if (isNaN(count) || count < 0) {
+            return 1;
+        }
+        return Math.max(1, count + 1);
+    }
+    extractEmbeddedObjects(sheetContexts, sheetNameMap) {
+        const tables = this.getOrderedTableWrappers();
+        if (!tables.length || !sheetContexts.length) {
+            return { drawings: [], charts: [] };
+        }
+        const drawings = [];
+        const charts = [];
+        const chartAnchors = new Set();
+        const imageCache = new Map();
+        const tableCount = Math.min(tables.length, sheetContexts.length);
+        for (let sheetIndex = 0; sheetIndex < tableCount; sheetIndex++) {
+            const tableWrapper = tables[sheetIndex];
+            const tableNameKey = tableWrapper["table:table"]
+                ? "table:table"
+                : "table";
+            const tableChildren = tableWrapper[tableNameKey];
+            if (!tableChildren)
+                continue;
+            const rows = tableChildren.filter((child) => child["table:table-row"] || child["table-row"]);
+            let currentRowIndex = 1;
+            const sheetContext = sheetContexts[sheetIndex];
+            const sheetId = sheetContext?.sheetId ?? sheetIndex + 1;
+            for (const rowWrapper of rows) {
+                const rowNameKey = rowWrapper["table:table-row"]
+                    ? "table:table-row"
+                    : "table-row";
+                const rowChildren = rowWrapper[rowNameKey];
+                const rowAttrs = rowWrapper[":@"] || {};
+                const rowsRepeated = parseInt(rowAttrs["@_table:number-rows-repeated"] ||
+                    rowAttrs["@_number-rows-repeated"] ||
+                    "1", 10);
+                const effectiveRepeats = Math.min(rowsRepeated, 10000);
+                for (let repeat = 0; repeat < effectiveRepeats; repeat++) {
+                    let columnIndex = 1;
+                    const normalizedRowChildren = rowChildren
+                        ? this.expandRowCells(rowChildren)
+                        : null;
+                    if (normalizedRowChildren) {
+                        for (const cellWrapper of normalizedRowChildren) {
+                            const isCell = !!cellWrapper["table:table-cell"];
+                            const isCovered = !!cellWrapper["table:covered-table-cell"];
+                            if (!isCell && !isCovered)
+                                continue;
+                            const cellKey = isCell
+                                ? "table:table-cell"
+                                : "table:covered-table-cell";
+                            const cellChildren = cellWrapper[cellKey];
+                            const cellAttrs = cellWrapper[":@"] || {};
+                            const colsRepeated = parseInt(cellAttrs["@_table:number-columns-repeated"] ||
+                                cellAttrs["@_number-columns-repeated"] ||
+                                "1", 10);
+                            if (isCovered) {
+                                columnIndex += colsRepeated;
+                                continue;
+                            }
+                            const frameNodes = this.collectFrameNodes(cellChildren, cellAttrs);
+                            if (frameNodes.length) {
+                                for (let c = 0; c < colsRepeated; c++) {
+                                    const anchorColumnIndex = columnIndex + c;
+                                    for (const { frame, cellAttrs: frameCellAttrs, } of frameNodes) {
+                                        const chart = this.convertFrameToEmbeddedChart(frame, sheetContext, sheetId, currentRowIndex, anchorColumnIndex, sheetNameMap, frameCellAttrs);
+                                        if (chart) {
+                                            chartAnchors.add(this.buildAnchorKey(sheetId, currentRowIndex, anchorColumnIndex));
+                                            charts.push(chart);
+                                            continue;
+                                        }
+                                        const anchorKey = this.buildAnchorKey(sheetId, currentRowIndex, anchorColumnIndex);
+                                        if (chartAnchors.has(anchorKey)) {
+                                            continue;
+                                        }
+                                        const embedded = this.convertFrameToEmbeddedObject(frame, sheetId, currentRowIndex, anchorColumnIndex, imageCache, frameCellAttrs);
+                                        if (embedded) {
+                                            drawings.push(embedded);
+                                        }
+                                    }
+                                }
+                            }
+                            columnIndex += colsRepeated;
+                        }
+                    }
+                    currentRowIndex++;
+                }
+            }
+        }
+        return { drawings, charts };
+    }
+    buildAnchorKey(sheetId, rowIndex, columnIndex) {
+        return `${sheetId}:${rowIndex}:${columnIndex}`;
+    }
+    /**
+     * Walk the ordered content XML for each table and assign outline
+     * level + collapsed/hiddenByGroup state on `rowMetadata` and
+     * `columnMetadata`. ODS encodes outline as `<table:table-row-group>`
+     * / `<table:table-column-group>` wrappers (nest for level > 1); a
+     * group is collapsed when its `table:display="false"`. Cells inside
+     * a collapsed wrapper get `hiddenByGroup`; the summary cell (per
+     * `outlinePr.summaryBelow`/`summaryRight`, default true = below /
+     * right of the group) gets `collapsed = true`.
+     */
+    extractOutlineGroups(sheets) {
+        if (!this.contentXmlOrdered || !sheets.length)
+            return;
+        const docContent = this.contentXmlOrdered[0]?.["office:document-content"] ||
+            this.contentXmlOrdered[0]?.["document-content"];
+        if (!docContent)
+            return;
+        const body = getChildren(docContent, "office:body") || getChildren(docContent, "body");
+        if (!body)
+            return;
+        const spreadsheet = getChildren(body, "office:spreadsheet") ||
+            getChildren(body, "spreadsheet");
+        if (!spreadsheet)
+            return;
+        const tables = spreadsheet.filter((child) => child["table:table"] || child["table"]);
+        const tableCount = Math.min(tables.length, sheets.length);
+        for (let sheetIndex = 0; sheetIndex < tableCount; sheetIndex++) {
+            const tableWrapper = tables[sheetIndex];
+            const tableNameKey = tableWrapper["table:table"]
+                ? "table:table"
+                : "table";
+            const tableChildren = tableWrapper[tableNameKey];
+            if (!Array.isArray(tableChildren))
+                continue;
+            const sheet = sheets[sheetIndex];
+            if (!sheet)
+                continue;
+            const summaryBelow = sheet.outlinePr?.summaryBelow !== false;
+            const summaryRight = sheet.outlinePr?.summaryRight !== false;
+            const rowMetadata = (sheet.rowMetadata ?? []);
+            const columnMetadata = (sheet.columnMetadata ?? []);
+            const setMeta = (meta, index, patch) => {
+                if (!meta[index])
+                    meta[index] = {};
+                Object.assign(meta[index], patch);
+            };
+            const walk = (nodes, itemTag, groupTag, meta, repeatAttrs, summaryAfter) => {
+                let cursor = 1;
+                const openStack = [];
+                const collapsedDepth = () => openStack.some((g) => g.collapsed);
+                const currentLevel = () => openStack.length;
+                const visit = (children) => {
+                    for (const child of children) {
+                        if (!child)
+                            continue;
+                        if (child[groupTag]) {
+                            const attrs = child[":@"] || {};
+                            const display = attrs["@_table:display"] ?? attrs["@_display"];
+                            const collapsed = display === "false" || display === false;
+                            const startIndex = cursor;
+                            openStack.push({
+                                level: openStack.length + 1,
+                                startIndex,
+                                collapsed,
+                            });
+                            visit(child[groupTag] || []);
+                            const closing = openStack.pop();
+                            if (closing.collapsed) {
+                                const summaryIndex = summaryAfter
+                                    ? cursor
+                                    : closing.startIndex - 1;
+                                if (summaryIndex >= 1) {
+                                    setMeta(meta, summaryIndex, { collapsed: true });
+                                }
+                            }
+                        }
+                        else if (child[itemTag]) {
+                            const attrs = child[":@"] || {};
+                            let repeat = 1;
+                            for (const attrName of repeatAttrs) {
+                                const raw = attrs[`@_${attrName}`];
+                                if (raw !== undefined) {
+                                    repeat = Math.max(1, parseInt(String(raw), 10) || 1);
+                                    break;
+                                }
+                            }
+                            repeat = Math.min(repeat, 10000);
+                            const level = currentLevel();
+                            const hidden = collapsedDepth();
+                            if (level > 0 || hidden) {
+                                for (let r = 0; r < repeat; r++) {
+                                    const patch = {};
+                                    if (level > 0)
+                                        patch.outlineLevel = level;
+                                    if (hidden)
+                                        patch.hiddenByGroup = true;
+                                    setMeta(meta, cursor + r, patch);
+                                }
+                            }
+                            cursor += repeat;
+                        }
+                    }
+                };
+                visit(nodes);
+            };
+            walk(tableChildren, "table:table-column", "table:table-column-group", columnMetadata, ["table:number-columns-repeated", "number-columns-repeated"], summaryRight);
+            walk(tableChildren, "table:table-row", "table:table-row-group", rowMetadata, ["table:number-rows-repeated", "number-rows-repeated"], summaryBelow);
+            if (columnMetadata.length > 0)
+                sheet.columnMetadata = columnMetadata;
+            if (rowMetadata.length > 0)
+                sheet.rowMetadata = rowMetadata;
+        }
+    }
+    extractMerges(sheetContexts) {
+        const merges = new Map();
+        if (!this.contentXmlOrdered || !sheetContexts.length) {
+            return merges;
+        }
+        const docContent = this.contentXmlOrdered[0]?.["office:document-content"] ||
+            this.contentXmlOrdered[0]?.["document-content"];
+        if (!docContent)
+            return merges;
+        const body = getChildren(docContent, "office:body") || getChildren(docContent, "body");
+        if (!body)
+            return merges;
+        const spreadsheet = getChildren(body, "office:spreadsheet") ||
+            getChildren(body, "spreadsheet");
+        if (!spreadsheet)
+            return merges;
+        const tables = spreadsheet.filter((child) => child["table:table"] || child["table"]);
+        const tableCount = Math.min(tables.length, sheetContexts.length);
+        const seen = new Set();
+        for (let sheetIndex = 0; sheetIndex < tableCount; sheetIndex++) {
+            const tableWrapper = tables[sheetIndex];
+            const tableNameKey = tableWrapper["table:table"]
+                ? "table:table"
+                : "table";
+            const tableChildren = tableWrapper[tableNameKey];
+            if (!tableChildren)
+                continue;
+            const rows = tableChildren.filter((child) => child["table:table-row"] || child["table-row"]);
+            const sheetId = sheetContexts[sheetIndex]?.sheetId ?? sheetIndex + 1;
+            let currentRowIndex = 1;
+            for (const rowWrapper of rows) {
+                const rowNameKey = rowWrapper["table:table-row"]
+                    ? "table:table-row"
+                    : "table-row";
+                const rowChildren = rowWrapper[rowNameKey];
+                const rowAttrs = rowWrapper[":@"] || {};
+                const rowsRepeated = parseInt(rowAttrs["@_table:number-rows-repeated"] ||
+                    rowAttrs["@_number-rows-repeated"] ||
+                    "1", 10);
+                const effectiveRepeats = Math.min(rowsRepeated, 10000);
+                for (let repeat = 0; repeat < effectiveRepeats; repeat++) {
+                    let columnIndex = 1;
+                    if (rowChildren) {
+                        for (const cellWrapper of rowChildren) {
+                            const isCell = !!cellWrapper["table:table-cell"];
+                            const isCovered = !!cellWrapper["table:covered-table-cell"];
+                            if (!isCell && !isCovered)
+                                continue;
+                            const cellKey = isCell
+                                ? "table:table-cell"
+                                : "table:covered-table-cell";
+                            const cellAttrs = cellWrapper[":@"] || {};
+                            const colsRepeated = parseInt(cellAttrs["@_table:number-columns-repeated"] ||
+                                cellAttrs["@_number-columns-repeated"] ||
+                                "1", 10);
+                            if (isCovered) {
+                                columnIndex += colsRepeated;
+                                continue;
+                            }
+                            const rowsSpannedRaw = parseInt(cellAttrs["@_table:number-rows-spanned"] ||
+                                cellAttrs["@_number-rows-spanned"] ||
+                                "1", 10);
+                            const colsSpannedRaw = parseInt(cellAttrs["@_table:number-columns-spanned"] ||
+                                cellAttrs["@_number-columns-spanned"] ||
+                                "1", 10);
+                            const rowsSpanned = Math.max(1, rowsSpannedRaw || 1);
+                            const colsSpanned = Math.max(1, colsSpannedRaw || 1);
+                            if (rowsSpanned > 1 || colsSpanned > 1) {
+                                for (let colOffset = 0; colOffset < colsRepeated; colOffset++) {
+                                    const startColumnIndex = columnIndex + colOffset;
+                                    const range = {
+                                        sheetId,
+                                        startRowIndex: currentRowIndex,
+                                        endRowIndex: currentRowIndex + rowsSpanned - 1,
+                                        startColumnIndex,
+                                        endColumnIndex: startColumnIndex + colsSpanned - 1,
+                                    };
+                                    const key = `${range.sheetId}:${range.startRowIndex}:${range.endRowIndex}:${range.startColumnIndex}:${range.endColumnIndex}`;
+                                    if (!seen.has(key)) {
+                                        seen.add(key);
+                                        if (!merges.has(sheetId)) {
+                                            merges.set(sheetId, []);
+                                        }
+                                        merges.get(sheetId).push(range);
+                                    }
+                                }
+                            }
+                            columnIndex += colsRepeated;
+                        }
+                    }
+                    currentRowIndex++;
+                }
+            }
+        }
+        return merges;
+    }
+    getOrderedTableWrappers() {
+        if (!this.contentXmlOrdered)
+            return [];
+        const docContent = this.contentXmlOrdered[0]?.["office:document-content"] ||
+            this.contentXmlOrdered[0]?.["document-content"];
+        if (!docContent)
+            return [];
+        const body = getChildren(docContent, "office:body") || getChildren(docContent, "body");
+        if (!body)
+            return [];
+        const spreadsheet = getChildren(body, "office:spreadsheet") ||
+            getChildren(body, "spreadsheet");
+        if (!spreadsheet)
+            return [];
+        return spreadsheet.filter((child) => child["table:table"] || child["table"]);
+    }
+    findOrderedTableWrapperForContext(sheetContext, sheetId) {
+        const tables = this.getOrderedTableWrappers();
+        if (!tables.length)
+            return undefined;
+        if (sheetContext?.name) {
+            const normalizedTarget = this.normalizeSheetName(sheetContext.name);
+            for (const tableWrapper of tables) {
+                const attrs = tableWrapper[":@"] || {};
+                const rawName = attrs["@_table:name"] ||
+                    attrs["@_name"] ||
+                    attrs["@_table:display-name"];
+                const normalizedCandidate = this.normalizeSheetName(rawName);
+                if ((rawName && rawName === sheetContext.name) ||
+                    (normalizedCandidate &&
+                        normalizedTarget &&
+                        normalizedCandidate === normalizedTarget)) {
+                    return tableWrapper;
+                }
+            }
+        }
+        if (sheetId && tables[sheetId - 1]) {
+            return tables[sheetId - 1];
+        }
+        return tables[0];
+    }
+    extractTableColumnsFromHeader(range, sheetContext, useHeaderRow = true) {
+        const startColumn = Math.max(1, range.startColumnIndex ?? 1);
+        const endColumn = Math.max(startColumn, range.endColumnIndex ?? startColumn);
+        const columnCount = Math.max(1, endColumn - startColumn + 1);
+        const buildDefaultColumns = () => Array.from({ length: columnCount }, (_, index) => ({
+            name: `Column ${index + 1}`,
+        }));
+        if (!useHeaderRow) {
+            return buildDefaultColumns();
+        }
+        const tableWrapper = this.findOrderedTableWrapperForContext(sheetContext, range.sheetId);
+        if (!tableWrapper) {
+            return buildDefaultColumns();
+        }
+        const tableNameKey = tableWrapper["table:table"] ? "table:table" : "table";
+        const tableChildren = tableWrapper[tableNameKey];
+        if (!tableChildren) {
+            return buildDefaultColumns();
+        }
+        const rows = tableChildren.filter((child) => child["table:table-row"] || child["table-row"]);
+        if (!rows.length) {
+            return buildDefaultColumns();
+        }
+        const headerRowIndex = Math.max(1, range.startRowIndex ?? 1);
+        const headerValues = [];
+        let currentRowIndex = 1;
+        outer: for (const rowWrapper of rows) {
+            const rowNameKey = rowWrapper["table:table-row"]
+                ? "table:table-row"
+                : "table-row";
+            const rowChildren = rowWrapper[rowNameKey];
+            const rowAttrs = rowWrapper[":@"] || {};
+            const rowsRepeated = parseInt(rowAttrs["@_table:number-rows-repeated"] ||
+                rowAttrs["@_number-rows-repeated"] ||
+                "1", 10);
+            const effectiveRepeats = Math.min(rowsRepeated, 10000);
+            const normalizedRowChildren = rowChildren
+                ? this.expandRowCells(rowChildren)
+                : null;
+            for (let repeat = 0; repeat < effectiveRepeats; repeat++) {
+                if (currentRowIndex === headerRowIndex) {
+                    let columnIndex = 1;
+                    if (normalizedRowChildren) {
+                        for (const cellWrapper of normalizedRowChildren) {
+                            const isCell = !!cellWrapper["table:table-cell"];
+                            const isCovered = !!cellWrapper["table:covered-table-cell"];
+                            if (!isCell && !isCovered) {
+                                continue;
+                            }
+                            const cellNameKey = isCell
+                                ? "table:table-cell"
+                                : "table:covered-table-cell";
+                            const cellChildren = cellWrapper[cellNameKey];
+                            const cellAttrs = cellWrapper[":@"] || {};
+                            const colsRepeated = parseInt(cellAttrs["@_table:number-columns-repeated"] ||
+                                cellAttrs["@_number-columns-repeated"] ||
+                                "1", 10);
+                            if (isCovered) {
+                                columnIndex += colsRepeated;
+                                continue;
+                            }
+                            let displayValue = "";
+                            if (cellChildren) {
+                                const textWrapper = findChild(cellChildren, "text:p") ||
+                                    findChild(cellChildren, "p");
+                                if (textWrapper) {
+                                    const key = textWrapper["text:p"] ? "text:p" : "p";
+                                    displayValue = this.extractTextContent(textWrapper[key]);
+                                }
+                                else {
+                                    displayValue = this.extractTextContent(cellChildren);
+                                }
+                            }
+                            for (let c = 0; c < colsRepeated; c++) {
+                                const targetColumnIndex = columnIndex;
+                                if (targetColumnIndex >= startColumn &&
+                                    targetColumnIndex <= endColumn) {
+                                    const relativeIndex = headerValues.length;
+                                    const fallbackName = `Column ${relativeIndex + 1}`;
+                                    const trimmed = displayValue?.trim();
+                                    headerValues.push(trimmed && trimmed.length ? trimmed : fallbackName);
+                                    if (headerValues.length >= columnCount) {
+                                        break;
+                                    }
+                                }
+                                columnIndex++;
+                            }
+                            if (headerValues.length >= columnCount) {
+                                break;
+                            }
+                        }
+                    }
+                    break outer;
+                }
+                currentRowIndex++;
+            }
+            if (currentRowIndex > headerRowIndex) {
+                break;
+            }
+        }
+        if (!headerValues.length) {
+            return buildDefaultColumns();
+        }
+        const columns = [];
+        for (let i = 0; i < columnCount; i++) {
+            const label = headerValues[i];
+            columns.push({
+                name: label && label.trim().length ? label : `Column ${i + 1}`,
+            });
+        }
+        return columns;
+    }
+    collectFrameNodes(cellChildren, cellAttrs) {
+        if (!cellChildren)
+            return [];
+        const children = Array.isArray(cellChildren)
+            ? cellChildren
+            : [cellChildren];
+        const frames = [];
+        for (const child of children) {
+            if (!child || typeof child !== "object")
+                continue;
+            const frameNode = child["draw:frame"] || child["frame"];
+            if (!frameNode)
+                continue;
+            if (Array.isArray(frameNode)) {
+                for (const node of frameNode) {
+                    frames.push({ frame: node, cellAttrs: child[":@"] || cellAttrs });
+                }
+            }
+            else {
+                frames.push({ frame: frameNode, cellAttrs: child[":@"] || cellAttrs });
+            }
+        }
+        return frames;
+    }
+    extractSheetSettings(sheetContexts) {
+        const map = new Map();
+        if (!this.settingsXml || !sheetContexts.length) {
+            return map;
+        }
+        const documentSettings = get(this.settingsXml, "office:document-settings") ||
+            get(this.settingsXml, "document-settings");
+        if (!documentSettings)
+            return map;
+        const settingsNode = get(documentSettings, "office:settings") ||
+            get(documentSettings, "settings");
+        if (!settingsNode)
+            return map;
+        const nameMap = new Map();
+        const traverse = (node) => {
+            if (!node || typeof node !== "object")
+                return;
+            const entries = this.toArray(node["config:config-item-map-entry"] || node["config-item-map-entry"]);
+            for (const entry of entries) {
+                const attrs = this.getAttributes(entry);
+                const entryName = attrs?.["@_config:name"] ||
+                    attrs?.["@_name"] ||
+                    attrs?.["@_table:name"];
+                if (entryName) {
+                    const parsed = this.parseConfigItemEntry(entry);
+                    if (parsed) {
+                        const existing = nameMap.get(entryName) || {};
+                        const combined = { ...existing, ...parsed };
+                        nameMap.set(entryName, combined);
+                        const normalized = this.normalizeSheetName(entryName);
+                        if (normalized) {
+                            nameMap.set(normalized, combined);
+                            nameMap.set(`'${normalized}'`, combined);
+                        }
+                    }
+                }
+                traverse(entry);
+            }
+            const namedMaps = this.toArray(node["config:config-item-map-named"] || node["config-item-map-named"]);
+            for (const named of namedMaps) {
+                traverse(named);
+            }
+        };
+        const itemSets = this.toArray(get(settingsNode, "config:config-item-set") ||
+            get(settingsNode, "config-item-set"));
+        for (const set of itemSets) {
+            traverse(set);
+        }
+        for (const context of sheetContexts) {
+            const normalized = this.normalizeSheetName(context.name);
+            const settings = nameMap.get(context.name) ||
+                (normalized ? nameMap.get(normalized) : undefined);
+            if (settings) {
+                map.set(context.sheetId, settings);
+            }
+        }
+        return map;
+    }
+    parseConfigItemEntry(entry) {
+        const configItems = this.toArray(get(entry, "config:config-item") || get(entry, "config-item"));
+        if (!configItems.length)
+            return undefined;
+        const settings = {};
+        for (const item of configItems) {
+            const attrs = this.getAttributes(item);
+            if (!attrs)
+                continue;
+            const name = attrs["@_config:name"] || attrs["@_name"];
+            if (!name)
+                continue;
+            const value = this.getNodeText(item);
+            if (value === undefined)
+                continue;
+            const normalized = value.trim();
+            if (!normalized.length)
+                continue;
+            if (name === "ShowGrid" || name === "ShowGridLines") {
+                const parsed = this.parseBooleanAttribute(normalized);
+                if (parsed !== undefined) {
+                    settings.showGridLines = parsed;
+                }
+                continue;
+            }
+            if (name === "FreezeCell") {
+                const freeze = this.parseFreezeCoordinates(normalized);
+                if (freeze) {
+                    Object.assign(settings, freeze);
+                }
+                continue;
+            }
+            if (name === "VerticalSplitPosition") {
+                const parsed = this.parseIntegerValue(normalized);
+                if (parsed !== undefined) {
+                    settings.frozenRowCount = parsed;
+                }
+                continue;
+            }
+            if (name === "HorizontalSplitPosition") {
+                const parsed = this.parseIntegerValue(normalized);
+                if (parsed !== undefined) {
+                    settings.frozenColumnCount = parsed;
+                }
+                continue;
+            }
+            if (name === "TabColor") {
+                const color = this.normalizeOdsColor(normalized);
+                if (color) {
+                    settings.tabColor = color;
+                }
+            }
+        }
+        return Object.keys(settings).length ? settings : undefined;
+    }
+    parseFreezeCoordinates(value) {
+        const normalized = value.replace(/\$/g, "").trim();
+        if (!normalized)
+            return undefined;
+        const cell = addressToCell(normalized.toUpperCase());
+        if (!cell)
+            return undefined;
+        return {
+            frozenRowCount: Math.max(0, cell.rowIndex - 1),
+            frozenColumnCount: Math.max(0, cell.columnIndex - 1),
+        };
+    }
+    convertFrameToEmbeddedObject(frameNode, sheetId, rowIndex, columnIndex, imageCache, cellAttrs) {
+        const frameAttrs = this.getAttributes(frameNode);
+        const imageNode = this.findFrameImageNode(frameNode);
+        const imageAttrs = this.getAttributes(imageNode);
+        const imagePath = this.normalizeImagePath(imageAttrs?.["@_xlink:href"] ||
+            imageAttrs?.["@_href"] ||
+            frameAttrs?.["@_xlink:href"] ||
+            frameAttrs?.["@_href"]);
+        if (!imagePath)
+            return undefined;
+        const imageUrl = this.getImageDataUrl(imagePath, imageCache);
+        if (!imageUrl)
+            return undefined;
+        const { overlayPosition, isInsideCell } = this.buildOverlayPlacement(frameAttrs, cellAttrs, rowIndex, columnIndex);
+        const description = frameAttrs?.["@_draw:name"] || cellAttrs?.["@_draw:name"] || undefined;
+        return {
+            embedId: uuid(),
+            spec: {
+                type: "image",
+                imageUrl,
+                description,
+            },
+            position: {
+                sheetId,
+                overlayPosition,
+            },
+            draggable: true,
+            lockAspectRatio: true,
+            isInsideCell,
+        };
+    }
+    convertFrameToEmbeddedChart(frameNode, sheetContext, sheetId, rowIndex, columnIndex, sheetNameMap, cellAttrs) {
+        const frameAttrs = this.getAttributes(frameNode);
+        const inlineChart = this.findInlineChartNode(frameNode);
+        let chartNode = inlineChart;
+        if (!chartNode) {
+            const objectNode = this.findFrameObjectNode(frameNode);
+            const chartFromObject = this.loadChartNodeFromObject(objectNode, frameAttrs);
+            chartNode = chartFromObject;
+        }
+        if (!chartNode)
+            return undefined;
+        const spec = this.convertChartNodeToSpec(chartNode, sheetNameMap, sheetContext);
+        if (!spec)
+            return undefined;
+        const { overlayPosition } = this.buildOverlayPlacement(frameAttrs, cellAttrs, rowIndex, columnIndex);
+        const chartId = uuid();
+        return {
+            chartId,
+            spec,
+            position: {
+                sheetId,
+                overlayPosition,
+            },
+            draggable: true,
+            resizable: true,
+        };
+    }
+    findInlineChartNode(frameNode) {
+        if (!frameNode)
+            return undefined;
+        if (Array.isArray(frameNode)) {
+            for (const entry of frameNode) {
+                const found = this.findInlineChartNode(entry);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        }
+        const chartNode = frameNode["chart:chart"] || frameNode["chart"];
+        if (chartNode) {
+            return Array.isArray(chartNode) ? chartNode[0] : chartNode;
+        }
+        return undefined;
+    }
+    findFrameObjectNode(frameNode) {
+        if (!frameNode)
+            return undefined;
+        if (Array.isArray(frameNode)) {
+            for (const entry of frameNode) {
+                const found = this.findFrameObjectNode(entry);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        }
+        const objectNode = frameNode["draw:object"] || frameNode["object"];
+        if (objectNode) {
+            return Array.isArray(objectNode) ? objectNode[0] : objectNode;
+        }
+        return undefined;
+    }
+    findFrameImageNode(frameNode) {
+        if (!frameNode)
+            return undefined;
+        if (Array.isArray(frameNode)) {
+            for (const entry of frameNode) {
+                const found = this.findFrameImageNode(entry);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        }
+        const direct = frameNode["draw:image"] || frameNode["image"] || frameNode["draw:object"];
+        if (direct) {
+            return Array.isArray(direct) ? direct[0] : direct;
+        }
+        return undefined;
+    }
+    loadChartNodeFromObject(objectNode, frameAttrs) {
+        if (!objectNode)
+            return undefined;
+        const objectAttrs = this.getAttributes(objectNode);
+        const href = objectAttrs?.["@_xlink:href"] ||
+            objectAttrs?.["@_href"] ||
+            frameAttrs?.["@_xlink:href"] ||
+            frameAttrs?.["@_href"];
+        return this.loadChartNodeFromHref(href);
+    }
+    loadChartNodeFromHref(href) {
+        const path = this.resolveObjectPath(href);
+        if (!path)
+            return undefined;
+        try {
+            const content = this.zipParser.Get(path);
+            const chartDoc = this.xmlParser.parse(content);
+            this.odsStyles.parseContentXml(chartDoc);
+            return this.findChartNodeInDocument(chartDoc);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    resolveObjectPath(href) {
+        if (!href)
+            return undefined;
+        let normalized = href.trim();
+        if (!normalized)
+            return undefined;
+        if (normalized.startsWith("#")) {
+            normalized = normalized.slice(1);
+        }
+        normalized = normalized.replace(/^\.\/+/, "");
+        while (normalized.startsWith("../")) {
+            normalized = normalized.slice(3);
+        }
+        if (!normalized)
+            return undefined;
+        const candidates = new Set();
+        if (normalized.endsWith(".xml")) {
+            candidates.add(normalized);
+            candidates.add(`ObjectReplacements/${normalized}`);
+        }
+        else {
+            candidates.add(`${normalized}/content.xml`);
+            candidates.add(`${normalized}/Content.xml`);
+            candidates.add(`${normalized}.xml`);
+            candidates.add(`ObjectReplacements/${normalized}/content.xml`);
+            candidates.add(`ObjectReplacements/${normalized}/Content.xml`);
+        }
+        for (const candidate of candidates) {
+            if (!candidate)
+                continue;
+            if (this.zipParser.Has(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    findChartNodeInDocument(doc) {
+        if (!doc)
+            return undefined;
+        const chartNode = get(doc, "office:document-content.office:body.office:chart.chart:chart") ||
+            get(doc, "office:document-content.office:body.chart:chart") ||
+            get(doc, "chart:chart");
+        if (chartNode) {
+            return Array.isArray(chartNode) ? chartNode[0] : chartNode;
+        }
+        return this.findNodeRecursive(doc, "chart:chart");
+    }
+    findNodeRecursive(node, key) {
+        if (!node || typeof node !== "object")
+            return undefined;
+        if (node[key]) {
+            return Array.isArray(node[key]) ? node[key][0] : node[key];
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) {
+                for (const entry of value) {
+                    const found = this.findNodeRecursive(entry, key);
+                    if (found)
+                        return found;
+                }
+            }
+            else if (typeof value === "object") {
+                const found = this.findNodeRecursive(value, key);
+                if (found)
+                    return found;
+            }
+        }
+        return undefined;
+    }
+    convertChartNodeToSpec(chartNode, sheetNameMap, context) {
+        if (!chartNode)
+            return undefined;
+        const chartAttrs = this.getAttributes(chartNode);
+        const chartType = this.mapOdsChartClassToType(chartAttrs?.["@_chart:class"] || chartAttrs?.["@_class"]);
+        const titleNode = get(chartNode, "chart:title.chart:title-text") ||
+            get(chartNode, "chart:title") ||
+            get(chartNode, "title");
+        const rawTitle = titleNode ? this.extractTextContent(titleNode) : "";
+        const title = rawTitle?.trim() ? rawTitle.trim() : undefined;
+        const plotArea = get(chartNode, "chart:plot-area") || get(chartNode, "plot-area");
+        if (!plotArea)
+            return undefined;
+        const seriesNodes = this.toArray(get(plotArea, "chart:series") ||
+            get(plotArea, "chart:data-series") ||
+            get(plotArea, "series"));
+        if (!seriesNodes.length)
+            return undefined;
+        const domains = [];
+        const series = [];
+        let seriesIndex = 1;
+        for (const seriesNode of seriesNodes) {
+            const domainNode = get(seriesNode, "chart:domain") ||
+                get(seriesNode, "domain") ||
+                get(seriesNode, "chart:categories");
+            if (domainNode) {
+                const domainAddress = this.findRangeString(domainNode);
+                if (domainAddress) {
+                    const chartData = this.createChartDataFromAddress(domainAddress, sheetNameMap, context);
+                    if (chartData) {
+                        domains.push(chartData);
+                    }
+                }
+            }
+            const valueAddress = this.findRangeString(seriesNode, new Set(["chart:domain", "domain", "chart:categories"]));
+            if (valueAddress) {
+                const seriesData = this.createChartDataFromAddress(valueAddress, sheetNameMap, context);
+                if (seriesData) {
+                    const label = this.extractSeriesLabel(seriesNode);
+                    seriesData.dataLabel = label || `Series ${seriesIndex}`;
+                    const color = this.extractChartSeriesColor(seriesNode);
+                    if (color) {
+                        seriesData.color = color;
+                    }
+                    series.push(seriesData);
+                    seriesIndex++;
+                }
+            }
+        }
+        if (!series.length) {
+            return undefined;
+        }
+        const finalizedDomains = domains.length ? domains : [series[0]];
+        return {
+            chartType,
+            title,
+            domains: finalizedDomains,
+            series,
+        };
+    }
+    extractSeriesLabel(seriesNode) {
+        if (!seriesNode)
+            return undefined;
+        const labelNode = get(seriesNode, "chart:label") ||
+            get(seriesNode, "label") ||
+            get(seriesNode, "chart:series-label");
+        const label = labelNode ? this.extractTextContent(labelNode) : undefined;
+        return label?.trim() || undefined;
+    }
+    extractChartSeriesColor(seriesNode) {
+        if (!seriesNode)
+            return undefined;
+        const attrs = this.getAttributes(seriesNode);
+        const styleCandidates = [
+            attrs?.["@_chart:style-name"],
+            attrs?.["@_chart:data-style-name"],
+            attrs?.["@_style-name"],
+        ];
+        for (const candidate of styleCandidates) {
+            const color = this.odsStyles.getChartStyleColor(candidate);
+            if (color) {
+                return typeof color === "string" ? color : undefined;
+            }
+        }
+        const seriesProps = get(seriesNode, "chart:data-point-properties") ||
+            get(seriesNode, "chart:series-properties");
+        const inlineColor = this.extractColorFromChartProperties(seriesProps);
+        if (inlineColor) {
+            return inlineColor;
+        }
+        const dataPoints = this.toArray(get(seriesNode, "chart:data-point") ||
+            get(seriesNode, "chart:data-points") ||
+            get(seriesNode, "data-point"));
+        for (const dataPoint of dataPoints) {
+            const pointAttrs = this.getAttributes(dataPoint);
+            const pointStyleCandidates = [
+                pointAttrs?.["@_chart:style-name"],
+                pointAttrs?.["@_chart:data-style-name"],
+                pointAttrs?.["@_style-name"],
+            ];
+            for (const candidate of pointStyleCandidates) {
+                const color = this.odsStyles.getChartStyleColor(candidate);
+                if (color)
+                    return typeof color === "string" ? color : undefined;
+            }
+            const pointColor = this.extractColorFromChartProperties(get(dataPoint, "chart:data-point-properties") || dataPoint);
+            if (pointColor)
+                return pointColor;
+        }
+        return undefined;
+    }
+    extractColorFromChartProperties(node) {
+        if (!node)
+            return undefined;
+        const attrs = this.getAttributes(node);
+        if (!attrs)
+            return undefined;
+        const rawValue = attrs["@_draw:fill-color"] ||
+            attrs["@_svg:fill-color"] ||
+            attrs["@_chart:color"] ||
+            attrs["@_fo:background-color"] ||
+            attrs["@_style:background-color"];
+        if (!rawValue)
+            return undefined;
+        const normalized = this.normalizeOdsColor(rawValue);
+        if (normalized &&
+            normalized.toLowerCase() !== "none" &&
+            normalized.toLowerCase() !== "transparent") {
+            return normalized;
+        }
+        return undefined;
+    }
+    mapOdsChartClassToType(value) {
+        const normalized = value?.toLowerCase() || "";
+        if (normalized.includes("line") || normalized.includes("scatter")) {
+            return "line";
+        }
+        if (normalized.includes("pie")) {
+            return "pie";
+        }
+        if (normalized.includes("area")) {
+            return "area";
+        }
+        return "bar";
+    }
+    findRangeString(node, skipKeys) {
+        if (!node)
+            return undefined;
+        const stack = [node];
+        while (stack.length) {
+            const current = stack.shift();
+            if (current === undefined || current === null)
+                continue;
+            if (typeof current === "string") {
+                if (this.looksLikeCellRangeAddress(current)) {
+                    return current;
+                }
+                continue;
+            }
+            if (Array.isArray(current)) {
+                stack.unshift(...current);
+                continue;
+            }
+            if (typeof current === "object") {
+                const attrs = current[":@"] || current;
+                for (const [key, attrValue] of Object.entries(attrs)) {
+                    if (key.startsWith("@_") &&
+                        typeof attrValue === "string" &&
+                        this.looksLikeCellRangeAddress(attrValue)) {
+                        return attrValue;
+                    }
+                }
+                for (const [childKey, childValue] of Object.entries(current)) {
+                    if (childKey === ":@")
+                        continue;
+                    if (skipKeys && skipKeys.has(childKey))
+                        continue;
+                    stack.push(childValue);
+                }
+            }
+        }
+        return undefined;
+    }
+    looksLikeCellRangeAddress(value) {
+        if (!value)
+            return false;
+        const trimmed = value.trim();
+        if (!trimmed)
+            return false;
+        if (trimmed.includes("#REF"))
+            return false;
+        if (!/[A-Za-z]/.test(trimmed) || !/\d/.test(trimmed))
+            return false;
+        return trimmed.includes(".") || trimmed.includes(":");
+    }
+    createChartDataFromAddress(address, sheetNameMap, context) {
+        if (!address)
+            return undefined;
+        let ranges = this.parseRangeList(address, sheetNameMap, context);
+        if (!ranges.length && context?.name) {
+            const augmented = `'${context.name}'.${address}`;
+            ranges = this.parseRangeList(augmented, sheetNameMap, context);
+        }
+        if (!ranges.length)
+            return undefined;
+        return {
+            sources: ranges,
+        };
+    }
+    buildOverlayPlacement(frameAttrs, cellAttrs, rowIndex, columnIndex) {
+        const widthPixels = this.convertLengthToPixels(frameAttrs?.["@_svg:width"] ||
+            frameAttrs?.["@_width"] ||
+            cellAttrs?.["@_svg:width"] ||
+            cellAttrs?.["@_width"]);
+        const heightPixels = this.convertLengthToPixels(frameAttrs?.["@_svg:height"] ||
+            frameAttrs?.["@_height"] ||
+            cellAttrs?.["@_svg:height"] ||
+            cellAttrs?.["@_height"]);
+        const offsetXPixels = this.convertLengthToPixels(frameAttrs?.["@_svg:x"] ||
+            frameAttrs?.["@_x"] ||
+            cellAttrs?.["@_svg:x"] ||
+            cellAttrs?.["@_x"]);
+        const offsetYPixels = this.convertLengthToPixels(frameAttrs?.["@_svg:y"] ||
+            frameAttrs?.["@_y"] ||
+            cellAttrs?.["@_svg:y"] ||
+            cellAttrs?.["@_y"]);
+        const overlayPosition = {
+            anchorCell: { rowIndex, columnIndex },
+        };
+        if (typeof widthPixels === "number") {
+            overlayPosition.widthPixels = widthPixels;
+        }
+        if (typeof heightPixels === "number") {
+            overlayPosition.heightPixels = heightPixels;
+        }
+        if (typeof offsetXPixels === "number") {
+            overlayPosition.offsetXPixels = offsetXPixels;
+        }
+        if (typeof offsetYPixels === "number") {
+            overlayPosition.offsetYPixels = offsetYPixels;
+        }
+        const DEFAULT_CELL_IMAGE_MAX_SIZE = 60;
+        const exceedsCellSize = (typeof widthPixels === "number" &&
+            widthPixels > DEFAULT_CELL_IMAGE_MAX_SIZE) ||
+            (typeof heightPixels === "number" &&
+                heightPixels > DEFAULT_CELL_IMAGE_MAX_SIZE);
+        const isInsideCell = !exceedsCellSize &&
+            (offsetXPixels === undefined || Math.abs(offsetXPixels) < 0.01) &&
+            (offsetYPixels === undefined || Math.abs(offsetYPixels) < 0.01);
+        return { overlayPosition, isInsideCell };
+    }
+    getImageDataUrl(imagePath, cache) {
+        if (cache.has(imagePath)) {
+            return cache.get(imagePath);
+        }
+        try {
+            const binary = this.zipParser.GetBinary(imagePath);
+            const dataUrl = this.createDataUrlFromBytes(binary, this.getImageMimeType(imagePath));
+            cache.set(imagePath, dataUrl);
+            return dataUrl;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    normalizeImagePath(href) {
+        if (!href)
+            return undefined;
+        let normalized = href.trim();
+        if (!normalized || normalized.startsWith("#"))
+            return undefined;
+        normalized = normalized.replace(/^\.\/+/, "");
+        while (normalized.startsWith("../")) {
+            normalized = normalized.slice(3);
+        }
+        normalized = normalized.replace(/^\/+/, "");
+        return normalized;
+    }
+    getImageMimeType(path) {
+        const extension = path.split(".").pop()?.toLowerCase();
+        switch (extension) {
+            case "jpg":
+            case "jpeg":
+                return "image/jpeg";
+            case "gif":
+                return "image/gif";
+            case "bmp":
+                return "image/bmp";
+            case "svg":
+                return "image/svg+xml";
+            case "webp":
+                return "image/webp";
+            default:
+                return "image/png";
+        }
+    }
+    createDataUrlFromBytes(data, mimeType) {
+        const base64 = this.bytesToBase64(data);
+        return `data:${mimeType};base64,${base64}`;
+    }
+    bytesToBase64(data) {
+        const globalRef = typeof globalThis !== "undefined" ? globalThis : undefined;
+        if (globalRef?.Buffer) {
+            return globalRef.Buffer.from(data).toString("base64");
+        }
+        const chunkSize = 0x8000;
+        let binary = "";
+        for (let i = 0; i < data.length; i += chunkSize) {
+            const chunk = data.subarray(i, i + chunkSize);
+            binary += String.fromCharCode(...Array.from(chunk));
+        }
+        if (typeof btoa === "function") {
+            return btoa(binary);
+        }
+        if (globalRef?.btoa) {
+            return globalRef.btoa(binary);
+        }
+        throw new Error("Unable to encode image data");
+    }
+    convertLengthToPixels(value) {
+        if (!value)
+            return undefined;
+        const match = value
+            .toString()
+            .trim()
+            .match(/^(-?\d+(?:\.\d+)?)(cm|mm|in|pt|pc|px)?$/i);
+        if (!match)
+            return undefined;
+        const amount = parseFloat(match[1]);
+        const unit = (match[2] || "px").toLowerCase();
+        const unitMap = {
+            px: 1,
+            cm: 37.7952755906,
+            mm: 3.77952755906,
+            in: 96,
+            pt: 96 / 72,
+            pc: 16,
+        };
+        const factor = unitMap[unit] ?? 1;
+        return amount * factor;
+    }
+    normalizeOdsColor(value) {
+        if (!value)
+            return undefined;
+        const trimmed = value.trim();
+        if (!trimmed)
+            return undefined;
+        if (trimmed.startsWith("#")) {
+            return trimmed.toUpperCase();
+        }
+        if (/^\d+$/.test(trimmed)) {
+            const numeric = parseInt(trimmed, 10);
+            if (!isNaN(numeric)) {
+                return `#${(numeric & 0xffffff)
+                    .toString(16)
+                    .padStart(6, "0")
+                    .toUpperCase()}`;
+            }
+        }
+        return trimmed;
+    }
+    parseIntegerValue(value) {
+        if (value === undefined || value === null)
+            return undefined;
+        const parsed = parseInt(value, 10);
+        return isNaN(parsed) ? undefined : parsed;
+    }
+    getNodeText(node) {
+        if (node === undefined || node === null)
+            return undefined;
+        if (typeof node === "string")
+            return node;
+        if (typeof node["#text"] === "string")
+            return node["#text"];
+        if (typeof node["_text"] === "string")
+            return node["_text"];
+        return undefined;
+    }
+    buildSheetNameMap(sheetContexts) {
+        const map = new Map();
+        for (const context of sheetContexts) {
+            this.registerSheetNameVariants(map, context.name, context.sheetId);
+        }
+        return map;
+    }
+    registerSheetNameVariants(map, name, sheetId) {
+        if (!name)
+            return;
+        map.set(name, sheetId);
+        const normalized = this.normalizeSheetName(name);
+        if (normalized && normalized !== name) {
+            map.set(normalized, sheetId);
+        }
+        if (normalized) {
+            map.set(`'${normalized}'`, sheetId);
+        }
+    }
+    normalizeSheetName(name) {
+        if (!name)
+            return undefined;
+        let normalized = name.trim();
+        normalized = normalized.replace(/^'+|'+$/g, "");
+        normalized = normalized.replace(/^"+|"+$/g, "");
+        normalized = normalized.replace(/^\$+/, "");
+        return normalized;
+    }
+    parseRangeList(addresses, sheetNameMap, context) {
+        if (!addresses)
+            return [];
+        const segments = this.splitAddressSegments(addresses);
+        const ranges = [];
+        for (const segment of segments) {
+            const range = this.parseRange(segment, sheetNameMap, context);
+            if (range) {
+                ranges.push(range);
+            }
+        }
+        return ranges;
+    }
+    splitAddressSegments(addresses) {
+        const segments = [];
+        let buffer = "";
+        let inQuotes = false;
+        for (let i = 0; i < addresses.length; i++) {
+            const char = addresses[i];
+            if (char === "'") {
+                if (inQuotes && addresses[i + 1] === "'") {
+                    buffer += "''";
+                    i++;
+                    continue;
+                }
+                inQuotes = !inQuotes;
+                buffer += char;
+                continue;
+            }
+            if (!inQuotes && (char === "," || /\s/.test(char))) {
+                if (buffer.trim()) {
+                    segments.push(buffer.trim());
+                    buffer = "";
+                }
+                continue;
+            }
+            buffer += char;
+        }
+        if (buffer.trim()) {
+            segments.push(buffer.trim());
+        }
+        return segments;
+    }
+    parseRange(address, sheetNameMap, context) {
+        if (!address)
+            return undefined;
+        const normalized = address.replace(/\$/g, "");
+        const [startRef, endRef] = normalized.split(":");
+        const start = this.parseCellReference(startRef, sheetNameMap, context);
+        if (!start)
+            return undefined;
+        const end = this.parseCellReference(endRef ?? startRef, sheetNameMap, context) ||
+            start;
+        const sheetId = end.sheetId ?? start.sheetId ?? context?.sheetId;
+        if (!sheetId)
+            return undefined;
+        return {
+            sheetId,
+            startRowIndex: Math.min(start.rowIndex, end.rowIndex),
+            endRowIndex: Math.max(start.rowIndex, end.rowIndex),
+            startColumnIndex: Math.min(start.columnIndex, end.columnIndex),
+            endColumnIndex: Math.max(start.columnIndex, end.columnIndex),
+        };
+    }
+    parseCellReference(reference, sheetNameMap, context) {
+        if (!reference)
+            return undefined;
+        let ref = reference.trim();
+        if (!ref)
+            return undefined;
+        ref = ref.replace(/\$/g, "");
+        let sheetName;
+        let cellPart = ref;
+        const dotMatch = ref.match(/^(.*)[.!]([A-Za-z]+\d+)$/);
+        if (dotMatch) {
+            sheetName = dotMatch[1];
+            cellPart = dotMatch[2];
+        }
+        const bangMatch = ref.match(/^(.*)!([A-Za-z]+\d+)$/);
+        if (!sheetName && bangMatch) {
+            sheetName = bangMatch[1];
+            cellPart = bangMatch[2];
+        }
+        const quotedMatch = ref.match(/^'([^']+)'\.([A-Za-z]+\d+)$/);
+        if (!sheetName && quotedMatch) {
+            sheetName = quotedMatch[1];
+            cellPart = quotedMatch[2];
+        }
+        const cell = addressToCell(cellPart.toUpperCase());
+        if (!cell)
+            return undefined;
+        const normalizedSheet = sheetName
+            ? this.normalizeSheetName(sheetName)
+            : undefined;
+        const sheetId = (normalizedSheet && sheetNameMap.get(normalizedSheet)) ??
+            (sheetName && sheetNameMap.get(sheetName)) ??
+            context?.sheetId;
+        return {
+            rowIndex: cell.rowIndex,
+            columnIndex: cell.columnIndex,
+            sheetId,
+        };
+    }
+    parseBooleanAttribute(value) {
+        if (value === undefined || value === null)
+            return undefined;
+        if (typeof value === "boolean")
+            return value;
+        const normalized = value.toString().toLowerCase();
+        if (normalized === "true" || normalized === "1")
+            return true;
+        if (normalized === "false" || normalized === "0")
+            return false;
+        return undefined;
+    }
+    normalizeConditionExpression(expression) {
+        if (!expression)
+            return undefined;
+        let normalized = expression.trim();
+        if (!normalized)
+            return undefined;
+        if (normalized.startsWith("of:=")) {
+            normalized = normalized.slice(4);
+        }
+        else if (normalized.startsWith("of:")) {
+            normalized = normalized.slice(3);
+        }
+        if (!normalized.startsWith("=")) {
+            normalized = `=${normalized}`;
+        }
+        return normalized;
+    }
+    normalizeExpression(expression) {
+        if (!expression)
+            return undefined;
+        let normalized = expression.trim();
+        if (!normalized)
+            return undefined;
+        normalized = convertOdsFormulaToExcel(normalized);
+        normalized = normalized.trim();
+        if (!normalized)
+            return undefined;
+        return normalized.startsWith("=") ? normalized : `=${normalized}`;
+    }
+    toArray(value) {
+        if (!value)
+            return [];
+        return Array.isArray(value) ? value : [value];
+    }
+    expandRowCells(rowChildren) {
+        if (!rowChildren) {
+            return [];
+        }
+        const entries = Array.isArray(rowChildren) ? rowChildren : [rowChildren];
+        const normalized = [];
+        for (const entry of entries) {
+            if (!entry)
+                continue;
+            if (entry["table:table-cell"] || entry["table:covered-table-cell"]) {
+                normalized.push(entry);
+                continue;
+            }
+            const normalizedEntry = this.wrapRawCellEntry(entry);
+            if (normalizedEntry) {
+                normalized.push(normalizedEntry);
+            }
+        }
+        return normalized;
+    }
+    wrapRawCellEntry(entry) {
+        if (entry === undefined || entry === null)
+            return undefined;
+        const { attributes, childNodes } = this.extractAttributesFromNode(entry);
+        const wrapper = {
+            "table:table-cell": childNodes.length ? childNodes : [],
+        };
+        if (Object.keys(attributes).length) {
+            wrapper[":@"] = attributes;
+        }
+        return wrapper;
+    }
+    extractAttributesFromNode(node) {
+        const attributes = {};
+        const childNodes = [];
+        if (node === undefined || node === null) {
+            return { attributes, childNodes };
+        }
+        if (typeof node !== "object" || Array.isArray(node)) {
+            childNodes.push(typeof node === "object" ? node : { "#text": node ?? "" });
+            return { attributes, childNodes };
+        }
+        for (const [key, value] of Object.entries(node)) {
+            if (key === ":@") {
+                if (value && typeof value === "object") {
+                    Object.assign(attributes, value);
+                }
+                continue;
+            }
+            if (key.startsWith("@_")) {
+                attributes[key] = value;
+                continue;
+            }
+            childNodes.push({ [key]: value });
+        }
+        return { attributes, childNodes };
+    }
+    getAttributes(node) {
+        if (!node)
+            return undefined;
+        if (Array.isArray(node)) {
+            return node.length ? this.getAttributes(node[0]) : undefined;
+        }
+        return node[":@"] || node;
+    }
+    mapAlertStyle(value) {
+        if (!value)
+            return undefined;
+        const normalized = value.toLowerCase();
+        if (normalized.includes("warn"))
+            return "warning";
+        if (normalized.includes("info"))
+            return "information";
+        return "stop";
+    }
+    async getSheets(minRowCount = 0, minColumnCount = 0) {
+        const cache = this.ensureSheetCache();
+        if (!minRowCount && !minColumnCount) {
+            return [cache.sheets, cache.tables];
+        }
+        const sheets = cache.sheets.map((sheet) => {
+            const rowCount = Math.max(sheet.rowCount ?? 0, minRowCount);
+            const columnCount = Math.max(sheet.columnCount ?? 0, minColumnCount);
+            if (rowCount === sheet.rowCount && columnCount === sheet.columnCount) {
+                return sheet;
+            }
+            return {
+                ...sheet,
+                rowCount,
+                columnCount,
+            };
+        });
+        return [sheets, cache.tables];
+    }
+    async getConditionalFormatting() {
+        return this.ensureSheetCache().conditionalFormatting;
+    }
+    async getDrawings() {
+        return this.ensureSheetCache().drawings;
+    }
+    async getCharts() {
+        return this.ensureSheetCache().charts;
+    }
+    async getDataValidations() {
+        return this.ensureSheetCache().dataValidations;
+    }
+    getNamedRanges() {
+        return this.ensureSheetCache().namedRanges;
+    }
+    findCalculationSettings(node) {
+        if (!node)
+            return undefined;
+        if (Array.isArray(node)) {
+            for (const child of node) {
+                const found = this.findCalculationSettings(child);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        }
+        if (node["table:calculation-settings"]) {
+            const settingsNode = node["table:calculation-settings"];
+            if (Array.isArray(settingsNode)) {
+                return settingsNode[0];
+            }
+            return settingsNode;
+        }
+        return (this.findCalculationSettings(node["office:spreadsheet"]) ||
+            this.findCalculationSettings(node["office:body"]) ||
+            this.findCalculationSettings(node["office:document-content"]));
+    }
+    getIterativeCalculationOptions() {
+        try {
+            const calcSettings = this.findCalculationSettings(this.contentXml) ??
+                this.findCalculationSettings(this.contentXmlOrdered);
+            if (!calcSettings)
+                return undefined;
+            const enabledAttr = getAttribute(calcSettings, "table:use-iteration");
+            const maxIterationsAttr = getAttribute(calcSettings, "table:iteration-count");
+            const maxChangeAttr = getAttribute(calcSettings, "table:minimum-step");
+            if (enabledAttr === undefined &&
+                maxIterationsAttr === undefined &&
+                maxChangeAttr === undefined) {
+                return undefined;
+            }
+            const enabled = enabledAttr === "true" || enabledAttr === true || enabledAttr === "1";
+            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;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async *processSheetData(chunkSize = 100, enableCellXfsRegistry = false, enableSharedStrings = true) {
+        try {
+            if (!this.contentXmlOrdered)
+                return;
+            const docContent = this.contentXmlOrdered[0]?.["office:document-content"] ||
+                this.contentXmlOrdered[0]?.["document-content"];
+            if (!docContent)
+                return;
+            const body = getChildren(docContent, "office:body") ||
+                getChildren(docContent, "body");
+            if (!body)
+                return;
+            const spreadsheet = getChildren(body, "office:spreadsheet") ||
+                getChildren(body, "spreadsheet");
+            if (!spreadsheet)
+                return;
+            const tables = spreadsheet.filter((child) => child["table:table"] || child["table"]);
+            const totalSheets = tables.length;
+            for (let currentSheetIndex = 0; currentSheetIndex < totalSheets; currentSheetIndex++) {
+                const tableWrapper = tables[currentSheetIndex];
+                const tableNameKey = tableWrapper["table:table"]
+                    ? "table:table"
+                    : "table";
+                const tableChildren = tableWrapper[tableNameKey];
+                const tableAttrs = tableWrapper[":@"] || {};
+                const name = tableAttrs["@_table:name"] ||
+                    tableAttrs["@_name"] ||
+                    `Sheet${currentSheetIndex + 1}`;
+                const sheetId = currentSheetIndex + 1; // 1-based ID
+                const tableStyleName = tableAttrs["@_table:style-name"] || tableAttrs["@_style-name"];
+                const tableCellFormat = tableStyleName
+                    ? this.odsStyles.getTableCellFormat(tableStyleName)
+                    : undefined;
+                // Get rows
+                const rows = tableChildren.filter((child) => child["table:table-row"] || child["table-row"]);
+                const columnWrappers = tableChildren.filter((child) => child["table:table-column"] || child["table-column"]);
+                const columnFormats = new Map();
+                let formattedColumnIndex = 1;
+                for (const columnWrapper of columnWrappers) {
+                    const columnAttrs = columnWrapper[":@"] || {};
+                    const colsRepeated = parseInt(columnAttrs["@_table:number-columns-repeated"] ||
+                        columnAttrs["@_number-columns-repeated"] ||
+                        "1", 10);
+                    const columnStyleName = columnAttrs["@_table:style-name"] || columnAttrs["@_style-name"];
+                    const columnStyle = columnStyleName
+                        ? this.odsStyles.getColumnStyle(columnStyleName)
+                        : undefined;
+                    const columnCellFormat = columnStyle?.format;
+                    for (let col = 0; col < colsRepeated; col++) {
+                        if (columnCellFormat) {
+                            columnFormats.set(formattedColumnIndex, columnCellFormat);
+                        }
+                        formattedColumnIndex++;
+                    }
+                }
+                let chunkIndex = 0;
+                let currentChunk = [];
+                let currentChunkRowIndices = [];
+                let currentRowIndex = 1;
+                // Stamp `cellData.dataValidation` refs while rows stream (see
+                // dv-cell-stamp.ts) — hosts resolve a cell's rule only through the
+                // per-cell reference. Same cached parse as `getDataValidations()`,
+                // so the stamped ids match the rule list consumers persist.
+                const dvStamper = new SheetDataValidationStamper(await this.getDataValidations(), sheetId);
+                for (const rowWrapper of rows) {
+                    const rowNameKey = rowWrapper["table:table-row"]
+                        ? "table:table-row"
+                        : "table-row";
+                    const rowChildren = rowWrapper[rowNameKey];
+                    const rowAttrs = rowWrapper[":@"] || {};
+                    const rowsRepeated = parseInt(rowAttrs["@_table:number-rows-repeated"] ||
+                        rowAttrs["@_number-rows-repeated"] ||
+                        "1");
+                    const rowStyleName = rowAttrs["@_table:style-name"] || rowAttrs["@_style-name"];
+                    const rowStyle = rowStyleName
+                        ? this.odsStyles.getRowStyle(rowStyleName)
+                        : undefined;
+                    const rowCellFormat = rowStyle?.format;
+                    const rowBaseFormat = fastMergeCellFormats(tableCellFormat, rowCellFormat);
+                    const effectiveRepeats = Math.min(rowsRepeated, 10000); // Cap to avoid infinite loops on empty sheets
+                    for (let r = 0; r < effectiveRepeats; r++) {
+                        const rowData = {
+                            values: [],
+                        };
+                        let columnIndex = 1;
+                        const normalizedRowChildren = rowChildren
+                            ? this.expandRowCells(rowChildren)
+                            : null;
+                        if (normalizedRowChildren) {
+                            for (const cellWrapper of normalizedRowChildren) {
+                                const isCell = !!cellWrapper["table:table-cell"];
+                                const isCovered = !!cellWrapper["table:covered-table-cell"];
+                                if (!isCell && !isCovered)
+                                    continue;
+                                const cellNameKey = isCell
+                                    ? "table:table-cell"
+                                    : "table:covered-table-cell";
+                                const cellChildren = cellWrapper[cellNameKey];
+                                const cellAttrs = cellWrapper[":@"] || {};
+                                const colsRepeated = parseInt(cellAttrs["@_table:number-columns-repeated"] ||
+                                    cellAttrs["@_number-columns-repeated"] ||
+                                    "1");
+                                if (isCovered) {
+                                    columnIndex += colsRepeated;
+                                    continue;
+                                }
+                                // Extract value
+                                const valueType = cellAttrs["@_office:value-type"] || cellAttrs["@_value-type"];
+                                let cellValue = null;
+                                let displayValue = "";
+                                let textFormatRuns;
+                                // Get text content
+                                const textPWrapper = findChild(cellChildren, "text:p") ||
+                                    findChild(cellChildren, "p");
+                                if (textPWrapper) {
+                                    const textPKey = textPWrapper["text:p"] ? "text:p" : "p";
+                                    const richText = this.extractTextContentWithRuns(textPWrapper[textPKey]);
+                                    displayValue = richText.text;
+                                    if (richText.runs.length > 0) {
+                                        textFormatRuns = richText.runs;
+                                    }
+                                }
+                                const hyperlinkValue = this.extractHyperlinkValue(cellChildren);
+                                if (valueType === "float" ||
+                                    valueType === "currency" ||
+                                    valueType === "percentage") {
+                                    cellValue = parseFloat(cellAttrs["@_office:value"] || cellAttrs["@_value"]);
+                                }
+                                else if (valueType === "date") {
+                                    cellValue =
+                                        cellAttrs["@_office:date-value"] ||
+                                            cellAttrs["@_date-value"];
+                                }
+                                else if (valueType === "string") {
+                                    cellValue =
+                                        cellAttrs["@_office:string-value"] ||
+                                            cellAttrs["@_string-value"] ||
+                                            displayValue;
+                                }
+                                else {
+                                    cellValue = displayValue;
+                                }
+                                const cellData = {};
+                                if (hyperlinkValue) {
+                                    cellData.hyperlink = hyperlinkValue;
+                                }
+                                if (cellValue !== null && cellValue !== "") {
+                                    const formula = cellAttrs["@_table:formula"] || cellAttrs["@_formula"];
+                                    const isSharedString = enableSharedStrings &&
+                                        !formula &&
+                                        valueType === "string" &&
+                                        typeof cellValue === "string";
+                                    if (isSharedString) {
+                                        cellData.ss = String(this.getOrCreateSharedStringIndex(String(cellValue), textFormatRuns));
+                                    }
+                                    else {
+                                        if (valueType === "float" ||
+                                            valueType === "currency" ||
+                                            valueType === "percentage") {
+                                            cellData.ev = { nv: cellValue };
+                                        }
+                                        else {
+                                            cellData.ev = { sv: String(cellValue) };
+                                        }
+                                        if (formula) {
+                                            const excelFormula = convertOdsFormulaToExcel(formula);
+                                            cellData.ue = { fv: excelFormula };
+                                            // Array (matrix) formula anchor: ODF marks the spill
+                                            // shape with table:number-matrix-{columns,rows}-spanned.
+                                            // Convert to A1 spill ref so xlsx export can emit
+                                            // <f t="array" ref="..."/>. Spilled cells in the matrix
+                                            // appear as ordinary table cells without `table:formula`
+                                            // and so don't reach this branch.
+                                            const matrixCols = parseInt(cellAttrs["@_table:number-matrix-columns-spanned"] ||
+                                                cellAttrs["@_number-matrix-columns-spanned"] ||
+                                                "0");
+                                            const matrixRows = parseInt(cellAttrs["@_table:number-matrix-rows-spanned"] ||
+                                                cellAttrs["@_number-matrix-rows-spanned"] ||
+                                                "0");
+                                            if (matrixCols > 0 || matrixRows > 0) {
+                                                const cols = Math.max(matrixCols, 1);
+                                                const rows = Math.max(matrixRows, 1);
+                                                const start = cellToAddress({
+                                                    rowIndex: currentRowIndex,
+                                                    columnIndex,
+                                                });
+                                                const end = cellToAddress({
+                                                    rowIndex: currentRowIndex + rows - 1,
+                                                    columnIndex: columnIndex + cols - 1,
+                                                });
+                                                if (start && end) {
+                                                    cellData.af = `${start}:${end}`;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            cellData.ue = cellData.ev;
+                                        }
+                                        // Skip persisted `fv` for formula cells — renderer
+                                        // derives the formatted value at paint time.
+                                        if (!formula) {
+                                            cellData.fv = displayValue;
+                                        }
+                                    }
+                                }
+                                const cellStyleName = cellAttrs["@_table:style-name"] || cellAttrs["@_style-name"];
+                                const cellFormat = cellStyleName
+                                    ? this.odsStyles.getStyle(cellStyleName)
+                                    : undefined;
+                                const hasCellValue = Object.keys(cellData).length > 0;
+                                // Fill repeated columns
+                                for (let c = 0; c < colsRepeated; c++) {
+                                    const targetColumnIndex = columnIndex;
+                                    let mergedFormat = fastMergeCellFormats(rowBaseFormat, columnFormats.get(targetColumnIndex), cellFormat);
+                                    if (mergedFormat) {
+                                        if (mergedFormat.__alignValueType) {
+                                            const alignment = valueType === "float" ||
+                                                valueType === "currency" ||
+                                                valueType === "percentage"
+                                                ? "right"
+                                                : "left";
+                                            mergedFormat.horizontalAlignment = alignment;
+                                            delete mergedFormat.__alignValueType;
+                                        }
+                                    }
+                                    const needsDefaultRightAlign = (valueType === "float" ||
+                                        valueType === "currency" ||
+                                        valueType === "percentage" ||
+                                        valueType === "date") &&
+                                        (!mergedFormat || !mergedFormat.horizontalAlignment);
+                                    if (needsDefaultRightAlign) {
+                                        mergedFormat = mergedFormat
+                                            ? { ...mergedFormat }
+                                            : {};
+                                        mergedFormat.horizontalAlignment = "right";
+                                    }
+                                    const displaySuggestsCurrency = typeof displayValue === "string" &&
+                                        DISPLAY_CURRENCY_REGEX.test(displayValue);
+                                    if (valueType === "currency") {
+                                        mergedFormat = mergedFormat
+                                            ? { ...mergedFormat }
+                                            : {};
+                                        const currencySymbol = cellAttrs["@_office:currency"] ||
+                                            cellAttrs["@_currency"] ||
+                                            "$";
+                                        if (!mergedFormat.numberFormat ||
+                                            mergedFormat.numberFormat.type === "NUMBER") {
+                                            const pattern = mergedFormat.numberFormat?.pattern || "#,##0.00";
+                                            mergedFormat.numberFormat = {
+                                                type: "CURRENCY",
+                                                pattern: pattern.includes(currencySymbol)
+                                                    ? pattern
+                                                    : `${currencySymbol}${pattern.startsWith("#") || pattern.startsWith("0")
+                                                        ? " "
+                                                        : ""}${pattern}`,
+                                            };
+                                        }
+                                    }
+                                    const shouldInferNumberFormat = valueType === "float" &&
+                                        (!mergedFormat ||
+                                            !mergedFormat.numberFormat ||
+                                            displaySuggestsCurrency);
+                                    if (shouldInferNumberFormat) {
+                                        const detectionSource = typeof displayValue === "string" &&
+                                            displayValue.trim() !== ""
+                                            ? displayValue
+                                            : cellValue;
+                                        if (detectionSource !== undefined) {
+                                            const [detectedValueType, detectedNumberFormatType, , detectedPattern,] = detectValueTypeAndPattern(detectionSource, undefined);
+                                            if (detectedValueType === "numberValue" &&
+                                                detectedNumberFormatType) {
+                                                const shouldOverrideExistingFormat = !mergedFormat ||
+                                                    !mergedFormat.numberFormat ||
+                                                    mergedFormat.numberFormat.type === "NUMBER" ||
+                                                    (displaySuggestsCurrency &&
+                                                        detectedNumberFormatType === "CURRENCY");
+                                                if (shouldOverrideExistingFormat) {
+                                                    mergedFormat = mergedFormat
+                                                        ? { ...mergedFormat }
+                                                        : {};
+                                                    mergedFormat.numberFormat = {
+                                                        type: detectedNumberFormatType,
+                                                        ...(detectedPattern
+                                                            ? { pattern: detectedPattern }
+                                                            : {}),
+                                                    };
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (!hasCellValue && !mergedFormat) {
+                                        columnIndex++;
+                                        continue;
+                                    }
+                                    const finalCellData = hasCellValue
+                                        ? { ...cellData }
+                                        : {};
+                                    if (mergedFormat) {
+                                        if (enableCellXfsRegistry) {
+                                            const styleId = this.registerFormat(mergedFormat);
+                                            finalCellData.ef = { sid: styleId };
+                                            finalCellData.uf = { sid: styleId };
+                                        }
+                                        else {
+                                            finalCellData.userEnteredFormat = mergedFormat;
+                                        }
+                                    }
+                                    rowData.values[targetColumnIndex] = finalCellData;
+                                    columnIndex++;
+                                }
+                            }
+                        }
+                        // Inject sparkline formulas for this row
+                        const sheetSparklines = this.sparklinesBySheet.get(sheetId);
+                        if (sheetSparklines) {
+                            const rowSparklines = sheetSparklines.get(currentRowIndex);
+                            if (rowSparklines) {
+                                for (const [colIndex, sparkline] of rowSparklines.entries()) {
+                                    const existingCell = rowData.values[colIndex];
+                                    // Only set formula if cell doesn't already have one
+                                    if (existingCell?.ue?.fv) {
+                                        continue;
+                                    }
+                                    // Extract data values for effective value
+                                    const sparklineData = extractSparklineData(sparkline, currentRowIndex, rowData.values);
+                                    // Build options object for sparkline result
+                                    const sparklineOptions = {};
+                                    if (sparkline.chartType !== "line") {
+                                        sparklineOptions.charttype = sparkline.chartType;
+                                    }
+                                    if (sparkline.color) {
+                                        sparklineOptions.color = sparkline.color;
+                                    }
+                                    const cellData = {
+                                        ...existingCell,
+                                        ue: { fv: sparkline.formula },
+                                    };
+                                    // Only set effective value if we have enough data points
+                                    if (sparklineData.length >= 2) {
+                                        cellData.ev = {
+                                            structuredValue: {
+                                                kind: "sparkline",
+                                                data: sparklineData,
+                                                options: sparklineOptions,
+                                            },
+                                        };
+                                    }
+                                    rowData.values[colIndex] = cellData;
+                                }
+                                // Clean up processed sparklines
+                                sheetSparklines.delete(currentRowIndex);
+                            }
+                        }
+                        dvStamper.stampRow(currentRowIndex, rowData.values);
+                        const isRowEmpty = rowData.values.length === 0;
+                        if (isRowEmpty) {
+                            currentRowIndex++;
+                            if (r === 0 && effectiveRepeats > 1) {
+                                currentRowIndex += effectiveRepeats - 1;
+                                break;
+                            }
+                            continue;
+                        }
+                        currentChunk.push(rowData);
+                        currentChunkRowIndices.push(currentRowIndex);
+                        currentRowIndex++;
+                        if (currentChunk.length >= chunkSize) {
+                            yield {
+                                sheetId,
+                                title: name,
+                                currentSheetIndex,
+                                totalSheets,
+                                chunkIndex,
+                                rows: currentChunk,
+                                rowIndices: currentChunkRowIndices,
+                                startRowIndex: currentChunkRowIndices[0],
+                                endRowIndex: currentChunkRowIndices[currentChunk.length - 1],
+                                totalRows: -1,
+                                isLastChunk: false,
+                                cellXfs: enableCellXfsRegistry ? this.cellXfs : new Map(),
+                            };
+                            currentChunk = [];
+                            currentChunkRowIndices = [];
+                            chunkIndex++;
+                        }
+                    }
+                }
+                // Rows fully absent from the content (or skipped by the repeated-
+                // empty-row fast path) but covered by a bounded DV range still need
+                // phantom `{ dataValidation }` cells or blank template rows lose
+                // their dropdowns.
+                for (const trailing of dvStamper.trailingRows()) {
+                    currentChunk.push({ values: trailing.values });
+                    currentChunkRowIndices.push(trailing.rowIndex);
+                    if (currentChunk.length >= chunkSize) {
+                        yield {
+                            sheetId,
+                            title: name,
+                            currentSheetIndex,
+                            totalSheets,
+                            chunkIndex,
+                            rows: currentChunk,
+                            rowIndices: currentChunkRowIndices,
+                            startRowIndex: currentChunkRowIndices[0],
+                            endRowIndex: currentChunkRowIndices[currentChunk.length - 1],
+                            totalRows: -1,
+                            isLastChunk: false,
+                            cellXfs: enableCellXfsRegistry ? this.cellXfs : new Map(),
+                        };
+                        currentChunk = [];
+                        currentChunkRowIndices = [];
+                        chunkIndex++;
+                    }
+                }
+                // Yield remaining
+                if (currentChunk.length > 0) {
+                    yield {
+                        sheetId,
+                        title: name,
+                        currentSheetIndex,
+                        totalSheets,
+                        chunkIndex,
+                        rows: currentChunk,
+                        rowIndices: currentChunkRowIndices,
+                        startRowIndex: currentChunkRowIndices[0],
+                        endRowIndex: currentChunkRowIndices[currentChunk.length - 1],
+                        totalRows: currentRowIndex - 1,
+                        isLastChunk: true,
+                        cellXfs: enableCellXfsRegistry ? this.cellXfs : new Map(),
+                    };
+                }
+                else {
+                    // Empty sheet
+                    yield {
+                        sheetId,
+                        title: name,
+                        currentSheetIndex,
+                        totalSheets,
+                        chunkIndex,
+                        rows: [],
+                        rowIndices: [],
+                        startRowIndex: 0,
+                        endRowIndex: 0,
+                        totalRows: 0,
+                        isLastChunk: true,
+                        cellXfs: enableCellXfsRegistry ? this.cellXfs : new Map(),
+                    };
+                }
+            }
+        }
+        catch (error) {
+            console.error("Error processing ODS sheet data", error);
+            throw error;
+        }
+    }
+}