@jasy/pdf 1.0.0-alpha.7 → 1.0.0-alpha.9

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

@@ -3,6 +3,7 @@ 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";
+import type { CrossAlign } from "../layout/alignment.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.
@@ -29,8 +30,18 @@ export interface PositioningFrame {
  * the document's final physical page total. `pageSize` is the media box in points, orientation applied.
  */
 export interface PageInfo {
+    /** 1-based, counting PHYSICAL pages across the whole document. */
     pageNumber: number;
+    /** Physical pages in the whole document. */
     pageCount: number;
+    /**
+     * 1-based within the LOGICAL page this sheet came from - the `Page(...)` element the author wrote.
+     * A document of one `Page` has `subPageNumber === pageNumber`; a document of several (an invoice
+     * plus its attachment, say) restarts the count at each one.
+     */
+    subPageNumber: number;
+    /** Physical pages this logical page produced. */
+    subPageTotalPages: number;
     pageSize: {
         width: number;
         height: number;
@@ -108,6 +119,31 @@ export declare abstract class PDFElement {
      * parent packer once this element has been placed whole. Default: no.
      */
     breaksAfter(): boolean;
+    /**
+     * This child's own cross-axis alignment inside its Column / Row (CSS `align-self`), overriding the
+     * container's `align`. Lives on the base element because any child of a stack may set it, not just
+     * the sized ones. `undefined` means "follow the container".
+     */
+    alignSelf?: CrossAlign;
+    /** Sets `alignSelf` and returns the element, so a factory can thread it through in one expression. */
+    withAlignSelf(align: CrossAlign | undefined): this;
+    /**
+     * Where this child sits among its siblings (CSS `order`), lowest first, source order deciding ties.
+     * It moves the child in the LAYOUT only - the element tree, and therefore the reading order a tagged
+     * PDF exposes, is untouched. Default 0.
+     */
+    order: number;
+    /**
+     * How willingly this child gives up main-axis space when the line overflows (CSS `flex-shrink`),
+     * weighted by its own size as CSS does. **Default 0, deliberately unlike CSS's 1**: shrinking is a
+     * change of what a document LOOKS like, and every document written before this existed must keep
+     * laying out exactly as it did. Opt in per child.
+     */
+    flexShrink: number;
+    /** Sets `flexShrink` and returns the element. */
+    withFlexShrink(shrink: number | undefined): this;
+    /** Sets `order` and returns the element, so a factory can thread it through in one expression. */
+    withOrder(order: number | undefined): this;
 }
 export declare abstract class SizedPDFElement extends PDFElement {
     protected x: number;
@@ -120,14 +156,32 @@ export declare abstract class SizedPDFElement extends PDFElement {
 export declare abstract class FlexiblePDFElement extends PDFElement {
     protected flex: number;
     protected verticalChildAlignment: VerticalAlignment;
+    /** Points reserved before any leftover is shared out (CSS `flex-basis`); default 0. */
+    protected basis: number;
+    /** The same as a fraction of the line, for `flexBasis: "25%"`. */
+    protected basisFactor?: number;
     constructor(data: FlexibleElement);
     getFlex(): number;
+    /**
+     * The main extent this child starts from, before the leftover is shared out. `lineMain` is what the
+     * line offers its items (its extent minus the gaps), so a percentage basis resolves against the same
+     * base a percentage WIDTH already does - and falls back to 0 on an unbounded axis, where a fraction
+     * has no meaning.
+     */
+    /** Whether a PERCENTAGE basis was given - it resolves to 0 on an unbounded axis, so asking for the
+     *  number alone cannot tell "no basis" from "a basis that does not apply here". */
+    hasBasisFactor(): boolean;
+    getBasis(lineMain: number): number;
 }
 export declare enum HorizontalAlignment {
+    /** CSS `text-align: start` - the side the writing STARTS on: left in `ltr`, right in `rtl`. The
+     *  default, so a right-to-left paragraph begins on the right without anyone asking for it. */
+    start = "START",
     left = "LEFT",
     right = "RIGHT",
     center = "CENTER",
-    block = "BLOCK"
+    /** CSS `text-align: justify` - both edges line up, the last line of a paragraph excepted. */
+    justify = "JUSTIFY"
 }
 export declare enum VerticalAlignment {
     top = "TOP",
@@ -142,6 +196,10 @@ export interface WithChild {
 }
 export interface FlexibleElement {
     flex: number;
+    /** Points reserved before the leftover is shared out (CSS `flex-basis`). */
+    basis?: number;
+    /** The same as a fraction of the line, for `flexBasis: "25%"`. */
+    basisFactor?: number;
     verticalChildAlignment?: VerticalAlignment;
 }
 export interface SizedElement {

package/dist/elements/pdf-element.js

@@ -5,6 +5,19 @@ export class PDFElement {
         // fragmentation copies (adoptStructId), so a paragraph or table split across pages stays ONE structure
         // element. Only the elements that actually tag (Text, Image, StructGroup) read it.
         this._structId = _nextStructId++;
+        /**
+         * Where this child sits among its siblings (CSS `order`), lowest first, source order deciding ties.
+         * It moves the child in the LAYOUT only - the element tree, and therefore the reading order a tagged
+         * PDF exposes, is untouched. Default 0.
+         */
+        this.order = 0;
+        /**
+         * How willingly this child gives up main-axis space when the line overflows (CSS `flex-shrink`),
+         * weighted by its own size as CSS does. **Default 0, deliberately unlike CSS's 1**: shrinking is a
+         * change of what a document LOOKS like, and every document written before this existed must keep
+         * laying out exactly as it did. Opt in per child.
+         */
+        this.flexShrink = 0;
     }
     get structId() {
         return this._structId;
@@ -65,6 +78,31 @@ export class PDFElement {
     breaksAfter() {
         return false;
     }
+    /** Sets `alignSelf` and returns the element, so a factory can thread it through in one expression. */
+    withAlignSelf(align) {
+        if (align !== undefined)
+            this.alignSelf = align;
+        return this;
+    }
+    /** Sets `flexShrink` and returns the element. */
+    withFlexShrink(shrink) {
+        if (shrink !== undefined) {
+            if (!Number.isFinite(shrink) || shrink < 0) {
+                throw new Error(`Invalid flexShrink ${shrink}: it must be a number of at least 0.`);
+            }
+            this.flexShrink = shrink;
+        }
+        return this;
+    }
+    /** Sets `order` and returns the element, so a factory can thread it through in one expression. */
+    withOrder(order) {
+        if (order !== undefined) {
+            if (!Number.isFinite(order))
+                throw new Error(`Invalid order ${order}: it must be a number.`);
+            this.order = order;
+        }
+        return this;
+    }
 }
 export class SizedPDFElement extends PDFElement {
     constructor(data) {
@@ -83,17 +121,40 @@ export class FlexiblePDFElement extends PDFElement {
         super();
         this.flex = data.flex;
         this.verticalChildAlignment = data.verticalChildAlignment || VerticalAlignment.middle;
+        this.basis = data.basis ?? 0;
+        this.basisFactor = data.basisFactor;
     }
     getFlex() {
         return this.flex;
     }
+    /**
+     * The main extent this child starts from, before the leftover is shared out. `lineMain` is what the
+     * line offers its items (its extent minus the gaps), so a percentage basis resolves against the same
+     * base a percentage WIDTH already does - and falls back to 0 on an unbounded axis, where a fraction
+     * has no meaning.
+     */
+    /** Whether a PERCENTAGE basis was given - it resolves to 0 on an unbounded axis, so asking for the
+     *  number alone cannot tell "no basis" from "a basis that does not apply here". */
+    hasBasisFactor() {
+        return this.basisFactor !== undefined;
+    }
+    getBasis(lineMain) {
+        if (this.basisFactor !== undefined) {
+            return Number.isFinite(lineMain) ? lineMain * this.basisFactor : 0;
+        }
+        return this.basis;
+    }
 }
 export var HorizontalAlignment;
 (function (HorizontalAlignment) {
+    /** CSS `text-align: start` - the side the writing STARTS on: left in `ltr`, right in `rtl`. The
+     *  default, so a right-to-left paragraph begins on the right without anyone asking for it. */
+    HorizontalAlignment["start"] = "START";
     HorizontalAlignment["left"] = "LEFT";
     HorizontalAlignment["right"] = "RIGHT";
     HorizontalAlignment["center"] = "CENTER";
-    HorizontalAlignment["block"] = "BLOCK";
+    /** CSS `text-align: justify` - both edges line up, the last line of a paragraph excepted. */
+    HorizontalAlignment["justify"] = "JUSTIFY";
 })(HorizontalAlignment || (HorizontalAlignment = {}));
 export var VerticalAlignment;
 (function (VerticalAlignment) {

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

@@ -1,3 +1,5 @@
+import type { Radii } from "../ir/display-list.js";
+import type { GradientInput } from "../api/gradient.js";
 import { Color } from "../common/color.js";
 import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
 import { Fragmentable, FragmentResult } from "../layout/fragmentation.js";
@@ -12,10 +14,11 @@ export interface SideBorders {
 }
 interface RectangleElementParams extends SizedElement, WithChildren {
     color?: Color;
-    backgroundColor?: Color;
+    /** Solid colour, or a box-relative gradient the renderer resolves against this box. */
+    backgroundColor?: Color | GradientInput;
     borderWidth?: number;
-    /** Corner radius in points; 0 = sharp corners (default). */
-    radius?: number;
+    /** Corner radius in points - one number for all four corners, or per corner. 0 = sharp (default). */
+    radius?: number | Radii;
     /** Individual side borders; overrides the uniform `color` border when present. */
     sideBorders?: SideBorders;
     /** When true, this box is a positioning frame for `Positioned` descendants (CSS `relative`). */
@@ -28,6 +31,17 @@ interface RectangleElementParams extends SizedElement, WithChildren {
     widthFactor?: number;
     /** Height as a fraction (0..1) of the offered height; see `widthFactor`. */
     heightFactor?: number;
+    /** Lower / upper bounds per axis, in points or as a fraction; see `SizingParams`. */
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    minWidthFactor?: number;
+    maxWidthFactor?: number;
+    minHeightFactor?: number;
+    maxHeightFactor?: number;
+    /** width / height; derives whichever axis is left open (CSS `aspect-ratio`). */
+    aspectRatio?: number;
     /** Start this box on a fresh page (CSS `break-before: page`). */
     breakBefore?: boolean;
     /** Start everything after this box on a fresh page (CSS `break-after: page`). */
@@ -45,7 +59,7 @@ export declare class RectangleElement extends SizedPDFElement implements Fragmen
     private breakBefore;
     private breakAfter;
     private sizeMemory;
-    constructor({ children, color, backgroundColor, borderWidth, width, height, radius, sideBorders, relative, overflow, widthFactor, heightFactor, breakBefore, breakAfter, }: RectangleElementParams);
+    constructor({ children, color, backgroundColor, borderWidth, width, height, radius, sideBorders, relative, overflow, breakBefore, breakAfter, ...sizing }: RectangleElementParams);
     breaksBefore(): boolean;
     breaksAfter(): boolean;
     /**
@@ -72,9 +86,9 @@ export declare class RectangleElement extends SizedPDFElement implements Fragmen
         height: number | undefined;
         children: PDFElement[];
         color: Color;
-        backgroundColor: Color | undefined;
+        backgroundColor: Color | GradientInput | undefined;
         borderWidth: number;
-        radius: number;
+        radius: number | Radii;
         sideBorders: SideBorders | undefined;
         overflow: "hidden" | "visible";
     };

package/dist/elements/rectangle-element.js

@@ -1,9 +1,9 @@
 import { Color } from "../common/color.js";
-import { BoxConstraints, resolveExtent } from "../layout/box-constraints.js";
+import { BoxConstraints, extentSpecs, resolveSize, } from "../layout/box-constraints.js";
 import { childrenForceBreak, 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, widthFactor, heightFactor, breakBefore, breakAfter, }) {
+    constructor({ children = [], color = new Color(0, 0, 0), backgroundColor, borderWidth, width, height, radius, sideBorders, relative, overflow, breakBefore, breakAfter, ...sizing }) {
         super({ x: 0, y: 0, width, height });
         this.children = [];
         this.children = children;
@@ -17,7 +17,7 @@ export class RectangleElement extends SizedPDFElement {
         this.overflow = overflow ?? "visible";
         this.breakBefore = breakBefore ?? false;
         this.breakAfter = breakAfter ?? false;
-        this.sizeMemory = { x: 0, y: 0, width, height, widthFactor, heightFactor };
+        this.sizeMemory = { ...sizing, x: 0, y: 0, width, height };
     }
     breaksBefore() {
         return this.breakBefore;
@@ -102,15 +102,21 @@ export class RectangleElement extends SizedPDFElement {
     calculateLayout(constraints, offset, ctx) {
         // An explicit extent is a fixed point size or a fraction of the offered box (relative sizing);
         // the fraction only resolves in a bounded region. `undefined` = fill / shrink-wrap below.
-        const explicitWidth = resolveExtent(this.sizeMemory.width, this.sizeMemory.widthFactor, constraints.maxWidth, constraints.hasBoundedWidth);
-        const explicitHeight = resolveExtent(this.sizeMemory.height, this.sizeMemory.heightFactor, constraints.maxHeight, constraints.hasBoundedHeight);
+        const specs = extentSpecs(this.sizeMemory);
+        const resolved = resolveSize(specs.width, specs.height, this.sizeMemory.aspectRatio, constraints);
+        const explicitWidth = resolved.width;
+        const explicitHeight = resolved.height;
+        // min/max come back as narrowed constraints, so the fill and shrink-wrap paths below obey them too.
+        const bounds = resolved.constraints;
         // Width: an explicit size wins (clamped), else fill the offered box. (Without this a
         // fixed box would balloon to the parent's size.)
+        // Whether there is a region to fill is decided by the constraints we were GIVEN: a `maxWidth` caps
+        // a box, it does not turn a shrink-wrapping one into a filling one (CSS `max-width` does not either).
         this.width =
             explicitWidth !== undefined
-                ? constraints.constrainWidth(explicitWidth)
+                ? bounds.constrainWidth(explicitWidth)
                 : constraints.hasBoundedWidth
-                    ? constraints.maxWidth
+                    ? bounds.maxWidth
                     : this.width;
         // Width shrink-wrap: no explicit width AND an unbounded region (e.g. a `Box` badge inside a
         // `Positioned`). Resolved after the children are measured, just below.
@@ -121,9 +127,9 @@ export class RectangleElement extends SizedPDFElement {
         const shrinkWrapHeight = explicitHeight === undefined && !constraints.hasBoundedHeight;
         this.height =
             explicitHeight !== undefined
-                ? constraints.constrainHeight(explicitHeight)
+                ? bounds.constrainHeight(explicitHeight)
                 : constraints.hasBoundedHeight
-                    ? constraints.maxHeight
+                    ? bounds.maxHeight
                     : this.height;
         this.x = this.sizeMemory.x + offset.x;
         this.y = this.sizeMemory.y + offset.y;
@@ -161,11 +167,18 @@ export class RectangleElement extends SizedPDFElement {
             contentWidth = Math.max(contentWidth, childSize.width);
         }
         // No explicit width and no bounded region: shrink-wrap to the widest child.
+        // Clamped, so a min/max still applies to a box that sized itself to its content.
         if (shrinkWrapWidth)
-            this.width = contentWidth + 2 * this.borderWidth;
+            this.width = bounds.constrainWidth(contentWidth + 2 * this.borderWidth);
+        // A ratio on a shrink-wrapping box can only be applied HERE: before the children were measured
+        // there was no width to derive the height from.
+        const ratio = this.sizeMemory.aspectRatio;
+        const ratioSizesHeight = ratio !== undefined && ratio > 0 && shrinkWrapWidth && shrinkWrapHeight;
         // No explicit height and no bounded region: the border hugs its content.
-        if (shrinkWrapHeight)
-            this.height = contentHeight + 2 * this.borderWidth;
+        if (ratioSizesHeight)
+            this.height = bounds.constrainHeight((this.width ?? 0) / ratio);
+        else if (shrinkWrapHeight)
+            this.height = bounds.constrainHeight(contentHeight + 2 * this.borderWidth);
         // 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 };

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

@@ -8,11 +8,28 @@ interface RowElementParams extends WithChildren {
     main?: MainAlign;
     /** Vertical alignment of each child (cross axis); defaults to `stretch`. */
     cross?: CrossAlign;
+    /** Lay the children out backwards along the main axis (CSS `row-reverse`). */
+    reverse?: boolean;
+    /** Let the children flow onto further lines when they do not fit (CSS `flex-wrap`). */
+    wrap?: boolean;
+    /** How the block of wrapped lines sits across the axis (CSS `align-content`). */
+    alignContent?: MainAlign;
     /** Width/height as points (fixed) or a fraction (0..1) of the offered box (relative sizing). */
     width?: number;
     height?: number;
     widthFactor?: number;
     heightFactor?: number;
+    /** Lower / upper bounds per axis, in points or as a fraction; see `SizingParams`. */
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    minWidthFactor?: number;
+    maxWidthFactor?: number;
+    minHeightFactor?: number;
+    maxHeightFactor?: number;
+    /** width / height; derives whichever axis is left open (CSS `aspect-ratio`). */
+    aspectRatio?: number;
     /** Start this row on a fresh page (CSS `break-before: page`). */
     breakBefore?: boolean;
     /** Start everything after this row on a fresh page (CSS `break-after: page`). */
@@ -35,10 +52,13 @@ export declare class RowElement extends SizedPDFElement {
     private gap;
     private main;
     private cross;
+    private reverse;
+    private wrap;
+    private alignContent?;
     private breakBefore;
     private breakAfter;
     private requested;
-    constructor({ children, gap, main, cross, width, height, widthFactor, heightFactor, breakBefore, breakAfter, }: RowElementParams);
+    constructor({ children, gap, main, cross, reverse, wrap, alignContent, width, height, breakBefore, breakAfter, ...sizing }: RowElementParams);
     breaksBefore(): boolean;
     breaksAfter(): boolean;
     relativeSizeFactor(horizontal: boolean): number | undefined;
@@ -55,6 +75,9 @@ export declare class RowElement extends SizedPDFElement {
         gap: number;
         main: MainAlign;
         cross: CrossAlign;
+        reverse: boolean;
+        wrap: boolean;
+        alignContent: MainAlign | undefined;
     };
 }
 export {};

package/dist/elements/row-element.js

@@ -1,4 +1,4 @@
-import { resolveExtent } from "../layout/box-constraints.js";
+import { extentSpecs, resolveSize, } from "../layout/box-constraints.js";
 import { FlexLayoutHelper, HORIZONTAL_AXIS } from "../utils/flex-layout.js";
 import { FlexiblePDFElement, SizedPDFElement, } from "./pdf-element.js";
 /**
@@ -14,13 +14,16 @@ import { FlexiblePDFElement, SizedPDFElement, } from "./pdf-element.js";
  * Grid/Table concern.
  */
 export class RowElement extends SizedPDFElement {
-    constructor({ children, gap, main, cross, width, height, widthFactor, heightFactor, breakBefore, breakAfter, }) {
+    constructor({ children, gap, main, cross, reverse, wrap, alignContent, width, height, breakBefore, breakAfter, ...sizing }) {
         super({ x: 0, y: 0 });
         this.children = children;
         this.gap = gap ?? 0;
         this.main = main ?? "start";
         this.cross = cross ?? "stretch";
-        this.requested = { width, height, widthFactor, heightFactor };
+        this.reverse = reverse ?? false;
+        this.wrap = wrap ?? false;
+        this.alignContent = alignContent;
+        this.requested = { ...sizing, width, height };
         this.breakBefore = breakBefore ?? false;
         this.breakAfter = breakAfter ?? false;
     }
@@ -49,24 +52,33 @@ export class RowElement extends SizedPDFElement {
         this.y = offset.y;
         // Relative sizing: a pinned extent (fixed or a fraction of the offered box, clamped) wins; else
         // width fills the offered space (flex children split the leftover) and height is the tallest child.
-        const explicitWidth = resolveExtent(this.requested.width, this.requested.widthFactor, constraints.maxWidth, constraints.hasBoundedWidth);
-        const explicitHeight = resolveExtent(this.requested.height, this.requested.heightFactor, constraints.maxHeight, constraints.hasBoundedHeight);
+        const specs = extentSpecs(this.requested);
+        const resolved = resolveSize(specs.width, specs.height, this.requested.aspectRatio, constraints);
+        const { width: explicitWidth, height: explicitHeight, constraints: bounds } = resolved;
+        // Fill-or-shrink-wrap is decided by the constraints we were GIVEN; a min/max only caps the result.
         const boundedWidth = explicitWidth !== undefined
-            ? constraints.constrainWidth(explicitWidth)
+            ? bounds.constrainWidth(explicitWidth)
             : constraints.hasBoundedWidth
-                ? constraints.maxWidth
+                ? bounds.maxWidth
                 : undefined;
         const boundedHeight = explicitHeight !== undefined
-            ? constraints.constrainHeight(explicitHeight)
+            ? bounds.constrainHeight(explicitHeight)
             : constraints.hasBoundedHeight
-                ? constraints.maxHeight
+                ? bounds.maxHeight
                 : undefined;
         // Horizontal stack: main = width (children fill it), cross = height (children can stretch to it).
         const mainAvail = boundedWidth ?? Infinity;
         const crossAvail = boundedHeight ?? Infinity;
         let result = { mainUsed: 0, crossUsed: 0 };
         if (this.children.length > 0) {
-            result = FlexLayoutHelper.layout(this.children, 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,
+                reverse: this.reverse,
+                wrap: this.wrap,
+                alignContent: this.alignContent,
+            }, ctx);
         }
         this.width = boundedWidth ?? result.mainUsed;
         this.height = boundedHeight ?? result.crossUsed;
@@ -82,6 +94,9 @@ export class RowElement extends SizedPDFElement {
             gap: this.gap,
             main: this.main,
             cross: this.cross,
+            reverse: this.reverse,
+            wrap: this.wrap,
+            alignContent: this.alignContent,
         };
     }
 }

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

@@ -1,6 +1,8 @@
 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";
@@ -9,6 +11,8 @@ export interface TextSegment {
     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 +23,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 +41,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 +66,14 @@ 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;
     /** Accessibility role for the tagged structure tree (heading level or paragraph; default `"p"`). */
     role?: TextRole;
 }
@@ -60,6 +88,11 @@ 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 fontSize;
     private fontFamily;
     private fontStyle;
@@ -70,12 +103,31 @@ 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 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, 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;
+    /** 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 +138,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).
@@ -109,12 +163,17 @@ 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;
         role: TextRole | undefined;
     };
 }