@cj-tech-master/excelts 9.4.2 → 9.5.0

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

@@ -0,0 +1,428 @@
+/**
+ * DOCX Writers - Math / Equations (OMML)
+ *
+ * Renders Office Math Markup Language elements (m:oMath).
+ */
+import { NS_M } from "../constants.js";
+/** 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. */
+export function renderMathBlock(xml, math) {
+    xml.openNode("m:oMathPara", { "xmlns:m": NS_M });
+    xml.openNode("m:oMath");
+    renderMathContents(xml, math.content);
+    xml.closeNode();
+    xml.closeNode();
+}

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

@@ -0,0 +1,125 @@
+/**
+ * DOCX Writers - Numbering
+ *
+ * Renders word/numbering.xml with abstract numbering definitions and instances.
+ * Supports suffix, legal numbering style, restart levels, and level overrides.
+ */
+import { NS_W, NS_R, STD_DOC_ATTRIBUTES } from "../constants.js";
+import { renderParagraphProperties } from "./paragraph-writer.js";
+import { renderRunProperties } from "./run-writer.js";
+/** Render a single numbering level. */
+function renderLevel(xml, level) {
+    xml.openNode("w:lvl", { "w:ilvl": String(level.level) });
+    // Per ECMA-376 CT_Lvl order:
+    // start → numFmt → lvlRestart → pStyle → isLgl → suff → lvlText → lvlPicBulletId → legacy → lvlJc → pPr → rPr
+    if (level.start !== undefined) {
+        xml.leafNode("w:start", { "w:val": String(level.start) });
+    }
+    xml.leafNode("w:numFmt", { "w:val": level.format });
+    if (level.restartAfterLevel !== undefined) {
+        xml.leafNode("w:lvlRestart", { "w:val": String(level.restartAfterLevel) });
+    }
+    if (level.paragraphStyle) {
+        xml.leafNode("w:pStyle", { "w:val": level.paragraphStyle });
+    }
+    if (level.isLegalNumberingStyle) {
+        xml.leafNode("w:isLgl");
+    }
+    if (level.suffix) {
+        xml.leafNode("w:suff", { "w:val": level.suffix });
+    }
+    xml.leafNode("w:lvlText", { "w:val": level.text });
+    if (level.picBulletId !== undefined) {
+        xml.leafNode("w:lvlPicBulletId", { "w:val": String(level.picBulletId) });
+    }
+    if (level.justification) {
+        xml.leafNode("w:lvlJc", { "w:val": level.justification });
+    }
+    if (level.paragraphProperties) {
+        renderParagraphProperties(xml, level.paragraphProperties);
+    }
+    if (level.runProperties) {
+        renderRunProperties(xml, level.runProperties);
+    }
+    xml.closeNode();
+}
+/** Render word/numbering.xml. */
+export function renderNumbering(xml, abstractNums, instances, numPicBullets) {
+    xml.openXml(STD_DOC_ATTRIBUTES);
+    xml.openNode("w:numbering", {
+        "xmlns:w": NS_W,
+        "xmlns:r": NS_R,
+        "xmlns:v": "urn:schemas-microsoft-com:vml",
+        "xmlns:o": "urn:schemas-microsoft-com:office:office"
+    });
+    // Picture bullets come first
+    if (numPicBullets) {
+        for (const pb of numPicBullets) {
+            xml.openNode("w:numPicBullet", { "w:numPicBulletId": String(pb.id) });
+            if (pb.rawVmlXml) {
+                // Use raw VML for full fidelity
+                xml.writeRaw(pb.rawVmlXml);
+            }
+            else if (pb.rId) {
+                // Default VML shape with image fill
+                xml.openNode("w:pict");
+                xml.leafNode("v:shapetype", {
+                    id: "_x0000_t75",
+                    coordsize: "21600,21600",
+                    "o:spt": "75",
+                    "o:preferrelative": "t",
+                    path: "m@4@5l@4@11@9@11@9@5xe",
+                    filled: "f",
+                    stroked: "f"
+                });
+                xml.openNode("v:shape", {
+                    id: `_x0000_i10${pb.id}`,
+                    type: "#_x0000_t75",
+                    style: `width:${pb.width ? Math.round(pb.width / 12700) : 12}pt;height:${pb.height ? Math.round(pb.height / 12700) : 12}pt`
+                });
+                xml.leafNode("v:imagedata", { "r:id": pb.rId, "o:title": "" });
+                xml.closeNode();
+                xml.closeNode();
+            }
+            xml.closeNode();
+        }
+    }
+    if (abstractNums) {
+        for (const abs of abstractNums) {
+            xml.openNode("w:abstractNum", { "w:abstractNumId": String(abs.abstractNumId) });
+            if (abs.multiLevelType) {
+                xml.leafNode("w:multiLevelType", { "w:val": abs.multiLevelType });
+            }
+            if (abs.numStyleLink) {
+                xml.leafNode("w:numStyleLink", { "w:val": abs.numStyleLink });
+            }
+            if (abs.styleLink) {
+                xml.leafNode("w:styleLink", { "w:val": abs.styleLink });
+            }
+            for (const level of abs.levels) {
+                renderLevel(xml, level);
+            }
+            xml.closeNode();
+        }
+    }
+    if (instances) {
+        for (const inst of instances) {
+            xml.openNode("w:num", { "w:numId": String(inst.numId) });
+            xml.leafNode("w:abstractNumId", { "w:val": String(inst.abstractNumId) });
+            if (inst.overrides) {
+                for (const ov of inst.overrides) {
+                    xml.openNode("w:lvlOverride", { "w:ilvl": String(ov.level) });
+                    if (ov.startOverride !== undefined) {
+                        xml.leafNode("w:startOverride", { "w:val": String(ov.startOverride) });
+                    }
+                    if (ov.levelDef) {
+                        renderLevel(xml, ov.levelDef);
+                    }
+                    xml.closeNode();
+                }
+            }
+            xml.closeNode();
+        }
+    }
+    xml.closeNode();
+}