@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/esm/modules/word/docx-packager.js

@@ -0,0 +1,822 @@
+/**
+ * DOCX Module - Packager
+ *
+ * Assembles a DocxDocument model into a DOCX ZIP package using the
+ * archive and XML modules. Supports all parts including comments,
+ * custom properties, document background, hyperlink relationships,
+ * and per-header/footer relationship files.
+ */
+import { zip } from "../archive/create-archive.js";
+import { XmlWriter } from "../xml/writer.js";
+import { ContentType, RelType, PartPath, STD_DOC_ATTRIBUTES } from "./constants.js";
+import { ContentTypesManager } from "./content-types.js";
+import { RelationshipManager } from "./relationships.js";
+import { renderChartPart } from "./writers/chart-writer.js";
+import { renderComments, renderCommentsExtended } from "./writers/comment-writer.js";
+import { renderDocument, CHART_RID_REGISTRY } from "./writers/document-writer.js";
+import { renderFootnotes, renderEndnotes } from "./writers/footnote-writer.js";
+import { renderHeader, renderFooter, renderWatermarkHeader } from "./writers/header-footer-writer.js";
+import { renderNumbering } from "./writers/numbering-writer.js";
+import { renderSettings, renderFontTable, renderCoreProperties, renderAppProperties, renderCustomProperties, renderWebSettings, renderPeople, renderTheme } from "./writers/parts-writer.js";
+import { renderStyles } from "./writers/styles-writer.js";
+/** Render XML to string using XmlWriter. */
+function renderXml(renderFn) {
+    const writer = new XmlWriter();
+    renderFn(writer);
+    return writer.xml;
+}
+/** Get the .rels path for a given part path. */
+function getPartRelsPath(partPath) {
+    const lastSlash = partPath.lastIndexOf("/");
+    const dir = lastSlash >= 0 ? partPath.substring(0, lastSlash) : "";
+    const name = lastSlash >= 0 ? partPath.substring(lastSlash + 1) : partPath;
+    return dir ? `${dir}/_rels/${name}.rels` : `_rels/${name}.rels`;
+}
+/** Scan a Run for image rIds. */
+function scanRunForImages(run, out) {
+    for (const rc of run.content) {
+        if (rc.type === "image" && rc.rId) {
+            out.add(rc.rId);
+        }
+    }
+}
+/** Scan ParagraphChild[] for hyperlinks with URL (no rId yet). */
+function scanChildrenForHyperlinks(children, out) {
+    for (const child of children) {
+        if ("type" in child && child.type === "hyperlink") {
+            const h = child;
+            if (h.url && !h.rId) {
+                out.push(h);
+            }
+            // Also scan hyperlink children (runs) for images — handled elsewhere
+        }
+    }
+}
+/** Scan ParagraphChild[] for image rIds. */
+function scanChildrenForImages(children, out) {
+    for (const child of children) {
+        if ("type" in child) {
+            if (child.type === "hyperlink") {
+                const h = child;
+                for (const r of h.children) {
+                    scanRunForImages(r, out);
+                }
+            }
+        }
+        else {
+            // It's a Run (no type field)
+            scanRunForImages(child, out);
+        }
+    }
+}
+/** Recursively collect hyperlinks with URL from body content. */
+function collectHyperlinks(body) {
+    const links = [];
+    function fromParagraph(p) {
+        scanChildrenForHyperlinks(p.children, links);
+    }
+    function fromTable(t) {
+        for (const row of t.rows) {
+            for (const cell of row.cells) {
+                for (const c of cell.content) {
+                    if (c.type === "paragraph") {
+                        fromParagraph(c);
+                    }
+                    else if (c.type === "table") {
+                        fromTable(c);
+                    }
+                }
+            }
+        }
+    }
+    function fromSdt(sdt) {
+        for (const c of sdt.content) {
+            if ("type" in c && c.type === "paragraph") {
+                fromParagraph(c);
+            }
+            else if ("type" in c && c.type === "table") {
+                fromTable(c);
+            }
+        }
+    }
+    for (const content of body) {
+        if (content.type === "paragraph") {
+            fromParagraph(content);
+        }
+        else if (content.type === "table") {
+            fromTable(content);
+        }
+        else if (content.type === "sdt") {
+            fromSdt(content);
+        }
+        else if (content.type === "tableOfContents") {
+            // Scan TOC cached paragraphs
+            const toc = content;
+            if (toc.cachedParagraphs) {
+                for (const p of toc.cachedParagraphs) {
+                    fromParagraph(p);
+                }
+            }
+        }
+    }
+    return links;
+}
+/** Infer a content type for an opaque part based on its file extension. */
+function inferContentType(ext) {
+    const map = {
+        xml: "application/xml",
+        rels: "application/vnd.openxmlformats-package.relationships+xml",
+        png: "image/png",
+        jpeg: "image/jpeg",
+        jpg: "image/jpeg",
+        gif: "image/gif",
+        bmp: "image/bmp",
+        tiff: "image/tiff",
+        tif: "image/tiff",
+        svg: "image/svg+xml",
+        webp: "image/webp",
+        emf: "image/x-emf",
+        wmf: "image/x-wmf",
+        odttf: "application/vnd.openxmlformats-officedocument.obfuscatedFont",
+        ttf: "application/x-font-ttf",
+        otf: "application/x-font-otf",
+        bin: "application/vnd.openxmlformats-officedocument.oleObject",
+        vml: "application/vnd.openxmlformats-officedocument.vmlDrawing"
+    };
+    return map[ext];
+}
+/**
+ * Generic walker: visit all paragraphs within a block list, recursing into
+ * tables (including nested tables) and SDTs. This is shared by image/hyperlink
+ * collection helpers to ensure consistent coverage.
+ */
+function walkParagraphs(blocks, onParagraph) {
+    for (const block of blocks) {
+        if (!("type" in block)) {
+            continue;
+        }
+        if (block.type === "paragraph") {
+            onParagraph(block);
+        }
+        else if (block.type === "table") {
+            for (const row of block.rows) {
+                for (const cell of row.cells) {
+                    walkParagraphs(cell.content, onParagraph);
+                }
+            }
+        }
+        else if (block.type === "sdt") {
+            const sdt = block;
+            // SDT content may include Paragraph | Run | Table — only the first and last here
+            const filtered = sdt.content.filter(c => "type" in c && (c.type === "paragraph" || c.type === "table"));
+            walkParagraphs(filtered, onParagraph);
+        }
+        else if (block.type === "tableOfContents") {
+            const toc = block;
+            if (toc.cachedParagraphs) {
+                walkParagraphs(toc.cachedParagraphs, onParagraph);
+            }
+        }
+    }
+}
+/** Collect all image rIds referenced in header/footer content. */
+function collectImageRidsFromContent(content) {
+    const rIds = new Set();
+    walkParagraphs(content.children, p => {
+        scanChildrenForImages(p.children, rIds);
+    });
+    return rIds;
+}
+/** Collect hyperlinks from header/footer content. */
+function collectHyperlinksFromHeaderFooter(content) {
+    const links = [];
+    walkParagraphs(content.children, p => {
+        scanChildrenForHyperlinks(p.children, links);
+    });
+    return links;
+}
+/**
+ * Package a DocxDocument model into a DOCX ZIP file.
+ * Returns the ZIP bytes as Uint8Array.
+ */
+export async function packageDocx(doc, compressionLevel) {
+    const archive = zip({ level: compressionLevel ?? 6 });
+    // Managers
+    const contentTypes = new ContentTypesManager();
+    const packageRels = new RelationshipManager();
+    const documentRels = new RelationshipManager();
+    // --- Package relationships ---
+    packageRels.add(RelType.OfficeDocument, "word/document.xml");
+    packageRels.add(RelType.CoreProperties, "docProps/core.xml");
+    packageRels.add(RelType.ExtendedProperties, "docProps/app.xml");
+    // Custom properties
+    const hasCustomProps = doc.customProperties && doc.customProperties.length > 0;
+    if (hasCustomProps) {
+        packageRels.add(RelType.CustomProperties, "docProps/custom.xml");
+    }
+    // --- Document relationships ---
+    documentRels.add(RelType.Styles, "styles.xml");
+    documentRels.add(RelType.Settings, "settings.xml");
+    documentRels.add(RelType.FontTable, "fontTable.xml");
+    documentRels.add(RelType.Theme, "theme/theme1.xml");
+    // Numbering
+    const hasNumbering = (doc.abstractNumberings && doc.abstractNumberings.length > 0) ||
+        (doc.numberingInstances && doc.numberingInstances.length > 0);
+    if (hasNumbering) {
+        documentRels.add(RelType.Numbering, "numbering.xml");
+    }
+    // Footnotes & Endnotes
+    const hasFootnotes = doc.footnotes && doc.footnotes.length > 0;
+    const hasEndnotes = doc.endnotes && doc.endnotes.length > 0;
+    if (hasFootnotes) {
+        documentRels.add(RelType.Footnotes, "footnotes.xml");
+    }
+    if (hasEndnotes) {
+        documentRels.add(RelType.Endnotes, "endnotes.xml");
+    }
+    // Comments
+    const hasComments = doc.comments && doc.comments.length > 0;
+    if (hasComments) {
+        documentRels.add(RelType.Comments, "comments.xml");
+    }
+    // Images
+    const imageExtensions = new Set();
+    const imageRidMap = new Map(); // old rId -> new rId
+    const imageByRid = new Map(); // O(1) lookup by rId (original or new)
+    const svgRidMap = new Map(); // SVG fileName -> svgRId
+    const svgFallbacks = [];
+    if (doc.images) {
+        // Pre-build lookup index
+        for (const img of doc.images) {
+            if (img.rId) {
+                imageByRid.set(img.rId, img);
+            }
+        }
+        for (const img of doc.images) {
+            const oldRid = img.rId;
+            if (img.mediaType === "svg" && img.fallbackData) {
+                // SVG with fallback: register PNG fallback as main image, SVG as separate
+                const baseName = img.fileName.replace(/\.[^.]+$/, "");
+                const fallbackFileName = `${baseName}_fallback.png`;
+                // Register PNG fallback as the main rId
+                const fbRId = documentRels.add(RelType.Image, `media/${fallbackFileName}`);
+                img.rId = fbRId;
+                if (oldRid) {
+                    imageRidMap.set(oldRid, fbRId);
+                }
+                imageExtensions.add("png");
+                // Register SVG as separate image
+                const svgRId = documentRels.add(RelType.Image, `media/${img.fileName}`);
+                svgRidMap.set(img.fileName, svgRId);
+                const ext = img.fileName.split(".").pop()?.toLowerCase();
+                if (ext) {
+                    imageExtensions.add(ext);
+                }
+                svgFallbacks.push({ fallbackFileName, data: img.fallbackData });
+            }
+            else {
+                const rId = documentRels.add(RelType.Image, `media/${img.fileName}`);
+                img.rId = rId;
+                if (oldRid) {
+                    imageRidMap.set(oldRid, rId);
+                }
+                const ext = img.fileName.split(".").pop()?.toLowerCase();
+                if (ext) {
+                    imageExtensions.add(ext);
+                }
+            }
+        }
+    }
+    // Update FloatingImage rIds to match new image rIds
+    if (imageRidMap.size > 0) {
+        for (const content of doc.body) {
+            if (content.type === "floatingImage") {
+                const fi = content;
+                if (fi.rId && imageRidMap.has(fi.rId)) {
+                    // Already mapped — the image's rId was updated in-place above
+                    // but floatingImage still has the old rId; update it
+                }
+                // FloatingImage references images by rId; find the matching new rId
+                if (fi.rId) {
+                    const img = imageByRid.get(fi.rId);
+                    if (!img) {
+                        // Old rId — look up in map
+                        const newRid = imageRidMap.get(fi.rId);
+                        if (newRid) {
+                            fi.rId = newRid;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Assign svgRId to inline and floating images that reference SVG files
+    if (svgRidMap.size > 0 && doc.images) {
+        const assignSvgRId = (rId, target) => {
+            const img = doc.images.find(i => i.rId === rId || imageRidMap.get(rId) === i.rId);
+            if (img && img.mediaType === "svg" && img.fallbackData) {
+                const svgRId = svgRidMap.get(img.fileName);
+                if (svgRId) {
+                    target.svgRId = svgRId;
+                }
+            }
+        };
+        for (const content of doc.body) {
+            if (content.type === "floatingImage") {
+                assignSvgRId(content.rId, content);
+            }
+            else if (content.type === "paragraph") {
+                for (const child of content.children ?? []) {
+                    if ("content" in child && Array.isArray(child.content)) {
+                        for (const c of child.content) {
+                            if (c.type === "image" && c.rId) {
+                                assignSvgRId(c.rId, c);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Hyperlinks (external)
+    const hyperlinks = collectHyperlinks(doc.body);
+    for (const link of hyperlinks) {
+        if (link.url) {
+            const rId = documentRels.add(RelType.Hyperlink, link.url, "External");
+            link.rId = rId;
+        }
+    }
+    // Process altChunk body items: register relationship and prepare data part
+    const altChunks = [];
+    collectAltChunks(doc.body, altChunks);
+    altChunks.forEach((chunk, i) => {
+        const fileName = chunk.fileName ?? `afchunk${i + 1}.html`;
+        // Register relationship for the alt chunk
+        const rId = documentRels.add("http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk", fileName);
+        chunk.rId = rId;
+        // Register content type
+        const ct = chunk.contentType ?? "text/html";
+        contentTypes.addOverride(`/word/${fileName}`, ct);
+        // Write data to archive
+        if (chunk.data) {
+            archive.add(`word/${fileName}`, chunk.data);
+        }
+    });
+    // Headers
+    let headerIndex = 1;
+    const headerRelManagers = new Map();
+    if (doc.headers) {
+        for (const [key, headerDef] of doc.headers) {
+            const rId = documentRels.add(RelType.Header, `header${headerIndex}.xml`);
+            headerDef.rId = rId;
+            // Create per-header relationship manager for images and hyperlinks
+            const hRels = new RelationshipManager();
+            const imgRids = collectImageRidsFromContent(headerDef.content);
+            if (imgRids.size > 0 && doc.images) {
+                for (const oldRid of imgRids) {
+                    // O(1) lookup: direct or via remap
+                    const img = imageByRid.get(oldRid) ?? imageByRid.get(imageRidMap.get(oldRid) ?? "");
+                    if (img) {
+                        hRels.addWithId(oldRid, RelType.Image, `media/${img.fileName}`);
+                    }
+                }
+            }
+            // Hyperlinks in header
+            const hLinks = collectHyperlinksFromHeaderFooter(headerDef.content);
+            for (const link of hLinks) {
+                if (link.url) {
+                    const linkRId = hRels.add(RelType.Hyperlink, link.url, "External");
+                    link.rId = linkRId;
+                }
+            }
+            if (hRels.count > 0) {
+                headerRelManagers.set(key, hRels);
+            }
+            headerIndex++;
+        }
+    }
+    // Footers
+    let footerIndex = 1;
+    const footerRelManagers = new Map();
+    if (doc.footers) {
+        for (const [key, footerDef] of doc.footers) {
+            const rId = documentRels.add(RelType.Footer, `footer${footerIndex}.xml`);
+            footerDef.rId = rId;
+            // Create per-footer relationship manager for images and hyperlinks
+            const fRels = new RelationshipManager();
+            const imgRids = collectImageRidsFromContent(footerDef.content);
+            if (imgRids.size > 0 && doc.images) {
+                for (const oldRid of imgRids) {
+                    const img = imageByRid.get(oldRid) ?? imageByRid.get(imageRidMap.get(oldRid) ?? "");
+                    if (img) {
+                        fRels.addWithId(oldRid, RelType.Image, `media/${img.fileName}`);
+                    }
+                }
+            }
+            // Hyperlinks in footer
+            const fLinks = collectHyperlinksFromHeaderFooter(footerDef.content);
+            for (const link of fLinks) {
+                if (link.url) {
+                    const linkRId = fRels.add(RelType.Hyperlink, link.url, "External");
+                    link.rId = linkRId;
+                }
+            }
+            if (fRels.count > 0) {
+                footerRelManagers.set(key, fRels);
+            }
+            footerIndex++;
+        }
+    }
+    // Watermark header (auto-generated if doc.watermark is set)
+    let watermarkHeaderIndex;
+    let watermarkHeaderRels;
+    let watermarkHeaderRId;
+    if (doc.watermark) {
+        // Use next header index
+        const wmHdrIdx = headerIndex;
+        watermarkHeaderRId = documentRels.add(RelType.Header, `header${wmHdrIdx}.xml`);
+        watermarkHeaderIndex = wmHdrIdx;
+        // If image watermark, add image relationship in header .rels
+        if (doc.watermark.type === "image") {
+            const wmRels = new RelationshipManager();
+            const wmRId = doc.watermark.rId;
+            const img = imageByRid.get(wmRId) ?? imageByRid.get(imageRidMap.get(wmRId) ?? "");
+            if (img) {
+                wmRels.addWithId(wmRId, RelType.Image, `media/${img.fileName}`);
+            }
+            watermarkHeaderRels = wmRels;
+        }
+        headerIndex++;
+    }
+    // --- Content Types ---
+    contentTypes.addImageDefaults(imageExtensions);
+    contentTypes.addOverride(PartPath.Document, ContentType.Document);
+    contentTypes.addOverride(PartPath.Styles, ContentType.Styles);
+    contentTypes.addOverride(PartPath.Settings, ContentType.Settings);
+    contentTypes.addOverride(PartPath.FontTable, ContentType.FontTable);
+    contentTypes.addOverride(PartPath.Theme, ContentType.Theme);
+    if (hasNumbering) {
+        contentTypes.addOverride(PartPath.Numbering, ContentType.Numbering);
+    }
+    if (hasFootnotes) {
+        contentTypes.addOverride(PartPath.Footnotes, ContentType.Footnotes);
+    }
+    if (hasEndnotes) {
+        contentTypes.addOverride(PartPath.Endnotes, ContentType.Endnotes);
+    }
+    if (hasComments) {
+        contentTypes.addOverride(PartPath.Comments, ContentType.Comments);
+    }
+    headerIndex = 1;
+    if (doc.headers) {
+        for (const [,] of doc.headers) {
+            contentTypes.addOverride(PartPath.header(headerIndex), ContentType.Header);
+            headerIndex++;
+        }
+    }
+    footerIndex = 1;
+    if (doc.footers) {
+        for (const [,] of doc.footers) {
+            contentTypes.addOverride(PartPath.footer(footerIndex), ContentType.Footer);
+            footerIndex++;
+        }
+    }
+    if (watermarkHeaderIndex !== undefined) {
+        contentTypes.addOverride(PartPath.header(watermarkHeaderIndex), ContentType.Header);
+    }
+    contentTypes.addOverride(PartPath.CoreProps, ContentType.CoreProperties);
+    contentTypes.addOverride(PartPath.AppProps, ContentType.ExtendedProperties);
+    if (hasCustomProps) {
+        contentTypes.addOverride(PartPath.CustomProps, ContentType.CustomProperties);
+    }
+    // --- Generate & add parts to archive ---
+    // Note: [Content_Types].xml and _rels/.rels are serialized LAST so that any
+    // relationships/content types registered during content rendering (e.g.
+    // thumbnails, chart parts, alt chunks) are included.
+    // word/_rels/document.xml.rels
+    archive.add(PartPath.DocumentRels, renderXml(xml => documentRels.render(xml)));
+    // Build an effective doc that includes the auto-generated watermark header
+    // reference in section properties (without mutating the caller's doc).
+    let effectiveDoc = doc;
+    if (watermarkHeaderIndex !== undefined && watermarkHeaderRId) {
+        const existingHeaders = doc.sectionProperties?.headers
+            ? [...doc.sectionProperties.headers]
+            : [];
+        existingHeaders.push({
+            type: "default",
+            rId: watermarkHeaderRId
+        });
+        effectiveDoc = {
+            ...doc,
+            sectionProperties: {
+                ...doc.sectionProperties,
+                headers: existingHeaders
+            }
+        };
+    }
+    // Collect charts and register relationships BEFORE rendering document.xml
+    const charts = [];
+    collectCharts(doc.body, charts);
+    if (doc.headers) {
+        for (const [, h] of doc.headers) {
+            collectChartsFromHeaderFooter(h.content, charts);
+        }
+    }
+    if (doc.footers) {
+        for (const [, f] of doc.footers) {
+            collectChartsFromHeaderFooter(f.content, charts);
+        }
+    }
+    const chartRIds = [];
+    charts.forEach(chartContent => {
+        const num = chartRIds.length + 1;
+        const rId = documentRels.add(RelType.Chart, `charts/chart${num}.xml`);
+        chartRIds.push(rId);
+        // Store rId in registry so renderChartDrawing can look it up
+        CHART_RID_REGISTRY.set(chartContent, rId);
+    });
+    // word/document.xml
+    archive.add(PartPath.Document, renderXml(xml => renderDocument(xml, effectiveDoc)));
+    // word/styles.xml
+    archive.add(PartPath.Styles, renderXml(xml => renderStyles(xml, doc.docDefaults, doc.styles)));
+    // word/settings.xml
+    archive.add(PartPath.Settings, renderXml(xml => renderSettings(xml, doc.settings)));
+    // word/fontTable.xml
+    archive.add(PartPath.FontTable, renderXml(xml => renderFontTable(xml, doc.fonts)));
+    // word/fonts/*.odttf (embedded fonts)
+    if (doc.embeddedFonts && doc.embeddedFonts.length > 0) {
+        const fontTableRels = new RelationshipManager();
+        const usedRIds = new Set();
+        // Collect rIds referenced in fontTable
+        if (doc.fonts) {
+            for (const font of doc.fonts) {
+                if (font.embedRegular) {
+                    usedRIds.add(font.embedRegular);
+                }
+                if (font.embedBold) {
+                    usedRIds.add(font.embedBold);
+                }
+                if (font.embedItalic) {
+                    usedRIds.add(font.embedItalic);
+                }
+                if (font.embedBoldItalic) {
+                    usedRIds.add(font.embedBoldItalic);
+                }
+            }
+        }
+        for (const ef of doc.embeddedFonts) {
+            const partPath = `word/fonts/${ef.fileName}`;
+            archive.add(partPath, ef.data);
+            // Register relationship from fontTable.xml
+            if (usedRIds.has(ef.rId)) {
+                fontTableRels.addWithId(ef.rId, RelType.Font, `fonts/${ef.fileName}`);
+            }
+            else {
+                // Add anyway so the embedded font isn't orphaned
+                fontTableRels.addWithId(ef.rId, RelType.Font, `fonts/${ef.fileName}`);
+            }
+            // Register content type for .odttf / .ttf
+            const ext = ef.fileName.split(".").pop()?.toLowerCase();
+            if (ext === "odttf") {
+                contentTypes.addDefault("odttf", ContentType.ObfuscatedFont);
+            }
+            else if (ext === "ttf") {
+                contentTypes.addDefault("ttf", "application/x-font-ttf");
+            }
+            else if (ext === "otf") {
+                contentTypes.addDefault("otf", "application/x-font-otf");
+            }
+        }
+        // Write fontTable.xml.rels
+        archive.add("word/_rels/fontTable.xml.rels", renderXml(xml => fontTableRels.render(xml)));
+    }
+    // Custom XML parts (for SDT data binding)
+    if (doc.customXmlParts && doc.customXmlParts.length > 0) {
+        doc.customXmlParts.forEach((part, i) => {
+            const num = i + 1;
+            const itemPath = `word/customXml/item${num}.xml`;
+            const propsPath = `word/customXml/itemProps${num}.xml`;
+            // Write the XML content
+            archive.add(itemPath, part.xmlContent);
+            // Write itemProps*.xml
+            const propsXml = renderXml(xml => {
+                xml.openXml(STD_DOC_ATTRIBUTES);
+                xml.openNode("ds:datastoreItem", {
+                    "ds:itemID": `{${part.itemId}}`,
+                    "xmlns:ds": "http://schemas.openxmlformats.org/officeDocument/2006/customXml"
+                });
+                if (part.schemaReferences && part.schemaReferences.length > 0) {
+                    xml.openNode("ds:schemaRefs");
+                    for (const uri of part.schemaReferences) {
+                        xml.leafNode("ds:schemaRef", { "ds:uri": uri });
+                    }
+                    xml.closeNode();
+                }
+                else {
+                    xml.leafNode("ds:schemaRefs");
+                }
+                xml.closeNode();
+            });
+            archive.add(propsPath, propsXml);
+            // Write item rels (links itemN.xml → itemPropsN.xml)
+            const itemRels = new RelationshipManager();
+            itemRels.add(RelType.CustomXmlProps, `itemProps${num}.xml`);
+            archive.add(`word/customXml/_rels/item${num}.xml.rels`, renderXml(xml => itemRels.render(xml)));
+            // Register content types
+            contentTypes.addOverride(`/word/customXml/itemProps${num}.xml`, "application/vnd.openxmlformats-officedocument.customXmlProperties+xml");
+            // Add to document rels
+            documentRels.add(RelType.CustomXml, `customXml/item${num}.xml`);
+        });
+    }
+    // word/theme/theme1.xml
+    archive.add(PartPath.Theme, renderXml(xml => renderTheme(xml, doc.theme)));
+    // word/numbering.xml
+    if (hasNumbering) {
+        archive.add(PartPath.Numbering, renderXml(xml => renderNumbering(xml, doc.abstractNumberings, doc.numberingInstances, doc.numPicBullets)));
+    }
+    // word/footnotes.xml
+    if (hasFootnotes) {
+        archive.add(PartPath.Footnotes, renderXml(xml => renderFootnotes(xml, doc.footnotes)));
+    }
+    // word/endnotes.xml
+    if (hasEndnotes) {
+        archive.add(PartPath.Endnotes, renderXml(xml => renderEndnotes(xml, doc.endnotes)));
+    }
+    // word/comments.xml
+    if (hasComments) {
+        archive.add(PartPath.Comments, renderXml(xml => renderComments(xml, doc.comments)));
+        // word/commentsExtended.xml (for done/parentId)
+        const hasExtended = doc.comments.some(c => c.done !== undefined || c.parentId !== undefined);
+        if (hasExtended) {
+            const extXml = renderXml(xml => renderCommentsExtended(xml, doc.comments));
+            archive.add(PartPath.CommentsExtended, extXml);
+            documentRels.add(RelType.CommentsExtended, "commentsExtended.xml");
+            contentTypes.addOverride(`/${PartPath.CommentsExtended}`, ContentType.CommentsExtended);
+        }
+    }
+    // Headers
+    headerIndex = 1;
+    if (doc.headers) {
+        let hIdx = 0;
+        const keys = [...doc.headers.keys()];
+        for (const [, headerDef] of doc.headers) {
+            archive.add(PartPath.header(headerIndex), renderXml(xml => renderHeader(xml, headerDef.content)));
+            // Header .rels file
+            const hKey = keys[hIdx];
+            const hRels = headerRelManagers.get(hKey);
+            if (hRels && hRels.count > 0) {
+                archive.add(`word/_rels/header${headerIndex}.xml.rels`, renderXml(xml => hRels.render(xml)));
+            }
+            headerIndex++;
+            hIdx++;
+        }
+    }
+    // Footers
+    footerIndex = 1;
+    if (doc.footers) {
+        let fIdx = 0;
+        const keys = [...doc.footers.keys()];
+        for (const [, footerDef] of doc.footers) {
+            archive.add(PartPath.footer(footerIndex), renderXml(xml => renderFooter(xml, footerDef.content)));
+            // Footer .rels file
+            const fKey = keys[fIdx];
+            const fRels = footerRelManagers.get(fKey);
+            if (fRels && fRels.count > 0) {
+                archive.add(`word/_rels/footer${footerIndex}.xml.rels`, renderXml(xml => fRels.render(xml)));
+            }
+            footerIndex++;
+            fIdx++;
+        }
+    }
+    // Watermark header
+    if (watermarkHeaderIndex !== undefined && doc.watermark) {
+        archive.add(PartPath.header(watermarkHeaderIndex), renderXml(xml => renderWatermarkHeader(xml, doc.watermark)));
+        if (watermarkHeaderRels && watermarkHeaderRels.count > 0) {
+            archive.add(`word/_rels/header${watermarkHeaderIndex}.xml.rels`, renderXml(xml => watermarkHeaderRels.render(xml)));
+        }
+    }
+    // Media / images
+    if (doc.images) {
+        for (const img of doc.images) {
+            archive.add(PartPath.media(img.fileName), img.data);
+        }
+    }
+    // SVG fallback PNG files
+    for (const fb of svgFallbacks) {
+        archive.add(PartPath.media(fb.fallbackFileName), fb.data);
+    }
+    // docProps/core.xml
+    archive.add(PartPath.CoreProps, renderXml(xml => renderCoreProperties(xml, doc.coreProperties)));
+    // docProps/app.xml
+    archive.add(PartPath.AppProps, renderXml(xml => renderAppProperties(xml, doc.appProperties)));
+    // docProps/custom.xml
+    if (hasCustomProps) {
+        archive.add(PartPath.CustomProps, renderXml(xml => renderCustomProperties(xml, doc.customProperties)));
+    }
+    // word/webSettings.xml
+    if (doc.webSettings) {
+        archive.add(PartPath.WebSettings, renderXml(xml => renderWebSettings(xml, doc.webSettings)));
+        documentRels.add(RelType.WebSettings, "webSettings.xml");
+        contentTypes.addOverride(`/${PartPath.WebSettings}`, ContentType.WebSettings);
+    }
+    // word/people.xml
+    if (doc.people && doc.people.length > 0) {
+        archive.add(PartPath.People, renderXml(xml => renderPeople(xml, doc.people)));
+        documentRels.add(RelType.People, "people.xml");
+        contentTypes.addOverride(`/${PartPath.People}`, ContentType.People);
+    }
+    // docProps/thumbnail
+    if (doc.thumbnail) {
+        const ext = doc.thumbnail.contentType === "image/jpeg"
+            ? "jpeg"
+            : doc.thumbnail.contentType === "image/png"
+                ? "png"
+                : "wmf";
+        const thumbPath = `docProps/thumbnail.${ext}`;
+        archive.add(thumbPath, doc.thumbnail.data);
+        // Package rels: target is relative to package root (docProps/thumbnail.jpeg)
+        packageRels.add("http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail", thumbPath);
+        contentTypes.addDefault(ext, doc.thumbnail.contentType);
+    }
+    // Write opaque (unrecognized) parts for round-trip preservation
+    if (doc.opaqueParts) {
+        for (const part of doc.opaqueParts) {
+            archive.add(part.path, part.data);
+            // Register content type: explicit > inferred by extension > skip
+            const ext = part.path.split(".").pop()?.toLowerCase();
+            if (part.contentType) {
+                contentTypes.addOverride(`/${part.path}`, part.contentType);
+            }
+            else if (ext) {
+                // Infer from common extensions so [Content_Types].xml isn't incomplete
+                const inferred = inferContentType(ext);
+                if (inferred) {
+                    contentTypes.addOverride(`/${part.path}`, inferred);
+                }
+            }
+            // Write part relationships if any
+            if (part.relationships && part.relationships.length > 0) {
+                const partRels = new RelationshipManager();
+                for (const rel of part.relationships) {
+                    partRels.addWithId(rel.id, rel.type, rel.target, rel.targetMode);
+                }
+                const relsPath = getPartRelsPath(part.path);
+                archive.add(relsPath, renderXml(xml => partRels.render(xml)));
+            }
+        }
+    }
+    // Write chart parts (rIds already registered earlier)
+    charts.forEach((chartContent, i) => {
+        const num = i + 1;
+        const chartPath = `word/charts/chart${num}.xml`;
+        // Register chart part
+        archive.add(chartPath, renderXml(xml => renderChartPart(xml, chartContent.chart)));
+        // Register content type
+        contentTypes.addOverride(`/word/charts/chart${num}.xml`, ContentType.Chart);
+    });
+    // LAST: Write [Content_Types].xml and _rels/.rels after all parts have registered
+    // their content types and relationships.
+    archive.add(PartPath.ContentTypes, renderXml(xml => contentTypes.render(xml)));
+    archive.add(PartPath.PackageRels, renderXml(xml => packageRels.render(xml)));
+    return archive.bytes();
+}
+/** Recursively collect altChunks from body content. */
+function collectAltChunks(body, out) {
+    for (const item of body) {
+        if ("type" in item && item.type === "altChunk") {
+            out.push(item);
+        }
+        else if ("type" in item && item.type === "table") {
+            for (const row of item.rows) {
+                for (const cell of row.cells) {
+                    collectAltChunks(cell.content, out);
+                }
+            }
+        }
+        else if ("type" in item && item.type === "sdt") {
+            collectAltChunks(item.content, out);
+        }
+    }
+}
+/** Recursively collect chart contents from body content. */
+function collectCharts(body, out) {
+    for (const item of body) {
+        if ("type" in item && item.type === "chart") {
+            out.push(item);
+        }
+        else if ("type" in item && item.type === "table") {
+            for (const row of item.rows) {
+                for (const cell of row.cells) {
+                    collectCharts(cell.content, out);
+                }
+            }
+        }
+        else if ("type" in item && item.type === "sdt") {
+            collectCharts(item.content, out);
+        }
+    }
+}
+/** Collect charts from header/footer content. */
+function collectChartsFromHeaderFooter(content, out) {
+    collectCharts(content.children, out);
+}