@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/cjs/modules/word/convert/odt/odt.js

@@ -0,0 +1,1936 @@
+"use strict";
+/**
+ * DOCX Module - OpenDocument Text (ODT) Format Support
+ *
+ * Implements reading and writing of ODT (OpenDocument Text) files.
+ * ODT files are ZIP archives containing XML content in ODF namespaces.
+ *
+ * Main archive structure:
+ * - content.xml — document body and automatic styles
+ * - styles.xml — named styles, page layout, master pages
+ * - meta.xml — document metadata
+ * - META-INF/manifest.xml — manifest of all archive entries
+ * - Pictures/ — embedded images
+ *
+ * @stability experimental
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOdt = readOdt;
+exports.writeOdt = writeOdt;
+const create_archive_1 = require("../../../archive/create-archive.js");
+const read_archive_1 = require("../../../archive/read-archive.js");
+const dom_1 = require("../../../xml/dom.js");
+const writer_1 = require("../../../xml/writer.js");
+const internal_utils_1 = require("../../core/internal-utils");
+const text_utils_1 = require("../../core/text-utils");
+const errors_1 = require("../../errors");
+const units_1 = require("../../units");
+// =============================================================================
+// ODF Namespace Constants
+// =============================================================================
+/** ODF namespace URIs. */
+const 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",
+    dc: "http://purl.org/dc/elements/1.1/",
+    meta: "urn:oasis:names:tc:opendocument:xmlns:meta:1.0",
+    svg: "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0",
+    manifest: "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
+};
+// =============================================================================
+// Unit Conversion Helpers
+// =============================================================================
+/** Parse an ODF length value (e.g. "1.27cm", "0.5in", "12pt") to twips. */
+function odfLengthToTwips(value) {
+    if (!value) {
+        return undefined;
+    }
+    const match = value.match(/^(-?\d+(?:\.\d+)?)\s*(cm|mm|in|pt|pc|px|em)$/);
+    if (!match) {
+        return undefined;
+    }
+    const num = parseFloat(match[1]);
+    const unit = match[2];
+    switch (unit) {
+        case "cm":
+            return Math.round(num * 567);
+        case "mm":
+            return Math.round(num * 56.7);
+        case "in":
+            return Math.round(num * 1440);
+        case "pt":
+            return Math.round(num * 20);
+        case "pc":
+            return Math.round(num * 240);
+        case "px":
+            // Approximate: 1px ≈ 0.75pt at 96dpi
+            return Math.round(num * 15);
+        case "em":
+            // Approximate: 1em ≈ 12pt
+            return Math.round(num * 240);
+        default:
+            return undefined;
+    }
+}
+/** Parse an ODF length value to EMU (English Metric Units). */
+function odfLengthToEmu(value) {
+    if (!value) {
+        return undefined;
+    }
+    const match = value.match(/^(-?\d+(?:\.\d+)?)\s*(cm|mm|in|pt|pc|px)$/);
+    if (!match) {
+        return undefined;
+    }
+    const num = parseFloat(match[1]);
+    const unit = match[2];
+    switch (unit) {
+        case "cm":
+            return Math.round(num * units_1.EMU_PER_CM);
+        case "mm":
+            return Math.round((num * units_1.EMU_PER_CM) / 10);
+        case "in":
+            return Math.round(num * units_1.EMU_PER_INCH);
+        case "pt":
+            return Math.round(num * units_1.EMU_PER_POINT);
+        case "pc":
+            return Math.round(num * units_1.EMU_PER_POINT * 12); // 1 pica = 12 points
+        case "px":
+            return Math.round(num * units_1.EMU_PER_PX);
+        default:
+            return undefined;
+    }
+}
+/** Convert twips to ODF length string (cm). */
+function twipsToCm(twips) {
+    return (twips / 567).toFixed(3) + "cm";
+}
+/** Convert EMU to ODF length string (cm). */
+function emuToCm(emu) {
+    return (emu / units_1.EMU_PER_CM).toFixed(3) + "cm";
+}
+/** Convert half-points to pt string. */
+function halfPointsToPt(hp) {
+    return (hp / 2).toString() + "pt";
+}
+/** Parse a font size string (e.g. "12pt") to half-points. */
+function parseFontSizeToHalfPoints(value) {
+    if (!value) {
+        return undefined;
+    }
+    const match = value.match(/^(\d+(?:\.\d+)?)\s*pt$/);
+    if (!match) {
+        return undefined;
+    }
+    return Math.round(parseFloat(match[1]) * 2);
+}
+/** Parse a 6-digit hex color from ODF format (#RRGGBB). */
+function parseOdfColor(value) {
+    if (!value) {
+        return undefined;
+    }
+    const match = value.match(/^#([0-9a-fA-F]{6})$/);
+    if (!match) {
+        return undefined;
+    }
+    return match[1].toUpperCase();
+}
+/** Convert a hex color to ODF format (#RRGGBB). */
+function colorToOdf(hex) {
+    return `#${hex}`;
+}
+// =============================================================================
+// XML Element Query Helpers (Namespace-Aware)
+// =============================================================================
+/**
+ * Find a child element by namespace-prefixed name.
+ * Tries both "prefix:local" and just "local" for flexibility.
+ */
+function findNsChild(el, prefix, local) {
+    return (0, dom_1.findChild)(el, `${prefix}:${local}`) ?? (0, dom_1.findChild)(el, local);
+}
+/** Find all children by namespace-prefixed name. */
+function findNsChildren(el, prefix, local) {
+    const result = (0, dom_1.findChildren)(el, `${prefix}:${local}`);
+    if (result.length > 0) {
+        return result;
+    }
+    return (0, dom_1.findChildren)(el, local);
+}
+/** Get an attribute value with a namespace prefix. */
+function nsAttr(el, prefix, local) {
+    return el.attributes[`${prefix}:${local}`] ?? el.attributes[local];
+}
+// =============================================================================
+// ODF Style Parsing
+// =============================================================================
+/** Parse style properties from a style:style element. */
+function parseOdfStyle(el) {
+    const name = nsAttr(el, "style", "name") ?? "";
+    const family = nsAttr(el, "style", "family") ?? "";
+    const parentStyle = nsAttr(el, "style", "parent-style-name");
+    let paragraphProperties;
+    let textProperties;
+    let tableProperties;
+    let tableColumnProperties;
+    let tableCellProperties;
+    const pPropsEl = findNsChild(el, "style", "paragraph-properties");
+    if (pPropsEl) {
+        paragraphProperties = {
+            textAlign: nsAttr(pPropsEl, "fo", "text-align"),
+            marginTop: nsAttr(pPropsEl, "fo", "margin-top"),
+            marginBottom: nsAttr(pPropsEl, "fo", "margin-bottom"),
+            marginLeft: nsAttr(pPropsEl, "fo", "margin-left"),
+            marginRight: nsAttr(pPropsEl, "fo", "margin-right"),
+            textIndent: nsAttr(pPropsEl, "fo", "text-indent"),
+            lineHeight: nsAttr(pPropsEl, "fo", "line-height"),
+            breakBefore: nsAttr(pPropsEl, "fo", "break-before"),
+            keepWithNext: nsAttr(pPropsEl, "fo", "keep-with-next")
+        };
+    }
+    const tPropsEl = findNsChild(el, "style", "text-properties");
+    if (tPropsEl) {
+        textProperties = {
+            fontName: nsAttr(tPropsEl, "style", "font-name") ?? nsAttr(tPropsEl, "fo", "font-family"),
+            fontSize: nsAttr(tPropsEl, "fo", "font-size"),
+            fontWeight: nsAttr(tPropsEl, "fo", "font-weight"),
+            fontStyle: nsAttr(tPropsEl, "fo", "font-style"),
+            textDecoration: nsAttr(tPropsEl, "style", "text-underline-style") ??
+                nsAttr(tPropsEl, "style", "text-line-through-style"),
+            color: nsAttr(tPropsEl, "fo", "color"),
+            backgroundColor: nsAttr(tPropsEl, "fo", "background-color"),
+            textPosition: nsAttr(tPropsEl, "style", "text-position"),
+            fontVariant: nsAttr(tPropsEl, "fo", "font-variant"),
+            letterSpacing: nsAttr(tPropsEl, "fo", "letter-spacing")
+        };
+    }
+    const tablePropsEl = findNsChild(el, "style", "table-properties");
+    if (tablePropsEl) {
+        tableProperties = {
+            width: nsAttr(tablePropsEl, "style", "width"),
+            align: nsAttr(tablePropsEl, "table", "align") ?? nsAttr(tablePropsEl, "fo", "margin-left")
+        };
+    }
+    const tableColPropsEl = findNsChild(el, "style", "table-column-properties");
+    if (tableColPropsEl) {
+        tableColumnProperties = {
+            columnWidth: nsAttr(tableColPropsEl, "style", "column-width")
+        };
+    }
+    const tableCellPropsEl = findNsChild(el, "style", "table-cell-properties");
+    if (tableCellPropsEl) {
+        tableCellProperties = {
+            padding: nsAttr(tableCellPropsEl, "fo", "padding"),
+            borderTop: nsAttr(tableCellPropsEl, "fo", "border-top"),
+            borderBottom: nsAttr(tableCellPropsEl, "fo", "border-bottom"),
+            borderLeft: nsAttr(tableCellPropsEl, "fo", "border-left"),
+            borderRight: nsAttr(tableCellPropsEl, "fo", "border-right"),
+            backgroundColor: nsAttr(tableCellPropsEl, "fo", "background-color"),
+            verticalAlign: nsAttr(tableCellPropsEl, "style", "vertical-align")
+        };
+    }
+    return {
+        name,
+        family,
+        parentStyle,
+        paragraphProperties,
+        textProperties,
+        tableProperties,
+        tableColumnProperties,
+        tableCellProperties
+    };
+}
+/** Parse page layout properties from a style:page-layout element. */
+function parsePageLayout(el) {
+    const propsEl = findNsChild(el, "style", "page-layout-properties");
+    if (!propsEl) {
+        return undefined;
+    }
+    return {
+        pageWidth: nsAttr(propsEl, "fo", "page-width"),
+        pageHeight: nsAttr(propsEl, "fo", "page-height"),
+        marginTop: nsAttr(propsEl, "fo", "margin-top"),
+        marginBottom: nsAttr(propsEl, "fo", "margin-bottom"),
+        marginLeft: nsAttr(propsEl, "fo", "margin-left"),
+        marginRight: nsAttr(propsEl, "fo", "margin-right")
+    };
+}
+// =============================================================================
+// ODF Content Parsing → DocxDocument Model
+// =============================================================================
+/** Convert ODF text alignment to OOXML alignment. */
+function odfAlignToAlignment(align) {
+    if (!align) {
+        return undefined;
+    }
+    switch (align) {
+        case "start":
+        case "left":
+            return "left";
+        case "center":
+            return "center";
+        case "end":
+        case "right":
+            return "right";
+        case "justify":
+            return "both";
+        default:
+            return undefined;
+    }
+}
+/** Convert ODF paragraph properties to OOXML ParagraphProperties. */
+function odfParagraphPropsToDocx(props, styleName) {
+    if (!props && !styleName) {
+        return undefined;
+    }
+    const alignment = odfAlignToAlignment(props?.textAlign);
+    let indent;
+    const leftTwips = odfLengthToTwips(props?.marginLeft);
+    const rightTwips = odfLengthToTwips(props?.marginRight);
+    const firstLineTwips = odfLengthToTwips(props?.textIndent);
+    if (leftTwips !== undefined || rightTwips !== undefined || firstLineTwips !== undefined) {
+        indent = {
+            ...(leftTwips !== undefined ? { left: leftTwips } : {}),
+            ...(rightTwips !== undefined ? { right: rightTwips } : {}),
+            ...(firstLineTwips !== undefined
+                ? firstLineTwips >= 0
+                    ? { firstLine: firstLineTwips }
+                    : { hanging: -firstLineTwips }
+                : {})
+        };
+    }
+    let spacing;
+    const beforeTwips = odfLengthToTwips(props?.marginTop);
+    const afterTwips = odfLengthToTwips(props?.marginBottom);
+    if (beforeTwips !== undefined || afterTwips !== undefined) {
+        spacing = {
+            ...(beforeTwips !== undefined ? { before: beforeTwips } : {}),
+            ...(afterTwips !== undefined ? { after: afterTwips } : {})
+        };
+    }
+    const keepNext = props?.keepWithNext === "always" || props?.keepWithNext === "true" ? true : undefined;
+    const pageBreakBefore = props?.breakBefore === "page" ? true : undefined;
+    const result = {
+        ...(styleName ? { style: styleName } : {}),
+        ...(alignment ? { alignment } : {}),
+        ...(indent ? { indent } : {}),
+        ...(spacing ? { spacing } : {}),
+        ...(keepNext !== undefined ? { keepNext } : {}),
+        ...(pageBreakBefore !== undefined ? { pageBreakBefore } : {})
+    };
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+/** Convert ODF text properties to OOXML RunProperties. */
+function odfTextPropsToDocx(props) {
+    if (!props) {
+        return undefined;
+    }
+    const font = props.fontName || undefined;
+    const size = parseFontSizeToHalfPoints(props.fontSize);
+    const bold = props.fontWeight === "bold" ? true : undefined;
+    const italic = props.fontStyle === "italic" ? true : undefined;
+    let underline;
+    if (props.textDecoration && props.textDecoration !== "none") {
+        underline = "single";
+    }
+    let strike;
+    if (props.textDecoration === "line-through") {
+        strike = true;
+        underline = undefined;
+    }
+    const color = parseOdfColor(props.color);
+    const smallCaps = props.fontVariant === "small-caps" ? true : undefined;
+    const spacingTwips = odfLengthToTwips(props.letterSpacing);
+    let vertAlign;
+    if (props.textPosition) {
+        if (props.textPosition.startsWith("super") || props.textPosition.startsWith("33%")) {
+            vertAlign = "superscript";
+        }
+        else if (props.textPosition.startsWith("sub") || props.textPosition.startsWith("-33%")) {
+            vertAlign = "subscript";
+        }
+    }
+    const result = {
+        ...(font ? { font } : {}),
+        ...(size !== undefined ? { size } : {}),
+        ...(bold !== undefined ? { bold } : {}),
+        ...(italic !== undefined ? { italic } : {}),
+        ...(underline !== undefined ? { underline } : {}),
+        ...(strike !== undefined ? { strike } : {}),
+        ...(color !== undefined ? { color } : {}),
+        ...(smallCaps !== undefined ? { smallCaps } : {}),
+        ...(spacingTwips !== undefined ? { spacing: spacingTwips } : {}),
+        ...(vertAlign !== undefined ? { vertAlign } : {})
+    };
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+/** Parse inline text spans (text:span) within a paragraph. */
+function parseTextSpan(el, styles) {
+    const styleName = nsAttr(el, "text", "style-name");
+    const style = styleName ? styles.get(styleName) : undefined;
+    const runProps = odfTextPropsToDocx(style?.textProperties);
+    const content = [];
+    for (const child of el.children) {
+        if (child.type === "text") {
+            if (child.value) {
+                content.push({ type: "text", text: child.value });
+            }
+        }
+        else if (child.type === "element") {
+            const local = getLocalName(child.name);
+            if (local === "s") {
+                // text:s — multiple spaces
+                const count = parseInt(nsAttr(child, "text", "c") ?? "1", 10);
+                content.push({ type: "text", text: " ".repeat(count) });
+            }
+            else if (local === "tab") {
+                content.push({ type: "tab" });
+            }
+            else if (local === "line-break") {
+                content.push({ type: "break" });
+            }
+            else if (local === "span") {
+                // Nested span — flatten into current run content
+                const nestedRun = parseTextSpan(child, styles);
+                content.push(...nestedRun.content);
+            }
+        }
+    }
+    return {
+        ...(runProps ? { properties: runProps } : {}),
+        content
+    };
+}
+/** Parse a text:p or text:h element into a Paragraph. */
+function parseParagraph(el, styles, listContext) {
+    const styleName = nsAttr(el, "text", "style-name");
+    const style = styleName ? styles.get(styleName) : undefined;
+    const isHeading = getLocalName(el.name) === "h";
+    const outlineLevel = isHeading
+        ? parseInt(nsAttr(el, "text", "outline-level") ?? "1", 10)
+        : undefined;
+    let paraProps = odfParagraphPropsToDocx(style?.paragraphProperties, styleName);
+    // If this is a heading, add outline level
+    if (outlineLevel !== undefined && outlineLevel >= 1 && outlineLevel <= 9) {
+        paraProps = {
+            ...paraProps,
+            outlineLevel: outlineLevel - 1,
+            style: styleName ?? `Heading${outlineLevel}`
+        };
+    }
+    // If inside a list, add numbering reference
+    if (listContext) {
+        paraProps = {
+            ...paraProps,
+            numbering: { numId: 1, level: listContext.level }
+        };
+    }
+    const children = [];
+    for (const child of el.children) {
+        if (child.type === "text") {
+            if (child.value) {
+                children.push({
+                    content: [{ type: "text", text: child.value }]
+                });
+            }
+        }
+        else if (child.type === "element") {
+            const local = getLocalName(child.name);
+            if (local === "span") {
+                children.push(parseTextSpan(child, styles));
+            }
+            else if (local === "a") {
+                // Hyperlink. Pass the href through sanitizeUrl so dangerous
+                // schemes (javascript:, vbscript:, data: with executable payloads,
+                // etc.) coming from an untrusted ODT do not survive into the DOCX
+                // model. Unsafe links degrade to plain text — the caller still sees
+                // the link's children but no clickable hyperlink is created.
+                const rawHref = nsAttr(child, "xlink", "href");
+                const safeHref = (0, internal_utils_1.sanitizeUrl)(rawHref);
+                const runs = [];
+                for (const linkChild of child.children) {
+                    if (linkChild.type === "text") {
+                        if (linkChild.value) {
+                            runs.push({ content: [{ type: "text", text: linkChild.value }] });
+                        }
+                    }
+                    else if (linkChild.type === "element" && getLocalName(linkChild.name) === "span") {
+                        runs.push(parseTextSpan(linkChild, styles));
+                    }
+                }
+                if (safeHref) {
+                    children.push({
+                        type: "hyperlink",
+                        url: safeHref,
+                        children: runs
+                    });
+                }
+                else if (rawHref && rawHref.startsWith("#")) {
+                    // Internal anchor — sanitizeUrl rejects fragment-only URLs but
+                    // they're safe and meaningful. Preserve as a Hyperlink with
+                    // `anchor` set, mirroring how DOCX represents in-document
+                    // links.
+                    children.push({
+                        type: "hyperlink",
+                        anchor: rawHref.slice(1),
+                        children: runs
+                    });
+                }
+                else {
+                    // Drop the wrapper — preserve text content as plain runs so no
+                    // user-visible content disappears.
+                    for (const r of runs) {
+                        children.push(r);
+                    }
+                }
+            }
+            else if (local === "s") {
+                const count = parseInt(nsAttr(child, "text", "c") ?? "1", 10);
+                children.push({ content: [{ type: "text", text: " ".repeat(count) }] });
+            }
+            else if (local === "tab") {
+                children.push({ content: [{ type: "tab" }] });
+            }
+            else if (local === "line-break") {
+                children.push({ content: [{ type: "break" }] });
+            }
+            else if (local === "frame") {
+                // Inline image frame
+                const imageRun = parseDrawFrame(child);
+                if (imageRun) {
+                    children.push(imageRun);
+                }
+            }
+            else if (local === "bookmark-start") {
+                const bkName = nsAttr(child, "text", "name") ?? "";
+                children.push({ type: "bookmarkStart", id: 0, name: bkName });
+            }
+            else if (local === "bookmark-end") {
+                children.push({ type: "bookmarkEnd", id: 0 });
+            }
+            else if (local === "note") {
+                // Footnote/endnote — extract text content
+                const noteBodyEl = findNsChild(child, "text", "note-body");
+                if (noteBodyEl) {
+                    const noteText = (0, dom_1.textContent)(noteBodyEl);
+                    if (noteText) {
+                        children.push({ content: [{ type: "text", text: `[${noteText}]` }] });
+                    }
+                }
+            }
+        }
+    }
+    return {
+        type: "paragraph",
+        ...(paraProps ? { properties: paraProps } : {}),
+        children
+    };
+}
+/** Parse a draw:frame element for inline images. */
+function parseDrawFrame(el) {
+    const width = odfLengthToEmu(nsAttr(el, "svg", "width"));
+    const height = odfLengthToEmu(nsAttr(el, "svg", "height"));
+    const name = nsAttr(el, "draw", "name");
+    const imageEl = findNsChild(el, "draw", "image") ?? (0, dom_1.findChild)(el, "draw:image") ?? (0, dom_1.findChild)(el, "image");
+    if (!imageEl) {
+        return undefined;
+    }
+    const href = nsAttr(imageEl, "xlink", "href");
+    if (!href) {
+        return undefined;
+    }
+    const imageContent = {
+        type: "image",
+        rId: href, // Use the path as rId placeholder; resolved during image collection
+        width: width ?? units_1.EMU_PER_INCH, // Default 1 inch
+        height: height ?? units_1.EMU_PER_INCH,
+        ...(name ? { name } : {})
+    };
+    return {
+        content: [imageContent]
+    };
+}
+/** Parse a text:list element. */
+function parseList(el, styles, parentLevel) {
+    const listStyleName = nsAttr(el, "text", "style-name");
+    const paragraphs = [];
+    const level = parentLevel;
+    const items = findNsChildren(el, "text", "list-item");
+    for (const item of items) {
+        for (const child of item.children) {
+            if (child.type !== "element") {
+                continue;
+            }
+            const local = getLocalName(child.name);
+            if (local === "p" || local === "h") {
+                paragraphs.push(parseParagraph(child, styles, { listStyleName, level }));
+            }
+            else if (local === "list") {
+                // Nested list
+                paragraphs.push(...parseList(child, styles, level + 1));
+            }
+        }
+    }
+    return paragraphs;
+}
+/** Parse a table:table element into a Table. */
+function parseTable(el, styles) {
+    const tableStyleName = nsAttr(el, "table", "style-name");
+    const tableStyle = tableStyleName ? styles.get(tableStyleName) : undefined;
+    // Parse column definitions for widths
+    const columnWidths = [];
+    const colElements = findNsChildren(el, "table", "table-column");
+    for (const colEl of colElements) {
+        const colStyleName = nsAttr(colEl, "table", "style-name");
+        const colStyle = colStyleName ? styles.get(colStyleName) : undefined;
+        const width = odfLengthToTwips(colStyle?.tableColumnProperties?.columnWidth);
+        const repeatCount = parseInt(nsAttr(colEl, "table", "number-columns-repeated") ?? "1", 10);
+        for (let i = 0; i < repeatCount; i++) {
+            columnWidths.push(width ?? 2000);
+        }
+    }
+    // Parse rows
+    const rows = [];
+    const rowElements = findNsChildren(el, "table", "table-row");
+    for (const rowEl of rowElements) {
+        const cells = [];
+        // Iterate in document order (preserve natural order)
+        const orderedCells = [];
+        for (const child of rowEl.children) {
+            if (child.type === "element") {
+                const childLocal = getLocalName(child.name);
+                if (childLocal === "table-cell" || childLocal === "covered-table-cell") {
+                    orderedCells.push(child);
+                }
+            }
+        }
+        for (const cellEl of orderedCells) {
+            const cellLocal = getLocalName(cellEl.name);
+            const isCovered = cellLocal === "covered-table-cell";
+            const gridSpan = parseInt(nsAttr(cellEl, "table", "number-columns-spanned") ?? "1", 10);
+            const rowSpan = parseInt(nsAttr(cellEl, "table", "number-rows-spanned") ?? "1", 10);
+            const cellProps = {
+                ...(gridSpan > 1 ? { gridSpan } : {}),
+                ...(rowSpan > 1 ? { rowSpan } : {}),
+                ...(isCovered ? { verticalMerge: "continue" } : {})
+            };
+            // Parse cell content
+            const cellContent = [];
+            for (const cellChild of cellEl.children) {
+                if (cellChild.type !== "element") {
+                    continue;
+                }
+                const cellChildLocal = getLocalName(cellChild.name);
+                if (cellChildLocal === "p" || cellChildLocal === "h") {
+                    cellContent.push(parseParagraph(cellChild, styles));
+                }
+                else if (cellChildLocal === "table") {
+                    cellContent.push(parseTable(cellChild, styles));
+                }
+                else if (cellChildLocal === "list") {
+                    cellContent.push(...parseList(cellChild, styles, 0));
+                }
+            }
+            // Ensure at least one paragraph per cell
+            if (cellContent.length === 0) {
+                cellContent.push({ type: "paragraph", children: [] });
+            }
+            cells.push({
+                ...(Object.keys(cellProps).length > 0 ? { properties: cellProps } : {}),
+                content: cellContent
+            });
+        }
+        rows.push({ cells });
+    }
+    // Build table properties
+    let tableProps;
+    const widthTwips = odfLengthToTwips(tableStyle?.tableProperties?.width);
+    if (widthTwips !== undefined || tableStyleName) {
+        tableProps = {
+            ...(tableStyleName ? { style: tableStyleName } : {}),
+            ...(widthTwips !== undefined ? { width: { value: widthTwips, type: "dxa" } } : {})
+        };
+    }
+    return {
+        type: "table",
+        ...(tableProps ? { properties: tableProps } : {}),
+        ...(columnWidths.length > 0 ? { columnWidths } : {}),
+        rows
+    };
+}
+/** Parse document body content from the office:body/office:text element. */
+function parseDocumentBody(bodyEl, styles) {
+    const content = [];
+    for (const child of bodyEl.children) {
+        if (child.type !== "element") {
+            continue;
+        }
+        const local = getLocalName(child.name);
+        if (local === "p" || local === "h") {
+            content.push(parseParagraph(child, styles));
+        }
+        else if (local === "table") {
+            content.push(parseTable(child, styles));
+        }
+        else if (local === "list") {
+            content.push(...parseList(child, styles, 0));
+        }
+        else if (local === "section") {
+            // Sections in ODF are logical containers; flatten their content
+            content.push(...parseDocumentBody(child, styles));
+        }
+    }
+    return content;
+}
+/** Get the local name from a possibly prefixed XML name. */
+function getLocalName(name) {
+    const colonIdx = name.indexOf(":");
+    if (colonIdx >= 0) {
+        return name.substring(colonIdx + 1);
+    }
+    return name;
+}
+// =============================================================================
+// Meta Parsing
+// =============================================================================
+/** Parse meta.xml into CoreProperties. */
+function parseMetaXml(xml) {
+    let doc;
+    try {
+        doc = (0, dom_1.parseXml)(xml);
+    }
+    catch {
+        return undefined;
+    }
+    const root = doc.root;
+    const metaEl = findNsChild(root, "office", "meta") ?? (0, dom_1.findChild)(root, "office:meta") ?? root;
+    const title = getMetaText(metaEl, "dc", "title");
+    const subject = getMetaText(metaEl, "dc", "subject");
+    const creator = getMetaText(metaEl, "dc", "creator") ?? getMetaText(metaEl, "meta", "initial-creator");
+    const description = getMetaText(metaEl, "dc", "description");
+    const keywords = getMetaText(metaEl, "meta", "keyword");
+    const createdStr = getMetaText(metaEl, "meta", "creation-date");
+    const modifiedStr = getMetaText(metaEl, "dc", "date");
+    const created = createdStr ? new Date(createdStr) : undefined;
+    const modified = modifiedStr ? new Date(modifiedStr) : undefined;
+    const result = {
+        ...(title ? { title } : {}),
+        ...(subject ? { subject } : {}),
+        ...(creator ? { creator } : {}),
+        ...(description ? { description } : {}),
+        ...(keywords ? { keywords } : {}),
+        ...(created && !isNaN(created.getTime()) ? { created } : {}),
+        ...(modified && !isNaN(modified.getTime()) ? { modified } : {})
+    };
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+/** Get text content of a metadata element. */
+function getMetaText(parent, prefix, local) {
+    const el = findNsChild(parent, prefix, local);
+    if (!el) {
+        return undefined;
+    }
+    const text = (0, dom_1.textContent)(el).trim();
+    return text || undefined;
+}
+// =============================================================================
+// Page Layout Parsing
+// =============================================================================
+/** Parse page layout from styles.xml into SectionProperties. */
+function parsePageLayoutToSection(pageLayout) {
+    if (!pageLayout) {
+        return undefined;
+    }
+    let pageSize;
+    const widthTwips = odfLengthToTwips(pageLayout.pageWidth);
+    const heightTwips = odfLengthToTwips(pageLayout.pageHeight);
+    if (widthTwips !== undefined && heightTwips !== undefined) {
+        pageSize = {
+            width: widthTwips,
+            height: heightTwips,
+            ...(widthTwips > heightTwips ? { orientation: "landscape" } : {})
+        };
+    }
+    let margins;
+    const marginTop = odfLengthToTwips(pageLayout.marginTop);
+    const marginBottom = odfLengthToTwips(pageLayout.marginBottom);
+    const marginLeft = odfLengthToTwips(pageLayout.marginLeft);
+    const marginRight = odfLengthToTwips(pageLayout.marginRight);
+    if (marginTop !== undefined ||
+        marginBottom !== undefined ||
+        marginLeft !== undefined ||
+        marginRight !== undefined) {
+        margins = {
+            top: marginTop ?? 1440,
+            right: marginRight ?? 1440,
+            bottom: marginBottom ?? 1440,
+            left: marginLeft ?? 1440
+        };
+    }
+    if (!pageSize && !margins) {
+        return undefined;
+    }
+    return {
+        ...(pageSize ? { pageSize } : {}),
+        ...(margins ? { margins } : {})
+    };
+}
+// =============================================================================
+// Styles Conversion → StyleDef[]
+// =============================================================================
+/** Convert parsed ODF styles to DocxDocument style definitions. */
+function convertStylesToStyleDefs(styles) {
+    const defs = [];
+    for (const [, style] of styles) {
+        // Only convert named/non-automatic styles
+        if (!style.name) {
+            continue;
+        }
+        let type;
+        switch (style.family) {
+            case "paragraph":
+                type = "paragraph";
+                break;
+            case "text":
+                type = "character";
+                break;
+            case "table":
+                type = "table";
+                break;
+            default:
+                continue; // Skip unsupported style families
+        }
+        const def = {
+            type,
+            styleId: style.name,
+            name: style.name,
+            ...(style.parentStyle ? { basedOn: style.parentStyle } : {}),
+            ...(style.paragraphProperties
+                ? { paragraphProperties: odfParagraphPropsToDocx(style.paragraphProperties) }
+                : {}),
+            ...(style.textProperties ? { runProperties: odfTextPropsToDocx(style.textProperties) } : {})
+        };
+        defs.push(def);
+    }
+    return defs;
+}
+// =============================================================================
+// ODT list numbering definition (numId=1)
+// =============================================================================
+/**
+ * Walk the converted body and, if any paragraph references `numbering.numId`,
+ * synthesize the corresponding `abstractNumberings` and `numberingInstances`
+ * so Word renders bullet/number markers. Without this the list paragraphs
+ * carry a `numId` that resolves to nothing in the produced document and the
+ * markers are invisible.
+ *
+ * The reader currently only emits a single bulleted abstract definition for
+ * `numId === 1` (matching parseParagraph above). Numbered/multi-level ODT
+ * lists fall back to bullets for now — preserving the visible structure is
+ * the primary goal.
+ */
+function buildOdtNumberingDefs(body) {
+    if (!hasListParagraph(body)) {
+        return {};
+    }
+    const tabSuffix = "tab";
+    const bulletChars = ["•", "◦", "▪", "•", "◦", "▪", "•", "◦", "▪"];
+    const levels = bulletChars.map((ch, level) => ({
+        level,
+        format: "bullet",
+        text: ch,
+        start: 1,
+        paragraphProperties: {
+            indent: { left: 720 * (level + 1), hanging: 360 }
+        },
+        suffix: tabSuffix
+    }));
+    return {
+        abstractNumberings: [{ abstractNumId: 1, levels }],
+        numberingInstances: [{ numId: 1, abstractNumId: 1 }]
+    };
+}
+function hasListParagraph(blocks) {
+    for (const block of blocks) {
+        if (block.type === "paragraph") {
+            if (block.properties?.numbering) {
+                return true;
+            }
+        }
+        else if (block.type === "table") {
+            for (const row of block.rows) {
+                for (const cell of row.cells) {
+                    if (hasListParagraph(cell.content)) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+// =============================================================================
+// readOdt — Main Entry Point
+// =============================================================================
+/**
+ * Read an ODT file and convert to DocxDocument model.
+ *
+ * Extracts the ZIP archive, parses content.xml, styles.xml, and meta.xml,
+ * and produces a unified DocxDocument representation.
+ *
+ * @param buffer - The ODT file as a Uint8Array.
+ * @returns A DocxDocument representing the ODT content.
+ * @throws {DocxParseError} If the ODT file is malformed or missing required parts.
+ *
+ * @stability experimental
+ */
+async function readOdt(buffer) {
+    // Extract ZIP contents
+    const reader = (0, read_archive_1.unzip)(buffer);
+    const entries = new Map();
+    for await (const entry of reader.entries()) {
+        const data = await entry.bytes();
+        const path = entry.path.replace(/^\//, "").replace(/\\/g, "/");
+        entries.set(path, data);
+    }
+    const decoder = internal_utils_1.utf8Decoder;
+    // Parse content.xml (required)
+    const contentData = entries.get("content.xml");
+    if (!contentData) {
+        throw new errors_1.DocxParseError("Required ODT part not found: content.xml");
+    }
+    const contentXml = decoder.decode(contentData);
+    const contentDoc = (0, dom_1.parseXml)(contentXml);
+    // Parse styles.xml (optional)
+    const stylesData = entries.get("styles.xml");
+    let stylesXml;
+    if (stylesData) {
+        stylesXml = decoder.decode(stylesData);
+    }
+    // Parse meta.xml (optional)
+    const metaData = entries.get("meta.xml");
+    let coreProperties;
+    if (metaData) {
+        coreProperties = parseMetaXml(decoder.decode(metaData));
+    }
+    // Collect all styles (from both content.xml and styles.xml)
+    const allStyles = new Map();
+    let pageLayoutProps;
+    // Parse styles from styles.xml
+    if (stylesXml) {
+        const stylesDoc = (0, dom_1.parseXml)(stylesXml);
+        const stylesRoot = stylesDoc.root;
+        // Named styles (office:styles)
+        const officeStylesEl = findNsChild(stylesRoot, "office", "styles");
+        if (officeStylesEl) {
+            for (const child of officeStylesEl.children) {
+                if (child.type === "element" && getLocalName(child.name) === "style") {
+                    const s = parseOdfStyle(child);
+                    if (s.name) {
+                        allStyles.set(s.name, s);
+                    }
+                }
+            }
+        }
+        // Automatic styles in styles.xml (office:automatic-styles)
+        const autoStylesEl = findNsChild(stylesRoot, "office", "automatic-styles");
+        if (autoStylesEl) {
+            for (const child of autoStylesEl.children) {
+                if (child.type === "element") {
+                    const childLocal = getLocalName(child.name);
+                    if (childLocal === "style") {
+                        const s = parseOdfStyle(child);
+                        if (s.name) {
+                            allStyles.set(s.name, s);
+                        }
+                    }
+                    else if (childLocal === "page-layout") {
+                        pageLayoutProps = parsePageLayout(child);
+                    }
+                }
+            }
+        }
+        // Master page styles for page layout reference
+        const masterStylesEl = findNsChild(stylesRoot, "office", "master-styles");
+        if (masterStylesEl && !pageLayoutProps) {
+            // Look for the page layout reference in master pages
+            for (const child of masterStylesEl.children) {
+                if (child.type === "element" && getLocalName(child.name) === "master-page") {
+                    const pageLayoutName = nsAttr(child, "style", "page-layout-name");
+                    if (pageLayoutName && autoStylesEl) {
+                        for (const autoChild of autoStylesEl.children) {
+                            if (autoChild.type === "element" &&
+                                getLocalName(autoChild.name) === "page-layout" &&
+                                nsAttr(autoChild, "style", "name") === pageLayoutName) {
+                                pageLayoutProps = parsePageLayout(autoChild);
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    // Parse automatic styles from content.xml
+    const contentAutoStylesEl = findNsChild(contentDoc.root, "office", "automatic-styles");
+    if (contentAutoStylesEl) {
+        for (const child of contentAutoStylesEl.children) {
+            if (child.type === "element") {
+                const childLocal = getLocalName(child.name);
+                if (childLocal === "style") {
+                    const s = parseOdfStyle(child);
+                    if (s.name) {
+                        allStyles.set(s.name, s);
+                    }
+                }
+                else if (childLocal === "page-layout" && !pageLayoutProps) {
+                    pageLayoutProps = parsePageLayout(child);
+                }
+            }
+        }
+    }
+    // Parse document body
+    const bodyEl = findNsChild(contentDoc.root, "office", "body");
+    if (!bodyEl) {
+        throw new errors_1.DocxParseError("Invalid ODT: missing office:body element");
+    }
+    const textEl = findNsChild(bodyEl, "office", "text");
+    if (!textEl) {
+        throw new errors_1.DocxParseError("Invalid ODT: missing office:text element");
+    }
+    const body = parseDocumentBody(textEl, allStyles);
+    // Convert styles to StyleDef[]
+    const styleDefs = convertStylesToStyleDefs(allStyles);
+    // Parse section properties from page layout
+    const sectionProperties = parsePageLayoutToSection(pageLayoutProps);
+    // Collect images
+    const images = [];
+    for (const [path, data] of entries) {
+        if (path.startsWith("Pictures/") && data.length > 0) {
+            const ext = path.substring(path.lastIndexOf(".") + 1).toLowerCase();
+            let mediaType;
+            switch (ext) {
+                case "png":
+                    mediaType = "image/png";
+                    break;
+                case "jpg":
+                case "jpeg":
+                    mediaType = "image/jpeg";
+                    break;
+                case "gif":
+                    mediaType = "image/gif";
+                    break;
+                case "svg":
+                    mediaType = "image/svg+xml";
+                    break;
+                case "emf":
+                    mediaType = "image/x-emf";
+                    break;
+                case "wmf":
+                    mediaType = "image/x-wmf";
+                    break;
+                case "tiff":
+                case "tif":
+                    mediaType = "image/tiff";
+                    break;
+                case "bmp":
+                    mediaType = "image/bmp";
+                    break;
+                default:
+                    mediaType = "application/octet-stream";
+                    break;
+            }
+            images.push({
+                rId: path,
+                data,
+                mediaType: mediaType,
+                fileName: path.substring(path.lastIndexOf("/") + 1)
+            });
+        }
+    }
+    const doc = {
+        body,
+        ...(sectionProperties ? { sectionProperties } : {}),
+        ...(styleDefs.length > 0 ? { styles: styleDefs } : {}),
+        ...(coreProperties ? { coreProperties } : {}),
+        ...(images.length > 0 ? { images } : {}),
+        ...buildOdtNumberingDefs(body)
+    };
+    return doc;
+}
+/**
+ * Build a deterministic, ZIP-safe `Pictures/` path for each image in the
+ * document. The same rId → path map is consumed by both the content
+ * writer (`xlink:href`) and the archive writer so that what we point at
+ * in content.xml actually exists in the package.
+ *
+ * Image identifiers (`rId`, `fileName`) come from arbitrary upstream
+ * input — including untrusted DOCX files round-tripped through readDocx.
+ * Without sanitisation a hostile rId like `../../etc/passwd` would
+ * produce both an out-of-tree ZIP entry name and an out-of-package
+ * `xlink:href`, which is a real vector for confusing downstream ODT
+ * readers and tooling that resolves relative paths.
+ */
+function buildOdtImagePathMap(images) {
+    const byRId = new Map();
+    const byFileName = new Map();
+    if (!images) {
+        return { byRId, byFileName };
+    }
+    const used = new Set();
+    // Allocate a unique `Pictures/<safe>` path for each image. We generate
+    // a single counter-based fallback when the preferred name is empty or
+    // collides with an entry that's already taken; the previous version
+    // double-incremented `counter` (once inside the collision loop, once
+    // after) producing sparse names like `image1.bin`, `image3.bin`, ….
+    let counter = 1;
+    const allocate = (preferred) => {
+        const safeBase = sanitizeOdtPictureName(preferred);
+        let candidate = safeBase || `image${counter++}.bin`;
+        while (used.has(candidate)) {
+            // Suffix a fresh counter to disambiguate; preserve the extension
+            // when we have one so downstream readers still classify the file
+            // correctly. `_bin` was the previous fallback when no extension
+            // was available — keep that behaviour for the no-base case.
+            const c = counter++;
+            if (safeBase) {
+                const dot = safeBase.lastIndexOf(".");
+                const stem = dot >= 0 ? safeBase.slice(0, dot) : safeBase;
+                const ext = dot >= 0 ? safeBase.slice(dot) : "";
+                candidate = `${stem}_${c}${ext}`;
+            }
+            else {
+                candidate = `image${c}.bin`;
+            }
+        }
+        used.add(candidate);
+        return `Pictures/${candidate}`;
+    };
+    for (const image of images) {
+        const path = allocate(image.fileName ?? image.rId);
+        if (image.rId) {
+            byRId.set(image.rId, path);
+        }
+        if (image.fileName) {
+            // Two distinct images might share a fileName (the inputs are
+            // attacker-controlled in the round-trip path). The first one to
+            // claim a fileName wins the byFileName lookup; later collisions
+            // are still reachable via their own rId in byRId. Without this
+            // guard the second insertion would silently overwrite the first
+            // and inline-image lookups via fileName would resolve to the
+            // wrong binary.
+            if (!byFileName.has(image.fileName)) {
+                byFileName.set(image.fileName, path);
+            }
+        }
+    }
+    return { byRId, byFileName };
+}
+/**
+ * Sanitise a single ODT picture file-name component. Strips path
+ * separators, parent-directory traversal, leading dots, and anything
+ * outside a conservative whitelist. Returns an empty string if no usable
+ * characters remain (caller falls back to a generated name).
+ */
+function sanitizeOdtPictureName(raw) {
+    if (!raw) {
+        return "";
+    }
+    // Drop directory components — we only ever want a leaf file name.
+    const lastSep = Math.max(raw.lastIndexOf("/"), raw.lastIndexOf("\\"));
+    let leaf = lastSep >= 0 ? raw.substring(lastSep + 1) : raw;
+    // Strip leading dots so names like "..png" or ".htaccess" don't sneak
+    // through with attribute meaning to filesystems.
+    while (leaf.startsWith(".")) {
+        leaf = leaf.substring(1);
+    }
+    // Whitelist alnum, dash, underscore, dot. Replace everything else with
+    // underscore. Empty result triggers fallback in the caller.
+    leaf = leaf.replace(/[^A-Za-z0-9._-]/g, "_");
+    // Avoid pathological double-dot anywhere mid-name (e.g. "foo..bin").
+    leaf = leaf.replace(/\.{2,}/g, ".");
+    return leaf;
+}
+// =============================================================================
+// writeOdt — Main Entry Point
+// =============================================================================
+/**
+ * Convert a DocxDocument to ODT (OpenDocument Text) format.
+ *
+ * Generates the ZIP archive structure with content.xml, styles.xml,
+ * meta.xml, and META-INF/manifest.xml.
+ *
+ * @param doc - The DocxDocument to convert.
+ * @returns A Uint8Array containing the ODT ZIP archive.
+ *
+ * @stability experimental
+ */
+async function writeOdt(doc) {
+    const encoder = internal_utils_1.utf8Encoder;
+    const archive = (0, create_archive_1.zip)();
+    // Mimetype MUST be the first entry in the ZIP, uncompressed (ODF spec requirement)
+    archive.add("mimetype", encoder.encode("application/vnd.oasis.opendocument.text"), { level: 0 });
+    // Compute a sanitised rId → Pictures/<safe>.<ext> map up front so the
+    // content writer and archive writer agree on every image path.
+    const imageMap = buildOdtImagePathMap(doc.images);
+    // Collect image paths for manifest
+    const imagePaths = [];
+    // Generate content.xml — the writer reads from imageMap so href values
+    // are guaranteed in-package and free of traversal sequences.
+    const contentXml = generateContentXml(doc, imagePaths, imageMap);
+    archive.add("content.xml", encoder.encode(contentXml));
+    // Generate styles.xml
+    const stylesXml = generateStylesXml(doc);
+    archive.add("styles.xml", encoder.encode(stylesXml));
+    // Generate meta.xml
+    const metaXml = generateMetaXml(doc);
+    archive.add("meta.xml", encoder.encode(metaXml));
+    // Add images at the sanitised paths.
+    if (doc.images) {
+        for (const image of doc.images) {
+            if (!image.data) {
+                continue;
+            }
+            const imgPath = (image.rId ? imageMap.byRId.get(image.rId) : undefined) ??
+                (image.fileName ? imageMap.byFileName.get(image.fileName) : undefined);
+            if (!imgPath) {
+                continue;
+            }
+            archive.add(imgPath, image.data);
+            imagePaths.push(imgPath);
+        }
+    }
+    // Generate META-INF/manifest.xml
+    const manifestXml = generateManifestXml(imagePaths);
+    archive.add("META-INF/manifest.xml", encoder.encode(manifestXml));
+    return archive.bytes();
+}
+/** Create a new write context. */
+function createWriteContext(imageMap) {
+    return {
+        runStyleMap: new Map(),
+        runStyleProps: new Map(),
+        nextRunStyleId: 1,
+        bookmarkNames: new Map(),
+        imagePathByRId: imageMap?.byRId ?? new Map(),
+        imagePathByFileName: imageMap?.byFileName ?? new Map()
+    };
+}
+/**
+ * Generate a deterministic cache key for RunProperties.
+ * Only includes formatting-relevant properties.
+ */
+function runPropsKey(props) {
+    const parts = [];
+    if (props.font) {
+        const fontName = typeof props.font === "string" ? props.font : props.font.ascii;
+        if (fontName) {
+            parts.push(`f:${fontName}`);
+        }
+    }
+    if (props.size !== undefined) {
+        parts.push(`s:${props.size}`);
+    }
+    if (props.bold) {
+        parts.push("b");
+    }
+    if (props.italic) {
+        parts.push("i");
+    }
+    if (props.underline) {
+        parts.push("u");
+    }
+    if (props.strike) {
+        parts.push("st");
+    }
+    if (props.color) {
+        const colorVal = typeof props.color === "string" ? props.color : props.color.val;
+        if (colorVal) {
+            parts.push(`c:${colorVal}`);
+        }
+    }
+    if (props.smallCaps) {
+        parts.push("sc");
+    }
+    if (props.vertAlign) {
+        parts.push(`va:${props.vertAlign}`);
+    }
+    if (props.spacing !== undefined) {
+        parts.push(`sp:${props.spacing}`);
+    }
+    return parts.join("|");
+}
+/** Get or create an automatic style name for the given RunProperties. */
+function getRunAutoStyleName(ctx, props) {
+    const key = runPropsKey(props);
+    let name = ctx.runStyleMap.get(key);
+    if (!name) {
+        name = `T${ctx.nextRunStyleId++}`;
+        ctx.runStyleMap.set(key, name);
+        ctx.runStyleProps.set(name, props);
+    }
+    return name;
+}
+/** Generate the content.xml for the ODT package. */
+function generateContentXml(doc, imagePaths, imageMap) {
+    // First pass: write body to collect automatic run styles
+    const ctx = createWriteContext(imageMap);
+    const bodyWriter = new writer_1.XmlWriter();
+    bodyWriter.openNode("office:body");
+    bodyWriter.openNode("office:text");
+    for (const block of doc.body) {
+        writeBodyContent(bodyWriter, block, doc, imagePaths, ctx);
+    }
+    bodyWriter.closeNode(); // office:text
+    bodyWriter.closeNode(); // office:body
+    const bodyXml = bodyWriter.xml;
+    // Second pass: assemble the full content.xml with collected automatic styles
+    const w = new writer_1.XmlWriter();
+    w.openXml();
+    w.openNode("office:document-content", {
+        "xmlns:office": NS.office,
+        "xmlns:style": NS.style,
+        "xmlns:text": NS.text,
+        "xmlns:table": NS.table,
+        "xmlns:draw": NS.draw,
+        "xmlns:fo": NS.fo,
+        "xmlns:xlink": NS.xlink,
+        "xmlns:svg": NS.svg,
+        "office:version": "1.3"
+    });
+    // Automatic styles section
+    w.openNode("office:automatic-styles");
+    writeAutoStyles(w, doc);
+    writeCollectedRunStyles(w, ctx);
+    w.closeNode();
+    // Body (inject pre-built body XML)
+    w.writeRaw(bodyXml);
+    w.closeNode(); // office:document-content
+    return w.xml;
+}
+/** Write collected automatic run styles into the automatic-styles section. */
+function writeCollectedRunStyles(w, ctx) {
+    for (const [styleName, props] of ctx.runStyleProps) {
+        w.openNode("style:style", {
+            "style:name": styleName,
+            "style:family": "text"
+        });
+        writeTextPropertiesOdf(w, props);
+        w.closeNode();
+    }
+}
+/** Write automatic styles based on document content. */
+function writeAutoStyles(w, doc) {
+    // Output styles from the StyleDef array that exist in the document.
+    if (doc.styles) {
+        for (const styleDef of doc.styles) {
+            writeStyleDef(w, styleDef);
+        }
+    }
+}
+/** Write a single StyleDef as an ODF style. */
+function writeStyleDef(w, def) {
+    const family = styleTypeToOdfFamily(def.type);
+    if (!family) {
+        return;
+    }
+    w.openNode("style:style", {
+        "style:name": def.styleId,
+        "style:family": family,
+        ...(def.basedOn ? { "style:parent-style-name": def.basedOn } : {}),
+        ...(def.name !== def.styleId ? { "style:display-name": def.name } : {})
+    });
+    // Paragraph properties
+    if (def.paragraphProperties) {
+        writeParagraphPropertiesOdf(w, def.paragraphProperties);
+    }
+    // Run/text properties
+    if (def.runProperties) {
+        writeTextPropertiesOdf(w, def.runProperties);
+    }
+    w.closeNode();
+}
+/** Convert DocxDocument style type to ODF style family. */
+function styleTypeToOdfFamily(type) {
+    switch (type) {
+        case "paragraph":
+            return "paragraph";
+        case "character":
+            return "text";
+        case "table":
+            return "table";
+        default:
+            return undefined;
+    }
+}
+/** Write paragraph properties as ODF elements. */
+function writeParagraphPropertiesOdf(w, props) {
+    const attrs = {};
+    if (props.alignment) {
+        attrs["fo:text-align"] = alignmentToOdf(props.alignment);
+    }
+    if (props.indent) {
+        if (props.indent.left !== undefined) {
+            attrs["fo:margin-left"] = twipsToCm(props.indent.left);
+        }
+        if (props.indent.right !== undefined) {
+            attrs["fo:margin-right"] = twipsToCm(props.indent.right);
+        }
+        if (props.indent.firstLine !== undefined) {
+            attrs["fo:text-indent"] = twipsToCm(props.indent.firstLine);
+        }
+        else if (props.indent.hanging !== undefined) {
+            attrs["fo:text-indent"] = twipsToCm(-props.indent.hanging);
+        }
+    }
+    if (props.spacing) {
+        if (props.spacing.before !== undefined) {
+            attrs["fo:margin-top"] = twipsToCm(props.spacing.before);
+        }
+        if (props.spacing.after !== undefined) {
+            attrs["fo:margin-bottom"] = twipsToCm(props.spacing.after);
+        }
+    }
+    if (props.keepNext) {
+        attrs["fo:keep-with-next"] = "always";
+    }
+    if (props.pageBreakBefore) {
+        attrs["fo:break-before"] = "page";
+    }
+    if (Object.keys(attrs).length > 0) {
+        w.leafNode("style:paragraph-properties", attrs);
+    }
+}
+/** Write run/text properties as ODF elements. */
+function writeTextPropertiesOdf(w, props) {
+    const attrs = {};
+    if (props.font) {
+        const fontName = typeof props.font === "string" ? props.font : props.font.ascii;
+        if (fontName) {
+            attrs["style:font-name"] = fontName;
+        }
+    }
+    if (props.size !== undefined) {
+        attrs["fo:font-size"] = halfPointsToPt(props.size);
+    }
+    if (props.bold) {
+        attrs["fo:font-weight"] = "bold";
+    }
+    if (props.italic) {
+        attrs["fo:font-style"] = "italic";
+    }
+    if (props.underline) {
+        attrs["style:text-underline-style"] = "solid";
+        attrs["style:text-underline-width"] = "auto";
+        attrs["style:text-underline-color"] = "font-color";
+    }
+    if (props.strike) {
+        attrs["style:text-line-through-style"] = "solid";
+    }
+    if (props.color) {
+        const colorVal = typeof props.color === "string" ? props.color : props.color.val;
+        if (colorVal && colorVal !== "auto") {
+            attrs["fo:color"] = colorToOdf(colorVal);
+        }
+    }
+    if (props.smallCaps) {
+        attrs["fo:font-variant"] = "small-caps";
+    }
+    if (props.vertAlign === "superscript") {
+        attrs["style:text-position"] = "super 58%";
+    }
+    else if (props.vertAlign === "subscript") {
+        attrs["style:text-position"] = "sub 58%";
+    }
+    if (props.spacing !== undefined) {
+        attrs["fo:letter-spacing"] = twipsToCm(props.spacing);
+    }
+    if (Object.keys(attrs).length > 0) {
+        w.leafNode("style:text-properties", attrs);
+    }
+}
+/** Convert OOXML alignment to ODF text-align value. */
+function alignmentToOdf(alignment) {
+    switch (alignment) {
+        case "left":
+        case "start":
+            return "start";
+        case "center":
+            return "center";
+        case "right":
+        case "end":
+            return "end";
+        case "both":
+            return "justify";
+        default:
+            return "start";
+    }
+}
+/** Write a block-level content element to the XML writer. */
+function writeBodyContent(w, block, doc, imagePaths, ctx) {
+    switch (block.type) {
+        case "paragraph":
+            writeParagraph(w, block, doc, imagePaths, ctx);
+            break;
+        case "table":
+            writeTable(w, block, doc, imagePaths, ctx);
+            break;
+        case "tableOfContents":
+            // Write TOC cached paragraphs if available
+            if (block.cachedParagraphs) {
+                for (const p of block.cachedParagraphs) {
+                    writeParagraph(w, p, doc, imagePaths, ctx);
+                }
+            }
+            break;
+        case "math":
+            // Math blocks are rendered as paragraphs with math text
+            w.openNode("text:p");
+            for (const mc of block.content) {
+                if (mc.type === "mathRun") {
+                    w.writeText(mc.text);
+                }
+            }
+            w.closeNode();
+            break;
+        default:
+            // Other block types (floatingImage, textBox, etc.) — emit as empty paragraph placeholder
+            w.leafNode("text:p");
+            break;
+    }
+}
+/** Write a paragraph element. */
+function writeParagraph(w, para, doc, imagePaths, ctx) {
+    const isHeading = para.properties?.outlineLevel !== undefined && para.properties.outlineLevel >= 0;
+    const styleName = para.properties?.style;
+    if (isHeading) {
+        const level = (para.properties.outlineLevel ?? 0) + 1;
+        w.openNode("text:h", {
+            ...(styleName ? { "text:style-name": styleName } : {}),
+            "text:outline-level": String(level)
+        });
+    }
+    else {
+        w.openNode("text:p", {
+            ...(styleName ? { "text:style-name": styleName } : {})
+        });
+    }
+    for (const child of para.children) {
+        writeParagraphChild(w, child, doc, imagePaths, ctx);
+    }
+    w.closeNode();
+}
+/** Write a paragraph child (Run, Hyperlink, etc.). */
+function writeParagraphChild(w, child, doc, imagePaths, ctx) {
+    if ((0, text_utils_1.isRun)(child)) {
+        writeRun(w, child, doc, imagePaths, ctx);
+        return;
+    }
+    switch (child.type) {
+        case "hyperlink": {
+            // Defense in depth: even though hyperlinks coming through readDocx /
+            // htmlImport / odtRead are already sanitized, models can be built
+            // by hand. Run the URL through sanitizeUrl one more time before
+            // writing it into the ODT, so a malicious model can't smuggle
+            // javascript:/vbscript: URLs through this writer.
+            const rawHref = child.url ?? (child.anchor ? `#${child.anchor}` : "");
+            const href = rawHref.startsWith("#") ? rawHref : ((0, internal_utils_1.sanitizeUrl)(rawHref) ?? "");
+            if (!href) {
+                // Drop the link wrapper — write children as plain runs.
+                for (const run of child.children) {
+                    writeRun(w, run, doc, imagePaths, ctx);
+                }
+                break;
+            }
+            w.openNode("text:a", {
+                "xlink:type": "simple",
+                "xlink:href": href
+            });
+            for (const run of child.children) {
+                writeRun(w, run, doc, imagePaths, ctx);
+            }
+            w.closeNode();
+            break;
+        }
+        case "bookmarkStart":
+            ctx.bookmarkNames.set(child.id, child.name);
+            w.leafNode("text:bookmark-start", { "text:name": child.name });
+            break;
+        case "bookmarkEnd": {
+            const name = ctx.bookmarkNames.get(child.id);
+            if (name !== undefined) {
+                // Emit the matching name so range-aware ODT readers can pair the
+                // start/end markers correctly.
+                w.leafNode("text:bookmark-end", { "text:name": name });
+            }
+            else {
+                // Stray end without a known start (shouldn't happen for documents
+                // produced by this library) — emit with an empty name to keep the
+                // XML well-formed.
+                w.leafNode("text:bookmark-end", { "text:name": "" });
+            }
+            break;
+        }
+        case "insertedRun":
+            writeRun(w, child.run, doc, imagePaths, ctx);
+            break;
+        case "deletedRun":
+            // Deleted runs are typically not shown in the output
+            break;
+        default:
+            // Other paragraph children (comments, etc.) — skip
+            break;
+    }
+}
+/** Write a Run (text:span or direct text). */
+function writeRun(w, run, doc, imagePaths, ctx) {
+    const hasProps = run.properties && Object.keys(run.properties).length > 0;
+    if (hasProps) {
+        const styleName = getRunAutoStyleName(ctx, run.properties);
+        w.openNode("text:span", { "text:style-name": styleName });
+    }
+    for (const content of run.content) {
+        writeRunContent(w, content, doc, imagePaths, ctx);
+    }
+    if (hasProps) {
+        w.closeNode();
+    }
+}
+/** Write run content elements. */
+function writeRunContent(w, content, doc, imagePaths, ctx) {
+    switch (content.type) {
+        case "text":
+            writeOdfText(w, content.text);
+            break;
+        case "break":
+            if (content.breakType === "page") {
+                // ODF 1.2 §5.1.4 — `text:soft-page-break` is a hint that a layout
+                // page break occurs at this position. Strict semantic page breaks
+                // require `fo:break-before="page"` on the surrounding paragraph
+                // automatic style; we emit the soft hint here so the break is at
+                // least preserved (rather than silently dropped, which corrupted
+                // documents on round-trip).
+                w.leafNode("text:soft-page-break");
+            }
+            else if (content.breakType === "column") {
+                // Column breaks degrade to a soft page break in ODF — better than
+                // dropping silently.
+                w.leafNode("text:soft-page-break");
+            }
+            else {
+                w.leafNode("text:line-break");
+            }
+            break;
+        case "tab":
+            w.leafNode("text:tab");
+            break;
+        case "image": {
+            // Write inline image as draw:frame
+            const widthCm = emuToCm(content.width);
+            const heightCm = emuToCm(content.height);
+            // Resolve the safe Pictures/ path that writeOdt registered when it
+            // built the image map. This keeps content.xml's xlink:href in
+            // lockstep with the actual ZIP entry name, and prevents a hostile
+            // rId from emitting a traversing `xlink:href`.
+            const mapped = ctx.imagePathByRId.get(content.rId) ??
+                (content.name ? ctx.imagePathByFileName.get(content.name) : undefined);
+            const imgPath = mapped ?? `Pictures/${sanitizeOdtPictureName(content.rId) || "image.bin"}`;
+            w.openNode("draw:frame", {
+                "draw:name": content.name ?? "",
+                "svg:width": widthCm,
+                "svg:height": heightCm,
+                "text:anchor-type": "as-char"
+            });
+            w.leafNode("draw:image", {
+                "xlink:href": imgPath,
+                "xlink:type": "simple",
+                "xlink:show": "embed",
+                "xlink:actuate": "onLoad"
+            });
+            w.closeNode();
+            break;
+        }
+        case "carriageReturn":
+            w.leafNode("text:line-break");
+            break;
+        case "noBreakHyphen":
+            w.writeText("\u2011");
+            break;
+        case "softHyphen":
+            w.writeText("\u00AD");
+            break;
+        default:
+            // Other content types (field, footnoteRef, etc.) — skip for now
+            break;
+    }
+}
+/** Write text content, handling multiple spaces via text:s. */
+function writeOdfText(w, text) {
+    // ODF collapses whitespace like HTML. Use text:s for multiple spaces.
+    let i = 0;
+    while (i < text.length) {
+        const spaceStart = text.indexOf("  ", i);
+        if (spaceStart < 0) {
+            w.writeText(text.substring(i));
+            break;
+        }
+        // Write text before the spaces
+        if (spaceStart > i) {
+            w.writeText(text.substring(i, spaceStart));
+        }
+        // Count consecutive spaces
+        let spaceCount = 0;
+        let j = spaceStart;
+        while (j < text.length && text[j] === " ") {
+            spaceCount++;
+            j++;
+        }
+        // First space is implicit, rest use text:s
+        w.writeText(" ");
+        if (spaceCount > 1) {
+            w.leafNode("text:s", { "text:c": String(spaceCount - 1) });
+        }
+        i = j;
+    }
+}
+/** Write a table element. */
+function writeTable(w, table, doc, imagePaths, ctx) {
+    w.openNode("table:table", {
+        ...(table.properties?.style ? { "table:style-name": table.properties.style } : {})
+    });
+    // Write column definitions
+    if (table.columnWidths && table.columnWidths.length > 0) {
+        for (const _width of table.columnWidths) {
+            w.leafNode("table:table-column");
+        }
+    }
+    // Write rows
+    for (const row of table.rows) {
+        writeTableRow(w, row, doc, imagePaths, ctx);
+    }
+    w.closeNode();
+}
+/** Write a table row. */
+function writeTableRow(w, row, doc, imagePaths, ctx) {
+    w.openNode("table:table-row");
+    for (const cell of row.cells) {
+        writeTableCell(w, cell, doc, imagePaths, ctx);
+    }
+    w.closeNode();
+}
+/** Write a table cell. */
+function writeTableCell(w, cell, doc, imagePaths, ctx) {
+    const attrs = {};
+    if (cell.properties?.gridSpan && cell.properties.gridSpan > 1) {
+        attrs["table:number-columns-spanned"] = String(cell.properties.gridSpan);
+    }
+    if (cell.properties?.rowSpan && cell.properties.rowSpan > 1) {
+        attrs["table:number-rows-spanned"] = String(cell.properties.rowSpan);
+    }
+    if (cell.properties?.verticalMerge === "continue") {
+        w.leafNode("table:covered-table-cell");
+        return;
+    }
+    w.openNode("table:table-cell", attrs);
+    for (const content of cell.content) {
+        if (content.type === "paragraph") {
+            writeParagraph(w, content, doc, imagePaths, ctx);
+        }
+        else if (content.type === "table") {
+            writeTable(w, content, doc, imagePaths, ctx);
+        }
+    }
+    w.closeNode();
+}
+// =============================================================================
+// Styles XML Generation
+// =============================================================================
+/** Generate styles.xml for the ODT package. */
+function generateStylesXml(doc) {
+    const w = new writer_1.XmlWriter();
+    w.openXml();
+    w.openNode("office:document-styles", {
+        "xmlns:office": NS.office,
+        "xmlns:style": NS.style,
+        "xmlns:text": NS.text,
+        "xmlns:table": NS.table,
+        "xmlns:fo": NS.fo,
+        "xmlns:draw": NS.draw,
+        "xmlns:svg": NS.svg,
+        "office:version": "1.3"
+    });
+    // Office styles (named styles)
+    w.openNode("office:styles");
+    // Default paragraph style
+    w.openNode("style:default-style", { "style:family": "paragraph" });
+    if (doc.docDefaults?.paragraphProperties) {
+        writeParagraphPropertiesOdf(w, doc.docDefaults.paragraphProperties);
+    }
+    if (doc.docDefaults?.runProperties) {
+        writeTextPropertiesOdf(w, doc.docDefaults.runProperties);
+    }
+    else {
+        w.leafNode("style:text-properties", {
+            "fo:font-size": "12pt",
+            "style:font-name": "Times New Roman"
+        });
+    }
+    w.closeNode();
+    // Default table style
+    w.openNode("style:default-style", { "style:family": "table" });
+    w.closeNode();
+    w.closeNode(); // office:styles
+    // Automatic styles (page layout)
+    w.openNode("office:automatic-styles");
+    // Page layout
+    w.openNode("style:page-layout", { "style:name": "pm1" });
+    const pageProps = {};
+    if (doc.sectionProperties?.pageSize) {
+        pageProps["fo:page-width"] = twipsToCm(doc.sectionProperties.pageSize.width);
+        pageProps["fo:page-height"] = twipsToCm(doc.sectionProperties.pageSize.height);
+        if (doc.sectionProperties.pageSize.orientation === "landscape") {
+            pageProps["style:print-orientation"] = "landscape";
+        }
+    }
+    else {
+        // Default A4
+        pageProps["fo:page-width"] = "21.001cm";
+        pageProps["fo:page-height"] = "29.700cm";
+    }
+    if (doc.sectionProperties?.margins) {
+        const m = doc.sectionProperties.margins;
+        pageProps["fo:margin-top"] = twipsToCm(m.top);
+        pageProps["fo:margin-bottom"] = twipsToCm(m.bottom);
+        pageProps["fo:margin-left"] = twipsToCm(m.left);
+        pageProps["fo:margin-right"] = twipsToCm(m.right);
+    }
+    else {
+        // Default 1 inch margins
+        pageProps["fo:margin-top"] = "2.540cm";
+        pageProps["fo:margin-bottom"] = "2.540cm";
+        pageProps["fo:margin-left"] = "2.540cm";
+        pageProps["fo:margin-right"] = "2.540cm";
+    }
+    w.leafNode("style:page-layout-properties", pageProps);
+    w.closeNode(); // style:page-layout
+    w.closeNode(); // office:automatic-styles
+    // Master styles
+    w.openNode("office:master-styles");
+    w.leafNode("style:master-page", {
+        "style:name": "Default",
+        "style:page-layout-name": "pm1"
+    });
+    w.closeNode();
+    w.closeNode(); // office:document-styles
+    return w.xml;
+}
+// =============================================================================
+// Meta XML Generation
+// =============================================================================
+/** Generate meta.xml for the ODT package. */
+function generateMetaXml(doc) {
+    const w = new writer_1.XmlWriter();
+    w.openXml();
+    w.openNode("office:document-meta", {
+        "xmlns:office": NS.office,
+        "xmlns:meta": NS.meta,
+        "xmlns:dc": NS.dc,
+        "office:version": "1.3"
+    });
+    w.openNode("office:meta");
+    if (doc.coreProperties) {
+        const cp = doc.coreProperties;
+        if (cp.title) {
+            w.leafNode("dc:title", undefined, cp.title);
+        }
+        if (cp.subject) {
+            w.leafNode("dc:subject", undefined, cp.subject);
+        }
+        if (cp.creator) {
+            w.leafNode("meta:initial-creator", undefined, cp.creator);
+            w.leafNode("dc:creator", undefined, cp.creator);
+        }
+        if (cp.description) {
+            w.leafNode("dc:description", undefined, cp.description);
+        }
+        if (cp.keywords) {
+            w.leafNode("meta:keyword", undefined, cp.keywords);
+        }
+        if (cp.created) {
+            w.leafNode("meta:creation-date", undefined, cp.created.toISOString());
+        }
+        if (cp.modified) {
+            w.leafNode("dc:date", undefined, cp.modified.toISOString());
+        }
+    }
+    // Generator
+    w.leafNode("meta:generator", undefined, "excelts/odt");
+    w.closeNode(); // office:meta
+    w.closeNode(); // office:document-meta
+    return w.xml;
+}
+// =============================================================================
+// Manifest XML Generation
+// =============================================================================
+/** Generate META-INF/manifest.xml for the ODT package. */
+function generateManifestXml(imagePaths) {
+    const w = new writer_1.XmlWriter();
+    w.openXml();
+    w.openNode("manifest:manifest", {
+        "xmlns:manifest": NS.manifest,
+        "manifest:version": "1.3"
+    });
+    // Root entry
+    w.leafNode("manifest:file-entry", {
+        "manifest:full-path": "/",
+        "manifest:version": "1.3",
+        "manifest:media-type": "application/vnd.oasis.opendocument.text"
+    });
+    // Content parts
+    w.leafNode("manifest:file-entry", {
+        "manifest:full-path": "content.xml",
+        "manifest:media-type": "text/xml"
+    });
+    w.leafNode("manifest:file-entry", {
+        "manifest:full-path": "styles.xml",
+        "manifest:media-type": "text/xml"
+    });
+    w.leafNode("manifest:file-entry", {
+        "manifest:full-path": "meta.xml",
+        "manifest:media-type": "text/xml"
+    });
+    // Images
+    for (const imgPath of imagePaths) {
+        const ext = imgPath.substring(imgPath.lastIndexOf(".") + 1).toLowerCase();
+        let mediaType;
+        switch (ext) {
+            case "png":
+                mediaType = "image/png";
+                break;
+            case "jpg":
+            case "jpeg":
+                mediaType = "image/jpeg";
+                break;
+            case "gif":
+                mediaType = "image/gif";
+                break;
+            case "svg":
+                mediaType = "image/svg+xml";
+                break;
+            default:
+                mediaType = "application/octet-stream";
+                break;
+        }
+        w.leafNode("manifest:file-entry", {
+            "manifest:full-path": imgPath,
+            "manifest:media-type": mediaType
+        });
+    }
+    w.closeNode(); // manifest:manifest
+    return w.xml;
+}