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

package/dist/elements/page-element.js

@@ -1,22 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PageElement = void 0;
-exports.resolvePageContentBox = resolvePageContentBox;
-exports.layoutPageBands = layoutPageBands;
-const page_sizes_1 = require("../constants/page-sizes");
-const pdf_config_1 = require("../renderer/pdf-config");
-const box_constraints_1 = require("../layout/box-constraints");
-const pdf_element_1 = require("./pdf-element");
+import { pageFormats } from "../constants/page-sizes.js";
+import { Orientation } from "../renderer/pdf-config.js";
+import { BoxConstraints } from "../layout/box-constraints.js";
+import { PDFElement } from "./pdf-element.js";
 /**
  * The content box of a page (inside the margins, orientation applied) for a fully
  * resolved config. Single source of truth, shared by `PageElement` layout and the page
  * driver so they can never drift.
  */
-function resolvePageContentBox(config) {
+export function resolvePageContentBox(config) {
     const margin = config.margin;
-    let width = page_sizes_1.pageFormats[config.pageSize][0] - margin.left - margin.right;
-    let height = page_sizes_1.pageFormats[config.pageSize][1] - margin.top - margin.bottom;
-    if (config.orientation === pdf_config_1.Orientation.landscape) {
+    const [pageW, pageH] = config.customSize ?? pageFormats[config.pageSize];
+    let width = pageW - margin.left - margin.right;
+    let height = pageH - margin.top - margin.bottom;
+    if (config.orientation === Orientation.landscape) {
         [width, height] = [height, width];
     }
     return { origin: { x: margin.left, y: margin.top }, width, height };
@@ -29,17 +25,17 @@ function resolvePageContentBox(config) {
  * no header/footer the bands are zero and the body equals the full content box - identical
  * to a page without them.
  */
-function layoutPageBands(config, header, footer, ctx) {
+export function layoutPageBands(config, header, footer, ctx) {
     const { origin, width, height } = resolvePageContentBox(config);
     let headerHeight = 0;
     if (header) {
-        headerHeight = header.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), origin, ctx).height;
+        headerHeight = header.calculateLayout(BoxConstraints.loose(width, Infinity), origin, ctx).height;
     }
     let footerHeight = 0;
     if (footer) {
         // Measure first to learn its height, then place it flush against the bottom edge.
-        footerHeight = footer.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), origin, ctx).height;
-        footer.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), { x: origin.x, y: origin.y + height - footerHeight }, ctx);
+        footerHeight = footer.calculateLayout(BoxConstraints.loose(width, Infinity), origin, ctx).height;
+        footer.calculateLayout(BoxConstraints.loose(width, Infinity), { x: origin.x, y: origin.y + height - footerHeight }, ctx);
     }
     return {
         bodyOrigin: { x: origin.x, y: origin.y + headerHeight },
@@ -49,11 +45,11 @@ function layoutPageBands(config, header, footer, ctx) {
         footerHeight,
     };
 }
-class PageElement extends pdf_element_1.PDFElement {
+export class PageElement extends PDFElement {
     constructor({ children, config, header, footer }) {
         super();
         this.children = children;
-        this.config = config !== null && config !== void 0 ? config : {};
+        this.config = config ?? {};
         this.header = header;
         this.footer = footer;
     }
@@ -61,15 +57,17 @@ class PageElement extends pdf_element_1.PDFElement {
         // Merge the document defaults (carried in the context) with this page's overrides,
         // then hand descendants a context bound to THIS page's geometry. This is what
         // fixes the old last-page-wins global page-config bug.
-        this.config = Object.assign(Object.assign({}, ctx.pageConfig), this.config);
+        this.config = { ...ctx.pageConfig, ...this.config };
         const pageCtx = {
             metrics: ctx.metrics,
             pageConfig: this.config,
+            textStyle: ctx.textStyle,
+            onOverflow: ctx.onOverflow,
         };
         // Place the header/footer bands; the body gets the region left in between (the whole
         // content box when there is neither - byte-identical to a plain page).
         const bands = layoutPageBands(this.config, this.header, this.footer, pageCtx);
-        const childConstraints = box_constraints_1.BoxConstraints.loose(bands.bodyWidth, bands.bodyHeight);
+        const childConstraints = BoxConstraints.loose(bands.bodyWidth, bands.bodyHeight);
         // The page body is itself a positioning frame: a `Positioned` with no `relative` ancestor
         // resolves against the content box (a `relative` Box overrides it for its own subtree). Drained
         // after the body is laid out, so a page-level Positioned isn't a silent no-op.
@@ -78,7 +76,7 @@ class PageElement extends pdf_element_1.PDFElement {
             size: { width: bands.bodyWidth, height: bands.bodyHeight },
             place: [],
         };
-        const bodyCtx = Object.assign(Object.assign({}, pageCtx), { frame });
+        const bodyCtx = { ...pageCtx, frame };
         this.children.forEach((child) => child.calculateLayout(childConstraints, bands.bodyOrigin, bodyCtx));
         for (const place of frame.place)
             place(frame, pageCtx);
@@ -98,4 +96,3 @@ class PageElement extends pdf_element_1.PDFElement {
         return this;
     }
 }
-exports.PageElement = PageElement;

package/dist/elements/pdf-document-element.d.ts

@@ -1,12 +1,18 @@
-import { PageElement } from "./page-element";
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
-import { LayoutContext, PDFElement, WithChildren } from "./pdf-element";
+import { PageElement } from "./page-element.js";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import { LayoutContext, PDFElement, WithChildren } from "./pdf-element.js";
+import type { ResolvedTextStyle } from "../text/text-style.js";
 interface PDFDocumentParams extends WithChildren {
     children: PageElement[];
+    /** Document-level text defaults descendants inherit (seeded into the layout-context root). */
+    defaultTextStyle?: Partial<ResolvedTextStyle>;
 }
 export declare class PDFDocumentElement extends PDFElement {
     private children;
-    constructor({ children }: PDFDocumentParams);
+    private defaultTextStyle?;
+    constructor({ children, defaultTextStyle }: PDFDocumentParams);
+    /** The document-level text defaults; the renderer merges them into the cascade root. */
+    getDefaultTextStyle(): Partial<ResolvedTextStyle> | undefined;
     calculateLayout(_constraints: BoxConstraints, _offset: Offset, ctx: LayoutContext): Size;
     getProps(): PDFDocumentParams;
 }

package/dist/elements/pdf-document-element.js

@@ -1,22 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PDFDocumentElement = void 0;
-const box_constraints_1 = require("../layout/box-constraints");
-const pdf_element_1 = require("./pdf-element");
-class PDFDocumentElement extends pdf_element_1.PDFElement {
-    constructor({ children }) {
+import { BoxConstraints } from "../layout/box-constraints.js";
+import { PDFElement } from "./pdf-element.js";
+export class PDFDocumentElement extends PDFElement {
+    constructor({ children, defaultTextStyle }) {
         super();
         this.children = children;
+        this.defaultTextStyle = defaultTextStyle;
+    }
+    /** The document-level text defaults; the renderer merges them into the cascade root. */
+    getDefaultTextStyle() {
+        return this.defaultTextStyle;
     }
     calculateLayout(_constraints, _offset, ctx) {
         // The document is the root: each page derives its own geometry, so it ignores the
         // incoming constraints/offset. It has no size of its own.
         const origin = { x: 0, y: 0 };
-        this.children.forEach((child) => child.calculateLayout(new box_constraints_1.BoxConstraints(), origin, ctx));
+        this.children.forEach((child) => child.calculateLayout(new BoxConstraints(), origin, ctx));
         return { width: 0, height: 0 };
     }
     getProps() {
-        return { children: this.children };
+        return { children: this.children, defaultTextStyle: this.defaultTextStyle };
     }
 }
-exports.PDFDocumentElement = PDFDocumentElement;

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

@@ -1,6 +1,8 @@
-import type { FontMetrics } from "../utils/font-metrics";
-import type { PDFPageConfig } from "./page-element";
-import type { BoxConstraints, Offset, Size } from "../layout/box-constraints";
+import type { FontMetrics } from "../utils/font-metrics.js";
+import type { PDFPageConfig } from "./page-element.js";
+import type { ResolvedTextStyle } from "../text/text-style.js";
+import type { OverflowPolicy } from "../layout/fragmentation.js";
+import type { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
 /**
  * Everything the layout pass needs, threaded explicitly (no global singleton):
  * font metrics for measuring, and the geometry of the page currently being laid out.
@@ -26,6 +28,13 @@ export interface LayoutContext {
     pageConfig: PDFPageConfig;
     /** The nearest enclosing positioning frame, if any (set by a `relative` Box). */
     frame?: PositioningFrame;
+    /** The cascaded text style descendants inherit (CSS/Flutter-style). Seeded at the document root
+     *  from the built-in defaults + the `Document` defaults, and carried through page contexts; a
+     *  `Text` resolves its own unset properties against it. Absent falls back to the built-in defaults. */
+    textStyle?: ResolvedTextStyle;
+    /** What to do when an element overflows a page region and cannot break (set from the render option;
+     *  absent = clip silently). Evaluated in `packChildren` where the forced placement happens. */
+    onOverflow?: OverflowPolicy;
 }
 export declare abstract class PDFElement {
     abstract getProps(): unknown;

package/dist/elements/pdf-element.js

@@ -1,13 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VerticalAlignment = exports.HorizontalAlignment = exports.FlexiblePDFElement = exports.SizedPDFElement = exports.PDFElement = void 0;
-exports.isSizedElement = isSizedElement;
-exports.hasChildrenProp = hasChildrenProp;
-exports.hasChildProp = hasChildProp;
-class PDFElement {
+export class PDFElement {
 }
-exports.PDFElement = PDFElement;
-class SizedPDFElement extends PDFElement {
+export class SizedPDFElement extends PDFElement {
     constructor(data) {
         super();
         this.x = data.x;
@@ -19,8 +12,7 @@ class SizedPDFElement extends PDFElement {
         return { x: this.x, y: this.y, width: this.width, height: this.height };
     }
 }
-exports.SizedPDFElement = SizedPDFElement;
-class FlexiblePDFElement extends PDFElement {
+export class FlexiblePDFElement extends PDFElement {
     constructor(data) {
         super();
         this.flex = data.flex;
@@ -30,26 +22,25 @@ class FlexiblePDFElement extends PDFElement {
         return this.flex;
     }
 }
-exports.FlexiblePDFElement = FlexiblePDFElement;
-var HorizontalAlignment;
+export var HorizontalAlignment;
 (function (HorizontalAlignment) {
     HorizontalAlignment["left"] = "LEFT";
     HorizontalAlignment["right"] = "RIGHT";
     HorizontalAlignment["center"] = "CENTER";
     HorizontalAlignment["block"] = "BLOCK";
-})(HorizontalAlignment || (exports.HorizontalAlignment = HorizontalAlignment = {}));
-var VerticalAlignment;
+})(HorizontalAlignment || (HorizontalAlignment = {}));
+export var VerticalAlignment;
 (function (VerticalAlignment) {
     VerticalAlignment["top"] = "TOP";
     VerticalAlignment["middle"] = "MIDDLE";
     VerticalAlignment["bottom"] = "BOTTOM";
-})(VerticalAlignment || (exports.VerticalAlignment = VerticalAlignment = {}));
-function isSizedElement(obj) {
+})(VerticalAlignment || (VerticalAlignment = {}));
+export function isSizedElement(obj) {
     return typeof obj === "object" && obj !== null && "x" in obj && "y" in obj;
 }
-function hasChildrenProp(obj) {
+export function hasChildrenProp(obj) {
     return "children" in obj;
 }
-function hasChildProp(obj) {
+export function hasChildProp(obj) {
     return "child" in obj;
 }

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

@@ -1,8 +1,8 @@
-import { Color } from "../common/color";
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
-import { Fragmentable, FragmentResult } from "../layout/fragmentation";
-import { LayoutContext, PDFElement, SizedElement, SizedPDFElement, WithChildren } from "./pdf-element";
-/** Per-side border colours. When set, each present side is stroked individually (sharp
+import { Color } from "../common/color.js";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import { Fragmentable, FragmentResult } from "../layout/fragmentation.js";
+import { LayoutContext, PDFElement, SizedElement, SizedPDFElement, WithChildren } from "./pdf-element.js";
+/** Per-side border colors. When set, each present side is stroked individually (sharp
  *  corners), instead of the uniform `color` border - this is what enables grid lines. */
 export interface SideBorders {
     top?: Color;

package/dist/elements/rectangle-element.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RectangleElement = void 0;
-const color_1 = require("../common/color");
-const box_constraints_1 = require("../layout/box-constraints");
-const fragmentation_1 = require("../layout/fragmentation");
-const pdf_element_1 = require("./pdf-element");
-class RectangleElement extends pdf_element_1.SizedPDFElement {
-    constructor({ children = [], color = new color_1.Color(0, 0, 0), backgroundColor, borderWidth, width, height, radius, sideBorders, relative, overflow, }) {
+import { Color } from "../common/color.js";
+import { BoxConstraints } from "../layout/box-constraints.js";
+import { packChildren } from "../layout/fragmentation.js";
+import { SizedPDFElement, } from "./pdf-element.js";
+export class RectangleElement extends SizedPDFElement {
+    constructor({ children = [], color = new Color(0, 0, 0), backgroundColor, borderWidth, width, height, radius, sideBorders, relative, overflow, }) {
         super({ x: 0, y: 0, width, height });
         this.children = [];
         this.children = children;
         this.color = color;
         this.backgroundColor = backgroundColor;
         // `?? 1` (not `|| 1`) so an explicit `0` means "no border" instead of snapping to 1.
-        this.borderWidth = borderWidth !== null && borderWidth !== void 0 ? borderWidth : 1;
-        this.radius = radius !== null && radius !== void 0 ? radius : 0;
+        this.borderWidth = borderWidth ?? 1;
+        this.radius = radius ?? 0;
         this.sideBorders = sideBorders;
-        this.relative = relative !== null && relative !== void 0 ? relative : false;
-        this.overflow = overflow !== null && overflow !== void 0 ? overflow : "visible";
+        this.relative = relative ?? false;
+        this.overflow = overflow ?? "visible";
         this.sizeMemory = { x: 0, y: 0, width, height };
     }
     /**
@@ -29,17 +26,16 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
      * box is sized by what it actually holds on each page.
      */
     fragment(maxHeight, width, ctx) {
-        var _a;
-        const boxWidth = (_a = this.sizeMemory.width) !== null && _a !== void 0 ? _a : width;
+        const boxWidth = this.sizeMemory.width ?? width;
         const innerWidth = Math.max(0, boxWidth - 2 * this.borderWidth);
         // Border-box: the content is inset by the border on top and bottom, so a fragment
         // holding `c` of content is `c + 2*border` tall. (Derived, not a fudge factor.)
         const innerMaxHeight = maxHeight - 2 * this.borderWidth;
-        const { fitted, remainder } = (0, fragmentation_1.packChildren)(this.children, innerMaxHeight, innerWidth, ctx);
+        const { fitted, remainder } = packChildren(this.children, innerMaxHeight, innerWidth, ctx);
         if (remainder.length === 0)
             return { fitted: this, remainder: null };
         const contentHeight = (kids) => kids.reduce((sum, child) => sum +
-            child.calculateLayout(box_constraints_1.BoxConstraints.loose(innerWidth, Infinity), { x: 0, y: 0 }, ctx)
+            child.calculateLayout(BoxConstraints.loose(innerWidth, Infinity), { x: 0, y: 0 }, ctx)
                 .height, 0);
         return {
             fitted: this.cloneWithChildren(fitted, contentHeight(fitted) + 2 * this.borderWidth),
@@ -63,7 +59,6 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         });
     }
     calculateLayout(constraints, offset, ctx) {
-        var _a, _b, _c, _d, _e;
         // Width: an explicit size wins (clamped), else fill the offered box. (Without this a
         // fixed box would balloon to the parent's size.)
         this.width =
@@ -93,17 +88,17 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         const frame = this.relative
             ? { origin: { x: 0, y: 0 }, size: { width: 0, height: 0 }, place: [] }
             : undefined;
-        const childCtx = frame ? Object.assign(Object.assign({}, ctx), { frame }) : ctx;
+        const childCtx = frame ? { ...ctx, frame } : ctx;
         // Lay out children stacked inside the border (inset by the border width). Width is
         // finalized here; height is left unbounded so each child sizes to its own content.
         const innerWidth = shrinkWrapWidth
             ? Infinity
-            : Math.max(0, ((_a = this.width) !== null && _a !== void 0 ? _a : 0) - 2 * this.borderWidth);
+            : Math.max(0, (this.width ?? 0) - 2 * this.borderWidth);
         let contentWidth = 0;
         let contentHeight = 0;
         let yCursor = this.y + this.borderWidth;
         for (const child of this.children) {
-            const childSize = child.calculateLayout(box_constraints_1.BoxConstraints.loose(innerWidth, Infinity), { x: this.x + this.borderWidth, y: yCursor }, childCtx);
+            const childSize = child.calculateLayout(BoxConstraints.loose(innerWidth, Infinity), { x: this.x + this.borderWidth, y: yCursor }, childCtx);
             yCursor += childSize.height;
             contentHeight += childSize.height;
             contentWidth = Math.max(contentWidth, childSize.width);
@@ -117,7 +112,7 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         // The box is sized now: place any out-of-flow `Positioned` descendants against its box.
         if (frame) {
             frame.origin = { x: this.x, y: this.y };
-            frame.size = { width: (_b = this.width) !== null && _b !== void 0 ? _b : 0, height: (_c = this.height) !== null && _c !== void 0 ? _c : 0 };
+            frame.size = { width: this.width ?? 0, height: this.height ?? 0 };
             for (const place of frame.place)
                 place(frame, ctx);
         }
@@ -126,8 +121,8 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         // border added on (that asymmetric "+border" was the source of the magic-3 fudge in
         // fragment). Top-left coordinates; the Y-flip happens at the IR -> backend seam.
         return {
-            width: (_d = this.width) !== null && _d !== void 0 ? _d : 0,
-            height: (_e = this.height) !== null && _e !== void 0 ? _e : 0,
+            width: this.width ?? 0,
+            height: this.height ?? 0,
         };
     }
     getProps() {
@@ -146,4 +141,3 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         };
     }
 }
-exports.RectangleElement = RectangleElement;

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

@@ -1,6 +1,6 @@
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
-import { MainAlign, CrossAlign } from "../utils/flex-layout";
-import { LayoutContext, PDFElement, SizedPDFElement, WithChildren } from "./pdf-element";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import { MainAlign, CrossAlign } from "../utils/flex-layout.js";
+import { LayoutContext, PDFElement, SizedPDFElement, WithChildren } from "./pdf-element.js";
 interface RowElementParams extends WithChildren {
     /** Space inserted between children, in points. */
     gap?: number;

package/dist/elements/row-element.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RowElement = void 0;
-const flex_layout_1 = require("../utils/flex-layout");
-const pdf_element_1 = require("./pdf-element");
+import { FlexLayoutHelper, HORIZONTAL_AXIS } from "../utils/flex-layout.js";
+import { SizedPDFElement } from "./pdf-element.js";
 /**
  * Horizontal stack: the mirror of `ContainerElement` (Column). Children are laid out
  * left-to-right via the shared `FlexLayoutHelper` on the horizontal axis; fixed children
@@ -15,13 +12,13 @@ const pdf_element_1 = require("./pdf-element");
  * does not fit (handled by the parent's `packChildren`); synchronized cell splitting is a
  * Grid/Table concern.
  */
-class RowElement extends pdf_element_1.SizedPDFElement {
+export class RowElement extends SizedPDFElement {
     constructor({ children, gap, main, cross }) {
         super({ x: 0, y: 0 });
         this.children = children;
-        this.gap = gap !== null && gap !== void 0 ? gap : 0;
-        this.main = main !== null && main !== void 0 ? main : "start";
-        this.cross = cross !== null && cross !== void 0 ? cross : "stretch";
+        this.gap = gap ?? 0;
+        this.main = main ?? "start";
+        this.cross = cross ?? "stretch";
     }
     calculateLayout(constraints, offset, ctx) {
         this.x = offset.x;
@@ -32,7 +29,7 @@ class RowElement extends pdf_element_1.SizedPDFElement {
         const crossAvail = constraints.hasBoundedHeight ? constraints.maxHeight : Infinity;
         let result = { mainUsed: 0, crossUsed: 0 };
         if (this.children.length > 0) {
-            result = flex_layout_1.FlexLayoutHelper.layout(this.children, flex_layout_1.HORIZONTAL_AXIS, mainAvail, crossAvail, this.x, this.y, { gap: this.gap, main: this.main, cross: this.cross }, ctx);
+            result = FlexLayoutHelper.layout(this.children, HORIZONTAL_AXIS, mainAvail, crossAvail, this.x, this.y, { gap: this.gap, main: this.main, cross: this.cross }, ctx);
         }
         this.width = constraints.hasBoundedWidth ? constraints.maxWidth : result.mainUsed;
         this.height = constraints.hasBoundedHeight ? constraints.maxHeight : result.crossUsed;
@@ -51,4 +48,3 @@ class RowElement extends pdf_element_1.SizedPDFElement {
         };
     }
 }
-exports.RowElement = RowElement;

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

@@ -1,8 +1,9 @@
-import { Color } from "../common/color";
-import { FontStyle } from "../utils/pdf-object-manager";
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
-import { Fragmentable, FragmentResult } from "../layout/fragmentation";
-import { HorizontalAlignment, LayoutContext, SizedPDFElement } from "./pdf-element";
+import { Color } from "../common/color.js";
+import { FontStyle } from "../utils/pdf-object-manager.js";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import { Fragmentable, FragmentResult } from "../layout/fragmentation.js";
+import { TextOverflow } from "../text/line-breaker.js";
+import { HorizontalAlignment, LayoutContext, SizedPDFElement } from "./pdf-element.js";
 export interface TextSegment {
     content: string;
     fontStyle?: FontStyle;
@@ -12,21 +13,39 @@ export interface TextSegment {
 }
 interface TextElementParams {
     id?: string;
-    fontSize: number;
+    /** Unset (undefined) inherits the cascaded size; see ResolvedTextStyle. */
+    fontSize?: number;
     fontFamily?: string;
     fontStyle?: FontStyle;
     content: string | TextSegment[];
     color?: Color;
     textAlignment?: HorizontalAlignment;
+    /** Cap the wrapped lines (default: unlimited / open-end). */
+    maxLines?: number;
+    /** What to do past `maxLines`: `"clip"` (default) drops them, `"ellipsis"` ends with "…". */
+    overflow?: TextOverflow;
+    /** Line-height multiplier: each line is `fontSize * lineHeight` tall (default `1`). */
+    lineHeight?: number;
 }
 export declare class TextElement extends SizedPDFElement implements Fragmentable {
+    private readonly rawFontSize?;
+    private readonly rawFontFamily?;
+    private readonly rawFontStyle?;
+    private readonly rawColor?;
+    private readonly rawTextAlignment?;
+    private readonly rawLineHeight?;
     private fontSize;
     private fontFamily;
     private fontStyle;
     private color;
-    private content;
     private textAlignment;
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, }: TextElementParams);
+    private lineHeight;
+    private content;
+    private maxLines?;
+    private overflow;
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow, lineHeight, }: TextElementParams);
+    private resolveStyle;
+    private applyStyle;
     /**
      * Splits the paragraph at line boxes (Slice 1). The lines that fit in `maxHeight` stay;
      * the rest become a remainder `TextElement` re-wrapped on the next page. If not even one
@@ -39,9 +58,13 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     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).
-     *  Mirrors the renderer's advance EXACTLY: per-glyph, WITHOUT kerning. `getStringWidth` subtracts
-     *  kerning, so it under-reserves and the text would wrap inside its own natural-width box - the cause
-     *  of fixed Row children wrapping despite ample space. */
+     *  Must match the LINE-BREAKER's one-line measure EXACTLY - not just algebraically but BIT-for-bit,
+     *  so a text laid out at this width never re-wraps inside its own natural-width box. The breaker
+     *  accumulates `currentWidth += wordWidth + spaceWidth`, grouping the word and its trailing space
+     *  into one term; we must group the same way. Adding word and space as two separate steps is
+     *  algebraically equal but, because floating-point addition is not associative, drifts by a sub-ULP
+     *  - 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;
     getProps(): {
         x: number;
@@ -54,6 +77,9 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
         color: Color;
         content: string | TextSegment[];
         textAlignment: HorizontalAlignment;
+        maxLines: number | undefined;
+        overflow: TextOverflow;
+        lineHeight: number;
     };
 }
 export {};