@jasy/pdf 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/renderer/pdf-backend.js

@@ -1,6 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PdfBackend = void 0;
+import { isRounded } from "../ir/display-list.js";
+import { Color } from "../common/color.js";
 /**
  * PDF backend - turns display-list primitives into content-stream operators.
  *
@@ -9,7 +8,7 @@ exports.PdfBackend = void 0;
  * emitted inline by the per-element renderers, so output stays byte-identical while
  * the renderers are migrated onto the IR one at a time.
  */
-class PdfBackend {
+export class PdfBackend {
     /**
      * Flip a display list from the engine's top-left origin (y grows downward) to PDF's
      * bottom-left origin (y grows upward). This is the ONE place the Y axis is flipped -
@@ -20,21 +19,80 @@ class PdfBackend {
     static flipY(nodes, pageHeight) {
         return nodes.map((node) => {
             switch (node.type) {
-                case "rect":
-                    return Object.assign(Object.assign({}, node), { y: pageHeight - node.y - node.height });
+                case "rect": {
+                    // A gradient fill carries its own page-space anchors; flip them with the box (see "path").
+                    const fill = node.fill === undefined || node.fill instanceof Color
+                        ? node.fill
+                        : { ...node.fill, y0: pageHeight - node.fill.y0, y1: pageHeight - node.fill.y1 };
+                    return { ...node, y: pageHeight - node.y - node.height, fill };
+                }
                 case "line":
-                    return Object.assign(Object.assign({}, node), { y1: pageHeight - node.y1, y2: pageHeight - node.y2 });
+                    return {
+                        ...node,
+                        y1: pageHeight - node.y1,
+                        y2: pageHeight - node.y2,
+                    };
                 case "text":
                     // node.y is the baseline measured from the page top; flip it directly.
-                    return Object.assign(Object.assign({}, node), { y: pageHeight - node.y });
+                    return { ...node, y: pageHeight - node.y };
                 case "image": {
                     // Flip the placement box (and the clip frame, if any) around its bottom edge.
-                    const flipped = Object.assign(Object.assign({}, node), { y: pageHeight - node.y - node.height });
+                    const flipped = { ...node, y: pageHeight - node.y - node.height };
                     if (node.clip) {
-                        flipped.clip = Object.assign(Object.assign({}, node.clip), { y: pageHeight - node.clip.y - node.clip.height });
+                        flipped.clip = {
+                            ...node.clip,
+                            y: pageHeight - node.clip.y - node.clip.height,
+                        };
                     }
                     return flipped;
                 }
+                case "clip-push":
+                    // Flip the clip rect around its bottom edge, like a rect.
+                    return { ...node, y: pageHeight - node.y - node.height };
+                case "clip-pop":
+                    return node;
+                case "path": {
+                    // Flip every point's y directly (like a line endpoint); `z` carries no coordinates.
+                    const commands = node.commands.map((c) => {
+                        if (c.op === "z")
+                            return c;
+                        if (c.op === "c") {
+                            return { ...c, y1: pageHeight - c.y1, y2: pageHeight - c.y2, y: pageHeight - c.y };
+                        }
+                        return { ...c, y: pageHeight - c.y };
+                    });
+                    // A gradient fill carries its own page-space anchor points; flip their y too (radii and
+                    // x stay). A solid Color fill has no geometry.
+                    const fill = node.fill instanceof Color
+                        ? node.fill
+                        : { ...node.fill, y0: pageHeight - node.fill.y0, y1: pageHeight - node.fill.y1 };
+                    return { ...node, commands, fill };
+                }
+                case "link":
+                    // A link's clickable rect flips around its bottom edge, exactly like a rect.
+                    return { ...node, y: pageHeight - node.y - node.height };
+                case "formfield":
+                    // A form field's box flips around its bottom edge, exactly like a link rect.
+                    return { ...node, y: pageHeight - node.y - node.height };
+                case "outline":
+                    // An outline anchor is a single point (the target's top); flip it like a text baseline.
+                    return { ...node, y: pageHeight - node.y };
+                case "anchor":
+                    // A named-destination anchor is a single point (the target's top), flipped like a baseline.
+                    return { ...node, y: pageHeight - node.y };
+                case "transform-push": {
+                    // The child nodes are flipped from top-left to bottom-left by F = [1,0,0,-1,0,H] (F is its
+                    // own inverse). For a matrix authored in top-left space to act correctly on them, conjugate
+                    // it by that flip: M_pdf = F · M · F. Worked out for [a,b,c,d,e,f] with H = pageHeight:
+                    const [a, b, c, d, e, f] = node.matrix;
+                    const H = pageHeight;
+                    return {
+                        ...node,
+                        matrix: [a, -b, -c, d, H * c + e, H - H * d - f],
+                    };
+                }
+                case "transform-pop":
+                    return node; // no coordinates to flip
                 default: {
                     const unknown = node;
                     return unknown;
@@ -42,9 +100,59 @@ class PdfBackend {
             }
         });
     }
-    /** Serialize a whole display list into one content stream (page-level entry point). */
-    static serialize(nodes, om) {
-        return nodes.map((node) => PdfBackend.serializeNode(node, om)).join("");
+    /** Serialize a whole display list into one content stream (page-level entry point). When a
+     *  `PageStructContext` is given (accessible tagging on), each drawable node is wrapped in a marked-content
+     *  sequence (`/Role <</MCID n>> BDC … EMC`, or `/Artifact` when untagged); graphics-state and empty nodes
+     *  pass through untouched, so untagged output stays byte-identical. */
+    /**
+     * Every number reaching the backend must be finite. A non-finite coordinate is a layout bug, but
+     * silence turns it into a corrupt PDF: `Infinity` is written into the operator stream verbatim, and a
+     * viewer then discards everything from that point on - including the footer, which is drawn last. That
+     * failure is invisible until somebody opens the file, so we refuse instead.
+     *
+     * Checks the node's numbers, not the serialized text: a document containing the WORD "Infinity" is
+     * perfectly legal and must not trip this.
+     */
+    static assertFinite(node) {
+        const finite = (value) => {
+            if (typeof value === "number")
+                return Number.isFinite(value);
+            if (Array.isArray(value))
+                return value.every(finite);
+            if (value !== null && typeof value === "object")
+                return Object.values(value).every(finite);
+            return true;
+        };
+        if (!finite(node)) {
+            throw new Error(`Layout produced a non-finite number on a "${node.type}" node, refusing to emit a corrupt ` +
+                `content stream. This is a bug in an element's calculateLayout (a size resolved to Infinity ` +
+                `or NaN), not in your document.`);
+        }
+    }
+    static serialize(nodes, om, struct) {
+        return nodes
+            .map((node) => {
+            PdfBackend.assertFinite(node);
+            const ops = PdfBackend.serializeNode(node, om);
+            // Two kinds of node skip the marked-content wrapper, both because they carry no tag and never
+            // draw: GRAPHICS-STATE nodes (clip / transform push+pop) only save/restore state around the
+            // drawables they enclose, and SIDE-CHANNEL nodes (link, outline, anchor) become annotations /
+            // catalog entries instead of content-stream operators.
+            if (!struct ||
+                node.type === "clip-push" ||
+                node.type === "clip-pop" ||
+                node.type === "transform-push" ||
+                node.type === "transform-pop" ||
+                node.type === "link" ||
+                node.type === "outline" ||
+                node.type === "anchor" ||
+                node.type === "formfield" ||
+                ops === "")
+                return ops;
+            const { open, close } = struct.mark(node.tag);
+            return open + ops + close;
+        })
+            .join("");
     }
     /**
      * Escapes a string for a PDF literal string `( ... )`. The backslash must be doubled
@@ -54,6 +162,27 @@ class PdfBackend {
     static escapePdfString(text) {
         return text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
     }
+    /**
+     * Builds the `[ ... ]` operand of a `TJ` from a run and its per-gap kern adjustments (em/1000, the
+     * sign the font declares - negative tightens). A `TJ` number moves the pen LEFT, so it is the
+     * NEGATED kern. Consecutive un-kerned glyphs stay in one encoded chunk, so `[(T) 40 (otal)]` rather
+     * than one chunk per glyph. `kerns[i]` is the adjustment AFTER code point `i`.
+     */
+    static kernedArray(text, kerns, encode) {
+        const chars = [...text];
+        let out = "";
+        let chunk = chars[0] ?? "";
+        for (let i = 0; i < kerns.length; i++) {
+            if (kerns[i] === 0) {
+                chunk += chars[i + 1];
+            }
+            else {
+                out += encode(chunk) + ` ${-kerns[i]} `;
+                chunk = chars[i + 1];
+            }
+        }
+        return `[${out}${encode(chunk)}]`;
+    }
     /**
      * Returns the `/GSx gs` operator that selects a transparency state, or `""` when both
      * alphas are fully opaque. Opaque draws emit nothing here, so output stays
@@ -70,32 +199,50 @@ class PdfBackend {
      * (kappa ≈ 0.5523). Returns m/l/c/h ops WITHOUT the paint operator.
      */
     static roundedRectPath(x, y, w, h, radius) {
-        const r = Math.min(radius, w / 2, h / 2);
-        const c = r * 0.5523; // control-point offset that approximates a quarter circle
+        // Per corner, in PDF coordinates (y up). With all four equal this emits exactly the operators the
+        // single-radius version did - the byte-identity guard for every document that never asks for one.
+        const r = PdfBackend.clampRadii(radius, w, h);
+        const k = 0.5523; // control-point offset that approximates a quarter circle
         const f = (n) => n.toFixed(3);
-        const xr = x + r;
-        const xwr = x + w - r;
         const xw = x + w;
-        const yr = y + r;
-        const yhr = y + h - r;
         const yh = y + h;
-        return (`${f(xr)} ${f(y)} m\n` +
-            `${f(xwr)} ${f(y)} l\n` +
-            `${f(xwr + c)} ${f(y)} ${f(xw)} ${f(yr - c)} ${f(xw)} ${f(yr)} c\n` +
-            `${f(xw)} ${f(yhr)} l\n` +
-            `${f(xw)} ${f(yhr + c)} ${f(xwr + c)} ${f(yh)} ${f(xwr)} ${f(yh)} c\n` +
-            `${f(xr)} ${f(yh)} l\n` +
-            `${f(xr - c)} ${f(yh)} ${f(x)} ${f(yhr + c)} ${f(x)} ${f(yhr)} c\n` +
-            `${f(x)} ${f(yr)} l\n` +
-            `${f(x)} ${f(yr - c)} ${f(xr - c)} ${f(y)} ${f(xr)} ${f(y)} c\n` +
+        return (`${f(x + r.bl)} ${f(y)} m\n` +
+            `${f(xw - r.br)} ${f(y)} l\n` +
+            `${f(xw - r.br + r.br * k)} ${f(y)} ${f(xw)} ${f(y + r.br - r.br * k)} ${f(xw)} ${f(y + r.br)} c\n` +
+            `${f(xw)} ${f(yh - r.tr)} l\n` +
+            `${f(xw)} ${f(yh - r.tr + r.tr * k)} ${f(xw - r.tr + r.tr * k)} ${f(yh)} ${f(xw - r.tr)} ${f(yh)} c\n` +
+            `${f(x + r.tl)} ${f(yh)} l\n` +
+            `${f(x + r.tl - r.tl * k)} ${f(yh)} ${f(x)} ${f(yh - r.tl + r.tl * k)} ${f(x)} ${f(yh - r.tl)} c\n` +
+            `${f(x)} ${f(y + r.bl)} l\n` +
+            `${f(x)} ${f(y + r.bl - r.bl * k)} ${f(x + r.bl - r.bl * k)} ${f(y)} ${f(x + r.bl)} ${f(y)} c\n` +
             `h`);
     }
+    /**
+     * Clamp the four radii into the box. Each is capped at half the box, and two radii sharing an edge
+     * are scaled down together when they would overlap - the CSS rule, and what keeps the path from
+     * folding back on itself.
+     */
+    static clampRadii(radius, w, h) {
+        const n = typeof radius === "number" ? radius : 0;
+        const cap = Math.max(0, Math.min(w, h) / 2);
+        const at = (v) => Math.max(0, Math.min(v ?? n, cap));
+        const r = typeof radius === "number"
+            ? { tl: at(radius), tr: at(radius), br: at(radius), bl: at(radius) }
+            : { tl: at(radius.tl), tr: at(radius.tr), br: at(radius.br), bl: at(radius.bl) };
+        // Per-edge overlap: scale the whole set by the tightest edge, so the corners stay proportional.
+        // An edge whose two corners are both 0 constrains NOTHING - it must not contribute a ratio of 0,
+        // which would scale every other corner away with it.
+        const ratio = (extent, a, b) => a + b > 0 ? extent / (a + b) : Infinity;
+        const scale = Math.min(1, ratio(w, r.tl, r.tr), ratio(w, r.bl, r.br), ratio(h, r.tl, r.bl), ratio(h, r.tr, r.br));
+        if (scale >= 1)
+            return r;
+        return { tl: r.tl * scale, tr: r.tr * scale, br: r.br * scale, bl: r.bl * scale };
+    }
     /**
      * Serialize a single display-list node to its content-stream operators.
      * `om` is used only by primitives that allocate PDF resources (images, fonts).
      */
     static serializeNode(node, om) {
-        var _a, _b, _c, _d, _e;
         switch (node.type) {
             case "line":
                 // q/Q isolates the graphics state; "[] 0 d" resets the dash pattern to solid.
@@ -109,28 +256,43 @@ class PdfBackend {
                     `S\n` +
                     `Q\n`);
             case "rect": {
-                // Stroke only with a stroke colour AND a positive width - a 0-width border means
+                // Stroke only with a stroke color AND a positive width - a 0-width border means
                 // "no border" (e.g. a filled box with no outline). Nothing to paint at all (no
                 // fill, no border) draws nothing. Paint: B = fill+stroke, f = fill, S = stroke.
-                const doStroke = !!node.stroke && ((_a = node.strokeWidth) !== null && _a !== void 0 ? _a : 0) > 0;
+                const doStroke = !!node.stroke && (node.strokeWidth ?? 0) > 0;
                 if (!node.fill && !doStroke)
                     return "";
-                let ops = "";
-                if (doStroke) {
-                    ops += `${node.strokeWidth} w\n${node.stroke.toPDFColorString()} RG\n`;
-                }
-                if (node.fill)
-                    ops += `${node.fill.toPDFColorString()} rg\n`;
-                const paint = node.fill ? (doStroke ? "B" : "f") : "S";
                 // Rounded corners emit a Bézier path; sharp corners keep the plain `re`
                 // (byte-identical when no radius is set).
-                const path = ((_b = node.radius) !== null && _b !== void 0 ? _b : 0) > 0
+                const path = isRounded(node.radius)
                     ? PdfBackend.roundedRectPath(node.x, node.y, node.width, node.height, node.radius)
                     : `${node.x} ${node.y} ${node.width} ${node.height} re`;
+                // A gradient cannot be a fill COLOUR - PDF paints one with `sh`, which floods the current
+                // clip. So the box becomes the clip, the shading is painted inside it, and a border is
+                // stroked afterwards on its own. Solid fills keep the plain operators, byte for byte.
+                const gradient = node.fill !== undefined && !(node.fill instanceof Color) ? node.fill : undefined;
+                if (gradient) {
+                    const shading = om.registerShading(gradient);
+                    let out = `q\n${path} W n\n/${shading} sh\nQ\n`;
+                    if (doStroke) {
+                        const gsStroke = PdfBackend.alphaPrefix(om, 1, node.stroke.getAlpha());
+                        const stroke = `${node.strokeWidth} w\n${node.stroke.toPDFColorString()} RG\n` + `${path} S\n`;
+                        out += gsStroke ? `q\n${gsStroke}${stroke}Q\n` : stroke;
+                    }
+                    return out;
+                }
+                const fill = node.fill;
+                let ops = "";
+                if (doStroke) {
+                    ops += `${node.strokeWidth} w\n${node.stroke.toPDFColorString()} RG\n`;
+                }
+                if (fill)
+                    ops += `${fill.toPDFColorString()} rg\n`;
+                const paint = fill ? (doStroke ? "B" : "f") : "S";
                 const body = ops + `${path} ${paint}\n`;
                 // Transparency needs an isolating q/Q so the state does not leak; opaque rects
                 // keep their bare operators (byte-identical).
-                const gs = PdfBackend.alphaPrefix(om, (_d = (_c = node.fill) === null || _c === void 0 ? void 0 : _c.getAlpha()) !== null && _d !== void 0 ? _d : 1, doStroke ? node.stroke.getAlpha() : 1);
+                const gs = PdfBackend.alphaPrefix(om, fill?.getAlpha() ?? 1, doStroke ? node.stroke.getAlpha() : 1);
                 return gs ? `q\n${gs}${body}Q\n` : body;
             }
             case "text": {
@@ -145,34 +307,111 @@ class PdfBackend {
                 const font = isCustom
                     ? om.getCustomFontResource(node.fontFamily, node.fontStyle)
                     : om.registerFont(node.fontFamily, node.fontStyle);
-                const textOp = isCustom
-                    ? `<${om.encodeCustomText(node.fontFamily, node.text, node.fontStyle)}>`
-                    : `(${PdfBackend.escapePdfString(node.text)})`;
+                const encode = (t) => isCustom
+                    ? `<${om.encodeCustomText(node.fontFamily, t, node.fontStyle)}>`
+                    : `(${PdfBackend.escapePdfString(t)})`;
+                // A shaped run brings its own glyphs, already in drawing order - they cannot be derived from
+                // the text here.
+                const shapedHex = node.glyphs && isCustom
+                    ? om.registerGlyphs(node.fontFamily, node.glyphs, node.fontStyle)
+                    : undefined;
+                // Kerning (if the document has it on): a `TJ` array with the font's per-pair adjustments
+                // between glyph chunks, measured into the layout by the SAME numbers (runAdvance). A plain
+                // `Tj` when the run has no kerning, byte-identical.
+                const kerns = om.kerningEnabled
+                    ? om.getKernPairs(node.text, node.fontFamily, node.fontStyle)
+                    : [];
+                const showOp = shapedHex
+                    ? `<${shapedHex}> Tj`
+                    : kerns.some((k) => k !== 0)
+                        ? `${PdfBackend.kernedArray(node.text, kerns, encode)} TJ`
+                        : `${encode(node.text)} Tj`;
+                // letterSpacing is the `Tc` operator: extra advance after EVERY glyph (an embedded
+                // Identity-H font too - that is `Tw`, word spacing, which only touches single-byte code 32).
+                const spacing = node.letterSpacing ? `${node.letterSpacing.toFixed(3)} Tc\n` : "";
                 const block = `BT\n` +
                     `${node.color.toPDFColorString()} rg ` +
                     `/F${font.fontIndex} ${node.fontSize} Tf ` +
                     `${node.x.toFixed(3)} ${node.y.toFixed(3)} Td ` +
-                    `${textOp} Tj\n` +
+                    `${showOp}\n` +
                     `ET\n`;
-                // Transparent text gets an isolating q/Q + gs; opaque text is byte-identical.
                 const gs = PdfBackend.alphaPrefix(om, node.color.getAlpha(), 1);
-                return gs ? `q\n${gs}${block}Q\n` : block;
+                // `Tc` is graphics state and would leak into the next run, so isolate it in q/Q - the same
+                // reason transparent text is isolated. A run with neither stays byte-identical.
+                return gs || spacing ? `q\n${gs}${spacing}${block}Q\n` : block;
             }
             case "image": {
                 // The backend owns PDF resource creation: register the XObject (using the
                 // source pixel dimensions) and then place it with a scaling matrix.
-                const ref = om.registerImage(node.intrinsicWidth, node.intrinsicHeight, node.imageType, node.data);
+                const ref = om.registerImage(node.intrinsicWidth, node.intrinsicHeight, node.imageType, node.data, node.smask);
                 const draw = `q\n${node.width} 0 0 ${node.height} ${node.x} ${node.y} cm\n` + `/IM${ref} Do\nQ\n`;
                 if (!node.clip)
                     return draw;
                 // Clip to the frame (re … W n); rounded when a radius is set. The rectangular
                 // path is byte-identical to before.
                 const c = node.clip;
-                const clipPath = ((_e = node.radius) !== null && _e !== void 0 ? _e : 0) > 0
+                const clipPath = isRounded(node.radius)
                     ? PdfBackend.roundedRectPath(c.x, c.y, c.width, c.height, node.radius)
                     : `${c.x} ${c.y} ${c.width} ${c.height} re `;
                 return `q\n${clipPath}\nW n \n` + draw + `Q\n`;
             }
+            case "clip-push": {
+                // Save the graphics state and intersect the clip with this (rounded) rect. Everything
+                // drawn until the matching clip-pop is cropped to it.
+                const path = isRounded(node.radius)
+                    ? PdfBackend.roundedRectPath(node.x, node.y, node.width, node.height, node.radius)
+                    : `${node.x} ${node.y} ${node.width} ${node.height} re`;
+                return `q\n${path}\nW n\n`;
+            }
+            case "path": {
+                // A filled vector path (one color-glyph layer). Emit the subpath ops, then either a solid
+                // nonzero fill (a Color) or, for a gradient, clip to the path and paint a shading inside it.
+                const f = (n) => n.toFixed(3);
+                let path = "";
+                for (const c of node.commands) {
+                    if (c.op === "m")
+                        path += `${f(c.x)} ${f(c.y)} m\n`;
+                    else if (c.op === "l")
+                        path += `${f(c.x)} ${f(c.y)} l\n`;
+                    else if (c.op === "c")
+                        path += `${f(c.x1)} ${f(c.y1)} ${f(c.x2)} ${f(c.y2)} ${f(c.x)} ${f(c.y)} c\n`;
+                    else
+                        path += `h\n`;
+                }
+                if (!(node.fill instanceof Color)) {
+                    // Gradient: clip to the path (W n keeps it as the clip without painting it), then paint
+                    // the registered shading across that clip. The q/Q isolates the clip. Note: per-stop alpha
+                    // is not represented (a DeviceRGB shading has no alpha channel - that would need a soft-mask
+                    // group); COLR gradient stops are opaque in real fonts, so they render correctly.
+                    const shading = om.registerShading(node.fill);
+                    return `q\n${path}W n\n/${shading} sh\nQ\n`;
+                }
+                const body = `${node.fill.toPDFColorString()} rg\n${path}f\n`;
+                const gs = PdfBackend.alphaPrefix(om, node.fill.getAlpha(), 1);
+                return gs ? `q\n${gs}${body}Q\n` : body;
+            }
+            case "clip-pop":
+                return `Q\n`;
+            case "transform-push": {
+                // Save the graphics state, then apply the affine; everything until transform-pop paints through it.
+                const f = (n) => n.toFixed(3);
+                return `q\n${node.matrix.map(f).join(" ")} cm\n`;
+            }
+            case "transform-pop":
+                return `Q\n`;
+            case "link":
+                // A link draws nothing in the content stream - it becomes a page /Annot (built in PageRenderer).
+                return "";
+            case "outline":
+                // An outline anchor draws nothing - it becomes a /Outlines entry (built in PageRenderer/PDFRenderer).
+                return "";
+            case "anchor":
+                // A named destination draws nothing - it becomes a /Names /Dests entry (built in PageRenderer/PDFRenderer).
+                return "";
+            case "formfield":
+                // A form field draws nothing in the content stream - it becomes a Widget /Annot + /AcroForm field
+                // (built in PageRenderer via forms/acroform.ts).
+                return "";
             default: {
                 // Exhaustiveness guard: if a new IRNode variant is added, this fails to compile.
                 const unknown = node;
@@ -181,4 +420,3 @@ class PdfBackend {
         }
     }
 }
-exports.PdfBackend = PdfBackend;

package/dist/renderer/pdf-config.js

@@ -1,17 +1,14 @@
-"use strict";
 // Leaf module: no imports, so it can never sit inside an import cycle. The page/color
 // enums live here because they are runtime values used across modules that DO form
 // cycles (object manager <-> document <-> elements); importing them from a cyclic
 // module snapshots them as `undefined` under some load orders.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColorMode = exports.Orientation = void 0;
-var Orientation;
+export var Orientation;
 (function (Orientation) {
     Orientation["portrait"] = "PORTRAIT";
     Orientation["landscape"] = "LANDSCAPE";
-})(Orientation || (exports.Orientation = Orientation = {}));
-var ColorMode;
+})(Orientation || (Orientation = {}));
+export var ColorMode;
 (function (ColorMode) {
     ColorMode["color"] = "COLOR";
     ColorMode["grayscale"] = "GRAYSCALE";
-})(ColorMode || (exports.ColorMode = ColorMode = {}));
+})(ColorMode || (ColorMode = {}));

package/dist/renderer/pdf-document-class.d.ts

@@ -1,8 +1,8 @@
-import { PageSize } from "../constants/page-sizes";
-import { PDFDocumentElement } from "../elements";
-import { FontStyle, PDFObjectManager } from "../utils/pdf-object-manager";
-import { ColorMode, Orientation } from "./pdf-config";
-export { ColorMode, Orientation } from "./pdf-config";
+import { PageSize } from "../constants/page-sizes.js";
+import { PDFDocumentElement } from "../elements/index.js";
+import { FontStyle, PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { ColorMode, Orientation } from "./pdf-config.js";
+export { ColorMode, Orientation } from "./pdf-config.js";
 export interface Margin {
     left: number;
     top: number;

package/dist/renderer/pdf-document-class.js

@@ -1,90 +1,76 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PDFDocument = exports.Orientation = exports.ColorMode = void 0;
-const pdf_object_manager_1 = require("../utils/pdf-object-manager");
-const pdf_renderer_1 = require("./pdf-renderer");
+import { FontStyle, PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { PDFRenderer } from "./pdf-renderer.js";
 // Re-exported so existing `../renderer` consumers keep importing these from here.
-var pdf_config_1 = require("./pdf-config");
-Object.defineProperty(exports, "ColorMode", { enumerable: true, get: function () { return pdf_config_1.ColorMode; } });
-Object.defineProperty(exports, "Orientation", { enumerable: true, get: function () { return pdf_config_1.Orientation; } });
-class PDFDocument {
+export { ColorMode, Orientation } from "./pdf-config.js";
+export class PDFDocument {
     //#region  Helper
     // Method to register all standard fonts
     registerStandardFonts(objectManager) {
         const standardFonts = [
             {
                 fontName: "Helvetica",
-                fontStyle: pdf_object_manager_1.FontStyle.Normal,
+                fontStyle: FontStyle.Normal,
                 fullName: "Helvetica",
             },
             {
                 fontName: "Helvetica",
-                fontStyle: pdf_object_manager_1.FontStyle.Bold,
+                fontStyle: FontStyle.Bold,
                 fullName: "Helvetica-Bold",
             },
             {
                 fontName: "Helvetica",
-                fontStyle: pdf_object_manager_1.FontStyle.Italic,
+                fontStyle: FontStyle.Italic,
                 fullName: "Helvetica-Oblique",
             },
             {
                 fontName: "Helvetica",
-                fontStyle: pdf_object_manager_1.FontStyle.BoldItalic,
+                fontStyle: FontStyle.BoldItalic,
                 fullName: "Helvetica-BoldOblique",
             },
-            { fontName: "Courier", fontStyle: pdf_object_manager_1.FontStyle.Normal, fullName: "Courier" },
+            { fontName: "Courier", fontStyle: FontStyle.Normal, fullName: "Courier" },
             {
                 fontName: "Courier",
-                fontStyle: pdf_object_manager_1.FontStyle.Bold,
+                fontStyle: FontStyle.Bold,
                 fullName: "Courier-Bold",
             },
             {
                 fontName: "Courier",
-                fontStyle: pdf_object_manager_1.FontStyle.Italic,
+                fontStyle: FontStyle.Italic,
                 fullName: "Courier-Oblique",
             },
             {
                 fontName: "Courier",
-                fontStyle: pdf_object_manager_1.FontStyle.BoldItalic,
+                fontStyle: FontStyle.BoldItalic,
                 fullName: "Courier-BoldOblique",
             },
             {
                 fontName: "Times-Roman",
-                fontStyle: pdf_object_manager_1.FontStyle.Normal,
+                fontStyle: FontStyle.Normal,
                 fullName: "Times-Roman",
             },
             {
                 fontName: "Times-Roman",
-                fontStyle: pdf_object_manager_1.FontStyle.Bold,
+                fontStyle: FontStyle.Bold,
                 fullName: "Times-Bold",
             },
             {
                 fontName: "Times-Roman",
-                fontStyle: pdf_object_manager_1.FontStyle.Italic,
+                fontStyle: FontStyle.Italic,
                 fullName: "Times-Italic",
             },
             {
                 fontName: "Times-Roman",
-                fontStyle: pdf_object_manager_1.FontStyle.BoldItalic,
+                fontStyle: FontStyle.BoldItalic,
                 fullName: "Times-BoldItalic",
             },
             {
                 fontName: "Symbol",
-                fontStyle: pdf_object_manager_1.FontStyle.Normal,
+                fontStyle: FontStyle.Normal,
                 fullName: "Symbol",
             },
             {
                 fontName: "ITC Zapf Dingbats",
-                fontStyle: pdf_object_manager_1.FontStyle.Normal,
+                fontStyle: FontStyle.Normal,
                 fullName: "ZapfDingbats",
             },
         ];
@@ -94,25 +80,25 @@ class PDFDocument {
     constructor(config) {
         // One object manager per document instance - no global singleton. Threaded
         // explicitly into the renderer.
-        this._objectManager = new pdf_object_manager_1.PDFObjectManager();
+        this._objectManager = new PDFObjectManager();
         // Add all standard font families - unless the document is PDF/A, which forbids non-embedded
         // fonts (the caller then supplies embedded fonts for every name it uses).
-        if ((config === null || config === void 0 ? void 0 : config.registerStandardFonts) !== false) {
+        if (config?.registerStandardFonts !== false) {
             this.registerStandardFonts(this._objectManager);
         }
         if (config)
             this._objectManager.changePDFConfig(config);
+        // Kerning is on by default at the document level (the `renderToBytes` path sets the same). A
+        // bare `PDFObjectManager` still defaults OFF, so unit tests keep predictable un-kerned metrics.
+        this._objectManager.setKerning(true);
     }
     get objectManager() {
         return this._objectManager;
     }
     beforeRenderer() { }
-    static render() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instance = new this();
-            instance.child = instance.build();
-            return yield pdf_renderer_1.PDFRenderer.render(instance.child, instance._objectManager);
-        });
+    static async render() {
+        const instance = new this();
+        instance.child = instance.build();
+        return await PDFRenderer.render(instance.child, instance._objectManager);
     }
 }
-exports.PDFDocument = PDFDocument;