@cj-tech-master/excelts 9.5.4 → 9.5.5

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

@@ -4,10 +4,7 @@
  * Generates DrawingML chart part XML (word/charts/chartN.xml) from
  * high-level Chart definitions.
  */
-import { STD_DOC_ATTRIBUTES } from "../constants.js";
-const NS_C = "http://schemas.openxmlformats.org/drawingml/2006/chart";
-const NS_A_LOCAL = "http://schemas.openxmlformats.org/drawingml/2006/main";
-const NS_R_LOCAL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+import { NS_A, NS_C_CHART, NS_R, STD_DOC_ATTRIBUTES } from "../constants.js";
 const CHART_TYPE_CATEGORY = {
     bar: { tag: "barChart", direction: "bar", grouping: "clustered" },
     barStacked: { tag: "barChart", direction: "bar", grouping: "stacked" },
@@ -25,15 +22,22 @@ const CHART_TYPE_CATEGORY = {
     doughnut: { tag: "doughnutChart" },
     scatter: { tag: "scatterChart", scatterStyle: "marker" },
     scatterSmooth: { tag: "scatterChart", scatterStyle: "smoothMarker" },
-    radar: { tag: "radarChart" }
+    radar: { tag: "radarChart" },
+    radarFilled: { tag: "radarChart", radarStyle: "filled" },
+    bubble: { tag: "bubbleChart" },
+    stock: { tag: "stockChart" },
+    surface: { tag: "surfaceChart" },
+    surface3D: { tag: "surface3DChart" },
+    surfaceWireframe: { tag: "surfaceChart", wireframe: true },
+    surfaceWireframe3D: { tag: "surface3DChart", wireframe: true }
 };
 /** Render a chart part (word/charts/chartN.xml). */
 export function renderChartPart(xml, chart) {
     xml.openXml(STD_DOC_ATTRIBUTES);
     xml.openNode("c:chartSpace", {
-        "xmlns:c": NS_C,
-        "xmlns:a": NS_A_LOCAL,
-        "xmlns:r": NS_R_LOCAL
+        "xmlns:c": NS_C_CHART,
+        "xmlns:a": NS_A,
+        "xmlns:r": NS_R
     });
     // Date1904 (calendar base)
     xml.leafNode("c:date1904", { val: "0" });
@@ -82,14 +86,21 @@ export function renderChartPart(xml, chart) {
     // Chart type-specific rendering
     const catAxId = "111111111";
     const valAxId = "222222222";
-    renderChartTypeElement(xml, chart, catAxId, valAxId);
+    const catAxId2 = "333333333";
+    const valAxId2 = "444444444";
+    const hasSecondary = renderChartTypeElement(xml, chart, catAxId, valAxId, catAxId2, valAxId2);
     // Axes (unless pie/doughnut which use no axes)
     const noAxes = chart.type === "pie" || chart.type === "pie3D" || chart.type === "doughnut";
     if (!noAxes) {
-        // Category axis
+        // Primary category axis
         renderAxis(xml, "catAx", catAxId, valAxId, chart.categoryAxis, "b");
-        // Value axis
+        // Primary value axis
         renderAxis(xml, "valAx", valAxId, catAxId, chart.valueAxis, "l");
+        // Secondary axes (for combo charts)
+        if (hasSecondary) {
+            renderAxis(xml, "catAx", catAxId2, valAxId2, undefined, "b", true);
+            renderAxis(xml, "valAx", valAxId2, catAxId2, chart.secondaryValueAxis, "r");
+        }
     }
     // Plot area background
     if (chart.plotAreaColor) {
@@ -158,8 +169,55 @@ function renderTitle(xml, title) {
     xml.leafNode("c:overlay", { val: "0" });
     xml.closeNode(); // c:title
 }
-function renderChartTypeElement(xml, chart, catAxId, valAxId) {
-    const info = CHART_TYPE_CATEGORY[chart.type] ?? { tag: "barChart" };
+function renderChartTypeElement(xml, chart, catAxId, valAxId, catAxId2, valAxId2) {
+    // Determine if this is a combo chart
+    const hasSeriesOverrides = chart.series.some(s => s.chartType !== undefined);
+    const hasSecondarySeries = chart.secondarySeries !== undefined && chart.secondarySeries.length > 0;
+    const hasSecondaryAxis = hasSecondarySeries || chart.series.some(s => s.plotOnSecondaryAxis);
+    if (!hasSeriesOverrides && !hasSecondarySeries) {
+        // Simple (non-combo) chart — original logic
+        renderSingleChartTypeBlock(xml, chart.type, chart.series, chart, catAxId, valAxId, 0);
+        return false;
+    }
+    const groups = [];
+    let globalIndex = 0;
+    const findOrCreateGroup = (type, secondary) => {
+        let group = groups.find(g => g.chartType === type && g.secondary === secondary);
+        if (!group) {
+            group = { chartType: type, secondary, series: [] };
+            groups.push(group);
+        }
+        return group;
+    };
+    // Primary series
+    for (const s of chart.series) {
+        const effectiveType = s.chartType ?? chart.type;
+        const secondary = s.plotOnSecondaryAxis ?? false;
+        const group = findOrCreateGroup(effectiveType, secondary);
+        group.series.push({ series: s, globalIndex });
+        globalIndex++;
+    }
+    // Secondary series (legacy approach)
+    if (hasSecondarySeries) {
+        const secondaryType = chart.secondaryType ?? "line";
+        for (const s of chart.secondarySeries) {
+            const group = findOrCreateGroup(secondaryType, true);
+            group.series.push({ series: s, globalIndex });
+            globalIndex++;
+        }
+    }
+    // Render each group as a separate chart type element
+    for (const group of groups) {
+        const useCatAx = group.secondary ? catAxId2 : catAxId;
+        const useValAx = group.secondary ? valAxId2 : valAxId;
+        const seriesItems = group.series.map(item => item.series);
+        const startIndex = group.series[0].globalIndex;
+        renderSingleChartTypeBlock(xml, group.chartType, seriesItems, chart, useCatAx, useValAx, startIndex);
+    }
+    return hasSecondaryAxis;
+}
+function renderSingleChartTypeBlock(xml, chartType, series, chart, catAxId, valAxId, startIndex) {
+    const info = CHART_TYPE_CATEGORY[chartType] ?? { tag: "barChart" };
     const tagName = `c:${info.tag}`;
     xml.openNode(tagName);
     // Direction (bar vs col)
@@ -174,25 +232,40 @@ function renderChartTypeElement(xml, chart, catAxId, valAxId) {
     if ("scatterStyle" in info && info.scatterStyle) {
         xml.leafNode("c:scatterStyle", { val: info.scatterStyle });
     }
+    // Radar style
+    if ("radarStyle" in info && info.radarStyle) {
+        xml.leafNode("c:radarStyle", { val: info.radarStyle });
+    }
+    else if (info.tag === "radarChart") {
+        xml.leafNode("c:radarStyle", { val: "marker" });
+    }
+    // Wireframe (surface charts)
+    if ("wireframe" in info && info.wireframe) {
+        xml.leafNode("c:wireframe", { val: "1" });
+    }
     xml.leafNode("c:varyColors", {
-        val: chart.type === "pie" || chart.type === "pie3D" || chart.type === "doughnut" ? "1" : "0"
+        val: chartType === "pie" || chartType === "pie3D" || chartType === "doughnut" ? "1" : "0"
     });
     // Series
-    chart.series.forEach((series, idx) => {
-        renderSeries(xml, series, idx, chart.type, "marked" in info && info.marked);
+    series.forEach((s, idx) => {
+        renderSeries(xml, s, startIndex + idx, chartType, "marked" in info && info.marked);
     });
+    // Chart-level data labels
+    if (chart.dataLabels) {
+        renderChartDataLabels(xml, chart.dataLabels);
+    }
     // Gap width / overlap (bar/column)
     if (info.tag === "barChart") {
         xml.leafNode("c:gapWidth", { val: "150" });
-        if (chart.type === "barStacked" ||
-            chart.type === "barPercentStacked" ||
-            chart.type === "columnStacked" ||
-            chart.type === "columnPercentStacked") {
+        if (chartType === "barStacked" ||
+            chartType === "barPercentStacked" ||
+            chartType === "columnStacked" ||
+            chartType === "columnPercentStacked") {
             xml.leafNode("c:overlap", { val: "100" });
         }
     }
     // Axes IDs
-    const noAxes = chart.type === "pie" || chart.type === "pie3D" || chart.type === "doughnut";
+    const noAxes = chartType === "pie" || chartType === "pie3D" || chartType === "doughnut";
     if (!noAxes) {
         xml.leafNode("c:axId", { val: catAxId });
         xml.leafNode("c:axId", { val: valAxId });
@@ -336,9 +409,17 @@ function renderSeries(xml, series, index, chartType, markedLine) {
     xml.closeNode();
     xml.closeNode();
     xml.closeNode();
+    // Trendline
+    if (series.trendline) {
+        renderTrendline(xml, series.trendline);
+    }
+    // Error bars
+    if (series.errorBars) {
+        renderErrorBars(xml, series.errorBars);
+    }
     xml.closeNode(); // c:ser
 }
-function renderAxis(xml, tagName, axId, crossAxId, axis, defaultPos) {
+function renderAxis(xml, tagName, axId, crossAxId, axis, defaultPos, forceHidden) {
     xml.openNode(`c:${tagName}`);
     xml.leafNode("c:axId", { val: axId });
     // Scaling
@@ -351,7 +432,7 @@ function renderAxis(xml, tagName, axId, crossAxId, axis, defaultPos) {
         xml.leafNode("c:max", { val: String(axis.max) });
     }
     xml.closeNode();
-    xml.leafNode("c:delete", { val: axis?.hidden ? "1" : "0" });
+    xml.leafNode("c:delete", { val: forceHidden || axis?.hidden ? "1" : "0" });
     xml.leafNode("c:axPos", { val: defaultPos });
     // Title
     if (axis?.title) {
@@ -383,3 +464,63 @@ function renderAxis(xml, tagName, axId, crossAxId, axis, defaultPos) {
     }
     xml.closeNode();
 }
+// -- Data labels position map ---------------------------------------------------
+const DATA_LABEL_POSITION_MAP = {
+    outsideEnd: "outEnd",
+    center: "ctr",
+    insideEnd: "inEnd",
+    bestFit: "bestFit"
+};
+function renderChartDataLabels(xml, dataLabels) {
+    xml.openNode("c:dLbls");
+    if (dataLabels.position) {
+        xml.leafNode("c:dLblPos", { val: DATA_LABEL_POSITION_MAP[dataLabels.position] ?? "bestFit" });
+    }
+    xml.leafNode("c:showLegendKey", { val: "0" });
+    xml.leafNode("c:showVal", { val: dataLabels.showValue ? "1" : "0" });
+    xml.leafNode("c:showCatName", { val: dataLabels.showCategory ? "1" : "0" });
+    xml.leafNode("c:showSerName", { val: dataLabels.showSerName ? "1" : "0" });
+    xml.leafNode("c:showPercent", { val: dataLabels.showPercent ? "1" : "0" });
+    xml.leafNode("c:showBubbleSize", { val: "0" });
+    xml.closeNode();
+}
+// -- Trendline ------------------------------------------------------------------
+function renderTrendline(xml, trendline) {
+    if (!trendline) {
+        return;
+    }
+    xml.openNode("c:trendline");
+    xml.leafNode("c:trendlineType", { val: trendline.type });
+    if (trendline.type === "polynomial" && trendline.order !== undefined) {
+        xml.leafNode("c:order", { val: String(trendline.order) });
+    }
+    if (trendline.type === "movingAvg" && trendline.period !== undefined) {
+        xml.leafNode("c:period", { val: String(trendline.period) });
+    }
+    if (trendline.displayEquation) {
+        xml.leafNode("c:dispEq", { val: "1" });
+    }
+    if (trendline.displayRSquared) {
+        xml.leafNode("c:dispRSqr", { val: "1" });
+    }
+    xml.closeNode();
+}
+// -- Error Bars -----------------------------------------------------------------
+function renderErrorBars(xml, errorBars) {
+    if (!errorBars) {
+        return;
+    }
+    const directions = errorBars.direction === "both" ? ["x", "y"] : [errorBars.direction];
+    for (const dir of directions) {
+        xml.openNode("c:errBars");
+        xml.leafNode("c:errBarType", { val: "both" });
+        xml.leafNode("c:errValType", { val: errorBars.type });
+        xml.leafNode("c:errDir", { val: dir });
+        if (errorBars.value !== undefined &&
+            (errorBars.type === "fixedVal" || errorBars.type === "percentage")) {
+            xml.leafNode("c:val", { val: String(errorBars.value) });
+        }
+        xml.leafNode("c:noEndCap", { val: "0" });
+        xml.closeNode();
+    }
+}

package/dist/browser/modules/word/writer/checkbox-writer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * DOCX Writers - CheckBox
+ *
+ * Renders checkbox as a structured document tag (SDT) with w14:checkbox.
+ *
+ * Per ECMA-376 Part 4 §17.5.2.41 the `w14:checkedState/@w14:val` attribute
+ * holds a 4-digit hexadecimal Unicode code point. We persist that hex form
+ * verbatim into the `w14:val` attribute, but the displayed glyph is rendered
+ * by converting to the actual character. To stay forgiving we accept both
+ * the canonical hex form (e.g. `"2612"`) and a literal glyph form (e.g.
+ * `"☒"`) on the input side, normalising both to a hex string for the
+ * attribute and the actual glyph for the displayed run.
+ */
+import type { XmlSink } from "../../xml/types.js";
+import type { CheckBox } from "../types.js";
+/** Render a checkbox as a paragraph with SDT. */
+export declare function renderCheckBox(xml: XmlSink, cb: CheckBox): void;

package/dist/browser/modules/word/writer/checkbox-writer.js

@@ -0,0 +1,79 @@
+/**
+ * DOCX Writers - CheckBox
+ *
+ * Renders checkbox as a structured document tag (SDT) with w14:checkbox.
+ *
+ * Per ECMA-376 Part 4 §17.5.2.41 the `w14:checkedState/@w14:val` attribute
+ * holds a 4-digit hexadecimal Unicode code point. We persist that hex form
+ * verbatim into the `w14:val` attribute, but the displayed glyph is rendered
+ * by converting to the actual character. To stay forgiving we accept both
+ * the canonical hex form (e.g. `"2612"`) and a literal glyph form (e.g.
+ * `"☒"`) on the input side, normalising both to a hex string for the
+ * attribute and the actual glyph for the displayed run.
+ */
+import { NS_W14 } from "../constants.js";
+/**
+ * Normalise a checked-state value to {hex, glyph}.
+ *
+ *   - If the input parses as a hexadecimal code point (1-6 hex digits with
+ *     no other characters) we treat it as the canonical hex form.
+ *   - Otherwise we treat it as a literal glyph and derive its hex from the
+ *     first code point of the string.
+ *
+ * Empty / nullish input falls back to the supplied default.
+ */
+function normaliseCheckState(input, fallback) {
+    const value = input && input.length > 0 ? input : fallback;
+    // Canonical hex form: 1-6 hex digits and nothing else.
+    if (/^[0-9a-fA-F]{1,6}$/.test(value)) {
+        const cp = parseInt(value, 16);
+        if (Number.isFinite(cp) && cp >= 0 && cp <= 0x10ffff) {
+            return { hex: value.toUpperCase().padStart(4, "0"), glyph: String.fromCodePoint(cp) };
+        }
+    }
+    // Literal glyph form: take the first Unicode code point.
+    const cp = value.codePointAt(0);
+    if (cp === undefined) {
+        // Should not happen because fallback is always non-empty, but stay safe.
+        return { hex: "2610", glyph: "\u2610" };
+    }
+    return {
+        hex: cp.toString(16).toUpperCase().padStart(4, "0"),
+        glyph: String.fromCodePoint(cp)
+    };
+}
+/** Render a checkbox as a paragraph with SDT. */
+export function renderCheckBox(xml, cb) {
+    const checked = cb.checked ?? false;
+    const checkedNorm = normaliseCheckState(cb.checkedState?.value, "2612"); // ☒
+    const uncheckedNorm = normaliseCheckState(cb.uncheckedState?.value, "2610"); // ☐
+    const checkedFont = cb.checkedState?.font ?? "MS Gothic";
+    const uncheckedFont = cb.uncheckedState?.font ?? "MS Gothic";
+    const display = checked ? checkedNorm : uncheckedNorm;
+    const displayFont = checked ? checkedFont : uncheckedFont;
+    xml.openNode("w:sdt");
+    // SDT properties
+    xml.openNode("w:sdtPr");
+    xml.openNode("w14:checkbox", { "xmlns:w14": NS_W14 });
+    xml.leafNode("w14:checked", { "w14:val": checked ? "1" : "0" });
+    xml.leafNode("w14:checkedState", { "w14:val": checkedNorm.hex, "w14:font": checkedFont });
+    xml.leafNode("w14:uncheckedState", { "w14:val": uncheckedNorm.hex, "w14:font": uncheckedFont });
+    xml.closeNode();
+    xml.closeNode();
+    // SDT content - display the checkbox character
+    xml.openNode("w:sdtContent");
+    xml.openNode("w:r");
+    xml.openNode("w:rPr");
+    xml.leafNode("w:rFonts", {
+        "w:ascii": displayFont,
+        "w:hAnsi": displayFont,
+        "w:eastAsia": displayFont
+    });
+    xml.closeNode();
+    xml.openNode("w:t");
+    xml.writeText(display.glyph);
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // w:sdt
+}

package/dist/{types/modules/word/writers → browser/modules/word/writer}/comment-writer.d.ts

@@ -5,8 +5,9 @@
  */
 import type { XmlSink } from "../../xml/types.js";
 import type { CommentDef } from "../types.js";
+import type { RenderHelpers } from "./render-context.js";
 /** Render word/comments.xml. */
-export declare function renderComments(xml: XmlSink, comments: readonly CommentDef[]): void;
+export declare function renderComments(xml: XmlSink, comments: readonly CommentDef[], helpers?: RenderHelpers): void;
 /**
  * Render word/commentsExtended.xml — extended comment metadata (done/parentId).
  * Only includes comments that have either `done` or `parentId` set.

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

@@ -3,11 +3,10 @@
  *
  * Renders word/comments.xml and word/commentsExtended.xml parts.
  */
-import { NS_W, NS_R, STD_DOC_ATTRIBUTES } from "../constants.js";
+import { NS_W, NS_W15, NS_R, STD_DOC_ATTRIBUTES } from "../constants.js";
 import { renderParagraph } from "./paragraph-writer.js";
-const NS_W15 = "http://schemas.microsoft.com/office/word/2012/wordml";
 /** Render word/comments.xml. */
-export function renderComments(xml, comments) {
+export function renderComments(xml, comments, helpers) {
     xml.openXml(STD_DOC_ATTRIBUTES);
     xml.openNode("w:comments", {
         "xmlns:w": NS_W,
@@ -26,7 +25,7 @@ export function renderComments(xml, comments) {
         }
         xml.openNode("w:comment", attrs);
         for (const para of comment.content) {
-            renderParagraph(xml, para);
+            renderParagraph(xml, para, helpers);
         }
         xml.closeNode();
     }
@@ -57,8 +56,11 @@ export function renderCommentsExtended(xml, comments) {
             continue;
         }
         const attrs = { "w15:paraId": firstPara.paraId };
-        if (c.done) {
-            attrs["w15:done"] = "1";
+        // Round-trip explicit done state. `done === false` is meaningful — it
+        // tells consumers "this comment is explicitly *not* resolved", which
+        // can differ semantically from omitting the attribute entirely.
+        if (c.done !== undefined) {
+            attrs["w15:done"] = c.done ? "1" : "0";
         }
         if (c.parentId) {
             attrs["w15:paraIdParent"] = c.parentId;

package/dist/browser/modules/word/writer/common-parts.d.ts

@@ -0,0 +1,57 @@
+/**
+ * DOCX Module - Common Auxiliary Parts Builder
+ *
+ * Shared logic for generating auxiliary XML parts (styles, settings, numbering,
+ * fontTable, theme, core properties, app properties, custom properties).
+ *
+ * Both the buffered packager and streaming writer use this to avoid duplicating
+ * the same rendering logic.
+ */
+import type { AbstractNumbering, AppProperties, CoreProperties, CustomProperty, DocDefaults, DocumentSettings, DocumentTheme, EndnoteDef, FontDef, FootnoteDef, NumPicBullet, NumberingInstance, StyleDef } from "../types.js";
+import type { RenderHelpers } from "./render-context.js";
+/** Input options for building common auxiliary parts. */
+export interface AuxiliaryPartsInput {
+    readonly docDefaults?: DocDefaults;
+    readonly styles?: readonly StyleDef[];
+    readonly settings?: DocumentSettings;
+    readonly fonts?: readonly FontDef[];
+    readonly theme?: DocumentTheme;
+    readonly abstractNumberings?: readonly AbstractNumbering[];
+    readonly numberingInstances?: readonly NumberingInstance[];
+    readonly numPicBullets?: readonly NumPicBullet[];
+    readonly coreProperties?: CoreProperties;
+    readonly appProperties?: AppProperties;
+    readonly customProperties?: readonly CustomProperty[];
+    readonly footnotes?: readonly FootnoteDef[];
+    readonly endnotes?: readonly EndnoteDef[];
+    /**
+     * Optional render helpers passed to footnote/endnote rendering so in-note
+     * hyperlinks/images resolve to the rIds the caller has registered against
+     * the per-part .rels. Defaults to `{}`, meaning no remap and no
+     * hyperlink rIds — sufficient for documents without notes that contain
+     * external links or remapped images.
+     */
+    readonly notesHelpers?: RenderHelpers;
+    /**
+     * Raw XML output policy. When `"strip"` or `"reject"`, opaque rawXml
+     * fields on settings/theme/numbering are skipped or cause an error
+     * respectively. Defaults to `"preserve"`.
+     */
+    readonly rawXmlPolicy?: "preserve" | "strip" | "reject";
+}
+/** A rendered XML part ready to be written to ZIP. */
+export interface RenderedPart {
+    readonly path: string;
+    readonly content: string;
+}
+/**
+ * Build all common auxiliary XML parts that are shared between
+ * the buffered packager and streaming writer.
+ *
+ * Returns an array of rendered parts (path + XML string).
+ * Does NOT include: document.xml, images, headers/footers, comments,
+ * charts, custom XML, embedded fonts, opaque parts, watermarks.
+ * Those are handled by the respective packager/streaming-writer because
+ * they require relationship ID coordination.
+ */
+export declare function buildCommonAuxiliaryParts(input: AuxiliaryPartsInput): RenderedPart[];

package/dist/browser/modules/word/writer/common-parts.js

@@ -0,0 +1,101 @@
+/**
+ * DOCX Module - Common Auxiliary Parts Builder
+ *
+ * Shared logic for generating auxiliary XML parts (styles, settings, numbering,
+ * fontTable, theme, core properties, app properties, custom properties).
+ *
+ * Both the buffered packager and streaming writer use this to avoid duplicating
+ * the same rendering logic.
+ */
+import { XmlWriter } from "../../xml/writer.js";
+import { PartPath } from "../constants.js";
+import { renderFootnotes, renderEndnotes } from "./footnote-writer.js";
+import { renderNumbering } from "./numbering-writer.js";
+import { renderSettings, renderFontTable, renderCoreProperties, renderAppProperties, renderCustomProperties, renderTheme } from "./parts-writer.js";
+import { renderStyles } from "./styles-writer.js";
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Build all common auxiliary XML parts that are shared between
+ * the buffered packager and streaming writer.
+ *
+ * Returns an array of rendered parts (path + XML string).
+ * Does NOT include: document.xml, images, headers/footers, comments,
+ * charts, custom XML, embedded fonts, opaque parts, watermarks.
+ * Those are handled by the respective packager/streaming-writer because
+ * they require relationship ID coordination.
+ */
+export function buildCommonAuxiliaryParts(input) {
+    const parts = [];
+    // styles.xml (always written)
+    parts.push({
+        path: PartPath.Styles,
+        content: renderXml(xml => renderStyles(xml, input.docDefaults, input.styles))
+    });
+    // settings.xml
+    parts.push({
+        path: PartPath.Settings,
+        content: renderXml(xml => renderSettings(xml, input.settings, input.rawXmlPolicy))
+    });
+    // fontTable.xml
+    parts.push({
+        path: PartPath.FontTable,
+        content: renderXml(xml => renderFontTable(xml, input.fonts))
+    });
+    // theme/theme1.xml
+    parts.push({
+        path: PartPath.Theme,
+        content: renderXml(xml => renderTheme(xml, input.theme, input.rawXmlPolicy))
+    });
+    // numbering.xml (conditional)
+    const hasNumbering = (input.abstractNumberings && input.abstractNumberings.length > 0) ||
+        (input.numberingInstances && input.numberingInstances.length > 0);
+    if (hasNumbering) {
+        parts.push({
+            path: PartPath.Numbering,
+            content: renderXml(xml => renderNumbering(xml, input.abstractNumberings, input.numberingInstances, input.numPicBullets, input.rawXmlPolicy))
+        });
+    }
+    // footnotes.xml (conditional)
+    if (input.footnotes && input.footnotes.length > 0) {
+        parts.push({
+            path: PartPath.Footnotes,
+            content: renderXml(xml => renderFootnotes(xml, input.footnotes, input.notesHelpers))
+        });
+    }
+    // endnotes.xml (conditional)
+    if (input.endnotes && input.endnotes.length > 0) {
+        parts.push({
+            path: PartPath.Endnotes,
+            content: renderXml(xml => renderEndnotes(xml, input.endnotes, input.notesHelpers))
+        });
+    }
+    // docProps/core.xml
+    parts.push({
+        path: PartPath.CoreProps,
+        content: renderXml(xml => renderCoreProperties(xml, input.coreProperties))
+    });
+    // docProps/app.xml
+    parts.push({
+        path: PartPath.AppProps,
+        content: renderXml(xml => renderAppProperties(xml, input.appProperties))
+    });
+    // docProps/custom.xml (conditional)
+    if (input.customProperties && input.customProperties.length > 0) {
+        parts.push({
+            path: PartPath.CustomProps,
+            content: renderXml(xml => renderCustomProperties(xml, input.customProperties))
+        });
+    }
+    return parts;
+}
+// =============================================================================
+// Internal
+// =============================================================================
+/** Render XML to string using XmlWriter. */
+function renderXml(renderFn) {
+    const writer = new XmlWriter();
+    renderFn(writer);
+    return writer.xml;
+}

package/dist/{types/modules/word → browser/modules/word/writer}/content-types.d.ts

@@ -4,7 +4,7 @@
  * Generates [Content_Types].xml for the DOCX package.
  * Uses a plain data record + free functions for tree-shakeability.
  */
-import type { XmlSink } from "../xml/types.js";
+import type { XmlSink } from "../../xml/types.js";
 /** Content type override entry. */
 export interface ContentTypeOverride {
     readonly partName: string;
@@ -19,7 +19,7 @@ export interface ContentTypesState {
 export declare function createContentTypes(): ContentTypesState;
 /** Add a default content type for a file extension. */
 export declare function addContentTypeDefault(state: ContentTypesState, extension: string, contentType: string): void;
-/** Add an override content type for a specific part. */
+/** Add an override content type for a specific part. Deduplicates by partName. */
 export declare function addContentTypeOverride(state: ContentTypesState, partName: string, contentType: string): void;
 /** Add image extension defaults from a set of used extensions. */
 export declare function addImageContentTypeDefaults(state: ContentTypesState, extensions: Iterable<string>): void;

package/dist/{esm/modules/word → browser/modules/word/writer}/content-types.js

@@ -4,7 +4,7 @@
  * Generates [Content_Types].xml for the DOCX package.
  * Uses a plain data record + free functions for tree-shakeability.
  */
-import { NS_CONTENT_TYPES, STD_DOC_ATTRIBUTES, ContentType, IMAGE_CONTENT_TYPES } from "./constants.js";
+import { NS_CONTENT_TYPES, STD_DOC_ATTRIBUTES, ContentType, IMAGE_CONTENT_TYPES } from "../constants.js";
 /** Create a new ContentTypesState with standard defaults (rels, xml). */
 export function createContentTypes() {
     const defaults = new Map();
@@ -16,12 +16,20 @@ export function createContentTypes() {
 export function addContentTypeDefault(state, extension, contentType) {
     state.defaults.set(extension, contentType);
 }
-/** Add an override content type for a specific part. */
+/** Add an override content type for a specific part. Deduplicates by partName. */
 export function addContentTypeOverride(state, partName, contentType) {
-    state.overrides.push({
-        partName: partName.startsWith("/") ? partName : `/${partName}`,
-        contentType
-    });
+    const normalized = partName.startsWith("/") ? partName : `/${partName}`;
+    const overrides = state.overrides;
+    // Deduplicate: if same partName already exists, update in-place
+    const existing = overrides.findIndex(o => o.partName === normalized);
+    if (existing !== -1) {
+        // Same content type → no-op; different → replace (last wins)
+        if (overrides[existing].contentType !== contentType) {
+            overrides[existing] = { partName: normalized, contentType };
+        }
+        return;
+    }
+    overrides.push({ partName: normalized, contentType });
 }
 /** Add image extension defaults from a set of used extensions. */
 export function addImageContentTypeDefaults(state, extensions) {

package/dist/browser/modules/word/writer/document-writer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+import type { XmlSink } from "../../xml/types.js";
+import type { DocxDocument, BodyContent, StructuredDocumentTag } from "../types.js";
+import { type RenderHelpers, type WordRenderContext } from "./render-context.js";
+/**
+ * Render a structured document tag.
+ *
+ * `ctx` may be `undefined` when called from a sub-renderer that only knows
+ * about `RenderHelpers` (e.g. table cell, header/footer). In that case we
+ * still emit a syntactically valid `<w:sdt>`, but we cannot auto-assign an
+ * id from the document-wide id generator — callers that care about
+ * uniqueness should provide `properties.id` explicitly.
+ */
+export declare function renderSdt(xml: XmlSink, sdt: StructuredDocumentTag, ctx: WordRenderContext | undefined, helpers?: RenderHelpers): void;
+/** Render a single body content element (paragraph, table, image, etc.). */
+export declare function renderBodyContent(xml: XmlSink, content: BodyContent, ctx?: WordRenderContext): void;
+/** Render the complete word/document.xml. */
+export declare function renderDocument(xml: XmlSink, doc: DocxDocument, ctx?: WordRenderContext): void;