@cj-tech-master/excelts 9.6.1 → 10.0.0

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

@@ -6,6 +6,7 @@ const base_cell_anchor_xform_1 = require("./base-cell-anchor-xform.js");
 const ext_xform_1 = require("./ext-xform.js");
 const graphic_frame_xform_1 = require("./graphic-frame-xform.js");
 const pic_xform_1 = require("./pic-xform.js");
+const shape_xform_1 = require("./shape-xform.js");
 const static_xform_1 = require("../static-xform.js");
 /** https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML */
 const EMU_PER_PIXEL_AT_96_DPI = 9525;
@@ -73,6 +74,7 @@ class AbsoluteAnchorXform extends base_cell_anchor_xform_1.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 graphic_frame_xform_1.GraphicFrameXform(),
+            "xdr:userShape": new shape_xform_1.ShapeXform(),
             "xdr:clientData": new static_xform_1.StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -97,6 +99,9 @@ class AbsoluteAnchorXform extends base_cell_anchor_xform_1.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/cjs/modules/excel/xlsx/xform/drawing/base-cell-anchor-xform.js

@@ -50,8 +50,25 @@ class BaseCellAnchorXform extends base_xform_1.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/cjs/modules/excel/xlsx/xform/drawing/blip-xform.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlipXform = void 0;
 const base_xform_1 = require("../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 base_xform_1.BaseXform {
     constructor() {
         super();
@@ -13,23 +18,37 @@ class BlipXform extends base_xform_1.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) {
@@ -49,6 +68,14 @@ class BlipXform extends base_xform_1.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;
         }
@@ -59,7 +86,7 @@ class BlipXform extends base_xform_1.BaseXform {
             case this.tag:
                 return false;
             default:
-                // unprocessed internal nodes
+                // unprocessed internal nodes (a:extLst / a:ext / alphaModFix)
                 return true;
         }
     }

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

@@ -6,6 +6,7 @@ const cell_position_xform_1 = require("./cell-position-xform.js");
 const ext_xform_1 = require("./ext-xform.js");
 const graphic_frame_xform_1 = require("./graphic-frame-xform.js");
 const pic_xform_1 = require("./pic-xform.js");
+const shape_xform_1 = require("./shape-xform.js");
 const static_xform_1 = require("../static-xform.js");
 class OneCellAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
     constructor() {
@@ -14,6 +15,7 @@ class OneCellAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
             "xdr:from": new cell_position_xform_1.CellPositionXform({ tag: "xdr:from" }),
             "xdr:ext": new ext_xform_1.ExtXform({ tag: "xdr:ext" }),
             "xdr:pic": new pic_xform_1.PicXform(),
+            "xdr:userShape": new shape_xform_1.ShapeXform(),
             "xdr:graphicFrame": new graphic_frame_xform_1.GraphicFrameXform(),
             "xdr:clientData": new static_xform_1.StaticXform({ tag: "xdr:clientData" })
         };
@@ -39,6 +41,9 @@ class OneCellAnchorXform extends base_cell_anchor_xform_1.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/cjs/modules/excel/xlsx/xform/drawing/pic-xform.js

@@ -28,7 +28,8 @@ class PicXform extends base_xform_1.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/cjs/modules/excel/xlsx/xform/drawing/shape-xform.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShapeXform = void 0;
+const base_xform_1 = require("../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 base_xform_1.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
+    }
+}
+exports.ShapeXform = ShapeXform;

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

@@ -5,6 +5,7 @@ const base_cell_anchor_xform_1 = require("./base-cell-anchor-xform.js");
 const cell_position_xform_1 = require("./cell-position-xform.js");
 const graphic_frame_xform_1 = require("./graphic-frame-xform.js");
 const pic_xform_1 = require("./pic-xform.js");
+const shape_xform_1 = require("./shape-xform.js");
 const sp_xform_1 = require("./sp-xform.js");
 const static_xform_1 = require("../static-xform.js");
 class TwoCellAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
@@ -27,6 +28,7 @@ class TwoCellAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
             "xdr:to": new cell_position_xform_1.CellPositionXform({ tag: "xdr:to" }),
             "xdr:pic": new pic_xform_1.PicXform(),
             "xdr:sp": new sp_xform_1.SpXform(),
+            "xdr:userShape": new shape_xform_1.ShapeXform(),
             "xdr:graphicFrame": new graphic_frame_xform_1.GraphicFrameXform(),
             "xdr:clientData": new static_xform_1.StaticXform({ tag: "xdr:clientData" })
         };
@@ -128,7 +130,14 @@ class TwoCellAnchorXform extends base_cell_anchor_xform_1.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/cjs/modules/excel/xlsx/xform/sheet/worksheet-xform.js

@@ -501,7 +501,70 @@ class WorkSheetXform extends base_xform_1.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: (0, ooxml_paths_1.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/cjs/modules/pdf/builder/document-builder.js

@@ -132,56 +132,29 @@ 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 = (0, page_renderer_1.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;
-                (0, page_renderer_1.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) {
-                (0, page_renderer_1.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);
-                (0, page_renderer_1.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);
+        (0, page_renderer_1.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;
     }
     /**

package/dist/cjs/modules/pdf/builder/pdf-editor.js

@@ -180,7 +180,7 @@ class PdfEditorPage {
     }
     /** @internal */
     _hasOverlay() {
-        return (this._overlay._stream.toString().length > 0 ||
+        return (this._overlay._stream.hasContent() ||
             this._overlay._images.length > 0 ||
             this._overlay._builderAnnotations.length > 0 ||
             this._overlay._formFields.length > 0);

package/dist/cjs/modules/pdf/core/pdf-stream.js

@@ -28,6 +28,16 @@ const pdf_object_1 = require("./pdf-object");
  */
 class PdfContentStream {
     constructor() {
+        /**
+         * Content stream fragments in draw order. Most entries are plain operator
+         * strings produced eagerly. A function entry is a *deferred* fragment:
+         * its body is only evaluated at serialization time. This is required for
+         * text whose final byte encoding depends on font decisions (embedded
+         * CIDFont vs. Type1/WinAnsi vs. Type3 fallback) that are not finalised
+         * until `PdfDocumentBuilder.build()`. Deferring keeps the fragment at its
+         * exact draw-order position (preserving z-order) while letting the actual
+         * encoding run after the font manager's state is settled.
+         */
         this.parts = [];
     }
     // ===========================================================================
@@ -41,6 +51,17 @@ class PdfContentStream {
         this.parts.push(operator);
         return this;
     }
+    /**
+     * Append a deferred fragment whose body is evaluated only at serialization
+     * time. Used by text drawing so the final byte encoding can be chosen after
+     * the document's fonts are resolved at build time. The fragment occupies its
+     * draw-order slot immediately, so z-order relative to other operators is
+     * preserved.
+     */
+    deferred(produce) {
+        this.parts.push(produce);
+        return this;
+    }
     // ===========================================================================
     // Graphics State
     // ===========================================================================
@@ -440,10 +461,25 @@ class PdfContentStream {
     // Serialization
     // ===========================================================================
     /**
-     * Get the content stream as a string.
+     * Whether any fragment has been appended. Unlike `toString().length > 0`,
+     * this does NOT evaluate deferred fragments, so it is safe to call before
+     * fonts are resolved (e.g. when probing for overlay content during an
+     * editor save, prior to `writeFontResources`). A deferred text fragment
+     * counts as content even though its bytes are not produced yet.
+     */
+    hasContent() {
+        return this.parts.length > 0;
+    }
+    /**
+     * Get the content stream as a string. Deferred fragments (see `deferred`)
+     * are evaluated here, after font resolution has completed at build time.
      */
     toString() {
-        return this.parts.join("\n");
+        const out = [];
+        for (const part of this.parts) {
+            out.push(typeof part === "function" ? part() : part);
+        }
+        return out.join("\n");
     }
     /**
      * Get the content stream as a Uint8Array (UTF-8 encoded).

package/dist/cjs/modules/pdf/font/font-manager.js

@@ -186,30 +186,47 @@ class FontManager {
     getEmbeddedResourceName() {
         return this.embeddedResourceName;
     }
+    /**
+     * Resolve the resource name a draw-time-resolved Type1 resource should
+     * actually render (and be measured) with, given the font manager's
+     * *current* state. If an embedded font exists (possibly auto-discovered
+     * at build time, after the text was drawn against a Type1 resource), the
+     * embedded resource name is returned so both measurement and encoding go
+     * through the CIDFont. Otherwise the original Type1 resource name is kept;
+     * `measureText` handles Type3-fallback widths internally from that name.
+     *
+     * Centralises the routing rule shared by the deferred text renderer and
+     * any deferred measurement (anchor alignment, word wrapping) so the two
+     * never disagree.
+     */
+    resolveRenderResourceName(type1ResourceName) {
+        return this.embeddedFont ? this.embeddedResourceName : type1ResourceName;
+    }
     /**
      * Record that a text string will be rendered, tracking its code points.
      * Must be called for every text string before writing the PDF.
+     *
+     * Two sets are maintained because font selection may be decided *after*
+     * drawing (e.g. `PdfDocumentBuilder.build()` auto-discovers and embeds a
+     * system font once it sees the accumulated non-WinAnsi code points):
+     *
+     *   - `usedCodePoints` — every code point seen, always. If an embedded
+     *     font ends up being used (whether registered up front or
+     *     auto-discovered at build time), the subset must cover all of these,
+     *     including plain ASCII, so the CIDFont can encode the full run.
+     *   - `type3CodePoints` — non-WinAnsi code points only. Drives the
+     *     build-time decision to auto-embed a system font, and the Type3
+     *     fallback when none is available.
      */
     trackText(text) {
-        if (this.embeddedFont) {
-            for (let i = 0; i < text.length; i++) {
-                const cp = text.codePointAt(i);
-                this.usedCodePoints.add(cp);
-                if (cp > 0xffff) {
-                    i++; // skip low surrogate
-                }
+        for (let i = 0; i < text.length; i++) {
+            const cp = text.codePointAt(i);
+            if (cp > 0xffff) {
+                i++; // skip low surrogate
             }
-        }
-        else {
-            // No embedded font — track non-WinAnsi chars for Type3 fallback
-            for (let i = 0; i < text.length; i++) {
-                const cp = text.codePointAt(i);
-                if (cp > 0xffff) {
-                    i++;
-                }
-                if (!(0, pdf_stream_1.isWinAnsiCodePoint)(cp)) {
-                    this.type3CodePoints.add(cp);
-                }
+            this.usedCodePoints.add(cp);
+            if (!(0, pdf_stream_1.isWinAnsiCodePoint)(cp)) {
+                this.type3CodePoints.add(cp);
             }
         }
     }