@cj-tech-master/excelts 9.4.2 → 9.5.0

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

@@ -0,0 +1,465 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHART_RID_REGISTRY = void 0;
+exports.renderDocument = renderDocument;
+const constants_1 = require("../constants");
+const checkbox_writer_1 = require("./checkbox-writer");
+const image_writer_1 = require("./image-writer");
+const math_writer_1 = require("./math-writer");
+const paragraph_writer_1 = require("./paragraph-writer");
+const parts_writer_1 = require("./parts-writer");
+const section_writer_1 = require("./section-writer");
+const table_writer_1 = require("./table-writer");
+const textbox_writer_1 = require("./textbox-writer");
+const toc_writer_1 = require("./toc-writer");
+/** 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") {
+                (0, paragraph_writer_1.renderParagraph)(xml, child);
+            }
+            else if (child.type === "table") {
+                (0, table_writer_1.renderTable)(xml, child);
+            }
+        }
+    }
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render a block-level content element. */
+function renderBodyContent(xml, content) {
+    switch (content.type) {
+        case "paragraph":
+            (0, paragraph_writer_1.renderParagraph)(xml, content);
+            break;
+        case "table":
+            (0, table_writer_1.renderTable)(xml, content);
+            break;
+        case "floatingImage":
+            (0, image_writer_1.renderFloatingImage)(xml, content);
+            break;
+        case "tableOfContents":
+            (0, toc_writer_1.renderTableOfContents)(xml, content);
+            break;
+        case "math":
+            (0, math_writer_1.renderMathBlock)(xml, content);
+            break;
+        case "textBox":
+            (0, textbox_writer_1.renderTextBox)(xml, content);
+            break;
+        case "sdt":
+            renderSdt(xml, content);
+            break;
+        case "checkBox":
+            (0, checkbox_writer_1.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. */
+function renderDocument(xml, doc) {
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("w:document", constants_1.DOCUMENT_NAMESPACES);
+    // Document background (must come before w:body)
+    if (doc.background) {
+        (0, parts_writer_1.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) {
+        (0, section_writer_1.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": constants_1.NS_A });
+    xml.openNode("a:graphicData", { uri: constants_1.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) {
+            (0, paragraph_writer_1.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.
+ */
+exports.CHART_RID_REGISTRY = new WeakMap();
+/** Auto-incrementing SDT ID counter. */
+let _autoSdtIdCounter = 100000000;
+function nextAutoSdtId() {
+    return _autoSdtIdCounter++;
+}
+function renderChartDrawing(xml, content) {
+    const rId = exports.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/cjs/modules/word/writers/footnote-writer.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * DOCX Writers - Footnotes & Endnotes
+ *
+ * Renders word/footnotes.xml and word/endnotes.xml parts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFootnotes = renderFootnotes;
+exports.renderEndnotes = renderEndnotes;
+const constants_1 = require("../constants");
+const paragraph_writer_1 = require("./paragraph-writer");
+/** 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) {
+        (0, paragraph_writer_1.renderParagraph)(xml, para);
+    }
+    xml.closeNode();
+}
+/** Render word/footnotes.xml. */
+function renderFootnotes(xml, footnotes) {
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("w:footnotes", {
+        "xmlns:w": constants_1.NS_W,
+        "xmlns:r": constants_1.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. */
+function renderEndnotes(xml, endnotes) {
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("w:endnotes", {
+        "xmlns:w": constants_1.NS_W,
+        "xmlns:r": constants_1.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();
+}

package/dist/cjs/modules/word/writers/header-footer-writer.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * DOCX Writers - Headers & Footers
+ *
+ * Renders word/header{N}.xml and word/footer{N}.xml parts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHeader = renderHeader;
+exports.renderFooter = renderFooter;
+exports.renderWatermarkHeader = renderWatermarkHeader;
+const constants_1 = require("../constants");
+const paragraph_writer_1 = require("./paragraph-writer");
+const table_writer_1 = require("./table-writer");
+/** Render content blocks (shared between header and footer). */
+function renderContent(xml, content) {
+    for (const child of content.children) {
+        if (child.type === "paragraph") {
+            (0, paragraph_writer_1.renderParagraph)(xml, child);
+        }
+        else if (child.type === "table") {
+            (0, table_writer_1.renderTable)(xml, child);
+        }
+    }
+}
+/** Render a header part (word/header{N}.xml). */
+function renderHeader(xml, content) {
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("w:hdr", {
+        "xmlns:w": constants_1.NS_W,
+        "xmlns:r": constants_1.NS_R
+    });
+    renderContent(xml, content);
+    xml.closeNode();
+}
+/** Render a footer part (word/footer{N}.xml). */
+function renderFooter(xml, content) {
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("w:ftr", {
+        "xmlns:w": constants_1.NS_W,
+        "xmlns:r": constants_1.NS_R
+    });
+    renderContent(xml, content);
+    xml.closeNode();
+}
+/** Render a header part containing a watermark. */
+function renderWatermarkHeader(xml, watermark, imageRId) {
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("w:hdr", {
+        "xmlns:w": constants_1.NS_W,
+        "xmlns:r": constants_1.NS_R,
+        "xmlns:v": constants_1.NS_V,
+        "xmlns:o": constants_1.NS_O,
+        "xmlns:w10": constants_1.NS_W10
+    });
+    // Watermark goes in a paragraph with a single pict run
+    xml.openNode("w:p");
+    xml.openNode("w:pPr");
+    xml.openNode("w:pStyle");
+    xml.closeNode();
+    xml.closeNode(); // pPr
+    xml.openNode("w:r");
+    xml.openNode("w:pict");
+    if (watermark.type === "text") {
+        renderTextWatermarkVml(xml, watermark);
+    }
+    else {
+        renderImageWatermarkVml(xml, watermark, imageRId);
+    }
+    xml.closeNode(); // pict
+    xml.closeNode(); // r
+    xml.closeNode(); // p
+    xml.closeNode(); // hdr
+}
+function renderTextWatermarkVml(xml, wm) {
+    const color = wm.color ?? "C0C0C0";
+    const font = wm.font ?? "Calibri";
+    const fontSize = wm.fontSize ?? 1; // half-points; Word uses pt string in style
+    const fontPt = fontSize / 2;
+    const rotation = wm.rotation ?? -45;
+    const opacity = wm.semiTransparent !== false ? ".5" : "1";
+    // VML shape for text watermark (PowerWash / WASHOUT style)
+    xml.leafNode("v:shapetype", {
+        id: "_x0000_t136",
+        coordsize: "21600,21600",
+        "o:spt": "136",
+        path: "m@7,l@8,m@5,21600l@6,21600e"
+    });
+    const style = `position:absolute;margin-left:0;margin-top:0;width:468pt;height:234pt;` +
+        `rotation:${rotation};z-index:-251658752;mso-position-horizontal:center;` +
+        `mso-position-horizontal-relative:margin;mso-position-vertical:center;` +
+        `mso-position-vertical-relative:margin`;
+    xml.openNode("v:shape", {
+        id: "PowerPlusWaterMarkObject",
+        "o:spid": "_x0000_s2049",
+        type: "#_x0000_t136",
+        style,
+        "o:allowincell": "f",
+        fillcolor: `#${color}`,
+        stroked: "f"
+    });
+    xml.leafNode("v:fill", { opacity });
+    xml.leafNode("v:textpath", {
+        style: `font-family:"${font}";font-size:${fontPt}pt`,
+        string: wm.text
+    });
+    xml.leafNode("w10:wrap", { anchorx: "margin", anchory: "margin" });
+    xml.closeNode(); // v:shape
+}
+function renderImageWatermarkVml(xml, wm, rId) {
+    const scale = wm.scale ?? 100;
+    const rid = rId ?? wm.rId;
+    const style = `position:absolute;margin-left:0;margin-top:0;width:0;height:0;` +
+        `z-index:-251658752;mso-position-horizontal:center;` +
+        `mso-position-horizontal-relative:margin;mso-position-vertical:center;` +
+        `mso-position-vertical-relative:margin`;
+    xml.openNode("v:shape", {
+        id: "PowerPlusWaterMarkObject",
+        "o:spid": "_x0000_s2050",
+        type: "",
+        style,
+        "o:allowincell": "f"
+    });
+    const gain = wm.washout !== false ? "19661f" : "65536f";
+    const blacklevel = wm.washout !== false ? "22938f" : "0";
+    xml.leafNode("v:imagedata", {
+        "r:id": rid,
+        "o:title": "",
+        gain,
+        blacklevel,
+        ...(scale !== 100 ? { "o:detectmouseclick": "t" } : {})
+    });
+    xml.leafNode("w10:wrap", { anchorx: "margin", anchory: "margin" });
+    xml.closeNode(); // v:shape
+}