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

package/dist/elements/text-element.d.ts

@@ -1,14 +1,19 @@
 import { Color } from "../common/color.js";
 import { FontStyle } from "../utils/pdf-object-manager.js";
 import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import type { Direction } from "../text/bidi.js";
+import { type TextTransform } from "../text/text-style.js";
 import { Fragmentable, FragmentResult } from "../layout/fragmentation.js";
 import { TextOverflow } from "../text/line-breaker.js";
 import { HorizontalAlignment, LayoutContext, SizedPDFElement } from "./pdf-element.js";
+import type { Hyphenator } from "../text/word-splitting.js";
 export interface TextSegment {
     content: string;
     fontStyle?: FontStyle;
     fontColor?: Color;
     fontFamily?: string;
+    /** The rest of the family stack for THIS run; unset inherits the Text's own. */
+    fontFallback?: string[];
     fontSize?: number;
     /** External URL: this segment becomes an inline hyperlink (a /Link annotation over its glyphs). */
     href?: string;
@@ -19,7 +24,17 @@ export interface TextSegment {
     strikethrough?: boolean;
     /** Extra space after every glyph, in points; unset inherits the Text's own value. */
     letterSpacing?: number;
+    /**
+     * CSS `vertical-align`, for a footnote marker or a formula index. Shifts THIS run's baseline;
+     * it does not resize the text, and it does not change the line's height - set `fontSize` yourself
+     * for the smaller look a browser's `<sup>` gets from its default stylesheet.
+     */
+    verticalAlign?: VerticalTextAlign;
 }
+/** How far a run sits off the baseline, as a fraction of its font size (up is positive). */
+export declare const VERTICAL_TEXT_SHIFT: Record<VerticalTextAlign, number>;
+/** CSS `vertical-align`, the three values that mean something for a run of text. */
+export type VerticalTextAlign = "baseline" | "super" | "sub";
 /** Accessibility role for the tagged structure tree: a heading level or a paragraph (the default). */
 export type TextRole = "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "p";
 interface TextElementParams {
@@ -27,12 +42,18 @@ interface TextElementParams {
     /** Unset (undefined) inherits the cascaded size; see ResolvedTextStyle. */
     fontSize?: number;
     fontFamily?: string;
+    /** The rest of the family stack, for code points `fontFamily` cannot draw. */
+    fontFallback?: string[];
     fontStyle?: FontStyle;
     content: string | TextSegment[];
     color?: Color;
     textAlignment?: HorizontalAlignment;
     /** Cap the wrapped lines (default: unlimited / open-end). */
     maxLines?: number;
+    /** Minimum lines that must stay behind at a page break (CSS `orphans`, default 2). */
+    orphans?: number;
+    /** Minimum lines that must carry over to the next page (CSS `widows`, default 2). */
+    widows?: number;
     /** What to do past `maxLines`: `"clip"` (default) drops them, `"ellipsis"` ends with "…". */
     overflow?: TextOverflow;
     /** Line-height multiplier: each line is `fontSize * lineHeight` tall. Unset means the font's
@@ -46,6 +67,20 @@ interface TextElementParams {
     skipInk?: boolean;
     /** Extra space after every glyph, in points (CSS `letter-spacing`). Default 0. */
     letterSpacing?: number;
+    /** Base writing direction (CSS `direction`); decides where a line starts. Default `"ltr"`. */
+    direction?: Direction;
+    /** CSS `text-transform`; applied before the text is measured or drawn. */
+    textTransform?: TextTransform;
+    /** CSS `word-spacing`, in points: extra advance at every space. */
+    wordSpacing?: number;
+    /** CSS `text-indent`, in points: how far the first line starts in. */
+    textIndent?: number;
+    /** CSS `overflow-wrap: break-word` - split a word wider than its box, anywhere. */
+    breakWord?: boolean;
+    /** The font's ligatures; on unless switched off. */
+    ligatures?: boolean;
+    /** Language-aware splitting; a hyphen is drawn at the break. See text/word-splitting.ts. */
+    hyphenate?: Hyphenator;
     /** Accessibility role for the tagged structure tree (heading level or paragraph; default `"p"`). */
     role?: TextRole;
 }
@@ -60,6 +95,14 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     private readonly rawStrikethrough?;
     private readonly rawSkipInk?;
     private readonly rawLetterSpacing?;
+    private readonly rawDirection?;
+    private readonly rawFontFallback?;
+    private readonly rawTextTransform?;
+    private readonly rawWordSpacing?;
+    private readonly rawTextIndent?;
+    private readonly rawBreakWord?;
+    private readonly rawLigatures?;
+    private readonly rawHyphenate?;
     private fontSize;
     private fontFamily;
     private fontStyle;
@@ -70,12 +113,41 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     private strikethrough;
     private skipInk;
     private letterSpacing;
+    private direction;
+    private fontFallback;
+    private resolved?;
+    private textTransform;
+    private wordSpacing;
+    private textIndent;
+    private breakWord;
+    private ligatures;
+    private hyphenate?;
     private content;
     private maxLines?;
+    private orphans?;
+    private widows?;
     private overflow;
     private readonly role?;
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, role, }: TextElementParams);
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, breakWord, hyphenate, ligatures, role, }: TextElementParams);
     private resolveStyle;
+    /** Justified lines may be squeezed to keep a word; every other alignment gets no slack. Read by the
+     *  breaker in BOTH passes, or a measured line and a drawn one would disagree about where it ends. */
+    /**
+     * The content as it is measured AND drawn - `text-transform` applied. One place, so a recased
+     * paragraph can never be measured in one casing and drawn in another (`ABC` and `abc` are not the
+     * same width in most fonts).
+     */
+    private display;
+    /**
+     * Drops or substitutes whatever the RESOLVED font cannot draw. Runs last, after the fallback stack
+     * has had its say, and before anything is measured - a character removed at draw time only would
+     * make the measured line and the drawn one disagree. A font that draws everything gets its input
+     * back unchanged, so an ordinary document is byte-identical.
+     */
+    private covered;
+    /** The content with `text-transform` applied, and nothing else. */
+    private recased;
+    private lineOptions;
     private applyStyle;
     /**
      * Splits the paragraph at line boxes (Slice 1). The lines that fit in `maxHeight` stay;
@@ -86,6 +158,8 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
     private fragmentString;
     private fragmentSegments;
+    /** The orphan/widow minimums for this paragraph; unset means the CSS default of 2 lines each. */
+    private breakRule;
     private cloneWithContent;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
     /** The unwrapped single-line width of the content (used when width is unbounded, e.g. inside a Row).
@@ -97,6 +171,15 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
      *  - enough to tip a borderline string (e.g. "20 Jun 2026", wider than "04 Jul 2026" only because
      *  'n' beats 'l') one bit over its own width, dropping the last word onto a second line. */
     private naturalWidth;
+    /**
+     * The widest piece of this text that cannot be broken - CSS's `min-content` width. A shrinking flex
+     * parent floors the width it hands us here, so a squeezed paragraph stops at its longest word
+     * instead of becoming one word per line.
+     *
+     * With `breakWord` or `hyphenate` on, the text may be cut mid-word, so the unbreakable piece is a
+     * single character - the same reasoning CSS applies to `word-break: break-all`.
+     */
+    minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     getProps(): {
         x: number;
         y: number;
@@ -109,12 +192,20 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
         content: string | TextSegment[];
         textAlignment: HorizontalAlignment;
         maxLines: number | undefined;
+        orphans: number | undefined;
+        widows: number | undefined;
         overflow: TextOverflow;
         lineHeight: number | undefined;
         underline: boolean;
         strikethrough: boolean;
         skipInk: boolean;
         letterSpacing: number;
+        direction: Direction;
+        wordSpacing: number;
+        textIndent: number;
+        breakWord: boolean;
+        ligatures: boolean;
+        hyphenate: Hyphenator | undefined;
         role: TextRole | undefined;
     };
 }

package/dist/elements/text-element.js

@@ -4,12 +4,34 @@
 // breaks the constructor-keyed RendererRegistry. A direct import keeps the graph acyclic.
 import { TextRenderer } from "../renderer/text-renderer.js";
 import { DEFAULT_TEXT_STYLE } from "../text/text-style.js";
-import { wrapStringIntoLines, breakSegmentsIntoLines, segmentLinesToSegments, } from "../text/line-breaker.js";
-import { lineBoxForSegmentLine, lineBoxForString } from "../text/line-metrics.js";
+import { applyTextTransform } from "../text/text-style.js";
+import { splitByFont } from "../text/font-fallback.js";
 import { runAdvance } from "../text/advance.js";
-import { SizedPDFElement } from "./pdf-element.js";
+import { singleLineWidth, MAX_SPACE_SHRINK, wrapStringIntoLines, breakSegmentsIntoLines, segmentLinesToSegments, } from "../text/line-breaker.js";
+import { adjustForOrphansWidows, DEFAULT_ORPHANS, DEFAULT_WIDOWS, } from "../text/orphans-widows.js";
+import { lineBoxForSegmentLine, lineBoxForString } from "../text/line-metrics.js";
+import { HorizontalAlignment, SizedPDFElement } from "./pdf-element.js";
+import { normalizeContent } from "../text/whitespace.js";
+import { coverText } from "../text/glyph-coverage.js";
+/** How far a run sits off the baseline, as a fraction of its font size (up is positive). */
+export const VERTICAL_TEXT_SHIFT = {
+    baseline: 0,
+    super: 1 / 3,
+    sub: -1 / 5,
+};
+/**
+ * A measurement in points has to be a real number. A NaN or an Infinity would travel all the way into
+ * the content stream as a position - the backend refuses it there, but by then the message names a
+ * coordinate rather than the property that was wrong. Rejected here, where the caller can see it.
+ */
+function finitePoints(value, name) {
+    if (value !== undefined && !Number.isFinite(value)) {
+        throw new Error(`@jasy/pdf: Invalid ${name} ${value}: it must be a finite number of points.`);
+    }
+    return value;
+}
 export class TextElement extends SizedPDFElement {
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow = "clip", lineHeight, underline, strikethrough, skipInk, letterSpacing, role, }) {
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow = "clip", lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, breakWord, hyphenate, ligatures, role, }) {
         super({ x: 0, y: 0 });
         this.role = role;
         this.rawFontSize = fontSize;
@@ -22,8 +44,20 @@ export class TextElement extends SizedPDFElement {
         this.rawStrikethrough = strikethrough;
         this.rawSkipInk = skipInk;
         this.rawLetterSpacing = letterSpacing;
-        this.content = content;
+        this.rawDirection = direction;
+        this.rawFontFallback = fontFallback;
+        this.rawTextTransform = textTransform;
+        this.rawWordSpacing = finitePoints(wordSpacing, "wordSpacing");
+        this.rawTextIndent = finitePoints(textIndent, "textIndent");
+        this.rawBreakWord = breakWord;
+        this.rawLigatures = ligatures;
+        this.rawHyphenate = hyphenate;
+        // Control characters have no glyph and would be DRAWN as .notdef boxes; `\n` survives
+        // because the breaker treats it as a hard break. See text/whitespace.ts.
+        this.content = normalizeContent(content);
         this.maxLines = maxLines;
+        this.orphans = orphans;
+        this.widows = widows;
         this.overflow = overflow;
         this.applyStyle(DEFAULT_TEXT_STYLE);
     }
@@ -31,6 +65,82 @@ export class TextElement extends SizedPDFElement {
     resolveStyle(ctx) {
         this.applyStyle(ctx.textStyle ?? DEFAULT_TEXT_STYLE);
     }
+    /** Justified lines may be squeezed to keep a word; every other alignment gets no slack. Read by the
+     *  breaker in BOTH passes, or a measured line and a drawn one would disagree about where it ends. */
+    /**
+     * The content as it is measured AND drawn - `text-transform` applied. One place, so a recased
+     * paragraph can never be measured in one casing and drawn in another (`ABC` and `abc` are not the
+     * same width in most fonts).
+     */
+    display(metrics) {
+        const cased = this.recased();
+        // A SPAN may bring its own stack, so the element's being empty is not enough to skip the pass.
+        const anyStack = this.fontFallback.length > 0 ||
+            (typeof cased !== "string" && cased.some((seg) => (seg.fontFallback?.length ?? 0) > 0));
+        if (!metrics)
+            return cased;
+        if (!anyStack)
+            return this.covered(cased, metrics);
+        // Font fallback turns the content into spans - one per family - which every later pass already
+        // knows how to handle. Nothing new downstream.
+        const pieces = typeof cased === "string" ? [{ content: cased }] : cased;
+        const out = [];
+        for (const seg of pieces) {
+            const runs = splitByFont(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontFallback ?? this.fontFallback, seg.fontStyle ?? this.fontStyle, metrics);
+            if (!runs)
+                out.push(seg);
+            else
+                for (const run of runs)
+                    out.push({ ...seg, content: run.text, fontFamily: run.fontFamily });
+        }
+        return this.covered(out, metrics);
+    }
+    /**
+     * Drops or substitutes whatever the RESOLVED font cannot draw. Runs last, after the fallback stack
+     * has had its say, and before anything is measured - a character removed at draw time only would
+     * make the measured line and the drawn one disagree. A font that draws everything gets its input
+     * back unchanged, so an ordinary document is byte-identical.
+     */
+    covered(content, metrics) {
+        const report = (dropped) => metrics.reportMissingGlyph?.(dropped);
+        if (typeof content === "string") {
+            const { text, dropped } = coverText(content, this.fontFamily, this.fontStyle, metrics);
+            if (dropped.length > 0)
+                report(dropped);
+            return text;
+        }
+        return content.map((seg) => {
+            const { text, dropped } = coverText(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontStyle ?? this.fontStyle, metrics);
+            if (dropped.length > 0)
+                report(dropped);
+            return text === seg.content ? seg : { ...seg, content: text };
+        });
+    }
+    /** The content with `text-transform` applied, and nothing else. */
+    recased() {
+        if (this.textTransform === "none")
+            return this.content;
+        if (typeof this.content === "string") {
+            return applyTextTransform(this.content, this.textTransform).text;
+        }
+        // The capitalisation state runs THROUGH the spans: `span("hel") + span("lo")` is one word.
+        let atWordStart = true;
+        return this.content.map((seg) => {
+            const done = applyTextTransform(seg.content, this.textTransform, atWordStart);
+            atWordStart = done.atWordStart;
+            return { ...seg, content: done.text };
+        });
+    }
+    lineOptions() {
+        return {
+            wordSpacing: this.wordSpacing,
+            indent: this.textIndent,
+            splitting: { breakWord: this.breakWord, hyphenate: this.hyphenate },
+            ligatures: this.ligatures,
+            // Justified lines may be squeezed to keep a word; every other alignment gets no slack.
+            shrink: this.textAlignment === HorizontalAlignment.justify ? MAX_SPACE_SHRINK : 0,
+        };
+    }
     applyStyle(ts) {
         this.fontSize = this.rawFontSize ?? ts.fontSize;
         this.fontFamily = this.rawFontFamily ?? ts.fontFamily;
@@ -42,6 +152,14 @@ export class TextElement extends SizedPDFElement {
         this.strikethrough = this.rawStrikethrough ?? ts.strikethrough;
         this.skipInk = this.rawSkipInk ?? ts.skipInk;
         this.letterSpacing = this.rawLetterSpacing ?? ts.letterSpacing;
+        this.direction = this.rawDirection ?? ts.direction;
+        this.fontFallback = this.rawFontFallback ?? ts.fontFallback;
+        this.textTransform = this.rawTextTransform ?? ts.textTransform;
+        this.wordSpacing = this.rawWordSpacing ?? ts.wordSpacing;
+        this.textIndent = this.rawTextIndent ?? ts.textIndent;
+        this.breakWord = this.rawBreakWord ?? ts.breakWord;
+        this.ligatures = this.rawLigatures ?? ts.ligatures;
+        this.hyphenate = this.rawHyphenate ?? ts.hyphenate;
     }
     /**
      * Splits the paragraph at line boxes (Slice 1). The lines that fit in `maxHeight` stay;
@@ -51,23 +169,25 @@ export class TextElement extends SizedPDFElement {
      */
     fragment(maxHeight, width, ctx) {
         this.resolveStyle(ctx);
-        return typeof this.content === "string"
-            ? this.fragmentString(this.content, maxHeight, width, ctx)
-            : this.fragmentSegments(this.content, maxHeight, width, ctx);
+        const content = this.display(ctx.metrics);
+        return typeof content === "string"
+            ? this.fragmentString(content, maxHeight, width, ctx)
+            : this.fragmentSegments(content, maxHeight, width, ctx);
     }
     // Plain string: every wrapped line gets the same box (the same one calculateTextHeight uses),
     // so `floor(maxHeight / lineBox)` lines fit.
     fragmentString(content, maxHeight, width, ctx) {
-        const lines = wrapStringIntoLines(content, this.fontFamily, this.fontSize, this.fontStyle, width, ctx.metrics, this.maxLines, this.overflow, this.letterSpacing);
+        const lines = wrapStringIntoLines(content, this.fontFamily, this.fontSize, this.fontStyle, width, ctx.metrics, this.maxLines, this.overflow, this.letterSpacing, this.lineOptions());
         const box = lineBoxForString(ctx.metrics, this.fontFamily, this.fontStyle, this.fontSize, this.lineHeight);
-        const fittedLineCount = Math.floor(maxHeight / box.height);
+        const fittedLineCount = adjustForOrphansWidows(Math.floor(maxHeight / box.height), lines.length, this.breakRule());
         if (fittedLineCount <= 0)
             return { fitted: null, remainder: this };
         if (fittedLineCount >= lines.length)
             return { fitted: this, remainder: null };
         return {
             fitted: this.cloneWithContent(lines.slice(0, fittedLineCount).join(" ")),
-            remainder: this.cloneWithContent(lines.slice(fittedLineCount).join(" ")),
+            // A continuation is no longer the paragraph's FIRST line, so it carries no indent.
+            remainder: this.cloneWithContent(lines.slice(fittedLineCount).join(" "), 0),
         };
     }
     // Styled segments: each line's height comes from the fonts on it, so pack lines by cumulative
@@ -78,29 +198,40 @@ export class TextElement extends SizedPDFElement {
             fontSize: this.fontSize,
             fontStyle: this.fontStyle,
             letterSpacing: this.letterSpacing,
+            direction: this.direction,
+            wordSpacing: this.wordSpacing,
+            textIndent: this.textIndent,
         };
         const lines = breakSegmentsIntoLines(content, defaults, width, ctx.metrics, this.maxLines, this.overflow);
         let used = 0;
-        let fittedLineCount = 0;
+        let packed = 0;
         for (const line of lines) {
             const lineBox = lineBoxForSegmentLine(line, defaults, ctx.metrics, this.lineHeight).height;
             if (used + lineBox > maxHeight)
                 break;
             used += lineBox;
-            fittedLineCount++;
+            packed++;
         }
+        const fittedLineCount = adjustForOrphansWidows(packed, lines.length, this.breakRule());
         if (fittedLineCount <= 0)
             return { fitted: null, remainder: this };
         if (fittedLineCount >= lines.length)
             return { fitted: this, remainder: null };
         return {
             fitted: this.cloneWithContent(segmentLinesToSegments(lines.slice(0, fittedLineCount))),
-            remainder: this.cloneWithContent(segmentLinesToSegments(lines.slice(fittedLineCount))),
+            remainder: this.cloneWithContent(segmentLinesToSegments(lines.slice(fittedLineCount)), 0),
+        };
+    }
+    /** The orphan/widow minimums for this paragraph; unset means the CSS default of 2 lines each. */
+    breakRule() {
+        return {
+            orphans: this.orphans ?? DEFAULT_ORPHANS,
+            widows: this.widows ?? DEFAULT_WIDOWS,
         };
     }
     // A copy carrying the same style but different (already-wrapped) content. Re-wrapping at
     // the same width reproduces exactly those lines (greedy is deterministic).
-    cloneWithContent(content) {
+    cloneWithContent(content, indent = this.textIndent) {
         return new TextElement({
             content,
             fontSize: this.fontSize,
@@ -109,12 +240,17 @@ export class TextElement extends SizedPDFElement {
             color: this.color,
             textAlignment: this.textAlignment,
             maxLines: this.maxLines,
+            orphans: this.orphans,
+            widows: this.widows,
             overflow: this.overflow,
             lineHeight: this.lineHeight,
             underline: this.underline,
             strikethrough: this.strikethrough,
             skipInk: this.skipInk,
             letterSpacing: this.letterSpacing,
+            direction: this.direction,
+            wordSpacing: this.wordSpacing,
+            textIndent: indent,
             role: this.role,
         }).adoptStructId(this); // a wrapped remainder is the SAME logical paragraph (one P across pages)
     }
@@ -125,11 +261,12 @@ export class TextElement extends SizedPDFElement {
         // Bounded width (e.g. inside a Column) wraps to that width; an unbounded width
         // (e.g. inside a Row) means the text takes its natural single-line width and does
         // not wrap. Columns always bound the width, so this leaves their layout untouched.
+        this.resolved = this.display(ctx.metrics);
         this.width = constraints.hasBoundedWidth
             ? constraints.maxWidth
             : this.naturalWidth(ctx.metrics);
         const wrapWidth = this.width ?? 0;
-        this.height = TextRenderer.calculateTextHeight(this.content, this.fontSize, this.fontFamily, this.fontStyle, ctx.metrics, wrapWidth, this.maxLines, this.overflow, this.lineHeight, this.letterSpacing);
+        this.height = TextRenderer.calculateTextHeight(this.resolved, this.fontSize, this.fontFamily, this.fontStyle, ctx.metrics, wrapWidth, this.maxLines, this.overflow, this.lineHeight, this.letterSpacing, this.lineOptions());
         // Top-left coordinates (y = top of the text box). The baseline offset and the
         // Y-flip are applied downstream (the line-builder positions baselines, the seam
         // flips to PDF), so the element stays coordinate-system-blind.
@@ -144,24 +281,54 @@ export class TextElement extends SizedPDFElement {
      *  - enough to tip a borderline string (e.g. "20 Jun 2026", wider than "04 Jul 2026" only because
      *  'n' beats 'l') one bit over its own width, dropping the last word onto a second line. */
     naturalWidth(metrics) {
-        const oneLine = (text, family, size, style, letterSpacing) => {
-            const font = { fontFamily: family, fontSize: size, fontStyle: style };
-            const words = text.split(" ");
-            const space = runAdvance(metrics, " ", font, letterSpacing);
-            let width = 0;
-            words.forEach((word, i) => {
-                const w = runAdvance(metrics, word, font, letterSpacing);
-                // Group (word + space) as one term, exactly like the breaker - see the note above. Both use
-                // the same `runAdvance`, so the two agree bit for bit even with letterSpacing.
-                width += i < words.length - 1 ? w + space : w;
-            });
-            return width;
+        // The breaker's own sum, to the last bit - see `singleLineWidth`.
+        const oneLine = (text, family, size, style, letterSpacing) => singleLineWidth(text, { fontFamily: family, fontSize: size, fontStyle: style }, metrics, letterSpacing, this.wordSpacing);
+        // The FIRST line starts `textIndent` in, so an unbounded box has to be that much wider.
+        const indent = Math.max(0, this.textIndent);
+        const content = this.display(metrics);
+        if (typeof content === "string") {
+            return (indent +
+                oneLine(content, this.fontFamily, this.fontSize, this.fontStyle, this.letterSpacing));
+        }
+        return content.reduce((sum, seg) => sum +
+            oneLine(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontSize ?? this.fontSize, seg.fontStyle ?? this.fontStyle, seg.letterSpacing ?? this.letterSpacing), indent);
+    }
+    /**
+     * The widest piece of this text that cannot be broken - CSS's `min-content` width. A shrinking flex
+     * parent floors the width it hands us here, so a squeezed paragraph stops at its longest word
+     * instead of becoming one word per line.
+     *
+     * With `breakWord` or `hyphenate` on, the text may be cut mid-word, so the unbreakable piece is a
+     * single character - the same reasoning CSS applies to `word-break: break-all`.
+     */
+    minIntrinsicMain(horizontal, ctx) {
+        // Only the width is a question here: the height of a text is whatever its lines add up to, and a
+        // column squeezing it vertically is the paginator's business, not the shrink pass's.
+        if (!horizontal)
+            return 0;
+        this.resolveStyle(ctx);
+        const metrics = ctx.metrics;
+        const widest = (text, family, size, style, letterSpacing) => {
+            // `ligatures` belongs to the FONT: it decides which glyphs are drawn and therefore how wide the
+            // piece is. Leaving it out here would measure a floor the drawing never matches.
+            const font = {
+                fontFamily: family,
+                fontSize: size,
+                fontStyle: style,
+                ligatures: this.ligatures,
+            };
+            // Split on the same boundaries the breaker uses - a hard break ends a line too.
+            const pieces = this.breakWord || this.hyphenate ? [...text] : text.split(/[ \n]/);
+            return pieces.reduce((max, piece) => Math.max(max, runAdvance(metrics, piece, font, letterSpacing)), 0);
         };
-        if (typeof this.content === "string") {
-            return oneLine(this.content, this.fontFamily, this.fontSize, this.fontStyle, this.letterSpacing);
+        const content = this.display(metrics);
+        if (typeof content === "string") {
+            return widest(content, this.fontFamily, this.fontSize, this.fontStyle, this.letterSpacing);
         }
-        return this.content.reduce((sum, seg) => sum +
-            oneLine(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontSize ?? this.fontSize, seg.fontStyle ?? this.fontStyle, seg.letterSpacing ?? this.letterSpacing), 0);
+        // Segments join without a space, so a word may straddle two of them; taking the widest piece per
+        // segment can therefore UNDER-estimate. That errs towards squeezing a little too far, which lands
+        // back on the old overflow behaviour rather than on something new.
+        return content.reduce((max, seg) => Math.max(max, widest(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontSize ?? this.fontSize, seg.fontStyle ?? this.fontStyle, seg.letterSpacing ?? this.letterSpacing)), 0);
     }
     getProps() {
         return {
@@ -173,15 +340,23 @@ export class TextElement extends SizedPDFElement {
             fontFamily: this.fontFamily,
             fontStyle: this.fontStyle,
             color: this.color,
-            content: this.content,
+            content: this.resolved ?? this.content,
             textAlignment: this.textAlignment,
             maxLines: this.maxLines,
+            orphans: this.orphans,
+            widows: this.widows,
             overflow: this.overflow,
             lineHeight: this.lineHeight,
             underline: this.underline,
             strikethrough: this.strikethrough,
             skipInk: this.skipInk,
             letterSpacing: this.letterSpacing,
+            direction: this.direction,
+            wordSpacing: this.wordSpacing,
+            textIndent: this.textIndent,
+            breakWord: this.breakWord,
+            ligatures: this.ligatures,
+            hyphenate: this.hyphenate,
             role: this.role,
         };
     }