@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/cjs/modules/word/writers/table-writer.js

@@ -0,0 +1,506 @@
+"use strict";
+/**
+ * DOCX Writers - Table
+ *
+ * Renders w:tbl, w:tr, w:tc elements with full property support
+ * including floating tables, table look, cell spacing, and revisions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTable = renderTable;
+const paragraph_writer_1 = require("./paragraph-writer");
+const run_writer_1 = require("./run-writer");
+/** Render a table width element. */
+function renderTableWidth(xml, tagName, tw) {
+    xml.leafNode(tagName, { "w:w": String(tw.value), "w:type": tw.type });
+}
+/** Render table borders. */
+function renderTableBorders(xml, tagName, borders) {
+    xml.openNode(tagName);
+    if (borders.top) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:top", borders.top);
+    }
+    if (borders.left) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:left", borders.left);
+    }
+    if (borders.bottom) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:bottom", borders.bottom);
+    }
+    if (borders.right) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:right", borders.right);
+    }
+    if (borders.insideH) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:insideH", borders.insideH);
+    }
+    if (borders.insideV) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:insideV", borders.insideV);
+    }
+    if (borders.start) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:start", borders.start);
+    }
+    if (borders.end) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:end", borders.end);
+    }
+    if (borders.tl2br) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:tl2br", borders.tl2br);
+    }
+    if (borders.tr2bl) {
+        (0, paragraph_writer_1.renderBorder)(xml, "w:tr2bl", borders.tr2bl);
+    }
+    xml.closeNode();
+}
+/** Render table cell margins. */
+function renderCellMargins(xml, tagName, margins) {
+    xml.openNode(tagName);
+    if (margins.top) {
+        renderTableWidth(xml, "w:top", margins.top);
+    }
+    if (margins.left) {
+        renderTableWidth(xml, "w:left", margins.left);
+    }
+    if (margins.bottom) {
+        renderTableWidth(xml, "w:bottom", margins.bottom);
+    }
+    if (margins.right) {
+        renderTableWidth(xml, "w:right", margins.right);
+    }
+    if (margins.start) {
+        renderTableWidth(xml, "w:start", margins.start);
+    }
+    if (margins.end) {
+        renderTableWidth(xml, "w:end", margins.end);
+    }
+    xml.closeNode();
+}
+/** Render table look (conditional formatting flags). */
+function renderTableLook(xml, look) {
+    // Per ECMA-376, w:tblLook has individual attributes (w:firstRow etc.) as the
+    // authoritative representation. w:val is a legacy 4-hex-digit bitmask kept
+    // for compatibility with older consumers.
+    //
+    // We write individual attributes AND compute w:val to match them. This
+    // ensures both representations agree (no conflict).
+    const attrs = {};
+    let val = 0;
+    if (look.firstRow !== undefined) {
+        attrs["w:firstRow"] = look.firstRow ? "1" : "0";
+        if (look.firstRow) {
+            val |= 0x0020;
+        }
+    }
+    if (look.lastRow !== undefined) {
+        attrs["w:lastRow"] = look.lastRow ? "1" : "0";
+        if (look.lastRow) {
+            val |= 0x0040;
+        }
+    }
+    if (look.firstColumn !== undefined) {
+        attrs["w:firstColumn"] = look.firstColumn ? "1" : "0";
+        if (look.firstColumn) {
+            val |= 0x0080;
+        }
+    }
+    if (look.lastColumn !== undefined) {
+        attrs["w:lastColumn"] = look.lastColumn ? "1" : "0";
+        if (look.lastColumn) {
+            val |= 0x0100;
+        }
+    }
+    if (look.noHBand !== undefined) {
+        attrs["w:noHBand"] = look.noHBand ? "1" : "0";
+        if (look.noHBand) {
+            val |= 0x0200;
+        }
+    }
+    if (look.noVBand !== undefined) {
+        attrs["w:noVBand"] = look.noVBand ? "1" : "0";
+        if (look.noVBand) {
+            val |= 0x0400;
+        }
+    }
+    attrs["w:val"] = val.toString(16).toUpperCase().padStart(4, "0");
+    xml.leafNode("w:tblLook", attrs);
+}
+/** Render floating table properties (w:tblpPr). */
+function renderTableFloat(xml, float) {
+    const attrs = {};
+    if (float.horizontalAnchor) {
+        attrs["w:horzAnchor"] = float.horizontalAnchor;
+    }
+    if (float.verticalAnchor) {
+        attrs["w:vertAnchor"] = float.verticalAnchor;
+    }
+    if (float.absoluteHorizontalPosition !== undefined) {
+        attrs["w:tblpX"] = String(float.absoluteHorizontalPosition);
+    }
+    if (float.absoluteVerticalPosition !== undefined) {
+        attrs["w:tblpY"] = String(float.absoluteVerticalPosition);
+    }
+    if (float.relativeHorizontalPosition) {
+        attrs["w:tblpXSpec"] = float.relativeHorizontalPosition;
+    }
+    if (float.relativeVerticalPosition) {
+        attrs["w:tblpYSpec"] = float.relativeVerticalPosition;
+    }
+    if (float.topFromText !== undefined) {
+        attrs["w:topFromText"] = String(float.topFromText);
+    }
+    if (float.bottomFromText !== undefined) {
+        attrs["w:bottomFromText"] = String(float.bottomFromText);
+    }
+    if (float.leftFromText !== undefined) {
+        attrs["w:leftFromText"] = String(float.leftFromText);
+    }
+    if (float.rightFromText !== undefined) {
+        attrs["w:rightFromText"] = String(float.rightFromText);
+    }
+    // Note: w:tblOverlap is a separate sibling element of w:tblpPr, not an attribute.
+    // It's rendered separately by the caller (renderTableProperties).
+    xml.leafNode("w:tblpPr", attrs);
+}
+/** Render w:tblPr. */
+function renderTableProperties(xml, tPr, insidePropertyChange = false) {
+    xml.openNode("w:tblPr");
+    if (tPr.style) {
+        xml.leafNode("w:tblStyle", { "w:val": tPr.style });
+    }
+    // Floating table must come before width
+    if (tPr.float) {
+        renderTableFloat(xml, tPr.float);
+        // w:tblOverlap is a separate sibling element
+        if (tPr.float.overlap) {
+            xml.leafNode("w:tblOverlap", { "w:val": tPr.float.overlap });
+        }
+    }
+    if (tPr.width) {
+        renderTableWidth(xml, "w:tblW", tPr.width);
+    }
+    if (tPr.alignment) {
+        xml.leafNode("w:jc", { "w:val": tPr.alignment });
+    }
+    if (tPr.cellSpacing) {
+        renderTableWidth(xml, "w:tblCellSpacing", tPr.cellSpacing);
+    }
+    if (tPr.indent !== undefined) {
+        xml.leafNode("w:tblInd", { "w:w": String(tPr.indent), "w:type": "dxa" });
+    }
+    if (tPr.borders) {
+        renderTableBorders(xml, "w:tblBorders", tPr.borders);
+    }
+    if (tPr.shading) {
+        (0, run_writer_1.renderShading)(xml, tPr.shading);
+    }
+    if (tPr.layout) {
+        xml.leafNode("w:tblLayout", { "w:type": tPr.layout });
+    }
+    if (tPr.cellMargins) {
+        renderCellMargins(xml, "w:tblCellMar", tPr.cellMargins);
+    }
+    if (tPr.look) {
+        renderTableLook(xml, tPr.look);
+    }
+    if (tPr.visuallyRightToLeft) {
+        xml.leafNode("w:bidiVisual");
+    }
+    // Accessibility: caption and description
+    if (tPr.caption !== undefined) {
+        xml.leafNode("w:tblCaption", { "w:val": tPr.caption });
+    }
+    if (tPr.description !== undefined) {
+        xml.leafNode("w:tblDescription", { "w:val": tPr.description });
+    }
+    // Table property change (track changes) - must be last child
+    if (!insidePropertyChange && tPr.propertyChange) {
+        const rev = tPr.propertyChange.revision;
+        const attrs = {
+            "w:id": String(rev.id),
+            "w:author": rev.author
+        };
+        if (rev.date) {
+            attrs["w:date"] = rev.date;
+        }
+        xml.openNode("w:tblPrChange", attrs);
+        if (tPr.propertyChange.previousProperties) {
+            renderTableProperties(xml, tPr.propertyChange.previousProperties, true);
+        }
+        else {
+            xml.openNode("w:tblPr");
+            xml.closeNode();
+        }
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/** Render w:trPr. */
+function renderTableRowProperties(xml, rPr, insidePropertyChange = false) {
+    xml.openNode("w:trPr");
+    // Per ECMA-376 CT_TrPr schema order:
+    // cnfStyle → divId → gridBefore → gridAfter → wBefore → wAfter → cantSplit →
+    // trHeight → tblHeader → tblCellSpacing → jc → hidden → ins/del
+    if (rPr.cnfStyle) {
+        xml.leafNode("w:cnfStyle", { "w:val": rPr.cnfStyle });
+    }
+    if (rPr.gridBefore !== undefined) {
+        xml.leafNode("w:gridBefore", { "w:val": String(rPr.gridBefore) });
+    }
+    if (rPr.gridAfter !== undefined) {
+        xml.leafNode("w:gridAfter", { "w:val": String(rPr.gridAfter) });
+    }
+    if (rPr.widthBefore) {
+        renderTableWidth(xml, "w:wBefore", rPr.widthBefore);
+    }
+    if (rPr.widthAfter) {
+        renderTableWidth(xml, "w:wAfter", rPr.widthAfter);
+    }
+    if (rPr.cantSplit) {
+        xml.leafNode("w:cantSplit");
+    }
+    if (rPr.height) {
+        const attrs = { "w:val": String(rPr.height.value) };
+        if (rPr.height.rule) {
+            attrs["w:hRule"] = rPr.height.rule;
+        }
+        xml.leafNode("w:trHeight", attrs);
+    }
+    if (rPr.tableHeader) {
+        xml.leafNode("w:tblHeader");
+    }
+    if (rPr.cellSpacing) {
+        renderTableWidth(xml, "w:tblCellSpacing", rPr.cellSpacing);
+    }
+    if (rPr.hidden) {
+        xml.leafNode("w:hidden");
+    }
+    // Track changes: inserted row
+    if (rPr.inserted) {
+        const attrs = {
+            "w:id": String(rPr.inserted.revision.id),
+            "w:author": rPr.inserted.revision.author
+        };
+        if (rPr.inserted.revision.date) {
+            attrs["w:date"] = rPr.inserted.revision.date;
+        }
+        xml.leafNode("w:ins", attrs);
+    }
+    // Track changes: deleted row
+    if (rPr.deleted) {
+        const attrs = {
+            "w:id": String(rPr.deleted.revision.id),
+            "w:author": rPr.deleted.revision.author
+        };
+        if (rPr.deleted.revision.date) {
+            attrs["w:date"] = rPr.deleted.revision.date;
+        }
+        xml.leafNode("w:del", attrs);
+    }
+    // Row property change (track changes)
+    if (!insidePropertyChange && rPr.propertyChange) {
+        const rev = rPr.propertyChange.revision;
+        const attrs = {
+            "w:id": String(rev.id),
+            "w:author": rev.author
+        };
+        if (rev.date) {
+            attrs["w:date"] = rev.date;
+        }
+        xml.openNode("w:trPrChange", attrs);
+        if (rPr.propertyChange.previousProperties) {
+            renderTableRowProperties(xml, rPr.propertyChange.previousProperties, true);
+        }
+        else {
+            xml.openNode("w:trPr");
+            xml.closeNode();
+        }
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/** Render w:tcPr. */
+function renderTableCellProperties(xml, cPr, insidePropertyChange = false) {
+    xml.openNode("w:tcPr");
+    // Per CT_TcPr order: cnfStyle → tcW → gridSpan → hMerge → vMerge → tcBorders →
+    // shd → noWrap → tcMar → textDirection → tcFitText → vAlign → hideMark
+    if (cPr.cnfStyle) {
+        xml.leafNode("w:cnfStyle", { "w:val": cPr.cnfStyle });
+    }
+    if (cPr.width) {
+        renderTableWidth(xml, "w:tcW", cPr.width);
+    }
+    if (cPr.gridSpan !== undefined && cPr.gridSpan > 1) {
+        xml.leafNode("w:gridSpan", { "w:val": String(cPr.gridSpan) });
+    }
+    if (cPr.verticalMerge !== undefined) {
+        if (cPr.verticalMerge === "restart") {
+            xml.leafNode("w:vMerge", { "w:val": "restart" });
+        }
+        else {
+            xml.leafNode("w:vMerge");
+        }
+    }
+    if (cPr.borders) {
+        renderTableBorders(xml, "w:tcBorders", cPr.borders);
+    }
+    if (cPr.shading) {
+        (0, run_writer_1.renderShading)(xml, cPr.shading);
+    }
+    if (cPr.noWrap) {
+        xml.leafNode("w:noWrap");
+    }
+    if (cPr.margins) {
+        renderCellMargins(xml, "w:tcMar", cPr.margins);
+    }
+    if (cPr.textDirection) {
+        xml.leafNode("w:textDirection", { "w:val": cPr.textDirection });
+    }
+    if (cPr.fitText) {
+        xml.leafNode("w:tcFitText");
+    }
+    if (cPr.verticalAlign) {
+        xml.leafNode("w:vAlign", { "w:val": cPr.verticalAlign });
+    }
+    if (cPr.hideMark) {
+        xml.leafNode("w:hideMark");
+    }
+    // Cell-level revisions (cellIns/cellDel/cellMerge)
+    if (cPr.inserted) {
+        const attrs = {
+            "w:id": String(cPr.inserted.revision.id),
+            "w:author": cPr.inserted.revision.author
+        };
+        if (cPr.inserted.revision.date) {
+            attrs["w:date"] = cPr.inserted.revision.date;
+        }
+        xml.leafNode("w:cellIns", attrs);
+    }
+    if (cPr.deleted) {
+        const attrs = {
+            "w:id": String(cPr.deleted.revision.id),
+            "w:author": cPr.deleted.revision.author
+        };
+        if (cPr.deleted.revision.date) {
+            attrs["w:date"] = cPr.deleted.revision.date;
+        }
+        xml.leafNode("w:cellDel", attrs);
+    }
+    if (cPr.cellMerge) {
+        const attrs = {
+            "w:vMerge": cPr.cellMerge.vMerge,
+            "w:id": String(cPr.cellMerge.revision.id),
+            "w:author": cPr.cellMerge.revision.author
+        };
+        if (cPr.cellMerge.revision.date) {
+            attrs["w:date"] = cPr.cellMerge.revision.date;
+        }
+        xml.leafNode("w:cellMerge", attrs);
+    }
+    // Cell property change (track changes)
+    if (!insidePropertyChange && cPr.propertyChange) {
+        const rev = cPr.propertyChange.revision;
+        const attrs = {
+            "w:id": String(rev.id),
+            "w:author": rev.author
+        };
+        if (rev.date) {
+            attrs["w:date"] = rev.date;
+        }
+        xml.openNode("w:tcPrChange", attrs);
+        if (cPr.propertyChange.previousProperties) {
+            renderTableCellProperties(xml, cPr.propertyChange.previousProperties, true);
+        }
+        else {
+            xml.openNode("w:tcPr");
+            xml.closeNode();
+        }
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/** Render a table cell. */
+function renderTableCell(xml, cell) {
+    xml.openNode("w:tc");
+    if (cell.properties) {
+        renderTableCellProperties(xml, cell.properties);
+    }
+    // Cell must contain at least one paragraph
+    if (cell.content.length === 0) {
+        xml.openNode("w:p");
+        xml.closeNode();
+    }
+    else {
+        for (const block of cell.content) {
+            if (block.type === "paragraph") {
+                (0, paragraph_writer_1.renderParagraph)(xml, block);
+            }
+            else if (block.type === "table") {
+                renderTable(xml, block);
+            }
+        }
+    }
+    xml.closeNode();
+}
+/** Render a table row. */
+function renderTableRow(xml, row) {
+    xml.openNode("w:tr");
+    // Table property exception (w:tblPrEx) must come before w:trPr per schema
+    if (row.properties?.tblPrEx) {
+        renderTablePropertiesEx(xml, row.properties.tblPrEx);
+    }
+    if (row.properties) {
+        renderTableRowProperties(xml, row.properties);
+    }
+    for (const cell of row.cells) {
+        renderTableCell(xml, cell);
+    }
+    xml.closeNode();
+}
+/** Render w:tblPrEx (table-level property exceptions applied to a row). */
+function renderTablePropertiesEx(xml, ex) {
+    xml.openNode("w:tblPrEx");
+    // Output the subset of tblPr that can appear in tblPrEx
+    if (ex.width) {
+        renderTableWidth(xml, "w:tblW", ex.width);
+    }
+    if (ex.alignment) {
+        xml.leafNode("w:jc", { "w:val": ex.alignment });
+    }
+    if (ex.cellSpacing) {
+        renderTableWidth(xml, "w:tblCellSpacing", ex.cellSpacing);
+    }
+    if (ex.indent !== undefined) {
+        xml.leafNode("w:tblInd", { "w:w": String(ex.indent), "w:type": "dxa" });
+    }
+    if (ex.borders) {
+        renderTableBorders(xml, "w:tblBorders", ex.borders);
+    }
+    if (ex.shading) {
+        (0, run_writer_1.renderShading)(xml, ex.shading);
+    }
+    if (ex.layout) {
+        xml.leafNode("w:tblLayout", { "w:type": ex.layout });
+    }
+    if (ex.cellMargins) {
+        renderCellMargins(xml, "w:tblCellMar", ex.cellMargins);
+    }
+    if (ex.look) {
+        renderTableLook(xml, ex.look);
+    }
+    xml.closeNode();
+}
+/** Render a w:tbl element. */
+function renderTable(xml, table) {
+    xml.openNode("w:tbl");
+    if (table.properties) {
+        renderTableProperties(xml, table.properties);
+    }
+    // Column grid
+    if (table.columnWidths && table.columnWidths.length > 0) {
+        xml.openNode("w:tblGrid");
+        for (const w of table.columnWidths) {
+            xml.leafNode("w:gridCol", { "w:w": String(w) });
+        }
+        xml.closeNode();
+    }
+    for (const row of table.rows) {
+        renderTableRow(xml, row);
+    }
+    xml.closeNode();
+}

package/dist/cjs/modules/word/writers/textbox-writer.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * DOCX Writers - TextBox
+ *
+ * Renders text boxes using VML (v:shape) with mc:AlternateContent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTextBox = renderTextBox;
+const constants_1 = require("../constants");
+const paragraph_writer_1 = require("./paragraph-writer");
+/** Render a text box as a VML shape within a paragraph. */
+function renderTextBox(xml, textBox) {
+    const width = textBox.width ?? 4680; // default ~3.25 inches
+    const height = textBox.height ?? 1440; // default 1 inch
+    // Convert twips to points for VML style
+    const widthPt = width / 20;
+    const heightPt = height / 20;
+    const style = textBox.style ?? `width:${widthPt}pt;height:${heightPt}pt;mso-wrap-style:square`;
+    xml.openNode("w:p");
+    xml.openNode("w:r");
+    xml.openNode("w:pict");
+    // VML shape
+    const shapeAttrs = {
+        "xmlns:v": constants_1.NS_V,
+        "xmlns:o": constants_1.NS_O,
+        type: "#_x0000_t202",
+        style
+    };
+    if (textBox.stroke === false) {
+        shapeAttrs["stroked"] = "f";
+    }
+    if (textBox.strokeColor) {
+        shapeAttrs["strokecolor"] = `#${textBox.strokeColor}`;
+    }
+    if (textBox.fill === false) {
+        shapeAttrs["filled"] = "f";
+    }
+    if (textBox.fillColor) {
+        shapeAttrs["fillcolor"] = `#${textBox.fillColor}`;
+    }
+    xml.openNode("v:shape", shapeAttrs);
+    // Text box content
+    xml.openNode("v:textbox");
+    xml.openNode("w:txbxContent", { "xmlns:w": constants_1.NS_W });
+    for (const para of textBox.content) {
+        (0, paragraph_writer_1.renderParagraph)(xml, para);
+    }
+    xml.closeNode(); // w:txbxContent
+    xml.closeNode(); // v:textbox
+    // Word10 wrap
+    xml.leafNode("w10:wrap", { "xmlns:w10": constants_1.NS_W10, type: "square" });
+    xml.closeNode(); // v:shape
+    xml.closeNode(); // w:pict
+    xml.closeNode(); // w:r
+    xml.closeNode(); // w:p
+}

package/dist/cjs/modules/word/writers/toc-writer.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * DOCX Writers - Table of Contents
+ *
+ * Renders TOC as a structured document tag (SDT) with field codes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTableOfContents = renderTableOfContents;
+const paragraph_writer_1 = require("./paragraph-writer");
+/** Build TOC field instruction from properties. */
+function buildTocInstruction(toc) {
+    const parts = ["TOC"];
+    if (toc.headingStyleRange) {
+        parts.push(`\\o "${toc.headingStyleRange}"`);
+    }
+    if (toc.hyperlink) {
+        parts.push("\\h");
+    }
+    if (toc.stylesWithLevels && toc.stylesWithLevels.length > 0) {
+        // Format: "Style1,Level1;Style2,Level2;..."
+        const entries = toc.stylesWithLevels.map(s => `${s.styleName},${s.level}`).join(";");
+        parts.push(`\\t "${entries}"`);
+    }
+    if (toc.captionLabel) {
+        parts.push(`\\c "${toc.captionLabel}"`);
+    }
+    if (toc.sequenceFieldIdentifier) {
+        parts.push(`\\s "${toc.sequenceFieldIdentifier}"`);
+    }
+    return ` ${parts.join(" ")} `;
+}
+/** Render a Table of Contents block. */
+function renderTableOfContents(xml, toc) {
+    const instruction = buildTocInstruction(toc);
+    // Wrap in SDT for proper Word handling
+    xml.openNode("w:sdt");
+    xml.openNode("w:sdtPr");
+    xml.openNode("w:docPartObj");
+    xml.leafNode("w:docPartGallery", { "w:val": "Table of Contents" });
+    xml.leafNode("w:docPartUnique");
+    xml.closeNode();
+    xml.closeNode();
+    xml.openNode("w:sdtContent");
+    // Begin field paragraph
+    xml.openNode("w:p");
+    xml.openNode("w:r");
+    xml.leafNode("w:fldChar", { "w:fldCharType": "begin" });
+    xml.closeNode();
+    xml.openNode("w:r");
+    xml.openNode("w:instrText", { "xml:space": "preserve" });
+    xml.writeText(instruction);
+    xml.closeNode();
+    xml.closeNode();
+    xml.openNode("w:r");
+    xml.leafNode("w:fldChar", { "w:fldCharType": "separate" });
+    xml.closeNode();
+    xml.closeNode();
+    // Cached paragraphs (placeholder content until Word updates the field)
+    if (toc.cachedParagraphs && toc.cachedParagraphs.length > 0) {
+        for (const para of toc.cachedParagraphs) {
+            (0, paragraph_writer_1.renderParagraph)(xml, para);
+        }
+    }
+    else {
+        // Default placeholder
+        xml.openNode("w:p");
+        xml.openNode("w:r");
+        xml.openNode("w:t");
+        xml.writeText("Update this table of contents by right-clicking and selecting 'Update Field'");
+        xml.closeNode();
+        xml.closeNode();
+        xml.closeNode();
+    }
+    // End field paragraph
+    xml.openNode("w:p");
+    xml.openNode("w:r");
+    xml.leafNode("w:fldChar", { "w:fldCharType": "end" });
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // w:sdtContent
+    xml.closeNode(); // w:sdt
+}