@vectojs/core 1.14.0 → 1.15.0

package/dist/layout/LayoutEngine.d.ts

@@ -1,289 +0,0 @@
-/**
- * Map from a single grapheme character to its pre-measured glyph metrics.
- *
- * Each entry provides the glyph's pixel `width` at `baseSize`, and an `ast`
- * property holding the raw vector path data used by the renderer.
- */
-export interface GlyphAtlas {
-    [char: string]: {
-        width: number;
-        baseSize: number;
-        ast: any;
-    };
-}
-/**
- * Resolves the pixel advance width of a single grapheme at a given font size,
- * for glyphs not present in a pre-baked {@link GlyphAtlas}.
- *
- * Implemented by {@link createCanvasMeasurer} (canvas `measureText`), but kept
- * abstract so callers can supply their own metrics source.
- */
-export interface GlyphMeasurer {
-    measure(char: string, fontSize: number): number;
-}
-/**
- * Per-run inline style for rich text ({@link LayoutEngine.prepareRich}). All
- * fields are optional and inherited from the call's base style when omitted.
- */
-export interface TextStyle {
-    /** Font size in px for this run; overrides the base size (affects width + line height). */
-    fontSize?: number;
-    /** Fill color, e.g. `'#38bdf8'`. */
-    color?: string;
-    /** Bold weight (rendering only; width still measured at base metrics). */
-    bold?: boolean;
-    /** Italic slant (rendering only). */
-    italic?: boolean;
-    /** Hyperlink destination; carried through to the positioned nodes for hit-testing / a11y. */
-    href?: string;
-}
-/** A run of text sharing one {@link TextStyle}, the input unit of {@link LayoutEngine.prepareRich}. */
-export interface StyledSpan {
-    text: string;
-    style?: TextStyle;
-}
-/**
- * A single positioned glyph produced by {@link LayoutEngine.layoutText}.
- */
-export interface LayoutNode {
-    char: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Inline style carried from rich text; `undefined` for plain (single-style) layout. */
-    style?: TextStyle;
-    sourceIndex?: number;
-    sourceLength?: number;
-    isRTL?: boolean;
-    combining?: string[];
-}
-/**
- * The complete output of a text layout pass — an ordered list of positioned
- * glyphs and the total bounding-box dimensions.
- */
-export interface LayoutResult {
-    nodes: LayoutNode[];
-    totalWidth: number;
-    totalHeight: number;
-    fallbackToCanvas?: boolean;
-}
-/** A single measured grapheme (the "cold" half of the cold/hot split). */
-export interface PreparedGlyph {
-    char: string;
-    /** Advance width at the prepared `fontSize`. */
-    width: number;
-    /** Inline style (rich text only); drives per-glyph size, color and baseline. */
-    style?: TextStyle;
-    level: number;
-    sourceIndex: number;
-    sourceLength: number;
-    combining?: string[];
-}
-/** A measured word/segment, ready to be placed without re-measuring. */
-export interface PreparedWord {
-    glyphs: PreparedGlyph[];
-    /** Sum of glyph advances — used for word-level wrap decisions. */
-    width: number;
-    isWordLike: boolean | undefined;
-    /** Pre-computed `word.trim().length === 0`. */
-    isWhitespace: boolean;
-    /**
-     * Glyph indices where the word may break with a visible hyphen — from
-     * soft hyphens (U+00AD) in the source or the engine's `hyphenate` hook.
-     */
-    breakPoints?: number[];
-}
-/** A measured paragraph; `isEmpty` marks a blank line (forced newline). */
-export interface PreparedParagraph {
-    words: PreparedWord[];
-    isEmpty: boolean;
-    fallbackToCanvas?: boolean;
-    baseLevel?: number;
-}
-/**
- * The result of the **cold** measurement pass ({@link LayoutEngine.prepare}):
- * segmented + measured text that is independent of layout constraints
- * (`maxWidth`/`maxHeight`/exclusion masks). Reuse it across cheap **hot**
- * re-layouts ({@link LayoutEngine.layoutPrepared}) on resize / reposition,
- * avoiding the per-frame `Intl.Segmenter` + measurement cost.
- */
-export interface PreparedText {
-    paragraphs: PreparedParagraph[];
-    fontSize: number;
-    fallbackToCanvas?: boolean;
-    /** Advance width of '-' at `fontSize`, for wrap-time hyphen insertion. */
-    hyphenWidth?: number;
-}
-/**
- * A rectangular region (in the text's local coordinate space) that text must
- * flow around — the v1 of text flow exclusion shapes. A left/right rect acts
- * like a CSS float; a centered rect splits the affected lines in two.
- */
-export interface ExclusionRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/** A free horizontal interval `[x0, x1)` available for text on one line. */
-export interface LineSegment {
-    x0: number;
-    x1: number;
-}
-/**
- * The free horizontal segments left in `[0, maxWidth]` for a line whose box
- * spans the vertical band `[top, bottom)`, after subtracting every
- * {@link ExclusionRect} that overlaps that band. Returns the full width when
- * nothing overlaps, and `[]` when an exclusion (or union of them) spans the
- * whole width. Pure — the testable core of exclusion flow.
- *
- * Time O(n log n) in the number of overlapping exclusions; space O(n).
- */
-export declare function computeLineSegments(top: number, bottom: number, maxWidth: number, exclusions: ExclusionRect[]): LineSegment[];
-/**
- * VectoJS Global Layout Engine (Intl.Segmenter)
- * Advanced Typography Engine supporting CJK, Emoji, and Western Graphemes
- */
-export declare class LayoutEngine {
-    maxWidth: number;
-    /**
-     * Horizontal alignment. `'justify'` stretches inter-word spaces (or, for
-     * space-less CJK lines, inter-character gaps) so wrapped lines end flush at
-     * `maxWidth`; the last line of each paragraph stays ragged. Only applies to
-     * the object layout path without exclusion shapes.
-     */
-    textAlign: 'left' | 'justify';
-    maxHeight: number;
-    preserveLeadingSpaces: boolean;
-    private wordSegmenter;
-    private charSegmenter;
-    private wordCache;
-    private graphemeCache;
-    private paragraphCache;
-    private richParagraphCache;
-    private lastAtlas;
-    private measurer;
-    private _hyphenate;
-    /**
-     * Optional hyphenator: given a word, return its break parts (e.g.
-     * `['hyphen', 'ation']`). Used at wrap time when a word doesn't fit; a
-     * visible '-' is drawn at the chosen break. Soft hyphens (U+00AD) in the
-     * source work without any hyphenator. Setting this clears the prepared
-     * caches (break opportunities are baked in during prepare()).
-     */
-    get hyphenate(): ((word: string) => string[]) | null;
-    set hyphenate(fn: ((word: string) => string[]) | null);
-    constructor(maxWidth: number, maxHeight: number, measurer?: GlyphMeasurer | null);
-    private getWordSegments;
-    /**
-     * Resolve a grapheme's advance width at `fontSize`, in priority order:
-     * pre-baked atlas entry → injected {@link GlyphMeasurer} → `0.5em` fallback.
-     */
-    private glyphWidth;
-    private glyphKeyFor;
-    private getGraphemes;
-    /**
-     * Lay out a Unicode string into a list of positioned {@link LayoutNode} glyphs.
-     *
-     * Uses `Intl.Segmenter` to correctly handle CJK, emoji, and Western word
-     * boundaries.  An optional `exclusionMask` callback allows glyphs to flow
-     * around arbitrary shapes (e.g. physics bodies or video regions).
-     *
-     * @param text - The raw text string to lay out (newlines force paragraph breaks).
-     * @param fontAtlas - Pre-measured glyph metrics keyed by grapheme character.
-     * @param fontSize - Target font size in pixels (default: `32`).
-     * @param exclusionMask - Optional callback returning `true` when a candidate
-     *   glyph bounding box overlaps a forbidden region; the engine skips that
-     *   position and advances horizontally.
-     * @returns A {@link LayoutResult} with all positioned glyph nodes and total dimensions.
-     * @example
-     * const result = engine.layoutText('Hello 世界', atlas, 24);
-     * result.nodes.forEach(n => console.log(n.char, n.x, n.y));
-     */
-    layoutText(text: string, fontAtlas: GlyphAtlas, fontSize?: number, exclusionMask?: (x: number, y: number, w: number, h: number) => boolean): LayoutResult;
-    /**
-     * **Cold pass.** Segment and measure `text` once into a reusable
-     * {@link PreparedText}. Runs `Intl.Segmenter` (word + grapheme) and resolves
-     * each grapheme's advance width — the expensive work. The result is
-     * independent of `maxWidth`/`maxHeight`/exclusion masks, so it can be re-laid
-     * out cheaply by {@link layoutPrepared} on resize / reposition / animation.
-     *
-     * @param text - The raw text string (newlines force paragraph breaks).
-     * @param fontAtlas - Pre-measured glyph metrics keyed by grapheme character.
-     * @param fontSize - Target font size in pixels (default: `32`).
-     */
-    prepare(text: string, fontAtlas: GlyphAtlas, fontSize?: number): PreparedText;
-    /**
-     * **Cold pass for rich text.** Like {@link prepare}, but takes an array of
-     * {@link StyledSpan}s so different inline runs (bold / italic / color / size /
-     * links) compose on the same wrapped lines. Each grapheme carries the
-     * (base-merged) style of the span it came from — so a style change *mid-word*
-     * (e.g. `He` + **`llo`**) is honored. Run `fontSize` affects measured width and
-     * line height; the rest is rendering metadata carried through to the nodes.
-     *
-     * The result feeds the same {@link layoutPrepared} as plain text.
-     *
-     * @param spans - The styled runs, in document order.
-     * @param fontAtlas - Pre-measured glyph metrics keyed by grapheme character.
-     * @param baseFontSize - Size for runs without an explicit `fontSize` (default 32).
-     * @param baseStyle - Style inherited by every run (each run's own style wins).
-     */
-    prepareRich(spans: StyledSpan[], fontAtlas: GlyphAtlas, baseFontSize?: number, baseStyle?: TextStyle): PreparedText;
-    /**
-     * **Hot pass.** Place an already-measured {@link PreparedText} into positioned
-     * glyphs. Does only wrap/positioning arithmetic — no `Intl.Segmenter`, no
-     * re-measurement — so it is cheap enough to call every frame or on every
-     * resize. Reads the engine's current `maxWidth`/`maxHeight`, so changing those
-     * and re-calling reflows the same prepared text.
-     *
-     * @param prepared - Output of {@link prepare}.
-     * @param exclusionMask - Optional per-glyph collision callback (see {@link layoutText}).
-     * @param exclusions - Optional rect regions text flows around (exclusion shapes); each
-     *   line is split into the free x-segments left after subtracting them. Omitting
-     *   it (or passing `[]`) leaves the single-column path byte-for-byte unchanged.
-     */
-    layoutPrepared(prepared: PreparedText, exclusionMask?: (x: number, y: number, w: number, h: number) => boolean, exclusions?: ExclusionRect[]): LayoutResult;
-    /**
-     * Lay out a Unicode string directly into a pre-allocated {@link LayoutResultBuffer}.
-     *
-     * Avoids GC allocations by writing results directly to flat typed arrays in the buffer.
-     *
-     * @param text - The raw text string to lay out.
-     * @param fontAtlas - Pre-measured glyph metrics keyed by grapheme character.
-     * @param fontSize - Target font size in pixels.
-     * @param buffer - The pre-allocated buffer to write layout results into.
-     * @param exclusionMask - Optional collision-detection callback.
-     */
-    layoutTextIntoBuffer(text: string, fontAtlas: GlyphAtlas, fontSize: number, buffer: LayoutResultBuffer, exclusionMask?: (x: number, y: number, w: number, h: number) => boolean): void;
-    /**
-     * **Hot pass, zero-GC variant.** Place an already-measured {@link PreparedText}
-     * directly into a pre-allocated {@link LayoutResultBuffer}. Like
-     * {@link layoutPrepared} but writes flat typed arrays instead of allocating
-     * {@link LayoutNode} objects — the per-frame path for large dynamic scenes.
-     */
-    layoutPreparedIntoBuffer(prepared: PreparedText, buffer: LayoutResultBuffer, exclusionMask?: (x: number, y: number, w: number, h: number) => boolean): void;
-}
-/**
- * Pre-allocated buffer for zero-GC layout results.
- * Reuse a single instance across frames by calling reset() before each layout pass.
- */
-export declare class LayoutResultBuffer {
-    static readonly CAPACITY = 16384;
-    /** X positions of each glyph. */
-    xs: Float32Array;
-    /** Y positions of each glyph. */
-    ys: Float32Array;
-    /** Widths of each glyph. */
-    ws: Float32Array;
-    /** Heights of each glyph. */
-    hs: Float32Array;
-    /** Character for each glyph slot. */
-    chars: string[];
-    /** Number of valid glyphs written in this buffer. */
-    count: number;
-    /** Reset the buffer for reuse. Does NOT free memory. */
-    reset(): void;
-    /** Convert to the standard LayoutResult format (allocates — use sparingly). */
-    toLayoutResult(): LayoutResult;
-}

package/dist/layout/LayoutWorker.d.ts

@@ -1,23 +0,0 @@
-import { MSDFFontData } from '../text/MSDFFont';
-export interface LayoutWorkerRequest {
-    id: string;
-    seqId: number;
-    text: string;
-    fontId: string;
-    fontData?: MSDFFontData;
-    maxWidth: number;
-    maxHeight: number;
-    fontSize: number;
-    lineHeight?: number;
-    letterSpacing?: number;
-}
-export interface LayoutWorkerResponse {
-    id: string;
-    seqId: number;
-    width: number;
-    height: number;
-    codePoints: Uint32Array;
-    xCoords: Float32Array;
-    yCoords: Float32Array;
-    packedStyles: Uint32Array;
-}

package/dist/layout/LayoutWorkerManager.d.ts

@@ -1,26 +0,0 @@
-import { LayoutWorkerResponse } from './LayoutWorker';
-export declare class LayoutWorkerManager {
-    private static instance;
-    private worker;
-    private registeredFonts;
-    private pendingCallbacks;
-    private seqIdCounter;
-    private debounceTimers;
-    private constructor();
-    private createWorker;
-    private ensureWorker;
-    private handleWorkerFailure;
-    destroy(): void;
-    static getInstance(): LayoutWorkerManager;
-    queueLayout(entityId: string, text: string, options: {
-        fontId: string;
-        fontSize: number;
-        maxWidth: number;
-        maxHeight: number;
-        fontData?: any;
-        lineHeight?: number;
-        letterSpacing?: number;
-        callback: (res: LayoutWorkerResponse) => void;
-    }): void;
-    cancelLayout(entityId: string): void;
-}

package/dist/layout/LayoutWorkerSource.d.ts

@@ -1 +0,0 @@
-export declare const WORKER_SOURCE_STRING = "\"use strict\";(()=>{var C=new Map;function f(t){return typeof t==\"number\"&&Number.isFinite(t)}function U(t){return t.origin?t.origin===self.location.origin:!0}function j(t){if(!t||typeof t!=\"object\")return!1;let e=t;return typeof e.id==\"string\"&&f(e.seqId)&&typeof e.text==\"string\"&&typeof e.fontId==\"string\"&&(e.fontData===void 0||typeof e.fontData==\"object\")&&f(e.maxWidth)&&f(e.maxHeight)&&f(e.fontSize)&&(e.lineHeight===void 0||f(e.lineHeight))&&(e.letterSpacing===void 0||f(e.letterSpacing))}self.onmessage=t=>{if(!U(t)||!j(t.data))return;let{id:e,seqId:D,text:L,fontId:k,fontData:S,maxWidth:H,maxHeight:z,fontSize:d,lineHeight:I,letterSpacing:M}=t.data;S&&C.set(k,S);let g=C.get(k);if(!g)return;let m=[],i=[],h=[],w=[],n=0,c=0,r=0,o=-1,p=g.metrics?.ascender??.8,R=g.metrics?.descender??-.2,b=I??d*(p-R),P=M??0,F=new Map;for(let s of g.glyphs??[])F.set(s.unicode,s.advance);let x=()=>{n>r&&(r=n),n=0,c++,o=-1},A=Array.from(L);for(let s=0;s<A.length;s++){let a=A[s].codePointAt(0);if(a===10){x();continue}let W=(F.get(a)??1)*d,q=a>=11904;if(q&&(o=-1),n+W>H&&n>0){if(a===32){x();continue}if(o>=0&&i[o]>0){let l=i[o];l>r&&(r=l),c++;let v=c*b+p*d;for(let y=o;y<i.length;y++)i[y]-=l,h[y]=v;n-=l}else x()}a===32?o=-1:o===-1&&!q&&(o=m.length),m.push(a),i.push(n),h.push(c*b+p*d),w.push(-256),n+=W+P}n>r&&(r=n);let u={id:e,seqId:D,width:r,height:(c+1)*b,codePoints:new Uint32Array(m),xCoords:new Float32Array(i),yCoords:new Float32Array(h),packedStyles:new Uint32Array(w)};self.postMessage(u,[u.codePoints.buffer,u.xCoords.buffer,u.yCoords.buffer,u.packedStyles.buffer])};})();\n";

package/dist/layout/measure.d.ts

@@ -1,20 +0,0 @@
-import type { GlyphMeasurer } from './LayoutEngine';
-/**
- * Create a {@link GlyphMeasurer} backed by a single lazily-created offscreen
- * Canvas 2D context.
- *
- * Each grapheme is measured once at `baseSize` and cached; because canvas
- * `measureText` advance width is linear in font size, later queries at any
- * `fontSize` are derived by pure arithmetic (no re-measure). This gives the
- * {@link LayoutEngine} real per-glyph metrics for text that has no pre-baked
- * vector atlas, fixing the coarse `0.5em` line-breaking fallback.
- *
- * Returns `null` in DOM-free environments (SSR, workers without a canvas) so
- * callers stay portable and the engine keeps its `0.5em` fallback.
- *
- * @param fontFamily - CSS font family used for measurement; should match what
- *   the renderer actually draws (e.g. `TextEntity` falls back to `sans-serif`).
- * @param baseSize - Pixel size at which each glyph is measured and cached.
- * @returns A measurer, or `null` when no Canvas 2D context is available.
- */
-export declare function createCanvasMeasurer(fontFamily?: string, baseSize?: number): GlyphMeasurer | null;

package/dist/math/SpatialHashGrid.d.ts

@@ -1,53 +0,0 @@
-/**
- * Fixed-cell Spatial Hash Grid for O(1) average-case AABB neighbor queries.
- * Insert entities each frame, then query by AABB to find nearby entity IDs.
- */
-export declare class SpatialHashGrid {
-    private cellSize;
-    private grid;
-    private entityCells;
-    constructor(cellSize?: number);
-    private hash;
-    private cellsForAABB;
-    /**
-     * Insert or update an entity's axis-aligned bounding box in the grid.
-     *
-     * If the entity is already registered its old cell memberships are removed
-     * before the new ones are computed, so this method is safe to call every
-     * frame.
-     *
-     * @param id - Unique string identifier for the entity.
-     * @param x - Left edge of the AABB in world space.
-     * @param y - Top edge of the AABB in world space.
-     * @param w - Width of the AABB.
-     * @param h - Height of the AABB.
-     */
-    insert(id: string, x: number, y: number, w: number, h: number): void;
-    /**
-     * Remove an entity from all grid cells it currently occupies.
-     *
-     * Silently does nothing if the entity is not registered.
-     *
-     * @param id - Unique string identifier of the entity to remove.
-     */
-    remove(id: string): void;
-    /**
-     * Return all entity IDs whose grid cells overlap the given AABB.
-     *
-     * Time complexity: O(k) where k is the number of cells the query AABB spans
-     * plus the number of results — O(1) average for small, similarly-sized entities.
-     *
-     * @param x - Left edge of the query AABB.
-     * @param y - Top edge of the query AABB.
-     * @param w - Width of the query AABB.
-     * @param h - Height of the query AABB.
-     * @returns A `Set` of entity ID strings whose cells intersect the query region.
-     */
-    query(x: number, y: number, w: number, h: number): Set<string>;
-    /**
-     * Clear all cells and entity registrations, resetting the grid to an empty state.
-     *
-     * Call once per frame before re-inserting all dynamic entities.
-     */
-    clear(): void;
-}

package/dist/math/SpringPhysics.d.ts

@@ -1,13 +0,0 @@
-export declare class SpringPhysics {
-    value: number;
-    target: number;
-    velocity: number;
-    stiffness: number;
-    damping: number;
-    mass: number;
-    private readonly valEpsilon;
-    private readonly velEpsilon;
-    constructor(initial: number);
-    update(dt: number): void;
-    isAtRest(): boolean;
-}

package/dist/text/ArabicShaper.d.ts

@@ -1,10 +0,0 @@
-export interface ShapedResult {
-    shapedText: string;
-    indexMap: Int32Array;
-}
-export declare class ArabicShaper {
-    private static MAPPINGS;
-    private static isHarakat;
-    private static getJoiningType;
-    static shapeArabic(text: string): ShapedResult;
-}

package/dist/text/BidiResolver.d.ts

@@ -1,5 +0,0 @@
-export declare class BidiResolver {
-    static getBaseLevel(text: string): number;
-    static resolveLevels(text: string): Uint8Array;
-    static reorderVisual(nodes: any[], baseLevel: number): void;
-}

package/dist/text/MSDFFont.d.ts

@@ -1,129 +0,0 @@
-/**
- * MSDF (Multi-channel Signed Distance Field) font support.
- *
- * Parses the `msdf-atlas-gen` JSON layout — the de-facto MSDF format produced by
- * Chlumsky's `msdf-atlas-gen` / `msdfgen` — and lays a string out into textured
- * quads positioned in CSS pixels with atlas UVs. Pair {@link MSDFFont.layout}
- * with the WebGL backend's `setMSDFTexture` + `addGlyph` to render GPU text that
- * stays crisp at any scale (and supports outline/glow in the shader).
- *
- * Geometry conventions match the renderer: local space is y-down, top-left
- * origin; UVs use v=0 at the top of the atlas image (atlas uploaded without a
- * Y-flip, the same as `setTexture`/`addSprite`).
- */
-/** Atlas section of an `msdf-atlas-gen` JSON file. */
-export interface MSDFAtlasInfo {
-    /** Field type, e.g. `'msdf'` | `'mtsdf'` | `'sdf'`. */
-    type: string;
-    /** Distance field range in atlas pixels — drives the shader's edge sharpness. */
-    distanceRange: number;
-    /** Glyph size the atlas was rasterized at (em → px), informational. */
-    size: number;
-    /** Atlas image width in pixels. */
-    width: number;
-    /** Atlas image height in pixels. */
-    height: number;
-    /** Whether `atlasBounds` are measured from the image bottom or top. */
-    yOrigin: 'bottom' | 'top';
-}
-/** Font-wide metrics in em units. */
-export interface MSDFMetrics {
-    emSize: number;
-    /** Line advance in em (multiply by font size for px). */
-    lineHeight: number;
-    /** Distance from baseline to the top of the line in em (positive, up). */
-    ascender: number;
-    /** Distance from baseline to the bottom in em (negative, down). */
-    descender: number;
-    underlineY?: number;
-    underlineThickness?: number;
-}
-/** Em-unit / atlas-pixel rectangle as emitted by `msdf-atlas-gen`. */
-export interface MSDFBounds {
-    left: number;
-    bottom: number;
-    right: number;
-    top: number;
-}
-/** One glyph's metrics. Whitespace has `advance` but no plane/atlas bounds. */
-export interface MSDFGlyphDef {
-    unicode: number;
-    /** Horizontal advance in em units. */
-    advance: number;
-    /** Quad position relative to the baseline, em units, y-up. */
-    planeBounds?: MSDFBounds;
-    /** Source rectangle in the atlas, pixels. */
-    atlasBounds?: MSDFBounds;
-}
-/** Kerning pair adjustment in em units. */
-export interface MSDFKerning {
-    unicode1: number;
-    unicode2: number;
-    advance: number;
-}
-/** A parsed `msdf-atlas-gen` JSON document. */
-export interface MSDFFontData {
-    atlas: MSDFAtlasInfo;
-    metrics: MSDFMetrics;
-    glyphs: MSDFGlyphDef[];
-    kerning?: MSDFKerning[];
-}
-/** A glyph positioned for rendering: a CSS-pixel quad + atlas UVs (0..1). */
-export interface PositionedGlyph {
-    /** Source character (may be a surrogate-pair astral codepoint). */
-    char: string;
-    /** Quad top-left in local CSS pixels (y-down). */
-    x: number;
-    y: number;
-    /** Quad size in CSS pixels. */
-    w: number;
-    h: number;
-    /** Atlas UVs: `(u0,v0)` top-left, `(u1,v1)` bottom-right; v=0 is the atlas top. */
-    u0: number;
-    v0: number;
-    u1: number;
-    v1: number;
-}
-/** Result of {@link MSDFFont.layout}. */
-export interface MSDFLayoutResult {
-    glyphs: PositionedGlyph[];
-    /** Total pen advance of the widest line in CSS pixels. */
-    width: number;
-    /** `lineCount × lineHeight × fontSize` in CSS pixels. */
-    height: number;
-}
-/** Options for {@link MSDFFont.layout}. */
-export interface MSDFLayoutOptions {
-    /** Pen origin x (left of the first glyph), CSS pixels. Default 0. */
-    x?: number;
-    /** Text-block top y (baseline of line 0 = `y + ascender×size`). Default 0. */
-    y?: number;
-    /** Extra advance added after every glyph, CSS pixels. Default 0. */
-    letterSpacing?: number;
-}
-/**
- * A loaded MSDF font. Construct from parsed {@link MSDFFontData}, or use
- * {@link MSDFFont.parse} to read the JSON string straight from `msdf-atlas-gen`.
- */
-export declare class MSDFFont {
-    private static idCounter;
-    readonly id: string;
-    readonly data: MSDFFontData;
-    private readonly byCode;
-    private readonly kern;
-    constructor(data: MSDFFontData);
-    /** Parse the `msdf-atlas-gen` JSON (string or already-parsed object). */
-    static parse(json: string | MSDFFontData): MSDFFont;
-    /** Get a glyph's definition by its unicode value in O(1) time. */
-    getGlyph(unicode: number): MSDFGlyphDef | undefined;
-    /** Distance field range in atlas pixels (for the shader's `u_distanceRange`). */
-    get distanceRange(): number;
-    get atlasWidth(): number;
-    get atlasHeight(): number;
-    /**
-     * Lay `text` out at `fontSizePx`. Returns positioned quads (skipping glyphs the
-     * font doesn't contain), the widest line's advance, and the total block height.
-     * Honors `\n`, kerning pairs, and `letterSpacing`.
-     */
-    layout(text: string, fontSizePx: number, opts?: MSDFLayoutOptions): MSDFLayoutResult;
-}

package/dist/text/PreparedContentGrid.d.ts

@@ -1,60 +0,0 @@
-export interface PreparedContentGridCell {
-    /** UTF-16 source start, matching DOM Range offsets. */
-    readonly sourceStart: number;
-    /** UTF-16 source end, matching DOM Range offsets. */
-    readonly sourceEnd: number;
-    /** Legal UTF-16 caret offsets relative to `sourceStart`. */
-    readonly sourceCaretOffsets: readonly number[];
-    /** Contextually shaped glyph text used by the canvas painter. */
-    readonly glyph: string;
-    /** Visual x coordinate inside the line. */
-    readonly x: number;
-    /** Grid advance in local CSS pixels. */
-    readonly advance: number;
-    /** Resolved bidi embedding level. */
-    readonly level: number;
-}
-export interface PreparedContentGridLine {
-    /** Start of this logical line in {@link PreparedContentGrid.source}. */
-    readonly sourceStart: number;
-    /** End of visible line content, excluding the hard break. */
-    readonly sourceEnd: number;
-    /** Start of the next line, thereby owning the intervening hard break. */
-    readonly nextSourceStart: number;
-    /** Total visual grid width in local CSS pixels. */
-    readonly width: number;
-    /** Cells stay in logical source order; their x coordinates encode visual order. */
-    readonly cells: readonly PreparedContentGridCell[];
-}
-/**
- * Immutable source-aware geometry shared by canvas grid text and its semantic
- * DOM projection. It deliberately remains independent of syntax highlighting.
- */
-export interface PreparedContentGrid {
-    readonly kind: 'content-grid';
-    readonly revision: number;
-    readonly source: string;
-    readonly font: string;
-    readonly cellWidth: number;
-    readonly lineHeight: number;
-    readonly baseline: number;
-    readonly tabSize: number;
-    readonly lines: readonly PreparedContentGridLine[];
-}
-export interface PrepareContentGridOptions {
-    /** CSS font shorthand shared by canvas and the projected DOM. */
-    font: string;
-    /** Width of one grid column in local CSS pixels. */
-    cellWidth: number;
-    /** Visual line advance in local CSS pixels. */
-    lineHeight: number;
-    /** Canvas baseline relative to each line's top. */
-    baseline: number;
-    /** Number of columns between tab stops. Defaults to 4. */
-    tabSize?: number;
-}
-/**
- * Compile logical source into one retained grid plan. Canvas paint and native
- * text projection must consume this same object rather than re-segmenting it.
- */
-export declare function prepareContentGrid(source: string, options: PrepareContentGridOptions): PreparedContentGrid;

package/dist/text/Typography.d.ts

@@ -1,11 +0,0 @@
-/**
- * Return the baseline offset inside a CSS line box for a canvas-compatible
- * font. Canvas text and a native editor must use this identical value whenever
- * one mirrors the other; CSS otherwise centers font metrics in the line box.
- *
- * The 0.8 fallback preserves the framework's deterministic, DOM-free text
- * contract in SSR and test environments where Canvas 2D is unavailable.
- */
-export declare function cssLineBoxBaseline(font: string, lineHeight: number): number;
-/** Clear cached browser font metrics after a webfont finishes loading. */
-export declare function clearCssLineBoxMetrics(): void;