@cj-tech-master/excelts 9.6.0 → 9.6.1

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

@@ -90,6 +90,16 @@ function renderPageBorders(xml, borders) {
 /** Render w:sectPr element. */
 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) {
@@ -102,6 +112,14 @@ 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 });
@@ -134,29 +152,7 @@ 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(constants_1.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) {
@@ -173,10 +169,37 @@ 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(constants_1.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 });
@@ -189,18 +212,6 @@ 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/cjs/modules/word/writer/streaming-writer.js

@@ -904,6 +904,7 @@ class StreamingDocxWriter {
             addXmlFile(constants_1.PartPath.Comments, xml => (0, comment_writer_1.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
@@ -977,6 +978,7 @@ class StreamingDocxWriter {
                 addXmlFile(headerPath, xml => (0, header_footer_writer_1.renderHeader)(xml, headerDef.content, {
                     imageRemap: this._renderCtx.imageRIdRemap,
                     hyperlinkRIds: this._renderCtx.hyperlinkRIds,
+                    nextDocPrId: this._renderCtx.ids.nextDocPrId,
                     rawXmlPolicy: this._renderCtx.rawXmlPolicy
                 }));
                 if ((0, relationships_1.getRelationshipCount)(hRels) > 0) {
@@ -1047,6 +1049,7 @@ class StreamingDocxWriter {
                 addXmlFile(footerPath, xml => (0, header_footer_writer_1.renderFooter)(xml, footerDef.content, {
                     imageRemap: this._renderCtx.imageRIdRemap,
                     hyperlinkRIds: this._renderCtx.hyperlinkRIds,
+                    nextDocPrId: this._renderCtx.ids.nextDocPrId,
                     rawXmlPolicy: this._renderCtx.rawXmlPolicy
                 }));
                 if ((0, relationships_1.getRelationshipCount)(fRels) > 0) {
@@ -1225,6 +1228,7 @@ class StreamingDocxWriter {
             notesHelpers: {
                 imageRemap: this._renderCtx.imageRIdRemap,
                 hyperlinkRIds: this._renderCtx.hyperlinkRIds,
+                nextDocPrId: this._renderCtx.ids.nextDocPrId,
                 rawXmlPolicy: this._renderCtx.rawXmlPolicy
             }
         });

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

@@ -173,6 +173,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/cjs/modules/word/writer/table-writer.js

@@ -171,6 +171,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/esm/modules/excel/xlsx/xform/comment/comment-xform.js

@@ -1,5 +1,6 @@
 import { BaseXform } from "../base-xform.js";
 import { RichTextXform } from "../strings/rich-text-xform.js";
+import { TextXform } from "../strings/text-xform.js";
 class CommentXform extends BaseXform {
     constructor(model) {
         super();
@@ -14,6 +15,12 @@ class CommentXform extends BaseXform {
         }
         return this._richTextXform;
     }
+    get textXform() {
+        if (!this._textXform) {
+            this._textXform = new TextXform();
+        }
+        return this._textXform;
+    }
     render(xmlStream, model) {
         const renderModel = model || this.model;
         xmlStream.openNode("comment", {
@@ -49,6 +56,13 @@ class CommentXform extends 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;
         }
@@ -59,17 +73,26 @@ class CommentXform extends 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/esm/modules/pdf/excel-bridge.js

@@ -21,7 +21,7 @@
 // Consumers that convert workbooks with charts must call
 // `installChartSupport()` from `@cj-tech-master/excelts/chart` before
 // invoking `excelToPdf()`.
-import { getChartSupport } from "../excel/chart-host-registry.js";
+import { getChartSupport, tryGetChartSupport } from "../excel/chart-host-registry.js";
 import { ValueType } from "../excel/enums.js";
 import { formatCellValue } from "../excel/utils/cell-format.js";
 import { tryInvokeFormulaEngine } from "../formula/host-registry.js";
@@ -1172,3 +1172,69 @@ export 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.
+ */
+export function createWordLayoutChartPdfRenderer() {
+    return (layoutChart, page, rect) => {
+        const support = 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, 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/esm/modules/pdf/word-bridge.js

@@ -46,47 +46,59 @@ export 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 import("./excel-bridge.js");
-            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 import("./excel-bridge.js");
+        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 = 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
@@ -105,13 +117,11 @@ export 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;
@@ -136,7 +146,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/esm/modules/word/advanced/diff.js

@@ -144,24 +144,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/esm/modules/word/advanced/drawing-shapes.js

@@ -62,6 +62,7 @@ export function createShape(options) {
         outlineWidth,
         noOutline,
         textContent: options.textBody?.paragraphs,
+        textBodyAnchor: options.textBody?.anchor,
         altText: options.altText,
         name: options.name,
         horizontalPosition: options.horizontalPosition,
@@ -69,6 +70,8 @@ export 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

package/dist/esm/modules/word/bridge/excel-bridge.js

@@ -229,7 +229,7 @@ function convertCell(cell, opts) {
     const para = {
         type: "paragraph",
         properties: opts.preserveFormatting ? alignmentToParaProps(cell.alignment) : undefined,
-        children: children.length > 0 ? children : [{ content: [{ type: "text", text: "" }] }]
+        children: wrapHyperlink(cell.hyperlink, children)
     };
     const cellProps = {};
     if (opts.preserveFormatting && cell.fill) {
@@ -249,6 +249,26 @@ function convertCell(cell, opts) {
         properties: Object.keys(cellProps).length > 0 ? cellProps : undefined
     };
 }
+/**
+ * Build a paragraph's children for a converted cell, wrapping the runs
+ * in a Word {@link Hyperlink} when the source Excel cell carries one.
+ *
+ * Excel cell hyperlinks are external URLs (or `#Sheet!A1` internal
+ * references). We map `#…` targets to a Word anchor and everything else
+ * to an external `url`; the packager assigns the relationship id on
+ * write. An empty cell still produces a single empty run so the table
+ * structure stays intact.
+ */
+function wrapHyperlink(hyperlink, runs) {
+    const children = runs.length > 0 ? [...runs] : [{ content: [{ type: "text", text: "" }] }];
+    if (!hyperlink) {
+        return children;
+    }
+    const link = hyperlink.startsWith("#")
+        ? { type: "hyperlink", anchor: hyperlink.slice(1), children }
+        : { type: "hyperlink", url: hyperlink, children };
+    return [link];
+}
 function cellText(cell) {
     if (cell.type === ValueType.Null || cell.type === ValueType.Merge) {
         return "";