@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/esm/modules/word/writers/checkbox-writer.js

@@ -0,0 +1,42 @@
+/**
+ * DOCX Writers - CheckBox
+ *
+ * Renders checkbox as a structured document tag (SDT) with w14:checkbox.
+ */
+import { NS_W14 } from "../constants.js";
+/** Render a checkbox as a paragraph with SDT. */
+export function renderCheckBox(xml, cb) {
+    const checked = cb.checked ?? false;
+    const checkedChar = cb.checkedState?.value ?? "2612"; // ☒
+    const uncheckedChar = cb.uncheckedState?.value ?? "2610"; // ☐
+    const checkedFont = cb.checkedState?.font ?? "MS Gothic";
+    const uncheckedFont = cb.uncheckedState?.font ?? "MS Gothic";
+    const displayChar = checked ? checkedChar : uncheckedChar;
+    const displayFont = checked ? checkedFont : uncheckedFont;
+    xml.openNode("w:sdt");
+    // SDT properties
+    xml.openNode("w:sdtPr");
+    xml.openNode("w14:checkbox", { "xmlns:w14": NS_W14 });
+    xml.leafNode("w14:checked", { "w14:val": checked ? "1" : "0" });
+    xml.leafNode("w14:checkedState", { "w14:val": checkedChar, "w14:font": checkedFont });
+    xml.leafNode("w14:uncheckedState", { "w14:val": uncheckedChar, "w14:font": uncheckedFont });
+    xml.closeNode();
+    xml.closeNode();
+    // SDT content - display the checkbox character
+    xml.openNode("w:sdtContent");
+    xml.openNode("w:r");
+    xml.openNode("w:rPr");
+    xml.leafNode("w:rFonts", {
+        "w:ascii": displayFont,
+        "w:hAnsi": displayFont,
+        "w:eastAsia": displayFont
+    });
+    xml.closeNode();
+    xml.openNode("w:t");
+    // Convert hex code point to character
+    xml.writeText(String.fromCodePoint(parseInt(displayChar, 16)));
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // w:sdt
+}

package/dist/esm/modules/word/writers/comment-writer.js

@@ -0,0 +1,70 @@
+/**
+ * DOCX Writers - Comments
+ *
+ * Renders word/comments.xml and word/commentsExtended.xml parts.
+ */
+import { NS_W, NS_R, STD_DOC_ATTRIBUTES } from "../constants.js";
+import { renderParagraph } from "./paragraph-writer.js";
+const NS_W15 = "http://schemas.microsoft.com/office/word/2012/wordml";
+/** Render word/comments.xml. */
+export function renderComments(xml, comments) {
+    xml.openXml(STD_DOC_ATTRIBUTES);
+    xml.openNode("w:comments", {
+        "xmlns:w": NS_W,
+        "xmlns:r": NS_R
+    });
+    for (const comment of comments) {
+        const attrs = {
+            "w:id": String(comment.id),
+            "w:author": comment.author
+        };
+        if (comment.date) {
+            attrs["w:date"] = comment.date;
+        }
+        if (comment.initials) {
+            attrs["w:initials"] = comment.initials;
+        }
+        xml.openNode("w:comment", attrs);
+        for (const para of comment.content) {
+            renderParagraph(xml, para);
+        }
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/**
+ * Render word/commentsExtended.xml — extended comment metadata (done/parentId).
+ * Only includes comments that have either `done` or `parentId` set.
+ * @returns true if any extended comments were rendered.
+ */
+export function renderCommentsExtended(xml, comments) {
+    // Collect comments that need extension
+    const extended = comments.filter(c => c.done !== undefined || c.parentId !== undefined);
+    if (extended.length === 0) {
+        return false;
+    }
+    // Each extended comment must reference the paraId of its first paragraph
+    xml.openXml(STD_DOC_ATTRIBUTES);
+    xml.openNode("w15:commentsEx", {
+        "xmlns:w": NS_W,
+        "xmlns:w15": NS_W15,
+        "mc:Ignorable": "w15",
+        "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006"
+    });
+    for (const c of extended) {
+        const firstPara = c.content[0];
+        if (!firstPara?.paraId) {
+            continue;
+        }
+        const attrs = { "w15:paraId": firstPara.paraId };
+        if (c.done) {
+            attrs["w15:done"] = "1";
+        }
+        if (c.parentId) {
+            attrs["w15:paraIdParent"] = c.parentId;
+        }
+        xml.leafNode("w15:commentEx", attrs);
+    }
+    xml.closeNode();
+    return true;
+}

package/dist/esm/modules/word/writers/document-writer.js

@@ -0,0 +1,461 @@
+/**
+ * DOCX Writers - Document Body
+ *
+ * Renders the main word/document.xml part including all block-level
+ * content types: paragraphs, tables, floating images, TOC, math,
+ * text boxes, and structured document tags.
+ */
+import { DOCUMENT_NAMESPACES, STD_DOC_ATTRIBUTES, NS_A, NS_WPS } from "../constants.js";
+import { renderCheckBox } from "./checkbox-writer.js";
+import { renderFloatingImage } from "./image-writer.js";
+import { renderMathBlock } from "./math-writer.js";
+import { renderParagraph } from "./paragraph-writer.js";
+import { renderDocumentBackground } from "./parts-writer.js";
+import { renderSectionProperties } from "./section-writer.js";
+import { renderTable } from "./table-writer.js";
+import { renderTextBox } from "./textbox-writer.js";
+import { renderTableOfContents } from "./toc-writer.js";
+/** Render a structured document tag. */
+function renderSdt(xml, sdt) {
+    xml.openNode("w:sdt");
+    if (sdt.properties) {
+        xml.openNode("w:sdtPr");
+        const p = sdt.properties;
+        // Auto-assign ID if not provided (Word strongly expects unique IDs)
+        const sdtId = p.id ?? nextAutoSdtId();
+        xml.leafNode("w:id", { "w:val": String(sdtId) });
+        if (p.tag) {
+            xml.leafNode("w:tag", { "w:val": p.tag });
+        }
+        if (p.alias) {
+            xml.leafNode("w:alias", { "w:val": p.alias });
+        }
+        // Lock: combine lockContent + lockSdt
+        if (p.lockContent && p.lockSdt) {
+            xml.leafNode("w:lock", { "w:val": "sdtContentLocked" });
+        }
+        else if (p.lockContent) {
+            xml.leafNode("w:lock", { "w:val": "contentLocked" });
+        }
+        else if (p.lockSdt) {
+            xml.leafNode("w:lock", { "w:val": "sdtLocked" });
+        }
+        // Appearance (w15:appearance for modern SDTs)
+        if (p.appearance) {
+            xml.leafNode("w15:appearance", { "w15:val": p.appearance });
+        }
+        else if (p.showAs) {
+            // Back-compat mapping of legacy showAs
+            const mapped = p.showAs === "boundingBox" ? "boundingBox" : p.showAs === "startEnd" ? "tags" : "hidden";
+            xml.leafNode("w15:appearance", { "w15:val": mapped });
+        }
+        // Show placeholder toggle
+        if (p.showingPlaceholder) {
+            xml.leafNode("w:showingPlcHdr");
+        }
+        if (p.placeholder) {
+            xml.openNode("w:placeholder");
+            xml.leafNode("w:docPart", { "w:val": p.placeholder });
+            xml.closeNode();
+        }
+        if (p.temporary) {
+            xml.leafNode("w:temporary");
+        }
+        if (p.dataBinding) {
+            const bindAttrs = {
+                "w:xpath": p.dataBinding.xpath,
+                "w:storeItemID": p.dataBinding.storeItemId
+            };
+            if (p.dataBinding.prefixMappings) {
+                bindAttrs["w:prefixMappings"] = p.dataBinding.prefixMappings;
+            }
+            xml.leafNode("w:dataBinding", bindAttrs);
+        }
+        // Type discriminator markers
+        if (p.plainText) {
+            xml.leafNode("w:text");
+        }
+        if (p.richText) {
+            xml.leafNode("w:richText");
+        }
+        if (p.picture) {
+            xml.leafNode("w:picture");
+        }
+        if (p.group) {
+            xml.leafNode("w:group");
+        }
+        if (p.equation) {
+            xml.leafNode("w:equation");
+        }
+        if (p.citation) {
+            xml.leafNode("w:citation");
+        }
+        if (p.bibliography) {
+            xml.leafNode("w:bibliography");
+        }
+        if (p.repeatingSectionItem) {
+            xml.leafNode("w15:repeatingSectionItem");
+        }
+        if (p.repeatingSection) {
+            // w15:repeatingSection has child elements (not attributes) per the schema
+            const rs = p.repeatingSection;
+            const hasChildren = rs.sectionTitle !== undefined || rs.allowInsertDelete !== undefined;
+            if (hasChildren) {
+                xml.openNode("w15:repeatingSection");
+                if (rs.sectionTitle !== undefined) {
+                    xml.leafNode("w15:sectionTitle", { "w15:val": rs.sectionTitle });
+                }
+                if (rs.allowInsertDelete === false) {
+                    xml.leafNode("w15:doNotAllowInsertDeleteSection");
+                }
+                xml.closeNode();
+            }
+            else {
+                xml.leafNode("w15:repeatingSection");
+            }
+        }
+        // Checkbox (w14 extension)
+        if (p.checkbox) {
+            xml.openNode("w14:checkbox");
+            xml.leafNode("w14:checked", p.checkbox.checked ? { "w14:val": "1" } : { "w14:val": "0" });
+            if (p.checkbox.checkedChar || p.checkbox.checkedFont) {
+                const cAttrs = {};
+                if (p.checkbox.checkedChar) {
+                    cAttrs["w14:val"] = p.checkbox.checkedChar;
+                }
+                if (p.checkbox.checkedFont) {
+                    cAttrs["w14:font"] = p.checkbox.checkedFont;
+                }
+                xml.leafNode("w14:checkedState", cAttrs);
+            }
+            if (p.checkbox.uncheckedChar || p.checkbox.uncheckedFont) {
+                const uAttrs = {};
+                if (p.checkbox.uncheckedChar) {
+                    uAttrs["w14:val"] = p.checkbox.uncheckedChar;
+                }
+                if (p.checkbox.uncheckedFont) {
+                    uAttrs["w14:font"] = p.checkbox.uncheckedFont;
+                }
+                xml.leafNode("w14:uncheckedState", uAttrs);
+            }
+            xml.closeNode();
+        }
+        // Dropdown list
+        if (p.dropdownList) {
+            xml.openNode("w:dropDownList");
+            for (const item of p.dropdownList) {
+                const attrs = { "w:value": item.value };
+                if (item.displayText) {
+                    attrs["w:displayText"] = item.displayText;
+                }
+                xml.leafNode("w:listItem", attrs);
+            }
+            xml.closeNode();
+        }
+        // ComboBox
+        if (p.comboBox) {
+            xml.openNode("w:comboBox");
+            for (const item of p.comboBox) {
+                const attrs = { "w:value": item.value };
+                if (item.displayText) {
+                    attrs["w:displayText"] = item.displayText;
+                }
+                xml.leafNode("w:listItem", attrs);
+            }
+            xml.closeNode();
+        }
+        // Date picker
+        if (p.date) {
+            const dateAttrs = {};
+            if (p.date.fullDate) {
+                dateAttrs["w:fullDate"] = p.date.fullDate;
+            }
+            xml.openNode("w:date", Object.keys(dateAttrs).length > 0 ? dateAttrs : undefined);
+            if (p.date.dateFormat) {
+                xml.leafNode("w:dateFormat", { "w:val": p.date.dateFormat });
+            }
+            if (p.date.lid) {
+                xml.leafNode("w:lid", { "w:val": p.date.lid });
+            }
+            if (p.date.storeMappedDataAs) {
+                xml.leafNode("w:storeMappedDataAs", { "w:val": p.date.storeMappedDataAs });
+            }
+            xml.closeNode();
+        }
+        xml.closeNode();
+    }
+    xml.openNode("w:sdtContent");
+    for (const child of sdt.content) {
+        if ("type" in child) {
+            if (child.type === "paragraph") {
+                renderParagraph(xml, child);
+            }
+            else if (child.type === "table") {
+                renderTable(xml, child);
+            }
+        }
+    }
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render a block-level content element. */
+function renderBodyContent(xml, content) {
+    switch (content.type) {
+        case "paragraph":
+            renderParagraph(xml, content);
+            break;
+        case "table":
+            renderTable(xml, content);
+            break;
+        case "floatingImage":
+            renderFloatingImage(xml, content);
+            break;
+        case "tableOfContents":
+            renderTableOfContents(xml, content);
+            break;
+        case "math":
+            renderMathBlock(xml, content);
+            break;
+        case "textBox":
+            renderTextBox(xml, content);
+            break;
+        case "sdt":
+            renderSdt(xml, content);
+            break;
+        case "checkBox":
+            renderCheckBox(xml, content);
+            break;
+        case "drawingShape":
+            renderDrawingShape(xml, content);
+            break;
+        case "opaqueDrawing":
+            renderOpaqueDrawing(xml, content);
+            break;
+        case "chart":
+            renderChartDrawing(xml, content);
+            break;
+        case "altChunk":
+            xml.leafNode("w:altChunk", { "r:id": content.rId });
+            break;
+    }
+}
+/** Render the complete word/document.xml. */
+export function renderDocument(xml, doc) {
+    xml.openXml(STD_DOC_ATTRIBUTES);
+    xml.openNode("w:document", DOCUMENT_NAMESPACES);
+    // Document background (must come before w:body)
+    if (doc.background) {
+        renderDocumentBackground(xml, doc.background);
+    }
+    xml.openNode("w:body");
+    for (const content of doc.body) {
+        renderBodyContent(xml, content);
+    }
+    // Final section properties (goes directly in w:body)
+    if (doc.sectionProperties) {
+        renderSectionProperties(xml, doc.sectionProperties);
+    }
+    xml.closeNode(); // w:body
+    xml.closeNode(); // w:document
+}
+// =============================================================================
+// DrawingML Shape Writer
+// =============================================================================
+function renderDrawingShape(xml, shape) {
+    // If rawXml is available, use it for round-trip fidelity
+    if (shape.rawXml) {
+        xml.writeRaw(shape.rawXml);
+        return;
+    }
+    // Wrap in w:p > w:r > w:drawing > wp:anchor > a:graphic > a:graphicData > wps:wsp
+    xml.openNode("w:p");
+    xml.openNode("w:r");
+    xml.openNode("w:drawing");
+    const anchorAttrs = {
+        distT: "0",
+        distB: "0",
+        distL: "114300",
+        distR: "114300",
+        simplePos: "0",
+        relativeHeight: "251658240",
+        behindDoc: shape.behindDoc ? "1" : "0",
+        locked: "0",
+        layoutInCell: "1",
+        allowOverlap: "1"
+    };
+    xml.openNode("wp:anchor", anchorAttrs);
+    xml.leafNode("wp:simplePos", { x: "0", y: "0" });
+    // Horizontal position
+    const hp = shape.horizontalPosition;
+    xml.openNode("wp:positionH", {
+        relativeFrom: hp?.relativeTo ?? "column"
+    });
+    if (hp?.align) {
+        xml.openNode("wp:align");
+        xml.writeText(hp.align);
+        xml.closeNode();
+    }
+    else {
+        xml.openNode("wp:posOffset");
+        xml.writeText(String(hp?.offset ?? 0));
+        xml.closeNode();
+    }
+    xml.closeNode(); // wp:positionH
+    // Vertical position
+    const vp = shape.verticalPosition;
+    xml.openNode("wp:positionV", {
+        relativeFrom: vp?.relativeTo ?? "paragraph"
+    });
+    if (vp?.align) {
+        xml.openNode("wp:align");
+        xml.writeText(vp.align);
+        xml.closeNode();
+    }
+    else {
+        xml.openNode("wp:posOffset");
+        xml.writeText(String(vp?.offset ?? 0));
+        xml.closeNode();
+    }
+    xml.closeNode(); // wp:positionV
+    xml.leafNode("wp:extent", {
+        cx: String(shape.width),
+        cy: String(shape.height)
+    });
+    xml.leafNode("wp:effectExtent", { l: "0", t: "0", r: "0", b: "0" });
+    // Wrap
+    const wrap = shape.wrap;
+    if (!wrap || wrap.style === "none") {
+        xml.leafNode("wp:wrapNone");
+    }
+    else if (wrap.style === "square") {
+        xml.leafNode("wp:wrapSquare", { wrapText: wrap.side ?? "bothSides" });
+    }
+    else if (wrap.style === "tight") {
+        xml.leafNode("wp:wrapTight", { wrapText: wrap.side ?? "bothSides" });
+    }
+    else if (wrap.style === "topAndBottom") {
+        xml.leafNode("wp:wrapTopAndBottom");
+    }
+    const docPrAttrs = { id: "1", name: shape.name ?? "Shape" };
+    if (shape.altText) {
+        docPrAttrs["descr"] = shape.altText;
+    }
+    xml.leafNode("wp:docPr", docPrAttrs);
+    xml.openNode("a:graphic", { "xmlns:a": NS_A });
+    xml.openNode("a:graphicData", { uri: NS_WPS });
+    xml.openNode("wps:wsp");
+    // Shape properties
+    xml.openNode("wps:spPr");
+    // Transform
+    xml.openNode("a:xfrm", shape.rotation ? { rot: String(shape.rotation) } : {});
+    xml.leafNode("a:off", { x: "0", y: "0" });
+    xml.leafNode("a:ext", { cx: String(shape.width), cy: String(shape.height) });
+    xml.closeNode(); // a:xfrm
+    // Preset geometry
+    xml.openNode("a:prstGeom", { prst: shape.shapeType });
+    xml.leafNode("a:avLst");
+    xml.closeNode(); // a:prstGeom
+    // Fill
+    if (shape.noFill) {
+        xml.leafNode("a:noFill");
+    }
+    else if (shape.fillColor) {
+        xml.openNode("a:solidFill");
+        xml.leafNode("a:srgbClr", { val: shape.fillColor });
+        xml.closeNode();
+    }
+    // Outline
+    const lnAttrs = {};
+    if (shape.outlineWidth) {
+        lnAttrs["w"] = String(shape.outlineWidth);
+    }
+    if (shape.outlineColor || shape.noOutline) {
+        xml.openNode("a:ln", lnAttrs);
+        if (shape.noOutline) {
+            xml.leafNode("a:noFill");
+        }
+        else if (shape.outlineColor) {
+            xml.openNode("a:solidFill");
+            xml.leafNode("a:srgbClr", { val: shape.outlineColor });
+            xml.closeNode();
+        }
+        xml.closeNode(); // a:ln
+    }
+    xml.closeNode(); // wps:spPr
+    // Text body
+    if (shape.textContent && shape.textContent.length > 0) {
+        xml.openNode("wps:txbx");
+        xml.openNode("w:txbxContent");
+        for (const para of shape.textContent) {
+            renderParagraph(xml, para);
+        }
+        xml.closeNode(); // w:txbxContent
+        xml.closeNode(); // wps:txbx
+    }
+    // Body properties (required)
+    xml.leafNode("wps:bodyPr");
+    xml.closeNode(); // wps:wsp
+    xml.closeNode(); // a:graphicData
+    xml.closeNode(); // a:graphic
+    xml.closeNode(); // wp:anchor
+    xml.closeNode(); // w:drawing
+    xml.closeNode(); // w:r
+    xml.closeNode(); // w:p
+}
+// =============================================================================
+// Opaque Drawing Writer
+// =============================================================================
+function renderOpaqueDrawing(xml, drawing) {
+    xml.openNode("w:p");
+    xml.openNode("w:r");
+    xml.writeRaw(drawing.rawXml);
+    xml.closeNode(); // w:r
+    xml.closeNode(); // w:p
+}
+// =============================================================================
+// Chart Drawing Writer (inline chart reference)
+// =============================================================================
+/**
+ * Registry mapping ChartContent → rId. Populated by packager before rendering.
+ * Uses a WeakMap so chart contents can be garbage collected.
+ */
+export const CHART_RID_REGISTRY = new WeakMap();
+/** Auto-incrementing SDT ID counter. */
+let _autoSdtIdCounter = 100000000;
+function nextAutoSdtId() {
+    return _autoSdtIdCounter++;
+}
+function renderChartDrawing(xml, content) {
+    const rId = CHART_RID_REGISTRY.get(content) ?? "rId0";
+    const cx = content.chart.width ?? 5486400; // 6 inches default
+    const cy = content.chart.height ?? 3200400; // 3.5 inches default
+    xml.openNode("w:p");
+    xml.openNode("w:r");
+    xml.openNode("w:drawing");
+    xml.openNode("wp:inline", { distT: "0", distB: "0", distL: "0", distR: "0" });
+    xml.leafNode("wp:extent", { cx: String(cx), cy: String(cy) });
+    xml.leafNode("wp:effectExtent", { l: "0", t: "0", r: "0", b: "0" });
+    xml.leafNode("wp:docPr", {
+        id: "1",
+        name: content.name ?? "Chart",
+        ...(content.altText ? { descr: content.altText } : {})
+    });
+    xml.leafNode("wp:cNvGraphicFramePr");
+    xml.openNode("a:graphic", {
+        "xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main"
+    });
+    xml.openNode("a:graphicData", {
+        uri: "http://schemas.openxmlformats.org/drawingml/2006/chart"
+    });
+    xml.leafNode("c:chart", {
+        "xmlns:c": "http://schemas.openxmlformats.org/drawingml/2006/chart",
+        "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+        "r:id": rId
+    });
+    xml.closeNode(); // a:graphicData
+    xml.closeNode(); // a:graphic
+    xml.closeNode(); // wp:inline
+    xml.closeNode(); // w:drawing
+    xml.closeNode(); // w:r
+    xml.closeNode(); // w:p
+}

package/dist/esm/modules/word/writers/footnote-writer.js

@@ -0,0 +1,72 @@
+/**
+ * DOCX Writers - Footnotes & Endnotes
+ *
+ * Renders word/footnotes.xml and word/endnotes.xml parts.
+ */
+import { NS_W, NS_R, STD_DOC_ATTRIBUTES } from "../constants.js";
+import { renderParagraph } from "./paragraph-writer.js";
+/** Render the default separator/continuation separator entries (required by Word). */
+function renderDefaultSeparators(xml, elementName) {
+    // Separator (id=-1)
+    xml.openNode(elementName, { "w:type": "separator", "w:id": "-1" });
+    xml.openNode("w:p");
+    xml.openNode("w:r");
+    xml.leafNode("w:separator");
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    // Continuation separator (id=0)
+    xml.openNode(elementName, { "w:type": "continuationSeparator", "w:id": "0" });
+    xml.openNode("w:p");
+    xml.openNode("w:r");
+    xml.leafNode("w:continuationSeparator");
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render a single footnote/endnote entry. */
+function renderNote(xml, elementName, note) {
+    const attrs = { "w:id": String(note.id) };
+    if (note.type && note.type !== "normal") {
+        attrs["w:type"] = note.type;
+    }
+    xml.openNode(elementName, attrs);
+    for (const para of note.content) {
+        renderParagraph(xml, para);
+    }
+    xml.closeNode();
+}
+/** Render word/footnotes.xml. */
+export function renderFootnotes(xml, footnotes) {
+    xml.openXml(STD_DOC_ATTRIBUTES);
+    xml.openNode("w:footnotes", {
+        "xmlns:w": NS_W,
+        "xmlns:r": NS_R
+    });
+    // If the caller already provided separator entries (by having any id <= 0), use those.
+    // Otherwise, synthesize the default separators.
+    const hasSeparators = footnotes.some(fn => fn.id <= 0);
+    if (!hasSeparators) {
+        renderDefaultSeparators(xml, "w:footnote");
+    }
+    for (const fn of footnotes) {
+        renderNote(xml, "w:footnote", fn);
+    }
+    xml.closeNode();
+}
+/** Render word/endnotes.xml. */
+export function renderEndnotes(xml, endnotes) {
+    xml.openXml(STD_DOC_ATTRIBUTES);
+    xml.openNode("w:endnotes", {
+        "xmlns:w": NS_W,
+        "xmlns:r": NS_R
+    });
+    const hasSeparators = endnotes.some(en => en.id <= 0);
+    if (!hasSeparators) {
+        renderDefaultSeparators(xml, "w:endnote");
+    }
+    for (const en of endnotes) {
+        renderNote(xml, "w:endnote", en);
+    }
+    xml.closeNode();
+}