@phin-tech/dottie 0.0.0-stage → 0.1.0

package/dist/types/connector.d.ts

@@ -0,0 +1,28 @@
+import { angle } from "./element.ts";
+import type { Element, Page, Port } from "./model.ts";
+import { type Point, type Rect } from "./path.ts";
+export type Index = Map<string, Element>;
+export declare function portPoint(shape: Element, port: Port): Point;
+/** Where the line from the shape's center toward `target` crosses its outline. */
+export declare function edgePoint(shape: Element, toward: Point): Point;
+export declare function endpoints(e: Element, index: Index): [Point, Point];
+export type Route = {
+    kind: "polyline";
+    points: Point[];
+} | {
+    kind: "cubic";
+    a: Point;
+    b: Point;
+    c: Point;
+    d: Point;
+};
+/** A route's centerline as points; a cubic is sampled at 25 points. */
+export declare function routePoints(r: Route): Point[];
+export declare function route(e: Element, index: Index): Route;
+/** Arrowhead wing points for a tip at `tip` arriving from `from`. */
+export declare function arrowhead(tip: Point, from: Point, size: number): [Point, Point];
+export declare function connectorBounds(e: Element, index: Index): Rect;
+/** Point halfway along the route, where a label sits. */
+export declare function midpoint(e: Element, index: Index): Point;
+export declare function indexOf(page: Page): Index;
+export { angle };

package/dist/types/dungeon.d.ts

@@ -0,0 +1,19 @@
+import { frame } from "./element.ts";
+import type { Element, RGBA } from "./model.ts";
+import { Path, type Point } from "./path.ts";
+export declare const BAND = 0.75;
+/** Grid lines inside the polygons (even-odd) at world multiples of `cell`, leaving out lines on the edge. */
+export declare function gridLines(polygons: Point[][], cell: number): [Point, Point][];
+/** The faint pencil the grid is ruled in. */
+export declare function lineColor(floor: RGBA): RGBA;
+export declare function isFloor(e: Element): boolean;
+export interface Rock {
+    ink: RGBA;
+    width: number;
+    path: Path;
+}
+/** A well-mixed value in [0, 1) from two integers and a salt (Guildhall's 32-bit hash). */
+export declare function hash01(i: number, j: number, salt: number): number;
+/** Hatching for every floor (already filtered by `isFloor`), in page coordinates. */
+export declare function rock(floors: Element[]): Rock[];
+export { frame };

package/dist/types/element.d.ts

@@ -0,0 +1,22 @@
+import { type Element, type RGBA } from "./model.ts";
+import { Path, type Point, type Rect, midX, midY } from "./path.ts";
+export declare const frame: (e: Element) => Rect;
+export declare const angle: (e: Element) => number;
+export declare const center: (e: Element) => Point;
+/** A point in the element's own (unrotated) frame, on the canvas. */
+export declare const rotated: (e: Element, p: Point) => Point;
+/** A canvas point in the element's own (unrotated) frame. */
+export declare const unrotated: (e: Element, p: Point) => Point;
+/** Bounding box of the frame after rotation. */
+export declare function rotatedBounds(e: Element): Rect;
+/** The element with automatic ink drawn as `ink`; a light ink is not used on a light, mostly opaque fill. */
+export declare function resolvingInk(e: Element, ink: RGBA): Element;
+export interface Contour {
+    closed: boolean;
+    points: Point[];
+}
+/** A `.path` element's contours in canvas coordinates: `1 + 3n` Bézier points each. */
+export declare function shapeContours(e: Element): Contour[];
+/** The exact (not sketchy) geometry of a `.path`. */
+export declare function shapePath(e: Element): Path;
+export { midX, midY };

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+import { type DottieFile, type RGBA } from "./model.ts";
+export * from "./model.ts";
+export { inspect, inspectFrame, inspectPage, sampleTimes } from "./inspect.ts";
+export { DottiePlayer, Playback, definePlayer, pageIndex, withRoughness } from "./player.ts";
+export { bounds, plan, svg, svgParts, type Plan, type Part } from "./svg.ts";
+export { themeNamed, themes, type Theme } from "./theme.ts";
+export { cameraView, frameTimes, posterTime, resolved, sceneAt, still, transientElements } from "./timeline.ts";
+export interface RenderOptions {
+    /** Page name or 1-based number; the first page by default. */
+    page?: string | number;
+    /** Seconds into the animation; its poster frame (the end, unless set) by default. */
+    at?: number;
+    /** Draw precisely instead of sketchy. */
+    clean?: boolean;
+    /** Page color behind the drawing; null for transparent. White (or the page's theme) by default. */
+    background?: RGBA | null;
+}
+/** One page of a drawing as an SVG document, as Dottie's own SVG export draws it. */
+export declare function render(source: string | DottieFile | unknown, options?: RenderOptions): string;
+/** The library's version. */
+export declare const VERSION = "0.1.0";

package/dist/types/inspect.d.ts

@@ -0,0 +1,7 @@
+import { type DottieFile, type Page } from "./model.ts";
+/** Times worth checking on an animated page (Inspector.sampleTimes). */
+export declare function sampleTimes(page: Page): number[];
+export declare function inspectFrame(page: Page, t: number): Record<string, unknown>;
+export declare function inspectPage(page: Page, n: number, times: number[]): Record<string, unknown>;
+/** A whole file: every page at its sample times (or `times`). */
+export declare function inspect(file: DottieFile, times?: number[]): Record<string, unknown>;

package/dist/types/metrics.d.ts

@@ -0,0 +1,11 @@
+export declare const ascent = 0.951995849609375, descent = 0.2129974365234375, leading = 0.0279998779296875;
+export declare const boldAscent = 0.975006103515625, boldDescent = 0.2169952392578125, boldLeading = 0.0290069580078125;
+export declare const italicAscent = 0.957000732421875, italicDescent = 0.2129974365234375, italicLeading = 0.0279998779296875;
+export declare const boldItalicAscent = 0.975006103515625, boldItalicDescent = 0.2169952392578125, boldItalicLeading = 0.0290069580078125;
+export declare const monoAdvance = 0.60205078125, monoAscent = 0.92822265625, monoDescent = 0.23583984375;
+export declare const fonts: Record<"regular" | "bold" | "italic" | "boldItalic", {
+    w: Record<string, number>;
+    k: Record<string, number>;
+}>;
+/** Ascent, descent and leading per em of the fallback font for characters Helvetica Neue lacks. */
+export declare const fallbackMetrics: Record<string, [number, number, number]>;

package/dist/types/model.d.ts

@@ -0,0 +1,181 @@
+export interface RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export type FillStyle = "solid" | "hachure" | "crossHatch" | "grid";
+export type DashStyle = "solid" | "dashed" | "dotted";
+export type ElementKind = "rectangle" | "ellipse" | "diamond" | "text" | "connector" | "freehand" | "path" | "note" | "image";
+export type Port = "top" | "right" | "bottom" | "left";
+export type Routing = "straight" | "curved" | "elbow";
+export type Arrowhead = "none" | "arrow" | "triangle" | "dot" | "bar";
+export type Ease = "linear" | "easeIn" | "easeOut" | "easeInOut" | "hold";
+export interface Style {
+    stroke: RGBA;
+    fill: RGBA;
+    fillStyle: FillStyle;
+    strokeWidth: number;
+    dash: DashStyle;
+    roughness: number;
+    bowing: number;
+    fontSize: number;
+    gridSize: number | null;
+    opacity: number | null;
+}
+export interface Endpoint {
+    elementID: string | null;
+    port: Port | null;
+    x: number;
+    y: number;
+}
+export interface ConnectorData {
+    start: Endpoint;
+    end: Endpoint;
+    routing: Routing;
+    startHead: Arrowhead;
+    endHead: Arrowhead;
+}
+export interface PathSubpath {
+    closed: boolean;
+    coords: number[];
+}
+export interface StrokePoint {
+    x: number;
+    y: number;
+}
+export interface EmbeddedImage {
+    data: string;
+    format: string;
+}
+export interface Element {
+    id: string;
+    /** A kind dottie.js doesn't know is kept as written and drawn as a labelled placeholder. */
+    kind: ElementKind | string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    style: Style;
+    seed: number;
+    layerID: string;
+    text: string | null;
+    connector: ConnectorData | null;
+    groupID: string | null;
+    points: StrokePoint[] | null;
+    path: number[] | null;
+    subpaths: PathSubpath[] | null;
+    evenOdd: boolean | null;
+    rotation: number | null;
+    link: string | null;
+    anchor: string | null;
+    /** Base64 bytes; an empty `data` is a picture that couldn't be found (drawn crossed out). */
+    image: EmbeddedImage | null;
+    reveal: number | null;
+}
+export interface Layer {
+    id: string;
+    name: string;
+    visible: boolean;
+    locked: boolean;
+}
+export interface Keyframe {
+    t: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    rotation?: number;
+    strokeWidth?: number;
+    stroke?: RGBA;
+    fill?: RGBA;
+    visible?: boolean;
+    reveal?: number;
+    opacity?: number;
+    ease?: Ease;
+}
+export interface Follow {
+    path: string;
+    start: number;
+    end: number;
+    ease: Ease | null;
+    reverse: boolean | null;
+    orient: boolean | null;
+    laps: number | null;
+}
+export interface Repeat {
+    start: number;
+    end: number;
+    count: number | null;
+}
+export interface Track {
+    element: string;
+    keys: Keyframe[];
+    boil: boolean | null;
+    follow: Follow[] | null;
+    repeats: Repeat[] | null;
+}
+export interface CameraKey {
+    t: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    ease: Ease | null;
+}
+export interface Marker {
+    t: number;
+    name: string;
+}
+export interface Timeline {
+    fps: number;
+    duration: number;
+    boil: number | null;
+    settle: boolean | null;
+    poster: number | null;
+    tracks: Track[];
+    camera: CameraKey[] | null;
+    markers: Marker[] | null;
+}
+export interface Page {
+    id: string;
+    name: string;
+    layers: Layer[];
+    elements: Element[];
+    theme: string | null;
+    timeline: Timeline | null;
+}
+export interface DottieFile {
+    version: number;
+    pages: Page[];
+    /** What was skipped or guessed while reading. Empty for a file Dottie wrote. */
+    warnings: string[];
+}
+/** The newest file version this library was written for. Newer files still load, with a warning. */
+export declare const SUPPORTED_VERSION = 2;
+export declare const KINDS: readonly string[];
+/** The fields dottie.js reads, per object; the schema test checks they're exactly the schema's. Anything else
+ * in a file is newer than this version and is reported in `warnings`. */
+export declare const KNOWN_FIELDS: Record<string, readonly string[]>;
+export declare const MAX_DURATION = 3600;
+export declare const BOIL_DRAWINGS = 3;
+export declare const black: RGBA;
+export declare const clear: RGBA;
+export declare const inkOnDark: RGBA;
+export declare class DottieFormatError extends Error {
+}
+export declare function clampTime(t: number): number;
+export declare function clampFPS(f: number): number;
+export declare function repeatIsValid(r: Repeat): boolean;
+/** Sorts in place by `key`, keeping equal keys in their original order (as Swift's sort happens to for these). */
+export declare function stableSortBy<T>(a: T[], key: (v: T) => number): void;
+/** Reads a .dottie file from its JSON text (or the parsed object). Throws `DottieFormatError` when it isn't one. */
+export declare function parseDottie(source: string | unknown): DottieFile;
+export declare function luminance(c: RGBA): number;
+export declare function sameColor(a: RGBA, b: RGBA): boolean;
+export declare function isAutomaticInk(c: RGBA): boolean;
+export declare function cloneElement(e: Element): Element;
+/** Elements back to front: lower layers first, array order within a layer. */
+export declare function orderedElements(page: Page): Element[];
+/** Elements by id; with duplicate ids the first one wins, as in Dottie. */
+export declare function elementIndex(page: Page): Map<string, Element>;

package/dist/types/note.d.ts

@@ -0,0 +1,47 @@
+import type { Element } from "./model.ts";
+import { type Rect } from "./path.ts";
+export declare const PADDING = 12;
+/** Where the text goes inside a note's frame. */
+export declare function textRect(f: Rect): Rect;
+type Inline = {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    mono?: boolean;
+    strike?: boolean;
+    link?: boolean;
+};
+type Block = {
+    kind: "heading";
+    level: number;
+    inline: Inline[];
+} | {
+    kind: "paragraph";
+    inline: Inline[];
+} | {
+    kind: "list";
+    ordered: number | null;
+    items: {
+        checkbox: boolean | null;
+        children: Block[];
+    }[];
+} | {
+    kind: "quote";
+    children: Block[];
+} | {
+    kind: "code";
+    text: string;
+} | {
+    kind: "rule";
+} | {
+    kind: "table";
+    align: (string | null)[];
+    head: Inline[][];
+    rows: Inline[][][];
+};
+export declare function parseBlocks(source: string): Block[];
+/** Inline Markdown into styled runs; soft and hard breaks become line separators. */
+export declare function inline(src: string, style?: Omit<Inline, "text">): Inline[];
+/** The note's text as positioned SVG, laid out as Dottie lays it out (SVG.swift's noteText). */
+export declare function noteMarkup(source: string, e: Element): string;
+export {};

package/dist/types/path.d.ts

@@ -0,0 +1,76 @@
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type Segment = {
+    op: "M";
+    p: Point;
+} | {
+    op: "L";
+    p: Point;
+} | {
+    op: "Q";
+    c: Point;
+    p: Point;
+} | {
+    op: "C";
+    c1: Point;
+    c2: Point;
+    p: Point;
+} | {
+    op: "Z";
+};
+export declare class Path {
+    segments: Segment[];
+    get isEmpty(): boolean;
+    moveTo(p: Point): this;
+    lineTo(p: Point): this;
+    quadTo(p: Point, c: Point): this;
+    curveTo(p: Point, c1: Point, c2: Point): this;
+    close(): this;
+    addPath(other: Path): this;
+    /** move, then a line to each point (CGMutablePath.addLines). */
+    addLines(pts: Point[]): this;
+    /** CGPath(rect:): clockwise (on screen) from the top-left corner. */
+    static rect(r: Rect): Path;
+    /** CGPath(ellipseIn:): four cubics clockwise (on screen) from the right-hand point. */
+    addEllipse(r: Rect): this;
+    static ellipse(r: Rect): Path;
+    translated(dx: number, dy: number): Path;
+    /** Every contour as points, curves flattened into short segments (CGPath.contours). */
+    contours(): Point[][];
+    /** The first `fraction` of the path by length, contours in drawing order: a stroke being drawn on. */
+    trimmed(fraction: number): Path;
+    /** SVG path data, as Dottie's SVG export writes it. */
+    data(): string;
+}
+/** Swift's `.rounded()`: half away from zero. */
+export declare function roundHalfAway(v: number): number;
+/** Dottie's SVG number: two decimals, integers without a point. */
+export declare function fmt(v: number): string;
+/** Points along a path with their running length (Motion.swift's Polyline). */
+export declare class Polyline {
+    points: Point[];
+    lengths: number[];
+    constructor(points: Point[]);
+    get length(): number;
+    /** The point `u` (0...1) of the way along, by distance. */
+    point(u: number): Point;
+}
+export declare const midX: (r: Rect) => number;
+export declare const midY: (r: Rect) => number;
+export declare const maxX: (r: Rect) => number;
+export declare const maxY: (r: Rect) => number;
+export declare function union(a: Rect | null, b: Rect): Rect;
+export declare function inset(r: Rect, dx: number, dy: number): Rect;
+export declare function rotate(p: Point, c: Point, a: number): Point;
+/** A point on a cubic Bézier (StrokeFit.point). */
+export declare function bezierPoint(b: Point[], t: number): Point;
+/** A cubic Bézier chain (1 + 3n points) as a polyline of short steps (Element.flatten). */
+export declare function flatten(cp: Point[], maxStep: number): Point[];

package/dist/types/player-entry.d.ts

@@ -0,0 +1 @@
+export * from "./index.ts";

package/dist/types/player.d.ts

@@ -0,0 +1,80 @@
+import { type DottieFile, type Page, type RGBA } from "./model.ts";
+import { type Plan } from "./svg.ts";
+/** Finds a page by name (any case) or 1-based number; the first page when `spec` is empty or matches nothing. */
+export declare function pageIndex(file: DottieFile, spec: string | null | undefined): number;
+export declare function withRoughness(page: Page, roughness: number): Page;
+/** Plays one page of a Dottie file into an element: the engine behind <dottie-player>, usable on its own. */
+export declare class Playback {
+    readonly page: Page;
+    readonly plan: Plan;
+    readonly scenes: number[];
+    readonly sceneNames: string[];
+    readonly background: RGBA;
+    readonly ink: RGBA;
+    private svg;
+    private groups;
+    private order;
+    frame: number;
+    onFrame: ((frame: number) => void) | null;
+    constructor(page: Page, into: Element, options?: {
+        clean?: boolean;
+    });
+    get frameCount(): number;
+    get posterFrame(): number;
+    /** Draws frame `i`, replacing only the pieces whose markup changed since the last frame. */
+    show(i: number): void;
+    /** Draws the moment `t` (seconds) in the frame-`i` view. */
+    drawAt(t: number, i?: number): void;
+    /** The scene frame `i` is in, or -1 before the first. */
+    sceneAt(i: number): number;
+}
+/** HTMLElement where there is a DOM; a stand-in elsewhere, so the library still loads in Node (to render SVG). */
+declare const ElementBase: typeof HTMLElement;
+export declare class DottiePlayer extends ElementBase {
+    static observedAttributes: string[];
+    file: DottieFile | null;
+    playback: Playback | null;
+    private root;
+    private stage;
+    private bar;
+    private playButton;
+    private scrub;
+    private time;
+    private sceneLabel;
+    private prev;
+    private next;
+    private playing;
+    private last;
+    private acc;
+    private raf;
+    private loadToken;
+    private visible;
+    private observer;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    /** Loads from `src`, or from an inline JSON script child. */
+    load(): Promise<void>;
+    /** Shows an already-parsed file. */
+    setFile(file: DottieFile): void;
+    private mount;
+    get paused(): boolean;
+    get currentTime(): number;
+    set currentTime(t: number);
+    get duration(): number;
+    play(): void;
+    pause(): void;
+    /** Plays on to the next scene (from the start after the last). */
+    nextScene(): void;
+    /** Back to the start of this scene, or the one before if already there. */
+    prevScene(): void;
+    private setPlaying;
+    private schedule;
+    /** Steps whole frames at the timeline's rate; with scenes, playing stops at each one and at the end. */
+    private tick;
+    private key;
+}
+/** Registers <dottie-player> (or another tag name) once. */
+export declare function definePlayer(tag?: string): void;
+export {};

package/dist/types/rng.d.ts

@@ -0,0 +1,17 @@
+/** (hi, lo) as unsigned 32-bit halves of a 64-bit value. */
+type U64 = [number, number];
+export declare class SeededRNG {
+    private state;
+    constructor(seed: number);
+    /** The next 64 bits, as (hi, lo). */
+    next(): U64;
+    /** The top 53 bits of `next()`, exactly. */
+    private top53;
+    /** Uniform in -1...1. */
+    signed(): number;
+    /** Uniform in 0...1. */
+    unit(): number;
+}
+/** A different but repeatable seed for each boil step, never 0 (DottieDocument.boiled). */
+export declare function boiled(seed: number, step: number): number;
+export {};

package/dist/types/rough.d.ts

@@ -0,0 +1,16 @@
+import { Path, type Point } from "./path.ts";
+import type { SeededRNG } from "./rng.ts";
+/** A hand-drawn line from `a` to `b`, traced twice. With `preserveEnds` both end points stay exact. */
+export declare function line(a: Point, b: Point, rng: SeededRNG, roughness: number, bowing: number, preserveEnds: boolean, into: Path): void;
+export declare function polygon(pts: Point[], rng: SeededRNG, roughness: number, bowing: number): Path;
+export declare function ellipse(r: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, rng: SeededRNG, roughness: number): Path;
+export declare function catmullRom(p: Point[], path: Path): void;
+/** rough.js's default hachure angle. */
+export declare const HACHURE_ANGLE: number;
+/** Parallel lines `gap` apart at `angle` inside the polygons (even-odd), aligned to the shape. */
+export declare function hachureLines(polygons: Point[][], angle: number, gap: number): [Point, Point][];

package/dist/types/shapes.d.ts

@@ -0,0 +1,17 @@
+import { type Index } from "./connector.ts";
+import type { DashStyle, Element } from "./model.ts";
+import { Path, type Point } from "./path.ts";
+/** The `.grid` cell size actually drawn. */
+export declare const cellSize: (e: Element) => number;
+/** Outline path for an element; roughness 0 gives exact geometry. */
+export declare function outline(e: Element): Path;
+/** Every contour of a filled shape as a polygon; only a `.path` has more than one. */
+export declare function fillPolygons(e: Element): Point[][];
+/** Precise shape used for fills. */
+export declare function fillPath(e: Element): Path;
+/** Pen-shaded fill for hachure / crossHatch, or the cell lines of a grid fill; empty for solid fills. */
+export declare function hachurePath(e: Element): Path;
+/** Dash lengths for a stroke width; null for a solid line. */
+export declare function dashPattern(dash: DashStyle, width: number): number[] | null;
+/** A connector as the stroked line (with open arrowheads) and the closed heads filled in the stroke color. */
+export declare function connectorParts(e: Element, index: Index): [Path, Path];

package/dist/types/svg-util.d.ts

@@ -0,0 +1,3 @@
+import type { RGBA } from "./model.ts";
+export declare function color(c: RGBA): string;
+export declare function escapeXML(s: string): string;

package/dist/types/svg.d.ts

@@ -0,0 +1,36 @@
+import { type Index } from "./connector.ts";
+import { type Element, type Page, type RGBA } from "./model.ts";
+import { color, escapeXML } from "./svg-util.ts";
+import { type Rect } from "./path.ts";
+/** The drawing's extent plus `padding`; a floor's rock hatching reaches past its shape. */
+export declare function bounds(page: Page, padding?: number): Rect;
+export interface Plan {
+    times: number[];
+    /** The part of the page each frame shows. */
+    rects: Rect[];
+    /** Output size in points. */
+    size: {
+        width: number;
+        height: number;
+    };
+}
+/** What an animation shows over time (Exporter.animation): with a camera, its view at each frame, widened to
+ * the first key's shape; without, the bounds of the whole animation for every frame. */
+export declare function plan(page: Page): Plan;
+/** The opening `<svg>` tag for `b`, with the page color behind everything when `paint`. */
+export declare function svgOpen(b: Rect, background: RGBA | null, paint: boolean): string;
+export interface Part {
+    key: string;
+    markup: string;
+}
+/** The SVG for each thing drawn, back to front, keyed by element id (rock hatching as "rock"). */
+export declare function svgParts(page: Page, background: RGBA | null, fixed?: Rect): {
+    bounds: Rect;
+    parts: Part[];
+};
+/** A whole page as an SVG document. Pass `background: null` for a transparent page. */
+export declare function svg(page: Page, background?: RGBA | null, fixed?: Rect): string;
+/** Where a connector's label sits. */
+export declare function labelRect(e: Element, index: Index): Rect;
+export declare function textElement(text: string, f: Rect, e: Element, centered: boolean): string;
+export { color, escapeXML };

package/dist/types/text.d.ts

@@ -0,0 +1,15 @@
+export type Face = "regular" | "bold" | "italic" | "boldItalic";
+/** Width of a run of text at `fontSize`, kerned. */
+export declare function measure(s: string, fontSize: number, face?: Face): number;
+/** First line's height, and each further line's, for the regular face (CoreText rounds each metric). */
+export declare function lineHeights(fontSize: number): [number, number];
+/** Whether a line may break after `ch` when `next` follows (Unicode line breaking as CoreText does it: after
+ * a space, and after a slash or hyphen not followed by a digit, a space or another of itself). */
+export declare function breaksAfter(ch: string, next: string): boolean;
+/** Lines `s` wraps into within `maxWidth` (or inside a piece too long for a line). */
+export declare function wrap(s: string, fontSize: number, maxWidth: number, face?: Face): string[];
+/** The size CoreText suggests for `s` wrapped at `maxWidth`, rounded up (Renderer.textSize). */
+export declare function textSize(s: string, fontSize: number, maxWidth: number): {
+    width: number;
+    height: number;
+};

package/dist/types/theme.d.ts

@@ -0,0 +1,10 @@
+import type { RGBA } from "./model.ts";
+export interface Theme {
+    id: string;
+    name: string;
+    background: RGBA;
+    ink: RGBA;
+}
+export declare const themes: Theme[];
+/** The theme a page names, or null (white page, black ink) for none or one this version doesn't know. */
+export declare function themeNamed(id: string | null | undefined): Theme | null;

package/dist/types/timeline.d.ts

@@ -0,0 +1,36 @@
+import { type Ease, type Element, type Follow, type Page, type Timeline, type Track } from "./model.ts";
+import { Polyline, type Point, type Rect } from "./path.ts";
+export declare function applyEase(ease: Ease, u: number): number;
+/** The time inside the track's own keys that `t` plays (repeats folded back). */
+export declare function localTime(track: Track, t: number): number;
+/** Whether some property is tweening at `t`: between two keys that set it to different values, not held. */
+export declare function isChanging(track: Track, t: number): boolean;
+/** Whether the element is shown at `t`. */
+export declare function isVisible(track: Track, t: number): boolean;
+/** `e` posed at `t` (returns a copy). */
+export declare function applyTrack(track: Track, e: Element, t: number): Element;
+/** The path span placing the element at `t`, unless an x or y key after it has taken the element back. */
+export declare function followSpan(track: Track, t: number): Follow | null;
+/** The clean route of a connector, or the clean, rotated outline of any other element. */
+export declare function tracing(e: Element, page: Page): Polyline;
+/** `e` moved onto the path it is following at `t`, if any. `page` has every key applied. */
+export declare function following(track: Track, e: Element, t: number, page: Page): Element;
+/** The page as a still drawing at `t` seconds (DottieDocument.resolved(at:)). A page without a timeline is returned as is. */
+export declare function resolved(page: Page, t: number): Page;
+/** The moment a still picture of the page shows: its poster, else the end. */
+export declare function posterTime(page: Page): number;
+/** The page as a still picture (its poster frame when animated). */
+export declare function still(page: Page): Page;
+export declare function cameraRect(tl: Timeline, t: number): Rect | null;
+/** What exports show at `t`: the camera's view widened (never cropped) to the first key's shape. */
+export declare function cameraView(tl: Timeline, t: number): Rect | null;
+/** `r` widened about its center to the width-to-height ratio `aspect`. */
+export declare function fit(r: Rect, aspect: number): Rect;
+export declare function frameCount(tl: Timeline): number;
+/** The times exports and playback draw: every frame, plus the end when it falls between frames. */
+export declare function frameTimes(tl: Timeline): number[];
+/** The index of the last scene marker at or before `t`, or -1. */
+export declare function sceneAt(tl: Timeline, t: number): number;
+/** Elements that only exist in motion: hidden at the start and in the still (packets, mostly). */
+export declare function transientElements(page: Page): Set<string>;
+export type { Point };