@jasy/pdf 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/renderer/pdf-backend.d.ts

@@ -41,11 +41,22 @@ export declare class PdfBackend {
     static escapePdfString(text: string): string;
     /**
      * 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`.
+     * sign the font declares). Generic over the UNIT so the same chunking serves both paths: characters
+     * for a WinAnsi run, glyph ids for a shaped one - a shaped run cannot be expressed as text.
+     * 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: string, kerns: number[], encode: (chunk: string) => string): string;
+    static kernedArray<T>(units: readonly T[], kerns: number[], encode: (chunk: T[]) => string): string;
+    /** The path-construction operators for a command list. Shared by a filled path and by a clip. */
+    private static pathOps;
+    /**
+     * The graphics-state operators for a stroke, in the order a content stream wants them. Only what
+     * differs from the PDF default is emitted, EXCEPT the miter limit: SVG's initial value is 4 and
+     * PDF's is 10, so a mitered join has to say so or a sharp corner grows a spike the source never had.
+     * The caller isolates these in a q/Q - `d` in particular would otherwise dash every later stroke.
+     */
+    private static strokeState;
     /**
      * 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

package/dist/renderer/pdf-backend.js

@@ -1,4 +1,4 @@
-import { isRounded } from "../ir/display-list.js";
+import { isRounded, } from "../ir/display-list.js";
 import { Color } from "../common/color.js";
 /**
  * PDF backend - turns display-list primitives into content-stream operators.
@@ -46,6 +46,19 @@ export class PdfBackend {
                     }
                     return flipped;
                 }
+                case "clip-path-push":
+                    // Its commands live in the same space as a Path's, so they flip the same way.
+                    return {
+                        ...node,
+                        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 };
+                        }),
+                    };
                 case "clip-push":
                     // Flip the clip rect around its bottom edge, like a rect.
                     return { ...node, y: pageHeight - node.y - node.height };
@@ -63,7 +76,7 @@ export class PdfBackend {
                     });
                     // 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
+                    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, commands, fill };
@@ -140,6 +153,7 @@ export class PdfBackend {
             // catalog entries instead of content-stream operators.
             if (!struct ||
                 node.type === "clip-push" ||
+                node.type === "clip-path-push" ||
                 node.type === "clip-pop" ||
                 node.type === "transform-push" ||
                 node.type === "transform-pop" ||
@@ -164,25 +178,72 @@ export class PdfBackend {
     }
     /**
      * 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`.
+     * sign the font declares). Generic over the UNIT so the same chunking serves both paths: characters
+     * for a WinAnsi run, glyph ids for a shaped one - a shaped run cannot be expressed as text.
+     * 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];
+    static kernedArray(units, kerns, encode) {
+        const gaps = Math.max(0, units.length - 1);
+        if (kerns.length !== gaps) {
+            // The loop walks the GAPS, so a short list would drop the units past it - silently, and only the
+            // last glyph, which is exactly the kind of thing nobody notices until a word reads wrong. An
+            // empty run has no gaps at all, so any adjustment for one is a disagreement too.
+            throw new Error(`@jasy/pdf: ${kerns.length} kern adjustments for ${units.length} units - expected ${gaps}.`);
+        }
         let out = "";
-        let chunk = chars[0] ?? "";
+        let chunk = units.length > 0 ? [units[0]] : [];
         for (let i = 0; i < kerns.length; i++) {
             if (kerns[i] === 0) {
-                chunk += chars[i + 1];
+                chunk.push(units[i + 1]);
             }
             else {
                 out += encode(chunk) + ` ${-kerns[i]} `;
-                chunk = chars[i + 1];
+                chunk = [units[i + 1]];
             }
         }
         return `[${out}${encode(chunk)}]`;
     }
+    /** The path-construction operators for a command list. Shared by a filled path and by a clip. */
+    static pathOps(commands) {
+        const f = (n) => n.toFixed(3);
+        let out = "";
+        for (const c of commands) {
+            if (c.op === "m")
+                out += `${f(c.x)} ${f(c.y)} m\n`;
+            else if (c.op === "l")
+                out += `${f(c.x)} ${f(c.y)} l\n`;
+            else if (c.op === "c")
+                out += `${f(c.x1)} ${f(c.y1)} ${f(c.x2)} ${f(c.y2)} ${f(c.x)} ${f(c.y)} c\n`;
+            else
+                out += `h\n`;
+        }
+        return out;
+    }
+    /**
+     * The graphics-state operators for a stroke, in the order a content stream wants them. Only what
+     * differs from the PDF default is emitted, EXCEPT the miter limit: SVG's initial value is 4 and
+     * PDF's is 10, so a mitered join has to say so or a sharp corner grows a spike the source never had.
+     * The caller isolates these in a q/Q - `d` in particular would otherwise dash every later stroke.
+     */
+    static strokeState(stroke) {
+        const CAPS = { butt: 0, round: 1, square: 2 };
+        const JOINS = { miter: 0, round: 1, bevel: 2 };
+        let ops = `${stroke.width} w\n${stroke.color.toPDFColorString()} RG\n`;
+        if (stroke.cap && stroke.cap !== "butt")
+            ops += `${CAPS[stroke.cap]} J\n`;
+        const join = stroke.join ?? "miter";
+        if (join !== "miter")
+            ops += `${JOINS[join]} j\n`;
+        else
+            ops += `${stroke.miterLimit ?? 4} M\n`;
+        // A dash array of all zeros means "solid" in SVG but is an error in PDF, so it is dropped.
+        if (stroke.dash && stroke.dash.length > 0 && stroke.dash.some((n) => n > 0)) {
+            ops += `[${stroke.dash.join(" ")}] ${stroke.dashOffset ?? 0} d\n`;
+        }
+        return ops;
+    }
     /**
      * 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
@@ -273,7 +334,8 @@ export class PdfBackend {
                 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`;
+                    const gsFill = PdfBackend.alphaPrefix(om, gradient.alpha ?? 1, 1);
+                    let out = `q\n${gsFill}${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`;
@@ -308,7 +370,7 @@ export class PdfBackend {
                     ? om.getCustomFontResource(node.fontFamily, node.fontStyle)
                     : om.registerFont(node.fontFamily, node.fontStyle);
                 const encode = (t) => isCustom
-                    ? `<${om.encodeCustomText(node.fontFamily, t, node.fontStyle)}>`
+                    ? `<${om.encodeCustomText(node.fontFamily, t, node.fontStyle, false)}>`
                     : `(${PdfBackend.escapePdfString(t)})`;
                 // A shaped run brings its own glyphs, already in drawing order - they cannot be derived from
                 // the text here.
@@ -318,13 +380,24 @@ export class PdfBackend {
                 // 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`
+                // A shaped run brings its glyphs along, so kern those directly rather than re-deriving them
+                // from the text - which would also have to guess the run's ligature setting.
+                const kerns = !om.kerningEnabled
+                    ? []
+                    : node.glyphs && isCustom
+                        ? om.getGlyphKernPairs(node.glyphs, node.fontFamily, node.fontStyle)
+                        : // No glyph list means the run was NOT shaped, whatever the document asks for - so take the
+                            // character path explicitly. Letting it default would shape here, and a pair count that
+                            // does not match the character count silently drops the last one.
+                            om.getKernPairs(node.text, node.fontFamily, node.fontStyle, false);
+                // A shaped run kerns too, over its SHAPED glyphs - `getKernPairs` returns one adjustment per
+                // adjacent drawn pair either way, so both paths use the same numbers `runAdvance` measured.
+                const showOp = node.glyphs && isCustom
+                    ? kerns.some((k) => k !== 0)
+                        ? `${PdfBackend.kernedArray(node.glyphs, kerns, (chunk) => `<${om.registerGlyphs(node.fontFamily, chunk, node.fontStyle)}>`)} TJ`
+                        : `<${shapedHex}> Tj`
                     : kerns.some((k) => k !== 0)
-                        ? `${PdfBackend.kernedArray(node.text, kerns, encode)} TJ`
+                        ? `${PdfBackend.kernedArray([...node.text], kerns, (chunk) => encode(chunk.join("")))} 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).
@@ -364,32 +437,49 @@ export class PdfBackend {
                 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)) {
+                // A vector path: a color-glyph layer (fill only) or an SVG shape (fill and/or stroke). Emit
+                // the subpath ops once, then pick the painting operator from what the node actually carries.
+                const path = PdfBackend.pathOps(node.commands);
+                // The even-odd variants of the fill and clip operators are the same letter plus a star.
+                const star = node.fillRule === "evenodd" ? "*" : "";
+                const stroke = node.stroke;
+                if (node.fill !== undefined && !(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.
+                    // A stroke cannot share that q/Q: the clip would cut the outline in half, because a stroke
+                    // straddles the edge. So it is drawn afterwards, over the same path.
                     const shading = om.registerShading(node.fill);
-                    return `q\n${path}W n\n/${shading} sh\nQ\n`;
+                    const gsFill = PdfBackend.alphaPrefix(om, node.fill.alpha ?? 1, 1);
+                    const filled = `q\n${gsFill}${path}W${star} n\n/${shading} sh\nQ\n`;
+                    if (!stroke)
+                        return filled;
+                    const gsStroke = PdfBackend.alphaPrefix(om, 1, stroke.color.getAlpha());
+                    return `${filled}q\n${gsStroke}${PdfBackend.strokeState(stroke)}${path}S\nQ\n`;
+                }
+                // No fill and no stroke: a shape that paints nothing. Emitting the path without an operator
+                // would leave it pending in the content stream and swallow whatever is drawn next.
+                if (node.fill === undefined && !stroke)
+                    return "";
+                if (stroke) {
+                    // A stroked path always gets its own q/Q. Unlike a rect it can set `J`, `j`, `M` and `d`,
+                    // and those would otherwise stay on for every later stroke on the page - a dash pattern
+                    // leaking into the next table rule. Existing IR carries no stroke, so nothing moves.
+                    const paint = node.fill !== undefined ? `B${star}` : "S";
+                    const color = node.fill !== undefined ? `${node.fill.toPDFColorString()} rg\n` : "";
+                    const gs = PdfBackend.alphaPrefix(om, node.fill !== undefined ? node.fill.getAlpha() : 1, stroke.color.getAlpha());
+                    return `q\n${gs}${color}${PdfBackend.strokeState(stroke)}${path}${paint}\nQ\n`;
                 }
-                const body = `${node.fill.toPDFColorString()} rg\n${path}f\n`;
+                const body = `${node.fill.toPDFColorString()} rg\n${path}f${star}\n`;
                 const gs = PdfBackend.alphaPrefix(om, node.fill.getAlpha(), 1);
                 return gs ? `q\n${gs}${body}Q\n` : body;
             }
+            case "clip-path-push": {
+                // `W n` sets the clip from the current path without painting it; the q is closed by clip-pop.
+                const star = node.fillRule === "evenodd" ? "*" : "";
+                return `q\n${PdfBackend.pathOps(node.commands)}W${star} n\n`;
+            }
             case "clip-pop":
                 return `Q\n`;
             case "transform-push": {

package/dist/renderer/pdf-renderer.js

@@ -1,6 +1,6 @@
 import { PDFDocumentRenderer } from "./pdf-document-renderer.js";
 import { RendererRegistry } from "../utils/renderer-registry.js";
-import { DefaultTextStyleElement, ExpandedElement, ImageElement, LineElement, PaddingElement, TextElement, } from "../elements/index.js";
+import { DefaultTextStyleElement, ExpandedElement, ImageElement, LineElement, CanvasElement, PaddingElement, SvgElement, TextElement, } from "../elements/index.js";
 import { TextRenderer } from "./text-renderer.js";
 import { ContainerElement } from "../elements/container-element.js";
 import { RectangleElement } from "../elements/rectangle-element.js";
@@ -13,6 +13,8 @@ import { PaddingRenderer } from "./padding-renderer.js";
 import { DefaultTextStyleRenderer } from "./default-text-style-renderer.js";
 import { ImageRenderer } from "./image-renderer.js";
 import { LineRenderer } from "./line-renderer.js";
+import { SvgRenderer } from "./svg-renderer.js";
+import { CanvasRenderer } from "./canvas-renderer.js";
 import { RepeatingHeaderElement } from "../elements/layout/repeating-header-element.js";
 import { RepeatingHeaderRenderer } from "./repeating-header-renderer.js";
 import { DeferredElement } from "../elements/layout/deferred-element.js";
@@ -67,6 +69,8 @@ export class PDFRenderer {
         RendererRegistry.register(DefaultTextStyleElement, DefaultTextStyleRenderer.render);
         RendererRegistry.register(ImageElement, ImageRenderer.render);
         RendererRegistry.register(LineElement, LineRenderer.render);
+        RendererRegistry.register(SvgElement, SvgRenderer.render);
+        RendererRegistry.register(CanvasElement, CanvasRenderer.render);
         RendererRegistry.register(RepeatingHeaderElement, RepeatingHeaderRenderer.render);
         RendererRegistry.register(DeferredElement, DeferredRenderer.render);
         RendererRegistry.register(PositionedElement, PositionedRenderer.render);

package/dist/renderer/positioned-renderer.js

@@ -5,6 +5,6 @@ export class PositionedRenderer {
         // after the frame's flow content, so it paints on top.
         const { child } = positionedElement.getProps();
         const renderer = RendererRegistry.getRenderer(child);
-        return renderer ? renderer(child, objectManager) : [];
+        return renderer(child, objectManager);
     }
 }

package/dist/renderer/rectangle-renderer.js

@@ -44,9 +44,7 @@ export class RectangleRenderer {
         if (children)
             for (const child of children) {
                 const renderer = RendererRegistry.getRenderer(child);
-                if (renderer) {
-                    nodes.push(...(await renderer(child, objectManager)));
-                }
+                nodes.push(...(await renderer(child, objectManager)));
             }
         if (clip)
             nodes.push({ type: "clip-pop" });

package/dist/renderer/repeating-header-renderer.js

@@ -5,8 +5,7 @@ export class RepeatingHeaderRenderer {
         const nodes = [];
         for (const child of [header, body]) {
             const renderer = RendererRegistry.getRenderer(child);
-            if (renderer)
-                nodes.push(...(await renderer(child, objectManager)));
+            nodes.push(...(await renderer(child, objectManager)));
         }
         return nodes;
     }

package/dist/renderer/rotated-renderer.js

@@ -22,7 +22,7 @@ export class RotatedRenderer {
             cy - sin * cx - cos * cy,
         ];
         const renderer = RendererRegistry.getRenderer(child);
-        const childNodes = renderer ? await renderer(child, objectManager) : [];
+        const childNodes = await renderer(child, objectManager);
         // Wrap the child's drawing between a push (apply the matrix) and a pop (restore).
         return [{ type: "transform-push", matrix }, ...childNodes, { type: "transform-pop" }];
     }

package/dist/renderer/row-renderer.js

@@ -6,9 +6,7 @@ export class RowRenderer {
         if (children)
             for (const child of children) {
                 const renderer = RendererRegistry.getRenderer(child);
-                if (renderer) {
-                    nodes.push(...(await renderer(child, objectManager)));
-                }
+                nodes.push(...(await renderer(child, objectManager)));
             }
         return nodes;
     }

package/dist/renderer/struct-group-renderer.js

@@ -8,7 +8,7 @@ export class StructGroupRenderer {
         const { role, child } = group.getProps();
         const renderChild = async () => {
             const renderer = RendererRegistry.getRenderer(child);
-            return renderer ? await renderer(child, objectManager) : [];
+            return renderer(child, objectManager);
         };
         if (!objectManager.struct.enabled)
             return renderChild();

package/dist/renderer/svg-renderer.d.ts

@@ -0,0 +1,11 @@
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { SvgElement } from "../elements/svg-element.js";
+import type { IRNode } from "../ir/display-list.js";
+/**
+ * Turns the drawing into display-list nodes inside the box layout gave it. All the work is in
+ * `svg/`; this is only the seam, which is why an SVG needs no new IR primitive - the vector layer
+ * that colour emoji already draw through carries it.
+ */
+export declare class SvgRenderer {
+    static render(element: SvgElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+}

package/dist/renderer/svg-renderer.js

@@ -0,0 +1,27 @@
+import { svgToIr } from "../svg/index.js";
+/**
+ * Turns the drawing into display-list nodes inside the box layout gave it. All the work is in
+ * `svg/`; this is only the seam, which is why an SVG needs no new IR primitive - the vector layer
+ * that colour emoji already draw through carries it.
+ */
+export class SvgRenderer {
+    static async render(element, objectManager) {
+        const { x, y, width, height, source, alt } = element.getProps();
+        const nodes = svgToIr(source, {
+            x: x ?? 0,
+            y: y ?? 0,
+            width: width ?? 0,
+            height: height ?? 0,
+        });
+        // Accessible tagging: a drawing WITH alt text is one Figure - every path of it belongs to the
+        // same struct element, which is what `openElement` keyed on `structId` gives us. Without alt it
+        // stays untagged and the backend treats it as decoration (an Artifact).
+        if (!alt || !objectManager.struct.enabled)
+            return nodes;
+        const tag = {
+            role: "Figure",
+            key: objectManager.struct.openElement(element.structId, "Figure", { alt }),
+        };
+        return nodes.map((node) => (node.type === "path" ? { ...node, tag } : node));
+    }
+}

package/dist/renderer/text-renderer.js

@@ -8,6 +8,7 @@ import { lineBoxForSegmentLine, lineBoxForString } from "../text/line-metrics.js
 import { runAdvance } from "../text/advance.js";
 import { visualRuns, visualRunsOf } from "../text/bidi.js";
 import { skipInkSegments, strikethroughStroke, underlineStroke, } from "../text/text-decoration.js";
+import { quadToCubic } from "../vector/path.js";
 export class TextRenderer {
     // Measuring only needs metrics, not the full object manager. (The render pass below
     // still receives the manager because it also registers fonts/images.)
@@ -18,17 +19,26 @@ export class TextRenderer {
             const box = lineBoxForString(objectManager, fontFamily, fontStyle, fontSize, lineHeight);
             return lines.length * box.height;
         }
-        // Segments: each line's box comes from the fonts actually on it.
-        const defaults = { fontFamily, fontSize, fontStyle, letterSpacing };
+        // Segments: each line's box comes from the fonts actually on it. `splitting` has to travel with
+        // them for the same reason `letterSpacing` does: it changes where a line ENDS, so leaving it out
+        // measures a paragraph at one line count and draws it at another.
+        const defaults = {
+            fontFamily,
+            fontSize,
+            fontStyle,
+            letterSpacing,
+            splitting: lineOptions.splitting,
+            ligatures: lineOptions.ligatures,
+        };
         const lines = breakSegmentsIntoLines(content, defaults, maxWidth, objectManager, maxLines, overflow);
         return lines.reduce((total, line) => total + lineBoxForSegmentLine(line, defaults, objectManager, lineHeight).height, 0);
     }
     static async render(textElement, objectManager) {
-        const { x, y, width, fontSize, color, content, fontFamily, fontStyle, textAlignment, maxLines, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, wordSpacing, textIndent, role, } = textElement.getProps();
+        const { x, y, width, fontSize, color, content, fontFamily, fontStyle, textAlignment, maxLines, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, wordSpacing, textIndent, breakWord, hyphenate, ligatures, role, } = textElement.getProps();
         // Component -> display list. Wrapping and positioning stay here; the backend
         // turns each run into BT/Tf/Td/Tj/ET. The wrapping algorithm is unchanged from
         // the original renderer - unifying it into the engine is Phase 3.
-        const { runs, links, decorations } = TextRenderer._buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, width ?? Number.NaN, textAlignment, color, x, y, maxLines, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, wordSpacing, textIndent);
+        const { runs, links, decorations } = TextRenderer._buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, width ?? Number.NaN, textAlignment, color, x, y, maxLines, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, wordSpacing, textIndent, breakWord, hyphenate, ligatures);
         // Accessible tagging: this whole text block is one structure element (a paragraph P, or a heading
         // from `role`); each run's text lands under it. Emoji sub-nodes produced below stay untagged (drawn
         // as artifacts). Keyed by structId so a block split across pages stays one element.
@@ -161,19 +171,9 @@ export class TextRenderer {
                 out.push({ op: "l", x: curX, y: curY });
             }
             else if (cmd.type === "Q") {
-                const ctrlX = mapX(cmd.cx, cmd.cy);
-                const ctrlY = mapY(cmd.cx, cmd.cy);
                 const endX = mapX(cmd.x, cmd.y);
                 const endY = mapY(cmd.x, cmd.y);
-                out.push({
-                    op: "c",
-                    x1: curX + (2 / 3) * (ctrlX - curX),
-                    y1: curY + (2 / 3) * (ctrlY - curY),
-                    x2: endX + (2 / 3) * (ctrlX - endX),
-                    y2: endY + (2 / 3) * (ctrlY - endY),
-                    x: endX,
-                    y: endY,
-                });
+                out.push(quadToCubic(curX, curY, mapX(cmd.cx, cmd.cy), mapY(cmd.cx, cmd.cy), endX, endY));
                 curX = endX;
                 curY = endY;
             }
@@ -224,7 +224,7 @@ export class TextRenderer {
     // Lay the content out into absolutely-positioned text runs. Glyph positions match
     // the previous hand-written operators exactly (verified by pixel-identical render);
     // only the output form changed from PDF strings to `TextRun`s.
-    static _buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, maxWidth, textAlignment, color, initialX, yPosition, maxLines, overflow, lineHeight, underline = false, strikethrough = false, skipInk = false, letterSpacing = 0, direction = "ltr", wordSpacing = 0, textIndent = 0) {
+    static _buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, maxWidth, textAlignment, color, initialX, yPosition, maxLines, overflow, lineHeight, underline = false, strikethrough = false, skipInk = false, letterSpacing = 0, direction = "ltr", wordSpacing = 0, textIndent = 0, breakWord = false, hyphenate, ligatures = true) {
         const runs = [];
         // /Link annotation rects for any `href` spans, collected as we place segments. Empty for the
         // common (no-href) case, so plain text keeps producing exactly the runs it did before.
@@ -353,7 +353,9 @@ export class TextRenderer {
          * text, no glyph list, byte-identical output.
          */
         const shapedPiece = (part, family, style) => {
-            const shaped = objectManager.shapeText(part.logical, family, style);
+            // The run's OWN setting, not the default: measuring asked with it (`runAdvance` -> RunFont), and
+            // drawing has to ask the same question or the line is measured one width and drawn another.
+            const shaped = objectManager.shapeText(part.logical, family, style, ligatures ? undefined : []);
             if (!shaped)
                 return { text: part.text };
             const ordered = part.rtl ? [...shaped].reverse() : shaped;
@@ -361,7 +363,7 @@ export class TextRenderer {
         };
         // The advance the viewer will use: plain glyph widths (a `Tj` never kerns) plus one
         // `letterSpacing` per code point (the `Tc` operator), from the one shared `advance.ts` primitive.
-        const font = { fontFamily, fontSize, fontStyle };
+        const font = { fontFamily, fontSize, fontStyle, ligatures };
         // --- Plain string: one run per wrapped line. ---
         if (typeof content === "string") {
             const lines = wrapStringIntoLines(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager, maxLines, overflow, letterSpacing, 
@@ -371,6 +373,8 @@ export class TextRenderer {
                 wordSpacing,
                 indent: textIndent,
                 shrink: align === HorizontalAlignment.justify ? MAX_SPACE_SHRINK : 0,
+                splitting: { breakWord, hyphenate },
+                ligatures,
             });
             // yPosition is the top of the text box (top-left). The line box seats its own baseline; lines
             // then stack by that box's height. Same numbers as calculateTextHeight, by construction.
@@ -457,7 +461,14 @@ export class TextRenderer {
         // The seam flips the whole thing to PDF space. `letterSpacing` MUST be in the defaults so a span
         // that does not override it wraps and aligns with the element's spacing - the same defaults the
         // measure path (calculateTextHeight) uses, or segmented spaced text mis-wraps (measured != drawn).
-        const defaults = { fontFamily, fontSize, fontStyle, letterSpacing };
+        const defaults = {
+            fontFamily,
+            fontSize,
+            fontStyle,
+            letterSpacing,
+            splitting: { breakWord, hyphenate },
+            ligatures,
+        };
         let top = yPosition;
         // Materialised, because justification has to know which line is the LAST one of the paragraph.
         const segmentLines = [

package/dist/svg/css.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The `<style>` block - the third way an SVG carries style, beside presentation attributes and the
+ * `style=""` bag.
+ *
+ * It exists here because it is the case that BREAKS in practice: Illustrator's default export option
+ * is "Internal CSS", which puts every fill into a class and leaves the shapes with nothing but
+ * `class="st0"`. Dropping the block therefore does not lose a detail - it makes the whole logo black.
+ * (react-pdf drops it, with a warning; we dropped it silently until this module existed.)
+ *
+ * Only FLAT selectors are resolved - a tag, `.class`, `#id`, and compounds of those - because that is
+ * what exporters emit. A combinator or a pseudo-class is reported rather than quietly mismatched: a
+ * selector that silently fails to match is the same black logo again, one level down.
+ */
+export interface CssRule {
+    tag?: string;
+    id?: string;
+    classes: string[];
+    /** CSS specificity as one number, and the source order that breaks ties. */
+    weight: number;
+    order: number;
+    declarations: Record<string, string>;
+}
+/**
+ * Parses every `<style>` block's text into rules, in source order.
+ *
+ * The brace matching is done by hand rather than with one regex: `@media print { .a { … } }` nests,
+ * and a regex that skips to the first balanced-looking block silently applies the INNER rule while
+ * never seeing the at-rule that guards it.
+ */
+export declare function parseStylesheet(css: string): CssRule[];
+/**
+ * The declarations that apply to one element, weakest first - so a caller can just assign them in
+ * order and let the last one win, as the cascade does.
+ */
+export declare function declarationsFor(rules: readonly CssRule[], tagName: string, attributes: {
+    class?: string;
+    id?: string;
+}): Record<string, string>;