@cj-tech-master/excelts 9.4.2 → 9.5.0

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

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * DOCX Writers - Floating Image
+ *
+ * Renders wp:anchor elements for floating (non-inline) images
+ * with full support for rotation, flip, lock anchor, outline, and wrap margins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFloatingImage = renderFloatingImage;
+const constants_1 = require("../constants");
+/** Render a floating image as a standalone paragraph with wp:anchor. */
+function renderFloatingImage(xml, img) {
+    const drawingId = img.drawingId ?? 1;
+    const name = img.name ?? "Picture";
+    xml.openNode("w:p");
+    xml.openNode("w:r");
+    xml.openNode("w:drawing");
+    // Wrap margins
+    const wrapMargins = img.wrap?.margins;
+    xml.openNode("wp:anchor", {
+        distT: String(img.distT ?? wrapMargins?.top ?? 0),
+        distB: String(img.distB ?? wrapMargins?.bottom ?? 0),
+        distL: String(img.distL ?? wrapMargins?.left ?? 114300),
+        distR: String(img.distR ?? wrapMargins?.right ?? 114300),
+        simplePos: img.simplePos ? "1" : "0",
+        relativeHeight: String(img.relativeHeight ?? 251658240),
+        behindDoc: img.behindDoc ? "1" : "0",
+        locked: img.lockAnchor ? "1" : "0",
+        layoutInCell: img.layoutInCell === false ? "0" : "1",
+        allowOverlap: img.allowOverlap === false ? "0" : "1"
+    });
+    xml.leafNode("wp:simplePos", {
+        x: String(img.simplePos?.x ?? 0),
+        y: String(img.simplePos?.y ?? 0)
+    });
+    // Horizontal position
+    {
+        const hp = img.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();
+    }
+    // Vertical position
+    {
+        const vp = img.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();
+    }
+    xml.leafNode("wp:extent", { cx: String(img.width), cy: String(img.height) });
+    xml.leafNode("wp:effectExtent", { l: "0", t: "0", r: "0", b: "0" });
+    // Wrapping
+    if (img.wrap) {
+        switch (img.wrap.style) {
+            case "square":
+                xml.leafNode("wp:wrapSquare", { wrapText: img.wrap.side ?? "bothSides" });
+                break;
+            case "tight":
+                xml.leafNode("wp:wrapTight", { wrapText: img.wrap.side ?? "bothSides" });
+                break;
+            case "through":
+                xml.leafNode("wp:wrapThrough", { wrapText: img.wrap.side ?? "bothSides" });
+                break;
+            case "topAndBottom":
+                xml.leafNode("wp:wrapTopAndBottom");
+                break;
+            case "none":
+                xml.leafNode("wp:wrapNone");
+                break;
+        }
+    }
+    else {
+        xml.leafNode("wp:wrapNone");
+    }
+    xml.leafNode("wp:docPr", {
+        id: String(drawingId),
+        name,
+        ...(img.altText ? { descr: img.altText } : {})
+    });
+    xml.openNode("wp:cNvGraphicFramePr");
+    xml.leafNode("a:graphicFrameLocks", { "xmlns:a": constants_1.NS_A, noChangeAspect: "1" });
+    xml.closeNode();
+    xml.openNode("a:graphic", { "xmlns:a": constants_1.NS_A });
+    xml.openNode("a:graphicData", { uri: constants_1.URI_PIC });
+    xml.openNode("pic:pic", { "xmlns:pic": constants_1.NS_PIC });
+    xml.openNode("pic:nvPicPr");
+    xml.leafNode("pic:cNvPr", { id: String(drawingId), name });
+    xml.leafNode("pic:cNvPicPr");
+    xml.closeNode();
+    xml.openNode("pic:blipFill");
+    if (img.svgRId) {
+        // SVG with raster fallback: a:blip has extLst with asvg:svgBlip
+        xml.openNode("a:blip", { "r:embed": img.rId });
+        xml.openNode("a:extLst");
+        xml.openNode("a:ext", { uri: constants_1.GUID_SVG });
+        xml.leafNode("asvg:svgBlip", {
+            "xmlns:asvg": constants_1.NS_ASVG,
+            "r:embed": img.svgRId
+        });
+        xml.closeNode(); // a:ext
+        xml.closeNode(); // a:extLst
+        xml.closeNode(); // a:blip
+    }
+    else {
+        xml.leafNode("a:blip", { "r:embed": img.rId });
+    }
+    // Source rectangle (crop)
+    if (img.srcRect) {
+        const sr = img.srcRect;
+        const srAttrs = {};
+        if (sr.l !== undefined) {
+            srAttrs["l"] = String(sr.l);
+        }
+        if (sr.t !== undefined) {
+            srAttrs["t"] = String(sr.t);
+        }
+        if (sr.r !== undefined) {
+            srAttrs["r"] = String(sr.r);
+        }
+        if (sr.b !== undefined) {
+            srAttrs["b"] = String(sr.b);
+        }
+        xml.leafNode("a:srcRect", srAttrs);
+    }
+    xml.openNode("a:stretch");
+    xml.leafNode("a:fillRect");
+    xml.closeNode();
+    xml.closeNode();
+    xml.openNode("pic:spPr");
+    // Transform with rotation/flip
+    const xfrmAttrs = {};
+    if (img.rotation) {
+        xfrmAttrs["rot"] = String(img.rotation);
+    }
+    if (img.flipHorizontal) {
+        xfrmAttrs["flipH"] = "1";
+    }
+    if (img.flipVertical) {
+        xfrmAttrs["flipV"] = "1";
+    }
+    xml.openNode("a:xfrm", Object.keys(xfrmAttrs).length > 0 ? xfrmAttrs : undefined);
+    xml.leafNode("a:off", { x: "0", y: "0" });
+    xml.leafNode("a:ext", { cx: String(img.width), cy: String(img.height) });
+    xml.closeNode();
+    xml.openNode("a:prstGeom", { prst: "rect" });
+    xml.leafNode("a:avLst");
+    xml.closeNode();
+    // Outline
+    if (img.outline) {
+        const lnAttrs = {};
+        if (img.outline.width !== undefined) {
+            lnAttrs["w"] = String(img.outline.width);
+        }
+        xml.openNode("a:ln", Object.keys(lnAttrs).length > 0 ? lnAttrs : undefined);
+        if (img.outline.color) {
+            xml.openNode("a:solidFill");
+            xml.leafNode("a:srgbClr", { val: img.outline.color });
+            xml.closeNode();
+        }
+        xml.closeNode();
+    }
+    xml.closeNode(); // pic:spPr
+    xml.closeNode(); // pic:pic
+    xml.closeNode(); // a:graphicData
+    xml.closeNode(); // a:graphic
+    xml.closeNode(); // wp:anchor
+    xml.closeNode(); // w:drawing
+    xml.closeNode(); // w:r
+    xml.closeNode(); // w:p
+}

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

@@ -0,0 +1,431 @@
+"use strict";
+/**
+ * DOCX Writers - Math / Equations (OMML)
+ *
+ * Renders Office Math Markup Language elements (m:oMath).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMathBlock = renderMathBlock;
+const constants_1 = require("../constants");
+/** Render math content array. */
+function renderMathContents(xml, contents) {
+    for (const content of contents) {
+        renderMathContent(xml, content);
+    }
+}
+/** Render a single math content element. */
+function renderMathContent(xml, content) {
+    switch (content.type) {
+        case "mathRun":
+            renderMathRun(xml, content);
+            break;
+        case "mathFraction":
+            renderMathFraction(xml, content);
+            break;
+        case "mathSuperScript":
+            renderMathSuperScript(xml, content);
+            break;
+        case "mathSubScript":
+            renderMathSubScript(xml, content);
+            break;
+        case "mathSubSuperScript":
+            renderMathSubSuperScript(xml, content);
+            break;
+        case "mathPreSubSuperScript":
+            renderMathPreSubSuperScript(xml, content);
+            break;
+        case "mathPhantom":
+            renderMathPhantom(xml, content);
+            break;
+        case "mathGroupChar":
+            renderMathGroupChar(xml, content);
+            break;
+        case "mathBorderBox":
+            renderMathBorderBox(xml, content);
+            break;
+        case "mathRadical":
+            renderMathRadical(xml, content);
+            break;
+        case "mathDelimiter":
+            renderMathDelimiter(xml, content);
+            break;
+        case "mathNary":
+            renderMathNary(xml, content);
+            break;
+        case "mathFunction":
+            renderMathFunction(xml, content);
+            break;
+        case "mathLimit":
+            renderMathLimit(xml, content);
+            break;
+        case "mathMatrix":
+            renderMathMatrix(xml, content);
+            break;
+        case "mathAccent":
+            renderMathAccent(xml, content);
+            break;
+        case "mathBar":
+            renderMathBar(xml, content);
+            break;
+        case "mathBox":
+            renderMathBox(xml, content);
+            break;
+        case "mathEquationArray":
+            renderMathEquationArray(xml, content);
+            break;
+    }
+}
+/** Render math run (m:r). */
+function renderMathRun(xml, run) {
+    xml.openNode("m:r");
+    if (run.properties) {
+        xml.openNode("m:rPr");
+        if (run.properties.italic !== undefined) {
+            xml.leafNode("m:sty", {
+                "m:val": run.properties.bold
+                    ? run.properties.italic
+                        ? "bi"
+                        : "b"
+                    : run.properties.italic
+                        ? "i"
+                        : "p"
+            });
+        }
+        if (run.properties.font) {
+            xml.leafNode("m:scr", { "m:val": "roman" });
+        }
+        xml.closeNode();
+    }
+    xml.openNode("m:t", { "xml:space": "preserve" });
+    xml.writeText(run.text);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render fraction (m:f). */
+function renderMathFraction(xml, frac) {
+    xml.openNode("m:f");
+    if (frac.fractionType && frac.fractionType !== "bar") {
+        xml.openNode("m:fPr");
+        xml.leafNode("m:type", { "m:val": frac.fractionType });
+        xml.closeNode();
+    }
+    xml.openNode("m:num");
+    renderMathContents(xml, frac.numerator);
+    xml.closeNode();
+    xml.openNode("m:den");
+    renderMathContents(xml, frac.denominator);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render superscript (m:sSup). */
+function renderMathSuperScript(xml, sup) {
+    xml.openNode("m:sSup");
+    xml.openNode("m:e");
+    renderMathContents(xml, sup.base);
+    xml.closeNode();
+    xml.openNode("m:sup");
+    renderMathContents(xml, sup.superScript);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render subscript (m:sSub). */
+function renderMathSubScript(xml, sub) {
+    xml.openNode("m:sSub");
+    xml.openNode("m:e");
+    renderMathContents(xml, sub.base);
+    xml.closeNode();
+    xml.openNode("m:sub");
+    renderMathContents(xml, sub.subScript);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render sub-superscript (m:sSubSup). */
+function renderMathSubSuperScript(xml, ss) {
+    xml.openNode("m:sSubSup");
+    xml.openNode("m:e");
+    renderMathContents(xml, ss.base);
+    xml.closeNode();
+    xml.openNode("m:sub");
+    renderMathContents(xml, ss.subScript);
+    xml.closeNode();
+    xml.openNode("m:sup");
+    renderMathContents(xml, ss.superScript);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render pre-sub-superscript (m:sPre). */
+function renderMathPreSubSuperScript(xml, ss) {
+    xml.openNode("m:sPre");
+    xml.openNode("m:sub");
+    renderMathContents(xml, ss.preSubScript);
+    xml.closeNode();
+    xml.openNode("m:sup");
+    renderMathContents(xml, ss.preSuperScript);
+    xml.closeNode();
+    xml.openNode("m:e");
+    renderMathContents(xml, ss.base);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render phantom (m:phant). */
+function renderMathPhantom(xml, p) {
+    xml.openNode("m:phant");
+    // phant properties
+    const hasProps = p.show !== undefined ||
+        p.zeroWidth !== undefined ||
+        p.zeroAscent !== undefined ||
+        p.zeroDescent !== undefined ||
+        p.transparent !== undefined;
+    if (hasProps) {
+        xml.openNode("m:phantPr");
+        if (p.show) {
+            xml.leafNode("m:show", { "m:val": "1" });
+        }
+        if (p.zeroWidth) {
+            xml.leafNode("m:zeroWid", { "m:val": "1" });
+        }
+        if (p.zeroAscent) {
+            xml.leafNode("m:zeroAsc", { "m:val": "1" });
+        }
+        if (p.zeroDescent) {
+            xml.leafNode("m:zeroDesc", { "m:val": "1" });
+        }
+        if (p.transparent) {
+            xml.leafNode("m:transp", { "m:val": "1" });
+        }
+        xml.closeNode();
+    }
+    xml.openNode("m:e");
+    renderMathContents(xml, p.content);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render group character (m:groupChr). */
+function renderMathGroupChar(xml, g) {
+    xml.openNode("m:groupChr");
+    if (g.char || g.position || g.verticalAlign) {
+        xml.openNode("m:groupChrPr");
+        if (g.char) {
+            xml.leafNode("m:chr", { "m:val": g.char });
+        }
+        if (g.position) {
+            xml.leafNode("m:pos", { "m:val": g.position });
+        }
+        if (g.verticalAlign) {
+            xml.leafNode("m:vertJc", { "m:val": g.verticalAlign });
+        }
+        xml.closeNode();
+    }
+    xml.openNode("m:e");
+    renderMathContents(xml, g.base);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render border box (m:borderBox). */
+function renderMathBorderBox(xml, b) {
+    xml.openNode("m:borderBox");
+    const hasProps = b.hideTop ||
+        b.hideBottom ||
+        b.hideLeft ||
+        b.hideRight ||
+        b.strikeBlTr ||
+        b.strikeTlBr ||
+        b.strikeH ||
+        b.strikeV;
+    if (hasProps) {
+        xml.openNode("m:borderBoxPr");
+        if (b.hideTop) {
+            xml.leafNode("m:hideTop", { "m:val": "1" });
+        }
+        if (b.hideBottom) {
+            xml.leafNode("m:hideBot", { "m:val": "1" });
+        }
+        if (b.hideLeft) {
+            xml.leafNode("m:hideLeft", { "m:val": "1" });
+        }
+        if (b.hideRight) {
+            xml.leafNode("m:hideRight", { "m:val": "1" });
+        }
+        if (b.strikeBlTr) {
+            xml.leafNode("m:strikeBLTR", { "m:val": "1" });
+        }
+        if (b.strikeTlBr) {
+            xml.leafNode("m:strikeTLBR", { "m:val": "1" });
+        }
+        if (b.strikeH) {
+            xml.leafNode("m:strikeH", { "m:val": "1" });
+        }
+        if (b.strikeV) {
+            xml.leafNode("m:strikeV", { "m:val": "1" });
+        }
+        xml.closeNode();
+    }
+    xml.openNode("m:e");
+    renderMathContents(xml, b.content);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render radical (m:rad). */
+function renderMathRadical(xml, rad) {
+    xml.openNode("m:rad");
+    if (rad.hideDegree) {
+        xml.openNode("m:radPr");
+        xml.leafNode("m:degHide", { "m:val": "1" });
+        xml.closeNode();
+    }
+    xml.openNode("m:deg");
+    if (rad.degree) {
+        renderMathContents(xml, rad.degree);
+    }
+    xml.closeNode();
+    xml.openNode("m:e");
+    renderMathContents(xml, rad.content);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render delimiter (m:d). */
+function renderMathDelimiter(xml, d) {
+    xml.openNode("m:d");
+    if (d.beginChar || d.endChar || d.separatorChar) {
+        xml.openNode("m:dPr");
+        if (d.beginChar) {
+            xml.leafNode("m:begChr", { "m:val": d.beginChar });
+        }
+        if (d.endChar) {
+            xml.leafNode("m:endChr", { "m:val": d.endChar });
+        }
+        if (d.separatorChar) {
+            xml.leafNode("m:sepChr", { "m:val": d.separatorChar });
+        }
+        xml.closeNode();
+    }
+    for (const group of d.content) {
+        xml.openNode("m:e");
+        renderMathContents(xml, group);
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/** Render n-ary operator (m:nary) — sum, product, integral, etc. */
+function renderMathNary(xml, nary) {
+    xml.openNode("m:nary");
+    // Properties
+    const hasProps = nary.char || nary.limitsLocation || nary.supHide || nary.subHide;
+    if (hasProps) {
+        xml.openNode("m:naryPr");
+        if (nary.char) {
+            xml.leafNode("m:chr", { "m:val": nary.char });
+        }
+        if (nary.limitsLocation) {
+            xml.leafNode("m:limLoc", { "m:val": nary.limitsLocation });
+        }
+        if (nary.supHide) {
+            xml.leafNode("m:supHide", { "m:val": "1" });
+        }
+        if (nary.subHide) {
+            xml.leafNode("m:subHide", { "m:val": "1" });
+        }
+        xml.closeNode();
+    }
+    xml.openNode("m:sub");
+    if (nary.sub) {
+        renderMathContents(xml, nary.sub);
+    }
+    xml.closeNode();
+    xml.openNode("m:sup");
+    if (nary.sup) {
+        renderMathContents(xml, nary.sup);
+    }
+    xml.closeNode();
+    xml.openNode("m:e");
+    renderMathContents(xml, nary.content);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render function (m:func). */
+function renderMathFunction(xml, func) {
+    xml.openNode("m:func");
+    xml.openNode("m:fName");
+    renderMathContents(xml, func.name);
+    xml.closeNode();
+    xml.openNode("m:e");
+    renderMathContents(xml, func.content);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render limit (m:limUpp or m:limLow). */
+function renderMathLimit(xml, lim) {
+    const tag = lim.limitType === "upper" ? "m:limUpp" : "m:limLow";
+    xml.openNode(tag);
+    xml.openNode("m:e");
+    renderMathContents(xml, lim.base);
+    xml.closeNode();
+    xml.openNode("m:lim");
+    renderMathContents(xml, lim.limit);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render matrix (m:m). */
+function renderMathMatrix(xml, matrix) {
+    xml.openNode("m:m");
+    for (const row of matrix.rows) {
+        xml.openNode("m:mr");
+        for (const cell of row) {
+            xml.openNode("m:e");
+            renderMathContents(xml, cell);
+            xml.closeNode();
+        }
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/** Render accent (m:acc). */
+function renderMathAccent(xml, acc) {
+    xml.openNode("m:acc");
+    if (acc.char) {
+        xml.openNode("m:accPr");
+        xml.leafNode("m:chr", { "m:val": acc.char });
+        xml.closeNode();
+    }
+    xml.openNode("m:e");
+    renderMathContents(xml, acc.content);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render bar/overline/underline (m:bar). */
+function renderMathBar(xml, bar) {
+    xml.openNode("m:bar");
+    xml.openNode("m:barPr");
+    xml.leafNode("m:pos", { "m:val": bar.position === "top" ? "top" : "bot" });
+    xml.closeNode();
+    xml.openNode("m:e");
+    renderMathContents(xml, bar.content);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render box (m:box). */
+function renderMathBox(xml, box) {
+    xml.openNode("m:box");
+    xml.openNode("m:e");
+    renderMathContents(xml, box.content);
+    xml.closeNode();
+    xml.closeNode();
+}
+/** Render equation array (m:eqArr). */
+function renderMathEquationArray(xml, eqArr) {
+    xml.openNode("m:eqArr");
+    for (const row of eqArr.rows) {
+        xml.openNode("m:e");
+        renderMathContents(xml, row);
+        xml.closeNode();
+    }
+    xml.closeNode();
+}
+/** Render a math block (m:oMathPara > m:oMath). Body-level math. */
+function renderMathBlock(xml, math) {
+    xml.openNode("m:oMathPara", { "xmlns:m": constants_1.NS_M });
+    xml.openNode("m:oMath");
+    renderMathContents(xml, math.content);
+    xml.closeNode();
+    xml.closeNode();
+}