@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/{browser/modules/word/writers → esm/modules/word/writer}/footnote-writer.js

@@ -25,48 +25,51 @@ function renderDefaultSeparators(xml, elementName) {
     xml.closeNode();
 }
 /** Render a single footnote/endnote entry. */
-function renderNote(xml, elementName, note) {
+function renderNote(xml, elementName, note, helpers) {
     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);
+        renderParagraph(xml, para, helpers);
     }
     xml.closeNode();
 }
 /** Render word/footnotes.xml. */
-export function renderFootnotes(xml, footnotes) {
+export function renderFootnotes(xml, footnotes, helpers) {
     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 the caller already provided separator entries (identified by their
+    // `type` rather than a magic id range), use those. Otherwise synthesize
+    // the default separators. Earlier we keyed off `id <= 0`, but a caller is
+    // free to use id=0 for a normal note — that would silently skip the
+    // mandatory separators and produce an invalid document.
+    const hasSeparators = footnotes.some(fn => fn.type === "separator" || fn.type === "continuationSeparator");
     if (!hasSeparators) {
         renderDefaultSeparators(xml, "w:footnote");
     }
     for (const fn of footnotes) {
-        renderNote(xml, "w:footnote", fn);
+        renderNote(xml, "w:footnote", fn, helpers);
     }
     xml.closeNode();
 }
 /** Render word/endnotes.xml. */
-export function renderEndnotes(xml, endnotes) {
+export function renderEndnotes(xml, endnotes, helpers) {
     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);
+    const hasSeparators = endnotes.some(en => en.type === "separator" || en.type === "continuationSeparator");
     if (!hasSeparators) {
         renderDefaultSeparators(xml, "w:endnote");
     }
     for (const en of endnotes) {
-        renderNote(xml, "w:endnote", en);
+        renderNote(xml, "w:endnote", en, helpers);
     }
     xml.closeNode();
 }

package/dist/{browser/modules/word/writers → esm/modules/word/writer}/header-footer-writer.js

@@ -3,38 +3,57 @@
  *
  * Renders word/header{N}.xml and word/footer{N}.xml parts.
  */
-import { NS_W, NS_R, NS_V, NS_O, NS_W10, STD_DOC_ATTRIBUTES } from "../constants.js";
+import { NS_W, NS_R, NS_V, NS_O, NS_W10, NS_WP, NS_M, NS_W14, NS_W15, NS_WP14, NS_MC, STD_DOC_ATTRIBUTES } from "../constants.js";
 import { renderParagraph } from "./paragraph-writer.js";
 import { renderTable } from "./table-writer.js";
 /** Render content blocks (shared between header and footer). */
-function renderContent(xml, content) {
+function renderContent(xml, content, helpers) {
+    let emitted = 0;
     for (const child of content.children) {
         if (child.type === "paragraph") {
-            renderParagraph(xml, child);
+            renderParagraph(xml, child, helpers);
+            emitted++;
         }
         else if (child.type === "table") {
-            renderTable(xml, child);
+            renderTable(xml, child, helpers);
+            emitted++;
         }
     }
+    // OOXML requires every header/footer part to contain at least one
+    // <w:p>. When the caller passes an empty children array we still emit
+    // a placeholder so Word does not refuse to load the package.
+    if (emitted === 0) {
+        xml.openNode("w:p");
+        xml.closeNode();
+    }
 }
+/** Standard namespace attributes for header/footer parts — must include DrawingML namespaces. */
+const HEADER_FOOTER_NAMESPACES = {
+    "xmlns:w": NS_W,
+    "xmlns:r": NS_R,
+    "xmlns:wp": NS_WP,
+    "xmlns:m": NS_M,
+    "xmlns:v": NS_V,
+    "xmlns:o": NS_O,
+    "xmlns:w10": NS_W10,
+    "xmlns:w14": NS_W14,
+    "xmlns:w15": NS_W15,
+    "xmlns:wp14": NS_WP14,
+    "xmlns:mc": NS_MC,
+    "mc:Ignorable": "w14 w15 wp14"
+};
 /** Render a header part (word/header{N}.xml). */
-export function renderHeader(xml, content) {
+export function renderHeader(xml, content, helpers) {
     xml.openXml(STD_DOC_ATTRIBUTES);
-    xml.openNode("w:hdr", {
-        "xmlns:w": NS_W,
-        "xmlns:r": NS_R
-    });
-    renderContent(xml, content);
+    xml.openNode("w:hdr", HEADER_FOOTER_NAMESPACES);
+    renderContent(xml, content, helpers);
     xml.closeNode();
 }
 /** Render a footer part (word/footer{N}.xml). */
-export function renderFooter(xml, content) {
+export function renderFooter(xml, content, helpers) {
     xml.openXml(STD_DOC_ATTRIBUTES);
-    xml.openNode("w:ftr", {
-        "xmlns:w": NS_W,
-        "xmlns:r": NS_R
-    });
-    renderContent(xml, content);
+    xml.openNode("w:ftr", HEADER_FOOTER_NAMESPACES);
+    renderContent(xml, content, helpers);
     xml.closeNode();
 }
 /** Render a header part containing a watermark. */
@@ -47,12 +66,11 @@ export function renderWatermarkHeader(xml, watermark, imageRId) {
         "xmlns:o": NS_O,
         "xmlns:w10": NS_W10
     });
-    // Watermark goes in a paragraph with a single pict run
+    // Watermark goes in a paragraph with a single pict run. Skip pPr
+    // entirely — emitting an empty <w:pStyle/> without @w:val is a hard
+    // schema violation Word rejects, and the default style is good enough
+    // for an auto-generated watermark header.
     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") {

package/dist/esm/modules/word/{writers → writer}/image-writer.js

@@ -5,10 +5,14 @@
  * with full support for rotation, flip, lock anchor, outline, and wrap margins.
  */
 import { NS_A, NS_PIC, URI_PIC, NS_ASVG, GUID_SVG } from "../constants.js";
+import { DEFAULT_RELATIVE_HEIGHT, DEFAULT_WRAP_MARGIN_EMU } from "../units.js";
 /** Render a floating image as a standalone paragraph with wp:anchor. */
-export function renderFloatingImage(xml, img) {
+export function renderFloatingImage(xml, img, imageRemap) {
     const drawingId = img.drawingId ?? 1;
     const name = img.name ?? "Picture";
+    // Resolve relationship id used in r:embed via packager-provided remap.
+    const embedRId = imageRemap?.get(img.rId) ?? img.rId;
+    const svgEmbedRId = img.svgRId ? (imageRemap?.get(img.svgRId) ?? img.svgRId) : undefined;
     xml.openNode("w:p");
     xml.openNode("w:r");
     xml.openNode("w:drawing");
@@ -17,10 +21,10 @@ export function renderFloatingImage(xml, img) {
     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),
+        distL: String(img.distL ?? wrapMargins?.left ?? DEFAULT_WRAP_MARGIN_EMU),
+        distR: String(img.distR ?? wrapMargins?.right ?? DEFAULT_WRAP_MARGIN_EMU),
         simplePos: img.simplePos ? "1" : "0",
-        relativeHeight: String(img.relativeHeight ?? 251658240),
+        relativeHeight: String(img.relativeHeight ?? DEFAULT_RELATIVE_HEIGHT),
         behindDoc: img.behindDoc ? "1" : "0",
         locked: img.lockAnchor ? "1" : "0",
         layoutInCell: img.layoutInCell === false ? "0" : "1",
@@ -105,19 +109,19 @@ export function renderFloatingImage(xml, img) {
     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:blip", { "r:embed": embedRId });
         xml.openNode("a:extLst");
         xml.openNode("a:ext", { uri: GUID_SVG });
         xml.leafNode("asvg:svgBlip", {
             "xmlns:asvg": NS_ASVG,
-            "r:embed": img.svgRId
+            "r:embed": svgEmbedRId
         });
         xml.closeNode(); // a:ext
         xml.closeNode(); // a:extLst
         xml.closeNode(); // a:blip
     }
     else {
-        xml.leafNode("a:blip", { "r:embed": img.rId });
+        xml.leafNode("a:blip", { "r:embed": embedRId });
     }
     // Source rectangle (crop)
     if (img.srcRect) {

package/dist/{browser/modules/word/writers → esm/modules/word/writer}/math-writer.js

@@ -418,11 +418,31 @@ function renderMathEquationArray(xml, eqArr) {
     }
     xml.closeNode();
 }
-/** Render a math block (m:oMathPara > m:oMath). Body-level math. */
+/**
+ * Render a math block (`m:oMathPara` containing one `m:oMath`).
+ *
+ * The OOXML schema only allows `m:oMathPara` inside a paragraph
+ * (`EG_PContent` includes `m:oMathPara`); it must not appear directly as
+ * a `EG_BlockLevelElts`. We therefore wrap it in `<w:p>` so the result is
+ * valid at the body level.
+ *
+ * Empty math blocks (`content.length === 0`) skip rendering altogether —
+ * an empty `<m:oMath/>` violates the schema (it requires at least one
+ * `OMathArg` child).
+ */
 export function renderMathBlock(xml, math) {
+    if (math.content.length === 0) {
+        // Emit an empty paragraph so the surrounding body still contains a
+        // valid block, but skip the math markup entirely.
+        xml.openNode("w:p");
+        xml.closeNode();
+        return;
+    }
+    xml.openNode("w:p");
     xml.openNode("m:oMathPara", { "xmlns:m": NS_M });
     xml.openNode("m:oMath");
     renderMathContents(xml, math.content);
     xml.closeNode();
     xml.closeNode();
+    xml.closeNode();
 }

package/dist/{browser/modules/word/writers → esm/modules/word/writer}/numbering-writer.js

@@ -5,6 +5,8 @@
  * Supports suffix, legal numbering style, restart levels, and level overrides.
  */
 import { NS_W, NS_R, STD_DOC_ATTRIBUTES } from "../constants.js";
+import { DocxRawXmlPolicyError } from "../errors.js";
+import { EMU_PER_POINT } from "../units.js";
 import { renderParagraphProperties } from "./paragraph-writer.js";
 import { renderRunProperties } from "./run-writer.js";
 /** Render a single numbering level. */
@@ -44,7 +46,7 @@ function renderLevel(xml, level) {
     xml.closeNode();
 }
 /** Render word/numbering.xml. */
-export function renderNumbering(xml, abstractNums, instances, numPicBullets) {
+export function renderNumbering(xml, abstractNums, instances, numPicBullets, rawXmlPolicy) {
     xml.openXml(STD_DOC_ATTRIBUTES);
     xml.openNode("w:numbering", {
         "xmlns:w": NS_W,
@@ -57,8 +59,13 @@ export function renderNumbering(xml, abstractNums, instances, 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);
+                if (rawXmlPolicy === "reject") {
+                    throw new DocxRawXmlPolicyError("numPicBullet.rawVmlXml");
+                }
+                if (rawXmlPolicy !== "strip") {
+                    // Use raw VML for full fidelity
+                    xml.writeRaw(pb.rawVmlXml);
+                }
             }
             else if (pb.rId) {
                 // Default VML shape with image fill
@@ -75,7 +82,7 @@ export function renderNumbering(xml, abstractNums, instances, numPicBullets) {
                 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`
+                    style: `width:${pb.width ? Math.round(pb.width / EMU_PER_POINT) : 12}pt;height:${pb.height ? Math.round(pb.height / EMU_PER_POINT) : 12}pt`
                 });
                 xml.leafNode("v:imagedata", { "r:id": pb.rId, "o:title": "" });
                 xml.closeNode();

package/dist/esm/modules/word/{writers → writer}/paragraph-writer.js

@@ -3,7 +3,9 @@
  *
  * Renders w:pPr and w:p elements including numbering, tabs, borders, etc.
  */
-import { renderRunProperties, renderShading, renderRun, renderBorderElement } from "./run-writer.js";
+import { isRun } from "../core/text-utils.js";
+import { DocxRawXmlPolicyError } from "../errors.js";
+import { renderBorderElement, renderRun, renderRunProperties, renderRunPropertiesContents, renderShading } from "./run-writer.js";
 import { renderSectionProperties } from "./section-writer.js";
 /** Render a single border element. */
 export function renderBorder(xml, tagName, border) {
@@ -238,9 +240,28 @@ export function renderParagraphProperties(xml, pPr, insidePropertyChange = false
     if (pPr.cnfStyle) {
         xml.leafNode("w:cnfStyle", { "w:val": pPr.cnfStyle });
     }
-    // Paragraph mark insertion/deletion (track changes)
-    // These go inside a w:rPr wrapper within w:pPr
-    if (pPr.paragraphInsertion || pPr.paragraphDeletion) {
+    // Paragraph property change revision — NOT recursed into when rendering previousProperties
+    if (!insidePropertyChange && pPr.propertyChange) {
+        xml.openNode("w:pPrChange", {
+            "w:id": String(pPr.propertyChange.revision.id),
+            "w:author": pPr.propertyChange.revision.author,
+            ...(pPr.propertyChange.revision.date ? { "w:date": pPr.propertyChange.revision.date } : {})
+        });
+        if (pPr.propertyChange.previousProperties) {
+            renderParagraphProperties(xml, pPr.propertyChange.previousProperties, true);
+        }
+        xml.closeNode();
+    }
+    // Paragraph mark properties (w:rPr inside w:pPr).
+    //
+    // ECMA-376 17.3.1.27 (CT_PPrBase) only allows ONE `w:rPr` child here. We
+    // therefore merge `paragraphInsertion` / `paragraphDeletion` (track-changes
+    // markers for the paragraph mark) into the same `w:rPr` as
+    // `markRunProperties`. Inside this single w:rPr, the schema requires
+    // w:ins/w:del/w:moveFrom/w:moveTo to come BEFORE the run-property children
+    // (per CT_ParaRPr).
+    const hasInsDel = !!(pPr.paragraphInsertion || pPr.paragraphDeletion);
+    if (hasInsDel || pPr.markRunProperties) {
         xml.openNode("w:rPr");
         if (pPr.paragraphInsertion) {
             const insAttrs = {
@@ -262,34 +283,40 @@ export function renderParagraphProperties(xml, pPr, insidePropertyChange = false
             }
             xml.leafNode("w:del", delAttrs);
         }
-        xml.closeNode(); // w:rPr
-    }
-    // Paragraph property change revision — NOT recursed into when rendering previousProperties
-    if (!insidePropertyChange && pPr.propertyChange) {
-        xml.openNode("w:pPrChange", {
-            "w:id": String(pPr.propertyChange.revision.id),
-            "w:author": pPr.propertyChange.revision.author,
-            ...(pPr.propertyChange.revision.date ? { "w:date": pPr.propertyChange.revision.date } : {})
-        });
-        if (pPr.propertyChange.previousProperties) {
-            renderParagraphProperties(xml, pPr.propertyChange.previousProperties, true);
+        if (pPr.markRunProperties) {
+            renderRunPropertiesContents(xml, pPr.markRunProperties);
         }
-        xml.closeNode();
-    }
-    if (pPr.markRunProperties) {
-        renderRunProperties(xml, pPr.markRunProperties);
+        xml.closeNode(); // w:rPr
     }
     xml.closeNode();
 }
 /** Render a hyperlink. */
-function renderHyperlink(xml, link) {
+function renderHyperlink(xml, link, helpers) {
     const attrs = {};
-    if (link.rId) {
-        attrs["r:id"] = link.rId;
+    // Resolve the relationship id: prefer the packager-provided WeakMap (so we
+    // never need the model to carry the rId), fall back to whatever the model
+    // already had (e.g. round-tripped DOCX where the reader populated rId).
+    // Resolve r:id. Prefer the packager-assigned rId from the helpers map
+    // (it's the only one guaranteed to exist in the rebuilt .rels file).
+    // Fall back to the model's `rId` only when no packager-assigned id is
+    // present — this happens for purely model-internal references such as
+    // anchor-only hyperlinks.
+    const resolvedRId = helpers?.hyperlinkRIds?.get(link) ?? (link.url ? undefined : link.rId);
+    if (resolvedRId) {
+        attrs["r:id"] = resolvedRId;
     }
     if (link.anchor) {
         attrs["w:anchor"] = link.anchor;
     }
+    // CT_Hyperlink (ECMA-376 §17.16.22) requires r:id OR w:anchor — when
+    // neither is present, emit the children as bare runs to avoid a schema
+    // violation that some validators flag.
+    if (!resolvedRId && !link.anchor) {
+        for (const run of link.children) {
+            renderRun(xml, run, helpers);
+        }
+        return;
+    }
     if (link.tooltip) {
         attrs["w:tooltip"] = link.tooltip;
     }
@@ -304,7 +331,7 @@ function renderHyperlink(xml, link) {
     }
     xml.openNode("w:hyperlink", attrs);
     for (const run of link.children) {
-        renderRun(xml, run);
+        renderRun(xml, run, helpers);
     }
     xml.closeNode();
 }
@@ -344,7 +371,7 @@ function renderCommentReference(xml, cr) {
     xml.closeNode();
 }
 /** Render an inserted run (track changes). */
-function renderInsertedRun(xml, ins) {
+function renderInsertedRun(xml, ins, helpers) {
     const attrs = {
         "w:id": String(ins.revision.id),
         "w:author": ins.revision.author
@@ -353,7 +380,7 @@ function renderInsertedRun(xml, ins) {
         attrs["w:date"] = ins.revision.date;
     }
     xml.openNode("w:ins", attrs);
-    renderRun(xml, ins.run);
+    renderRun(xml, ins.run, helpers);
     xml.closeNode();
 }
 /** Render a deleted run (track changes). */
@@ -401,7 +428,7 @@ function renderDeletedRun(xml, del) {
     xml.closeNode();
 }
 /** Render a moved-from or moved-to run (track changes). */
-function renderMovedRun(xml, moved, wrapperTag) {
+function renderMovedRun(xml, moved, wrapperTag, helpers) {
     const attrs = {
         "w:id": String(moved.revision.id),
         "w:author": moved.revision.author
@@ -410,15 +437,15 @@ function renderMovedRun(xml, moved, wrapperTag) {
         attrs["w:date"] = moved.revision.date;
     }
     xml.openNode(wrapperTag, attrs);
-    renderRun(xml, moved.run);
+    renderRun(xml, moved.run, helpers);
     xml.closeNode();
 }
 /** Render a paragraph child element. */
-function renderParagraphChild(xml, child) {
+function renderParagraphChild(xml, child, helpers) {
     if ("type" in child) {
         switch (child.type) {
             case "hyperlink":
-                renderHyperlink(xml, child);
+                renderHyperlink(xml, child, helpers);
                 return;
             case "bookmarkStart":
                 renderBookmarkStart(xml, child);
@@ -436,16 +463,16 @@ function renderParagraphChild(xml, child) {
                 renderCommentReference(xml, child);
                 return;
             case "insertedRun":
-                renderInsertedRun(xml, child);
+                renderInsertedRun(xml, child, helpers);
                 return;
             case "deletedRun":
                 renderDeletedRun(xml, child);
                 return;
             case "movedFromRun":
-                renderMovedRun(xml, child, "w:moveFrom");
+                renderMovedRun(xml, child, "w:moveFrom", helpers);
                 return;
             case "movedToRun":
-                renderMovedRun(xml, child, "w:moveTo");
+                renderMovedRun(xml, child, "w:moveTo", helpers);
                 return;
             case "moveFromRangeStart":
             case "moveFromRangeEnd":
@@ -486,18 +513,26 @@ function renderParagraphChild(xml, child) {
                 xml.leafNode(`w:${child.type}`, cmAttrs);
                 return;
             }
+            case "opaqueParagraphChild": {
+                const policy = helpers?.rawXmlPolicy;
+                if (policy === "reject") {
+                    throw new DocxRawXmlPolicyError("opaqueParagraphChild");
+                }
+                if (policy !== "strip") {
+                    xml.writeRaw(child.rawXml);
+                }
+                return;
+            }
             default:
                 break;
         }
     }
-    // Run objects don't have a .type property at the union level, but we handle
-    // them via duck typing: they have .content
-    if ("content" in child && !("type" in child)) {
-        renderRun(xml, child);
+    if (isRun(child)) {
+        renderRun(xml, child, helpers);
     }
 }
 /** Render a w:p element. */
-export function renderParagraph(xml, para) {
+export function renderParagraph(xml, para, helpers) {
     const pAttrs = {};
     if (para.paraId) {
         pAttrs["w14:paraId"] = para.paraId;
@@ -510,7 +545,7 @@ export function renderParagraph(xml, para) {
         renderParagraphProperties(xml, para.properties);
     }
     for (const child of para.children) {
-        renderParagraphChild(xml, child);
+        renderParagraphChild(xml, child, helpers);
     }
     xml.closeNode();
 }