@jasy/pdf 1.0.0-alpha.2 → 1.0.0-alpha.4

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

@@ -1,6 +1,6 @@
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { RectangleElement } from "../elements/rectangle-element";
-import { IRNode } from "../ir/display-list";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { RectangleElement } from "../elements/rectangle-element.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class RectangleRenderer {
     static render(rectangleElement: RectangleElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
     /** One `line` node per present side, along the box edges (top-left coordinates). */

package/dist/renderer/rectangle-renderer.js

@@ -1,56 +1,50 @@
-"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.RectangleRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class RectangleRenderer {
-    static render(rectangleElement, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { x, y, width, height, children, color, backgroundColor, borderWidth, radius, sideBorders, overflow, } = rectangleElement.getProps();
-            const h = height;
-            const nodes = [];
-            if (sideBorders) {
-                // Per-side borders: a fill-only box (no stroke), then a line per present side
-                // (sharp corners). This is what lets cells draw grid lines.
-                if (backgroundColor) {
-                    nodes.push({ type: "rect", x, y, width, height: h, strokeWidth: 0, fill: backgroundColor });
-                }
-                nodes.push(...RectangleRenderer.sideLines(x, y, width, h, borderWidth, sideBorders));
-            }
-            else {
-                // The box itself becomes a display-list primitive. A background means a filled box;
-                // otherwise it is stroked only. (Unchanged path - byte-identical.)
-                const node = Object.assign(Object.assign({ type: "rect", x,
-                    y,
-                    width, height: h, stroke: color, strokeWidth: borderWidth }, (backgroundColor ? { fill: backgroundColor } : {})), (radius ? { radius } : {}));
-                nodes.push(node);
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class RectangleRenderer {
+    static async render(rectangleElement, objectManager) {
+        const { x, y, width, height, children, color, backgroundColor, borderWidth, radius, sideBorders, overflow, } = rectangleElement.getProps();
+        const h = height;
+        const nodes = [];
+        if (sideBorders) {
+            // Per-side borders: a fill-only box (no stroke), then a line per present side
+            // (sharp corners). This is what lets cells draw grid lines.
+            if (backgroundColor) {
+                nodes.push({ type: "rect", x, y, width, height: h, strokeWidth: 0, fill: backgroundColor });
             }
-            // Children follow the box (Rectangle is also a container). With overflow: "hidden" they are
-            // wrapped in a clip to the (rounded) box rect, so a Positioned child is cropped at the edge
-            // instead of spilling over. Default "visible" emits no clip - byte-identical.
-            const clip = overflow === "hidden";
-            if (clip) {
-                nodes.push(Object.assign({ type: "clip-push", x, y, width, height: h }, (radius ? { radius } : {})));
-            }
-            if (children)
-                for (const child of children) {
-                    const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
-                    if (renderer) {
-                        nodes.push(...(yield renderer(child, objectManager)));
-                    }
+            nodes.push(...RectangleRenderer.sideLines(x, y, width, h, borderWidth, sideBorders));
+        }
+        else {
+            // The box itself becomes a display-list primitive. A background means a filled box;
+            // otherwise it is stroked only. (Unchanged path - byte-identical.)
+            const node = {
+                type: "rect",
+                x,
+                y,
+                width,
+                height: h,
+                stroke: color,
+                strokeWidth: borderWidth,
+                ...(backgroundColor ? { fill: backgroundColor } : {}),
+                ...(radius ? { radius } : {}),
+            };
+            nodes.push(node);
+        }
+        // Children follow the box (Rectangle is also a container). With overflow: "hidden" they are
+        // wrapped in a clip to the (rounded) box rect, so a Positioned child is cropped at the edge
+        // instead of spilling over. Default "visible" emits no clip - byte-identical.
+        const clip = overflow === "hidden";
+        if (clip) {
+            nodes.push({ type: "clip-push", x, y, width, height: h, ...(radius ? { radius } : {}) });
+        }
+        if (children)
+            for (const child of children) {
+                const renderer = RendererRegistry.getRenderer(child);
+                if (renderer) {
+                    nodes.push(...(await renderer(child, objectManager)));
                 }
-            if (clip)
-                nodes.push({ type: "clip-pop" });
-            return nodes;
-        });
+            }
+        if (clip)
+            nodes.push({ type: "clip-pop" });
+        return nodes;
     }
     /** One `line` node per present side, along the box edges (top-left coordinates). */
     static sideLines(x, y, width, height, strokeWidth, sides) {
@@ -66,4 +60,3 @@ class RectangleRenderer {
         return lines;
     }
 }
-exports.RectangleRenderer = RectangleRenderer;

package/dist/renderer/repeating-header-renderer.d.ts

@@ -1,6 +1,6 @@
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { RepeatingHeaderElement } from "../elements/layout/repeating-header-element";
-import { IRNode } from "../ir/display-list";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { RepeatingHeaderElement } from "../elements/layout/repeating-header-element.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class RepeatingHeaderRenderer {
     static render(element: RepeatingHeaderElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
 }

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

@@ -1,28 +1,13 @@
-"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.RepeatingHeaderRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class RepeatingHeaderRenderer {
-    static render(element, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { header, body } = element.getProps();
-            const nodes = [];
-            for (const child of [header, body]) {
-                const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
-                if (renderer)
-                    nodes.push(...(yield renderer(child, objectManager)));
-            }
-            return nodes;
-        });
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class RepeatingHeaderRenderer {
+    static async render(element, objectManager) {
+        const { header, body } = element.getProps();
+        const nodes = [];
+        for (const child of [header, body]) {
+            const renderer = RendererRegistry.getRenderer(child);
+            if (renderer)
+                nodes.push(...(await renderer(child, objectManager)));
+        }
+        return nodes;
     }
 }
-exports.RepeatingHeaderRenderer = RepeatingHeaderRenderer;

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

@@ -1,6 +1,6 @@
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { RowElement } from "../elements/row-element";
-import { IRNode } from "../ir/display-list";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { RowElement } from "../elements/row-element.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class RowRenderer {
     static render(rowElement: RowElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
 }

package/dist/renderer/row-renderer.js

@@ -1,30 +1,15 @@
-"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.RowRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class RowRenderer {
-    static render(rowElement, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { children } = rowElement.getProps();
-            const nodes = [];
-            if (children)
-                for (const child of children) {
-                    const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
-                    if (renderer) {
-                        nodes.push(...(yield renderer(child, objectManager)));
-                    }
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class RowRenderer {
+    static async render(rowElement, objectManager) {
+        const { children } = rowElement.getProps();
+        const nodes = [];
+        if (children)
+            for (const child of children) {
+                const renderer = RendererRegistry.getRenderer(child);
+                if (renderer) {
+                    nodes.push(...(await renderer(child, objectManager)));
                 }
-            return nodes;
-        });
+            }
+        return nodes;
     }
 }
-exports.RowRenderer = RowRenderer;

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

@@ -1,9 +1,10 @@
-import { TextElement, TextSegment } from "../elements/text-element";
-import { FontStyle, PDFObjectManager } from "../utils/pdf-object-manager";
-import type { FontMetrics } from "../utils/font-metrics";
-import { IRNode } from "../ir/display-list";
+import { TextElement, TextSegment } from "../elements/text-element.js";
+import { FontStyle, PDFObjectManager } from "../utils/pdf-object-manager.js";
+import type { FontMetrics } from "../utils/font-metrics.js";
+import { IRNode } from "../ir/display-list.js";
+import { TextOverflow } from "../text/line-breaker.js";
 export declare class TextRenderer {
-    static calculateTextHeight(content: string | TextSegment[], fontSize: number, fontFamily: string, fontStyle: FontStyle, objectManager: FontMetrics, maxWidth: number): number;
+    static calculateTextHeight(content: string | TextSegment[], fontSize: number, fontFamily: string, fontStyle: FontStyle, objectManager: FontMetrics, maxWidth: number, maxLines?: number, overflow?: TextOverflow, lineHeight?: number): number;
     static render(textElement: TextElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
     private static _buildRuns;
 }

package/dist/renderer/text-renderer.js

@@ -1,52 +1,38 @@
-"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.TextRenderer = void 0;
-const pdf_element_1 = require("../elements/pdf-element");
-const line_breaker_1 = require("../text/line-breaker");
+import { HorizontalAlignment } from "../elements/pdf-element.js";
+import { wrapStringIntoLines, breakSegmentsIntoLines, } from "../text/line-breaker.js";
 // Distance from the top of a line down to its baseline, as a fraction of the font
 // size. ~0.683 is the standard-14 ascent ratio used to seat the first baseline.
 const BASELINE_RATIO = 683 / 1000;
-class TextRenderer {
+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.)
-    static calculateTextHeight(content, fontSize, fontFamily, fontStyle, objectManager, maxWidth) {
-        // Plain string: one line height per wrapped line.
+    static calculateTextHeight(content, fontSize, fontFamily, fontStyle, objectManager, maxWidth, maxLines, overflow, lineHeight = 1) {
+        // Plain string: one line box (fontSize * lineHeight) per wrapped line.
         if (typeof content === "string") {
-            const lines = (0, line_breaker_1.wrapStringIntoLines)(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager);
-            return lines.length * fontSize;
+            const lines = wrapStringIntoLines(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager, maxLines, overflow);
+            return lines.length * fontSize * lineHeight;
         }
-        // Segments: each line contributes its own (tallest-on-line) leading.
-        const lines = (0, line_breaker_1.breakSegmentsIntoLines)(content, { fontFamily, fontSize, fontStyle }, maxWidth, objectManager);
-        return lines.reduce((total, line) => total + line.maxFontSize, 0);
+        // Segments: each line contributes its own (tallest-on-line) leading, scaled by lineHeight.
+        const lines = breakSegmentsIntoLines(content, { fontFamily, fontSize, fontStyle }, maxWidth, objectManager, maxLines, overflow);
+        return lines.reduce((total, line) => total + line.maxFontSize * lineHeight, 0);
     }
-    static render(textElement, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { x, y, width, fontSize, color, content, fontFamily, fontStyle, textAlignment } = 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.
-            return TextRenderer._buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, width !== null && width !== void 0 ? width : Number.NaN, textAlignment, color, x, y);
-        });
+    static async render(textElement, objectManager) {
+        const { x, y, width, fontSize, color, content, fontFamily, fontStyle, textAlignment, maxLines, overflow, lineHeight, } = 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.
+        return TextRenderer._buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, width ?? Number.NaN, textAlignment, color, x, y, maxLines, overflow, lineHeight);
     }
     // 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) {
+    static _buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, maxWidth, textAlignment, color, initialX, yPosition, maxLines, overflow, lineHeight = 1) {
         const runs = [];
         // Horizontal offset of a line of the given width under the current alignment.
         const alignmentOffset = (lineWidth) => {
-            if (textAlignment === pdf_element_1.HorizontalAlignment.center)
+            if (textAlignment === HorizontalAlignment.center)
                 return (maxWidth - lineWidth) / 2;
-            if (textAlignment === pdf_element_1.HorizontalAlignment.right)
+            if (textAlignment === HorizontalAlignment.right)
                 return maxWidth - lineWidth;
             return 0;
         };
@@ -62,16 +48,19 @@ class TextRenderer {
         };
         // --- Plain string: one run per wrapped line. ---
         if (typeof content === "string") {
-            const lines = (0, line_breaker_1.wrapStringIntoLines)(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager);
-            // yPosition is the top of the text box (top-left); seat line 0's baseline below
-            // it, then step DOWN per line. The seam flips the whole thing to PDF space.
-            const baseline = yPosition + fontSize * BASELINE_RATIO;
+            const lines = wrapStringIntoLines(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager, maxLines, overflow);
+            // yPosition is the top of the text box (top-left); seat line 0's baseline below it, then step
+            // DOWN by one line box (fontSize * lineHeight) per line. The lineHeight EXTRA leading is split
+            // half above / half below (CSS/Flutter "half-leading"), so the text sits centered in its line
+            // box instead of clinging to the top. At lineHeight 1 the half-leading is 0 -> byte-identical.
+            const halfLeading = (fontSize * (lineHeight - 1)) / 2;
+            const baseline = yPosition + halfLeading + fontSize * BASELINE_RATIO;
             lines.forEach((line, index) => {
                 const lineWidth = objectManager.getStringWidth(line, fontFamily, fontSize, fontStyle);
                 runs.push({
                     type: "text",
                     x: initialX + alignmentOffset(lineWidth),
-                    y: baseline + fontSize * index,
+                    y: baseline + fontSize * lineHeight * index,
                     text: line,
                     fontFamily,
                     fontStyle,
@@ -115,11 +104,13 @@ class TextRenderer {
                 overallMaxFont = size;
         }
         let lineY = yPosition + overallMaxFont * BASELINE_RATIO;
-        for (const line of (0, line_breaker_1.breakSegmentsIntoLines)(content, { fontFamily, fontSize, fontStyle }, maxWidth, objectManager)) {
-            pushLine(line, lineY);
-            lineY += line.maxFontSize;
+        for (const line of breakSegmentsIntoLines(content, { fontFamily, fontSize, fontStyle }, maxWidth, objectManager, maxLines, overflow)) {
+            // Half-leading: shift this line's baseline down by half its own extra leading, so the line
+            // sits centered in its box (CSS/Flutter). At lineHeight 1 the shift is 0 -> byte-identical.
+            const halfLeading = (line.maxFontSize * (lineHeight - 1)) / 2;
+            pushLine(line, lineY + halfLeading);
+            lineY += line.maxFontSize * lineHeight;
         }
         return runs;
     }
 }
-exports.TextRenderer = TextRenderer;

package/dist/text/line-breaker.d.ts

@@ -1,12 +1,15 @@
-import type { FontStyle } from "../utils/pdf-object-manager";
-import type { FontMetrics } from "../utils/font-metrics";
-import type { TextSegment } from "../elements/text-element";
+import type { FontStyle } from "../utils/pdf-object-manager.js";
+import type { FontMetrics } from "../utils/font-metrics.js";
+import type { TextSegment } from "../elements/text-element.js";
 /** Default font for segments that don't override it. */
 export interface SegmentDefaults {
     fontFamily: string;
     fontSize: number;
     fontStyle: FontStyle;
 }
+/** What happens to text beyond `maxLines`: `"clip"` drops it, `"ellipsis"` ends the last kept line
+ *  with an ellipsis. Mirrors Flutter's `TextOverflow`. */
+export type TextOverflow = "clip" | "ellipsis";
 /** One laid-out line of segments. `maxFontSize` is the tallest font ON THIS LINE - its
  *  leading - matching how real engines (and this lib's plain-string path) space lines. */
 export interface SegmentLine {
@@ -22,14 +25,14 @@ export interface SegmentLine {
  * rendering call this, so they can never disagree. Depends only on `FontMetrics`,
  * not the PDF byte writer - the future fragmentation pass can reuse it.
  */
-export declare function wrapStringIntoLines(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle, maxWidth: number, metrics: FontMetrics): string[];
+export declare function wrapStringIntoLines(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle, maxWidth: number, metrics: FontMetrics, maxLines?: number, overflow?: TextOverflow): string[];
 /**
  * Break styled segments into lines that fit within `maxWidth`. Same greedy
  * word-splitting as the string breaker, but each line records the tallest font on
  * THAT line as its leading (per-line, not a paragraph-global maximum). Single source
  * of truth: both height measurement and rendering call this.
  */
-export declare function breakSegmentsIntoLines(segments: TextSegment[], defaults: SegmentDefaults, maxWidth: number, metrics: FontMetrics): SegmentLine[];
+export declare function breakSegmentsIntoLines(segments: TextSegment[], defaults: SegmentDefaults, maxWidth: number, metrics: FontMetrics, maxLines?: number, overflow?: TextOverflow): SegmentLine[];
 /**
  * Inverse of `breakSegmentsIntoLines`: flatten broken lines back into a `TextSegment[]`
  * that re-wraps to exactly those lines. The wrap consumed the space at each line break,

package/dist/text/line-breaker.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapStringIntoLines = wrapStringIntoLines;
-exports.breakSegmentsIntoLines = breakSegmentsIntoLines;
-exports.segmentLinesToSegments = segmentLinesToSegments;
+/** Three ASCII dots, NOT the "…" glyph (U+2026): plain dots encode in every font - standard-14
+ *  (WinAnsi) and any embedded TTF - whereas U+2026 needs a glyph the font may not carry. */
+const ELLIPSIS = "...";
 /**
  * Break a plain string into lines that each fit within `maxWidth`, splitting on
  * spaces (greedy: a word stays on the current line unless it would overflow).
@@ -11,7 +9,7 @@ exports.segmentLinesToSegments = segmentLinesToSegments;
  * rendering call this, so they can never disagree. Depends only on `FontMetrics`,
  * not the PDF byte writer - the future fragmentation pass can reuse it.
  */
-function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, metrics) {
+export function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, metrics, maxLines, overflow) {
     let currentLine = "";
     let currentWidth = 0;
     const lines = [];
@@ -19,7 +17,10 @@ function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, me
     words.forEach((word, index) => {
         const wordWidth = metrics.getStringWidth(word, fontFamily, fontSize, fontStyle);
         const spaceWidth = metrics.getCharWidth(" ", fontSize, undefined, fontFamily, fontStyle);
-        if (currentWidth + wordWidth > maxWidth) {
+        // Break before a word that won't fit - but only once the line has content. A single word wider
+        // than maxWidth must sit on its (empty) line and overflow, not push a phantom empty line before
+        // it (which would over-count the height by a line and shift the text down at render).
+        if (currentWidth + wordWidth > maxWidth && currentLine !== "") {
             lines.push(currentLine.trim());
             currentLine = word;
             currentWidth = wordWidth;
@@ -31,7 +32,15 @@ function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, me
     });
     if (currentLine)
         lines.push(currentLine.trim());
-    return lines;
+    // Open-end by default; cap only when maxLines is set (the others get undefined → untouched).
+    if (maxLines == null || lines.length <= maxLines)
+        return lines;
+    const kept = lines.slice(0, maxLines);
+    if (overflow === "ellipsis") {
+        const last = kept.length - 1;
+        kept[last] = ellipsize(kept[last], fontFamily, fontSize, fontStyle, maxWidth, metrics);
+    }
+    return kept;
 }
 /**
  * Break styled segments into lines that fit within `maxWidth`. Same greedy
@@ -39,7 +48,7 @@ function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, me
  * THAT line as its leading (per-line, not a paragraph-global maximum). Single source
  * of truth: both height measurement and rendering call this.
  */
-function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
+export function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics, maxLines, overflow) {
     const lines = [];
     let width = 0;
     let maxFontSize = 0; // per line: starts at 0, grows to the tallest font on the line
@@ -54,13 +63,15 @@ function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
         // Start this segment's piece empty; its content is filled word-by-word below. (Not
         // the original content - otherwise a segment whose FIRST word overflows would carry
         // its whole text into the line that just closed.)
-        lineSegments.push(Object.assign(Object.assign({}, segment), { fontFamily: family, content: "" }));
+        lineSegments.push({ ...segment, fontFamily: family, content: "" });
         combined = "";
         if (maxFontSize < size)
             maxFontSize = size;
         words.forEach((word, wordIndex) => {
             const wordWidth = metrics.getStringWidth(word, family, size, style);
-            if (width + wordWidth > maxWidth) {
+            // Same guard as the string path: don't open a phantom empty line for an over-wide first word -
+            // place it (overflowing) on the current empty line instead.
+            if (width + wordWidth > maxWidth && width > 0) {
                 lines.push({ segments: lineSegments, width, maxFontSize });
                 // Start the next line; its leading resets to the wrapping segment's size.
                 width = 0;
@@ -68,13 +79,13 @@ function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
                 lineSegments = [];
                 combined = word;
                 width += wordWidth + spaceWidth;
-                lineSegments.push(Object.assign(Object.assign({}, segment), { content: combined }));
+                lineSegments.push({ ...segment, content: combined });
             }
             else {
                 combined += wordIndex === 0 ? word : " " + word;
                 width += wordWidth + spaceWidth;
                 if (lineSegments.length === 0) {
-                    lineSegments.push(Object.assign(Object.assign({}, segment), { fontFamily: family, content: combined }));
+                    lineSegments.push({ ...segment, fontFamily: family, content: combined });
                 }
                 lineSegments[lineSegments.length - 1].content = combined;
             }
@@ -83,7 +94,13 @@ function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
     if (lineSegments.length > 0) {
         lines.push({ segments: lineSegments, width, maxFontSize });
     }
-    return lines;
+    // Open-end by default; cap only when maxLines is set.
+    if (maxLines == null || lines.length <= maxLines)
+        return lines;
+    const kept = lines.slice(0, maxLines);
+    if (overflow === "ellipsis")
+        ellipsizeSegmentLine(kept[kept.length - 1], defaults, maxWidth, metrics);
+    return kept;
 }
 /**
  * Inverse of `breakSegmentsIntoLines`: flatten broken lines back into a `TextSegment[]`
@@ -92,10 +109,10 @@ function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
  * last word of a line and the first of the next would fuse ("a b" + "c d" -> "a bc d").
  * Used by text fragmentation to rebuild the fitted/remainder halves of a split paragraph.
  */
-function segmentLinesToSegments(lines) {
+export function segmentLinesToSegments(lines) {
     const result = [];
     lines.forEach((line, lineIndex) => {
-        line.segments.forEach((segment) => result.push(Object.assign({}, segment)));
+        line.segments.forEach((segment) => result.push({ ...segment }));
         if (lineIndex < lines.length - 1) {
             const last = result[result.length - 1];
             if (last && !last.content.endsWith(" "))
@@ -104,3 +121,37 @@ function segmentLinesToSegments(lines) {
     });
     return result;
 }
+/** Appends "…" to a single line, dropping trailing words (then characters) until the line plus the
+ *  ellipsis fits `maxWidth`. Falls back to a bare "…" if not even one character fits. */
+function ellipsize(line, fontFamily, fontSize, fontStyle, maxWidth, metrics) {
+    const fits = (s) => metrics.getStringWidth(s + ELLIPSIS, fontFamily, fontSize, fontStyle) <= maxWidth;
+    if (fits(line))
+        return line + ELLIPSIS;
+    const words = line.split(" ");
+    while (words.length > 1) {
+        words.pop();
+        if (fits(words.join(" ")))
+            return words.join(" ") + ELLIPSIS;
+    }
+    let single = words[0] ?? "";
+    while (single.length > 1) {
+        single = single.slice(0, -1);
+        if (fits(single))
+            return single + ELLIPSIS;
+    }
+    return ELLIPSIS;
+}
+/** Ellipsizes the LAST segment of a truncated segment line in place (within the width left by the
+ *  segments before it) and recomputes the line width. */
+function ellipsizeSegmentLine(line, defaults, maxWidth, metrics) {
+    const segs = line.segments;
+    if (segs.length === 0)
+        return;
+    const widthOf = (seg) => metrics.getStringWidth(seg.content, seg.fontFamily || defaults.fontFamily, seg.fontSize || defaults.fontSize, seg.fontStyle || defaults.fontStyle);
+    let prefix = 0;
+    for (let i = 0; i < segs.length - 1; i++)
+        prefix += widthOf(segs[i]);
+    const last = segs[segs.length - 1];
+    last.content = ellipsize(last.content, last.fontFamily || defaults.fontFamily, last.fontSize || defaults.fontSize, last.fontStyle || defaults.fontStyle, maxWidth - prefix, metrics);
+    line.width = prefix + widthOf(last);
+}

package/dist/text/text-style.d.ts

@@ -0,0 +1,25 @@
+import { Color } from "../common/color.js";
+import { FontStyle } from "../utils/pdf-object-manager.js";
+import { HorizontalAlignment } from "../elements/pdf-element.js";
+/**
+ * The inheritable text properties - the same set CSS and Flutter cascade. A `Text` resolves each of
+ * its own (possibly unset) properties against the nearest cascaded style: explicit > inherited >
+ * built-in default. Box/layout properties (padding, border, width, ...) are deliberately NOT here -
+ * they never inherit, exactly as in CSS.
+ */
+export interface ResolvedTextStyle {
+    fontSize: number;
+    fontFamily: string;
+    fontStyle: FontStyle;
+    color: Color;
+    textAlignment: HorizontalAlignment;
+    lineHeight: number;
+}
+/**
+ * The root of the cascade: what a `Text` falls back to when neither it nor any ancestor sets a
+ * property. These MUST match the historical `Text` defaults so a document that sets nothing renders
+ * byte-for-byte as before.
+ */
+export declare const DEFAULT_TEXT_STYLE: ResolvedTextStyle;
+/** Layers a partial override onto a complete style; an unset (undefined) field keeps the base. */
+export declare function mergeTextStyle(base: ResolvedTextStyle, override?: Partial<ResolvedTextStyle>): ResolvedTextStyle;

package/dist/text/text-style.js

@@ -0,0 +1,29 @@
+import { Color } from "../common/color.js";
+import { FontStyle } from "../utils/pdf-object-manager.js";
+import { HorizontalAlignment } from "../elements/pdf-element.js";
+/**
+ * The root of the cascade: what a `Text` falls back to when neither it nor any ancestor sets a
+ * property. These MUST match the historical `Text` defaults so a document that sets nothing renders
+ * byte-for-byte as before.
+ */
+export const DEFAULT_TEXT_STYLE = {
+    fontSize: 12,
+    fontFamily: "Helvetica",
+    fontStyle: FontStyle.Normal,
+    color: new Color(0, 0, 0),
+    textAlignment: HorizontalAlignment.left,
+    lineHeight: 1,
+};
+/** Layers a partial override onto a complete style; an unset (undefined) field keeps the base. */
+export function mergeTextStyle(base, override) {
+    if (!override)
+        return base;
+    return {
+        fontSize: override.fontSize ?? base.fontSize,
+        fontFamily: override.fontFamily ?? base.fontFamily,
+        fontStyle: override.fontStyle ?? base.fontStyle,
+        color: override.color ?? base.color,
+        textAlignment: override.textAlignment ?? base.textAlignment,
+        lineHeight: override.lineHeight ?? base.lineHeight,
+    };
+}