@cj-tech-master/excelts 9.6.0 → 9.6.1

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

@@ -316,8 +316,8 @@ export function renderShading(xml, shd) {
     });
 }
 /** Render an inline image (w:drawing > wp:inline). */
-function renderInlineImage(xml, img, imageRemap) {
-    const drawingId = img.drawingId ?? 1;
+function renderInlineImage(xml, img, imageRemap, nextDocPrId) {
+    const drawingId = nextDocPrId?.() ?? img.drawingId ?? 1;
     const name = img.name ?? "Picture";
     // Resolve the relationship id used in r:embed: prefer a packager-provided
     // remap (used when the model rId clashed with an existing relationship in
@@ -481,7 +481,11 @@ function renderFfData(xml, ff) {
         }
         if (ff.entries) {
             for (const entry of ff.entries) {
-                xml.leafNode("w:listEntry", { "w:val": entry });
+                // Word rejects FORMDROPDOWN list entries with an empty value
+                // ("Word experienced an error trying to open the file"). Substitute a
+                // single space so an intended blank/placeholder item still renders and
+                // the entry indices (and `w:default`) stay aligned.
+                xml.leafNode("w:listEntry", { "w:val": entry === "" ? " " : entry });
             }
         }
         xml.closeNode();
@@ -668,7 +672,7 @@ function renderRunContent(xml, content, helpers) {
                 }
                 return true;
             }
-            renderInlineImage(xml, content, helpers?.imageRemap);
+            renderInlineImage(xml, content, helpers?.imageRemap, helpers?.nextDocPrId);
             return true;
         case "field":
             // Fields create their own runs — must be rendered outside the current run

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

@@ -87,6 +87,16 @@ function renderPageBorders(xml, borders) {
 /** Render w:sectPr element. */
 export function renderSectionProperties(xml, sect, insidePropertyChange = false) {
     xml.openNode("w:sectPr");
+    // NOTE: Child element ordering below is dictated by the OOXML schema
+    // (ISO/IEC 29500 — CT_SectPr / EG_SectPrContents). Microsoft Word rejects
+    // (or silently "repairs") documents whose sectPr children are out of order,
+    // so the sequence here MUST stay:
+    //   headerReference*, footerReference*, footnotePr, endnotePr, type, pgSz,
+    //   pgMar, paperSrc, pgBorders, lnNumType, pgNumType, cols, formProt,
+    //   vAlign, noEndnote, titlePg, textDirection, bidi, rtlGutter, docGrid,
+    //   printerSettings
+    // (headerReference/footerReference come from EG_HdrFtrReferences, which the
+    // schema places ahead of EG_SectPrContents.)
     // Header references
     if (sect.headers) {
         for (const ref of sect.headers) {
@@ -99,6 +109,14 @@ export function renderSectionProperties(xml, sect, insidePropertyChange = false)
             renderHeaderFooterRef(xml, "w:footerReference", ref);
         }
     }
+    // Footnote properties
+    if (sect.footnoteProperties) {
+        renderNoteProperties(xml, "w:footnotePr", sect.footnoteProperties);
+    }
+    // Endnote properties
+    if (sect.endnoteProperties) {
+        renderNoteProperties(xml, "w:endnotePr", sect.endnoteProperties);
+    }
     // Section break type
     if (sect.breakType) {
         xml.leafNode("w:type", { "w:val": sect.breakType });
@@ -131,29 +149,7 @@ export function renderSectionProperties(xml, sect, insidePropertyChange = false)
     if (sect.pageBorders) {
         renderPageBorders(xml, sect.pageBorders);
     }
-    // Columns
-    if (sect.columns) {
-        renderColumns(xml, sect.columns);
-    }
-    else {
-        xml.leafNode("w:cols", { "w:space": String(DEFAULT_COLUMN_SPACE) });
-    }
-    // Title page (different first page header/footer)
-    if (sect.titlePage) {
-        xml.leafNode("w:titlePg");
-    }
-    // Page numbering
-    if (sect.pageNumbering) {
-        const attrs = {};
-        if (sect.pageNumbering.start !== undefined) {
-            attrs["w:start"] = String(sect.pageNumbering.start);
-        }
-        if (sect.pageNumbering.format) {
-            attrs["w:fmt"] = sect.pageNumbering.format;
-        }
-        xml.leafNode("w:pgNumType", attrs);
-    }
-    // Line numbers
+    // Line numbers (must precede pgNumType per schema)
     if (sect.lineNumbers) {
         const attrs = {};
         if (sect.lineNumbers.countBy !== undefined) {
@@ -170,10 +166,37 @@ export function renderSectionProperties(xml, sect, insidePropertyChange = false)
         }
         xml.leafNode("w:lnNumType", attrs);
     }
+    // Page numbering
+    if (sect.pageNumbering) {
+        const attrs = {};
+        if (sect.pageNumbering.start !== undefined) {
+            attrs["w:start"] = String(sect.pageNumbering.start);
+        }
+        if (sect.pageNumbering.format) {
+            attrs["w:fmt"] = sect.pageNumbering.format;
+        }
+        xml.leafNode("w:pgNumType", attrs);
+    }
+    // Columns
+    if (sect.columns) {
+        renderColumns(xml, sect.columns);
+    }
+    else {
+        xml.leafNode("w:cols", { "w:space": String(DEFAULT_COLUMN_SPACE) });
+    }
+    // Form protection
+    if (sect.formProtection) {
+        xml.leafNode("w:formProt", { "w:val": "1" });
+    }
     // Vertical alignment
     if (sect.verticalAlign) {
         xml.leafNode("w:vAlign", { "w:val": sect.verticalAlign });
     }
+    // Title page (different first page header/footer) — schema places this
+    // after vAlign/noEndnote and before textDirection.
+    if (sect.titlePage) {
+        xml.leafNode("w:titlePg");
+    }
     // Text direction
     if (sect.textDirection) {
         xml.leafNode("w:textDirection", { "w:val": sect.textDirection });
@@ -186,18 +209,6 @@ export function renderSectionProperties(xml, sect, insidePropertyChange = false)
     if (sect.rtlGutter) {
         xml.leafNode("w:rtlGutter");
     }
-    // Form protection
-    if (sect.formProtection) {
-        xml.leafNode("w:formProt", { "w:val": "1" });
-    }
-    // Footnote properties
-    if (sect.footnoteProperties) {
-        renderNoteProperties(xml, "w:footnotePr", sect.footnoteProperties);
-    }
-    // Endnote properties
-    if (sect.endnoteProperties) {
-        renderNoteProperties(xml, "w:endnotePr", sect.endnoteProperties);
-    }
     // Document grid
     if (sect.docGrid) {
         const gridAttrs = {

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

@@ -900,6 +900,7 @@ export class StreamingDocxWriter {
             addXmlFile(PartPath.Comments, xml => renderComments(xml, this._options.comments, {
                 imageRemap: this._renderCtx.imageRIdRemap,
                 hyperlinkRIds: this._renderCtx.hyperlinkRIds,
+                nextDocPrId: this._renderCtx.ids.nextDocPrId,
                 rawXmlPolicy: this._renderCtx.rawXmlPolicy
             }));
             // Also write commentsExtended if any have done/parentId
@@ -973,6 +974,7 @@ export class StreamingDocxWriter {
                 addXmlFile(headerPath, xml => renderHeader(xml, headerDef.content, {
                     imageRemap: this._renderCtx.imageRIdRemap,
                     hyperlinkRIds: this._renderCtx.hyperlinkRIds,
+                    nextDocPrId: this._renderCtx.ids.nextDocPrId,
                     rawXmlPolicy: this._renderCtx.rawXmlPolicy
                 }));
                 if (getRelationshipCount(hRels) > 0) {
@@ -1043,6 +1045,7 @@ export class StreamingDocxWriter {
                 addXmlFile(footerPath, xml => renderFooter(xml, footerDef.content, {
                     imageRemap: this._renderCtx.imageRIdRemap,
                     hyperlinkRIds: this._renderCtx.hyperlinkRIds,
+                    nextDocPrId: this._renderCtx.ids.nextDocPrId,
                     rawXmlPolicy: this._renderCtx.rawXmlPolicy
                 }));
                 if (getRelationshipCount(fRels) > 0) {
@@ -1221,6 +1224,7 @@ export class StreamingDocxWriter {
             notesHelpers: {
                 imageRemap: this._renderCtx.imageRIdRemap,
                 hyperlinkRIds: this._renderCtx.hyperlinkRIds,
+                nextDocPrId: this._renderCtx.ids.nextDocPrId,
                 rawXmlPolicy: this._renderCtx.rawXmlPolicy
             }
         });

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

@@ -170,6 +170,17 @@ function renderStyle(xml, style) {
     // For table styles
     if (style.tableProperties) {
         xml.openNode("w:tblPr");
+        // Per CT_TblPrBase order, band sizes precede w:tblW.
+        if (style.tableProperties.rowBandSize !== undefined) {
+            xml.leafNode("w:tblStyleRowBandSize", {
+                "w:val": String(style.tableProperties.rowBandSize)
+            });
+        }
+        if (style.tableProperties.colBandSize !== undefined) {
+            xml.leafNode("w:tblStyleColBandSize", {
+                "w:val": String(style.tableProperties.colBandSize)
+            });
+        }
         if (style.tableProperties.width) {
             xml.leafNode("w:tblW", {
                 "w:w": String(style.tableProperties.width.value),

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

@@ -168,6 +168,12 @@ function renderTableProperties(xml, tPr, insidePropertyChange = false) {
             xml.leafNode("w:tblOverlap", { "w:val": tPr.float.overlap });
         }
     }
+    if (tPr.rowBandSize !== undefined) {
+        xml.leafNode("w:tblStyleRowBandSize", { "w:val": String(tPr.rowBandSize) });
+    }
+    if (tPr.colBandSize !== undefined) {
+        xml.leafNode("w:tblStyleColBandSize", { "w:val": String(tPr.colBandSize) });
+    }
     if (tPr.width) {
         renderTableWidth(xml, "w:tblW", tPr.width);
     }

package/dist/cjs/modules/excel/xlsx/xform/comment/comment-xform.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommentXform = void 0;
 const base_xform_1 = require("../base-xform.js");
 const rich_text_xform_1 = require("../strings/rich-text-xform.js");
+const text_xform_1 = require("../strings/text-xform.js");
 class CommentXform extends base_xform_1.BaseXform {
     constructor(model) {
         super();
@@ -17,6 +18,12 @@ class CommentXform extends base_xform_1.BaseXform {
         }
         return this._richTextXform;
     }
+    get textXform() {
+        if (!this._textXform) {
+            this._textXform = new text_xform_1.TextXform();
+        }
+        return this._textXform;
+    }
     render(xmlStream, model) {
         const renderModel = model || this.model;
         xmlStream.openNode("comment", {
@@ -52,6 +59,13 @@ class CommentXform extends base_xform_1.BaseXform {
                 this.parser = this.richTextXform;
                 this.parser.parseOpen(node);
                 return true;
+            case "t":
+                // Legacy comments (e.g. produced by openpyxl/LibreOffice) may store the
+                // body as a bare <t> directly under <text> with no <r> run wrapper.
+                // This is valid for the CT_Rst type, so treat it like a run without font.
+                this.parser = this.textXform;
+                this.parser.parseOpen(node);
+                return true;
             default:
                 return false;
         }
@@ -62,17 +76,26 @@ class CommentXform extends base_xform_1.BaseXform {
         }
     }
     parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                // The active sub-parser has finished. Collect its result.
+                if (this.parser === this._richTextXform) {
+                    // <r> run: model is already a { font?, text } run.
+                    this.model.note.texts.push(this.parser.model);
+                }
+                else {
+                    // Bare <t> body (e.g. openpyxl/LibreOffice): wrap the plain string
+                    // as a single run without font, mirroring a <r><t> run.
+                    this.model.note.texts.push({ text: this.parser.model });
+                }
+                this.parser = undefined;
+            }
+            return true;
+        }
         switch (name) {
             case "comment":
                 return false;
-            case "r":
-                this.model.note.texts.push(this.parser.model);
-                this.parser = undefined;
-                return true;
             default:
-                if (this.parser) {
-                    this.parser.parseClose(name);
-                }
                 return true;
         }
     }

package/dist/cjs/modules/pdf/excel-bridge.js

@@ -20,6 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.excelToPdf = excelToPdf;
 exports.chartToPdf = chartToPdf;
 exports.createWordChartPdfRenderer = createWordChartPdfRenderer;
+exports.createWordLayoutChartPdfRenderer = createWordLayoutChartPdfRenderer;
 // Chart runtime is accessed through the chart-host-registry slot so
 // `@pkg/pdf` can do excel-to-PDF conversion without statically pulling
 // ~1.2 MB of chart rendering code into every consumer's bundle.
@@ -1177,3 +1178,69 @@ function createWordChartPdfRenderer() {
         support.drawChartPdf(page, model, rect);
     };
 }
+/**
+ * Create a layout-aware chart renderer for use as the internal
+ * `RenderLayoutOptions.chartRenderer` of the Word→PDF bridge.
+ *
+ * Unlike {@link createWordChartPdfRenderer} (which only sees the inner
+ * classic `Chart` model), this renderer receives the full
+ * {@link LayoutChart} and therefore handles **both** chart families
+ * with the full Excel rendering engine:
+ *
+ * - Classic `<c:chart>` (`chartKind === "chart"`) → `wordChartToChartModel`
+ *   → `drawChartPdf` (vector).
+ * - Modern `<cx:chartSpace>` ChartEx (`chartKind === "chartEx"`,
+ *   e.g. sunburst / treemap / waterfall / funnel / boxWhisker /
+ *   histogram / pareto / regionMap) → `parseChartEx` → `drawChartExPdf`
+ *   (vector) when the layout is vector-capable, otherwise the
+ *   pre-rendered SVG carried on the `LayoutChart` is left for the
+ *   translator's fallback.
+ *
+ * Returns `false` to decline a chart so the translator's built-in
+ * fallback (inline SVG, then a titled placeholder box) takes over. This
+ * keeps "fail soft" behaviour: a chart the engine can't draw still
+ * renders *something* rather than a blank slot.
+ *
+ * Requires `installChartSupport()` to have been called.
+ */
+function createWordLayoutChartPdfRenderer() {
+    return (layoutChart, page, rect) => {
+        const support = (0, chart_host_registry_1.tryGetChartSupport)();
+        if (!support) {
+            // Chart support not installed — decline so the Word→PDF
+            // translator falls back to the inline SVG / placeholder. This
+            // mirrors the auto-detect contract in `word-bridge.ts`, where a
+            // missing chart runtime must degrade gracefully rather than throw.
+            return false;
+        }
+        const source = layoutChart.source;
+        if (layoutChart.chartKind === "chart") {
+            // Classic chart: prefer the structured source, fall back to nothing.
+            if (source && source.type === "chart") {
+                support.drawChartPdf(page, (0, excel_bridge_1.wordChartToChartModel)(source.chart), rect);
+                return;
+            }
+            return false;
+        }
+        // ChartEx. Parse the carried `cx:chartSpace` XML into a ChartExModel
+        // and render it as vector PDF when the layout IDs are supported.
+        if (source && source.type === "chartEx" && source.chartExXml) {
+            let model;
+            try {
+                model = support.parseChartEx(source.chartExXml);
+            }
+            catch {
+                return false; // Malformed XML — let the fallback path handle it.
+            }
+            if (model && support.canRenderChartExAsVectorPdf(model)) {
+                support.drawChartExPdf(page, model, rect, {
+                    title: layoutChart.title
+                });
+                return;
+            }
+        }
+        // Not vector-capable (or no source): decline so the translator
+        // falls back to the inline SVG / placeholder.
+        return false;
+    };
+}

package/dist/cjs/modules/pdf/word-bridge.js

@@ -82,47 +82,59 @@ async function docxToPdf(doc, options) {
     //    caller explicitly overrode an axis. Margins are independent: the
     //    section's margins are applied unless the caller overrode them.
     const layoutOptions = mapToLayoutOptions(doc, options);
-    // 2. Auto-detect chart support: if no explicit chartRenderer is
-    //    provided, try to import the high-quality Excel-based renderer.
-    let chartRendererForChart = options?.chartRenderer;
-    if (!chartRendererForChart) {
-        try {
-            const mod = await Promise.resolve().then(() => __importStar(require("./excel-bridge")));
-            if (typeof mod.createWordChartPdfRenderer === "function") {
-                chartRendererForChart = mod.createWordChartPdfRenderer();
-            }
-        }
-        catch {
-            // Chart support not available — placeholder rendering takes over.
+    // 2. Try to obtain the built-in, layout-aware Excel chart renderer.
+    //    It handles BOTH classic `<c:chart>` and modern `<cx:chartSpace>`
+    //    ChartEx families (sunburst / treemap / waterfall / …). It is used
+    //    directly when the caller supplies no `chartRenderer`, and as the
+    //    fallback for ChartEx (which the public `Chart`-typed callback
+    //    cannot express) or whenever a user callback declines a chart.
+    let builtInLayoutRenderer;
+    try {
+        const mod = await Promise.resolve().then(() => __importStar(require("./excel-bridge")));
+        if (typeof mod.createWordLayoutChartPdfRenderer === "function") {
+            builtInLayoutRenderer = mod.createWordLayoutChartPdfRenderer();
         }
     }
+    catch {
+        // Chart support not available — placeholder rendering takes over.
+    }
     // 3. Run the layout engine. Everything from line wrapping to page
     //    breaks happens here; word-bridge no longer carries any of that.
     const layout = (0, layout_full_1.layoutDocumentFull)(doc, layoutOptions);
     // 4. Build a render-options object for the PDF translator. The
-    //    chartRenderer adaptation: layout produces `LayoutChart` (which
-    //    contains the original `ChartContent` in `source`); the public
-    //    chartRenderer API takes the inner `Chart` model. We unwrap so
-    //    existing callers keep working unchanged.
+    //    chart-rendering precedence is:
+    //      a. classic chart + user callback → user callback (its `false`
+    //         return falls through to the built-in layout renderer);
+    //      b. ChartEx, or classic chart with no user callback, or a
+    //         declined user callback → built-in layout-aware renderer;
+    //      c. neither available / both decline → translator fallback
+    //         (inline SVG, then a titled placeholder box).
+    const userChartRenderer = options?.chartRenderer;
     const renderOptions = {
         title: doc.coreProperties?.title,
         author: doc.coreProperties?.creator,
         subject: doc.coreProperties?.subject,
         defaultFont: options?.defaultFont ?? "Helvetica",
         defaultFontSize: options?.defaultFontSize ?? 11,
-        chartRenderer: chartRendererForChart
+        chartRenderer: userChartRenderer || builtInLayoutRenderer
             ? (layoutChart, page, rect) => {
                 const src = layoutChart.source;
-                if (src && src.type === "chart") {
-                    // Forward the user's return value so a renderer that knows
-                    // how to draw classic charts but declines a particular
-                    // family (e.g. unsupported axis combination) gets the
-                    // translator's placeholder fallback.
-                    return chartRendererForChart(src.chart, page, rect);
+                // (a) Classic chart with a user-supplied callback: honour it
+                //     first. Only fall through to the built-in renderer when
+                //     it explicitly declines (`false`).
+                if (userChartRenderer && src && src.type === "chart") {
+                    const handled = userChartRenderer(src.chart, page, rect);
+                    if (handled !== false) {
+                        return handled;
+                    }
+                }
+                // (b) Built-in layout-aware renderer handles classic charts
+                //     without a user callback AND all ChartEx charts.
+                if (builtInLayoutRenderer) {
+                    return builtInLayoutRenderer(layoutChart, page, rect);
                 }
-                // ChartEx (or absent source) cannot be passed to the user's
-                // `Chart`-typed callback. Decline so the translator's
-                // placeholder runs instead of leaving a blank slot.
+                // (c) Decline so the translator's placeholder runs instead of
+                //     leaving a blank slot.
                 return false;
             }
             : undefined
@@ -141,13 +153,11 @@ async function docxToPdf(doc, options) {
  * portrait-oriented numbers); otherwise the layout engine's defaults
  * (US Letter, 1-inch margins) take over.
  *
- * `headerMargin` / `footerMargin` are accepted for API compatibility
- * with the previous flow renderer but currently have no effect on the
- * layout-driven path: the layout engine does not yet position header /
- * footer paragraphs against custom inset values, and forwarding the
- * field would silently mislead callers. Pre-existing documents that
- * rely on those parameters still get the section's `headerMargin` /
- * `footerMargin` from sectionProperties when they exist.
+ * `headerMargin` / `footerMargin` are forwarded to the layout engine
+ * as header / footer band offsets (ECMA-376 `pgMar.header` /
+ * `pgMar.footer`). When omitted, the section's own header / footer
+ * margins apply; when neither exists the engine default of 36pt (0.5")
+ * is used.
  */
 function mapToLayoutOptions(doc, options) {
     const sectProps = doc.sectionProperties;
@@ -172,7 +182,12 @@ function mapToLayoutOptions(doc, options) {
         marginTop: options?.marginTop ?? sectionMarginTopPt,
         marginBottom: options?.marginBottom ?? sectionMarginBottomPt,
         marginLeft: options?.marginLeft ?? sectionMarginLeftPt,
-        marginRight: options?.marginRight ?? sectionMarginRightPt
+        marginRight: options?.marginRight ?? sectionMarginRightPt,
+        // Header / footer offsets: only forward an explicit caller value.
+        // Leaving these undefined lets the layout engine fall back to the
+        // section's `pgMar.header` / `pgMar.footer` (then the 36pt default).
+        headerMargin: options?.headerMargin,
+        footerMargin: options?.footerMargin
     };
     const layoutOpts = {};
     // Only attach pageGeometry when at least one axis is actually

package/dist/cjs/modules/word/advanced/diff.js

@@ -147,24 +147,136 @@ function computeDiff(oldTexts, newTexts) {
     }
     // Reverse since we built it backwards
     entries.reverse();
-    // Post-process: pair adjacent delete+add as "modified" when they're at the same position
+    return pairModifications(entries);
+}
+/**
+ * Pair deletions with insertions that represent the *same* paragraph in a
+ * modified form, based on text similarity.
+ *
+ * The LCS pass only matches paragraphs whose text is byte-identical, so when
+ * every paragraph is lightly edited it produces all-deletions + all-insertions
+ * with no "modified" at all. Within each contiguous change block (a run of
+ * deletions/insertions bounded by unchanged entries), we greedily pair each
+ * deletion with the most similar insertion whose similarity clears
+ * {@link MODIFY_SIMILARITY_THRESHOLD}. Pairs become "modified"; anything left
+ * unpaired stays a pure deletion or insertion. This yields, e.g., a recipe
+ * whose steps were all tweaked → mostly "modified", with a removed step as a
+ * pure deletion and a brand-new step as a pure insertion.
+ */
+function pairModifications(entries) {
     const result = [];
-    for (let k = 0; k < entries.length; k++) {
-        const curr = entries[k];
-        const next = k + 1 < entries.length ? entries[k + 1] : undefined;
-        if (curr.type === "deleted" && next?.type === "added") {
-            result.push({
+    let k = 0;
+    while (k < entries.length) {
+        const entry = entries[k];
+        if (entry.type !== "deleted" && entry.type !== "added") {
+            result.push(entry);
+            k++;
+            continue;
+        }
+        // Collect the maximal contiguous run of deleted/added entries.
+        const dels = [];
+        const adds = [];
+        let j = k;
+        while (j < entries.length && (entries[j].type === "deleted" || entries[j].type === "added")) {
+            if (entries[j].type === "deleted") {
+                dels.push(entries[j]);
+            }
+            else {
+                adds.push(entries[j]);
+            }
+            j++;
+        }
+        result.push(...pairChangeBlock(dels, adds));
+        k = j;
+    }
+    return result;
+}
+/**
+ * Pair one change block's deletions and insertions by similarity. Greedy:
+ * process deletions in order, each claiming the most similar still-unclaimed
+ * insertion above the threshold. Emits entries in old-index / new-index order.
+ */
+function pairChangeBlock(dels, adds) {
+    const usedAdd = new Array(adds.length).fill(false);
+    const out = [];
+    const leftoverAdds = [];
+    for (const del of dels) {
+        let bestIdx = -1;
+        let bestScore = MODIFY_SIMILARITY_THRESHOLD;
+        for (let a = 0; a < adds.length; a++) {
+            if (usedAdd[a]) {
+                continue;
+            }
+            const score = textSimilarity(del.oldText ?? "", adds[a].newText ?? "");
+            if (score >= bestScore) {
+                bestScore = score;
+                bestIdx = a;
+            }
+        }
+        if (bestIdx >= 0) {
+            usedAdd[bestIdx] = true;
+            out.push({
                 type: "modified",
-                oldIndex: curr.oldIndex,
-                newIndex: next.newIndex,
-                oldText: curr.oldText,
-                newText: next.newText
+                oldIndex: del.oldIndex,
+                newIndex: adds[bestIdx].newIndex,
+                oldText: del.oldText,
+                newText: adds[bestIdx].newText
             });
-            k++; // skip next
         }
         else {
-            result.push(curr);
+            out.push(del); // pure deletion
         }
     }
-    return result;
+    for (let a = 0; a < adds.length; a++) {
+        if (!usedAdd[a]) {
+            leftoverAdds.push(adds[a]); // pure insertion
+        }
+    }
+    // Order the block by position: modifications and deletions (old order)
+    // first, then the surviving pure insertions (new order). Both arrays are
+    // already in their natural index order from the LCS walk.
+    out.push(...leftoverAdds);
+    return out;
+}
+/** Minimum similarity (0..1) for a delete+add to be treated as a modification. */
+const MODIFY_SIMILARITY_THRESHOLD = 0.5;
+/**
+ * Similarity of two strings in [0, 1], combining word-set overlap (Jaccard)
+ * with a shared-prefix bonus. Cheap and dependency-free — good enough to tell
+ * "same paragraph, lightly edited" from "completely different paragraph".
+ */
+function textSimilarity(a, b) {
+    if (a === b) {
+        return 1;
+    }
+    if (a.length === 0 || b.length === 0) {
+        return 0;
+    }
+    const wordsA = a.toLowerCase().split(/\s+/).filter(Boolean);
+    const wordsB = b.toLowerCase().split(/\s+/).filter(Boolean);
+    if (wordsA.length === 0 || wordsB.length === 0) {
+        return 0;
+    }
+    const setA = new Set(wordsA);
+    const setB = new Set(wordsB);
+    let intersection = 0;
+    for (const w of setA) {
+        if (setB.has(w)) {
+            intersection++;
+        }
+    }
+    const union = setA.size + setB.size - intersection;
+    const jaccard = union === 0 ? 0 : intersection / union;
+    // Shared-prefix bonus: paragraphs that begin the same ("Step 3: …") are very
+    // likely the same item edited, even if many words changed.
+    let prefix = 0;
+    const max = Math.min(a.length, b.length);
+    while (prefix < max && a[prefix] === b[prefix]) {
+        prefix++;
+    }
+    const prefixRatio = prefix / Math.max(a.length, b.length);
+    // Weight word overlap most, with shared prefix as a strong booster so
+    // "Hello World" → "Hello Earth" (half the words, same prefix) reads as a
+    // modification while unrelated text stays a delete+add.
+    return Math.min(1, jaccard * 0.7 + prefixRatio * 0.5);
 }

package/dist/cjs/modules/word/advanced/drawing-shapes.js

@@ -73,6 +73,7 @@ function createShape(options) {
         outlineWidth,
         noOutline,
         textContent: options.textBody?.paragraphs,
+        textBodyAnchor: options.textBody?.anchor,
         altText: options.altText,
         name: options.name,
         horizontalPosition: options.horizontalPosition,
@@ -80,6 +81,8 @@ function createShape(options) {
         wrap: options.wrap,
         behindDoc: options.behindDoc,
         rotation: options.rotation,
+        flipHorizontal: options.flipH,
+        flipVertical: options.flipV,
         rawXml: rawXml.length > 0 ? rawXml : undefined,
         _advancedFillXml: advanced.fillXml,
         _advancedEffectsXml: advanced.effectsXml