@cj-tech-master/excelts 9.6.0 → 9.6.1

package/dist/browser/modules/archive/io/random-access.d.ts

@@ -55,7 +55,7 @@ export interface HttpRangeReaderOptions {
      * Whether to use credentials (cookies) for cross-origin requests.
      * @default "same-origin"
      */
-    credentials?: RequestCredentials;
+    credentials?: NonNullable<RequestInit["credentials"]>;
     /**
      * Optional: Pre-known file size to skip HEAD request.
      * If not provided, a HEAD request will be made to determine size.

package/dist/browser/modules/excel/workbook.browser.d.ts

@@ -241,7 +241,7 @@ interface CsvOptionsExtras {
     map?(value: CellValue, index: number): CellValue;
     includeEmptyRows?: boolean;
     requestHeaders?: Record<string, string>;
-    requestBody?: BodyInit;
+    requestBody?: NonNullable<RequestInit["body"]>;
     withCredentials?: boolean;
     signal?: AbortSignal;
     encoding?: string;

package/dist/browser/modules/excel/xlsx/xform/comment/comment-xform.d.ts

@@ -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";
 interface NoteText {
     font?: any;
     text: string;
@@ -16,9 +17,11 @@ interface CommentModel {
 declare class CommentXform extends BaseXform<CommentModel> {
     parser: any;
     private _richTextXform?;
+    private _textXform?;
     constructor(model?: CommentModel);
     get tag(): string;
     get richTextXform(): RichTextXform;
+    get textXform(): TextXform;
     render(xmlStream: any, model?: CommentModel): void;
     parseOpen(node: any): boolean;
     parseText(text: string): void;

package/dist/browser/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/browser/modules/pdf/excel-bridge.d.ts

@@ -17,6 +17,7 @@
  */
 import type { Chart, RegionMapDataOptions } from "../excel/chart/index.js";
 import type { Workbook } from "../excel/workbook.browser.js";
+import type { LayoutChart } from "../word/layout/layout-model.js";
 import type { Chart as WordChart } from "../word/types.js";
 import { type PdfPageBuilder } from "./builder/document-builder.js";
 import { type PdfExportOptions } from "./types.js";
@@ -126,3 +127,34 @@ export declare function createWordChartPdfRenderer(): (chart: WordChart, page: P
     width: number;
     height: number;
 }) => void;
+/**
+ * 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 declare function createWordLayoutChartPdfRenderer(): (chart: LayoutChart, page: PdfPageBuilder, rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}) => boolean | void;

package/dist/browser/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/browser/modules/pdf/word-bridge.d.ts

@@ -53,19 +53,21 @@ export interface DocxToPdfOptions {
     /** Default font size in points (default: 11). */
     readonly defaultFontSize?: number;
     /**
-     * Header margin from top edge in points (default: 36).
+     * Header band distance from the top edge of the page, in points
+     * (default: section's `pgMar.header`, or 36pt / 0.5").
      *
-     * @deprecated Currently has no effect on the layout-driven render
-     * path: header paragraphs are rendered into the page's `marginTop`
-     * strip starting at y=0 without an additional offset. Influence
-     * header placement by widening `marginTop` instead.
+     * Header paragraphs are laid out starting at this y-offset from the
+     * page top. Overriding it moves the entire header band — useful when
+     * the source document declares no section properties or you want to
+     * tighten / loosen the header position without touching `marginTop`.
      */
     readonly headerMargin?: number;
     /**
-     * Footer margin from bottom edge in points (default: 36).
+     * Footer band distance from the bottom edge of the page, in points
+     * (default: section's `pgMar.footer`, or 36pt / 0.5").
      *
-     * @deprecated See {@link DocxToPdfOptions.headerMargin}. Footer
-     * paragraphs are rendered starting at `pageHeight - marginBottom`.
+     * The footer band's top sits at `pageHeight - footerMargin`. The
+     * footnote stack (if any) is placed directly above this line.
      */
     readonly footerMargin?: number;
     /**
@@ -89,14 +91,17 @@ export interface DocxToPdfOptions {
      * destination rectangle in PDF coordinates. The implementation
      * should draw the chart into the rectangle.
      *
-     * Return `false` to decline a chart (the translator then falls back
-     * to its built-in placeholder rendering: an outlined rectangle with
-     * the chart title centred). Return `void` or `true` to indicate the
-     * chart was handled.
+     * Return `false` to decline a chart. The translator then falls back
+     * to the built-in layout-aware Excel renderer (which also handles
+     * `chartEx` charts), then to the inline `LayoutChart.svg` if present,
+     * and finally to a placeholder rectangle with the chart title
+     * centred. Return `void` or `true` to indicate the chart was handled.
      *
-     * Note: `chartEx` charts never reach this callback because there is
-     * no `Chart` instance to pass; they always render through the
-     * translator's built-in path.
+     * Note: `chartEx` charts (sunburst / treemap / waterfall / funnel /
+     * boxWhisker / …) never reach this `Chart`-typed callback because
+     * there is no classic `Chart` instance to pass. They are rendered by
+     * the built-in layout-aware renderer instead (full vector output when
+     * `installChartSupport()` has been called).
      */
     readonly chartRenderer?: (chart: Chart, page: PdfPageBuilder, rect: {
         x: number;

package/dist/browser/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/browser/modules/stream/common/consumers.d.ts

@@ -5,9 +5,10 @@
  * Used by both Node.js and browser implementations.
  */
 type StreamInput = AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>;
+type BlobOptions = NonNullable<ConstructorParameters<typeof Blob>[1]>;
 export interface StreamConsumers {
     arrayBuffer(stream: StreamInput): Promise<ArrayBuffer>;
-    blob(stream: StreamInput, options?: BlobPropertyBag): Promise<Blob>;
+    blob(stream: StreamInput, options?: BlobOptions): Promise<Blob>;
     buffer(stream: StreamInput): Promise<Uint8Array>;
     json(stream: StreamInput): Promise<unknown>;
     text(stream: StreamInput, encoding?: string): Promise<string>;

package/dist/browser/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/browser/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/browser/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 "";

package/dist/browser/modules/word/builder/document-handle.d.ts

@@ -66,6 +66,7 @@ export declare const Document: {
     addImage(doc: DocumentHandle, data: Uint8Array, mediaType: ImageMediaType, width: Emu, height: Emu, options?: {
         altText?: string;
         name?: string;
+        fallbackData?: Uint8Array;
     }): {
         rId: string;
         drawingId: number;
@@ -88,6 +89,7 @@ export declare const Document: {
         rotation?: number;
         flipHorizontal?: boolean;
         flipVertical?: boolean;
+        fallbackData?: Uint8Array;
     }): string;
     /** Add a custom font definition. */
     addFont(doc: DocumentHandle, font: FontDef): void;