@cj-tech-master/excelts 9.6.1 → 10.0.0

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

@@ -5,6 +5,8 @@ interface ShapeModel {
             insetmode?: string;
             inset?: number[];
         };
+        width?: number;
+        height?: number;
     };
     refAddress?: any;
 }
@@ -20,6 +22,11 @@ declare class VmlShapeXform extends BaseXform {
     parseOpen(node: any): boolean;
     parseText(text: string): void;
     parseClose(name: string): boolean;
+    /**
+     * Extract a points-valued length (e.g. `width:120pt`) from a VML style
+     * string. Returns `undefined` when the property is absent or not in `pt`.
+     */
+    static parseStyleLength(style: string, prop: "width" | "height"): number | undefined;
     static V_SHAPE_ATTRIBUTES: (model: ShapeModel, index: number) => any;
 }
 export { VmlShapeXform };

package/dist/browser/modules/excel/xlsx/xform/comment/vml-shape-xform.js

@@ -1,6 +1,9 @@
 import { BaseXform } from "../base-xform.js";
 import { VmlClientDataXform } from "./vml-client-data-xform.js";
 import { VmlTextboxXform } from "./vml-textbox-xform.js";
+/** Default comment box geometry in points (matches legacy Excel notes). */
+const DEFAULT_NOTE_WIDTH_PT = 97.8;
+const DEFAULT_NOTE_HEIGHT_PT = 59.1;
 class VmlShapeXform extends BaseXform {
     constructor() {
         super();
@@ -37,6 +40,21 @@ class VmlShapeXform extends BaseXform {
                     editAs: "",
                     protection: {}
                 };
+                {
+                    // Recover the comment box geometry from the VML style string
+                    // (e.g. "...width:120pt;height:80pt;..."). Only surface width/height
+                    // when they differ from the legacy defaults, so untouched notes keep
+                    // a clean model (and stay byte-compatible with prior behaviour).
+                    const style = node.attributes.style ?? "";
+                    const width = VmlShapeXform.parseStyleLength(style, "width");
+                    const height = VmlShapeXform.parseStyleLength(style, "height");
+                    if (width !== undefined && width !== DEFAULT_NOTE_WIDTH_PT) {
+                        this.model.width = width;
+                    }
+                    if (height !== undefined && height !== DEFAULT_NOTE_HEIGHT_PT) {
+                        this.model.height = height;
+                    }
+                }
                 break;
             default:
                 this.parser = this.map[node.name];
@@ -75,13 +93,29 @@ class VmlShapeXform extends BaseXform {
                 return true;
         }
     }
+    /**
+     * Extract a points-valued length (e.g. `width:120pt`) from a VML style
+     * string. Returns `undefined` when the property is absent or not in `pt`.
+     */
+    static parseStyleLength(style, prop) {
+        const match = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([0-9.]+)pt`, "i").exec(style);
+        if (!match) {
+            return undefined;
+        }
+        const value = parseFloat(match[1]);
+        return Number.isFinite(value) ? value : undefined;
+    }
 }
-VmlShapeXform.V_SHAPE_ATTRIBUTES = (model, index) => ({
-    id: `_x0000_s${1025 + index}`,
-    type: "#_x0000_t202",
-    style: "position:absolute; margin-left:105.3pt;margin-top:10.5pt;width:97.8pt;height:59.1pt;z-index:1;visibility:hidden",
-    fillcolor: "infoBackground [80]",
-    strokecolor: "none [81]",
-    "o:insetmode": model.note.margins && model.note.margins.insetmode
-});
+VmlShapeXform.V_SHAPE_ATTRIBUTES = (model, index) => {
+    const width = model.note?.width ?? DEFAULT_NOTE_WIDTH_PT;
+    const height = model.note?.height ?? DEFAULT_NOTE_HEIGHT_PT;
+    return {
+        id: `_x0000_s${1025 + index}`,
+        type: "#_x0000_t202",
+        style: `position:absolute; margin-left:105.3pt;margin-top:10.5pt;width:${width}pt;height:${height}pt;z-index:1;visibility:hidden`,
+        fillcolor: "infoBackground [80]",
+        strokecolor: "none [81]",
+        "o:insetmode": model.note.margins && model.note.margins.insetmode
+    };
+};
 export { VmlShapeXform };

package/dist/browser/modules/excel/xlsx/xform/core/content-types-xform.js

@@ -21,7 +21,9 @@ class ContentTypesXform extends BaseXform {
                     mediaHash[imageType] = true;
                     xmlStream.leafNode("Default", {
                         Extension: imageType,
-                        ContentType: `image/${imageType}`
+                        // SVG's IANA media type is "image/svg+xml"; everything else follows
+                        // the "image/<ext>" convention.
+                        ContentType: imageType === "svg" ? "image/svg+xml" : `image/${imageType}`
                     });
                 }
             }

package/dist/browser/modules/excel/xlsx/xform/drawing/absolute-anchor-xform.js

@@ -3,6 +3,7 @@ import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
 import { ExtXform } from "./ext-xform.js";
 import { GraphicFrameXform } from "./graphic-frame-xform.js";
 import { PicXform } from "./pic-xform.js";
+import { ShapeXform } from "./shape-xform.js";
 import { StaticXform } from "../static-xform.js";
 /** https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML */
 const EMU_PER_PIXEL_AT_96_DPI = 9525;
@@ -70,6 +71,7 @@ class AbsoluteAnchorXform extends BaseCellAnchorXform {
             // `<xdr:absoluteAnchor><xdr:pos/><xdr:ext/><xdr:clientData/></xdr:absoluteAnchor>`
             // with no chart reference, so the anchor was ignored on open.
             "xdr:graphicFrame": new GraphicFrameXform(),
+            "xdr:userShape": new ShapeXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -94,6 +96,9 @@ class AbsoluteAnchorXform extends BaseCellAnchorXform {
         else if (model.graphicFrame) {
             this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
         }
+        else if (model.shape?.kind === "userShape") {
+            this.map["xdr:userShape"].render(xmlStream, model.shape);
+        }
         this.map["xdr:clientData"].render(xmlStream, {});
         xmlStream.closeNode();
     }

package/dist/browser/modules/excel/xlsx/xform/drawing/base-cell-anchor-xform.js

@@ -47,8 +47,25 @@ class BaseCellAnchorXform extends BaseXform {
                 const name = match[1];
                 const mediaId = options.mediaIndex[name];
                 const medium = options.media[mediaId];
+                if (!medium) {
+                    return undefined;
+                }
+                // Resolve an SVG companion (asvg:svgBlip extension) back to its media
+                // index and record it on the raster media entry itself, so callers that
+                // look the image up by id (e.g. Workbook.getImage) surface the vector
+                // companion alongside the raster fallback.
+                if (model.svgRId) {
+                    const svgRel = options.rels[model.svgRId];
+                    const svgMatch = svgRel && svgRel.Target.match(/.*\/media\/(.+[.][a-zA-Z]{3,4})/);
+                    if (svgMatch) {
+                        const svgMediaId = options.mediaIndex[svgMatch[1]];
+                        if (svgMediaId !== undefined) {
+                            medium.svgMediaId = svgMediaId;
+                        }
+                    }
+                }
                 // Preserve alphaModFix (transparency) from the picture model if present
-                if (medium && model.alphaModFix !== undefined) {
+                if (model.alphaModFix !== undefined) {
                     return { ...medium, alphaModFix: model.alphaModFix };
                 }
                 return medium;

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

@@ -8,6 +8,12 @@ interface BlipModel {
      * instead of an embedded one via `r:embed`.
      */
     external?: boolean;
+    /**
+     * Relationship id of an SVG companion. When set, the raster blip carries an
+     * `asvg:svgBlip` extension referencing the SVG media so Excel 2016+ renders
+     * the vector image while older consumers fall back to the raster blip.
+     */
+    svgRId?: string;
 }
 declare class BlipXform extends BaseXform<BlipModel> {
     constructor();

package/dist/browser/modules/excel/xlsx/xform/drawing/blip-xform.js

@@ -1,4 +1,9 @@
 import { BaseXform } from "../base-xform.js";
+/** OOXML extension URI for the SVG blip (Office 2016 SVG feature). */
+const SVG_BLIP_EXT_URI = "{96DAC541-7B7A-43D3-8B79-37D633B846F1}";
+/** Namespace for the asvg:svgBlip element. */
+const SVG_BLIP_NS = "http://schemas.microsoft.com/office/drawing/2016/SVG/main";
+const REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
 class BlipXform extends BaseXform {
     constructor() {
         super();
@@ -10,23 +15,37 @@ class BlipXform extends BaseXform {
     render(xmlStream, model) {
         // External (linked) images use `r:link`; embedded images use `r:embed`.
         const relAttr = model.external ? "r:link" : "r:embed";
-        if (model.alphaModFix !== undefined && model.alphaModFix < 100000) {
-            // Render as open/close node with a:alphaModFix child
-            xmlStream.openNode(this.tag, {
-                "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+        const hasAlpha = model.alphaModFix !== undefined && model.alphaModFix < 100000;
+        const hasSvg = model.svgRId !== undefined;
+        // A bare blip can be a leaf node; an alpha modulation or an SVG extension
+        // both require child elements, so switch to the open/close form.
+        if (!hasAlpha && !hasSvg) {
+            xmlStream.leafNode(this.tag, {
+                "xmlns:r": REL_NS,
                 [relAttr]: model.rId,
                 cstate: "print"
             });
+            return;
+        }
+        xmlStream.openNode(this.tag, {
+            "xmlns:r": REL_NS,
+            [relAttr]: model.rId,
+            cstate: "print"
+        });
+        if (hasAlpha) {
             xmlStream.leafNode("a:alphaModFix", { amt: String(model.alphaModFix) });
-            xmlStream.closeNode();
         }
-        else {
-            xmlStream.leafNode(this.tag, {
-                "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
-                [relAttr]: model.rId,
-                cstate: "print"
+        if (hasSvg) {
+            xmlStream.openNode("a:extLst");
+            xmlStream.openNode("a:ext", { uri: SVG_BLIP_EXT_URI });
+            xmlStream.leafNode("asvg:svgBlip", {
+                "xmlns:asvg": SVG_BLIP_NS,
+                "r:embed": model.svgRId
             });
+            xmlStream.closeNode(); // a:ext
+            xmlStream.closeNode(); // a:extLst
         }
+        xmlStream.closeNode(); // a:blip
     }
     parseOpen(node) {
         switch (node.name) {
@@ -46,6 +65,14 @@ class BlipXform extends BaseXform {
                     this.model.alphaModFix = parseInt(node.attributes.amt, 10);
                 }
                 return true;
+            case "asvg:svgBlip": {
+                // Capture the SVG companion's relationship id for round-trip.
+                const embed = node.attributes["r:embed"];
+                if (embed !== undefined && this.model) {
+                    this.model.svgRId = embed;
+                }
+                return true;
+            }
             default:
                 return true;
         }
@@ -56,7 +83,7 @@ class BlipXform extends BaseXform {
             case this.tag:
                 return false;
             default:
-                // unprocessed internal nodes
+                // unprocessed internal nodes (a:extLst / a:ext / alphaModFix)
                 return true;
         }
     }

package/dist/browser/modules/excel/xlsx/xform/drawing/one-cell-anchor-xform.d.ts

@@ -6,6 +6,7 @@ interface OneCellModel {
         ext: any;
     };
     picture?: any;
+    shape?: any;
     /** Graphic frame model (for charts and other embedded objects) */
     graphicFrame?: any;
 }

package/dist/browser/modules/excel/xlsx/xform/drawing/one-cell-anchor-xform.js

@@ -3,6 +3,7 @@ import { CellPositionXform } from "./cell-position-xform.js";
 import { ExtXform } from "./ext-xform.js";
 import { GraphicFrameXform } from "./graphic-frame-xform.js";
 import { PicXform } from "./pic-xform.js";
+import { ShapeXform } from "./shape-xform.js";
 import { StaticXform } from "../static-xform.js";
 class OneCellAnchorXform extends BaseCellAnchorXform {
     constructor() {
@@ -11,6 +12,7 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
             "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
             "xdr:ext": new ExtXform({ tag: "xdr:ext" }),
             "xdr:pic": new PicXform(),
+            "xdr:userShape": new ShapeXform(),
             "xdr:graphicFrame": new GraphicFrameXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
@@ -36,6 +38,9 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
         else if (model.graphicFrame) {
             this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
         }
+        else if (model.shape?.kind === "userShape") {
+            this.map["xdr:userShape"].render(xmlStream, model.shape);
+        }
         this.map["xdr:clientData"].render(xmlStream, {});
         xmlStream.closeNode();
     }

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

@@ -6,6 +6,8 @@ interface PicModel {
     alphaModFix?: number;
     /** When true, render the picture as an external linked image (`r:link`). */
     external?: boolean;
+    /** Relationship id of an SVG companion (asvg:svgBlip extension). */
+    svgRId?: string;
     [key: string]: any;
 }
 declare class PicXform extends BaseXform {

package/dist/browser/modules/excel/xlsx/xform/drawing/pic-xform.js

@@ -25,7 +25,8 @@ class PicXform extends BaseXform {
         this.map["xdr:blipFill"].render(xmlStream, {
             rId: model.rId,
             alphaModFix: model.alphaModFix,
-            external: model.external
+            external: model.external,
+            svgRId: model.svgRId
         });
         this.map["xdr:spPr"].render(xmlStream, model);
         xmlStream.closeNode();

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

@@ -0,0 +1,47 @@
+import { BaseXform } from "../base-xform.js";
+/** Fill specification for a drawing shape. */
+export interface ShapeFill {
+    /** Solid fill colour as a hex RGB string (e.g. "FF0000"). Omit for no fill. */
+    color?: string;
+}
+/** Line (outline) specification for a drawing shape. */
+export interface ShapeLine {
+    /** Line colour as a hex RGB string (e.g. "000000"). */
+    color?: string;
+    /** Line width in points. */
+    width?: number;
+}
+/**
+ * Model for a user-visible drawing shape (`<xdr:sp>`).
+ *
+ * Distinct from the form-control shape rendered by `SpXform` — this one is
+ * visible, carries a configurable preset geometry, solid fill, outline and an
+ * optional text label, and is NOT wrapped in an `a14` AlternateContent block.
+ */
+export interface ShapeRenderModel {
+    /** Marks this as a user shape so the anchor routes to ShapeXform. */
+    kind: "userShape";
+    /** Unique drawing id. */
+    cNvPrId: number;
+    /** Display name (e.g. "Rectangle 1"). */
+    name: string;
+    /** Preset geometry name (e.g. "rect", "ellipse", "line", "roundRect"). */
+    shapeType: string;
+    fill?: ShapeFill;
+    line?: ShapeLine;
+    /** Optional text label centred in the shape. */
+    text?: string;
+}
+/**
+ * Renders a user-visible drawing shape. Geometry/position is governed by the
+ * enclosing anchor (`xfrm` is written as zero, matching how Excel anchors a
+ * shape to a cell range), while preset geometry, fill, outline and text are
+ * taken from the model. Write-only: shapes are not parsed back on read (the
+ * same limitation that already applies to all non-chart drawing content).
+ */
+declare class ShapeXform extends BaseXform {
+    model: ShapeRenderModel;
+    get tag(): string;
+    render(xmlStream: any, model: ShapeRenderModel): void;
+}
+export { ShapeXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/shape-xform.js

@@ -0,0 +1,109 @@
+import { BaseXform } from "../base-xform.js";
+const EMU_PER_POINT = 12700;
+/**
+ * Normalize a user-supplied colour to the bare 6-digit RGB hex that OOXML's
+ * `<a:srgbClr val="...">` requires:
+ * - strips a leading `#`
+ * - accepts 8-digit ARGB (the form excelts uses for cell fills) and drops the
+ *   leading alpha byte, since `srgbClr` carries no alpha channel
+ * - upper-cases
+ *
+ * Anything that isn't a 6- or 8-digit hex string is passed through unchanged so
+ * a caller using a less common form is not silently broken.
+ */
+function normalizeColor(color) {
+    const hex = color.startsWith("#") ? color.slice(1) : color;
+    if (/^[0-9a-fA-F]{8}$/.test(hex)) {
+        // ARGB → RGB: drop the alpha byte (srgbClr has no alpha component).
+        return hex.slice(2).toUpperCase();
+    }
+    if (/^[0-9a-fA-F]{6}$/.test(hex)) {
+        return hex.toUpperCase();
+    }
+    return hex;
+}
+/**
+ * Renders a user-visible drawing shape. Geometry/position is governed by the
+ * enclosing anchor (`xfrm` is written as zero, matching how Excel anchors a
+ * shape to a cell range), while preset geometry, fill, outline and text are
+ * taken from the model. Write-only: shapes are not parsed back on read (the
+ * same limitation that already applies to all non-chart drawing content).
+ */
+class ShapeXform extends BaseXform {
+    get tag() {
+        return "xdr:sp";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode("xdr:sp", { macro: "", textlink: "" });
+        // --- Non-visual shape properties ---
+        xmlStream.openNode("xdr:nvSpPr");
+        xmlStream.leafNode("xdr:cNvPr", { id: model.cNvPrId, name: model.name });
+        xmlStream.leafNode("xdr:cNvSpPr", {});
+        xmlStream.closeNode(); // xdr:nvSpPr
+        // --- Shape properties ---
+        xmlStream.openNode("xdr:spPr");
+        // Position/size is driven by the anchor; emit a zero xfrm placeholder.
+        xmlStream.openNode("a:xfrm");
+        xmlStream.leafNode("a:off", { x: 0, y: 0 });
+        xmlStream.leafNode("a:ext", { cx: 0, cy: 0 });
+        xmlStream.closeNode(); // a:xfrm
+        xmlStream.openNode("a:prstGeom", { prst: model.shapeType });
+        xmlStream.leafNode("a:avLst");
+        xmlStream.closeNode(); // a:prstGeom
+        // Fill: a colour produces a solidFill, otherwise an explicit noFill.
+        if (model.fill && model.fill.color) {
+            xmlStream.openNode("a:solidFill");
+            xmlStream.leafNode("a:srgbClr", { val: normalizeColor(model.fill.color) });
+            xmlStream.closeNode(); // a:solidFill
+        }
+        else {
+            xmlStream.leafNode("a:noFill");
+        }
+        // Line: an `a:ln` with width (pt → EMU) and/or a solid colour. When width
+        // is given without a colour, Excel applies its default outline colour at
+        // that width. When neither colour nor width is supplied, emit an explicit
+        // noFill line (no visible outline).
+        if (model.line && (model.line.color || model.line.width !== undefined)) {
+            const lnAttrs = {};
+            if (model.line.width !== undefined) {
+                lnAttrs.w = Math.round(model.line.width * EMU_PER_POINT);
+            }
+            xmlStream.openNode("a:ln", lnAttrs);
+            if (model.line.color) {
+                xmlStream.openNode("a:solidFill");
+                xmlStream.leafNode("a:srgbClr", { val: normalizeColor(model.line.color) });
+                xmlStream.closeNode(); // a:solidFill
+            }
+            xmlStream.closeNode(); // a:ln
+        }
+        else {
+            xmlStream.openNode("a:ln");
+            xmlStream.leafNode("a:noFill");
+            xmlStream.closeNode(); // a:ln
+        }
+        xmlStream.closeNode(); // xdr:spPr
+        // --- Text body ---
+        xmlStream.openNode("xdr:txBody");
+        xmlStream.leafNode("a:bodyPr", { vertOverflow: "clip", wrap: "square", anchor: "ctr" });
+        xmlStream.leafNode("a:lstStyle");
+        xmlStream.openNode("a:p");
+        xmlStream.openNode("a:pPr", { algn: "ctr" });
+        xmlStream.closeNode(); // a:pPr
+        if (model.text) {
+            xmlStream.openNode("a:r");
+            xmlStream.openNode("a:rPr", { lang: "en-US" });
+            xmlStream.closeNode(); // a:rPr
+            xmlStream.openNode("a:t");
+            xmlStream.writeText(model.text);
+            xmlStream.closeNode(); // a:t
+            xmlStream.closeNode(); // a:r
+        }
+        else {
+            xmlStream.leafNode("a:endParaRPr", { lang: "en-US" });
+        }
+        xmlStream.closeNode(); // a:p
+        xmlStream.closeNode(); // xdr:txBody
+        xmlStream.closeNode(); // xdr:sp
+    }
+}
+export { ShapeXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/two-cell-anchor-xform.js

@@ -2,6 +2,7 @@ import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
 import { CellPositionXform } from "./cell-position-xform.js";
 import { GraphicFrameXform } from "./graphic-frame-xform.js";
 import { PicXform } from "./pic-xform.js";
+import { ShapeXform } from "./shape-xform.js";
 import { SpXform } from "./sp-xform.js";
 import { StaticXform } from "../static-xform.js";
 class TwoCellAnchorXform extends BaseCellAnchorXform {
@@ -24,6 +25,7 @@ class TwoCellAnchorXform extends BaseCellAnchorXform {
             "xdr:to": new CellPositionXform({ tag: "xdr:to" }),
             "xdr:pic": new PicXform(),
             "xdr:sp": new SpXform(),
+            "xdr:userShape": new ShapeXform(),
             "xdr:graphicFrame": new GraphicFrameXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
@@ -125,7 +127,14 @@ class TwoCellAnchorXform extends BaseCellAnchorXform {
             this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
         }
         else if (model.shape) {
-            this.map["xdr:sp"].render(xmlStream, model.shape);
+            // A user-visible shape routes to the dedicated ShapeXform; the legacy
+            // form-control shape (no `kind`) stays on the SpXform path.
+            if (model.shape.kind === "userShape") {
+                this.map["xdr:userShape"].render(xmlStream, model.shape);
+            }
+            else {
+                this.map["xdr:sp"].render(xmlStream, model.shape);
+            }
         }
         this.map["xdr:clientData"].render(xmlStream, {});
         xmlStream.closeNode(); // xdr:twoCellAnchor

package/dist/browser/modules/excel/xlsx/xform/sheet/worksheet-xform.js

@@ -498,7 +498,70 @@ class WorkSheetXform extends BaseXform {
                 });
             }
         }
-        // Handle header watermark images — VML header/footer image
+        // Handle user-drawn shapes — anchored drawing parts with no media/rel.
+        const shapes = model.shapes ?? [];
+        if (shapes.length > 0) {
+            let { drawing } = model;
+            if (!drawing) {
+                drawing = model.drawing = {
+                    rId: nextRid(rels),
+                    name: `drawing${++options.drawingsCount}`,
+                    anchors: [],
+                    rels: []
+                };
+                options.drawings.push(drawing);
+                rels.push({
+                    Id: drawing.rId,
+                    Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+                    Target: drawingRelTargetFromWorksheet(drawing.name)
+                });
+            }
+            for (const shape of shapes) {
+                const anchorRange = shape.anchorRange;
+                if (!anchorRange) {
+                    continue;
+                }
+                // Mirror the three image anchoring modes. `getAnchorType` (drawing
+                // xform) dispatches on `pos`/`br`: absolute when `pos` is present,
+                // two-cell when `br` is present, one-cell otherwise (needs `ext`).
+                let range;
+                if (anchorRange.pos) {
+                    range = { pos: anchorRange.pos, ext: anchorRange.ext, editAs: "absolute" };
+                }
+                else if (anchorRange.br) {
+                    range = {
+                        tl: anchorRange.tl,
+                        br: anchorRange.br,
+                        editAs: anchorRange.editAs ?? "oneCell"
+                    };
+                }
+                else {
+                    range = {
+                        tl: anchorRange.tl,
+                        ext: anchorRange.ext,
+                        editAs: anchorRange.editAs ?? "oneCell"
+                    };
+                }
+                // Allocate a cNvPr id from the same monotonic space as the anchor's
+                // position in the drawing so it never collides with image/chart ids
+                // (which derive from the anchor index).
+                const cNvPrId = drawing.anchors.length + 1;
+                drawing.anchors.push({
+                    range,
+                    shape: {
+                        kind: "userShape",
+                        cNvPrId,
+                        name: shape.name ?? `Shape ${cNvPrId}`,
+                        shapeType: shape.shapeType,
+                        fill: shape.fillColor ? { color: shape.fillColor } : undefined,
+                        line: shape.lineColor !== undefined || shape.lineWidth !== undefined
+                            ? { color: shape.lineColor, width: shape.lineWidth }
+                            : undefined,
+                        text: shape.text
+                    }
+                });
+            }
+        }
         if (headerImageMedia.length > 0) {
             const medium = headerImageMedia[0]; // Only one header image per sheet
             const bookImage = options.media[medium.imageId];

package/dist/browser/modules/pdf/builder/document-builder.js

@@ -26,7 +26,7 @@ import { writePdfAMetadata, writePdfAOutputIntent } from "../core/pdfa.js";
 import { FontManager } from "../font/font-manager.js";
 import { iterateSystemFontCandidates } from "../font/system-fonts.js";
 import { parseTtf } from "../font/ttf-parser.js";
-import { wrapTextLines, emitTextWithMatrix, alphaGsName } from "../render/page-renderer.js";
+import { emitTextBlock, alphaGsName } from "../render/page-renderer.js";
 import { writeImageXObject } from "./image-utils.js";
 // =============================================================================
 // Constants
@@ -95,56 +95,29 @@ export class PdfPageBuilder {
         const bold = options.bold ?? false;
         const italic = options.italic ?? false;
         const fontFamily = options.fontFamily ?? "Helvetica";
-        // Resolve font
+        // Resolve the provisional Type1 resource and record the run's code
+        // points. The text is emitted as a deferred block so anchor alignment,
+        // word wrapping, and glyph encoding are all computed at build time —
+        // after fonts are finalised (a non-WinAnsi run may trigger a build-time
+        // auto-embed of a system CIDFont). Measuring against the provisional
+        // metrics here would misplace anchored text and break lines wrongly.
         const resourceName = this._fontManager.resolveFont(fontFamily, bold, italic);
         this._fontManager.trackText(text);
-        const useType3 = this._fontManager.hasType3Fonts() && !this._fontManager.hasEmbeddedFont();
-        // Resolve anchor into an adjusted x before any matrix math. We use the
-        // same font/size combination the stream will render with, so the
-        // alignment is correct for the actual glyphs (not a fallback
-        // estimate). Single-line drawing only — wrapped text ignores anchor
-        // because the wrapper re-splits by the caller's supplied x.
-        const anchor = options.anchor ?? "start";
-        const resolvedX = anchor === "start" || options.maxWidth
-            ? options.x
-            : options.x -
-                this._fontManager.measureText(text, resourceName, fontSize) *
-                    (anchor === "middle" ? 0.5 : 1);
-        if (options.maxWidth) {
-            // Word-wrap (reuses the shared wrapTextLines from page-renderer)
-            const measure = (s) => this._fontManager.measureText(s, resourceName, fontSize);
-            const lines = wrapTextLines(text, measure, options.maxWidth);
-            const leading = fontSize * lineHeightFactor;
-            this._stream.save();
-            this._applyAlpha(color.a);
-            this._stream.setFillColor(color);
-            for (let i = 0; i < lines.length; i++) {
-                const lineY = options.y - i * leading;
-                emitTextWithMatrix(this._stream, lines[i], 1, 0, 0, 1, options.x, lineY, resourceName, fontSize, this._fontManager, useType3);
-            }
-            this._stream.restore();
-        }
-        else {
-            // Single line
-            this._stream.save();
-            this._applyAlpha(color.a);
-            this._stream.setFillColor(color);
-            const rotation = options.rotation ?? 0;
-            if (rotation === 0) {
-                emitTextWithMatrix(this._stream, text, 1, 0, 0, 1, resolvedX, options.y, resourceName, fontSize, this._fontManager, useType3);
-            }
-            else {
-                // Build the rotation matrix around (x, y). `emitTextWithMatrix`
-                // accepts the full 2×3 text matrix, so we pre-multiply the
-                // rotation with the translation so one call positions and
-                // rotates the glyph sequence in a single Tm op.
-                const theta = (rotation * Math.PI) / 180;
-                const cos = Math.cos(theta);
-                const sin = Math.sin(theta);
-                emitTextWithMatrix(this._stream, text, cos, sin, -sin, cos, resolvedX, options.y, resourceName, fontSize, this._fontManager, useType3);
-            }
-            this._stream.restore();
-        }
+        this._stream.save();
+        this._applyAlpha(color.a);
+        this._stream.setFillColor(color);
+        emitTextBlock(this._stream, {
+            text,
+            x: options.x,
+            y: options.y,
+            type1ResourceName: resourceName,
+            fontSize,
+            anchor: options.anchor ?? "start",
+            maxWidth: options.maxWidth,
+            lineHeightFactor,
+            rotation: options.rotation ?? 0
+        }, this._fontManager);
+        this._stream.restore();
         return this;
     }
     /**