@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/esm/modules/word/units.js

@@ -4,66 +4,95 @@
  * Conversion functions between common measurement units used in OOXML.
  */
 // =============================================================================
+// Base unit constants
+// =============================================================================
+/** Twips per inch (OOXML page measurements). */
+export const TWIPS_PER_INCH = 1440;
+/** Twips per point. */
+export const TWIPS_PER_POINT = 20;
+/** Twips per centimeter (approximate). */
+export const TWIPS_PER_CM = 567;
+/** Twips per millimeter (approximate). */
+export const TWIPS_PER_MM = 56.7;
+/** EMU (English Metric Units) per inch — DrawingML coordinate space. */
+export const EMU_PER_INCH = 914400;
+/** EMU per centimeter. */
+export const EMU_PER_CM = 360000;
+/** EMU per point. */
+export const EMU_PER_POINT = 12700;
+/** EMU per pixel at 96 DPI (CSS pixel). */
+export const EMU_PER_PX = 9525;
+/** Default chart width in EMU (6 inches). */
+export const DEFAULT_CHART_WIDTH_EMU = 6 * EMU_PER_INCH;
+/** Default chart height in EMU (3.5 inches for c:chart). */
+export const DEFAULT_CHART_HEIGHT_EMU = Math.round(3.5 * EMU_PER_INCH);
+/** Default ChartEx height in EMU (4 inches). */
+export const DEFAULT_CHART_EX_HEIGHT_EMU = 4 * EMU_PER_INCH;
+/** Default wrap margin for inline drawings in EMU (≈0.125 inch). */
+export const DEFAULT_WRAP_MARGIN_EMU = 114300;
+/** Default `wp:anchor` `relativeHeight` (z-order) when not specified. */
+export const DEFAULT_RELATIVE_HEIGHT = 251658240;
+// =============================================================================
 // Twips conversions (1 inch = 1440 twips, 1 pt = 20 twips, 1 cm = 567 twips)
 // =============================================================================
 /** Convert inches to twips. */
 export function inchesToTwips(inches) {
-    return Math.round(inches * 1440);
+    return Math.round(inches * TWIPS_PER_INCH);
 }
 /** Convert twips to inches. */
 export function twipsToInches(twips) {
-    return twips / 1440;
+    return twips / TWIPS_PER_INCH;
 }
 /** Convert centimeters to twips. */
 export function cmToTwips(cm) {
-    return Math.round(cm * 567);
+    return Math.round(cm * TWIPS_PER_CM);
 }
 /** Convert twips to centimeters. */
 export function twipsToCm(twips) {
-    return twips / 567;
+    return twips / TWIPS_PER_CM;
 }
 /** Convert points to twips. */
 export function ptToTwips(pt) {
-    return Math.round(pt * 20);
+    return Math.round(pt * TWIPS_PER_POINT);
 }
 /** Convert twips to points. */
 export function twipsToPt(twips) {
-    return twips / 20;
+    return twips / TWIPS_PER_POINT;
 }
 /** Convert millimeters to twips. */
 export function mmToTwips(mm) {
-    return Math.round(mm * 56.7);
+    return Math.round(mm * TWIPS_PER_MM);
 }
 // =============================================================================
 // EMU conversions (1 inch = 914400 EMU, 1 cm = 360000 EMU, 1 pt = 12700 EMU)
 // =============================================================================
 /** Convert inches to EMU. */
 export function inchesToEmu(inches) {
-    return Math.round(inches * 914400);
+    return Math.round(inches * EMU_PER_INCH);
 }
 /** Convert EMU to inches. */
 export function emuToInches(emu) {
-    return emu / 914400;
+    return emu / EMU_PER_INCH;
 }
 /** Convert centimeters to EMU. */
 export function cmToEmu(cm) {
-    return Math.round(cm * 360000);
+    return Math.round(cm * EMU_PER_CM);
 }
 /** Convert EMU to centimeters. */
 export function emuToCm(emu) {
-    return emu / 360000;
+    return emu / EMU_PER_CM;
 }
 /** Convert points to EMU. */
 export function ptToEmu(pt) {
-    return Math.round(pt * 12700);
+    return Math.round(pt * EMU_PER_POINT);
 }
 /** Convert pixels (at 96 DPI) to EMU. */
 export function pxToEmu(px) {
-    return Math.round(px * 9525);
+    return Math.round(px * EMU_PER_PX);
 }
 /** Convert EMU to pixels (at 96 DPI). */
 export function emuToPx(emu) {
-    return emu / 9525;
+    return emu / EMU_PER_PX;
 }
 // =============================================================================
 // Half-point conversions (font sizes: 1 pt = 2 half-points)

package/dist/esm/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/esm/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/esm/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/esm/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/{browser/modules/word → esm/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) {