@rowsncolumns/toolkit 24.4.1

package/dist/esm/exporter/ods/ods-export.js

@@ -0,0 +1,3238 @@
+import { tokenize as defaultTokenizer } from "@rowsncolumns/calculator";
+import { CellXfsRegistry, deriveEffectiveNumberFormatFromFormula, } from "@rowsncolumns/spreadsheet-state";
+import { cellRangeToAddress, cellToAddress, getCellEffectiveFormat, getCellEffectiveValue, getCellFormattedValue, getCellUserEnteredFormat, getCellUserEnteredValue, getExtendedValueBool, getExtendedValueError, getExtendedValueFormula, getExtendedValueNumber, getExtendedValueString, escapeCharacters, isNil, sortSheetsByIndex, addressToSelection, } from "@rowsncolumns/utils";
+import { defaultSpreadsheetTheme } from "../../excel-parser/theme-default";
+import { imageUrlToBase64 } from "../../helpers";
+import { omitInvalidDataValidationError } from "../invalid-data-validation";
+import { buildOdsSparklineGroupsXml } from "./sparkline-builder";
+const BLANK_LABEL = "(Blanks)";
+const isStyleReference = (value) => !!value && typeof value === "object" && "sid" in value;
+/**
+ * Walk a sparse 1-indexed `DimensionProperties` array and return every
+ * outline group span. Mirrors the level-transition scan the gutter and
+ * collapse hooks use; the difference is that here we also resolve each
+ * group's `collapsed` state from its summary cell so the ODS exporter
+ * can emit `table:display="false"` on the wrapper.
+ *
+ * `summaryAfter` follows the sheet's `outlinePr.summaryBelow`/
+ * `summaryRight` setting — when true (Excel default), the summary cell
+ * sits at `endIndex + 1`; when false, at `startIndex - 1`.
+ */
+const findOutlineGroupSpans = (metadata, count, summaryAfter) => {
+    const spans = [];
+    if (!metadata?.length || count <= 0)
+        return spans;
+    const levelAt = (i) => i >= 1 && i <= count ? metadata[i]?.outlineLevel ?? 0 : 0;
+    const openStarts = new Map();
+    let prevLevel = 0;
+    // Walk one past `count` so a group that runs to the last row/column
+    // still closes cleanly.
+    for (let i = 1; i <= count + 1; i++) {
+        const curr = levelAt(i);
+        if (curr > prevLevel) {
+            for (let level = prevLevel + 1; level <= curr; level++) {
+                openStarts.set(level, i);
+            }
+        }
+        else if (curr < prevLevel) {
+            for (let level = prevLevel; level > curr; level--) {
+                const startIndex = openStarts.get(level) ?? i;
+                const endIndex = i - 1;
+                const summaryIndex = summaryAfter ? i : startIndex - 1;
+                const collapsed = !!metadata[summaryIndex]?.collapsed;
+                spans.push({ level, startIndex, endIndex, collapsed });
+                openStarts.delete(level);
+            }
+        }
+        prevLevel = curr;
+    }
+    return spans;
+};
+/**
+ * Build "opens-at" and "closes-at" indices for the group spans.
+ * Returns lookup maps the row/column emitter consults at each index to
+ * know how many group tags need to be opened or closed. Opens are
+ * sorted outermost-first (lower level number first); closes are sorted
+ * innermost-first (higher level number first) so the XML nests properly.
+ */
+const buildOutlineGroupIndex = (spans) => {
+    const opensAt = new Map();
+    const closesAt = new Map();
+    for (const span of spans) {
+        const opens = opensAt.get(span.startIndex) ?? [];
+        opens.push(span);
+        opensAt.set(span.startIndex, opens);
+        const closes = closesAt.get(span.endIndex) ?? [];
+        closes.push(span);
+        closesAt.set(span.endIndex, closes);
+    }
+    for (const opens of opensAt.values()) {
+        opens.sort((a, b) => a.level - b.level);
+    }
+    for (const closes of closesAt.values()) {
+        closes.sort((a, b) => b.level - a.level);
+    }
+    return { opensAt, closesAt };
+};
+const outlineGroupOpenTag = (span, tag) => {
+    const display = span.collapsed ? ` table:display="false"` : "";
+    return `<${tag}${display}>`;
+};
+const XML_DECLARATION = `<?xml version="1.0" encoding="UTF-8"?>`;
+const ODS_MIMETYPE = "application/vnd.oasis.opendocument.spreadsheet";
+const CREATOR = "Rows n Columns";
+const PIXELS_PER_INCH = 96;
+const CM_PER_INCH = 2.54;
+const ODS_NS = {
+    office: "urn:oasis:names:tc:opendocument:xmlns:office:1.0",
+    style: "urn:oasis:names:tc:opendocument:xmlns:style:1.0",
+    text: "urn:oasis:names:tc:opendocument:xmlns:text:1.0",
+    table: "urn:oasis:names:tc:opendocument:xmlns:table:1.0",
+    draw: "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0",
+    fo: "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0",
+    xlink: "http://www.w3.org/1999/xlink",
+    svg: "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0",
+    number: "urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0",
+    of: "urn:oasis:names:tc:opendocument:xmlns:of:1.2",
+    config: "urn:oasis:names:tc:opendocument:xmlns:config:1.0",
+    chart: "urn:oasis:names:tc:opendocument:xmlns:chart:1.0",
+    calcext: "urn:org:documentfoundation:names:experimental:calc:xmlns:calcext:1.0",
+    dc: "http://purl.org/dc/elements/1.1/",
+};
+const INVALID_XML_CHAR_REGEX = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g;
+const textEncoder = new TextEncoder();
+const encodeXml = (content) => textEncoder.encode(content);
+const sanitizeXmlText = (value) => {
+    if (!value)
+        return value;
+    return value.replace(INVALID_XML_CHAR_REGEX, "");
+};
+const escapeXml = (value) => sanitizeXmlText(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+const escapeXmlAddress = (value) => sanitizeXmlText(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+const pxToCm = (px) => (px * CM_PER_INCH) / PIXELS_PER_INCH;
+const DEFAULT_COLUMN_WIDTH_PX = 100;
+const DEFAULT_ROW_HEIGHT_PX = 21;
+class OdsStyleBuilder {
+    theme;
+    cellStyles = new Map();
+    usedStyleNames = new Set();
+    rowStyles = new Map();
+    columnStyles = new Map();
+    textStyles = new Map();
+    numberStyles = new Map();
+    styleXmlChunks = [];
+    numberXmlChunks = [];
+    // NEW: separate storage for conditional format styles (go to styles.xml)
+    conditionalStyleXmlChunks = [];
+    styleIndex = 1;
+    numberIndex = 1;
+    constructor(theme) {
+        this.theme = theme;
+    }
+    registerCell(format) {
+        if (!format)
+            return undefined;
+        const key = stableStringify(normalizeCellFormat(format));
+        const existing = this.cellStyles.get(key);
+        if (existing)
+            return existing;
+        return this.registerCellWithName(format, key);
+    }
+    registerRow(heightPx, hidden) {
+        if (!heightPx && !hidden)
+            return undefined;
+        const key = stableStringify({ heightPx, hidden });
+        const existing = this.rowStyles.get(key);
+        if (existing)
+            return existing;
+        const styleName = `ro${this.styleIndex++}`;
+        const styleXml = buildRowStyleXml(styleName, heightPx, hidden);
+        this.rowStyles.set(key, styleName);
+        this.styleXmlChunks.push(styleXml);
+        return styleName;
+    }
+    registerColumn(widthPx, hidden) {
+        if (!widthPx && !hidden)
+            return undefined;
+        const key = stableStringify({ widthPx, hidden });
+        const existing = this.columnStyles.get(key);
+        if (existing)
+            return existing;
+        const styleName = `co${this.styleIndex++}`;
+        const styleXml = buildColumnStyleXml(styleName, widthPx, hidden);
+        this.columnStyles.set(key, styleName);
+        this.styleXmlChunks.push(styleXml);
+        return styleName;
+    }
+    registerText(format) {
+        if (!format || Object.keys(format).length === 0)
+            return undefined;
+        const key = `text_${stableStringify(format)}`;
+        const existing = this.textStyles.get(key);
+        if (existing)
+            return existing;
+        const styleName = `T${this.styleIndex++}`;
+        const styleXml = buildTextStyleXml(styleName, format, this.theme);
+        this.textStyles.set(key, styleName);
+        this.styleXmlChunks.push(styleXml);
+        return styleName;
+    }
+    registerConditionalFormat(format, nameHint) {
+        if (!format)
+            return undefined;
+        const key = `cf_${stableStringify(normalizeCellFormat(format))}`;
+        const existing = this.cellStyles.get(key);
+        if (existing)
+            return existing;
+        const styleName = this.allocateStyleName(nameHint);
+        const styleXml = buildConditionalCellStyleXml(styleName, format, this.theme);
+        this.cellStyles.set(key, styleName);
+        // Store in separate array for styles.xml
+        this.conditionalStyleXmlChunks.push(styleXml);
+        return styleName;
+    }
+    registerNumberStyle(numberFormat) {
+        if (!numberFormat)
+            return undefined;
+        const key = stableStringify(numberFormat);
+        const existing = this.numberStyles.get(key);
+        if (existing)
+            return existing;
+        const styleName = `N${this.numberIndex++}`;
+        const xml = buildNumberStyleXml(styleName, numberFormat);
+        this.numberStyles.set(key, styleName);
+        this.numberXmlChunks.push(xml);
+        return styleName;
+    }
+    toAutomaticStylesXml() {
+        return `${this.numberXmlChunks.join("")}${this.styleXmlChunks.join("")}`;
+    }
+    // NEW: Get conditional styles for styles.xml
+    toConditionalStylesXml() {
+        return this.conditionalStyleXmlChunks.join("");
+    }
+    registerCellWithName(format, key, nameHint) {
+        const existing = this.cellStyles.get(key);
+        if (existing)
+            return existing;
+        const styleName = this.allocateStyleName(nameHint);
+        const numberStyleName = format.numberFormat
+            ? this.registerNumberStyle(format.numberFormat)
+            : undefined;
+        const styleXml = buildCellStyleXml(styleName, format, numberStyleName, this.theme);
+        this.cellStyles.set(key, styleName);
+        this.styleXmlChunks.push(styleXml);
+        return styleName;
+    }
+    allocateStyleName(nameHint) {
+        if (nameHint && !this.usedStyleNames.has(nameHint)) {
+            this.usedStyleNames.add(nameHint);
+            return nameHint;
+        }
+        let name = `ce${this.styleIndex++}`;
+        while (this.usedStyleNames.has(name)) {
+            name = `ce${this.styleIndex++}`;
+        }
+        this.usedStyleNames.add(name);
+        return name;
+    }
+}
+// NEW: Build style for conditional formatting (different parent)
+const buildConditionalCellStyleXml = (name, format, theme) => {
+    const textProps = [];
+    const cellProps = [];
+    const textFormat = format.textFormat ?? undefined;
+    if (textFormat?.bold) {
+        textProps.push(`fo:font-weight="bold"`);
+    }
+    if (textFormat?.italic) {
+        textProps.push(`fo:font-style="italic"`);
+    }
+    if (textFormat?.underline) {
+        textProps.push(`style:text-underline-style="solid"`);
+    }
+    if (textFormat?.strikethrough) {
+        textProps.push(`style:text-line-through-style="solid"`);
+    }
+    if (textFormat?.baselineOffset === "superscript") {
+        textProps.push(`style:text-position="super 58%"`);
+    }
+    else if (textFormat?.baselineOffset === "subscript") {
+        textProps.push(`style:text-position="sub 58%"`);
+    }
+    const textColor = normalizeColor(textFormat?.color ?? undefined, theme);
+    if (textColor) {
+        textProps.push(`fo:color="${textColor}"`);
+    }
+    const background = normalizeColor(format.backgroundColor ?? undefined, theme);
+    if (background) {
+        cellProps.push(`fo:background-color="${background}"`);
+    }
+    // Note: parent-style-name="Default" is crucial for LibreOffice to recognize it
+    return `<style:style style:name="${name}" style:family="table-cell" style:parent-style-name="Default"><style:table-cell-properties${cellProps.length ? " " + cellProps.join(" ") : ""}/><style:text-properties${textProps.length ? " " + textProps.join(" ") : ""}/></style:style>`;
+};
+export const createODSFile = async ({ conditionalFormats: _conditionalFormats, dataValidations: _dataValidations, sheets, sheetData, sharedStrings: sourceSharedStrings, tables: _tables = [], cellXfs, theme: _theme, embeds = [], charts = [], namedRanges = [], iterativeCalculationOptions, ignoreFormulaPatterns, citations, locale, }) => {
+    const sortedSheets = sortSheetsByIndex(sheets, true);
+    const styleBuilder = new OdsStyleBuilder(_theme ?? defaultSpreadsheetTheme);
+    const preparedTables = prepareTables(_tables ?? []);
+    const embedsBySheet = groupEmbedsBySheet(embeds ?? []);
+    const chartsBySheet = groupChartsBySheet(charts ?? []);
+    const namedRangeNames = new Set((namedRanges ?? [])
+        .map((range) => range.name)
+        .filter((name) => typeof name === "string" && isValidNamedRangeName(name))
+        .map((name) => name.toUpperCase()));
+    const sheetNameById = new Map();
+    sortedSheets.forEach((sheet, index) => {
+        sheetNameById.set(sheet.sheetId ?? index + 1, sheet.title ?? `Sheet${index + 1}`);
+    });
+    const dataValidationsById = _dataValidations?.reduce((acc, rule) => {
+        if (rule.id != null) {
+            acc[String(rule.id)] = rule;
+        }
+        return acc;
+    }, {}) ?? undefined;
+    const mediaEntries = [];
+    const sheetXmlEntries = [];
+    let chartObjectIndex = 1;
+    for (const sheet of sortedSheets) {
+        const rows = getRowsForSheet(sheetData, sheet.sheetId);
+        const sheetTables = preparedTables.filter((table) => table.sheetId === sheet.sheetId);
+        const sheetConditionalFormats = (_conditionalFormats ?? []).filter((rule) => rule.ranges?.some((range) => range.sheetId === sheet.sheetId));
+        const embedImages = embedsBySheet.get(sheet.sheetId) ?? [];
+        const sheetCharts = chartsBySheet.get(sheet.sheetId) ?? [];
+        const sheetName = sheetNameById.get(sheet.sheetId ?? 0) ?? sheet.title ?? "Sheet";
+        const sheetCitations = citations?.filter((citation) => citation.range.sheetId === sheet.sheetId);
+        const result = await buildWorksheetXml({
+            sheet,
+            sheetName,
+            rows,
+            sourceSharedStrings,
+            cellXfs,
+            styleBuilder,
+            tables: sheetTables,
+            conditionalFormats: sheetConditionalFormats,
+            dataValidationsById,
+            embeds: embedImages,
+            charts: sheetCharts,
+            mediaEntries,
+            namedRangeNames,
+            sheetNameById,
+            chartObjectIndex,
+            ignoreFormulaPatterns,
+            citations: sheetCitations,
+            sheetData,
+            sheets: sortedSheets,
+            locale,
+        });
+        chartObjectIndex = result.nextChartObjectIndex;
+        sheetXmlEntries.push({
+            xml: result.xml,
+            databaseRanges: result.databaseRanges,
+            chartObjects: result.chartObjects,
+        });
+    }
+    const validationEntries = buildAllDataValidationEntries(_dataValidations ?? [], sheetNameById);
+    const contentValidationsXml = validationEntries.length
+        ? `<table:content-validations>${validationEntries.join("")}</table:content-validations>`
+        : "";
+    const calculationSettingsXml = buildCalculationSettingsXml(iterativeCalculationOptions);
+    const contentXml = buildContentXml({
+        sheetsXml: sheetXmlEntries.map((entry) => entry.xml).join(""),
+        databaseRangesXml: buildDatabaseRangesXml(sheetXmlEntries.flatMap((entry) => entry.databaseRanges)),
+        namedRangesXml: buildNamedRangesXml(namedRanges, sheetNameById, namedRangeNames),
+        contentValidationsXml,
+        automaticStylesXml: styleBuilder.toAutomaticStylesXml(),
+        calculationSettingsXml,
+    });
+    const stylesXml = buildStylesXml(styleBuilder.toConditionalStylesXml());
+    const metaXml = buildMetaXml();
+    const settingsXml = buildSettingsXml(sortedSheets, _theme ?? defaultSpreadsheetTheme);
+    const chartObjects = sheetXmlEntries.flatMap((entry) => entry.chartObjects);
+    const manifestXml = buildManifestXml(mediaEntries, chartObjects, Boolean(settingsXml));
+    const files = {
+        "content.xml": encodeXml(contentXml),
+        "styles.xml": encodeXml(stylesXml),
+        "meta.xml": encodeXml(metaXml),
+        "META-INF/manifest.xml": encodeXml(manifestXml),
+    };
+    if (settingsXml) {
+        files["settings.xml"] = encodeXml(settingsXml);
+    }
+    for (const chartObject of chartObjects) {
+        files[`${chartObject.folder}/content.xml`] = encodeXml(chartObject.contentXml);
+    }
+    for (const entry of mediaEntries) {
+        files[entry.path] = entry.data;
+    }
+    const orderedEntries = [
+        { name: "mimetype", data: new TextEncoder().encode(ODS_MIMETYPE) },
+        ...Object.entries(files).map(([name, data]) => ({ name, data })),
+    ];
+    return buildZipStore(orderedEntries);
+};
+const getRowsForSheet = (sheetData, sheetId) => {
+    return (sheetData[sheetId] ??
+        sheetData[String(sheetId)] ??
+        sheetData[Number(sheetId)] ??
+        []);
+};
+const buildWorksheetXml = async ({ sheet, sheetName, rows, sourceSharedStrings, cellXfs, styleBuilder, tables, conditionalFormats, dataValidationsById, embeds, charts, mediaEntries, namedRangeNames, sheetNameById, chartObjectIndex, ignoreFormulaPatterns, citations, sheetData, sheets, locale, }) => {
+    const bounds = {
+        minRow: Number.POSITIVE_INFINITY,
+        maxRow: 0,
+        minColumn: Number.POSITIVE_INFINITY,
+        maxColumn: 0,
+    };
+    const rowMetadata = sheet.rowMetadata ?? [];
+    const maxRows = Math.max(rows.length, rowMetadata.length);
+    const rowXmlEntries = [];
+    const mergeState = buildMergeState(sheet.merges ?? []);
+    // Build annotations map from citations
+    const annotationsMap = new Map();
+    if (citations) {
+        for (const citation of citations) {
+            // Citation ranges are worksheet-based (1-based).
+            for (let rowIndex = citation.range.startRowIndex; rowIndex <= citation.range.endRowIndex; rowIndex++) {
+                for (let colIndex = citation.range.startColumnIndex; colIndex <= citation.range.endColumnIndex; colIndex++) {
+                    const address = cellToAddress({ rowIndex, columnIndex: colIndex });
+                    if (address) {
+                        annotationsMap.set(address, {
+                            text: citation.citation_string,
+                            author: citation.created_by || "System",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    const conditionalFormattingXml = conditionalFormats.length
+        ? buildConditionalFormattingXml({
+            sheetName,
+            conditionalFormats,
+            styleBuilder,
+            namedRangeNames,
+        })
+        : "";
+    // Collect row data for sparkline detection
+    const rowDataMap = {};
+    for (let rowIndex = 1; rowIndex < maxRows; rowIndex++) {
+        const row = rows[rowIndex];
+        const metadata = rowMetadata[rowIndex];
+        const rowXml = await buildWorksheetRow({
+            rowNumber: rowIndex,
+            row,
+            rowMetadata: metadata,
+            sourceSharedStrings,
+            cellXfs,
+            styleBuilder,
+            mergeState,
+            dataValidationsById,
+            mediaEntries,
+            sheet,
+            namedRangeNames,
+            tables,
+            ignoreFormulaPatterns,
+            annotationsMap,
+            sheetData,
+            sheets,
+            locale,
+        });
+        rowXmlEntries.push(rowXml);
+        // Collect row data for sparkline detection
+        if (row?.values) {
+            const rowValues = {};
+            for (const [colIndex, cell] of Object.entries(row.values)) {
+                if (cell) {
+                    rowValues[parseInt(colIndex, 10)] = cell;
+                }
+            }
+            if (Object.keys(rowValues).length > 0) {
+                rowDataMap[rowIndex] = rowValues;
+            }
+        }
+        if (!rowXml)
+            continue;
+        if (rowXml.minColumn) {
+            bounds.minColumn = Math.min(bounds.minColumn, rowXml.minColumn);
+        }
+        if (rowXml.maxColumn) {
+            bounds.maxColumn = Math.max(bounds.maxColumn, rowXml.maxColumn);
+        }
+        bounds.minRow = Math.min(bounds.minRow, rowIndex);
+        bounds.maxRow = Math.max(bounds.maxRow, rowIndex);
+    }
+    updateBoundsForMerges(bounds, mergeState);
+    // Row entries are 0-based here but the rowMetadata is 1-indexed:
+    // rowXmlEntries[0] is row 1, rowXmlEntries[i] is row i + 1.
+    const maxRowIndex = rowXmlEntries.length;
+    const summaryBelow = sheet.outlinePr?.summaryBelow !== false;
+    const rowSpans = findOutlineGroupSpans(rowMetadata, maxRowIndex, summaryBelow);
+    const { opensAt: rowOpensAt, closesAt: rowClosesAt } = buildOutlineGroupIndex(rowSpans);
+    const rowXmlChunks = [];
+    for (let index = 0; index < rowXmlEntries.length; index++) {
+        const rowIndex = index + 1;
+        for (const span of rowOpensAt.get(rowIndex) ?? []) {
+            rowXmlChunks.push(outlineGroupOpenTag(span, "table:table-row-group"));
+        }
+        const entry = rowXmlEntries[index];
+        if (entry) {
+            rowXmlChunks.push(entry.xml);
+        }
+        else {
+            // Aggregate consecutive empty rows into `number-rows-repeated`, but
+            // never cross a group boundary or include a row that any group
+            // opens/closes at — that would put a row inside the wrong wrapper.
+            let repeat = 1;
+            while (index + repeat < rowXmlEntries.length &&
+                !rowXmlEntries[index + repeat]) {
+                const nextRowIndex = index + repeat + 1;
+                if (rowOpensAt.has(nextRowIndex) || rowClosesAt.has(nextRowIndex - 1)) {
+                    break;
+                }
+                repeat += 1;
+            }
+            rowXmlChunks.push(repeat > 1
+                ? `<table:table-row table:number-rows-repeated="${repeat}"/>`
+                : `<table:table-row/>`);
+            // The break condition keeps closes from landing on any row except
+            // the last in the repetition, so we only need to emit them once.
+            const lastInRepeat = rowIndex + repeat - 1;
+            for (const _ of rowClosesAt.get(lastInRepeat) ?? []) {
+                rowXmlChunks.push(`</table:table-row-group>`);
+            }
+            index += repeat - 1;
+            continue;
+        }
+        for (const _ of rowClosesAt.get(rowIndex) ?? []) {
+            rowXmlChunks.push(`</table:table-row-group>`);
+        }
+    }
+    const embedFrames = embeds.length
+        ? await buildEmbedFramesXml({
+            embeds,
+            mediaEntries,
+            sheetName,
+            sheet,
+        })
+        : [];
+    const chartFramesResult = charts.length
+        ? await buildChartFramesXml({
+            charts,
+            sheet,
+            sheetName,
+            sheetNameById,
+            startIndex: chartObjectIndex,
+        })
+        : { frames: [], chartObjects: [], nextIndex: chartObjectIndex };
+    const shapesXml = embedFrames.length || chartFramesResult.frames.length
+        ? `<table:shapes>${[...embedFrames, ...chartFramesResult.frames].join("")}</table:shapes>`
+        : "";
+    const columnsXml = buildColumnsXml(sheet, styleBuilder, bounds);
+    // Build sparkline XML from SPARKLINE formulas
+    const sparklineXml = buildOdsSparklineGroupsXml(sheet, sheetName, rowDataMap) ?? "";
+    const sheetXml = `<table:table table:name="${escapeXml(sheetName)}">${shapesXml}${columnsXml}${rowXmlChunks.join("")}${conditionalFormattingXml}${sparklineXml}</table:table>`;
+    return {
+        xml: sheetXml,
+        databaseRanges: buildDatabaseRangeEntries(tables, sheetName, sheet, rows),
+        chartObjects: chartFramesResult.chartObjects,
+        nextChartObjectIndex: chartFramesResult.nextIndex,
+    };
+};
+const buildWorksheetRow = async ({ rowNumber, row, rowMetadata, sourceSharedStrings, cellXfs, styleBuilder, mergeState, dataValidationsById, mediaEntries, sheet, namedRangeNames, tables, ignoreFormulaPatterns, annotationsMap, sheetData, sheets, locale, }) => {
+    const values = row?.values ?? [];
+    const cellXmlChunks = [];
+    let minColumn = Number.POSITIVE_INFINITY;
+    let maxColumn = 0;
+    const hasHiddenFlag = Boolean(rowMetadata?.hiddenByUser || rowMetadata?.hiddenByFilter);
+    const defaultRowHeightPx = getDefaultRowHeightPx(sheet);
+    const rowSize = rowMetadata?.size && rowMetadata.size > 0 ? rowMetadata.size : undefined;
+    const hasExplicitHeight = Boolean(rowSize && Math.abs(rowSize - defaultRowHeightPx) > 0.01);
+    const hasCustomHeight = Boolean(rowSize && rowMetadata?.resizedByUser);
+    const rowStyle = styleBuilder.registerRow(rowSize && (hasExplicitHeight || hasCustomHeight) ? rowSize : undefined, hasHiddenFlag);
+    const maxColumnIndex = Math.max(values.length - 1, mergeState.maxColumnByRow.get(rowNumber) ?? 0);
+    for (let columnIndex = 1; columnIndex <= maxColumnIndex; columnIndex++) {
+        if (mergeState.coveredCells.has(`${rowNumber}:${columnIndex}`)) {
+            cellXmlChunks.push(`<table:covered-table-cell/>`);
+            continue;
+        }
+        const cell = values[columnIndex];
+        const mergeSpan = mergeState.anchorSpans.get(`${rowNumber}:${columnIndex}`);
+        const cellXml = await buildCellXml({
+            rowNumber,
+            columnIndex,
+            cell,
+            sourceSharedStrings,
+            cellXfs,
+            styleBuilder,
+            dataValidationsById,
+            mergeSpan,
+            mediaEntries,
+            sheet,
+            namedRangeNames,
+            tables,
+            ignoreFormulaPatterns,
+            annotationsMap,
+            sheetData,
+            sheets,
+            locale,
+        });
+        if (!cellXml) {
+            cellXmlChunks.push(`<table:table-cell/>`);
+            continue;
+        }
+        cellXmlChunks.push(cellXml);
+        minColumn = Math.min(minColumn, columnIndex);
+        maxColumn = Math.max(maxColumn, columnIndex);
+    }
+    const hasCells = cellXmlChunks.length > 0;
+    const needsMetadata = hasHiddenFlag || hasExplicitHeight || hasCustomHeight;
+    if (!hasCells && !needsMetadata) {
+        return null;
+    }
+    const attrs = [];
+    if (rowStyle) {
+        attrs.push(`table:style-name="${rowStyle}"`);
+    }
+    const rowXml = `<table:table-row${attrs.length ? " " + attrs.join(" ") : ""}>${cellXmlChunks.join("")}</table:table-row>`;
+    return {
+        xml: rowXml,
+        minColumn: isFinite(minColumn) ? minColumn : undefined,
+        maxColumn: maxColumn || undefined,
+    };
+};
+const buildCellXml = async ({ rowNumber, columnIndex, cell, sourceSharedStrings, cellXfs, styleBuilder, dataValidationsById, mergeSpan, mediaEntries, sheet, namedRangeNames, tables, ignoreFormulaPatterns, annotationsMap, sheetData, sheets, locale, }) => {
+    const normalizedCell = cell;
+    const userEnteredValue = getCellUserEnteredValue(normalizedCell);
+    const effectiveValue = getCellEffectiveValue(normalizedCell) ?? userEnteredValue;
+    // Match Excel's model: only the user-entered format is serialized.
+    // Auto-derived alignment / pattern color / formula precedent format are
+    // recomputed at render time. Legacy `ef` is read as a fallback so old
+    // files still export with the formatting they originally had.
+    const resolveStyleRef = (fmt) => {
+        if (!fmt)
+            return undefined;
+        if (isStyleReference(fmt)) {
+            const styleId = fmt.sid ?? fmt.styleId;
+            return styleId ? cellXfs?.get(styleId) : undefined;
+        }
+        return fmt;
+    };
+    let effectiveFormat = resolveStyleRef(getCellUserEnteredFormat(normalizedCell)) ??
+        resolveStyleRef(getCellEffectiveFormat(normalizedCell));
+    let formattedValue = getCellFormattedValue(normalizedCell);
+    let richTextRuns;
+    // The data-validation Invalid marker is UI-only and must never export as
+    // a real error cell — strip it so the cell's underlying value exports.
+    const valueSource = omitInvalidDataValidationError(effectiveValue) ??
+        omitInvalidDataValidationError(userEnteredValue);
+    const numberValue = getExtendedValueNumber(valueSource);
+    const boolValue = getExtendedValueBool(valueSource);
+    const rawFormulaValue = getExtendedValueFormula(userEnteredValue);
+    const formulaValue = shouldIgnoreFormula(rawFormulaValue, ignoreFormulaPatterns)
+        ? undefined
+        : rawFormulaValue;
+    const errorValue = getExtendedValueError(valueSource);
+    let stringValue = getExtendedValueString(valueSource);
+    const sharedStringIndex = normalizedCell?.ss;
+    const sharedStringValue = sharedStringIndex != null && sourceSharedStrings
+        ? sourceSharedStrings.get(String(sharedStringIndex))
+        : null;
+    if (sharedStringValue != null) {
+        stringValue =
+            typeof sharedStringValue === "string"
+                ? sharedStringValue
+                : sharedStringValue.text ?? "";
+        richTextRuns =
+            typeof sharedStringValue === "object" &&
+                Array.isArray(sharedStringValue.runs)
+                ? (sharedStringValue.runs)
+                : undefined;
+        formattedValue = undefined;
+    }
+    const isDateLike = effectiveFormat?.numberFormat?.type === "DATE" ||
+        effectiveFormat?.numberFormat?.type === "DATE_TIME";
+    if (isDateLike && formattedValue) {
+        stringValue = formattedValue;
+    }
+    if (formulaValue &&
+        (stringValue != null || formattedValue != null) &&
+        stringValue == null) {
+        stringValue = String(formattedValue ?? "");
+    }
+    const hasExplicitValue = !isNil(numberValue) ||
+        !isNil(boolValue) ||
+        !isNil(formulaValue) ||
+        !isNil(errorValue) ||
+        stringValue != null;
+    if (!hasExplicitValue && formattedValue === "") {
+        formattedValue = undefined;
+    }
+    // For formula cells with no explicit number format, derive the format
+    // from precedents (same logic as the renderer) so ODS consumers see the
+    // value with its inherited format without requiring a recalc.
+    let formatForExport = effectiveFormat;
+    if (formulaValue &&
+        !formatForExport?.numberFormat &&
+        sheetData &&
+        sheets &&
+        sheet?.sheetId != null) {
+        const sheetIdByName = new Map();
+        for (const s of sheets) {
+            if (s?.title)
+                sheetIdByName.set(s.title, s.sheetId);
+        }
+        // A real CellXfsRegistry so the derive helper can resolve precedent
+        // cells whose `uf` is a `{ sid }` style reference.
+        const cellXfsRegistry = cellXfs ? new CellXfsRegistry(cellXfs) : undefined;
+        const derived = deriveEffectiveNumberFormatFromFormula(formulaValue, sheet.sheetId, rowNumber, columnIndex, sheetData, (input) => defaultTokenizer(input), (name) => sheetIdByName.get(name) ?? sheet.sheetId, locale, cellXfsRegistry, undefined, typeof numberValue === "number" ? numberValue : null) ?? undefined;
+        if (derived) {
+            formatForExport = {
+                ...(formatForExport ?? {}),
+                numberFormat: derived,
+            };
+        }
+    }
+    const cellStyle = styleBuilder.registerCell(formatForExport);
+    const address = cellToAddress({
+        rowIndex: rowNumber,
+        columnIndex,
+    });
+    if (!address)
+        return undefined;
+    const validationRule = resolveCellDataValidation(normalizedCell, dataValidationsById);
+    const validationId = validationRule?.id != null ? String(validationRule.id) : "";
+    const validationAttr = validationId
+        ? ` table:content-validation-name="${escapeXml(validationId)}"`
+        : "";
+    const attrs = [];
+    if (cellStyle) {
+        attrs.push(`table:style-name="${cellStyle}"`);
+    }
+    if (mergeSpan) {
+        if (mergeSpan.columns > 1) {
+            attrs.push(`table:number-columns-spanned="${mergeSpan.columns}"`);
+        }
+        if (mergeSpan.rows > 1) {
+            attrs.push(`table:number-rows-spanned="${mergeSpan.rows}"`);
+        }
+    }
+    let valueAttr = "";
+    let textNode = "";
+    if (errorValue) {
+        const errorText = typeof errorValue === "string"
+            ? errorValue
+            : errorValue?.type || errorValue?.message || "#VALUE!";
+        valueAttr = ` office:value-type="string" office:string-value="${escapeXml(errorText)}"`;
+        textNode = `<text:p>${escapeXml(errorText)}</text:p>`;
+    }
+    else if (!isNil(numberValue)) {
+        valueAttr = ` office:value-type="float" office:value="${numberValue}"`;
+        if (stringValue != null) {
+            textNode = `<text:p>${escapeXml(String(stringValue))}</text:p>`;
+        }
+    }
+    else if (!isNil(boolValue)) {
+        valueAttr = ` office:value-type="boolean" office:boolean-value="${boolValue ? "true" : "false"}"`;
+    }
+    else if (stringValue != null || formattedValue != null) {
+        const text = stringValue ?? formattedValue;
+        if (text == null)
+            return undefined;
+        valueAttr = ` office:value-type="string" office:string-value="${escapeXml(String(text))}"`;
+        textNode = buildRichTextParagraph(String(text), richTextRuns, styleBuilder);
+    }
+    if (formulaValue) {
+        const resolvedFormula = resolveStructuredReferencesForOds(formulaValue, tables, rowNumber, columnIndex);
+        // If formula contains property references (e.g., =A1.propertyName),
+        // skip exporting unsupported formula and use formatted value instead
+        if (!hasPropertyReference(resolvedFormula)) {
+            const formulaAttr = ` table:formula="${escapeXml(toOdsFormula(resolvedFormula, namedRangeNames))}"`;
+            if (!valueAttr) {
+                valueAttr = ` office:value-type="string" office:string-value=""`;
+            }
+            valueAttr = `${formulaAttr}${valueAttr}`;
+            // Array formula anchor: emit ODF matrix-spanned attributes derived
+            // from the A1 spill ref. Spilled cells in the matrix carry no `ue`
+            // formula and are emitted as ordinary cells with their cached values.
+            const arrayRef = normalizedCell?.af;
+            if (arrayRef) {
+                const spill = addressToSelection(arrayRef);
+                if (spill) {
+                    const cols = spill.range.endColumnIndex - spill.range.startColumnIndex + 1;
+                    const rows = spill.range.endRowIndex - spill.range.startRowIndex + 1;
+                    if (cols > 0) {
+                        attrs.push(`table:number-matrix-columns-spanned="${cols}"`);
+                    }
+                    if (rows > 0) {
+                        attrs.push(`table:number-matrix-rows-spanned="${rows}"`);
+                    }
+                }
+            }
+        }
+    }
+    const hyperlinkValue = normalizeHyperlinkValue(normalizedCell?.hyperlink);
+    if (hyperlinkValue) {
+        const href = normalizeOdsHyperlinkHref(hyperlinkValue);
+        const display = hyperlinkValue.display ?? stringValue ?? formattedValue ?? "";
+        if (!valueAttr) {
+            valueAttr = ` office:value-type="string" office:string-value="${escapeXml(String(display ?? ""))}"`;
+        }
+        textNode = `<text:p><text:a xlink:href="${escapeXml(href)}" xlink:type="simple">${escapeXml(String(display ?? ""))}</text:a></text:p>`;
+    }
+    const imageXml = await buildCellImageXml({
+        imageUrl: normalizedCell?.imageUrl,
+        rowNumber,
+        columnIndex,
+        mergeSpan,
+        sheet,
+        mediaEntries,
+    });
+    // Build annotation XML if this cell has a citation
+    let annotationXml = "";
+    if (annotationsMap && address) {
+        const annotation = annotationsMap.get(address);
+        if (annotation) {
+            const now = new Date().toISOString();
+            annotationXml = `<office:annotation><dc:creator>${escapeXml(annotation.author)}</dc:creator><dc:date>${now}</dc:date><text:p>${escapeXml(annotation.text)}</text:p></office:annotation>`;
+        }
+    }
+    if (!valueAttr && !cellStyle && !textNode && !imageXml && !annotationXml) {
+        return undefined;
+    }
+    return `<table:table-cell${valueAttr}${validationAttr}${attrs.length ? " " + attrs.join(" ") : ""}>${annotationXml}${textNode}${imageXml}</table:table-cell>`;
+};
+const normalizeHyperlinkValue = (hyperlink) => {
+    if (!hyperlink) {
+        return undefined;
+    }
+    if (typeof hyperlink === "string") {
+        return { kind: "external", url: hyperlink };
+    }
+    return hyperlink;
+};
+const normalizeOdsHyperlinkHref = (hyperlink) => {
+    if (hyperlink.kind === "external") {
+        return hyperlink.url;
+    }
+    let location = hyperlink.location.trim();
+    if (location.startsWith("#")) {
+        location = location.slice(1);
+    }
+    if (location.includes("!")) {
+        location = location.replace("!", ".");
+    }
+    return `#${location}`;
+};
+const shouldIgnoreFormula = (formula, patterns) => {
+    if (!formula)
+        return false;
+    // Always ignore SPARKLINE formulas - they're exported as native ODS sparklines
+    if (formula.toUpperCase().startsWith("=SPARKLINE(")) {
+        return true;
+    }
+    if (!patterns)
+        return false;
+    const normalized = formula.startsWith("=") ? formula.slice(1) : formula;
+    const list = Array.isArray(patterns) ? patterns : [patterns];
+    return list.some((pattern) => pattern.test(formula) || pattern.test(normalized));
+};
+const hasPropertyReference = (formula) => {
+    if (!formula)
+        return false;
+    // Detects cell references with property access: A1.property, $A$1.nested.value, etc.
+    const propertyReferencePattern = /[$]?[A-Za-z]{1,3}[$]?[1-9][0-9]*\./;
+    return propertyReferencePattern.test(formula);
+};
+const resolveStructuredReferencesForOds = (formula, tables, rowNumber, columnIndex) => {
+    if (!formula || !tables.length)
+        return formula;
+    const stringRegex = /"([^"]|"")*"/g;
+    let result = "";
+    let lastIndex = 0;
+    let match;
+    while ((match = stringRegex.exec(formula)) !== null) {
+        const before = formula.slice(lastIndex, match.index);
+        result += resolveStructuredRefsInSegment(before, tables, rowNumber, columnIndex);
+        result += match[0];
+        lastIndex = match.index + match[0].length;
+    }
+    result += resolveStructuredRefsInSegment(formula.slice(lastIndex), tables, rowNumber, columnIndex);
+    return result;
+};
+const resolveStructuredRefsInSegment = (segment, tables, rowNumber, columnIndex) => {
+    if (!segment)
+        return segment;
+    let normalized = segment;
+    const tableForCell = findTableForCell(tables, rowNumber, columnIndex);
+    for (const table of tables) {
+        if (!table.columns?.length)
+            continue;
+        if (!isRowInTableDataRange(table, rowNumber))
+            continue;
+        const nameVariants = getTableNameVariants(table);
+        for (let idx = 0; idx < table.columns.length; idx++) {
+            const columnName = table.columns[idx]?.name;
+            if (!columnName)
+                continue;
+            const columnIndex = table.range.startColumnIndex + idx;
+            const cellRef = `${columnIndexToLetter(columnIndex)}${rowNumber}`;
+            const escapedColumn = escapeCharacters(columnName);
+            if (!escapedColumn)
+                continue;
+            for (const tableName of nameVariants) {
+                const escapedTable = escapeCharacters(tableName);
+                if (!escapedTable)
+                    continue;
+                const patterns = [
+                    `${escapedTable}\\[\\[#This Row\\],\\[${escapedColumn}\\]\\]`,
+                    `${escapedTable}\\[\\@\\[${escapedColumn}\\]\\]`,
+                    `${escapedTable}\\[\\@${escapedColumn}\\]`,
+                ];
+                for (const pattern of patterns) {
+                    normalized = normalized.replace(new RegExp(pattern, "g"), cellRef);
+                }
+            }
+            if (tableForCell?.id !== table.id) {
+                continue;
+            }
+            const unqualifiedPatterns = [
+                `\\[\\[#This Row\\],\\[${escapedColumn}\\]\\]`,
+                `\\[\\@\\[${escapedColumn}\\]\\]`,
+                `\\[\\@${escapedColumn}\\]`,
+            ];
+            for (const pattern of unqualifiedPatterns) {
+                normalized = normalized.replace(new RegExp(pattern, "g"), cellRef);
+            }
+        }
+    }
+    return normalized;
+};
+const getTableNameVariants = (table) => {
+    const names = new Set();
+    if (table.name)
+        names.add(table.name);
+    if (table.title)
+        names.add(table.title);
+    return Array.from(names);
+};
+const isRowInTableDataRange = (table, rowNumber) => {
+    const headerOffset = table.headerRow === false ? 0 : 1;
+    const totalOffset = table.totalRow ? 1 : 0;
+    const start = table.range.startRowIndex + headerOffset;
+    const end = table.range.endRowIndex - totalOffset;
+    return rowNumber >= start && rowNumber <= end;
+};
+const findTableForCell = (tables, rowNumber, columnIndex) => {
+    return tables.find((table) => {
+        const range = table.range;
+        return (rowNumber >= range.startRowIndex &&
+            rowNumber <= range.endRowIndex &&
+            columnIndex >= range.startColumnIndex &&
+            columnIndex <= range.endColumnIndex);
+    });
+};
+const toOdsFormula = (formula, namedRangeNames) => {
+    const trimmed = formula.startsWith("=") ? formula.slice(1) : formula;
+    const converted = convertExcelFormulaToOds(trimmed, namedRangeNames);
+    return `of:=${sanitizeXmlText(converted)}`;
+};
+const buildCalculationSettingsXml = (iterativeCalculationOptions) => {
+    if (!iterativeCalculationOptions)
+        return "";
+    const attrs = [
+        `table:use-iteration="${iterativeCalculationOptions.enabled ? "true" : "false"}"`,
+    ];
+    if (typeof iterativeCalculationOptions.maxIterations === "number") {
+        attrs.push(`table:iteration-count="${Math.max(0, Math.floor(iterativeCalculationOptions.maxIterations))}"`);
+    }
+    if (typeof iterativeCalculationOptions.maxChange === "number") {
+        attrs.push(`table:minimum-step="${iterativeCalculationOptions.maxChange}"`);
+    }
+    return `<table:calculation-settings ${attrs.join(" ")}/>`;
+};
+const buildContentXml = ({ sheetsXml, databaseRangesXml, namedRangesXml, contentValidationsXml, automaticStylesXml, calculationSettingsXml, }) => {
+    return `${XML_DECLARATION}<office:document-content xmlns:office="${ODS_NS.office}" xmlns:style="${ODS_NS.style}" xmlns:text="${ODS_NS.text}" xmlns:table="${ODS_NS.table}" xmlns:draw="${ODS_NS.draw}" xmlns:fo="${ODS_NS.fo}" xmlns:xlink="${ODS_NS.xlink}" xmlns:svg="${ODS_NS.svg}" xmlns:number="${ODS_NS.number}" xmlns:of="${ODS_NS.of}" xmlns:calcext="${ODS_NS.calcext}" xmlns:dc="${ODS_NS.dc}" office:version="1.2"><office:scripts/><office:automatic-styles>${automaticStylesXml}</office:automatic-styles><office:body><office:spreadsheet>${calculationSettingsXml}${contentValidationsXml}${sheetsXml}${namedRangesXml}${databaseRangesXml}</office:spreadsheet></office:body></office:document-content>`;
+};
+const buildStylesXml = (conditionalStylesXml = "") => {
+    return `${XML_DECLARATION}<office:document-styles xmlns:office="${ODS_NS.office}" xmlns:style="${ODS_NS.style}" xmlns:text="${ODS_NS.text}" xmlns:table="${ODS_NS.table}" xmlns:draw="${ODS_NS.draw}" xmlns:fo="${ODS_NS.fo}" xmlns:xlink="${ODS_NS.xlink}" xmlns:svg="${ODS_NS.svg}" xmlns:number="${ODS_NS.number}" office:version="1.2"><office:styles><style:style style:name="Default" style:family="table-cell"><style:paragraph-properties fo:margin-left="0cm" fo:margin-right="0cm"/></style:style>${conditionalStylesXml}</office:styles><office:automatic-styles/><office:master-styles/></office:document-styles>`;
+};
+const buildMetaXml = () => {
+    const now = new Date().toISOString();
+    return `${XML_DECLARATION}<office:document-meta xmlns:office="${ODS_NS.office}" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:dc="http://purl.org/dc/elements/1.1/" office:version="1.2"><office:meta><dc:creator>${CREATOR}</dc:creator><meta:creation-date>${now}</meta:creation-date></office:meta></office:document-meta>`;
+};
+const buildSettingsXml = (sheets, theme) => {
+    const entries = sheets
+        .map((sheet, index) => {
+        const name = sheet.title ?? `Sheet${index + 1}`;
+        const frozenRows = sheet.frozenRowCount ?? 0;
+        const frozenColumns = sheet.frozenColumnCount ?? 0;
+        const showGrid = sheet.showGridLines ?? true;
+        const tabColor = normalizeColor(sheet.tabColor ?? undefined, theme);
+        const freezeCell = buildFreezeCell(frozenRows, frozenColumns);
+        const items = [];
+        if (!showGrid) {
+            items.push(`<config:config-item config:name="ShowGrid" config:type="boolean">false</config:config-item>`);
+        }
+        if (freezeCell) {
+            items.push(`<config:config-item config:name="FreezeCell" config:type="string">${freezeCell}</config:config-item>`);
+        }
+        if (typeof frozenRows === "number" && frozenRows > 0) {
+            items.push(`<config:config-item config:name="VerticalSplitPosition" config:type="int">${frozenRows}</config:config-item>`);
+        }
+        if (typeof frozenColumns === "number" && frozenColumns > 0) {
+            items.push(`<config:config-item config:name="HorizontalSplitPosition" config:type="int">${frozenColumns}</config:config-item>`);
+        }
+        if (tabColor) {
+            items.push(`<config:config-item config:name="TabColor" config:type="string">${tabColor}</config:config-item>`);
+        }
+        if (!items.length) {
+            return undefined;
+        }
+        return `<config:config-item-map-entry config:name="${escapeXml(name)}">${items.join("")}</config:config-item-map-entry>`;
+    })
+        .filter((entry) => Boolean(entry));
+    if (!entries.length) {
+        return undefined;
+    }
+    return `${XML_DECLARATION}<office:document-settings xmlns:office="${ODS_NS.office}" xmlns:config="${ODS_NS.config}" office:version="1.2"><office:settings><config:config-item-set config:name="ooo:view-settings"><config:config-item-map-indexed config:name="Tables">${entries.join("")}</config:config-item-map-indexed></config:config-item-set></office:settings></office:document-settings>`;
+};
+const buildManifestXml = (mediaEntries, chartObjects, includeSettings) => {
+    const mediaItems = mediaEntries
+        .map((entry) => `<manifest:file-entry manifest:media-type="${entry.mime}" manifest:full-path="${entry.path}"/>`)
+        .join("");
+    const chartEntries = chartObjects
+        .map((entry) => `<manifest:file-entry manifest:media-type="application/vnd.oasis.opendocument.chart" manifest:full-path="${entry.folder}"/><manifest:file-entry manifest:media-type="text/xml" manifest:full-path="${entry.folder}/content.xml"/>`)
+        .join("");
+    const settingsEntry = includeSettings
+        ? `<manifest:file-entry manifest:media-type="text/xml" manifest:full-path="settings.xml"/>`
+        : "";
+    return `${XML_DECLARATION}<manifest:manifest xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0" manifest:version="1.2"><manifest:file-entry manifest:media-type="${ODS_MIMETYPE}" manifest:full-path="/"/><manifest:file-entry manifest:media-type="text/xml" manifest:full-path="content.xml"/><manifest:file-entry manifest:media-type="text/xml" manifest:full-path="styles.xml"/><manifest:file-entry manifest:media-type="text/xml" manifest:full-path="meta.xml"/>${settingsEntry}${mediaItems}${chartEntries}</manifest:manifest>`;
+};
+const buildFreezeCell = (rows, columns) => {
+    if (!rows && !columns)
+        return undefined;
+    const col = columnIndexToLetter(Math.max(1, columns + 1));
+    const row = Math.max(1, rows + 1);
+    return `${col}${row}`;
+};
+const buildColumnsXml = (sheet, styleBuilder, bounds) => {
+    const metadata = sheet.columnMetadata ?? [];
+    const maxColumns = Math.max(metadata.length - 1, bounds.maxColumn || 0);
+    if (!maxColumns)
+        return "";
+    const summaryRight = sheet.outlinePr?.summaryRight !== false;
+    const spans = findOutlineGroupSpans(metadata, maxColumns, summaryRight);
+    const { opensAt, closesAt } = buildOutlineGroupIndex(spans);
+    const parts = [];
+    for (let index = 1; index <= maxColumns; index++) {
+        for (const span of opensAt.get(index) ?? []) {
+            parts.push(outlineGroupOpenTag(span, "table:table-column-group"));
+        }
+        const props = metadata[index];
+        const widthPx = getColumnWidthPx(sheet, index);
+        const hidden = Boolean(props?.hiddenByUser || props?.hiddenByFilter);
+        const styleName = styleBuilder.registerColumn(widthPx, hidden);
+        const attrs = [];
+        if (styleName) {
+            attrs.push(`table:style-name="${styleName}"`);
+        }
+        parts.push(`<table:table-column${attrs.length ? " " + attrs.join(" ") : ""}/>`);
+        for (const _ of closesAt.get(index) ?? []) {
+            parts.push(`</table:table-column-group>`);
+        }
+    }
+    return parts.join("");
+};
+const buildCellStyleXml = (name, format, numberStyleName, theme) => {
+    const textProps = [];
+    const paragraphProps = [];
+    const cellProps = [];
+    const textFormat = format.textFormat ?? undefined;
+    if (textFormat?.bold) {
+        textProps.push(`fo:font-weight="bold"`);
+    }
+    if (textFormat?.italic) {
+        textProps.push(`fo:font-style="italic"`);
+    }
+    if (textFormat?.underline) {
+        textProps.push(`style:text-underline-style="solid"`);
+    }
+    if (textFormat?.strikethrough) {
+        textProps.push(`style:text-line-through-style="solid"`);
+    }
+    if (textFormat?.baselineOffset === "superscript") {
+        textProps.push(`style:text-position="super 58%"`);
+    }
+    else if (textFormat?.baselineOffset === "subscript") {
+        textProps.push(`style:text-position="sub 58%"`);
+    }
+    if (textFormat?.fontFamily) {
+        textProps.push(`fo:font-family="${escapeXml(textFormat.fontFamily)}"`);
+    }
+    if (textFormat?.fontSize) {
+        textProps.push(`fo:font-size="${textFormat.fontSize}pt"`);
+    }
+    const textColor = normalizeColor(textFormat?.color ?? undefined, theme);
+    if (textColor) {
+        textProps.push(`fo:color="${textColor}"`);
+    }
+    if (format.horizontalAlignment) {
+        paragraphProps.push(`fo:text-align="${format.horizontalAlignment}"`);
+    }
+    if (format.verticalAlignment) {
+        paragraphProps.push(`style:vertical-align="${mapVerticalAlignment(format.verticalAlignment)}"`);
+    }
+    if (format.wrapStrategy === "wrap") {
+        cellProps.push(`fo:wrap-option="wrap"`);
+    }
+    else if (format.wrapStrategy === "clip") {
+        cellProps.push(`fo:wrap-option="no-wrap"`, `style:overflow-behavior="clip"`);
+    }
+    if (format.indent) {
+        paragraphProps.push(`fo:margin-left="${format.indent}pt"`);
+    }
+    if (format.textRotation === "vertical") {
+        paragraphProps.push(`style:direction="ttb"`);
+    }
+    else if (typeof format.textRotation === "number") {
+        paragraphProps.push(`style:rotation-angle="${format.textRotation}"`);
+    }
+    // ODS doesn't natively model OOXML's 18 pattern types. When a cell has a
+    // non-solid `fillPattern`, prefer the foreground color as the visible
+    // background (matching LibreOffice's behavior on save). Solid / none /
+    // absent fillPattern falls back to the regular backgroundColor path.
+    const fillPatternForBg = format.fillPattern;
+    const useForegroundForBg = fillPatternForBg &&
+        fillPatternForBg !== "none" &&
+        fillPatternForBg !== "solid" &&
+        format.foregroundColor;
+    const background = useForegroundForBg
+        ? normalizeColor(format.foregroundColor ?? undefined, theme)
+        : normalizeColor(format.backgroundColor ?? undefined, theme);
+    if (background) {
+        cellProps.push(`fo:background-color="${background}"`);
+    }
+    const borders = format.borders;
+    if (borders) {
+        const top = borderToCss(borders.top ?? undefined, theme);
+        const bottom = borderToCss(borders.bottom ?? undefined, theme);
+        const left = borderToCss(borders.left ?? undefined, theme);
+        const right = borderToCss(borders.right ?? undefined, theme);
+        const diagUp = borderToCss(borders.diagonalUp ?? undefined, theme);
+        const diagDown = borderToCss(borders.diagonalDown ?? undefined, theme);
+        if (top)
+            cellProps.push(`fo:border-top="${top}"`);
+        if (bottom)
+            cellProps.push(`fo:border-bottom="${bottom}"`);
+        if (left)
+            cellProps.push(`fo:border-left="${left}"`);
+        if (right)
+            cellProps.push(`fo:border-right="${right}"`);
+        if (diagUp)
+            cellProps.push(`style:diagonal-bl-tr="${diagUp}"`);
+        if (diagDown)
+            cellProps.push(`style:diagonal-tl-br="${diagDown}"`);
+    }
+    const dataStyleAttr = numberStyleName
+        ? ` style:data-style-name="${numberStyleName}"`
+        : "";
+    return `<style:style style:name="${name}" style:family="table-cell"${dataStyleAttr}><style:table-cell-properties${cellProps.length ? " " + cellProps.join(" ") : ""}/><style:paragraph-properties${paragraphProps.length ? " " + paragraphProps.join(" ") : ""}/><style:text-properties${textProps.length ? " " + textProps.join(" ") : ""}/></style:style>`;
+};
+const buildTextStyleXml = (name, textFormat, theme) => {
+    const textProps = [];
+    if (textFormat.bold) {
+        textProps.push(`fo:font-weight="bold"`);
+    }
+    if (textFormat.italic) {
+        textProps.push(`fo:font-style="italic"`);
+    }
+    if (textFormat.underline) {
+        textProps.push(`style:text-underline-style="solid"`);
+    }
+    if (textFormat.strikethrough) {
+        textProps.push(`style:text-line-through-style="solid"`);
+    }
+    if (textFormat.baselineOffset === "superscript") {
+        textProps.push(`style:text-position="super 58%"`);
+    }
+    else if (textFormat.baselineOffset === "subscript") {
+        textProps.push(`style:text-position="sub 58%"`);
+    }
+    if (textFormat.fontFamily) {
+        textProps.push(`fo:font-family="${escapeXml(textFormat.fontFamily)}"`);
+    }
+    if (textFormat.fontSize) {
+        textProps.push(`fo:font-size="${textFormat.fontSize}pt"`);
+    }
+    const textColor = normalizeColor(textFormat.color ?? undefined, theme);
+    if (textColor) {
+        textProps.push(`fo:color="${textColor}"`);
+    }
+    return `<style:style style:name="${name}" style:family="text"><style:text-properties${textProps.length ? " " + textProps.join(" ") : ""}/></style:style>`;
+};
+const buildRichTextParagraph = (text, runs, styleBuilder) => {
+    if (!runs?.length) {
+        return `<text:p>${escapeXml(String(text))}</text:p>`;
+    }
+    const parts = [];
+    let cursor = 0;
+    const sortedRuns = [...runs].sort((a, b) => a.startIndex - b.startIndex || a.endIndex - b.endIndex);
+    for (const run of sortedRuns) {
+        if (run.nodeType !== "text")
+            continue;
+        const startIndex = Math.max(0, Math.min(text.length, run.startIndex));
+        const endIndex = Math.max(startIndex, Math.min(text.length, run.endIndex));
+        if (endIndex <= cursor)
+            continue;
+        if (cursor < startIndex) {
+            parts.push(escapeXml(text.slice(cursor, startIndex)));
+        }
+        const runText = text.slice(Math.max(cursor, startIndex), endIndex);
+        const styleName = styleBuilder.registerText(run.format);
+        parts.push(styleName
+            ? `<text:span text:style-name="${styleName}">${escapeXml(runText)}</text:span>`
+            : escapeXml(runText));
+        cursor = endIndex;
+    }
+    if (cursor < text.length) {
+        parts.push(escapeXml(text.slice(cursor)));
+    }
+    return `<text:p>${parts.join("")}</text:p>`;
+};
+const buildRowStyleXml = (name, heightPx, hidden) => {
+    const props = [];
+    if (heightPx) {
+        props.push(`style:row-height="${pxToCm(heightPx).toFixed(2)}cm"`);
+    }
+    if (hidden) {
+        props.push(`style:visibility="collapse"`);
+    }
+    return `<style:style style:name="${name}" style:family="table-row"><style:table-row-properties${props.length ? " " + props.join(" ") : ""}/></style:style>`;
+};
+const buildColumnStyleXml = (name, widthPx, hidden) => {
+    const props = [];
+    if (widthPx) {
+        props.push(`style:column-width="${pxToCm(widthPx).toFixed(2)}cm"`);
+    }
+    if (hidden) {
+        props.push(`style:visibility="collapse"`);
+    }
+    return `<style:style style:name="${name}" style:family="table-column"><style:table-column-properties${props.length ? " " + props.join(" ") : ""}/></style:style>`;
+};
+const buildNumberStyleXml = (name, format) => {
+    if (!format)
+        return "";
+    const type = format.type;
+    if (type === "PERCENT") {
+        return `<number:percentage-style style:name="${name}"><number:number number:min-integer-digits="1" number:decimal-places="2"/></number:percentage-style>`;
+    }
+    if (type === "CURRENCY" || type === "ACCOUNTING") {
+        return `<number:currency-style style:name="${name}"><number:currency-symbol>$</number:currency-symbol><number:number number:min-integer-digits="1" number:decimal-places="2"/></number:currency-style>`;
+    }
+    if (type === "DATE") {
+        return `<number:date-style style:name="${name}"><number:year number:style="long"/><number:text>-</number:text><number:month number:style="long"/><number:text>-</number:text><number:day number:style="long"/></number:date-style>`;
+    }
+    if (type === "TIME") {
+        return `<number:time-style style:name="${name}"><number:hours/><number:text>:</number:text><number:minutes/><number:text>:</number:text><number:seconds/></number:time-style>`;
+    }
+    if (type === "DATE_TIME") {
+        return `<number:date-style style:name="${name}"><number:year number:style="long"/><number:text>-</number:text><number:month number:style="long"/><number:text>-</number:text><number:day number:style="long"/><number:text> </number:text><number:hours/><number:text>:</number:text><number:minutes/></number:date-style>`;
+    }
+    if (type === "SCIENTIFIC") {
+        return `<number:scientific-number-style style:name="${name}"><number:number number:min-integer-digits="1"/></number:scientific-number-style>`;
+    }
+    return `<number:number-style style:name="${name}"><number:number number:min-integer-digits="1"/></number:number-style>`;
+};
+const buildAllDataValidationEntries = (rules, sheetNameById) => {
+    if (!rules.length)
+        return [];
+    const entries = rules
+        .map((rule) => {
+        const rangeAttr = buildRangeListForValidations(rule.ranges ?? [], sheetNameById);
+        if (!rangeAttr)
+            return undefined;
+        const config = convertDataValidationRule(rule);
+        if (!config)
+            return undefined;
+        const baseCellAddress = buildValidationBaseCellAddress(rule.ranges ?? [], sheetNameById);
+        const attrs = [
+            `table:name="${escapeXml(String(rule.id ?? ""))}"`,
+            `table:target-range-address="${escapeXmlAddress(rangeAttr)}"`,
+            `table:condition="${escapeXml(config.condition)}"`,
+        ];
+        if (config.allowEmptyCell !== undefined) {
+            attrs.push(`table:allow-empty-cell="${config.allowEmptyCell ? "true" : "false"}"`);
+        }
+        if (config.displayList) {
+            attrs.push(`table:display-list="${config.displayList}"`);
+        }
+        if (baseCellAddress) {
+            attrs.push(`table:base-cell-address="${escapeXmlAddress(baseCellAddress)}"`);
+        }
+        const help = config.helpMessage
+            ? `<table:help-message table:title="${escapeXml(config.helpMessage.title ?? "")}" table:message="${escapeXml(config.helpMessage.message ?? "")}"/>`
+            : "";
+        const error = config.errorMessage
+            ? `<table:error-message table:message-type="${config.errorMessage.type}" table:display="true" table:title="${escapeXml(config.errorMessage.title ?? "")}" table:message="${escapeXml(config.errorMessage.message ?? "")}"/>`
+            : "";
+        return `<table:content-validation ${attrs.join(" ")}><table:error-message table:message-type="stop" table:display="true"/></table:content-validation>`;
+    })
+        .filter((entry) => Boolean(entry));
+    return entries;
+};
+const buildConditionalFormattingXml = ({ conditionalFormats, sheetName, styleBuilder, namedRangeNames, }) => {
+    const entries = [];
+    let styleCounter = 1;
+    const escapeConditionText = (value) => value.replace(/"/g, '""');
+    const ensureFormula = (formula) => formula.startsWith("=") ? formula : `=${formula}`;
+    const stripFormula = (formula) => formula.startsWith("=") ? formula.slice(1) : formula;
+    const buildFormulaConditionValue = (formula) => {
+        const odsFormula = buildOdsConditionExpression(ensureFormula(formula), namedRangeNames);
+        return odsFormula ? `formula-is(${odsFormula})` : undefined;
+    };
+    const orderedRules = conditionalFormats
+        .map((rule, index) => ({ rule, index }))
+        .sort((left, right) => {
+        const leftPriority = left.rule.priority;
+        const rightPriority = right.rule.priority;
+        if (leftPriority == null && rightPriority == null) {
+            return left.index - right.index;
+        }
+        if (leftPriority == null) {
+            return 1;
+        }
+        if (rightPriority == null) {
+            return -1;
+        }
+        if (leftPriority === rightPriority) {
+            return left.index - right.index;
+        }
+        return leftPriority - rightPriority;
+    })
+        .map(({ rule }) => rule);
+    for (const rule of orderedRules) {
+        if (rule.enabled === false)
+            continue;
+        const ranges = rule.ranges ?? [];
+        if (!ranges.length)
+            continue;
+        const rangeAttr = buildCalcextRangeList(ranges, sheetName);
+        if (!rangeAttr)
+            continue;
+        const baseCellAddress = buildCalcextBaseAddress(ranges[0], sheetName);
+        const baseCellRef = cellToAddress({
+            rowIndex: ranges[0].startRowIndex,
+            columnIndex: ranges[0].startColumnIndex,
+        });
+        const absoluteRangeRef = (() => {
+            const range = ranges[0];
+            const startCol = columnIndexToLetter(range.startColumnIndex);
+            const endCol = columnIndexToLetter(range.endColumnIndex);
+            return `$${startCol}$${range.startRowIndex}:$${endCol}$${range.endRowIndex}`;
+        })();
+        const addConditionEntry = (format, conditionValue) => {
+            if (!format || !conditionValue)
+                return;
+            const styleName = styleBuilder.registerConditionalFormat(format, `ConditionalStyle_${styleCounter++}`);
+            if (!styleName)
+                return;
+            const stopIfTrueAttr = rule.stopIfTrue
+                ? `calcext:stop-if-true="true"`
+                : "";
+            const conditionAttrs = [
+                `calcext:apply-style-name="${styleName}"`,
+                `calcext:value="${escapeXml(conditionValue)}"`,
+                baseCellAddress
+                    ? `calcext:base-cell-address="${escapeXml(baseCellAddress)}"`
+                    : "",
+                stopIfTrueAttr,
+            ]
+                .filter(Boolean)
+                .join(" ");
+            entries.push(`<calcext:conditional-format calcext:target-range-address="${escapeXml(rangeAttr)}"><calcext:condition ${conditionAttrs}/></calcext:conditional-format>`);
+        };
+        const buildTextLiteralCondition = (raw) => `="${escapeConditionText(raw)}"`;
+        const buildBooleanConditionValue = () => {
+            const booleanRule = rule.booleanRule;
+            if (!booleanRule?.condition?.type || !baseCellRef)
+                return undefined;
+            const { condition } = booleanRule;
+            const values = condition.values ?? [];
+            const first = values[0]?.userEnteredValue ?? "";
+            const second = values[1]?.userEnteredValue ?? "";
+            const isFormulaValue = (value) => value.trim().startsWith("=");
+            const isNumericValue = (value) => value.trim() !== "" && !isNaN(Number(value));
+            const normalizeDateOperand = (raw) => {
+                const trimmed = raw.trim();
+                if (!trimmed)
+                    return "";
+                if (trimmed.startsWith("=")) {
+                    return stripFormula(trimmed);
+                }
+                if (isNumericValue(trimmed)) {
+                    return trimmed;
+                }
+                return `DATEVALUE("${escapeConditionText(trimmed)}")`;
+            };
+            if (condition.type === "CUSTOM_FORMULA") {
+                const formula = condition.values?.[0]?.userEnteredValue ?? booleanRule.formula;
+                if (!formula)
+                    return undefined;
+                return buildFormulaConditionValue(formula);
+            }
+            if (condition.type === "TEXT_EQ") {
+                return buildTextLiteralCondition(first);
+            }
+            if (condition.type === "TEXT_NOT_EQ") {
+                return `not-equal("${escapeConditionText(first)}")`;
+            }
+            if (condition.type === "TEXT_CONTAINS") {
+                return `contains-text("${escapeConditionText(first)}")`;
+            }
+            if (condition.type === "TEXT_NOT_CONTAINS") {
+                return `not-contains-text("${escapeConditionText(first)}")`;
+            }
+            if (condition.type === "TEXT_STARTS_WITH") {
+                return `begins-with("${escapeConditionText(first)}")`;
+            }
+            if (condition.type === "TEXT_ENDS_WITH") {
+                return `ends-with("${escapeConditionText(first)}")`;
+            }
+            if (condition.type === "NUMBER_BETWEEN" ||
+                condition.type === "NUMBER_NOT_BETWEEN" ||
+                condition.type === "NUMBER_EQ" ||
+                condition.type === "NUMBER_NOT_EQ" ||
+                condition.type === "NUMBER_GREATER" ||
+                condition.type === "NUMBER_GREATER_THAN_EQ" ||
+                condition.type === "NUMBER_LESS" ||
+                condition.type === "NUMBER_LESS_THAN_EQ") {
+                const needsFormula = isFormulaValue(first) ||
+                    isFormulaValue(second) ||
+                    (!isNumericValue(first) && first) ||
+                    (!isNumericValue(second) && second);
+                const operatorMap = {
+                    NUMBER_BETWEEN: "between",
+                    NUMBER_NOT_BETWEEN: "not-between",
+                    NUMBER_EQ: "equal",
+                    NUMBER_NOT_EQ: "not-equal",
+                    NUMBER_GREATER: "greater-than",
+                    NUMBER_GREATER_THAN_EQ: "greater-than-equal",
+                    NUMBER_LESS: "less-than",
+                    NUMBER_LESS_THAN_EQ: "less-than-equal",
+                };
+                const operator = operatorMap[condition.type];
+                if (!needsFormula && operator) {
+                    if ((operator === "between" || operator === "not-between") &&
+                        !(first && second)) {
+                        return undefined;
+                    }
+                    if (operator === "between" || operator === "not-between") {
+                        return `${operator}(${first},${second})`;
+                    }
+                    return `${operator}(${first})`;
+                }
+                const firstExpr = first ? stripFormula(first) : "";
+                const secondExpr = second ? stripFormula(second) : "";
+                if ((condition.type === "NUMBER_BETWEEN" ||
+                    condition.type === "NUMBER_NOT_BETWEEN") &&
+                    (!firstExpr || !secondExpr)) {
+                    return undefined;
+                }
+                if (condition.type === "NUMBER_BETWEEN") {
+                    return buildFormulaConditionValue(`AND(${baseCellRef}>=${firstExpr},${baseCellRef}<=${secondExpr})`);
+                }
+                if (condition.type === "NUMBER_NOT_BETWEEN") {
+                    return buildFormulaConditionValue(`OR(${baseCellRef}<${firstExpr},${baseCellRef}>${secondExpr})`);
+                }
+                const opMap = {
+                    NUMBER_EQ: "=",
+                    NUMBER_NOT_EQ: "<>",
+                    NUMBER_GREATER: ">",
+                    NUMBER_GREATER_THAN_EQ: ">=",
+                    NUMBER_LESS: "<",
+                    NUMBER_LESS_THAN_EQ: "<=",
+                };
+                const op = opMap[condition.type];
+                if (!op || !firstExpr)
+                    return undefined;
+                return (buildFormulaConditionValue(`${baseCellRef}${op}${firstExpr}`) ??
+                    undefined);
+            }
+            if (condition.type === "DATE_EQ" ||
+                condition.type === "DATE_NOT_EQ" ||
+                condition.type === "DATE_BEFORE" ||
+                condition.type === "DATE_AFTER" ||
+                condition.type === "DATE_ON_OR_BEFORE" ||
+                condition.type === "DATE_ON_OR_AFTER" ||
+                condition.type === "DATE_BETWEEN" ||
+                condition.type === "DATE_NOT_BETWEEN") {
+                const firstExpr = normalizeDateOperand(first);
+                const secondExpr = normalizeDateOperand(second);
+                if ((condition.type === "DATE_BETWEEN" ||
+                    condition.type === "DATE_NOT_BETWEEN") &&
+                    (!firstExpr || !secondExpr)) {
+                    return undefined;
+                }
+                const opMap = {
+                    DATE_EQ: "=",
+                    DATE_NOT_EQ: "<>",
+                    DATE_BEFORE: "<",
+                    DATE_AFTER: ">",
+                    DATE_ON_OR_BEFORE: "<=",
+                    DATE_ON_OR_AFTER: ">=",
+                };
+                if (condition.type === "DATE_BETWEEN") {
+                    return buildFormulaConditionValue(`AND(${baseCellRef}>=${firstExpr},${baseCellRef}<=${secondExpr})`);
+                }
+                if (condition.type === "DATE_NOT_BETWEEN") {
+                    return buildFormulaConditionValue(`OR(${baseCellRef}<${firstExpr},${baseCellRef}>${secondExpr})`);
+                }
+                const op = opMap[condition.type];
+                if (!op || !firstExpr)
+                    return undefined;
+                return buildFormulaConditionValue(`${baseCellRef}${op}${firstExpr}`);
+            }
+            switch (condition.type) {
+                case "BLANK":
+                    return buildFormulaConditionValue(`${baseCellRef}=""`);
+                case "NOT_BLANK":
+                    return buildFormulaConditionValue(`${baseCellRef}<>""`);
+                case "ERROR":
+                    return buildFormulaConditionValue(`ISERROR(${baseCellRef})`);
+                case "NOT_ERROR":
+                    return buildFormulaConditionValue(`NOT(ISERROR(${baseCellRef}))`);
+                case "BOOLEAN":
+                    return buildFormulaConditionValue(`OR(${baseCellRef}=TRUE,${baseCellRef}=FALSE)`);
+                case "TEXT_IS_EMAIL":
+                    return buildFormulaConditionValue(`AND(ISNUMBER(SEARCH("@",${baseCellRef})),ISNUMBER(SEARCH(".",${baseCellRef})))`);
+                case "TEXT_IS_URL":
+                    return buildFormulaConditionValue(`OR(LEFT(${baseCellRef},7)="http://",LEFT(${baseCellRef},8)="https://")`);
+                case "DATE_IS_VALID":
+                    return buildFormulaConditionValue(`ISNUMBER(${baseCellRef})`);
+                case "NUMBER_ABOVE_AVERAGE":
+                    return buildFormulaConditionValue(`${baseCellRef}>AVERAGE(${absoluteRangeRef})`);
+                case "NUMBER_BELOW_AVERAGE":
+                    return buildFormulaConditionValue(`${baseCellRef}<AVERAGE(${absoluteRangeRef})`);
+                case "DATE_TODAY": {
+                    const normalized = `INT(${baseCellRef})`;
+                    return buildFormulaConditionValue(`${normalized}=TODAY()`);
+                }
+                case "DATE_YESTERDAY": {
+                    const normalized = `INT(${baseCellRef})`;
+                    return buildFormulaConditionValue(`${normalized}=TODAY()-1`);
+                }
+                case "DATE_TOMORROW": {
+                    const normalized = `INT(${baseCellRef})`;
+                    return buildFormulaConditionValue(`${normalized}=TODAY()+1`);
+                }
+                case "DATE_LAST_7_DAYS": {
+                    const normalized = `INT(${baseCellRef})`;
+                    return buildFormulaConditionValue(`AND(${normalized}>=TODAY()-6,${normalized}<=TODAY())`);
+                }
+                case "DATE_THIS_WEEK": {
+                    const normalized = `INT(${baseCellRef})`;
+                    const weekStart = "TODAY()-WEEKDAY(TODAY(),2)+1";
+                    return buildFormulaConditionValue(`AND(${normalized}>=${weekStart},${normalized}<=${weekStart}+6)`);
+                }
+                case "DATE_LAST_WEEK": {
+                    const normalized = `INT(${baseCellRef})`;
+                    const weekStart = "TODAY()-WEEKDAY(TODAY(),2)+1";
+                    return buildFormulaConditionValue(`AND(${normalized}>=${weekStart}-7,${normalized}<=${weekStart}-1)`);
+                }
+                case "DATE_NEXT_WEEK": {
+                    const normalized = `INT(${baseCellRef})`;
+                    const weekStart = "TODAY()-WEEKDAY(TODAY(),2)+1";
+                    return buildFormulaConditionValue(`AND(${normalized}>=${weekStart}+7,${normalized}<=${weekStart}+13)`);
+                }
+                case "DATE_THIS_MONTH": {
+                    const normalized = `INT(${baseCellRef})`;
+                    return buildFormulaConditionValue(`AND(${normalized}>=EOMONTH(TODAY(),-1)+1,${normalized}<=EOMONTH(TODAY(),0))`);
+                }
+                case "DATE_LAST_MONTH": {
+                    const normalized = `INT(${baseCellRef})`;
+                    return buildFormulaConditionValue(`AND(${normalized}>=EOMONTH(TODAY(),-2)+1,${normalized}<=EOMONTH(TODAY(),-1))`);
+                }
+                case "DATE_NEXT_MONTH": {
+                    const normalized = `INT(${baseCellRef})`;
+                    return buildFormulaConditionValue(`AND(${normalized}>=EOMONTH(TODAY(),0)+1,${normalized}<=EOMONTH(TODAY(),1))`);
+                }
+                case "NUMBER_GREATER_THAN_PREVIOUS":
+                    return buildFormulaConditionValue(`IFERROR(${baseCellRef}>INDIRECT("R[-1]C",FALSE),TRUE)`);
+                case "NUMBER_GREATER_THAN_EQ_PREVIOUS":
+                    return buildFormulaConditionValue(`IFERROR(${baseCellRef}>=INDIRECT("R[-1]C",FALSE),TRUE)`);
+                case "NUMBER_LESS_THAN_PREVIOUS":
+                    return buildFormulaConditionValue(`IFERROR(${baseCellRef}<INDIRECT("R[-1]C",FALSE),TRUE)`);
+                case "NUMBER_LESS_THAN_EQ_PREVIOUS":
+                    return buildFormulaConditionValue(`IFERROR(${baseCellRef}<=INDIRECT("R[-1]C",FALSE),TRUE)`);
+                case "ONE_OF_LIST": {
+                    const entries = values
+                        .map((value) => value.userEnteredValue)
+                        .filter((value) => typeof value === "string");
+                    if (!entries.length)
+                        return undefined;
+                    const conditions = entries.map((entry) => {
+                        if (entry.startsWith("=")) {
+                            return `${baseCellRef}=${stripFormula(entry)}`;
+                        }
+                        if (isNumericValue(entry)) {
+                            return `${baseCellRef}=${entry}`;
+                        }
+                        return `${baseCellRef}="${escapeConditionText(entry)}"`;
+                    });
+                    return buildFormulaConditionValue(`OR(${conditions.join(",")})`);
+                }
+                case "ONE_OF_RANGE": {
+                    const rangeRef = values[0]?.userEnteredValue ?? "";
+                    if (!rangeRef)
+                        return undefined;
+                    return buildFormulaConditionValue(`COUNTIF(${stripFormula(rangeRef)},${baseCellRef})>0`);
+                }
+                default:
+                    return undefined;
+            }
+        };
+        const booleanConditionValue = buildBooleanConditionValue();
+        if (booleanConditionValue) {
+            addConditionEntry(rule.booleanRule?.format, booleanConditionValue);
+        }
+        if (rule.distinctRule && baseCellRef) {
+            const isUnique = rule.distinctRule.type === "UNIQUE";
+            const op = isUnique ? "=" : ">";
+            addConditionEntry(rule.distinctRule.format, buildFormulaConditionValue(`COUNTIF(${absoluteRangeRef},${baseCellRef})${op}1`));
+        }
+        if (rule.topBottomRule && baseCellRef) {
+            const rank = Number.isFinite(rule.topBottomRule.rank)
+                ? Math.max(1, rule.topBottomRule.rank)
+                : 10;
+            const isBottom = rule.topBottomRule.type === "BOTTOM";
+            const rankExpr = rule.topBottomRule.isPercent
+                ? `ROUNDUP(COUNT(${absoluteRangeRef})*${rank}/100,0)`
+                : String(rank);
+            const order = isBottom ? ",1" : "";
+            addConditionEntry(rule.topBottomRule.format, buildFormulaConditionValue(`RANK(${baseCellRef},${absoluteRangeRef}${order})<=${rankExpr}`));
+        }
+        if (rule.gradientRule && baseCellRef) {
+            const gradient = rule.gradientRule;
+            const thresholdForPoint = (point) => {
+                if (!point?.type)
+                    return undefined;
+                const type = String(point.type).toUpperCase();
+                const value = point.value ?? "";
+                switch (type) {
+                    case "MIN":
+                        return `MIN(${absoluteRangeRef})`;
+                    case "MAX":
+                        return `MAX(${absoluteRangeRef})`;
+                    case "NUMBER":
+                        return String(value);
+                    case "PERCENT":
+                    case "PERCENTILE":
+                        return `PERCENTILE.INC(${absoluteRangeRef},${Number(value) / 100})`;
+                    default:
+                        return undefined;
+                }
+            };
+            const minExpr = thresholdForPoint(gradient.minpoint);
+            const midExpr = thresholdForPoint(gradient.midpoint);
+            const maxExpr = thresholdForPoint(gradient.maxpoint);
+            if (gradient.minpoint?.color && (midExpr || maxExpr)) {
+                const upper = midExpr ?? maxExpr ?? minExpr;
+                if (upper) {
+                    addConditionEntry({ backgroundColor: gradient.minpoint.color }, buildFormulaConditionValue(`${baseCellRef}<=${upper}`));
+                }
+            }
+            if (gradient.midpoint?.color && midExpr && maxExpr) {
+                addConditionEntry({ backgroundColor: gradient.midpoint.color }, buildFormulaConditionValue(`AND(${baseCellRef}>${midExpr},${baseCellRef}<${maxExpr})`));
+            }
+            if (gradient.maxpoint?.color && (maxExpr || midExpr)) {
+                const lower = maxExpr ?? midExpr ?? minExpr;
+                if (lower) {
+                    addConditionEntry({ backgroundColor: gradient.maxpoint.color }, buildFormulaConditionValue(`${baseCellRef}>=${lower}`));
+                }
+            }
+        }
+        // ODS `calcext:` extension for icon sets and data bars. Same threshold
+        // type vocabulary as ODS gradient, plus a leading "auto-minimum" stop
+        // that LibreOffice expects to match OOXML's leading-cfvo convention.
+        const cfThresholdTypeToOds = (t) => {
+            if (!t?.type)
+                return "";
+            const map = {
+                MIN: "auto-minimum",
+                MAX: "auto-maximum",
+                NUMBER: "value",
+                PERCENT: "percent",
+                PERCENTILE: "percentile",
+                FORMULA: "formula",
+            };
+            const odsType = map[String(t.type).toUpperCase()] ?? "value";
+            const valueAttr = t.value !== undefined && t.value !== null
+                ? ` calcext:value="${escapeXml(String(t.value))}"`
+                : ` calcext:value="0"`;
+            return `<calcext:formatting-entry calcext:type="${odsType}"${valueAttr}/>`;
+        };
+        if (rule.iconSetRule) {
+            const { iconSet, thresholds } = rule.iconSetRule;
+            // Prepend the auto-minimum entry that ODS / LibreOffice expects.
+            const entriesXml = [
+                `<calcext:formatting-entry calcext:type="auto-minimum" calcext:value="0"/>`,
+                ...thresholds.map((t) => cfThresholdTypeToOds(t)),
+            ].join("");
+            entries.push(`<calcext:conditional-format calcext:target-range-address="${escapeXml(rangeAttr)}"><calcext:icon-set calcext:icon-set-type="${iconSet}">${entriesXml}</calcext:icon-set></calcext:conditional-format>`);
+        }
+        if (rule.dataBarRule) {
+            // Data-bar colors are typically authored as hex strings; theme-colored
+            // bars fall back to the LibreOffice default blue rather than resolving
+            // theme indices here (which would require plumbing theme through the
+            // CF builder for one edge case).
+            const colorToHex = (c) => {
+                if (typeof c === "string")
+                    return c;
+                return undefined;
+            };
+            const positiveColor = colorToHex(rule.dataBarRule.color) ?? "#638ec6";
+            const negativeColor = colorToHex(rule.dataBarRule.negativeColor);
+            const entriesXml = [
+                cfThresholdTypeToOds(rule.dataBarRule.minpoint),
+                cfThresholdTypeToOds(rule.dataBarRule.maxpoint),
+            ].join("");
+            const negAttr = negativeColor
+                ? ` calcext:negative-color="${negativeColor}"`
+                : "";
+            entries.push(`<calcext:conditional-format calcext:target-range-address="${escapeXml(rangeAttr)}"><calcext:data-bar calcext:positive-color="${positiveColor}"${negAttr}>${entriesXml}</calcext:data-bar></calcext:conditional-format>`);
+        }
+    }
+    if (!entries.length)
+        return "";
+    return `<calcext:conditional-formats>${entries.join("")}</calcext:conditional-formats>`;
+};
+const getFilterVisibleValues = (spec, range, rows, headerRow = true, totalRow = false) => {
+    const values = new Set();
+    const startRowIndex = range.startRowIndex + (headerRow ? 1 : 0);
+    const endRowIndex = range.endRowIndex - (totalRow ? 1 : 0);
+    const columnIndex = range.startColumnIndex + spec.columnIndex;
+    for (let rowIndex = startRowIndex; rowIndex <= endRowIndex; rowIndex++) {
+        const cell = rows[rowIndex]?.values?.[columnIndex];
+        const formattedValue = getCellFormattedValue(cell);
+        const fallbackValue = formattedValue ??
+            getCellEffectiveValue(cell) ??
+            getCellUserEnteredValue(cell);
+        if (isNil(fallbackValue) || fallbackValue === "") {
+            values.add(BLANK_LABEL);
+            continue;
+        }
+        values.add(String(fallbackValue));
+    }
+    return [...values];
+};
+const buildDatabaseRangeEntries = (tables, sheetName, sheet, rows) => {
+    const entries = [];
+    const basicFilter = sheet.basicFilter;
+    for (const table of tables) {
+        const ref = table.ref;
+        if (!ref)
+            continue;
+        const range = `${escapeSheetName(sheetName)}.${ref}`;
+        const filterButton = table.filterButton !== false;
+        const filterSpecs = table.filterSpecs ??
+            (basicFilter && rangesEqual(table.range, basicFilter.range)
+                ? basicFilter.filterSpecs ?? []
+                : []);
+        const sortSpecs = table.sortSpecs ??
+            (basicFilter && rangesEqual(table.range, basicFilter.range)
+                ? basicFilter.sortSpecs ?? []
+                : []);
+        const filterXml = buildFilterXml(filterSpecs ?? [], table.range, rows, table.headerRow ?? true, table.totalRow ?? false);
+        const sortXml = buildSortXml(sortSpecs ?? []);
+        const attrs = [
+            `table:name="${escapeXml(table.name)}"`,
+            `table:target-range-address="${escapeXml(range)}"`,
+            `table:orientation="row"`,
+        ];
+        if (filterButton) {
+            attrs.push(`table:display-filter-buttons="true"`);
+        }
+        entries.push(`<table:database-range ${attrs.join(" ")}>${filterXml}${sortXml}</table:database-range>`);
+    }
+    if (basicFilter &&
+        !tables.some((table) => rangesEqual(table.range, basicFilter.range))) {
+        const rangeAddress = buildOdsRangeAddress(basicFilter.range, sheetName);
+        if (rangeAddress) {
+            const filterXml = buildFilterXml(basicFilter.filterSpecs ?? [], basicFilter.range, rows, true, false);
+            const sortXml = buildSortXml(basicFilter.sortSpecs ?? []);
+            const name = String(basicFilter.id) ?? `Filter_${sheetName}`;
+            entries.push(`<table:database-range table:name="${escapeXml(name)}" table:target-range-address="${escapeXml(rangeAddress)}" table:orientation="row" table:display-filter-buttons="true">${filterXml}${sortXml}</table:database-range>`);
+        }
+    }
+    return entries;
+};
+const buildDatabaseRangesXml = (entries) => {
+    if (!entries.length)
+        return "";
+    return `<table:database-ranges>${entries.join("")}</table:database-ranges>`;
+};
+const buildNamedRangesXml = (namedRanges, sheetNameById, namedRangeNames) => {
+    if (!namedRanges?.length)
+        return "";
+    const ranges = [];
+    const expressions = [];
+    for (const namedRange of namedRanges) {
+        if (!namedRange?.name)
+            continue;
+        if (!isValidNamedRangeName(namedRange.name)) {
+            continue;
+        }
+        if (namedRange.range?.sheetId) {
+            const sheetName = sheetNameById.get(namedRange.range.sheetId);
+            if (!sheetName)
+                continue;
+            const address = buildOdsRangeAddressAbsolute(namedRange.range, sheetName);
+            if (!address)
+                continue;
+            const baseAddress = buildOdsBaseAddressAbsolute(namedRange.range, sheetName);
+            if (!baseAddress)
+                continue;
+            ranges.push(`<table:named-range table:name="${escapeXml(namedRange.name)}" table:cell-range-address="${escapeXml(address)}" table:base-cell-address="${escapeXml(baseAddress)}"/>`);
+            continue;
+        }
+        const rawValue = namedRange.value;
+        if (typeof rawValue === "string" && rawValue.trim().length) {
+            const trimmed = rawValue.trim();
+            const expression = trimmed.startsWith("=")
+                ? `of:=${sanitizeXmlText(convertExcelFormulaToOds(trimmed.slice(1), namedRangeNames))}`
+                : sanitizeXmlText(trimmed);
+            expressions.push(`<table:named-expression table:name="${escapeXml(namedRange.name)}" table:expression="${escapeXml(expression)}"/>`);
+        }
+    }
+    if (!ranges.length && !expressions.length)
+        return "";
+    return `<table:named-expressions>${ranges.join("")}${expressions.join("")}</table:named-expressions>`;
+};
+const buildFilterXml = (filterSpecs, range, rows, headerRow = true, totalRow = false) => {
+    if (!filterSpecs?.length)
+        return "";
+    const conditions = [];
+    for (const spec of filterSpecs) {
+        const criteria = spec.filterCriteria;
+        // A condition filter (greater-than / contains / between / blank / …) takes
+        // precedence over a value list, and is emitted as a single operator-based
+        // <table:filter-condition>. Otherwise fall back to value-list entries.
+        const condition = criteria?.condition;
+        const mapped = condition?.type
+            ? mapConditionToFilterCondition(condition.type, condition.values ?? [])
+            : undefined;
+        if (mapped) {
+            const attrs = [
+                `table:field-number="${spec.columnIndex}"`,
+                `table:operator="${mapped.operator}"`,
+            ];
+            if (mapped.value !== undefined) {
+                attrs.push(`table:value="${escapeXml(mapped.value)}"`);
+            }
+            if (mapped.value2 !== undefined) {
+                attrs.push(`table:value2="${escapeXml(mapped.value2)}"`);
+            }
+            conditions.push(`<table:filter-condition ${attrs.join(" ")}/>`);
+            continue;
+        }
+        const visibleValues = criteria?.visibleValues ??
+            getFilterVisibleValues(spec, range, rows, headerRow, totalRow);
+        const hiddenValues = criteria?.hiddenValues ?? [];
+        for (const value of visibleValues) {
+            conditions.push(`<table:filter-condition table:field-number="${spec.columnIndex}" table:operator="=" table:value="${escapeXml(value)}"/>`);
+        }
+        for (const value of hiddenValues) {
+            conditions.push(`<table:filter-condition table:field-number="${spec.columnIndex}" table:operator="!=" table:value="${escapeXml(value)}"/>`);
+        }
+    }
+    if (!conditions.length)
+        return "";
+    return `<table:filter><table:filter-and>${conditions.join("")}</table:filter-and></table:filter>`;
+};
+const buildSortXml = (sortSpecs) => {
+    if (!sortSpecs?.length)
+        return "";
+    const entries = sortSpecs.map((spec) => {
+        const order = spec.sortOrder === "DESCENDING" ? "descending" : "ascending";
+        return `<table:sort-by table:field-number="${spec.dimensionIndex}" table:order="${order}"/>`;
+    });
+    return `<table:sort>${entries.join("")}</table:sort>`;
+};
+const mapConditionToFilterCondition = (type, values) => {
+    const first = values?.[0]?.userEnteredValue;
+    const second = values?.[1]?.userEnteredValue;
+    switch (type) {
+        case "NUMBER_EQ":
+        case "TEXT_EQ":
+        case "DATE_EQ":
+            return { operator: "=", value: first ?? "" };
+        case "NUMBER_NOT_EQ":
+        case "TEXT_NOT_EQ":
+        case "DATE_NOT_EQ":
+            return { operator: "!=", value: first ?? "" };
+        case "NUMBER_GREATER":
+        case "DATE_AFTER":
+            return { operator: ">", value: first ?? "" };
+        case "NUMBER_GREATER_THAN_EQ":
+        case "DATE_ON_OR_AFTER":
+            return { operator: ">=", value: first ?? "" };
+        case "NUMBER_LESS":
+        case "DATE_BEFORE":
+            return { operator: "<", value: first ?? "" };
+        case "NUMBER_LESS_THAN_EQ":
+        case "DATE_ON_OR_BEFORE":
+            return { operator: "<=", value: first ?? "" };
+        case "NUMBER_BETWEEN":
+        case "DATE_BETWEEN":
+            return { operator: "between", value: first ?? "", value2: second ?? "" };
+        case "NUMBER_NOT_BETWEEN":
+        case "DATE_NOT_BETWEEN":
+            return {
+                operator: "not-between",
+                value: first ?? "",
+                value2: second ?? "",
+            };
+        case "TEXT_CONTAINS":
+            return { operator: "contains", value: first ?? "" };
+        case "TEXT_NOT_CONTAINS":
+            return { operator: "does-not-contain", value: first ?? "" };
+        case "TEXT_STARTS_WITH":
+            return { operator: "begins-with", value: first ?? "" };
+        case "TEXT_ENDS_WITH":
+            return { operator: "ends-with", value: first ?? "" };
+        case "BLANK":
+            return { operator: "empty" };
+        case "NOT_BLANK":
+            return { operator: "non-empty" };
+        case "BOOLEAN":
+            return { operator: "=", value: "TRUE" };
+        default:
+            return undefined;
+    }
+};
+const resolveCellDataValidation = (cell, map) => {
+    if (!cell)
+        return undefined;
+    const raw = cell?.dataValidation;
+    if (!raw)
+        return undefined;
+    if (typeof raw === "string" || typeof raw === "number") {
+        return map?.[String(raw)];
+    }
+    return raw;
+};
+const buildMergeState = (ranges) => {
+    const normalized = normalizeMergeRanges(ranges);
+    const anchorSpans = new Map();
+    const coveredCells = new Set();
+    const maxColumnByRow = new Map();
+    for (const range of normalized) {
+        const rows = range.endRowIndex - range.startRowIndex + 1;
+        const columns = range.endColumnIndex - range.startColumnIndex + 1;
+        anchorSpans.set(`${range.startRowIndex}:${range.startColumnIndex}`, {
+            rows,
+            columns,
+        });
+        for (let r = range.startRowIndex; r <= range.endRowIndex; r++) {
+            for (let c = range.startColumnIndex; c <= range.endColumnIndex; c++) {
+                if (r === range.startRowIndex && c === range.startColumnIndex) {
+                    continue;
+                }
+                coveredCells.add(`${r}:${c}`);
+            }
+            const current = maxColumnByRow.get(r) ?? 0;
+            maxColumnByRow.set(r, Math.max(current, range.endColumnIndex));
+        }
+    }
+    return { anchorSpans, coveredCells, maxColumnByRow, ranges: normalized };
+};
+const updateBoundsForMerges = (bounds, state) => {
+    for (const range of state.ranges) {
+        bounds.minRow = Math.min(bounds.minRow, range.startRowIndex);
+        bounds.maxRow = Math.max(bounds.maxRow, range.endRowIndex);
+        bounds.minColumn = Math.min(bounds.minColumn, range.startColumnIndex);
+        bounds.maxColumn = Math.max(bounds.maxColumn, range.endColumnIndex);
+    }
+};
+const sanitizeMergeRange = (range) => {
+    const startRow = sanitizeIndex(range?.startRowIndex);
+    const endRow = sanitizeIndex(range?.endRowIndex);
+    const startColumn = sanitizeIndex(range?.startColumnIndex);
+    const endColumn = sanitizeIndex(range?.endColumnIndex);
+    if (startRow == null ||
+        endRow == null ||
+        startColumn == null ||
+        endColumn == null) {
+        return null;
+    }
+    if (startRow > endRow || startColumn > endColumn) {
+        return null;
+    }
+    if (startRow === endRow && startColumn === endColumn) {
+        return null;
+    }
+    return {
+        startRowIndex: startRow,
+        endRowIndex: endRow,
+        startColumnIndex: startColumn,
+        endColumnIndex: endColumn,
+    };
+};
+const sanitizeIndex = (value) => {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    return Math.max(1, Math.floor(value));
+};
+const normalizeMergeRanges = (ranges) => {
+    if (!ranges?.length)
+        return [];
+    const sanitized = ranges
+        .map((range) => sanitizeMergeRange(range))
+        .filter((range) => Boolean(range));
+    if (!sanitized.length)
+        return [];
+    const sorted = sanitized.sort((a, b) => {
+        if (a.startRowIndex !== b.startRowIndex) {
+            return a.startRowIndex - b.startRowIndex;
+        }
+        if (a.startColumnIndex !== b.startColumnIndex) {
+            return a.startColumnIndex - b.startColumnIndex;
+        }
+        if (a.endRowIndex !== b.endRowIndex) {
+            return b.endRowIndex - a.endRowIndex;
+        }
+        return b.endColumnIndex - a.endColumnIndex;
+    });
+    const valid = [];
+    let active = [];
+    for (const merge of sorted) {
+        if (active.length) {
+            active = active.filter((entry) => entry.endRowIndex >= merge.startRowIndex);
+        }
+        const isContained = active.some((entry) => entry.startColumnIndex <= merge.startColumnIndex &&
+            entry.endColumnIndex >= merge.endColumnIndex &&
+            entry.endRowIndex >= merge.endRowIndex);
+        if (!isContained) {
+            valid.push(merge);
+            active.push(merge);
+        }
+    }
+    return valid;
+};
+const buildRangeList = (ranges, sheetName) => {
+    const refs = ranges
+        .map((range) => buildOdsRangeAddress(range, sheetName))
+        .filter((entry) => Boolean(entry));
+    if (!refs.length)
+        return "";
+    return refs.join(" ");
+};
+const buildRangeListForValidations = (ranges, sheetNameById) => {
+    const refs = ranges
+        .map((range) => {
+        const sheetName = sheetNameById.get(range.sheetId ?? 0);
+        if (!sheetName)
+            return undefined;
+        return buildOdsRangeAddress(range, sheetName);
+    })
+        .filter((entry) => Boolean(entry));
+    if (!refs.length)
+        return "";
+    return refs.join(" ");
+};
+const buildValidationBaseCellAddress = (ranges, sheetNameById) => {
+    if (!ranges.length)
+        return undefined;
+    const range = ranges[0];
+    const sheetName = sheetNameById.get(range.sheetId ?? 0);
+    if (!sheetName)
+        return undefined;
+    return buildOdsBaseAddress(range, sheetName);
+};
+const buildCalcextRangeList = (ranges, sheetName) => {
+    const refs = ranges
+        .map((range) => buildCalcextRangeAddress(range, sheetName))
+        .filter((entry) => Boolean(entry));
+    if (!refs.length)
+        return "";
+    return refs.join(" ");
+};
+const buildOdsRangeAddress = (range, sheetName) => {
+    try {
+        const ref = cellRangeToAddress(undefined, range);
+        if (!ref)
+            return undefined;
+        return `${escapeSheetName(sheetName)}.${ref}`;
+    }
+    catch {
+        return undefined;
+    }
+};
+const buildOdsBaseAddress = (range, sheetName) => {
+    try {
+        const ref = cellToAddress({
+            rowIndex: range.startRowIndex,
+            columnIndex: range.startColumnIndex,
+        });
+        if (!ref)
+            return undefined;
+        return `${escapeSheetName(sheetName)}.${ref}`;
+    }
+    catch {
+        return undefined;
+    }
+};
+const buildCalcextRangeAddress = (range, sheetName) => {
+    try {
+        const startCol = columnIndexToLetter(range.startColumnIndex);
+        const endCol = columnIndexToLetter(range.endColumnIndex);
+        const start = `$${escapeSheetName(sheetName)}.$${startCol}$${range.startRowIndex}`;
+        const end = `$${escapeSheetName(sheetName)}.$${endCol}$${range.endRowIndex}`;
+        return `${start}:${end}`;
+    }
+    catch {
+        return undefined;
+    }
+};
+const buildCalcextBaseAddress = (range, sheetName) => {
+    try {
+        const ref = cellToAddress({
+            rowIndex: range.startRowIndex,
+            columnIndex: range.startColumnIndex,
+        });
+        if (!ref)
+            return undefined;
+        return `${escapeSheetName(sheetName)}.${ref}`;
+    }
+    catch {
+        return undefined;
+    }
+};
+const buildOdsRangeAddressAbsolute = (range, sheetName) => {
+    try {
+        const startCol = columnIndexToLetter(range.startColumnIndex);
+        const endCol = columnIndexToLetter(range.endColumnIndex);
+        const ref = `.$${startCol}$${range.startRowIndex}:.${`$${endCol}$${range.endRowIndex}`}`;
+        return `$${escapeSheetName(sheetName)}${ref}`;
+    }
+    catch {
+        return undefined;
+    }
+};
+const buildOdsBaseAddressAbsolute = (range, sheetName) => {
+    try {
+        const col = columnIndexToLetter(range.startColumnIndex);
+        const ref = `.$${col}$${range.startRowIndex}`;
+        return `$${escapeSheetName(sheetName)}${ref}`;
+    }
+    catch {
+        return undefined;
+    }
+};
+function isValidNamedRangeName(name) {
+    if (!name)
+        return false;
+    if (/^\d/.test(name))
+        return false;
+    if (!/^[A-Za-z_][A-Za-z0-9_.]*$/.test(name))
+        return false;
+    if (/^[A-Za-z]{1,3}\d+$/.test(name))
+        return false;
+    return true;
+}
+const rangesEqual = (left, right) => {
+    if (!left || !right)
+        return false;
+    return (left.startRowIndex === right.startRowIndex &&
+        left.endRowIndex === right.endRowIndex &&
+        left.startColumnIndex === right.startColumnIndex &&
+        left.endColumnIndex === right.endColumnIndex);
+};
+const escapeSheetName = (name) => {
+    return `'${name.replace(/'/g, "''")}'`;
+};
+const columnIndexToLetter = (index) => {
+    let dividend = Math.max(1, index);
+    let columnName = "";
+    while (dividend > 0) {
+        const modulo = (dividend - 1) % 26;
+        columnName = String.fromCharCode(65 + modulo) + columnName;
+        dividend = Math.floor((dividend - modulo) / 26);
+    }
+    return columnName;
+};
+const stableStringify = (value) => {
+    return JSON.stringify(value, (_key, val) => {
+        if (val && typeof val === "object" && !Array.isArray(val)) {
+            return Object.keys(val)
+                .sort()
+                .reduce((acc, key) => {
+                acc[key] = val[key];
+                return acc;
+            }, {});
+        }
+        return val;
+    });
+};
+const normalizeCellFormat = (format) => {
+    const normalized = {};
+    if (format.backgroundColor)
+        normalized.backgroundColor = format.backgroundColor;
+    if (format.borders)
+        normalized.borders = format.borders;
+    if (format.textFormat)
+        normalized.textFormat = format.textFormat;
+    if (format.numberFormat)
+        normalized.numberFormat = format.numberFormat;
+    if (format.horizontalAlignment)
+        normalized.horizontalAlignment = format.horizontalAlignment;
+    if (format.verticalAlignment)
+        normalized.verticalAlignment = format.verticalAlignment;
+    if (format.wrapStrategy)
+        normalized.wrapStrategy = format.wrapStrategy;
+    if (format.indent)
+        normalized.indent = format.indent;
+    if (format.textRotation !== undefined)
+        normalized.textRotation = format.textRotation;
+    return normalized;
+};
+const normalizeColor = (color, theme) => {
+    if (!color)
+        return undefined;
+    if (typeof color === "string") {
+        const normalized = color.startsWith("#") ? color : `#${color}`;
+        return normalized.length === 7 ? normalized : undefined;
+    }
+    if (color.rgb) {
+        const rgb = color.rgb;
+        const normalized = rgb.startsWith("#") ? rgb : `#${rgb}`;
+        return normalized.length === 7 ? normalized : undefined;
+    }
+    if (typeof color.theme === "number") {
+        return resolveThemeColor(color, theme);
+    }
+    return undefined;
+};
+const THEME_COLOR_KEYS = {
+    0: "background1",
+    1: "text1",
+    2: "background2",
+    3: "text2",
+    4: "accent1",
+    5: "accent2",
+    6: "accent3",
+    7: "accent4",
+    8: "accent5",
+    9: "accent6",
+    10: "hyperlink",
+};
+const resolveThemeColor = (color, theme) => {
+    const themeKey = THEME_COLOR_KEYS[color.theme];
+    if (!themeKey)
+        return undefined;
+    const themeColors = theme?.themeColors ?? defaultSpreadsheetTheme.themeColors;
+    const base = themeColors[themeKey];
+    if (!base)
+        return undefined;
+    return applyTint(base, color.tint ?? undefined);
+};
+const applyTint = (hex, tint) => {
+    if (tint == null || tint === 0)
+        return hex;
+    const normalized = hex.startsWith("#") ? hex.slice(1) : hex;
+    if (normalized.length !== 6)
+        return `#${normalized}`;
+    const r = parseInt(normalized.slice(0, 2), 16);
+    const g = parseInt(normalized.slice(2, 4), 16);
+    const b = parseInt(normalized.slice(4, 6), 16);
+    const applyChannel = (channel) => {
+        if (tint < 0) {
+            return Math.round(channel * (1 + tint));
+        }
+        return Math.round(channel * (1 - tint) + 255 * tint);
+    };
+    const toHex = (value) => Math.max(0, Math.min(255, value)).toString(16).padStart(2, "0");
+    return `#${toHex(applyChannel(r))}${toHex(applyChannel(g))}${toHex(applyChannel(b))}`;
+};
+const mapVerticalAlignment = (value) => {
+    if (value === "middle")
+        return "middle";
+    return value ?? "bottom";
+};
+const buildZipStore = (entries) => {
+    const normalized = entries.map((entry) => {
+        const nameBytes = textEncoder.encode(entry.name);
+        const data = entry.data;
+        const crc = crc32(data);
+        return {
+            name: entry.name,
+            nameBytes,
+            data,
+            crc,
+            localSize: 30 + nameBytes.length + data.length,
+            centralSize: 46 + nameBytes.length,
+            localOffset: 0,
+        };
+    });
+    const totalLocal = normalized.reduce((sum, entry) => sum + entry.localSize, 0);
+    const totalCentral = normalized.reduce((sum, entry) => sum + entry.centralSize, 0);
+    const endSize = 22;
+    const totalSize = totalLocal + totalCentral + endSize;
+    const buffer = new Uint8Array(totalSize);
+    const view = new DataView(buffer.buffer);
+    let cursor = 0;
+    for (const entry of normalized) {
+        entry.localOffset = cursor;
+        cursor = writeUint32(view, cursor, 0x04034b50);
+        cursor = writeUint16(view, cursor, 20);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint32(view, cursor, entry.crc);
+        cursor = writeUint32(view, cursor, entry.data.length);
+        cursor = writeUint32(view, cursor, entry.data.length);
+        cursor = writeUint16(view, cursor, entry.nameBytes.length);
+        cursor = writeUint16(view, cursor, 0);
+        buffer.set(entry.nameBytes, cursor);
+        cursor += entry.nameBytes.length;
+        buffer.set(entry.data, cursor);
+        cursor += entry.data.length;
+    }
+    const centralOffset = cursor;
+    for (const entry of normalized) {
+        cursor = writeUint32(view, cursor, 0x02014b50);
+        cursor = writeUint16(view, cursor, 20);
+        cursor = writeUint16(view, cursor, 20);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint32(view, cursor, entry.crc);
+        cursor = writeUint32(view, cursor, entry.data.length);
+        cursor = writeUint32(view, cursor, entry.data.length);
+        cursor = writeUint16(view, cursor, entry.nameBytes.length);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint16(view, cursor, 0);
+        cursor = writeUint32(view, cursor, 0);
+        cursor = writeUint32(view, cursor, entry.localOffset);
+        buffer.set(entry.nameBytes, cursor);
+        cursor += entry.nameBytes.length;
+    }
+    const centralSize = cursor - centralOffset;
+    cursor = writeUint32(view, cursor, 0x06054b50);
+    cursor = writeUint16(view, cursor, 0);
+    cursor = writeUint16(view, cursor, 0);
+    cursor = writeUint16(view, cursor, normalized.length);
+    cursor = writeUint16(view, cursor, normalized.length);
+    cursor = writeUint32(view, cursor, centralSize);
+    cursor = writeUint32(view, cursor, centralOffset);
+    cursor = writeUint16(view, cursor, 0);
+    return buffer.buffer;
+};
+const writeUint16 = (view, offset, value) => {
+    view.setUint16(offset, value, true);
+    return offset + 2;
+};
+const writeUint32 = (view, offset, value) => {
+    view.setUint32(offset, value >>> 0, true);
+    return offset + 4;
+};
+let crcTable = null;
+const getCrcTable = () => {
+    if (crcTable)
+        return crcTable;
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[i] = c >>> 0;
+    }
+    crcTable = table;
+    return table;
+};
+const crc32 = (data) => {
+    const table = getCrcTable();
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc = table[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+};
+const borderToCss = (border, theme) => {
+    if (!border?.style)
+        return undefined;
+    const width = border.width ? Math.max(0.5, border.width) : 1;
+    const color = normalizeColor(border.color ?? undefined, theme) ?? "#000000";
+    return `${width}px solid ${color}`;
+};
+const buildOdsConditionExpression = (formula, namedRangeNames) => {
+    const trimmed = formula.startsWith("=") ? formula.slice(1) : formula;
+    return sanitizeXmlText(convertExcelFormulaToOds(trimmed, namedRangeNames));
+};
+const convertExcelFormulaToOds = (formula, namedRangeNames) => {
+    if (!formula)
+        return formula;
+    const stringRegex = /"([^"]|"")*"/g;
+    let result = "";
+    let lastIndex = 0;
+    let match;
+    while ((match = stringRegex.exec(formula)) !== null) {
+        const before = formula.slice(lastIndex, match.index);
+        result += convertExcelSegmentToOds(convertArgumentSeparators(before), namedRangeNames);
+        result += match[0];
+        lastIndex = match.index + match[0].length;
+    }
+    result += convertExcelSegmentToOds(convertArgumentSeparators(formula.slice(lastIndex)), namedRangeNames);
+    return result;
+};
+const convertExcelSegmentToOds = (segment, namedRangeNames) => {
+    if (!segment)
+        return segment;
+    let converted = segment.replace(/('([^']|'')+'|[A-Za-z0-9_]+)!\$?[A-Za-z]{1,3}\$?\d+(?::\$?[A-Za-z]{1,3}\$?\d+)?/g, (match) => {
+        const [sheetPart, refPart] = match.split("!");
+        const sheetName = formatOdsSheetName(sheetPart);
+        if (!sheetName)
+            return match;
+        if (refPart.includes(":")) {
+            const [start, end] = refPart.split(":");
+            return `[$${sheetName}.${start}:$${sheetName}.${end}]`;
+        }
+        return `[$${sheetName}.${refPart}]`;
+    });
+    const parts = splitByBracketedSegments(converted);
+    converted = parts
+        .map((part) => {
+        if (part.isBracket)
+            return part.value;
+        return convertLocalRefsToOds(part.value, namedRangeNames);
+    })
+        .join("");
+    return converted;
+};
+const convertArgumentSeparators = (formula) => {
+    if (!formula)
+        return formula;
+    let result = "";
+    let parenDepth = 0;
+    for (let i = 0; i < formula.length; i++) {
+        const char = formula[i];
+        if (char === "(") {
+            parenDepth += 1;
+            result += char;
+            continue;
+        }
+        if (char === ")") {
+            parenDepth = Math.max(0, parenDepth - 1);
+            result += char;
+            continue;
+        }
+        if (char === "," && parenDepth > 0) {
+            while (formula[i + 1] === " ") {
+                i += 1;
+            }
+            result += ";";
+            continue;
+        }
+        result += char;
+    }
+    return result;
+};
+const splitByBracketedSegments = (value) => {
+    const regex = /\[[^\]]+\]/g;
+    const segments = [];
+    let lastIndex = 0;
+    let match;
+    while ((match = regex.exec(value)) !== null) {
+        if (match.index > lastIndex) {
+            segments.push({
+                value: value.slice(lastIndex, match.index),
+                isBracket: false,
+            });
+        }
+        segments.push({ value: match[0], isBracket: true });
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < value.length) {
+        segments.push({ value: value.slice(lastIndex), isBracket: false });
+    }
+    return segments;
+};
+const convertLocalRefsToOds = (value, namedRangeNames) => {
+    let converted = value.replace(/(\$?[A-Za-z]{1,3}\$?\d+):(\$?[A-Za-z]{1,3}\$?\d+)/g, (match, start, end, offset) => {
+        if (!isValidRefBoundary(value, offset, match.length)) {
+            return match;
+        }
+        if (isNamedRangeToken(start, namedRangeNames))
+            return match;
+        if (isNamedRangeToken(end, namedRangeNames))
+            return match;
+        return `[.${start}:.${end}]`;
+    });
+    const parts = splitByBracketedSegments(converted);
+    converted = parts
+        .map((part) => {
+        if (part.isBracket)
+            return part.value;
+        return part.value.replace(/(\$?[A-Za-z]{1,3}\$?\d+)/g, (match, ref, offset) => {
+            if (!isValidRefBoundary(part.value, offset, match.length)) {
+                return match;
+            }
+            if (isNamedRangeToken(ref, namedRangeNames)) {
+                return match;
+            }
+            return `[.${ref}]`;
+        });
+    })
+        .join("");
+    return converted;
+};
+const isValidRefBoundary = (text, offset, length) => {
+    const prev = offset > 0 ? text[offset - 1] : "";
+    const next = offset + length < text.length ? text[offset + length] : "";
+    if (prev && /[A-Za-z0-9_.]/.test(prev))
+        return false;
+    if (next && /[A-Za-z0-9_.]/.test(next))
+        return false;
+    return true;
+};
+const isNamedRangeToken = (token, namedRangeNames) => {
+    if (!namedRangeNames || !token)
+        return false;
+    const normalized = token.replace(/\$/g, "").toUpperCase();
+    return namedRangeNames.has(normalized);
+};
+const formatOdsSheetName = (sheet) => {
+    if (!sheet)
+        return sheet;
+    let normalized = sheet;
+    if (normalized.startsWith("'") && normalized.endsWith("'")) {
+        normalized = normalized.slice(1, -1).replace(/''/g, "'");
+    }
+    if (/[^A-Za-z0-9_]/.test(normalized)) {
+        return `'${normalized.replace(/'/g, "''")}'`;
+    }
+    return normalized;
+};
+const groupEmbedsBySheet = (embeds) => {
+    const result = new Map();
+    for (const embed of embeds ?? []) {
+        if (!embed.position?.overlayPosition)
+            continue;
+        if (embed.spec?.type !== "image")
+            continue;
+        const overlay = embed.position.overlayPosition;
+        const placement = {
+            kind: "embed",
+            imageUrl: embed.spec.imageUrl,
+            rowIndex: overlay.anchorCell.rowIndex,
+            columnIndex: overlay.anchorCell.columnIndex,
+            offsetX: overlay.offsetXPixels ?? 0,
+            offsetY: overlay.offsetYPixels ?? 0,
+            width: overlay.widthPixels ?? 120,
+            height: overlay.heightPixels ?? 120,
+        };
+        const list = result.get(embed.position.sheetId) ?? [];
+        list.push(placement);
+        result.set(embed.position.sheetId, list);
+    }
+    return result;
+};
+const groupChartsBySheet = (charts) => {
+    const result = new Map();
+    for (const chart of charts ?? []) {
+        const overlay = chart.position?.overlayPosition;
+        if (!overlay)
+            continue;
+        const placement = {
+            chart,
+            rowIndex: overlay.anchorCell.rowIndex,
+            columnIndex: overlay.anchorCell.columnIndex,
+            offsetX: overlay.offsetXPixels ?? 0,
+            offsetY: overlay.offsetYPixels ?? 0,
+            width: overlay.widthPixels ?? 300,
+            height: overlay.heightPixels ?? 200,
+        };
+        const list = result.get(chart.position.sheetId) ?? [];
+        list.push(placement);
+        result.set(chart.position.sheetId, list);
+    }
+    return result;
+};
+const buildEmbedFramesXml = async ({ embeds, mediaEntries, sheetName, sheet, }) => {
+    if (!embeds.length)
+        return [];
+    const frames = [];
+    for (const placement of embeds) {
+        const dataUrl = await resolveImageDataUrl(placement.imageUrl);
+        if (!dataUrl)
+            continue;
+        const buffer = dataUriToBuffer(dataUrl, placement.imageUrl);
+        if (!buffer)
+            continue;
+        const mediaPath = `Pictures/image${mediaEntries.length + 1}.${buffer.extension}`;
+        mediaEntries.push({
+            path: mediaPath,
+            data: buffer.data,
+            mime: buffer.contentType,
+        });
+        const widthPx = Math.max(5, placement.width ?? 120);
+        const heightPx = Math.max(5, placement.height ?? 120);
+        const offsetXPx = placement.offsetX ?? 0;
+        const offsetYPx = placement.offsetY ?? 0;
+        const width = pxToCm(widthPx).toFixed(2);
+        const height = pxToCm(heightPx).toFixed(2);
+        const origin = getCellOriginPx(sheet, placement.rowIndex, placement.columnIndex);
+        const offsetX = pxToCm(origin.x + offsetXPx).toFixed(2);
+        const offsetY = pxToCm(origin.y + offsetYPx).toFixed(2);
+        const anchorRef = cellToAddress({
+            rowIndex: placement.rowIndex,
+            columnIndex: placement.columnIndex,
+        });
+        const anchorCell = anchorRef ?? undefined;
+        const anchorAttr = anchorCell
+            ? ` table:anchor-cell-address="${escapeXmlAddress(anchorCell)}"`
+            : "";
+        const endColumn = resolveAnchorEndpoint({
+            startIndex: placement.columnIndex,
+            startOffset: offsetXPx,
+            span: widthPx,
+            getSize: (index) => getColumnWidthPx(sheet, index),
+        });
+        const endRow = resolveAnchorEndpoint({
+            startIndex: placement.rowIndex,
+            startOffset: offsetYPx,
+            span: heightPx,
+            getSize: (index) => getRowHeightPx(sheet, index),
+        });
+        const endRef = cellToAddress({
+            rowIndex: endRow.index,
+            columnIndex: endColumn.index,
+        });
+        const endCell = endRef ?? undefined;
+        const endCellAttr = endCell
+            ? ` table:end-cell-address="${escapeXmlAddress(endCell)}"`
+            : "";
+        const endX = pxToCm(endColumn.offset).toFixed(2);
+        const endY = pxToCm(endRow.offset).toFixed(2);
+        frames.push(`<draw:frame draw:name="Image${mediaEntries.length}" svg:width="${width}cm" svg:height="${height}cm" svg:x="${offsetX}cm" svg:y="${offsetY}cm" table:anchor-type="cell"${anchorAttr}${endCellAttr} table:end-x="${endX}cm" table:end-y="${endY}cm"><draw:image xlink:href="${mediaPath}" xlink:type="simple" xlink:show="embed" xlink:actuate="onLoad"/></draw:frame>`);
+    }
+    return frames;
+};
+const getDefaultColumnWidthPx = (sheet) => {
+    if (sheet?.defaultColumnWidth) {
+        return Number(sheet.defaultColumnWidth) || DEFAULT_COLUMN_WIDTH_PX;
+    }
+    return DEFAULT_COLUMN_WIDTH_PX;
+};
+const getColumnWidthPx = (sheet, columnIndex) => {
+    const metadata = sheet.columnMetadata?.[columnIndex];
+    if (metadata?.size && metadata.size > 0) {
+        return metadata.size;
+    }
+    return getDefaultColumnWidthPx(sheet);
+};
+const getDefaultRowHeightPx = (sheet) => {
+    if (sheet?.defaultRowHeight) {
+        return Number(sheet.defaultRowHeight) || DEFAULT_ROW_HEIGHT_PX;
+    }
+    return DEFAULT_ROW_HEIGHT_PX;
+};
+const getRowHeightPx = (sheet, rowIndex) => {
+    const metadata = sheet.rowMetadata?.[rowIndex];
+    if (metadata?.size && metadata.resizedByUser) {
+        return metadata.size;
+    }
+    return getDefaultRowHeightPx(sheet);
+};
+const getCellSizePx = (sheet, rowIndex, columnIndex, mergeSpan) => {
+    const columns = Math.max(1, mergeSpan?.columns ?? 1);
+    const rows = Math.max(1, mergeSpan?.rows ?? 1);
+    let width = 0;
+    for (let col = 0; col < columns; col += 1) {
+        width += getColumnWidthPx(sheet, columnIndex + col);
+    }
+    let height = 0;
+    for (let row = 0; row < rows; row += 1) {
+        height += getRowHeightPx(sheet, rowIndex + row);
+    }
+    return {
+        width: Math.max(5, width),
+        height: Math.max(5, height),
+    };
+};
+const getCellOriginPx = (sheet, rowIndex, columnIndex) => {
+    let x = 0;
+    for (let col = 1; col < columnIndex; col += 1) {
+        x += getColumnWidthPx(sheet, col);
+    }
+    let y = 0;
+    for (let row = 1; row < rowIndex; row += 1) {
+        y += getRowHeightPx(sheet, row);
+    }
+    return { x, y };
+};
+const resolveAnchorEndpoint = ({ startIndex, startOffset, span, getSize, }) => {
+    let remaining = Math.max(0, span);
+    let index = Math.max(1, startIndex);
+    let offset = Math.max(0, startOffset);
+    while (remaining > 0) {
+        const size = Math.max(1, getSize(index));
+        const available = size - offset;
+        if (remaining <= available) {
+            return {
+                index,
+                offset: offset + remaining,
+            };
+        }
+        remaining -= available;
+        index += 1;
+        offset = 0;
+    }
+    return { index, offset };
+};
+const buildChartObjectXml = (chart, sheetNameById) => {
+    const spec = chart.spec;
+    const series = spec?.series ?? [];
+    if (!series.length)
+        return undefined;
+    const domain = spec?.domains?.[0]?.sources?.[0];
+    const domainRange = domain
+        ? buildChartRangeAddress(domain, sheetNameById)
+        : undefined;
+    const seriesRanges = series
+        .map((entry) => entry?.sources?.[0])
+        .map((range) => range ? buildChartRangeAddress(range, sheetNameById) : undefined)
+        .filter((range) => Boolean(range));
+    if (!seriesRanges.length)
+        return undefined;
+    const typeMap = {
+        bar: "chart:bar",
+        column: "chart:bar",
+        line: "chart:line",
+        pie: "chart:circle",
+        scatter: "chart:scatter",
+        area: "chart:area",
+    };
+    const chartClass = typeMap[spec.chartType] ?? "chart:bar";
+    const title = spec.title
+        ? `<chart:title><text:p>${escapeXml(String(spec.title))}</text:p></chart:title>`
+        : "";
+    const seriesPalette = [
+        "#4285f4",
+        "#ea4335",
+        "#fbbc04",
+        "#34a853",
+        "#ff6d01",
+        "#46bdc6",
+    ];
+    // Series chart styles + (optional) gradient defs. When a series
+    // carries an explicit gradient we emit a `<draw:gradient>` def
+    // alongside it and reference the def via `draw:fill-gradient-name`
+    // on the series's graphic-properties. ODS uses 1/10ths of a degree
+    // for `draw:angle` (so a 90° XLSX gradient is `900` here) and
+    // `linear` / `radial` for the two flavors we round-trip.
+    const gradientDefs = [];
+    const seriesStyles = seriesRanges
+        .map((_range, index) => {
+        const color = seriesPalette[index % seriesPalette.length];
+        const seriesData = series[index];
+        const gradient = seriesData?.gradient;
+        if (gradient && gradient.stops?.length >= 2) {
+            const gradName = `grad${index}`;
+            const startColor = gradient.stops[0].color;
+            const endColor = gradient.stops[gradient.stops.length - 1].color;
+            if (gradient.type === "path") {
+                // Path / radial. ODS center is in 0..100% — use the inset
+                // midpoints if supplied, fall back to dead center.
+                const cx = Math.round((((gradient.left ?? 0) + (1 - (gradient.right ?? 0))) / 2) * 100);
+                const cy = Math.round((((gradient.top ?? 0) + (1 - (gradient.bottom ?? 0))) / 2) * 100);
+                gradientDefs.push(`<draw:gradient draw:name="${gradName}" draw:style="radial" draw:start-color="${startColor}" draw:end-color="${endColor}" draw:start-intensity="100%" draw:end-intensity="100%" draw:cx="${cx}%" draw:cy="${cy}%"/>`);
+            }
+            else {
+                // XLSX `degree` (0..360 clockwise from right) ↔ ODS
+                // `draw:angle` (0..3600 = 1/10° units; 0 is "upward").
+                // We don't try to reconcile the start-of-axis difference —
+                // most viewers tolerate either convention as long as the
+                // two endpoints match.
+                const angle = Math.round((gradient.degree ?? 0) * 10);
+                gradientDefs.push(`<draw:gradient draw:name="${gradName}" draw:style="linear" draw:start-color="${startColor}" draw:end-color="${endColor}" draw:start-intensity="100%" draw:end-intensity="100%" draw:angle="${angle}"/>`);
+            }
+            return `<style:style style:name="series${index}" style:family="chart"><style:graphic-properties svg:stroke-color="${startColor}" svg:stroke-width="0.08cm" draw:fill="gradient" draw:fill-gradient-name="${gradName}"/></style:style>`;
+        }
+        const fillColor = seriesData?.color || color;
+        return `<style:style style:name="series${index}" style:family="chart"><style:graphic-properties svg:stroke-color="${fillColor}" svg:stroke-width="0.08cm" draw:fill="none"/></style:style>`;
+    })
+        .join("");
+    const gradientDefsXml = gradientDefs.join("");
+    let hasSeriesLabels = false;
+    const seriesXml = seriesRanges
+        .map((range, index) => {
+        const labelAddress = buildChartLabelAddress(series[index]?.dataLabel, sheetNameById, chart.position?.sheetId) ||
+            buildChartLabelAddressFromRange(series[index]?.sources?.[0], sheetNameById);
+        const labelAttr = labelAddress
+            ? ` chart:label-cell-address="${escapeXmlAddress(labelAddress)}"`
+            : "";
+        if (labelAddress) {
+            hasSeriesLabels = true;
+        }
+        const count = getRangePointCount(series[index]?.sources?.[0]);
+        const pointsXml = count
+            ? `<chart:data-point chart:repeated="${count}"/>`
+            : "";
+        return `<chart:series chart:class="${chartClass}" chart:style-name="series${index}" chart:values-cell-range-address="${escapeXmlAddress(range)}"${labelAttr}>${pointsXml}</chart:series>`;
+    })
+        .join("");
+    const axisXml = chartClass === "chart:circle"
+        ? ""
+        : `<chart:axis chart:dimension="x" chart:name="primary-x" chart:style-name="axisx"><chart:title/></chart:axis><chart:axis chart:dimension="y" chart:name="primary-y" chart:style-name="axisy"><chart:title/></chart:axis>`;
+    const categoriesAttr = domainRange
+        ? ` chart:categories-cell-range-address="${escapeXmlAddress(domainRange)}"`
+        : "";
+    const labelMode = domainRange ? "both" : hasSeriesLabels ? "row" : "none";
+    const plotAreaAttrs = ` chart:data-source-has-labels="${labelMode}"${categoriesAttr}`;
+    const wallFloor = chartClass === "chart:circle"
+        ? ""
+        : `<chart:wall chart:style-name="wall1"/><chart:floor chart:style-name="floor1"/>`;
+    const legendXml = chartClass === "chart:circle"
+        ? ""
+        : `<chart:legend chart:legend-position="end" chart:legend-align="center" chart:style-name="legend1"/>`;
+    return `${XML_DECLARATION}<office:document-content xmlns:office="${ODS_NS.office}" xmlns:chart="${ODS_NS.chart}" xmlns:table="${ODS_NS.table}" xmlns:text="${ODS_NS.text}" xmlns:style="${ODS_NS.style}" xmlns:draw="${ODS_NS.draw}" xmlns:svg="${ODS_NS.svg}" xmlns:fo="${ODS_NS.fo}" office:version="1.2"><office:automatic-styles>${gradientDefsXml}<style:style style:name="ch1" style:family="chart"><style:graphic-properties draw:fill="solid" draw:fill-color="#ffffff"/></style:style><style:style style:name="plot1" style:family="chart"><style:graphic-properties draw:fill="solid" draw:fill-color="#ffffff" svg:stroke-color="#b3b3b3"/></style:style><style:style style:name="wall1" style:family="chart"><style:graphic-properties draw:fill="solid" draw:fill-color="#ffffff" svg:stroke-color="#b3b3b3" svg:stroke-width="0.01cm"/></style:style><style:style style:name="floor1" style:family="chart"><style:graphic-properties draw:fill="none" svg:stroke-color="#b3b3b3"/></style:style><style:style style:name="legend1" style:family="chart"><style:graphic-properties draw:fill="none" svg:stroke-color="#b3b3b3"/><style:text-properties fo:font-size="10pt"/></style:style><style:style style:name="axisx" style:family="chart"><style:chart-properties chart:display-label="true" chart:tick-marks-major-inner="false" chart:tick-marks-major-outer="true"/><style:graphic-properties svg:stroke-color="#b3b3b3"/><style:text-properties fo:font-size="9pt"/></style:style><style:style style:name="axisy" style:family="chart"><style:chart-properties chart:display-label="true" chart:tick-marks-major-inner="false" chart:tick-marks-major-outer="true"/><style:graphic-properties svg:stroke-color="#b3b3b3"/><style:text-properties fo:font-size="9pt"/></style:style>${seriesStyles}</office:automatic-styles><office:body><office:chart><chart:chart chart:class="${chartClass}" chart:style-name="ch1">${title}${legendXml}<chart:plot-area chart:style-name="plot1"${plotAreaAttrs}>${axisXml}${seriesXml}${wallFloor}</chart:plot-area></chart:chart></office:chart></office:body></office:document-content>`;
+};
+const buildChartRangeAddress = (range, sheetNameById) => {
+    const sheetName = sheetNameById.get(range.sheetId);
+    if (!sheetName)
+        return undefined;
+    const start = cellToAddress({
+        rowIndex: range.startRowIndex,
+        columnIndex: range.startColumnIndex,
+    }, true, true);
+    const end = cellToAddress({
+        rowIndex: range.endRowIndex,
+        columnIndex: range.endColumnIndex,
+    }, true, true);
+    if (!start || !end)
+        return undefined;
+    const escaped = escapeSheetName(sheetName);
+    return `${escaped}.${start}:${end}`;
+};
+const getRangePointCount = (range) => {
+    if (!range)
+        return undefined;
+    const rows = Math.abs(range.endRowIndex - range.startRowIndex) + 1;
+    const cols = Math.abs(range.endColumnIndex - range.startColumnIndex) + 1;
+    return Math.max(rows, cols);
+};
+const buildChartLabelAddress = (label, sheetNameById, sheetId) => {
+    if (!label)
+        return "";
+    if (label.startsWith("=")) {
+        const formula = label.slice(1).trim();
+        if (formula.includes("."))
+            return formula;
+        const sheetName = sheetId != null ? sheetNameById.get(sheetId) : undefined;
+        return sheetName ? `${escapeSheetName(sheetName)}.${formula}` : formula;
+    }
+    return "";
+};
+const buildChartLabelAddressFromRange = (range, sheetNameById) => {
+    if (!range || range.startRowIndex <= 1)
+        return "";
+    const sheetName = sheetNameById.get(range.sheetId);
+    if (!sheetName)
+        return "";
+    const labelRef = cellToAddress({
+        rowIndex: range.startRowIndex - 1,
+        columnIndex: range.startColumnIndex,
+    }, true, true);
+    if (!labelRef)
+        return "";
+    return `${escapeSheetName(sheetName)}.${labelRef}`;
+};
+const buildChartFramesXml = async ({ charts, sheet, sheetName, sheetNameById, startIndex, }) => {
+    if (!charts.length) {
+        return { frames: [], chartObjects: [], nextIndex: startIndex };
+    }
+    const frames = [];
+    const chartObjects = [];
+    let index = startIndex;
+    for (const placement of charts) {
+        const chartXml = buildChartObjectXml(placement.chart, sheetNameById);
+        if (!chartXml)
+            continue;
+        const folder = `Object ${index}`;
+        chartObjects.push({ folder, contentXml: chartXml });
+        const widthPx = Math.max(5, placement.width ?? 300);
+        const heightPx = Math.max(5, placement.height ?? 200);
+        const offsetXPx = placement.offsetX ?? 0;
+        const offsetYPx = placement.offsetY ?? 0;
+        const width = pxToCm(widthPx).toFixed(2);
+        const height = pxToCm(heightPx).toFixed(2);
+        const origin = getCellOriginPx(sheet, placement.rowIndex, placement.columnIndex);
+        const offsetX = pxToCm(origin.x + offsetXPx).toFixed(2);
+        const offsetY = pxToCm(origin.y + offsetYPx).toFixed(2);
+        const anchorRef = cellToAddress({
+            rowIndex: placement.rowIndex,
+            columnIndex: placement.columnIndex,
+        });
+        const anchorCell = anchorRef ?? undefined;
+        const anchorAttr = anchorCell
+            ? ` table:anchor-cell-address="${escapeXmlAddress(anchorCell)}"`
+            : "";
+        const endColumn = resolveAnchorEndpoint({
+            startIndex: placement.columnIndex,
+            startOffset: offsetXPx,
+            span: widthPx,
+            getSize: (index) => getColumnWidthPx(sheet, index),
+        });
+        const endRow = resolveAnchorEndpoint({
+            startIndex: placement.rowIndex,
+            startOffset: offsetYPx,
+            span: heightPx,
+            getSize: (index) => getRowHeightPx(sheet, index),
+        });
+        const endRef = cellToAddress({
+            rowIndex: endRow.index,
+            columnIndex: endColumn.index,
+        });
+        const endCell = endRef ?? undefined;
+        const endCellAttr = endCell
+            ? ` table:end-cell-address="${escapeXmlAddress(endCell)}"`
+            : "";
+        const endX = pxToCm(endColumn.offset).toFixed(2);
+        const endY = pxToCm(endRow.offset).toFixed(2);
+        frames.push(`<draw:frame draw:name="Chart${index}" svg:width="${width}cm" svg:height="${height}cm" svg:x="${offsetX}cm" svg:y="${offsetY}cm" table:anchor-type="cell"${anchorAttr}${endCellAttr} table:end-x="${endX}cm" table:end-y="${endY}cm"><draw:object xlink:href="${folder}" xlink:type="simple"/></draw:frame>`);
+        index += 1;
+    }
+    return { frames, chartObjects, nextIndex: index };
+};
+const buildCellImageXml = async ({ imageUrl, rowNumber, columnIndex, mergeSpan, sheet, mediaEntries, }) => {
+    if (!imageUrl)
+        return "";
+    const dataUrl = await resolveImageDataUrl(imageUrl);
+    if (!dataUrl)
+        return "";
+    const buffer = dataUriToBuffer(dataUrl, imageUrl);
+    if (!buffer)
+        return "";
+    const mediaPath = `Pictures/image${mediaEntries.length + 1}.${buffer.extension}`;
+    mediaEntries.push({
+        path: mediaPath,
+        data: buffer.data,
+        mime: buffer.contentType,
+    });
+    const size = getCellSizePx(sheet, rowNumber, columnIndex, mergeSpan);
+    const width = pxToCm(size.width).toFixed(2);
+    const height = pxToCm(size.height).toFixed(2);
+    return `<draw:frame draw:name="CellImage${mediaEntries.length}" svg:width="${width}cm" svg:height="${height}cm" table:anchor-type="cell"><draw:image xlink:href="${mediaPath}" xlink:type="simple" xlink:show="embed" xlink:actuate="onLoad"/></draw:frame>`;
+};
+const resolveImageDataUrl = async (imageUrl) => {
+    if (imageUrl.startsWith("data:")) {
+        return imageUrl;
+    }
+    try {
+        return await imageUrlToBase64(imageUrl);
+    }
+    catch {
+        return undefined;
+    }
+};
+const dataUriToBuffer = (dataUrl, fallbackName) => {
+    const match = /^data:(.+?);base64,(.+)$/.exec(dataUrl);
+    if (!match)
+        return undefined;
+    const [, mime, base64] = match;
+    const binaryString = decodeBase64(base64);
+    const buffer = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        buffer[i] = binaryString.charCodeAt(i);
+    }
+    const extension = mime.split("/")[1] ?? fallbackName?.split(".").pop() ?? "bin";
+    return {
+        data: buffer,
+        extension: extension.toLowerCase(),
+        contentType: mime,
+    };
+};
+const decodeBase64 = (value) => {
+    if (typeof atob === "function") {
+        return atob(value);
+    }
+    const bufferCtor = globalThis.Buffer;
+    if (bufferCtor) {
+        return bufferCtor.from(value, "base64").toString("binary");
+    }
+    throw new Error("Base64 decoding is not supported in this environment");
+};
+const prepareTables = (tables) => {
+    const result = [];
+    tables.forEach((table, index) => {
+        const ref = gridRangeToRef(table.range);
+        if (!ref)
+            return;
+        const id = index + 1;
+        const sanitized = sanitizeTableName(table.title ?? `Table${id}`);
+        result.push({
+            ...table,
+            id,
+            ref,
+            name: sanitized,
+        });
+    });
+    return result;
+};
+const sanitizeTableName = (name) => {
+    const cleaned = name.replace(/[^A-Za-z0-9_]/g, "") || "Table";
+    if (/^\d/.test(cleaned)) {
+        return `T${cleaned}`;
+    }
+    return cleaned;
+};
+const gridRangeToRef = (range) => {
+    if (!range)
+        return undefined;
+    try {
+        const ref = cellRangeToAddress(undefined, range);
+        return ref ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const convertDataValidationRule = (rule) => {
+    if (!rule?.condition?.type)
+        return undefined;
+    const { condition } = rule;
+    const values = condition.values ?? [];
+    const allowBlank = rule.allowBlank !== false;
+    const displayStyle = rule.displayStyle === "plain"
+        ? "none"
+        : rule.displayStyle === "arrow"
+            ? "list"
+            : undefined;
+    const inputMessage = rule.inputMessage;
+    const alert = rule.alert;
+    const base = {
+        allowEmptyCell: allowBlank,
+        displayList: displayStyle,
+        helpMessage: inputMessage
+            ? { title: inputMessage.title, message: inputMessage.message }
+            : undefined,
+        errorMessage: alert?.message
+            ? {
+                type: alert.style ?? "stop",
+                title: alert.message.title,
+                message: alert.message.message,
+            }
+            : undefined,
+    };
+    const ensureFormula = (value) => value.startsWith("=") ? value.slice(1) : value;
+    if (condition.type === "ONE_OF_LIST") {
+        const entries = values
+            .map((value) => value.userEnteredValue)
+            .filter((value) => typeof value === "string");
+        if (!entries.length)
+            return undefined;
+        const args = entries.map((entry) => `"${entry.replace(/"/g, '""')}"`);
+        return {
+            ...base,
+            condition: `of:cell-content-is-in-list(${args.join(";")})`, // Remove the = after of:
+            displayList: "unsorted",
+        };
+    }
+    if (condition.type === "ONE_OF_RANGE") {
+        const references = values
+            .map((value) => value.userEnteredValue)
+            .filter((value) => typeof value === "string");
+        if (!references.length)
+            return undefined;
+        const ref = references[0];
+        const normalized = ref.replace(/^=/, "");
+        return {
+            condition: `of:=cell-content-is-in-list(${normalized})`,
+            ...base,
+        };
+    }
+    if (condition.type === "CUSTOM_FORMULA") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        return {
+            condition: `of:=${ensureFormula(raw)}`,
+            ...base,
+        };
+    }
+    if (condition.type === "BOOLEAN") {
+        return {
+            condition: `of:=OR(cell-content()=TRUE(),cell-content()=FALSE())`,
+            ...base,
+        };
+    }
+    if (condition.type === "BLANK") {
+        return {
+            condition: `of:=cell-content()=""`,
+            ...base,
+        };
+    }
+    if (condition.type === "NOT_BLANK") {
+        return {
+            condition: `of:=cell-content()<>""`,
+            ...base,
+        };
+    }
+    if (condition.type === "TEXT_EQ" || condition.type === "TEXT_NOT_EQ") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        const op = condition.type === "TEXT_EQ" ? "=" : "<>";
+        return {
+            condition: `of:=cell-content()${op}"${raw.replace(/"/g, '""')}"`,
+            ...base,
+        };
+    }
+    if (condition.type === "TEXT_CONTAINS") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        return {
+            condition: `of:=ISNUMBER(SEARCH("${raw.replace(/"/g, '""')}",cell-content()))`,
+            ...base,
+        };
+    }
+    if (condition.type === "TEXT_NOT_CONTAINS") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        return {
+            condition: `of:=ISERROR(SEARCH("${raw.replace(/"/g, '""')}",cell-content()))`,
+            ...base,
+        };
+    }
+    if (condition.type === "TEXT_STARTS_WITH") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        return {
+            condition: `of:=LEFT(cell-content(),LEN("${raw.replace(/"/g, '""')}"))="${raw.replace(/"/g, '""')}"`,
+            ...base,
+        };
+    }
+    if (condition.type === "TEXT_ENDS_WITH") {
+        const raw = values[0]?.userEnteredValue ?? "";
+        if (!raw)
+            return undefined;
+        return {
+            condition: `of:=RIGHT(cell-content(),LEN("${raw.replace(/"/g, '""')}"))="${raw.replace(/"/g, '""')}"`,
+            ...base,
+        };
+    }
+    if (condition.type === "TEXT_IS_EMAIL") {
+        return {
+            condition: `of:=AND(ISNUMBER(SEARCH("@",cell-content())),ISNUMBER(SEARCH(".",cell-content())))`,
+            ...base,
+        };
+    }
+    if (condition.type === "TEXT_IS_URL") {
+        return {
+            condition: `of:=OR(LEFT(cell-content(),7)="http://",LEFT(cell-content(),8)="https://")`,
+            ...base,
+        };
+    }
+    if (condition.type === "NUMBER_BETWEEN" ||
+        condition.type === "NUMBER_NOT_BETWEEN" ||
+        condition.type === "NUMBER_EQ" ||
+        condition.type === "NUMBER_NOT_EQ" ||
+        condition.type === "NUMBER_GREATER" ||
+        condition.type === "NUMBER_GREATER_THAN_EQ" ||
+        condition.type === "NUMBER_LESS" ||
+        condition.type === "NUMBER_LESS_THAN_EQ") {
+        const first = values[0]?.userEnteredValue ?? "";
+        if (!first)
+            return undefined;
+        const second = values[1]?.userEnteredValue ?? "";
+        const opMap = {
+            NUMBER_BETWEEN: "cell-content-is-between",
+            NUMBER_NOT_BETWEEN: "cell-content-is-not-between",
+            NUMBER_EQ: "cell-content-is-equal-to",
+            NUMBER_NOT_EQ: "cell-content-is-not-equal-to",
+            NUMBER_GREATER: "cell-content-is-greater-than",
+            NUMBER_GREATER_THAN_EQ: "cell-content-is-greater-than-or-equal-to",
+            NUMBER_LESS: "cell-content-is-less-than",
+            NUMBER_LESS_THAN_EQ: "cell-content-is-less-than-or-equal-to",
+        };
+        const fn = opMap[condition.type];
+        if (!fn)
+            return undefined;
+        if (condition.type === "NUMBER_BETWEEN" ||
+            condition.type === "NUMBER_NOT_BETWEEN") {
+            return {
+                condition: `of:=${fn}(${first},${second})`,
+                ...base,
+            };
+        }
+        return {
+            condition: `of:=${fn}(${first})`,
+            ...base,
+        };
+    }
+    if (condition.type === "DATE_EQ" ||
+        condition.type === "DATE_NOT_EQ" ||
+        condition.type === "DATE_BEFORE" ||
+        condition.type === "DATE_AFTER" ||
+        condition.type === "DATE_ON_OR_BEFORE" ||
+        condition.type === "DATE_ON_OR_AFTER" ||
+        condition.type === "DATE_BETWEEN" ||
+        condition.type === "DATE_NOT_BETWEEN") {
+        const first = values[0]?.userEnteredValue ?? "";
+        if (!first)
+            return undefined;
+        const second = values[1]?.userEnteredValue ?? "";
+        const opMap = {
+            DATE_EQ: "cell-content-date-equal-to",
+            DATE_NOT_EQ: "cell-content-date-not-equal-to",
+            DATE_BEFORE: "cell-content-date-before",
+            DATE_AFTER: "cell-content-date-after",
+            DATE_ON_OR_BEFORE: "cell-content-date-on-or-before",
+            DATE_ON_OR_AFTER: "cell-content-date-on-or-after",
+            DATE_BETWEEN: "cell-content-date-is-between",
+            DATE_NOT_BETWEEN: "cell-content-date-is-not-between",
+        };
+        const fn = opMap[condition.type];
+        if (!fn)
+            return undefined;
+        if (condition.type === "DATE_BETWEEN" ||
+            condition.type === "DATE_NOT_BETWEEN") {
+            return {
+                condition: `of:=${fn}(${first},${second})`,
+                ...base,
+            };
+        }
+        return {
+            condition: `of:=${fn}(${first})`,
+            ...base,
+        };
+    }
+    if (condition.type === "DATE_IS_VALID") {
+        return {
+            condition: `of:=ISNUMBER(cell-content())`,
+            ...base,
+        };
+    }
+    return {
+        condition: `of:=cell-content()`,
+        ...base,
+    };
+};