@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,3642 @@
+import { __assign, __asyncGenerator, __await, __awaiter, __extends, __generator, __read, __spreadArray, __values } from "tslib";
+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";
+var 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: function (_name, value) { return Unescape(value); },
+    attributeValueProcessor: function (_name, value) { return Unescape(value); },
+};
+var ODS_ORDERED_XML_OPTIONS = __assign(__assign({}, ODS_XML_OPTIONS), { preserveOrder: true });
+var DISPLAY_CURRENCY_REGEX = /[$€¥£₹]/;
+function findChild(children, tagName) {
+    return children === null || children === void 0 ? void 0 : children.find(function (child) { return child[tagName]; });
+}
+function getChildren(node, tagName) {
+    var found = findChild(node, tagName);
+    return found ? found[tagName] : undefined;
+}
+function getAttribute(node, attributeName) {
+    if (!node)
+        return undefined;
+    if (node["@_".concat(attributeName)] !== undefined) {
+        return node["@_".concat(attributeName)];
+    }
+    if (node[":@"] && node[":@"]["@_".concat(attributeName)] !== undefined) {
+        return node[":@"]["@_".concat(attributeName)];
+    }
+    return undefined;
+}
+function fastMergeCellFormats() {
+    var e_1, _a;
+    var formats = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        formats[_i] = arguments[_i];
+    }
+    var result;
+    try {
+        for (var formats_1 = __values(formats), formats_1_1 = formats_1.next(); !formats_1_1.done; formats_1_1 = formats_1.next()) {
+            var format = formats_1_1.value;
+            if (!format)
+                continue;
+            if (!result) {
+                result = __assign({}, 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
+                    ? __assign(__assign({}, result.textFormat), format.textFormat) : __assign({}, format.textFormat);
+            }
+            if (format.numberFormat) {
+                result.numberFormat = __assign({}, format.numberFormat);
+            }
+            if (format.borders) {
+                result.borders = result.borders
+                    ? __assign({}, result.borders) : __assign({}, 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;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (formats_1_1 && !formats_1_1.done && (_a = formats_1.return)) _a.call(formats_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    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.
+var 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",
+};
+var OdsPlugin = /** @class */ (function (_super) {
+    __extends(OdsPlugin, _super);
+    function OdsPlugin() {
+        var _this = _super.call(this) || this;
+        _this.cellXfs = new Map();
+        _this.sharedStrings = [];
+        _this.richSharedStringRuns = new Map();
+        _this.sharedStringIndexByValue = new Map();
+        _this.sheetCache = null;
+        _this.sparklinesBySheet = new Map();
+        _this.zipParser = new ZipParser();
+        _this.xmlParser = new XMLParser(ODS_XML_OPTIONS);
+        _this.xmlOrderedParser = new XMLParser(ODS_ORDERED_XML_OPTIONS);
+        _this.odsStyles = new OdsStyles();
+        return _this;
+    }
+    OdsPlugin.prototype.load = function (buffer, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var source, _a, content, styles, parsedStyles, settings;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(buffer instanceof File)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, buffer.arrayBuffer()];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = buffer;
+                        _b.label = 3;
+                    case 3:
+                        source = _a;
+                        return [4 /*yield*/, this.zipParser.load(source, password)];
+                    case 4:
+                        _b.sent();
+                        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 {
+                            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);
+                            }
+                            styles = this.zipParser.Get("styles.xml");
+                            if (styles) {
+                                parsedStyles = this.xmlParser.parse(styles);
+                                this.odsStyles.parseStylesXml(parsedStyles);
+                            }
+                            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);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    OdsPlugin.prototype.getCellXfs = function () {
+        return this.cellXfs;
+    };
+    OdsPlugin.prototype.getSharedStrings = function () {
+        return this.sharedStrings;
+    };
+    OdsPlugin.prototype.getOrCreateSharedStringIndex = function (value, runs) {
+        var key = (runs === null || runs === void 0 ? void 0 : runs.length) ? JSON.stringify({ value: value, runs: runs }) : value;
+        var existing = this.sharedStringIndexByValue.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        var index = this.sharedStrings.length;
+        this.sharedStrings.push(value);
+        if (runs === null || runs === void 0 ? void 0 : runs.length) {
+            this.richSharedStringRuns.set(index, runs);
+        }
+        this.sharedStringIndexByValue.set(key, index);
+        return index;
+    };
+    OdsPlugin.prototype.registerFormat = function (format) {
+        var key = getCellXfsKey(format);
+        if (!this.cellXfs.has(key)) {
+            this.cellXfs.set(key, format);
+        }
+        return key;
+    };
+    OdsPlugin.prototype.dispose = function () {
+        this.zipParser.Dispose();
+        this.contentXml = null;
+        this.contentXmlOrdered = null;
+        this.settingsXml = null;
+        this.sheetCache = null;
+    };
+    OdsPlugin.prototype.getSpreadsheetNode = function () {
+        if (!this.contentXml)
+            return undefined;
+        return (get(this.contentXml, "office:document-content.office:body.office:spreadsheet") || get(this.contentXml, "document-content.body.spreadsheet"));
+    };
+    OdsPlugin.prototype.getTables = function () {
+        var body = this.getSpreadsheetNode();
+        if (!body)
+            return [];
+        var tables = get(body, "table:table") || get(body, "table");
+        return Array.isArray(tables) ? tables : tables ? [tables] : [];
+    };
+    OdsPlugin.prototype.getSheetCount = function () {
+        return this.getTables().length;
+    };
+    OdsPlugin.prototype.ensureSheetCache = function () {
+        if (this.sheetCache) {
+            return this.sheetCache;
+        }
+        var cache = this.buildSheetCache();
+        this.sheetCache = cache;
+        return cache;
+    };
+    OdsPlugin.prototype.buildSheetCache = function () {
+        var e_2, _a;
+        var _this = this;
+        var _b, _c;
+        var tables = this.getTables();
+        var sheets = [];
+        var sheetContexts = [];
+        tables.forEach(function (table, index) {
+            var e_3, _a, e_4, _b;
+            var _c, _d, _e, _f;
+            var name = table["@_table:name"] ||
+                table["@_name"] ||
+                table["table:name"] ||
+                table["name"] ||
+                "Sheet".concat(index + 1);
+            var sheet = {
+                sheetId: index + 1,
+                title: name,
+                hidden: ((_c = table["@_table:style-name"]) === null || _c === void 0 ? void 0 : _c.includes("hidden")) ||
+                    ((_d = table["table:style-name"]) === null || _d === void 0 ? void 0 : _d.includes("hidden")) ||
+                    false,
+                rowMetadata: [],
+                columnMetadata: [],
+                merges: [],
+            };
+            // Column metadata from table-column elements
+            var columnNodes = get(table, "table:table-column") || get(table, "table-column") || [];
+            var allColumns = Array.isArray(columnNodes)
+                ? columnNodes
+                : columnNodes
+                    ? [columnNodes]
+                    : [];
+            var currentColumnIndex = 1;
+            var detectedColumnCount = 0;
+            var defaultColumnWidth;
+            var defaultColumnStyleName;
+            try {
+                for (var allColumns_1 = __values(allColumns), allColumns_1_1 = allColumns_1.next(); !allColumns_1_1.done; allColumns_1_1 = allColumns_1.next()) {
+                    var column = allColumns_1_1.value;
+                    if (!column)
+                        continue;
+                    var colsRepeated = parseInt(getAttribute(column, "table:number-columns-repeated") ||
+                        getAttribute(column, "number-columns-repeated") ||
+                        "1", 10);
+                    var styleName = getAttribute(column, "table:style-name") ||
+                        getAttribute(column, "style-name");
+                    var visibility = getAttribute(column, "table:visibility") ||
+                        getAttribute(column, "visibility");
+                    var columnStyle = styleName
+                        ? _this.odsStyles.getColumnStyle(styleName)
+                        : undefined;
+                    var width = columnStyle === null || columnStyle === void 0 ? void 0 : columnStyle.width;
+                    var isHidden = visibility === "collapse" ||
+                        visibility === "hidden" ||
+                        visibility === "none" ||
+                        (columnStyle === null || columnStyle === void 0 ? void 0 : columnStyle.hidden);
+                    for (var c = 0; c < colsRepeated; c++) {
+                        var props = {};
+                        var shouldAssign = false;
+                        if (typeof width === "number") {
+                            props.size = width;
+                            if (defaultColumnWidth === undefined) {
+                                defaultColumnWidth = width;
+                                defaultColumnStyleName = styleName;
+                            }
+                            var widthDiffers = defaultColumnWidth === undefined
+                                ? true
+                                : Math.abs(width - defaultColumnWidth) > 0.5;
+                            var 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);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (allColumns_1_1 && !allColumns_1_1.done && (_a = allColumns_1.return)) _a.call(allColumns_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            // Row metadata from table-row elements
+            var rowNodes = get(table, "table:table-row") || get(table, "table-row") || [];
+            var allRows = Array.isArray(rowNodes) ? rowNodes : [rowNodes];
+            // DO NOT DELETE
+            // console.log("allRows", allRows);
+            var currentRowIndex = 1;
+            var defaultRowHeight;
+            var defaultRowStyleName;
+            var detectedRowCount = 0;
+            try {
+                for (var allRows_1 = __values(allRows), allRows_1_1 = allRows_1.next(); !allRows_1_1.done; allRows_1_1 = allRows_1.next()) {
+                    var row = allRows_1_1.value;
+                    if (!row)
+                        continue;
+                    var rowsRepeated = parseInt(getAttribute(row, "table:number-rows-repeated") ||
+                        getAttribute(row, "number-rows-repeated") ||
+                        "1", 10);
+                    var styleName = getAttribute(row, "table:style-name") ||
+                        getAttribute(row, "style-name");
+                    var visibility = getAttribute(row, "table:visibility") ||
+                        getAttribute(row, "visibility");
+                    var rowStyle = styleName
+                        ? _this.odsStyles.getRowStyle(styleName)
+                        : undefined;
+                    var height = rowStyle === null || rowStyle === void 0 ? void 0 : rowStyle.height;
+                    var isHidden = visibility === "collapse" ||
+                        visibility === "hidden" ||
+                        visibility === "none" ||
+                        (rowStyle === null || rowStyle === void 0 ? void 0 : rowStyle.hidden);
+                    var effectiveRepeats = Math.min(rowsRepeated, 10000);
+                    var shouldProcessRowMetadata = typeof height === "number" || isHidden;
+                    if (!shouldProcessRowMetadata) {
+                        currentRowIndex += effectiveRepeats;
+                        detectedRowCount = Math.max(detectedRowCount, currentRowIndex - 1);
+                        continue;
+                    }
+                    for (var r = 0; r < effectiveRepeats; r++) {
+                        var props = {};
+                        var shouldAssign = false;
+                        if (typeof height === "number") {
+                            props.size = height;
+                            if (defaultRowHeight === undefined) {
+                                defaultRowHeight = height;
+                                defaultRowStyleName = styleName;
+                            }
+                            var heightDiffers = defaultRowHeight === undefined
+                                ? true
+                                : Math.abs(height - defaultRowHeight) > 0.5;
+                            var 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);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (allRows_1_1 && !allRows_1_1.done && (_b = allRows_1.return)) _b.call(allRows_1);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            if (detectedRowCount > 0) {
+                sheet.rowCount = Math.max((_e = sheet.rowCount) !== null && _e !== void 0 ? _e : 0, detectedRowCount);
+            }
+            if (detectedColumnCount > 0) {
+                sheet.columnCount = Math.max((_f = sheet.columnCount) !== null && _f !== void 0 ? _f : 0, detectedColumnCount);
+            }
+            sheets.push(sheet);
+            sheetContexts.push({ node: table, sheetId: sheet.sheetId, name: name });
+        });
+        var sheetNameMap = this.buildSheetNameMap(sheetContexts);
+        var spreadsheetNode = this.getSpreadsheetNode();
+        var tableViews = this.extractTableViews(sheetContexts);
+        var conditionalFormatting = extractConditionalFormats({
+            sheetContexts: sheetContexts,
+            sheetNameMap: 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),
+        });
+        var dataValidations = extractDataValidations({
+            sheetContexts: sheetContexts,
+            sheetNameMap: sheetNameMap,
+            spreadsheetNode: 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),
+        });
+        var namedRanges = this.extractNamedRanges(sheetContexts);
+        var _d = this.extractEmbeddedObjects(sheetContexts, sheetNameMap), drawings = _d.drawings, charts = _d.charts;
+        // Extract LibreOffice sparklines (calcext:sparkline-groups)
+        this.sparklinesBySheet = extractSparklines({
+            sheetContexts: sheetContexts,
+            sheetNameMap: sheetNameMap,
+            getAttributes: this.getAttributes.bind(this),
+            toArray: this.toArray.bind(this),
+        });
+        var mergesMap = this.extractMerges(sheetContexts);
+        this.extractOutlineGroups(sheets);
+        var sheetSettings = this.extractSheetSettings(sheetContexts);
+        var basicFilters = this.extractBasicFilters(sheetContexts, sheetNameMap, spreadsheetNode);
+        try {
+            for (var sheets_1 = __values(sheets), sheets_1_1 = sheets_1.next(); !sheets_1_1.done; sheets_1_1 = sheets_1.next()) {
+                var sheet = sheets_1_1.value;
+                sheet.merges = (_c = (_b = mergesMap.get(sheet.sheetId)) !== null && _b !== void 0 ? _b : sheet.merges) !== null && _c !== void 0 ? _c : [];
+                var 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;
+                    }
+                }
+                var filter = basicFilters.get(sheet.sheetId);
+                if (filter) {
+                    sheet.basicFilter = filter;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (sheets_1_1 && !sheets_1_1.done && (_a = sheets_1.return)) _a.call(sheets_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return {
+            sheets: sheets,
+            tables: tableViews,
+            conditionalFormatting: conditionalFormatting,
+            dataValidations: dataValidations,
+            namedRanges: namedRanges,
+            drawings: drawings,
+            charts: charts,
+        };
+    };
+    OdsPlugin.prototype.extractTableViews = function (sheetContexts) {
+        var e_5, _a, e_6, _b, e_7, _c;
+        if (!sheetContexts.length)
+            return [];
+        var spreadsheet = this.getSpreadsheetNode();
+        if (!spreadsheet)
+            return [];
+        var sheetNameMap = this.buildSheetNameMap(sheetContexts);
+        var tableViews = [];
+        var globalRanges = this.toArray(get(spreadsheet, "table:database-ranges.table:database-range") ||
+            get(spreadsheet, "database-ranges.database-range"));
+        try {
+            for (var globalRanges_1 = __values(globalRanges), globalRanges_1_1 = globalRanges_1.next(); !globalRanges_1_1.done; globalRanges_1_1 = globalRanges_1.next()) {
+                var node = globalRanges_1_1.value;
+                var tableView = this.convertDatabaseRangeNode(node, sheetNameMap, undefined, sheetContexts);
+                if (tableView) {
+                    tableViews.push(tableView);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (globalRanges_1_1 && !globalRanges_1_1.done && (_a = globalRanges_1.return)) _a.call(globalRanges_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        try {
+            for (var sheetContexts_1 = __values(sheetContexts), sheetContexts_1_1 = sheetContexts_1.next(); !sheetContexts_1_1.done; sheetContexts_1_1 = sheetContexts_1.next()) {
+                var context = sheetContexts_1_1.value;
+                var inlineRanges = this.toArray(get(context.node, "table:database-range") ||
+                    get(context.node, "database-range"));
+                try {
+                    for (var inlineRanges_1 = (e_7 = void 0, __values(inlineRanges)), inlineRanges_1_1 = inlineRanges_1.next(); !inlineRanges_1_1.done; inlineRanges_1_1 = inlineRanges_1.next()) {
+                        var node = inlineRanges_1_1.value;
+                        var tableView = this.convertDatabaseRangeNode(node, sheetNameMap, context, sheetContexts);
+                        if (tableView) {
+                            tableViews.push(tableView);
+                        }
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (inlineRanges_1_1 && !inlineRanges_1_1.done && (_c = inlineRanges_1.return)) _c.call(inlineRanges_1);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (sheetContexts_1_1 && !sheetContexts_1_1.done && (_b = sheetContexts_1.return)) _b.call(sheetContexts_1);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        return tableViews;
+    };
+    OdsPlugin.prototype.convertDatabaseRangeNode = function (node, sheetNameMap, context, sheetContexts) {
+        var attrs = this.getAttributes(node);
+        if (!attrs)
+            return undefined;
+        var rangeAttr = attrs["@_table:target-range-address"] ||
+            attrs["@_target-range-address"] ||
+            attrs["@_table:cell-range-address"];
+        var ranges = this.parseRangeList(rangeAttr, sheetNameMap, context);
+        if (!ranges.length)
+            return undefined;
+        var _a = __read(ranges, 1), range = _a[0];
+        var title = attrs["@_table:display-label"] ||
+            attrs["@_table:name"] ||
+            attrs["@_name"] ||
+            "Table".concat(range.sheetId);
+        var tableView = {
+            id: attrs["@_table:id"] || attrs["@_id"] || title,
+            sheetId: range.sheetId,
+            title: title,
+            range: range,
+        };
+        var headerRow = this.parseBooleanAttribute(attrs["@_table:contains-header"] || attrs["@_contains-header"]);
+        if (headerRow !== undefined) {
+            tableView.headerRow = headerRow;
+        }
+        var totalRow = this.parseBooleanAttribute(attrs["@_table:contains-total-row"] || attrs["@_contains-total-row"]);
+        if (totalRow !== undefined) {
+            tableView.totalRow = totalRow;
+        }
+        var filterButton = this.parseBooleanAttribute(attrs["@_table:display-filter-buttons"] ||
+            attrs["@_display-filter-buttons"]);
+        if (filterButton !== undefined) {
+            tableView.filterButton = filterButton;
+        }
+        var showRowStripes = this.parseBooleanAttribute(attrs["@_table:use-banding-rows"] || attrs["@_use-banding-rows"]);
+        if (showRowStripes !== undefined) {
+            tableView.showRowStripes = showRowStripes;
+        }
+        var showColumnStripes = this.parseBooleanAttribute(attrs["@_table:use-banding-columns"] || attrs["@_use-banding-columns"]);
+        if (showColumnStripes !== undefined) {
+            tableView.showColumnStripes = showColumnStripes;
+        }
+        var effectiveContext = context !== null && context !== void 0 ? context : sheetContexts === null || sheetContexts === void 0 ? void 0 : sheetContexts.find(function (entry) { return entry.sheetId === range.sheetId; });
+        var columns = this.extractTableColumnsFromHeader(range, effectiveContext, tableView.headerRow !== false);
+        if (columns === null || columns === void 0 ? void 0 : columns.length) {
+            tableView.columns = columns;
+        }
+        return tableView;
+    };
+    OdsPlugin.prototype.extractNamedRanges = function (sheetContexts) {
+        var e_8, _a, e_9, _b, e_10, _c;
+        var _this = this;
+        var spreadsheet = this.getSpreadsheetNode();
+        if (!spreadsheet)
+            return [];
+        var sheetNameMap = this.buildSheetNameMap(sheetContexts);
+        var namedRanges = [];
+        var processContainer = function (container, context) {
+            var e_11, _a, e_12, _b, e_13, _c;
+            if (!container)
+                return;
+            var rangeNodes = _this.toArray(get(container, "table:named-range") || get(container, "named-range"));
+            try {
+                for (var rangeNodes_1 = __values(rangeNodes), rangeNodes_1_1 = rangeNodes_1.next(); !rangeNodes_1_1.done; rangeNodes_1_1 = rangeNodes_1.next()) {
+                    var node = rangeNodes_1_1.value;
+                    var attrs = _this.getAttributes(node);
+                    if (!attrs)
+                        continue;
+                    var name_1 = attrs["@_table:name"] ||
+                        attrs["@_name"] ||
+                        attrs["@_table:display-name"];
+                    if (!name_1)
+                        continue;
+                    var addressAttr = attrs["@_table:cell-range-address"] ||
+                        attrs["@_cell-range-address"] ||
+                        attrs["@_table:base-cell-address"] ||
+                        attrs["@_base-cell-address"];
+                    var ranges = _this.parseRangeList(addressAttr, sheetNameMap, context);
+                    try {
+                        for (var ranges_1 = (e_12 = void 0, __values(ranges)), ranges_1_1 = ranges_1.next(); !ranges_1_1.done; ranges_1_1 = ranges_1.next()) {
+                            var range = ranges_1_1.value;
+                            namedRanges.push({
+                                namedRangeId: uuid(),
+                                name: name_1,
+                                range: range,
+                            });
+                        }
+                    }
+                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                    finally {
+                        try {
+                            if (ranges_1_1 && !ranges_1_1.done && (_b = ranges_1.return)) _b.call(ranges_1);
+                        }
+                        finally { if (e_12) throw e_12.error; }
+                    }
+                }
+            }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            finally {
+                try {
+                    if (rangeNodes_1_1 && !rangeNodes_1_1.done && (_a = rangeNodes_1.return)) _a.call(rangeNodes_1);
+                }
+                finally { if (e_11) throw e_11.error; }
+            }
+            var expressionNodes = _this.toArray(get(container, "table:named-expression") ||
+                get(container, "named-expression"));
+            try {
+                for (var expressionNodes_1 = __values(expressionNodes), expressionNodes_1_1 = expressionNodes_1.next(); !expressionNodes_1_1.done; expressionNodes_1_1 = expressionNodes_1.next()) {
+                    var node = expressionNodes_1_1.value;
+                    var attrs = _this.getAttributes(node);
+                    if (!attrs)
+                        continue;
+                    var name_2 = attrs["@_table:name"] ||
+                        attrs["@_name"] ||
+                        attrs["@_table:display-name"];
+                    if (!name_2)
+                        continue;
+                    var expressionAttr = attrs["@_table:expression"] || attrs["@_expression"];
+                    var excelFormula = _this.normalizeExpression(expressionAttr);
+                    if (excelFormula) {
+                        namedRanges.push({
+                            namedRangeId: uuid(),
+                            name: name_2,
+                            value: excelFormula,
+                        });
+                    }
+                }
+            }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            finally {
+                try {
+                    if (expressionNodes_1_1 && !expressionNodes_1_1.done && (_c = expressionNodes_1.return)) _c.call(expressionNodes_1);
+                }
+                finally { if (e_13) throw e_13.error; }
+            }
+        };
+        var globalContainers = this.toArray(get(spreadsheet, "table:named-expressions") ||
+            get(spreadsheet, "named-expressions"));
+        try {
+            for (var globalContainers_1 = __values(globalContainers), globalContainers_1_1 = globalContainers_1.next(); !globalContainers_1_1.done; globalContainers_1_1 = globalContainers_1.next()) {
+                var container = globalContainers_1_1.value;
+                processContainer(container);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (globalContainers_1_1 && !globalContainers_1_1.done && (_a = globalContainers_1.return)) _a.call(globalContainers_1);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        try {
+            for (var sheetContexts_2 = __values(sheetContexts), sheetContexts_2_1 = sheetContexts_2.next(); !sheetContexts_2_1.done; sheetContexts_2_1 = sheetContexts_2.next()) {
+                var context = sheetContexts_2_1.value;
+                var containers = this.toArray(get(context.node, "table:named-expressions") ||
+                    get(context.node, "named-expressions"));
+                try {
+                    for (var containers_1 = (e_10 = void 0, __values(containers)), containers_1_1 = containers_1.next(); !containers_1_1.done; containers_1_1 = containers_1.next()) {
+                        var container = containers_1_1.value;
+                        processContainer(container, context);
+                    }
+                }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                finally {
+                    try {
+                        if (containers_1_1 && !containers_1_1.done && (_c = containers_1.return)) _c.call(containers_1);
+                    }
+                    finally { if (e_10) throw e_10.error; }
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (sheetContexts_2_1 && !sheetContexts_2_1.done && (_b = sheetContexts_2.return)) _b.call(sheetContexts_2);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        return namedRanges;
+    };
+    OdsPlugin.prototype.extractBasicFilters = function (sheetContexts, sheetNameMap, spreadsheetNode) {
+        var e_14, _a, e_15, _b, e_16, _c;
+        var _this = this;
+        var filters = new Map();
+        if (!sheetContexts.length) {
+            return filters;
+        }
+        var processNode = function (node, context) {
+            if (!node)
+                return;
+            var filterNode = get(node, "table:filter") || get(node, "filter");
+            if (!filterNode)
+                return;
+            var attrs = _this.getAttributes(node);
+            if (!attrs)
+                return;
+            var rangeAttr = attrs["@_table:target-range-address"] ||
+                attrs["@_target-range-address"] ||
+                attrs["@_table:cell-range-address"] ||
+                attrs["@_cell-range-address"];
+            var ranges = _this.parseRangeList(rangeAttr, sheetNameMap, context);
+            if (!ranges.length)
+                return;
+            var filterSpecs = _this.convertFilterNodeToSpecs(filterNode);
+            if (!filterSpecs.length)
+                return;
+            var _a = __read(ranges, 1), range = _a[0];
+            var filterView = {
+                id: attrs["@_table:name"] || attrs["@_name"] || uuid(),
+                title: attrs["@_table:display-label"] ||
+                    attrs["@_table:name"] ||
+                    attrs["@_name"],
+                range: range,
+                filterSpecs: filterSpecs,
+            };
+            filters.set(range.sheetId, filterView);
+        };
+        if (spreadsheetNode) {
+            var globalRanges = this.toArray(get(spreadsheetNode, "table:database-ranges.table:database-range") ||
+                get(spreadsheetNode, "database-ranges.database-range"));
+            try {
+                for (var globalRanges_2 = __values(globalRanges), globalRanges_2_1 = globalRanges_2.next(); !globalRanges_2_1.done; globalRanges_2_1 = globalRanges_2.next()) {
+                    var node = globalRanges_2_1.value;
+                    processNode(node);
+                }
+            }
+            catch (e_14_1) { e_14 = { error: e_14_1 }; }
+            finally {
+                try {
+                    if (globalRanges_2_1 && !globalRanges_2_1.done && (_a = globalRanges_2.return)) _a.call(globalRanges_2);
+                }
+                finally { if (e_14) throw e_14.error; }
+            }
+        }
+        try {
+            for (var sheetContexts_3 = __values(sheetContexts), sheetContexts_3_1 = sheetContexts_3.next(); !sheetContexts_3_1.done; sheetContexts_3_1 = sheetContexts_3.next()) {
+                var context = sheetContexts_3_1.value;
+                var inlineRanges = this.toArray(get(context.node, "table:database-range") ||
+                    get(context.node, "database-range"));
+                try {
+                    for (var inlineRanges_2 = (e_16 = void 0, __values(inlineRanges)), inlineRanges_2_1 = inlineRanges_2.next(); !inlineRanges_2_1.done; inlineRanges_2_1 = inlineRanges_2.next()) {
+                        var node = inlineRanges_2_1.value;
+                        processNode(node, context);
+                    }
+                }
+                catch (e_16_1) { e_16 = { error: e_16_1 }; }
+                finally {
+                    try {
+                        if (inlineRanges_2_1 && !inlineRanges_2_1.done && (_c = inlineRanges_2.return)) _c.call(inlineRanges_2);
+                    }
+                    finally { if (e_16) throw e_16.error; }
+                }
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (sheetContexts_3_1 && !sheetContexts_3_1.done && (_b = sheetContexts_3.return)) _b.call(sheetContexts_3);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        return filters;
+    };
+    OdsPlugin.prototype.convertFilterNodeToSpecs = function (filterNode) {
+        var e_17, _a, e_18, _b;
+        var _this = this;
+        var specMap = new Map();
+        var addConditions = function (container) {
+            var e_19, _a;
+            var conditions = _this.toArray(get(container, "table:filter-condition") ||
+                get(container, "filter-condition"));
+            try {
+                for (var conditions_1 = __values(conditions), conditions_1_1 = conditions_1.next(); !conditions_1_1.done; conditions_1_1 = conditions_1.next()) {
+                    var condition = conditions_1_1.value;
+                    _this.applyFilterCondition(condition, specMap);
+                }
+            }
+            catch (e_19_1) { e_19 = { error: e_19_1 }; }
+            finally {
+                try {
+                    if (conditions_1_1 && !conditions_1_1.done && (_a = conditions_1.return)) _a.call(conditions_1);
+                }
+                finally { if (e_19) throw e_19.error; }
+            }
+        };
+        addConditions(filterNode);
+        var andNodes = this.toArray(get(filterNode, "table:filter-and") || get(filterNode, "filter-and"));
+        try {
+            for (var andNodes_1 = __values(andNodes), andNodes_1_1 = andNodes_1.next(); !andNodes_1_1.done; andNodes_1_1 = andNodes_1.next()) {
+                var node = andNodes_1_1.value;
+                addConditions(node);
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (andNodes_1_1 && !andNodes_1_1.done && (_a = andNodes_1.return)) _a.call(andNodes_1);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+        var orNodes = this.toArray(get(filterNode, "table:filter-or") || get(filterNode, "filter-or"));
+        try {
+            for (var orNodes_1 = __values(orNodes), orNodes_1_1 = orNodes_1.next(); !orNodes_1_1.done; orNodes_1_1 = orNodes_1.next()) {
+                var node = orNodes_1_1.value;
+                addConditions(node);
+            }
+        }
+        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        finally {
+            try {
+                if (orNodes_1_1 && !orNodes_1_1.done && (_b = orNodes_1.return)) _b.call(orNodes_1);
+            }
+            finally { if (e_18) throw e_18.error; }
+        }
+        return Array.from(specMap.values()).sort(function (a, b) { return a.columnIndex - b.columnIndex; });
+    };
+    OdsPlugin.prototype.applyFilterCondition = function (node, specMap) {
+        var _a, _b, _c, _d;
+        var attrs = this.getAttributes(node);
+        if (!attrs)
+            return;
+        var field = attrs["@_table:field-number"] ||
+            attrs["@_field-number"] ||
+            attrs["@_table:column-number"] ||
+            attrs["@_column-number"];
+        if (field === undefined)
+            return;
+        var columnIndex = parseInt(field, 10);
+        if (isNaN(columnIndex))
+            return;
+        var operator = String((_b = (_a = attrs["@_table:operator"]) !== null && _a !== void 0 ? _a : attrs["@_operator"]) !== null && _b !== void 0 ? _b : "=");
+        var value = (_c = attrs["@_table:value"]) !== null && _c !== void 0 ? _c : attrs["@_value"];
+        var value2 = (_d = attrs["@_table:value2"]) !== null && _d !== void 0 ? _d : attrs["@_value2"];
+        var spec = specMap.get(columnIndex);
+        if (!spec) {
+            spec = {
+                columnIndex: 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.
+        var conditionType = ODS_OPERATOR_TO_CONDITION[operator];
+        if (conditionType) {
+            var 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));
+    };
+    OdsPlugin.prototype.extractTextContent = function (node) {
+        var _this = this;
+        if (node === null || node === undefined)
+            return "";
+        var primitiveTypes = ["string", "number", "boolean"];
+        if (primitiveTypes.includes(typeof node)) {
+            return String(node);
+        }
+        if (Array.isArray(node)) {
+            return node.map(function (entry) { return _this.extractTextContent(entry); }).join("");
+        }
+        var result = "";
+        if (node["text:s"]) {
+            result += this.extractSpaceNodes(node["text:s"], node);
+        }
+        if (node["text:line-break"]) {
+            var 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) {
+            var textValue = node["#text"];
+            if (typeof textValue === "string" ||
+                typeof textValue === "number" ||
+                typeof textValue === "boolean") {
+                result += String(textValue);
+            }
+        }
+        return result;
+    };
+    OdsPlugin.prototype.extractTextContentWithRuns = function (node) {
+        var _this = this;
+        var text = "";
+        var runs = [];
+        var hasFormat = function (format) {
+            return !!format && Object.keys(format).length > 0;
+        };
+        var mergeFormat = function (base, next) { return (base || next ? __assign(__assign({}, (base !== null && base !== void 0 ? base : {})), (next !== null && next !== void 0 ? next : {})) : undefined); };
+        var appendText = function (value) {
+            if (typeof value === "string" ||
+                typeof value === "number" ||
+                typeof value === "boolean") {
+                text += String(value);
+            }
+        };
+        var walk = function (value, inherited) {
+            var e_20, _a;
+            var _b;
+            if (value === null || value === undefined)
+                return;
+            if (Array.isArray(value)) {
+                value.forEach(function (entry) { return 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"]) {
+                var breaks = _this.toArray(value["text:line-break"]);
+                text += "\n".repeat(breaks.length || 1);
+            }
+            if (value["#text"] !== undefined && value["#text"] !== null) {
+                appendText(value["#text"]);
+            }
+            var spanNodes = value["text:span"];
+            if (spanNodes) {
+                try {
+                    for (var _c = __values(_this.toArray(spanNodes)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var span = _d.value;
+                        var attrs = (_b = _this.getAttributes(span)) !== null && _b !== void 0 ? _b : {};
+                        var styleName = attrs["@_text:style-name"] || attrs["@_style-name"];
+                        var spanFormat = mergeFormat(inherited, _this.odsStyles.getTextFormat(styleName));
+                        var startIndex = text.length;
+                        walk(span, spanFormat);
+                        if (hasFormat(spanFormat) && text.length > startIndex) {
+                            var format = spanFormat;
+                            runs.push({
+                                startIndex: startIndex,
+                                endIndex: text.length,
+                                format: format,
+                                nodeType: "text",
+                            });
+                        }
+                    }
+                }
+                catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_20) throw e_20.error; }
+                }
+            }
+            if (value["text:a"]) {
+                walk(value["text:a"], inherited);
+            }
+            if (value["text:p"]) {
+                walk(value["text:p"], inherited);
+            }
+        };
+        walk(node);
+        return { text: text, runs: runs };
+    };
+    OdsPlugin.prototype.normalizeInternalHyperlinkLocation = function (href) {
+        var 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;
+        }
+        var match = location.match(/^(.*)\.([A-Za-z]+[0-9].*)$/);
+        if (match) {
+            return "".concat(match[1], "!").concat(match[2]);
+        }
+        return location;
+    };
+    OdsPlugin.prototype.extractHyperlinkValue = function (node) {
+        var e_21, _a, e_22, _b, e_23, _c;
+        if (node === null || node === undefined)
+            return undefined;
+        if (Array.isArray(node)) {
+            try {
+                for (var node_1 = __values(node), node_1_1 = node_1.next(); !node_1_1.done; node_1_1 = node_1.next()) {
+                    var entry = node_1_1.value;
+                    var result = this.extractHyperlinkValue(entry);
+                    if (result)
+                        return result;
+                }
+            }
+            catch (e_21_1) { e_21 = { error: e_21_1 }; }
+            finally {
+                try {
+                    if (node_1_1 && !node_1_1.done && (_a = node_1.return)) _a.call(node_1);
+                }
+                finally { if (e_21) throw e_21.error; }
+            }
+            return undefined;
+        }
+        if (typeof node !== "object") {
+            return undefined;
+        }
+        if (node["text:a"]) {
+            var anchors = Array.isArray(node["text:a"])
+                ? node["text:a"]
+                : [node["text:a"]];
+            try {
+                for (var anchors_1 = __values(anchors), anchors_1_1 = anchors_1.next(); !anchors_1_1.done; anchors_1_1 = anchors_1.next()) {
+                    var anchor = anchors_1_1.value;
+                    var attrs = (anchor === null || anchor === void 0 ? void 0 : anchor[":@"]) || anchor;
+                    var href = (attrs === null || attrs === void 0 ? void 0 : attrs["@_xlink:href"]) || (attrs === null || attrs === void 0 ? void 0 : attrs["@_href"]);
+                    if (!href) {
+                        continue;
+                    }
+                    var display = this.extractTextContent(anchor);
+                    if (href.startsWith("#") ||
+                        href.startsWith("sheet://") ||
+                        href.startsWith("vnd.sun.star.sheet:")) {
+                        return __assign({ kind: "internal", location: this.normalizeInternalHyperlinkLocation(href) }, (display ? { display: display } : {}));
+                    }
+                    return __assign({ kind: "external", url: href }, (display ? { display: display } : {}));
+                }
+            }
+            catch (e_22_1) { e_22 = { error: e_22_1 }; }
+            finally {
+                try {
+                    if (anchors_1_1 && !anchors_1_1.done && (_b = anchors_1.return)) _b.call(anchors_1);
+                }
+                finally { if (e_22) throw e_22.error; }
+            }
+        }
+        try {
+            for (var _d = __values(Object.values(node)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var value = _e.value;
+                var result = this.extractHyperlinkValue(value);
+                if (result)
+                    return result;
+            }
+        }
+        catch (e_23_1) { e_23 = { error: e_23_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
+            }
+            finally { if (e_23) throw e_23.error; }
+        }
+        return undefined;
+    };
+    OdsPlugin.prototype.extractSpaceNodes = function (node, fallback) {
+        var _this = this;
+        var nodes = this.toArray(node);
+        if (!nodes.length) {
+            var fallbackAttrs = this.getAttributes(fallback);
+            if (!fallbackAttrs)
+                return " ";
+            var repeat = this.getSpaceRepeatCount(fallbackAttrs);
+            return " ".repeat(repeat);
+        }
+        return nodes
+            .map(function (entry) {
+            var attrs = _this.getAttributes(entry);
+            var repeat = _this.getSpaceRepeatCount(attrs);
+            return " ".repeat(repeat);
+        })
+            .join("");
+    };
+    OdsPlugin.prototype.getSpaceRepeatCount = function (attrs) {
+        if (!attrs)
+            return 1;
+        var rawCount = attrs["@_text:c"] || attrs["@_c"] || attrs["@_text:count"];
+        if (rawCount === undefined) {
+            return 1;
+        }
+        var count = parseInt(rawCount, 10);
+        if (isNaN(count) || count < 0) {
+            return 1;
+        }
+        return Math.max(1, count + 1);
+    };
+    OdsPlugin.prototype.extractEmbeddedObjects = function (sheetContexts, sheetNameMap) {
+        var e_24, _a, e_25, _b, e_26, _c;
+        var _d;
+        var tables = this.getOrderedTableWrappers();
+        if (!tables.length || !sheetContexts.length) {
+            return { drawings: [], charts: [] };
+        }
+        var drawings = [];
+        var charts = [];
+        var chartAnchors = new Set();
+        var imageCache = new Map();
+        var tableCount = Math.min(tables.length, sheetContexts.length);
+        for (var sheetIndex = 0; sheetIndex < tableCount; sheetIndex++) {
+            var tableWrapper = tables[sheetIndex];
+            var tableNameKey = tableWrapper["table:table"]
+                ? "table:table"
+                : "table";
+            var tableChildren = tableWrapper[tableNameKey];
+            if (!tableChildren)
+                continue;
+            var rows = tableChildren.filter(function (child) { return child["table:table-row"] || child["table-row"]; });
+            var currentRowIndex = 1;
+            var sheetContext = sheetContexts[sheetIndex];
+            var sheetId = (_d = sheetContext === null || sheetContext === void 0 ? void 0 : sheetContext.sheetId) !== null && _d !== void 0 ? _d : sheetIndex + 1;
+            try {
+                for (var rows_1 = (e_24 = void 0, __values(rows)), rows_1_1 = rows_1.next(); !rows_1_1.done; rows_1_1 = rows_1.next()) {
+                    var rowWrapper = rows_1_1.value;
+                    var rowNameKey = rowWrapper["table:table-row"]
+                        ? "table:table-row"
+                        : "table-row";
+                    var rowChildren = rowWrapper[rowNameKey];
+                    var rowAttrs = rowWrapper[":@"] || {};
+                    var rowsRepeated = parseInt(rowAttrs["@_table:number-rows-repeated"] ||
+                        rowAttrs["@_number-rows-repeated"] ||
+                        "1", 10);
+                    var effectiveRepeats = Math.min(rowsRepeated, 10000);
+                    for (var repeat = 0; repeat < effectiveRepeats; repeat++) {
+                        var columnIndex = 1;
+                        var normalizedRowChildren = rowChildren
+                            ? this.expandRowCells(rowChildren)
+                            : null;
+                        if (normalizedRowChildren) {
+                            try {
+                                for (var normalizedRowChildren_1 = (e_25 = void 0, __values(normalizedRowChildren)), normalizedRowChildren_1_1 = normalizedRowChildren_1.next(); !normalizedRowChildren_1_1.done; normalizedRowChildren_1_1 = normalizedRowChildren_1.next()) {
+                                    var cellWrapper = normalizedRowChildren_1_1.value;
+                                    var isCell = !!cellWrapper["table:table-cell"];
+                                    var isCovered = !!cellWrapper["table:covered-table-cell"];
+                                    if (!isCell && !isCovered)
+                                        continue;
+                                    var cellKey = isCell
+                                        ? "table:table-cell"
+                                        : "table:covered-table-cell";
+                                    var cellChildren = cellWrapper[cellKey];
+                                    var cellAttrs = cellWrapper[":@"] || {};
+                                    var colsRepeated = parseInt(cellAttrs["@_table:number-columns-repeated"] ||
+                                        cellAttrs["@_number-columns-repeated"] ||
+                                        "1", 10);
+                                    if (isCovered) {
+                                        columnIndex += colsRepeated;
+                                        continue;
+                                    }
+                                    var frameNodes = this.collectFrameNodes(cellChildren, cellAttrs);
+                                    if (frameNodes.length) {
+                                        for (var c = 0; c < colsRepeated; c++) {
+                                            var anchorColumnIndex = columnIndex + c;
+                                            try {
+                                                for (var frameNodes_1 = (e_26 = void 0, __values(frameNodes)), frameNodes_1_1 = frameNodes_1.next(); !frameNodes_1_1.done; frameNodes_1_1 = frameNodes_1.next()) {
+                                                    var _e = frameNodes_1_1.value, frame = _e.frame, frameCellAttrs = _e.cellAttrs;
+                                                    var chart = this.convertFrameToEmbeddedChart(frame, sheetContext, sheetId, currentRowIndex, anchorColumnIndex, sheetNameMap, frameCellAttrs);
+                                                    if (chart) {
+                                                        chartAnchors.add(this.buildAnchorKey(sheetId, currentRowIndex, anchorColumnIndex));
+                                                        charts.push(chart);
+                                                        continue;
+                                                    }
+                                                    var anchorKey = this.buildAnchorKey(sheetId, currentRowIndex, anchorColumnIndex);
+                                                    if (chartAnchors.has(anchorKey)) {
+                                                        continue;
+                                                    }
+                                                    var embedded = this.convertFrameToEmbeddedObject(frame, sheetId, currentRowIndex, anchorColumnIndex, imageCache, frameCellAttrs);
+                                                    if (embedded) {
+                                                        drawings.push(embedded);
+                                                    }
+                                                }
+                                            }
+                                            catch (e_26_1) { e_26 = { error: e_26_1 }; }
+                                            finally {
+                                                try {
+                                                    if (frameNodes_1_1 && !frameNodes_1_1.done && (_c = frameNodes_1.return)) _c.call(frameNodes_1);
+                                                }
+                                                finally { if (e_26) throw e_26.error; }
+                                            }
+                                        }
+                                    }
+                                    columnIndex += colsRepeated;
+                                }
+                            }
+                            catch (e_25_1) { e_25 = { error: e_25_1 }; }
+                            finally {
+                                try {
+                                    if (normalizedRowChildren_1_1 && !normalizedRowChildren_1_1.done && (_b = normalizedRowChildren_1.return)) _b.call(normalizedRowChildren_1);
+                                }
+                                finally { if (e_25) throw e_25.error; }
+                            }
+                        }
+                        currentRowIndex++;
+                    }
+                }
+            }
+            catch (e_24_1) { e_24 = { error: e_24_1 }; }
+            finally {
+                try {
+                    if (rows_1_1 && !rows_1_1.done && (_a = rows_1.return)) _a.call(rows_1);
+                }
+                finally { if (e_24) throw e_24.error; }
+            }
+        }
+        return { drawings: drawings, charts: charts };
+    };
+    OdsPlugin.prototype.buildAnchorKey = function (sheetId, rowIndex, columnIndex) {
+        return "".concat(sheetId, ":").concat(rowIndex, ":").concat(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`.
+     */
+    OdsPlugin.prototype.extractOutlineGroups = function (sheets) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!this.contentXmlOrdered || !sheets.length)
+            return;
+        var docContent = ((_a = this.contentXmlOrdered[0]) === null || _a === void 0 ? void 0 : _a["office:document-content"]) ||
+            ((_b = this.contentXmlOrdered[0]) === null || _b === void 0 ? void 0 : _b["document-content"]);
+        if (!docContent)
+            return;
+        var body = getChildren(docContent, "office:body") || getChildren(docContent, "body");
+        if (!body)
+            return;
+        var spreadsheet = getChildren(body, "office:spreadsheet") ||
+            getChildren(body, "spreadsheet");
+        if (!spreadsheet)
+            return;
+        var tables = spreadsheet.filter(function (child) { return child["table:table"] || child["table"]; });
+        var tableCount = Math.min(tables.length, sheets.length);
+        var _loop_1 = function (sheetIndex) {
+            var tableWrapper = tables[sheetIndex];
+            var tableNameKey = tableWrapper["table:table"]
+                ? "table:table"
+                : "table";
+            var tableChildren = tableWrapper[tableNameKey];
+            if (!Array.isArray(tableChildren))
+                return "continue";
+            var sheet = sheets[sheetIndex];
+            if (!sheet)
+                return "continue";
+            var summaryBelow = ((_c = sheet.outlinePr) === null || _c === void 0 ? void 0 : _c.summaryBelow) !== false;
+            var summaryRight = ((_d = sheet.outlinePr) === null || _d === void 0 ? void 0 : _d.summaryRight) !== false;
+            var rowMetadata = ((_e = sheet.rowMetadata) !== null && _e !== void 0 ? _e : []);
+            var columnMetadata = ((_f = sheet.columnMetadata) !== null && _f !== void 0 ? _f : []);
+            var setMeta = function (meta, index, patch) {
+                if (!meta[index])
+                    meta[index] = {};
+                Object.assign(meta[index], patch);
+            };
+            var walk = function (nodes, itemTag, groupTag, meta, repeatAttrs, summaryAfter) {
+                var cursor = 1;
+                var openStack = [];
+                var collapsedDepth = function () { return openStack.some(function (g) { return g.collapsed; }); };
+                var currentLevel = function () { return openStack.length; };
+                var visit = function (children) {
+                    var e_27, _a, e_28, _b;
+                    var _c;
+                    try {
+                        for (var children_1 = (e_27 = void 0, __values(children)), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
+                            var child = children_1_1.value;
+                            if (!child)
+                                continue;
+                            if (child[groupTag]) {
+                                var attrs = child[":@"] || {};
+                                var display = (_c = attrs["@_table:display"]) !== null && _c !== void 0 ? _c : attrs["@_display"];
+                                var collapsed = display === "false" || display === false;
+                                var startIndex = cursor;
+                                openStack.push({
+                                    level: openStack.length + 1,
+                                    startIndex: startIndex,
+                                    collapsed: collapsed,
+                                });
+                                visit(child[groupTag] || []);
+                                var closing = openStack.pop();
+                                if (closing.collapsed) {
+                                    var summaryIndex = summaryAfter
+                                        ? cursor
+                                        : closing.startIndex - 1;
+                                    if (summaryIndex >= 1) {
+                                        setMeta(meta, summaryIndex, { collapsed: true });
+                                    }
+                                }
+                            }
+                            else if (child[itemTag]) {
+                                var attrs = child[":@"] || {};
+                                var repeat = 1;
+                                try {
+                                    for (var repeatAttrs_1 = (e_28 = void 0, __values(repeatAttrs)), repeatAttrs_1_1 = repeatAttrs_1.next(); !repeatAttrs_1_1.done; repeatAttrs_1_1 = repeatAttrs_1.next()) {
+                                        var attrName = repeatAttrs_1_1.value;
+                                        var raw = attrs["@_".concat(attrName)];
+                                        if (raw !== undefined) {
+                                            repeat = Math.max(1, parseInt(String(raw), 10) || 1);
+                                            break;
+                                        }
+                                    }
+                                }
+                                catch (e_28_1) { e_28 = { error: e_28_1 }; }
+                                finally {
+                                    try {
+                                        if (repeatAttrs_1_1 && !repeatAttrs_1_1.done && (_b = repeatAttrs_1.return)) _b.call(repeatAttrs_1);
+                                    }
+                                    finally { if (e_28) throw e_28.error; }
+                                }
+                                repeat = Math.min(repeat, 10000);
+                                var level = currentLevel();
+                                var hidden = collapsedDepth();
+                                if (level > 0 || hidden) {
+                                    for (var r = 0; r < repeat; r++) {
+                                        var patch = {};
+                                        if (level > 0)
+                                            patch.outlineLevel = level;
+                                        if (hidden)
+                                            patch.hiddenByGroup = true;
+                                        setMeta(meta, cursor + r, patch);
+                                    }
+                                }
+                                cursor += repeat;
+                            }
+                        }
+                    }
+                    catch (e_27_1) { e_27 = { error: e_27_1 }; }
+                    finally {
+                        try {
+                            if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+                        }
+                        finally { if (e_27) throw e_27.error; }
+                    }
+                };
+                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;
+        };
+        for (var sheetIndex = 0; sheetIndex < tableCount; sheetIndex++) {
+            _loop_1(sheetIndex);
+        }
+    };
+    OdsPlugin.prototype.extractMerges = function (sheetContexts) {
+        var e_29, _a, e_30, _b;
+        var _c, _d, _e, _f;
+        var merges = new Map();
+        if (!this.contentXmlOrdered || !sheetContexts.length) {
+            return merges;
+        }
+        var docContent = ((_c = this.contentXmlOrdered[0]) === null || _c === void 0 ? void 0 : _c["office:document-content"]) ||
+            ((_d = this.contentXmlOrdered[0]) === null || _d === void 0 ? void 0 : _d["document-content"]);
+        if (!docContent)
+            return merges;
+        var body = getChildren(docContent, "office:body") || getChildren(docContent, "body");
+        if (!body)
+            return merges;
+        var spreadsheet = getChildren(body, "office:spreadsheet") ||
+            getChildren(body, "spreadsheet");
+        if (!spreadsheet)
+            return merges;
+        var tables = spreadsheet.filter(function (child) { return child["table:table"] || child["table"]; });
+        var tableCount = Math.min(tables.length, sheetContexts.length);
+        var seen = new Set();
+        for (var sheetIndex = 0; sheetIndex < tableCount; sheetIndex++) {
+            var tableWrapper = tables[sheetIndex];
+            var tableNameKey = tableWrapper["table:table"]
+                ? "table:table"
+                : "table";
+            var tableChildren = tableWrapper[tableNameKey];
+            if (!tableChildren)
+                continue;
+            var rows = tableChildren.filter(function (child) { return child["table:table-row"] || child["table-row"]; });
+            var sheetId = (_f = (_e = sheetContexts[sheetIndex]) === null || _e === void 0 ? void 0 : _e.sheetId) !== null && _f !== void 0 ? _f : sheetIndex + 1;
+            var currentRowIndex = 1;
+            try {
+                for (var rows_2 = (e_29 = void 0, __values(rows)), rows_2_1 = rows_2.next(); !rows_2_1.done; rows_2_1 = rows_2.next()) {
+                    var rowWrapper = rows_2_1.value;
+                    var rowNameKey = rowWrapper["table:table-row"]
+                        ? "table:table-row"
+                        : "table-row";
+                    var rowChildren = rowWrapper[rowNameKey];
+                    var rowAttrs = rowWrapper[":@"] || {};
+                    var rowsRepeated = parseInt(rowAttrs["@_table:number-rows-repeated"] ||
+                        rowAttrs["@_number-rows-repeated"] ||
+                        "1", 10);
+                    var effectiveRepeats = Math.min(rowsRepeated, 10000);
+                    for (var repeat = 0; repeat < effectiveRepeats; repeat++) {
+                        var columnIndex = 1;
+                        if (rowChildren) {
+                            try {
+                                for (var rowChildren_1 = (e_30 = void 0, __values(rowChildren)), rowChildren_1_1 = rowChildren_1.next(); !rowChildren_1_1.done; rowChildren_1_1 = rowChildren_1.next()) {
+                                    var cellWrapper = rowChildren_1_1.value;
+                                    var isCell = !!cellWrapper["table:table-cell"];
+                                    var isCovered = !!cellWrapper["table:covered-table-cell"];
+                                    if (!isCell && !isCovered)
+                                        continue;
+                                    var cellKey = isCell
+                                        ? "table:table-cell"
+                                        : "table:covered-table-cell";
+                                    var cellAttrs = cellWrapper[":@"] || {};
+                                    var colsRepeated = parseInt(cellAttrs["@_table:number-columns-repeated"] ||
+                                        cellAttrs["@_number-columns-repeated"] ||
+                                        "1", 10);
+                                    if (isCovered) {
+                                        columnIndex += colsRepeated;
+                                        continue;
+                                    }
+                                    var rowsSpannedRaw = parseInt(cellAttrs["@_table:number-rows-spanned"] ||
+                                        cellAttrs["@_number-rows-spanned"] ||
+                                        "1", 10);
+                                    var colsSpannedRaw = parseInt(cellAttrs["@_table:number-columns-spanned"] ||
+                                        cellAttrs["@_number-columns-spanned"] ||
+                                        "1", 10);
+                                    var rowsSpanned = Math.max(1, rowsSpannedRaw || 1);
+                                    var colsSpanned = Math.max(1, colsSpannedRaw || 1);
+                                    if (rowsSpanned > 1 || colsSpanned > 1) {
+                                        for (var colOffset = 0; colOffset < colsRepeated; colOffset++) {
+                                            var startColumnIndex = columnIndex + colOffset;
+                                            var range = {
+                                                sheetId: sheetId,
+                                                startRowIndex: currentRowIndex,
+                                                endRowIndex: currentRowIndex + rowsSpanned - 1,
+                                                startColumnIndex: startColumnIndex,
+                                                endColumnIndex: startColumnIndex + colsSpanned - 1,
+                                            };
+                                            var key = "".concat(range.sheetId, ":").concat(range.startRowIndex, ":").concat(range.endRowIndex, ":").concat(range.startColumnIndex, ":").concat(range.endColumnIndex);
+                                            if (!seen.has(key)) {
+                                                seen.add(key);
+                                                if (!merges.has(sheetId)) {
+                                                    merges.set(sheetId, []);
+                                                }
+                                                merges.get(sheetId).push(range);
+                                            }
+                                        }
+                                    }
+                                    columnIndex += colsRepeated;
+                                }
+                            }
+                            catch (e_30_1) { e_30 = { error: e_30_1 }; }
+                            finally {
+                                try {
+                                    if (rowChildren_1_1 && !rowChildren_1_1.done && (_b = rowChildren_1.return)) _b.call(rowChildren_1);
+                                }
+                                finally { if (e_30) throw e_30.error; }
+                            }
+                        }
+                        currentRowIndex++;
+                    }
+                }
+            }
+            catch (e_29_1) { e_29 = { error: e_29_1 }; }
+            finally {
+                try {
+                    if (rows_2_1 && !rows_2_1.done && (_a = rows_2.return)) _a.call(rows_2);
+                }
+                finally { if (e_29) throw e_29.error; }
+            }
+        }
+        return merges;
+    };
+    OdsPlugin.prototype.getOrderedTableWrappers = function () {
+        var _a, _b;
+        if (!this.contentXmlOrdered)
+            return [];
+        var docContent = ((_a = this.contentXmlOrdered[0]) === null || _a === void 0 ? void 0 : _a["office:document-content"]) ||
+            ((_b = this.contentXmlOrdered[0]) === null || _b === void 0 ? void 0 : _b["document-content"]);
+        if (!docContent)
+            return [];
+        var body = getChildren(docContent, "office:body") || getChildren(docContent, "body");
+        if (!body)
+            return [];
+        var spreadsheet = getChildren(body, "office:spreadsheet") ||
+            getChildren(body, "spreadsheet");
+        if (!spreadsheet)
+            return [];
+        return spreadsheet.filter(function (child) { return child["table:table"] || child["table"]; });
+    };
+    OdsPlugin.prototype.findOrderedTableWrapperForContext = function (sheetContext, sheetId) {
+        var e_31, _a;
+        var tables = this.getOrderedTableWrappers();
+        if (!tables.length)
+            return undefined;
+        if (sheetContext === null || sheetContext === void 0 ? void 0 : sheetContext.name) {
+            var normalizedTarget = this.normalizeSheetName(sheetContext.name);
+            try {
+                for (var tables_1 = __values(tables), tables_1_1 = tables_1.next(); !tables_1_1.done; tables_1_1 = tables_1.next()) {
+                    var tableWrapper = tables_1_1.value;
+                    var attrs = tableWrapper[":@"] || {};
+                    var rawName = attrs["@_table:name"] ||
+                        attrs["@_name"] ||
+                        attrs["@_table:display-name"];
+                    var normalizedCandidate = this.normalizeSheetName(rawName);
+                    if ((rawName && rawName === sheetContext.name) ||
+                        (normalizedCandidate &&
+                            normalizedTarget &&
+                            normalizedCandidate === normalizedTarget)) {
+                        return tableWrapper;
+                    }
+                }
+            }
+            catch (e_31_1) { e_31 = { error: e_31_1 }; }
+            finally {
+                try {
+                    if (tables_1_1 && !tables_1_1.done && (_a = tables_1.return)) _a.call(tables_1);
+                }
+                finally { if (e_31) throw e_31.error; }
+            }
+        }
+        if (sheetId && tables[sheetId - 1]) {
+            return tables[sheetId - 1];
+        }
+        return tables[0];
+    };
+    OdsPlugin.prototype.extractTableColumnsFromHeader = function (range, sheetContext, useHeaderRow) {
+        var e_32, _a, e_33, _b;
+        var _c, _d, _e;
+        if (useHeaderRow === void 0) { useHeaderRow = true; }
+        var startColumn = Math.max(1, (_c = range.startColumnIndex) !== null && _c !== void 0 ? _c : 1);
+        var endColumn = Math.max(startColumn, (_d = range.endColumnIndex) !== null && _d !== void 0 ? _d : startColumn);
+        var columnCount = Math.max(1, endColumn - startColumn + 1);
+        var buildDefaultColumns = function () {
+            return Array.from({ length: columnCount }, function (_, index) { return ({
+                name: "Column ".concat(index + 1),
+            }); });
+        };
+        if (!useHeaderRow) {
+            return buildDefaultColumns();
+        }
+        var tableWrapper = this.findOrderedTableWrapperForContext(sheetContext, range.sheetId);
+        if (!tableWrapper) {
+            return buildDefaultColumns();
+        }
+        var tableNameKey = tableWrapper["table:table"] ? "table:table" : "table";
+        var tableChildren = tableWrapper[tableNameKey];
+        if (!tableChildren) {
+            return buildDefaultColumns();
+        }
+        var rows = tableChildren.filter(function (child) { return child["table:table-row"] || child["table-row"]; });
+        if (!rows.length) {
+            return buildDefaultColumns();
+        }
+        var headerRowIndex = Math.max(1, (_e = range.startRowIndex) !== null && _e !== void 0 ? _e : 1);
+        var headerValues = [];
+        var currentRowIndex = 1;
+        try {
+            outer: for (var rows_3 = __values(rows), rows_3_1 = rows_3.next(); !rows_3_1.done; rows_3_1 = rows_3.next()) {
+                var rowWrapper = rows_3_1.value;
+                var rowNameKey = rowWrapper["table:table-row"]
+                    ? "table:table-row"
+                    : "table-row";
+                var rowChildren = rowWrapper[rowNameKey];
+                var rowAttrs = rowWrapper[":@"] || {};
+                var rowsRepeated = parseInt(rowAttrs["@_table:number-rows-repeated"] ||
+                    rowAttrs["@_number-rows-repeated"] ||
+                    "1", 10);
+                var effectiveRepeats = Math.min(rowsRepeated, 10000);
+                var normalizedRowChildren = rowChildren
+                    ? this.expandRowCells(rowChildren)
+                    : null;
+                for (var repeat = 0; repeat < effectiveRepeats; repeat++) {
+                    if (currentRowIndex === headerRowIndex) {
+                        var columnIndex = 1;
+                        if (normalizedRowChildren) {
+                            try {
+                                for (var normalizedRowChildren_2 = (e_33 = void 0, __values(normalizedRowChildren)), normalizedRowChildren_2_1 = normalizedRowChildren_2.next(); !normalizedRowChildren_2_1.done; normalizedRowChildren_2_1 = normalizedRowChildren_2.next()) {
+                                    var cellWrapper = normalizedRowChildren_2_1.value;
+                                    var isCell = !!cellWrapper["table:table-cell"];
+                                    var isCovered = !!cellWrapper["table:covered-table-cell"];
+                                    if (!isCell && !isCovered) {
+                                        continue;
+                                    }
+                                    var cellNameKey = isCell
+                                        ? "table:table-cell"
+                                        : "table:covered-table-cell";
+                                    var cellChildren = cellWrapper[cellNameKey];
+                                    var cellAttrs = cellWrapper[":@"] || {};
+                                    var colsRepeated = parseInt(cellAttrs["@_table:number-columns-repeated"] ||
+                                        cellAttrs["@_number-columns-repeated"] ||
+                                        "1", 10);
+                                    if (isCovered) {
+                                        columnIndex += colsRepeated;
+                                        continue;
+                                    }
+                                    var displayValue = "";
+                                    if (cellChildren) {
+                                        var textWrapper = findChild(cellChildren, "text:p") ||
+                                            findChild(cellChildren, "p");
+                                        if (textWrapper) {
+                                            var key = textWrapper["text:p"] ? "text:p" : "p";
+                                            displayValue = this.extractTextContent(textWrapper[key]);
+                                        }
+                                        else {
+                                            displayValue = this.extractTextContent(cellChildren);
+                                        }
+                                    }
+                                    for (var c = 0; c < colsRepeated; c++) {
+                                        var targetColumnIndex = columnIndex;
+                                        if (targetColumnIndex >= startColumn &&
+                                            targetColumnIndex <= endColumn) {
+                                            var relativeIndex = headerValues.length;
+                                            var fallbackName = "Column ".concat(relativeIndex + 1);
+                                            var trimmed = displayValue === null || displayValue === void 0 ? void 0 : displayValue.trim();
+                                            headerValues.push(trimmed && trimmed.length ? trimmed : fallbackName);
+                                            if (headerValues.length >= columnCount) {
+                                                break;
+                                            }
+                                        }
+                                        columnIndex++;
+                                    }
+                                    if (headerValues.length >= columnCount) {
+                                        break;
+                                    }
+                                }
+                            }
+                            catch (e_33_1) { e_33 = { error: e_33_1 }; }
+                            finally {
+                                try {
+                                    if (normalizedRowChildren_2_1 && !normalizedRowChildren_2_1.done && (_b = normalizedRowChildren_2.return)) _b.call(normalizedRowChildren_2);
+                                }
+                                finally { if (e_33) throw e_33.error; }
+                            }
+                        }
+                        break outer;
+                    }
+                    currentRowIndex++;
+                }
+                if (currentRowIndex > headerRowIndex) {
+                    break;
+                }
+            }
+        }
+        catch (e_32_1) { e_32 = { error: e_32_1 }; }
+        finally {
+            try {
+                if (rows_3_1 && !rows_3_1.done && (_a = rows_3.return)) _a.call(rows_3);
+            }
+            finally { if (e_32) throw e_32.error; }
+        }
+        if (!headerValues.length) {
+            return buildDefaultColumns();
+        }
+        var columns = [];
+        for (var i = 0; i < columnCount; i++) {
+            var label = headerValues[i];
+            columns.push({
+                name: label && label.trim().length ? label : "Column ".concat(i + 1),
+            });
+        }
+        return columns;
+    };
+    OdsPlugin.prototype.collectFrameNodes = function (cellChildren, cellAttrs) {
+        var e_34, _a, e_35, _b;
+        if (!cellChildren)
+            return [];
+        var children = Array.isArray(cellChildren)
+            ? cellChildren
+            : [cellChildren];
+        var frames = [];
+        try {
+            for (var children_2 = __values(children), children_2_1 = children_2.next(); !children_2_1.done; children_2_1 = children_2.next()) {
+                var child = children_2_1.value;
+                if (!child || typeof child !== "object")
+                    continue;
+                var frameNode = child["draw:frame"] || child["frame"];
+                if (!frameNode)
+                    continue;
+                if (Array.isArray(frameNode)) {
+                    try {
+                        for (var frameNode_1 = (e_35 = void 0, __values(frameNode)), frameNode_1_1 = frameNode_1.next(); !frameNode_1_1.done; frameNode_1_1 = frameNode_1.next()) {
+                            var node = frameNode_1_1.value;
+                            frames.push({ frame: node, cellAttrs: child[":@"] || cellAttrs });
+                        }
+                    }
+                    catch (e_35_1) { e_35 = { error: e_35_1 }; }
+                    finally {
+                        try {
+                            if (frameNode_1_1 && !frameNode_1_1.done && (_b = frameNode_1.return)) _b.call(frameNode_1);
+                        }
+                        finally { if (e_35) throw e_35.error; }
+                    }
+                }
+                else {
+                    frames.push({ frame: frameNode, cellAttrs: child[":@"] || cellAttrs });
+                }
+            }
+        }
+        catch (e_34_1) { e_34 = { error: e_34_1 }; }
+        finally {
+            try {
+                if (children_2_1 && !children_2_1.done && (_a = children_2.return)) _a.call(children_2);
+            }
+            finally { if (e_34) throw e_34.error; }
+        }
+        return frames;
+    };
+    OdsPlugin.prototype.extractSheetSettings = function (sheetContexts) {
+        var e_36, _a, e_37, _b;
+        var _this = this;
+        var map = new Map();
+        if (!this.settingsXml || !sheetContexts.length) {
+            return map;
+        }
+        var documentSettings = get(this.settingsXml, "office:document-settings") ||
+            get(this.settingsXml, "document-settings");
+        if (!documentSettings)
+            return map;
+        var settingsNode = get(documentSettings, "office:settings") ||
+            get(documentSettings, "settings");
+        if (!settingsNode)
+            return map;
+        var nameMap = new Map();
+        var traverse = function (node) {
+            var e_38, _a, e_39, _b;
+            if (!node || typeof node !== "object")
+                return;
+            var entries = _this.toArray(node["config:config-item-map-entry"] || node["config-item-map-entry"]);
+            try {
+                for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+                    var entry = entries_1_1.value;
+                    var attrs = _this.getAttributes(entry);
+                    var entryName = (attrs === null || attrs === void 0 ? void 0 : attrs["@_config:name"]) ||
+                        (attrs === null || attrs === void 0 ? void 0 : attrs["@_name"]) ||
+                        (attrs === null || attrs === void 0 ? void 0 : attrs["@_table:name"]);
+                    if (entryName) {
+                        var parsed = _this.parseConfigItemEntry(entry);
+                        if (parsed) {
+                            var existing = nameMap.get(entryName) || {};
+                            var combined = __assign(__assign({}, existing), parsed);
+                            nameMap.set(entryName, combined);
+                            var normalized = _this.normalizeSheetName(entryName);
+                            if (normalized) {
+                                nameMap.set(normalized, combined);
+                                nameMap.set("'".concat(normalized, "'"), combined);
+                            }
+                        }
+                    }
+                    traverse(entry);
+                }
+            }
+            catch (e_38_1) { e_38 = { error: e_38_1 }; }
+            finally {
+                try {
+                    if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+                }
+                finally { if (e_38) throw e_38.error; }
+            }
+            var namedMaps = _this.toArray(node["config:config-item-map-named"] || node["config-item-map-named"]);
+            try {
+                for (var namedMaps_1 = __values(namedMaps), namedMaps_1_1 = namedMaps_1.next(); !namedMaps_1_1.done; namedMaps_1_1 = namedMaps_1.next()) {
+                    var named = namedMaps_1_1.value;
+                    traverse(named);
+                }
+            }
+            catch (e_39_1) { e_39 = { error: e_39_1 }; }
+            finally {
+                try {
+                    if (namedMaps_1_1 && !namedMaps_1_1.done && (_b = namedMaps_1.return)) _b.call(namedMaps_1);
+                }
+                finally { if (e_39) throw e_39.error; }
+            }
+        };
+        var itemSets = this.toArray(get(settingsNode, "config:config-item-set") ||
+            get(settingsNode, "config-item-set"));
+        try {
+            for (var itemSets_1 = __values(itemSets), itemSets_1_1 = itemSets_1.next(); !itemSets_1_1.done; itemSets_1_1 = itemSets_1.next()) {
+                var set = itemSets_1_1.value;
+                traverse(set);
+            }
+        }
+        catch (e_36_1) { e_36 = { error: e_36_1 }; }
+        finally {
+            try {
+                if (itemSets_1_1 && !itemSets_1_1.done && (_a = itemSets_1.return)) _a.call(itemSets_1);
+            }
+            finally { if (e_36) throw e_36.error; }
+        }
+        try {
+            for (var sheetContexts_4 = __values(sheetContexts), sheetContexts_4_1 = sheetContexts_4.next(); !sheetContexts_4_1.done; sheetContexts_4_1 = sheetContexts_4.next()) {
+                var context = sheetContexts_4_1.value;
+                var normalized = this.normalizeSheetName(context.name);
+                var settings = nameMap.get(context.name) ||
+                    (normalized ? nameMap.get(normalized) : undefined);
+                if (settings) {
+                    map.set(context.sheetId, settings);
+                }
+            }
+        }
+        catch (e_37_1) { e_37 = { error: e_37_1 }; }
+        finally {
+            try {
+                if (sheetContexts_4_1 && !sheetContexts_4_1.done && (_b = sheetContexts_4.return)) _b.call(sheetContexts_4);
+            }
+            finally { if (e_37) throw e_37.error; }
+        }
+        return map;
+    };
+    OdsPlugin.prototype.parseConfigItemEntry = function (entry) {
+        var e_40, _a;
+        var configItems = this.toArray(get(entry, "config:config-item") || get(entry, "config-item"));
+        if (!configItems.length)
+            return undefined;
+        var settings = {};
+        try {
+            for (var configItems_1 = __values(configItems), configItems_1_1 = configItems_1.next(); !configItems_1_1.done; configItems_1_1 = configItems_1.next()) {
+                var item = configItems_1_1.value;
+                var attrs = this.getAttributes(item);
+                if (!attrs)
+                    continue;
+                var name_3 = attrs["@_config:name"] || attrs["@_name"];
+                if (!name_3)
+                    continue;
+                var value = this.getNodeText(item);
+                if (value === undefined)
+                    continue;
+                var normalized = value.trim();
+                if (!normalized.length)
+                    continue;
+                if (name_3 === "ShowGrid" || name_3 === "ShowGridLines") {
+                    var parsed = this.parseBooleanAttribute(normalized);
+                    if (parsed !== undefined) {
+                        settings.showGridLines = parsed;
+                    }
+                    continue;
+                }
+                if (name_3 === "FreezeCell") {
+                    var freeze = this.parseFreezeCoordinates(normalized);
+                    if (freeze) {
+                        Object.assign(settings, freeze);
+                    }
+                    continue;
+                }
+                if (name_3 === "VerticalSplitPosition") {
+                    var parsed = this.parseIntegerValue(normalized);
+                    if (parsed !== undefined) {
+                        settings.frozenRowCount = parsed;
+                    }
+                    continue;
+                }
+                if (name_3 === "HorizontalSplitPosition") {
+                    var parsed = this.parseIntegerValue(normalized);
+                    if (parsed !== undefined) {
+                        settings.frozenColumnCount = parsed;
+                    }
+                    continue;
+                }
+                if (name_3 === "TabColor") {
+                    var color = this.normalizeOdsColor(normalized);
+                    if (color) {
+                        settings.tabColor = color;
+                    }
+                }
+            }
+        }
+        catch (e_40_1) { e_40 = { error: e_40_1 }; }
+        finally {
+            try {
+                if (configItems_1_1 && !configItems_1_1.done && (_a = configItems_1.return)) _a.call(configItems_1);
+            }
+            finally { if (e_40) throw e_40.error; }
+        }
+        return Object.keys(settings).length ? settings : undefined;
+    };
+    OdsPlugin.prototype.parseFreezeCoordinates = function (value) {
+        var normalized = value.replace(/\$/g, "").trim();
+        if (!normalized)
+            return undefined;
+        var cell = addressToCell(normalized.toUpperCase());
+        if (!cell)
+            return undefined;
+        return {
+            frozenRowCount: Math.max(0, cell.rowIndex - 1),
+            frozenColumnCount: Math.max(0, cell.columnIndex - 1),
+        };
+    };
+    OdsPlugin.prototype.convertFrameToEmbeddedObject = function (frameNode, sheetId, rowIndex, columnIndex, imageCache, cellAttrs) {
+        var frameAttrs = this.getAttributes(frameNode);
+        var imageNode = this.findFrameImageNode(frameNode);
+        var imageAttrs = this.getAttributes(imageNode);
+        var imagePath = this.normalizeImagePath((imageAttrs === null || imageAttrs === void 0 ? void 0 : imageAttrs["@_xlink:href"]) ||
+            (imageAttrs === null || imageAttrs === void 0 ? void 0 : imageAttrs["@_href"]) ||
+            (frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_xlink:href"]) ||
+            (frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_href"]));
+        if (!imagePath)
+            return undefined;
+        var imageUrl = this.getImageDataUrl(imagePath, imageCache);
+        if (!imageUrl)
+            return undefined;
+        var _a = this.buildOverlayPlacement(frameAttrs, cellAttrs, rowIndex, columnIndex), overlayPosition = _a.overlayPosition, isInsideCell = _a.isInsideCell;
+        var description = (frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_draw:name"]) || (cellAttrs === null || cellAttrs === void 0 ? void 0 : cellAttrs["@_draw:name"]) || undefined;
+        return {
+            embedId: uuid(),
+            spec: {
+                type: "image",
+                imageUrl: imageUrl,
+                description: description,
+            },
+            position: {
+                sheetId: sheetId,
+                overlayPosition: overlayPosition,
+            },
+            draggable: true,
+            lockAspectRatio: true,
+            isInsideCell: isInsideCell,
+        };
+    };
+    OdsPlugin.prototype.convertFrameToEmbeddedChart = function (frameNode, sheetContext, sheetId, rowIndex, columnIndex, sheetNameMap, cellAttrs) {
+        var frameAttrs = this.getAttributes(frameNode);
+        var inlineChart = this.findInlineChartNode(frameNode);
+        var chartNode = inlineChart;
+        if (!chartNode) {
+            var objectNode = this.findFrameObjectNode(frameNode);
+            var chartFromObject = this.loadChartNodeFromObject(objectNode, frameAttrs);
+            chartNode = chartFromObject;
+        }
+        if (!chartNode)
+            return undefined;
+        var spec = this.convertChartNodeToSpec(chartNode, sheetNameMap, sheetContext);
+        if (!spec)
+            return undefined;
+        var overlayPosition = this.buildOverlayPlacement(frameAttrs, cellAttrs, rowIndex, columnIndex).overlayPosition;
+        var chartId = uuid();
+        return {
+            chartId: chartId,
+            spec: spec,
+            position: {
+                sheetId: sheetId,
+                overlayPosition: overlayPosition,
+            },
+            draggable: true,
+            resizable: true,
+        };
+    };
+    OdsPlugin.prototype.findInlineChartNode = function (frameNode) {
+        var e_41, _a;
+        if (!frameNode)
+            return undefined;
+        if (Array.isArray(frameNode)) {
+            try {
+                for (var frameNode_2 = __values(frameNode), frameNode_2_1 = frameNode_2.next(); !frameNode_2_1.done; frameNode_2_1 = frameNode_2.next()) {
+                    var entry = frameNode_2_1.value;
+                    var found = this.findInlineChartNode(entry);
+                    if (found)
+                        return found;
+                }
+            }
+            catch (e_41_1) { e_41 = { error: e_41_1 }; }
+            finally {
+                try {
+                    if (frameNode_2_1 && !frameNode_2_1.done && (_a = frameNode_2.return)) _a.call(frameNode_2);
+                }
+                finally { if (e_41) throw e_41.error; }
+            }
+            return undefined;
+        }
+        var chartNode = frameNode["chart:chart"] || frameNode["chart"];
+        if (chartNode) {
+            return Array.isArray(chartNode) ? chartNode[0] : chartNode;
+        }
+        return undefined;
+    };
+    OdsPlugin.prototype.findFrameObjectNode = function (frameNode) {
+        var e_42, _a;
+        if (!frameNode)
+            return undefined;
+        if (Array.isArray(frameNode)) {
+            try {
+                for (var frameNode_3 = __values(frameNode), frameNode_3_1 = frameNode_3.next(); !frameNode_3_1.done; frameNode_3_1 = frameNode_3.next()) {
+                    var entry = frameNode_3_1.value;
+                    var found = this.findFrameObjectNode(entry);
+                    if (found)
+                        return found;
+                }
+            }
+            catch (e_42_1) { e_42 = { error: e_42_1 }; }
+            finally {
+                try {
+                    if (frameNode_3_1 && !frameNode_3_1.done && (_a = frameNode_3.return)) _a.call(frameNode_3);
+                }
+                finally { if (e_42) throw e_42.error; }
+            }
+            return undefined;
+        }
+        var objectNode = frameNode["draw:object"] || frameNode["object"];
+        if (objectNode) {
+            return Array.isArray(objectNode) ? objectNode[0] : objectNode;
+        }
+        return undefined;
+    };
+    OdsPlugin.prototype.findFrameImageNode = function (frameNode) {
+        var e_43, _a;
+        if (!frameNode)
+            return undefined;
+        if (Array.isArray(frameNode)) {
+            try {
+                for (var frameNode_4 = __values(frameNode), frameNode_4_1 = frameNode_4.next(); !frameNode_4_1.done; frameNode_4_1 = frameNode_4.next()) {
+                    var entry = frameNode_4_1.value;
+                    var found = this.findFrameImageNode(entry);
+                    if (found)
+                        return found;
+                }
+            }
+            catch (e_43_1) { e_43 = { error: e_43_1 }; }
+            finally {
+                try {
+                    if (frameNode_4_1 && !frameNode_4_1.done && (_a = frameNode_4.return)) _a.call(frameNode_4);
+                }
+                finally { if (e_43) throw e_43.error; }
+            }
+            return undefined;
+        }
+        var direct = frameNode["draw:image"] || frameNode["image"] || frameNode["draw:object"];
+        if (direct) {
+            return Array.isArray(direct) ? direct[0] : direct;
+        }
+        return undefined;
+    };
+    OdsPlugin.prototype.loadChartNodeFromObject = function (objectNode, frameAttrs) {
+        if (!objectNode)
+            return undefined;
+        var objectAttrs = this.getAttributes(objectNode);
+        var href = (objectAttrs === null || objectAttrs === void 0 ? void 0 : objectAttrs["@_xlink:href"]) ||
+            (objectAttrs === null || objectAttrs === void 0 ? void 0 : objectAttrs["@_href"]) ||
+            (frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_xlink:href"]) ||
+            (frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_href"]);
+        return this.loadChartNodeFromHref(href);
+    };
+    OdsPlugin.prototype.loadChartNodeFromHref = function (href) {
+        var path = this.resolveObjectPath(href);
+        if (!path)
+            return undefined;
+        try {
+            var content = this.zipParser.Get(path);
+            var chartDoc = this.xmlParser.parse(content);
+            this.odsStyles.parseContentXml(chartDoc);
+            return this.findChartNodeInDocument(chartDoc);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
+    OdsPlugin.prototype.resolveObjectPath = function (href) {
+        var e_44, _a;
+        if (!href)
+            return undefined;
+        var 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;
+        var candidates = new Set();
+        if (normalized.endsWith(".xml")) {
+            candidates.add(normalized);
+            candidates.add("ObjectReplacements/".concat(normalized));
+        }
+        else {
+            candidates.add("".concat(normalized, "/content.xml"));
+            candidates.add("".concat(normalized, "/Content.xml"));
+            candidates.add("".concat(normalized, ".xml"));
+            candidates.add("ObjectReplacements/".concat(normalized, "/content.xml"));
+            candidates.add("ObjectReplacements/".concat(normalized, "/Content.xml"));
+        }
+        try {
+            for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+                var candidate = candidates_1_1.value;
+                if (!candidate)
+                    continue;
+                if (this.zipParser.Has(candidate)) {
+                    return candidate;
+                }
+            }
+        }
+        catch (e_44_1) { e_44 = { error: e_44_1 }; }
+        finally {
+            try {
+                if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+            }
+            finally { if (e_44) throw e_44.error; }
+        }
+        return undefined;
+    };
+    OdsPlugin.prototype.findChartNodeInDocument = function (doc) {
+        if (!doc)
+            return undefined;
+        var 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");
+    };
+    OdsPlugin.prototype.findNodeRecursive = function (node, key) {
+        var e_45, _a, e_46, _b;
+        if (!node || typeof node !== "object")
+            return undefined;
+        if (node[key]) {
+            return Array.isArray(node[key]) ? node[key][0] : node[key];
+        }
+        try {
+            for (var _c = __values(Object.values(node)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var value = _d.value;
+                if (Array.isArray(value)) {
+                    try {
+                        for (var value_1 = (e_46 = void 0, __values(value)), value_1_1 = value_1.next(); !value_1_1.done; value_1_1 = value_1.next()) {
+                            var entry = value_1_1.value;
+                            var found = this.findNodeRecursive(entry, key);
+                            if (found)
+                                return found;
+                        }
+                    }
+                    catch (e_46_1) { e_46 = { error: e_46_1 }; }
+                    finally {
+                        try {
+                            if (value_1_1 && !value_1_1.done && (_b = value_1.return)) _b.call(value_1);
+                        }
+                        finally { if (e_46) throw e_46.error; }
+                    }
+                }
+                else if (typeof value === "object") {
+                    var found = this.findNodeRecursive(value, key);
+                    if (found)
+                        return found;
+                }
+            }
+        }
+        catch (e_45_1) { e_45 = { error: e_45_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_45) throw e_45.error; }
+        }
+        return undefined;
+    };
+    OdsPlugin.prototype.convertChartNodeToSpec = function (chartNode, sheetNameMap, context) {
+        var e_47, _a;
+        if (!chartNode)
+            return undefined;
+        var chartAttrs = this.getAttributes(chartNode);
+        var chartType = this.mapOdsChartClassToType((chartAttrs === null || chartAttrs === void 0 ? void 0 : chartAttrs["@_chart:class"]) || (chartAttrs === null || chartAttrs === void 0 ? void 0 : chartAttrs["@_class"]));
+        var titleNode = get(chartNode, "chart:title.chart:title-text") ||
+            get(chartNode, "chart:title") ||
+            get(chartNode, "title");
+        var rawTitle = titleNode ? this.extractTextContent(titleNode) : "";
+        var title = (rawTitle === null || rawTitle === void 0 ? void 0 : rawTitle.trim()) ? rawTitle.trim() : undefined;
+        var plotArea = get(chartNode, "chart:plot-area") || get(chartNode, "plot-area");
+        if (!plotArea)
+            return undefined;
+        var seriesNodes = this.toArray(get(plotArea, "chart:series") ||
+            get(plotArea, "chart:data-series") ||
+            get(plotArea, "series"));
+        if (!seriesNodes.length)
+            return undefined;
+        var domains = [];
+        var series = [];
+        var seriesIndex = 1;
+        try {
+            for (var seriesNodes_1 = __values(seriesNodes), seriesNodes_1_1 = seriesNodes_1.next(); !seriesNodes_1_1.done; seriesNodes_1_1 = seriesNodes_1.next()) {
+                var seriesNode = seriesNodes_1_1.value;
+                var domainNode = get(seriesNode, "chart:domain") ||
+                    get(seriesNode, "domain") ||
+                    get(seriesNode, "chart:categories");
+                if (domainNode) {
+                    var domainAddress = this.findRangeString(domainNode);
+                    if (domainAddress) {
+                        var chartData = this.createChartDataFromAddress(domainAddress, sheetNameMap, context);
+                        if (chartData) {
+                            domains.push(chartData);
+                        }
+                    }
+                }
+                var valueAddress = this.findRangeString(seriesNode, new Set(["chart:domain", "domain", "chart:categories"]));
+                if (valueAddress) {
+                    var seriesData = this.createChartDataFromAddress(valueAddress, sheetNameMap, context);
+                    if (seriesData) {
+                        var label = this.extractSeriesLabel(seriesNode);
+                        seriesData.dataLabel = label || "Series ".concat(seriesIndex);
+                        var color = this.extractChartSeriesColor(seriesNode);
+                        if (color) {
+                            seriesData.color = color;
+                        }
+                        series.push(seriesData);
+                        seriesIndex++;
+                    }
+                }
+            }
+        }
+        catch (e_47_1) { e_47 = { error: e_47_1 }; }
+        finally {
+            try {
+                if (seriesNodes_1_1 && !seriesNodes_1_1.done && (_a = seriesNodes_1.return)) _a.call(seriesNodes_1);
+            }
+            finally { if (e_47) throw e_47.error; }
+        }
+        if (!series.length) {
+            return undefined;
+        }
+        var finalizedDomains = domains.length ? domains : [series[0]];
+        return {
+            chartType: chartType,
+            title: title,
+            domains: finalizedDomains,
+            series: series,
+        };
+    };
+    OdsPlugin.prototype.extractSeriesLabel = function (seriesNode) {
+        if (!seriesNode)
+            return undefined;
+        var labelNode = get(seriesNode, "chart:label") ||
+            get(seriesNode, "label") ||
+            get(seriesNode, "chart:series-label");
+        var label = labelNode ? this.extractTextContent(labelNode) : undefined;
+        return (label === null || label === void 0 ? void 0 : label.trim()) || undefined;
+    };
+    OdsPlugin.prototype.extractChartSeriesColor = function (seriesNode) {
+        var e_48, _a, e_49, _b, e_50, _c;
+        if (!seriesNode)
+            return undefined;
+        var attrs = this.getAttributes(seriesNode);
+        var styleCandidates = [
+            attrs === null || attrs === void 0 ? void 0 : attrs["@_chart:style-name"],
+            attrs === null || attrs === void 0 ? void 0 : attrs["@_chart:data-style-name"],
+            attrs === null || attrs === void 0 ? void 0 : attrs["@_style-name"],
+        ];
+        try {
+            for (var styleCandidates_1 = __values(styleCandidates), styleCandidates_1_1 = styleCandidates_1.next(); !styleCandidates_1_1.done; styleCandidates_1_1 = styleCandidates_1.next()) {
+                var candidate = styleCandidates_1_1.value;
+                var color = this.odsStyles.getChartStyleColor(candidate);
+                if (color) {
+                    return typeof color === "string" ? color : undefined;
+                }
+            }
+        }
+        catch (e_48_1) { e_48 = { error: e_48_1 }; }
+        finally {
+            try {
+                if (styleCandidates_1_1 && !styleCandidates_1_1.done && (_a = styleCandidates_1.return)) _a.call(styleCandidates_1);
+            }
+            finally { if (e_48) throw e_48.error; }
+        }
+        var seriesProps = get(seriesNode, "chart:data-point-properties") ||
+            get(seriesNode, "chart:series-properties");
+        var inlineColor = this.extractColorFromChartProperties(seriesProps);
+        if (inlineColor) {
+            return inlineColor;
+        }
+        var dataPoints = this.toArray(get(seriesNode, "chart:data-point") ||
+            get(seriesNode, "chart:data-points") ||
+            get(seriesNode, "data-point"));
+        try {
+            for (var dataPoints_1 = __values(dataPoints), dataPoints_1_1 = dataPoints_1.next(); !dataPoints_1_1.done; dataPoints_1_1 = dataPoints_1.next()) {
+                var dataPoint = dataPoints_1_1.value;
+                var pointAttrs = this.getAttributes(dataPoint);
+                var pointStyleCandidates = [
+                    pointAttrs === null || pointAttrs === void 0 ? void 0 : pointAttrs["@_chart:style-name"],
+                    pointAttrs === null || pointAttrs === void 0 ? void 0 : pointAttrs["@_chart:data-style-name"],
+                    pointAttrs === null || pointAttrs === void 0 ? void 0 : pointAttrs["@_style-name"],
+                ];
+                try {
+                    for (var pointStyleCandidates_1 = (e_50 = void 0, __values(pointStyleCandidates)), pointStyleCandidates_1_1 = pointStyleCandidates_1.next(); !pointStyleCandidates_1_1.done; pointStyleCandidates_1_1 = pointStyleCandidates_1.next()) {
+                        var candidate = pointStyleCandidates_1_1.value;
+                        var color = this.odsStyles.getChartStyleColor(candidate);
+                        if (color)
+                            return typeof color === "string" ? color : undefined;
+                    }
+                }
+                catch (e_50_1) { e_50 = { error: e_50_1 }; }
+                finally {
+                    try {
+                        if (pointStyleCandidates_1_1 && !pointStyleCandidates_1_1.done && (_c = pointStyleCandidates_1.return)) _c.call(pointStyleCandidates_1);
+                    }
+                    finally { if (e_50) throw e_50.error; }
+                }
+                var pointColor = this.extractColorFromChartProperties(get(dataPoint, "chart:data-point-properties") || dataPoint);
+                if (pointColor)
+                    return pointColor;
+            }
+        }
+        catch (e_49_1) { e_49 = { error: e_49_1 }; }
+        finally {
+            try {
+                if (dataPoints_1_1 && !dataPoints_1_1.done && (_b = dataPoints_1.return)) _b.call(dataPoints_1);
+            }
+            finally { if (e_49) throw e_49.error; }
+        }
+        return undefined;
+    };
+    OdsPlugin.prototype.extractColorFromChartProperties = function (node) {
+        if (!node)
+            return undefined;
+        var attrs = this.getAttributes(node);
+        if (!attrs)
+            return undefined;
+        var rawValue = attrs["@_draw:fill-color"] ||
+            attrs["@_svg:fill-color"] ||
+            attrs["@_chart:color"] ||
+            attrs["@_fo:background-color"] ||
+            attrs["@_style:background-color"];
+        if (!rawValue)
+            return undefined;
+        var normalized = this.normalizeOdsColor(rawValue);
+        if (normalized &&
+            normalized.toLowerCase() !== "none" &&
+            normalized.toLowerCase() !== "transparent") {
+            return normalized;
+        }
+        return undefined;
+    };
+    OdsPlugin.prototype.mapOdsChartClassToType = function (value) {
+        var normalized = (value === null || value === void 0 ? void 0 : 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";
+    };
+    OdsPlugin.prototype.findRangeString = function (node, skipKeys) {
+        var e_51, _a, e_52, _b;
+        if (!node)
+            return undefined;
+        var stack = [node];
+        while (stack.length) {
+            var 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.apply(stack, __spreadArray([], __read(current), false));
+                continue;
+            }
+            if (typeof current === "object") {
+                var attrs = current[":@"] || current;
+                try {
+                    for (var _c = (e_51 = void 0, __values(Object.entries(attrs))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var _e = __read(_d.value, 2), key = _e[0], attrValue = _e[1];
+                        if (key.startsWith("@_") &&
+                            typeof attrValue === "string" &&
+                            this.looksLikeCellRangeAddress(attrValue)) {
+                            return attrValue;
+                        }
+                    }
+                }
+                catch (e_51_1) { e_51 = { error: e_51_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_51) throw e_51.error; }
+                }
+                try {
+                    for (var _f = (e_52 = void 0, __values(Object.entries(current))), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var _h = __read(_g.value, 2), childKey = _h[0], childValue = _h[1];
+                        if (childKey === ":@")
+                            continue;
+                        if (skipKeys && skipKeys.has(childKey))
+                            continue;
+                        stack.push(childValue);
+                    }
+                }
+                catch (e_52_1) { e_52 = { error: e_52_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                    }
+                    finally { if (e_52) throw e_52.error; }
+                }
+            }
+        }
+        return undefined;
+    };
+    OdsPlugin.prototype.looksLikeCellRangeAddress = function (value) {
+        if (!value)
+            return false;
+        var 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(":");
+    };
+    OdsPlugin.prototype.createChartDataFromAddress = function (address, sheetNameMap, context) {
+        if (!address)
+            return undefined;
+        var ranges = this.parseRangeList(address, sheetNameMap, context);
+        if (!ranges.length && (context === null || context === void 0 ? void 0 : context.name)) {
+            var augmented = "'".concat(context.name, "'.").concat(address);
+            ranges = this.parseRangeList(augmented, sheetNameMap, context);
+        }
+        if (!ranges.length)
+            return undefined;
+        return {
+            sources: ranges,
+        };
+    };
+    OdsPlugin.prototype.buildOverlayPlacement = function (frameAttrs, cellAttrs, rowIndex, columnIndex) {
+        var widthPixels = this.convertLengthToPixels((frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_svg:width"]) ||
+            (frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_width"]) ||
+            (cellAttrs === null || cellAttrs === void 0 ? void 0 : cellAttrs["@_svg:width"]) ||
+            (cellAttrs === null || cellAttrs === void 0 ? void 0 : cellAttrs["@_width"]));
+        var heightPixels = this.convertLengthToPixels((frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_svg:height"]) ||
+            (frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_height"]) ||
+            (cellAttrs === null || cellAttrs === void 0 ? void 0 : cellAttrs["@_svg:height"]) ||
+            (cellAttrs === null || cellAttrs === void 0 ? void 0 : cellAttrs["@_height"]));
+        var offsetXPixels = this.convertLengthToPixels((frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_svg:x"]) ||
+            (frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_x"]) ||
+            (cellAttrs === null || cellAttrs === void 0 ? void 0 : cellAttrs["@_svg:x"]) ||
+            (cellAttrs === null || cellAttrs === void 0 ? void 0 : cellAttrs["@_x"]));
+        var offsetYPixels = this.convertLengthToPixels((frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_svg:y"]) ||
+            (frameAttrs === null || frameAttrs === void 0 ? void 0 : frameAttrs["@_y"]) ||
+            (cellAttrs === null || cellAttrs === void 0 ? void 0 : cellAttrs["@_svg:y"]) ||
+            (cellAttrs === null || cellAttrs === void 0 ? void 0 : cellAttrs["@_y"]));
+        var overlayPosition = {
+            anchorCell: { rowIndex: rowIndex, columnIndex: 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;
+        }
+        var DEFAULT_CELL_IMAGE_MAX_SIZE = 60;
+        var exceedsCellSize = (typeof widthPixels === "number" &&
+            widthPixels > DEFAULT_CELL_IMAGE_MAX_SIZE) ||
+            (typeof heightPixels === "number" &&
+                heightPixels > DEFAULT_CELL_IMAGE_MAX_SIZE);
+        var isInsideCell = !exceedsCellSize &&
+            (offsetXPixels === undefined || Math.abs(offsetXPixels) < 0.01) &&
+            (offsetYPixels === undefined || Math.abs(offsetYPixels) < 0.01);
+        return { overlayPosition: overlayPosition, isInsideCell: isInsideCell };
+    };
+    OdsPlugin.prototype.getImageDataUrl = function (imagePath, cache) {
+        if (cache.has(imagePath)) {
+            return cache.get(imagePath);
+        }
+        try {
+            var binary = this.zipParser.GetBinary(imagePath);
+            var dataUrl = this.createDataUrlFromBytes(binary, this.getImageMimeType(imagePath));
+            cache.set(imagePath, dataUrl);
+            return dataUrl;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
+    OdsPlugin.prototype.normalizeImagePath = function (href) {
+        if (!href)
+            return undefined;
+        var normalized = href.trim();
+        if (!normalized || normalized.startsWith("#"))
+            return undefined;
+        normalized = normalized.replace(/^\.\/+/, "");
+        while (normalized.startsWith("../")) {
+            normalized = normalized.slice(3);
+        }
+        normalized = normalized.replace(/^\/+/, "");
+        return normalized;
+    };
+    OdsPlugin.prototype.getImageMimeType = function (path) {
+        var _a;
+        var extension = (_a = path.split(".").pop()) === null || _a === void 0 ? void 0 : _a.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";
+        }
+    };
+    OdsPlugin.prototype.createDataUrlFromBytes = function (data, mimeType) {
+        var base64 = this.bytesToBase64(data);
+        return "data:".concat(mimeType, ";base64,").concat(base64);
+    };
+    OdsPlugin.prototype.bytesToBase64 = function (data) {
+        var globalRef = typeof globalThis !== "undefined" ? globalThis : undefined;
+        if (globalRef === null || globalRef === void 0 ? void 0 : globalRef.Buffer) {
+            return globalRef.Buffer.from(data).toString("base64");
+        }
+        var chunkSize = 0x8000;
+        var binary = "";
+        for (var i = 0; i < data.length; i += chunkSize) {
+            var chunk = data.subarray(i, i + chunkSize);
+            binary += String.fromCharCode.apply(String, __spreadArray([], __read(Array.from(chunk)), false));
+        }
+        if (typeof btoa === "function") {
+            return btoa(binary);
+        }
+        if (globalRef === null || globalRef === void 0 ? void 0 : globalRef.btoa) {
+            return globalRef.btoa(binary);
+        }
+        throw new Error("Unable to encode image data");
+    };
+    OdsPlugin.prototype.convertLengthToPixels = function (value) {
+        var _a;
+        if (!value)
+            return undefined;
+        var match = value
+            .toString()
+            .trim()
+            .match(/^(-?\d+(?:\.\d+)?)(cm|mm|in|pt|pc|px)?$/i);
+        if (!match)
+            return undefined;
+        var amount = parseFloat(match[1]);
+        var unit = (match[2] || "px").toLowerCase();
+        var unitMap = {
+            px: 1,
+            cm: 37.7952755906,
+            mm: 3.77952755906,
+            in: 96,
+            pt: 96 / 72,
+            pc: 16,
+        };
+        var factor = (_a = unitMap[unit]) !== null && _a !== void 0 ? _a : 1;
+        return amount * factor;
+    };
+    OdsPlugin.prototype.normalizeOdsColor = function (value) {
+        if (!value)
+            return undefined;
+        var trimmed = value.trim();
+        if (!trimmed)
+            return undefined;
+        if (trimmed.startsWith("#")) {
+            return trimmed.toUpperCase();
+        }
+        if (/^\d+$/.test(trimmed)) {
+            var numeric = parseInt(trimmed, 10);
+            if (!isNaN(numeric)) {
+                return "#".concat((numeric & 0xffffff)
+                    .toString(16)
+                    .padStart(6, "0")
+                    .toUpperCase());
+            }
+        }
+        return trimmed;
+    };
+    OdsPlugin.prototype.parseIntegerValue = function (value) {
+        if (value === undefined || value === null)
+            return undefined;
+        var parsed = parseInt(value, 10);
+        return isNaN(parsed) ? undefined : parsed;
+    };
+    OdsPlugin.prototype.getNodeText = function (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;
+    };
+    OdsPlugin.prototype.buildSheetNameMap = function (sheetContexts) {
+        var e_53, _a;
+        var map = new Map();
+        try {
+            for (var sheetContexts_5 = __values(sheetContexts), sheetContexts_5_1 = sheetContexts_5.next(); !sheetContexts_5_1.done; sheetContexts_5_1 = sheetContexts_5.next()) {
+                var context = sheetContexts_5_1.value;
+                this.registerSheetNameVariants(map, context.name, context.sheetId);
+            }
+        }
+        catch (e_53_1) { e_53 = { error: e_53_1 }; }
+        finally {
+            try {
+                if (sheetContexts_5_1 && !sheetContexts_5_1.done && (_a = sheetContexts_5.return)) _a.call(sheetContexts_5);
+            }
+            finally { if (e_53) throw e_53.error; }
+        }
+        return map;
+    };
+    OdsPlugin.prototype.registerSheetNameVariants = function (map, name, sheetId) {
+        if (!name)
+            return;
+        map.set(name, sheetId);
+        var normalized = this.normalizeSheetName(name);
+        if (normalized && normalized !== name) {
+            map.set(normalized, sheetId);
+        }
+        if (normalized) {
+            map.set("'".concat(normalized, "'"), sheetId);
+        }
+    };
+    OdsPlugin.prototype.normalizeSheetName = function (name) {
+        if (!name)
+            return undefined;
+        var normalized = name.trim();
+        normalized = normalized.replace(/^'+|'+$/g, "");
+        normalized = normalized.replace(/^"+|"+$/g, "");
+        normalized = normalized.replace(/^\$+/, "");
+        return normalized;
+    };
+    OdsPlugin.prototype.parseRangeList = function (addresses, sheetNameMap, context) {
+        var e_54, _a;
+        if (!addresses)
+            return [];
+        var segments = this.splitAddressSegments(addresses);
+        var ranges = [];
+        try {
+            for (var segments_1 = __values(segments), segments_1_1 = segments_1.next(); !segments_1_1.done; segments_1_1 = segments_1.next()) {
+                var segment = segments_1_1.value;
+                var range = this.parseRange(segment, sheetNameMap, context);
+                if (range) {
+                    ranges.push(range);
+                }
+            }
+        }
+        catch (e_54_1) { e_54 = { error: e_54_1 }; }
+        finally {
+            try {
+                if (segments_1_1 && !segments_1_1.done && (_a = segments_1.return)) _a.call(segments_1);
+            }
+            finally { if (e_54) throw e_54.error; }
+        }
+        return ranges;
+    };
+    OdsPlugin.prototype.splitAddressSegments = function (addresses) {
+        var segments = [];
+        var buffer = "";
+        var inQuotes = false;
+        for (var i = 0; i < addresses.length; i++) {
+            var 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;
+    };
+    OdsPlugin.prototype.parseRange = function (address, sheetNameMap, context) {
+        var _a, _b;
+        if (!address)
+            return undefined;
+        var normalized = address.replace(/\$/g, "");
+        var _c = __read(normalized.split(":"), 2), startRef = _c[0], endRef = _c[1];
+        var start = this.parseCellReference(startRef, sheetNameMap, context);
+        if (!start)
+            return undefined;
+        var end = this.parseCellReference(endRef !== null && endRef !== void 0 ? endRef : startRef, sheetNameMap, context) ||
+            start;
+        var sheetId = (_b = (_a = end.sheetId) !== null && _a !== void 0 ? _a : start.sheetId) !== null && _b !== void 0 ? _b : context === null || context === void 0 ? void 0 : context.sheetId;
+        if (!sheetId)
+            return undefined;
+        return {
+            sheetId: 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),
+        };
+    };
+    OdsPlugin.prototype.parseCellReference = function (reference, sheetNameMap, context) {
+        var _a, _b;
+        if (!reference)
+            return undefined;
+        var ref = reference.trim();
+        if (!ref)
+            return undefined;
+        ref = ref.replace(/\$/g, "");
+        var sheetName;
+        var cellPart = ref;
+        var dotMatch = ref.match(/^(.*)[.!]([A-Za-z]+\d+)$/);
+        if (dotMatch) {
+            sheetName = dotMatch[1];
+            cellPart = dotMatch[2];
+        }
+        var bangMatch = ref.match(/^(.*)!([A-Za-z]+\d+)$/);
+        if (!sheetName && bangMatch) {
+            sheetName = bangMatch[1];
+            cellPart = bangMatch[2];
+        }
+        var quotedMatch = ref.match(/^'([^']+)'\.([A-Za-z]+\d+)$/);
+        if (!sheetName && quotedMatch) {
+            sheetName = quotedMatch[1];
+            cellPart = quotedMatch[2];
+        }
+        var cell = addressToCell(cellPart.toUpperCase());
+        if (!cell)
+            return undefined;
+        var normalizedSheet = sheetName
+            ? this.normalizeSheetName(sheetName)
+            : undefined;
+        var sheetId = (_b = (_a = (normalizedSheet && sheetNameMap.get(normalizedSheet))) !== null && _a !== void 0 ? _a : (sheetName && sheetNameMap.get(sheetName))) !== null && _b !== void 0 ? _b : context === null || context === void 0 ? void 0 : context.sheetId;
+        return {
+            rowIndex: cell.rowIndex,
+            columnIndex: cell.columnIndex,
+            sheetId: sheetId,
+        };
+    };
+    OdsPlugin.prototype.parseBooleanAttribute = function (value) {
+        if (value === undefined || value === null)
+            return undefined;
+        if (typeof value === "boolean")
+            return value;
+        var normalized = value.toString().toLowerCase();
+        if (normalized === "true" || normalized === "1")
+            return true;
+        if (normalized === "false" || normalized === "0")
+            return false;
+        return undefined;
+    };
+    OdsPlugin.prototype.normalizeConditionExpression = function (expression) {
+        if (!expression)
+            return undefined;
+        var 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 = "=".concat(normalized);
+        }
+        return normalized;
+    };
+    OdsPlugin.prototype.normalizeExpression = function (expression) {
+        if (!expression)
+            return undefined;
+        var normalized = expression.trim();
+        if (!normalized)
+            return undefined;
+        normalized = convertOdsFormulaToExcel(normalized);
+        normalized = normalized.trim();
+        if (!normalized)
+            return undefined;
+        return normalized.startsWith("=") ? normalized : "=".concat(normalized);
+    };
+    OdsPlugin.prototype.toArray = function (value) {
+        if (!value)
+            return [];
+        return Array.isArray(value) ? value : [value];
+    };
+    OdsPlugin.prototype.expandRowCells = function (rowChildren) {
+        var e_55, _a;
+        if (!rowChildren) {
+            return [];
+        }
+        var entries = Array.isArray(rowChildren) ? rowChildren : [rowChildren];
+        var normalized = [];
+        try {
+            for (var entries_2 = __values(entries), entries_2_1 = entries_2.next(); !entries_2_1.done; entries_2_1 = entries_2.next()) {
+                var entry = entries_2_1.value;
+                if (!entry)
+                    continue;
+                if (entry["table:table-cell"] || entry["table:covered-table-cell"]) {
+                    normalized.push(entry);
+                    continue;
+                }
+                var normalizedEntry = this.wrapRawCellEntry(entry);
+                if (normalizedEntry) {
+                    normalized.push(normalizedEntry);
+                }
+            }
+        }
+        catch (e_55_1) { e_55 = { error: e_55_1 }; }
+        finally {
+            try {
+                if (entries_2_1 && !entries_2_1.done && (_a = entries_2.return)) _a.call(entries_2);
+            }
+            finally { if (e_55) throw e_55.error; }
+        }
+        return normalized;
+    };
+    OdsPlugin.prototype.wrapRawCellEntry = function (entry) {
+        if (entry === undefined || entry === null)
+            return undefined;
+        var _a = this.extractAttributesFromNode(entry), attributes = _a.attributes, childNodes = _a.childNodes;
+        var wrapper = {
+            "table:table-cell": childNodes.length ? childNodes : [],
+        };
+        if (Object.keys(attributes).length) {
+            wrapper[":@"] = attributes;
+        }
+        return wrapper;
+    };
+    OdsPlugin.prototype.extractAttributesFromNode = function (node) {
+        var e_56, _a, _b;
+        var attributes = {};
+        var childNodes = [];
+        if (node === undefined || node === null) {
+            return { attributes: attributes, childNodes: childNodes };
+        }
+        if (typeof node !== "object" || Array.isArray(node)) {
+            childNodes.push(typeof node === "object" ? node : { "#text": node !== null && node !== void 0 ? node : "" });
+            return { attributes: attributes, childNodes: childNodes };
+        }
+        try {
+            for (var _c = __values(Object.entries(node)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var _e = __read(_d.value, 2), key = _e[0], value = _e[1];
+                if (key === ":@") {
+                    if (value && typeof value === "object") {
+                        Object.assign(attributes, value);
+                    }
+                    continue;
+                }
+                if (key.startsWith("@_")) {
+                    attributes[key] = value;
+                    continue;
+                }
+                childNodes.push((_b = {}, _b[key] = value, _b));
+            }
+        }
+        catch (e_56_1) { e_56 = { error: e_56_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_56) throw e_56.error; }
+        }
+        return { attributes: attributes, childNodes: childNodes };
+    };
+    OdsPlugin.prototype.getAttributes = function (node) {
+        if (!node)
+            return undefined;
+        if (Array.isArray(node)) {
+            return node.length ? this.getAttributes(node[0]) : undefined;
+        }
+        return node[":@"] || node;
+    };
+    OdsPlugin.prototype.mapAlertStyle = function (value) {
+        if (!value)
+            return undefined;
+        var normalized = value.toLowerCase();
+        if (normalized.includes("warn"))
+            return "warning";
+        if (normalized.includes("info"))
+            return "information";
+        return "stop";
+    };
+    OdsPlugin.prototype.getSheets = function () {
+        return __awaiter(this, arguments, void 0, function (minRowCount, minColumnCount) {
+            var cache, sheets;
+            if (minRowCount === void 0) { minRowCount = 0; }
+            if (minColumnCount === void 0) { minColumnCount = 0; }
+            return __generator(this, function (_a) {
+                cache = this.ensureSheetCache();
+                if (!minRowCount && !minColumnCount) {
+                    return [2 /*return*/, [cache.sheets, cache.tables]];
+                }
+                sheets = cache.sheets.map(function (sheet) {
+                    var _a, _b;
+                    var rowCount = Math.max((_a = sheet.rowCount) !== null && _a !== void 0 ? _a : 0, minRowCount);
+                    var columnCount = Math.max((_b = sheet.columnCount) !== null && _b !== void 0 ? _b : 0, minColumnCount);
+                    if (rowCount === sheet.rowCount && columnCount === sheet.columnCount) {
+                        return sheet;
+                    }
+                    return __assign(__assign({}, sheet), { rowCount: rowCount, columnCount: columnCount });
+                });
+                return [2 /*return*/, [sheets, cache.tables]];
+            });
+        });
+    };
+    OdsPlugin.prototype.getConditionalFormatting = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ensureSheetCache().conditionalFormatting];
+            });
+        });
+    };
+    OdsPlugin.prototype.getDrawings = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ensureSheetCache().drawings];
+            });
+        });
+    };
+    OdsPlugin.prototype.getCharts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ensureSheetCache().charts];
+            });
+        });
+    };
+    OdsPlugin.prototype.getDataValidations = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ensureSheetCache().dataValidations];
+            });
+        });
+    };
+    OdsPlugin.prototype.getNamedRanges = function () {
+        return this.ensureSheetCache().namedRanges;
+    };
+    OdsPlugin.prototype.findCalculationSettings = function (node) {
+        var e_57, _a;
+        if (!node)
+            return undefined;
+        if (Array.isArray(node)) {
+            try {
+                for (var node_2 = __values(node), node_2_1 = node_2.next(); !node_2_1.done; node_2_1 = node_2.next()) {
+                    var child = node_2_1.value;
+                    var found = this.findCalculationSettings(child);
+                    if (found)
+                        return found;
+                }
+            }
+            catch (e_57_1) { e_57 = { error: e_57_1 }; }
+            finally {
+                try {
+                    if (node_2_1 && !node_2_1.done && (_a = node_2.return)) _a.call(node_2);
+                }
+                finally { if (e_57) throw e_57.error; }
+            }
+            return undefined;
+        }
+        if (node["table:calculation-settings"]) {
+            var 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"]));
+    };
+    OdsPlugin.prototype.getIterativeCalculationOptions = function () {
+        var _a;
+        try {
+            var calcSettings = (_a = this.findCalculationSettings(this.contentXml)) !== null && _a !== void 0 ? _a : this.findCalculationSettings(this.contentXmlOrdered);
+            if (!calcSettings)
+                return undefined;
+            var enabledAttr = getAttribute(calcSettings, "table:use-iteration");
+            var maxIterationsAttr = getAttribute(calcSettings, "table:iteration-count");
+            var maxChangeAttr = getAttribute(calcSettings, "table:minimum-step");
+            if (enabledAttr === undefined &&
+                maxIterationsAttr === undefined &&
+                maxChangeAttr === undefined) {
+                return undefined;
+            }
+            var enabled = enabledAttr === "true" || enabledAttr === true || enabledAttr === "1";
+            var options = { enabled: enabled };
+            if (maxIterationsAttr !== undefined) {
+                var parsed = Number(maxIterationsAttr);
+                if (!Number.isNaN(parsed)) {
+                    options.maxIterations = parsed;
+                }
+            }
+            if (maxChangeAttr !== undefined) {
+                var parsed = Number(maxChangeAttr);
+                if (!Number.isNaN(parsed)) {
+                    options.maxChange = parsed;
+                }
+            }
+            return options;
+        }
+        catch (_b) {
+            return undefined;
+        }
+    };
+    OdsPlugin.prototype.processSheetData = function () {
+        return __asyncGenerator(this, arguments, function processSheetData_1(chunkSize, enableCellXfsRegistry, enableSharedStrings) {
+            var docContent, body, spreadsheet, tables, totalSheets, currentSheetIndex, tableWrapper, tableNameKey, tableChildren, tableAttrs, name_4, sheetId, tableStyleName, tableCellFormat, rows, columnWrappers, columnFormats, formattedColumnIndex, columnWrappers_1, columnWrappers_1_1, columnWrapper, columnAttrs, colsRepeated, columnStyleName, columnStyle, columnCellFormat, col, chunkIndex, currentChunk, currentChunkRowIndices, currentRowIndex, dvStamper, _a, rows_4, rows_4_1, rowWrapper, rowNameKey, rowChildren, rowAttrs, rowsRepeated, rowStyleName, rowStyle, rowCellFormat, rowBaseFormat, effectiveRepeats, r, rowData, columnIndex, normalizedRowChildren, normalizedRowChildren_3, normalizedRowChildren_3_1, cellWrapper, isCell, isCovered, cellNameKey, cellChildren, cellAttrs, colsRepeated, valueType, cellValue, displayValue, textFormatRuns, textPWrapper, textPKey, richText, hyperlinkValue, cellData, formula, isSharedString, excelFormula, matrixCols, matrixRows, cols, rows_5, start, end, cellStyleName, cellFormat, hasCellValue, c, targetColumnIndex, mergedFormat, alignment, needsDefaultRightAlign, displaySuggestsCurrency, currencySymbol, pattern, shouldInferNumberFormat, detectionSource, _b, detectedValueType, detectedNumberFormatType, detectedPattern, shouldOverrideExistingFormat, finalCellData, styleId, sheetSparklines, rowSparklines, _c, _d, _e, colIndex, sparkline, existingCell, sparklineData, sparklineOptions, cellData, isRowEmpty, e_58_1, _f, _g, trailing, e_59_1, error_1;
+            var e_60, _h, e_58, _j, e_61, _k, e_62, _l, e_59, _m;
+            var _o, _p, _q, _r;
+            if (chunkSize === void 0) { chunkSize = 100; }
+            if (enableCellXfsRegistry === void 0) { enableCellXfsRegistry = false; }
+            if (enableSharedStrings === void 0) { enableSharedStrings = true; }
+            return __generator(this, function (_s) {
+                switch (_s.label) {
+                    case 0:
+                        _s.trys.push([0, 37, , 38]);
+                        if (!!this.contentXmlOrdered) return [3 /*break*/, 2];
+                        return [4 /*yield*/, __await(void 0)];
+                    case 1: return [2 /*return*/, _s.sent()];
+                    case 2:
+                        docContent = ((_o = this.contentXmlOrdered[0]) === null || _o === void 0 ? void 0 : _o["office:document-content"]) ||
+                            ((_p = this.contentXmlOrdered[0]) === null || _p === void 0 ? void 0 : _p["document-content"]);
+                        if (!!docContent) return [3 /*break*/, 4];
+                        return [4 /*yield*/, __await(void 0)];
+                    case 3: return [2 /*return*/, _s.sent()];
+                    case 4:
+                        body = getChildren(docContent, "office:body") ||
+                            getChildren(docContent, "body");
+                        if (!!body) return [3 /*break*/, 6];
+                        return [4 /*yield*/, __await(void 0)];
+                    case 5: return [2 /*return*/, _s.sent()];
+                    case 6:
+                        spreadsheet = getChildren(body, "office:spreadsheet") ||
+                            getChildren(body, "spreadsheet");
+                        if (!!spreadsheet) return [3 /*break*/, 8];
+                        return [4 /*yield*/, __await(void 0)];
+                    case 7: return [2 /*return*/, _s.sent()];
+                    case 8:
+                        tables = spreadsheet.filter(function (child) { return child["table:table"] || child["table"]; });
+                        totalSheets = tables.length;
+                        currentSheetIndex = 0;
+                        _s.label = 9;
+                    case 9:
+                        if (!(currentSheetIndex < totalSheets)) return [3 /*break*/, 36];
+                        tableWrapper = tables[currentSheetIndex];
+                        tableNameKey = tableWrapper["table:table"]
+                            ? "table:table"
+                            : "table";
+                        tableChildren = tableWrapper[tableNameKey];
+                        tableAttrs = tableWrapper[":@"] || {};
+                        name_4 = tableAttrs["@_table:name"] ||
+                            tableAttrs["@_name"] ||
+                            "Sheet".concat(currentSheetIndex + 1);
+                        sheetId = currentSheetIndex + 1;
+                        tableStyleName = tableAttrs["@_table:style-name"] || tableAttrs["@_style-name"];
+                        tableCellFormat = tableStyleName
+                            ? this.odsStyles.getTableCellFormat(tableStyleName)
+                            : undefined;
+                        rows = tableChildren.filter(function (child) { return child["table:table-row"] || child["table-row"]; });
+                        columnWrappers = tableChildren.filter(function (child) { return child["table:table-column"] || child["table-column"]; });
+                        columnFormats = new Map();
+                        formattedColumnIndex = 1;
+                        try {
+                            for (columnWrappers_1 = (e_60 = void 0, __values(columnWrappers)), columnWrappers_1_1 = columnWrappers_1.next(); !columnWrappers_1_1.done; columnWrappers_1_1 = columnWrappers_1.next()) {
+                                columnWrapper = columnWrappers_1_1.value;
+                                columnAttrs = columnWrapper[":@"] || {};
+                                colsRepeated = parseInt(columnAttrs["@_table:number-columns-repeated"] ||
+                                    columnAttrs["@_number-columns-repeated"] ||
+                                    "1", 10);
+                                columnStyleName = columnAttrs["@_table:style-name"] || columnAttrs["@_style-name"];
+                                columnStyle = columnStyleName
+                                    ? this.odsStyles.getColumnStyle(columnStyleName)
+                                    : undefined;
+                                columnCellFormat = columnStyle === null || columnStyle === void 0 ? void 0 : columnStyle.format;
+                                for (col = 0; col < colsRepeated; col++) {
+                                    if (columnCellFormat) {
+                                        columnFormats.set(formattedColumnIndex, columnCellFormat);
+                                    }
+                                    formattedColumnIndex++;
+                                }
+                            }
+                        }
+                        catch (e_60_1) { e_60 = { error: e_60_1 }; }
+                        finally {
+                            try {
+                                if (columnWrappers_1_1 && !columnWrappers_1_1.done && (_h = columnWrappers_1.return)) _h.call(columnWrappers_1);
+                            }
+                            finally { if (e_60) throw e_60.error; }
+                        }
+                        chunkIndex = 0;
+                        currentChunk = [];
+                        currentChunkRowIndices = [];
+                        currentRowIndex = 1;
+                        _a = SheetDataValidationStamper.bind;
+                        return [4 /*yield*/, __await(this.getDataValidations())];
+                    case 10:
+                        dvStamper = new (_a.apply(SheetDataValidationStamper, [void 0, _s.sent(), sheetId]))();
+                        _s.label = 11;
+                    case 11:
+                        _s.trys.push([11, 19, 20, 21]);
+                        rows_4 = (e_58 = void 0, __values(rows)), rows_4_1 = rows_4.next();
+                        _s.label = 12;
+                    case 12:
+                        if (!!rows_4_1.done) return [3 /*break*/, 18];
+                        rowWrapper = rows_4_1.value;
+                        rowNameKey = rowWrapper["table:table-row"]
+                            ? "table:table-row"
+                            : "table-row";
+                        rowChildren = rowWrapper[rowNameKey];
+                        rowAttrs = rowWrapper[":@"] || {};
+                        rowsRepeated = parseInt(rowAttrs["@_table:number-rows-repeated"] ||
+                            rowAttrs["@_number-rows-repeated"] ||
+                            "1");
+                        rowStyleName = rowAttrs["@_table:style-name"] || rowAttrs["@_style-name"];
+                        rowStyle = rowStyleName
+                            ? this.odsStyles.getRowStyle(rowStyleName)
+                            : undefined;
+                        rowCellFormat = rowStyle === null || rowStyle === void 0 ? void 0 : rowStyle.format;
+                        rowBaseFormat = fastMergeCellFormats(tableCellFormat, rowCellFormat);
+                        effectiveRepeats = Math.min(rowsRepeated, 10000);
+                        r = 0;
+                        _s.label = 13;
+                    case 13:
+                        if (!(r < effectiveRepeats)) return [3 /*break*/, 17];
+                        rowData = {
+                            values: [],
+                        };
+                        columnIndex = 1;
+                        normalizedRowChildren = rowChildren
+                            ? this.expandRowCells(rowChildren)
+                            : null;
+                        if (normalizedRowChildren) {
+                            try {
+                                for (normalizedRowChildren_3 = (e_61 = void 0, __values(normalizedRowChildren)), normalizedRowChildren_3_1 = normalizedRowChildren_3.next(); !normalizedRowChildren_3_1.done; normalizedRowChildren_3_1 = normalizedRowChildren_3.next()) {
+                                    cellWrapper = normalizedRowChildren_3_1.value;
+                                    isCell = !!cellWrapper["table:table-cell"];
+                                    isCovered = !!cellWrapper["table:covered-table-cell"];
+                                    if (!isCell && !isCovered)
+                                        continue;
+                                    cellNameKey = isCell
+                                        ? "table:table-cell"
+                                        : "table:covered-table-cell";
+                                    cellChildren = cellWrapper[cellNameKey];
+                                    cellAttrs = cellWrapper[":@"] || {};
+                                    colsRepeated = parseInt(cellAttrs["@_table:number-columns-repeated"] ||
+                                        cellAttrs["@_number-columns-repeated"] ||
+                                        "1");
+                                    if (isCovered) {
+                                        columnIndex += colsRepeated;
+                                        continue;
+                                    }
+                                    valueType = cellAttrs["@_office:value-type"] || cellAttrs["@_value-type"];
+                                    cellValue = null;
+                                    displayValue = "";
+                                    textFormatRuns = void 0;
+                                    textPWrapper = findChild(cellChildren, "text:p") ||
+                                        findChild(cellChildren, "p");
+                                    if (textPWrapper) {
+                                        textPKey = textPWrapper["text:p"] ? "text:p" : "p";
+                                        richText = this.extractTextContentWithRuns(textPWrapper[textPKey]);
+                                        displayValue = richText.text;
+                                        if (richText.runs.length > 0) {
+                                            textFormatRuns = richText.runs;
+                                        }
+                                    }
+                                    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;
+                                    }
+                                    cellData = {};
+                                    if (hyperlinkValue) {
+                                        cellData.hyperlink = hyperlinkValue;
+                                    }
+                                    if (cellValue !== null && cellValue !== "") {
+                                        formula = cellAttrs["@_table:formula"] || cellAttrs["@_formula"];
+                                        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) {
+                                                excelFormula = convertOdsFormulaToExcel(formula);
+                                                cellData.ue = { fv: excelFormula };
+                                                matrixCols = parseInt(cellAttrs["@_table:number-matrix-columns-spanned"] ||
+                                                    cellAttrs["@_number-matrix-columns-spanned"] ||
+                                                    "0");
+                                                matrixRows = parseInt(cellAttrs["@_table:number-matrix-rows-spanned"] ||
+                                                    cellAttrs["@_number-matrix-rows-spanned"] ||
+                                                    "0");
+                                                if (matrixCols > 0 || matrixRows > 0) {
+                                                    cols = Math.max(matrixCols, 1);
+                                                    rows_5 = Math.max(matrixRows, 1);
+                                                    start = cellToAddress({
+                                                        rowIndex: currentRowIndex,
+                                                        columnIndex: columnIndex,
+                                                    });
+                                                    end = cellToAddress({
+                                                        rowIndex: currentRowIndex + rows_5 - 1,
+                                                        columnIndex: columnIndex + cols - 1,
+                                                    });
+                                                    if (start && end) {
+                                                        cellData.af = "".concat(start, ":").concat(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;
+                                            }
+                                        }
+                                    }
+                                    cellStyleName = cellAttrs["@_table:style-name"] || cellAttrs["@_style-name"];
+                                    cellFormat = cellStyleName
+                                        ? this.odsStyles.getStyle(cellStyleName)
+                                        : undefined;
+                                    hasCellValue = Object.keys(cellData).length > 0;
+                                    // Fill repeated columns
+                                    for (c = 0; c < colsRepeated; c++) {
+                                        targetColumnIndex = columnIndex;
+                                        mergedFormat = fastMergeCellFormats(rowBaseFormat, columnFormats.get(targetColumnIndex), cellFormat);
+                                        if (mergedFormat) {
+                                            if (mergedFormat.__alignValueType) {
+                                                alignment = valueType === "float" ||
+                                                    valueType === "currency" ||
+                                                    valueType === "percentage"
+                                                    ? "right"
+                                                    : "left";
+                                                mergedFormat.horizontalAlignment = alignment;
+                                                delete mergedFormat.__alignValueType;
+                                            }
+                                        }
+                                        needsDefaultRightAlign = (valueType === "float" ||
+                                            valueType === "currency" ||
+                                            valueType === "percentage" ||
+                                            valueType === "date") &&
+                                            (!mergedFormat || !mergedFormat.horizontalAlignment);
+                                        if (needsDefaultRightAlign) {
+                                            mergedFormat = mergedFormat
+                                                ? __assign({}, mergedFormat) : {};
+                                            mergedFormat.horizontalAlignment = "right";
+                                        }
+                                        displaySuggestsCurrency = typeof displayValue === "string" &&
+                                            DISPLAY_CURRENCY_REGEX.test(displayValue);
+                                        if (valueType === "currency") {
+                                            mergedFormat = mergedFormat
+                                                ? __assign({}, mergedFormat) : {};
+                                            currencySymbol = cellAttrs["@_office:currency"] ||
+                                                cellAttrs["@_currency"] ||
+                                                "$";
+                                            if (!mergedFormat.numberFormat ||
+                                                mergedFormat.numberFormat.type === "NUMBER") {
+                                                pattern = ((_q = mergedFormat.numberFormat) === null || _q === void 0 ? void 0 : _q.pattern) || "#,##0.00";
+                                                mergedFormat.numberFormat = {
+                                                    type: "CURRENCY",
+                                                    pattern: pattern.includes(currencySymbol)
+                                                        ? pattern
+                                                        : "".concat(currencySymbol).concat(pattern.startsWith("#") || pattern.startsWith("0")
+                                                            ? " "
+                                                            : "").concat(pattern),
+                                                };
+                                            }
+                                        }
+                                        shouldInferNumberFormat = valueType === "float" &&
+                                            (!mergedFormat ||
+                                                !mergedFormat.numberFormat ||
+                                                displaySuggestsCurrency);
+                                        if (shouldInferNumberFormat) {
+                                            detectionSource = typeof displayValue === "string" &&
+                                                displayValue.trim() !== ""
+                                                ? displayValue
+                                                : cellValue;
+                                            if (detectionSource !== undefined) {
+                                                _b = __read(detectValueTypeAndPattern(detectionSource, undefined), 4), detectedValueType = _b[0], detectedNumberFormatType = _b[1], detectedPattern = _b[3];
+                                                if (detectedValueType === "numberValue" &&
+                                                    detectedNumberFormatType) {
+                                                    shouldOverrideExistingFormat = !mergedFormat ||
+                                                        !mergedFormat.numberFormat ||
+                                                        mergedFormat.numberFormat.type === "NUMBER" ||
+                                                        (displaySuggestsCurrency &&
+                                                            detectedNumberFormatType === "CURRENCY");
+                                                    if (shouldOverrideExistingFormat) {
+                                                        mergedFormat = mergedFormat
+                                                            ? __assign({}, mergedFormat) : {};
+                                                        mergedFormat.numberFormat = __assign({ type: detectedNumberFormatType }, (detectedPattern
+                                                            ? { pattern: detectedPattern }
+                                                            : {}));
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        if (!hasCellValue && !mergedFormat) {
+                                            columnIndex++;
+                                            continue;
+                                        }
+                                        finalCellData = hasCellValue
+                                            ? __assign({}, cellData) : {};
+                                        if (mergedFormat) {
+                                            if (enableCellXfsRegistry) {
+                                                styleId = this.registerFormat(mergedFormat);
+                                                finalCellData.ef = { sid: styleId };
+                                                finalCellData.uf = { sid: styleId };
+                                            }
+                                            else {
+                                                finalCellData.userEnteredFormat = mergedFormat;
+                                            }
+                                        }
+                                        rowData.values[targetColumnIndex] = finalCellData;
+                                        columnIndex++;
+                                    }
+                                }
+                            }
+                            catch (e_61_1) { e_61 = { error: e_61_1 }; }
+                            finally {
+                                try {
+                                    if (normalizedRowChildren_3_1 && !normalizedRowChildren_3_1.done && (_k = normalizedRowChildren_3.return)) _k.call(normalizedRowChildren_3);
+                                }
+                                finally { if (e_61) throw e_61.error; }
+                            }
+                        }
+                        sheetSparklines = this.sparklinesBySheet.get(sheetId);
+                        if (sheetSparklines) {
+                            rowSparklines = sheetSparklines.get(currentRowIndex);
+                            if (rowSparklines) {
+                                try {
+                                    for (_c = (e_62 = void 0, __values(rowSparklines.entries())), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                        _e = __read(_d.value, 2), colIndex = _e[0], sparkline = _e[1];
+                                        existingCell = rowData.values[colIndex];
+                                        // Only set formula if cell doesn't already have one
+                                        if ((_r = existingCell === null || existingCell === void 0 ? void 0 : existingCell.ue) === null || _r === void 0 ? void 0 : _r.fv) {
+                                            continue;
+                                        }
+                                        sparklineData = extractSparklineData(sparkline, currentRowIndex, rowData.values);
+                                        sparklineOptions = {};
+                                        if (sparkline.chartType !== "line") {
+                                            sparklineOptions.charttype = sparkline.chartType;
+                                        }
+                                        if (sparkline.color) {
+                                            sparklineOptions.color = sparkline.color;
+                                        }
+                                        cellData = __assign(__assign({}, 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;
+                                    }
+                                }
+                                catch (e_62_1) { e_62 = { error: e_62_1 }; }
+                                finally {
+                                    try {
+                                        if (_d && !_d.done && (_l = _c.return)) _l.call(_c);
+                                    }
+                                    finally { if (e_62) throw e_62.error; }
+                                }
+                                // Clean up processed sparklines
+                                sheetSparklines.delete(currentRowIndex);
+                            }
+                        }
+                        dvStamper.stampRow(currentRowIndex, rowData.values);
+                        isRowEmpty = rowData.values.length === 0;
+                        if (isRowEmpty) {
+                            currentRowIndex++;
+                            if (r === 0 && effectiveRepeats > 1) {
+                                currentRowIndex += effectiveRepeats - 1;
+                                return [3 /*break*/, 17];
+                            }
+                            return [3 /*break*/, 16];
+                        }
+                        currentChunk.push(rowData);
+                        currentChunkRowIndices.push(currentRowIndex);
+                        currentRowIndex++;
+                        if (!(currentChunk.length >= chunkSize)) return [3 /*break*/, 16];
+                        return [4 /*yield*/, __await({
+                                sheetId: sheetId,
+                                title: name_4,
+                                currentSheetIndex: currentSheetIndex,
+                                totalSheets: totalSheets,
+                                chunkIndex: chunkIndex,
+                                rows: currentChunk,
+                                rowIndices: currentChunkRowIndices,
+                                startRowIndex: currentChunkRowIndices[0],
+                                endRowIndex: currentChunkRowIndices[currentChunk.length - 1],
+                                totalRows: -1,
+                                isLastChunk: false,
+                                cellXfs: enableCellXfsRegistry ? this.cellXfs : new Map(),
+                            })];
+                    case 14: return [4 /*yield*/, _s.sent()];
+                    case 15:
+                        _s.sent();
+                        currentChunk = [];
+                        currentChunkRowIndices = [];
+                        chunkIndex++;
+                        _s.label = 16;
+                    case 16:
+                        r++;
+                        return [3 /*break*/, 13];
+                    case 17:
+                        rows_4_1 = rows_4.next();
+                        return [3 /*break*/, 12];
+                    case 18: return [3 /*break*/, 21];
+                    case 19:
+                        e_58_1 = _s.sent();
+                        e_58 = { error: e_58_1 };
+                        return [3 /*break*/, 21];
+                    case 20:
+                        try {
+                            if (rows_4_1 && !rows_4_1.done && (_j = rows_4.return)) _j.call(rows_4);
+                        }
+                        finally { if (e_58) throw e_58.error; }
+                        return [7 /*endfinally*/];
+                    case 21:
+                        _s.trys.push([21, 27, 28, 29]);
+                        _f = (e_59 = void 0, __values(dvStamper.trailingRows())), _g = _f.next();
+                        _s.label = 22;
+                    case 22:
+                        if (!!_g.done) return [3 /*break*/, 26];
+                        trailing = _g.value;
+                        currentChunk.push({ values: trailing.values });
+                        currentChunkRowIndices.push(trailing.rowIndex);
+                        if (!(currentChunk.length >= chunkSize)) return [3 /*break*/, 25];
+                        return [4 /*yield*/, __await({
+                                sheetId: sheetId,
+                                title: name_4,
+                                currentSheetIndex: currentSheetIndex,
+                                totalSheets: totalSheets,
+                                chunkIndex: chunkIndex,
+                                rows: currentChunk,
+                                rowIndices: currentChunkRowIndices,
+                                startRowIndex: currentChunkRowIndices[0],
+                                endRowIndex: currentChunkRowIndices[currentChunk.length - 1],
+                                totalRows: -1,
+                                isLastChunk: false,
+                                cellXfs: enableCellXfsRegistry ? this.cellXfs : new Map(),
+                            })];
+                    case 23: return [4 /*yield*/, _s.sent()];
+                    case 24:
+                        _s.sent();
+                        currentChunk = [];
+                        currentChunkRowIndices = [];
+                        chunkIndex++;
+                        _s.label = 25;
+                    case 25:
+                        _g = _f.next();
+                        return [3 /*break*/, 22];
+                    case 26: return [3 /*break*/, 29];
+                    case 27:
+                        e_59_1 = _s.sent();
+                        e_59 = { error: e_59_1 };
+                        return [3 /*break*/, 29];
+                    case 28:
+                        try {
+                            if (_g && !_g.done && (_m = _f.return)) _m.call(_f);
+                        }
+                        finally { if (e_59) throw e_59.error; }
+                        return [7 /*endfinally*/];
+                    case 29:
+                        if (!(currentChunk.length > 0)) return [3 /*break*/, 32];
+                        return [4 /*yield*/, __await({
+                                sheetId: sheetId,
+                                title: name_4,
+                                currentSheetIndex: currentSheetIndex,
+                                totalSheets: totalSheets,
+                                chunkIndex: chunkIndex,
+                                rows: currentChunk,
+                                rowIndices: currentChunkRowIndices,
+                                startRowIndex: currentChunkRowIndices[0],
+                                endRowIndex: currentChunkRowIndices[currentChunk.length - 1],
+                                totalRows: currentRowIndex - 1,
+                                isLastChunk: true,
+                                cellXfs: enableCellXfsRegistry ? this.cellXfs : new Map(),
+                            })];
+                    case 30: return [4 /*yield*/, _s.sent()];
+                    case 31:
+                        _s.sent();
+                        return [3 /*break*/, 35];
+                    case 32: return [4 /*yield*/, __await({
+                            sheetId: sheetId,
+                            title: name_4,
+                            currentSheetIndex: currentSheetIndex,
+                            totalSheets: totalSheets,
+                            chunkIndex: chunkIndex,
+                            rows: [],
+                            rowIndices: [],
+                            startRowIndex: 0,
+                            endRowIndex: 0,
+                            totalRows: 0,
+                            isLastChunk: true,
+                            cellXfs: enableCellXfsRegistry ? this.cellXfs : new Map(),
+                        })];
+                    case 33: 
+                    // Empty sheet
+                    return [4 /*yield*/, _s.sent()];
+                    case 34:
+                        // Empty sheet
+                        _s.sent();
+                        _s.label = 35;
+                    case 35:
+                        currentSheetIndex++;
+                        return [3 /*break*/, 9];
+                    case 36: return [3 /*break*/, 38];
+                    case 37:
+                        error_1 = _s.sent();
+                        console.error("Error processing ODS sheet data", error_1);
+                        throw error_1;
+                    case 38: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return OdsPlugin;
+}(BaseWorkbookPlugin));
+export { OdsPlugin };