@weasel-js/font 1.6.1 → 1.7.1

package/dist/{test-seams-BpiGqWz-.d.ts → test-seams-Df2Zqwk8.d.ts}

@@ -1,82 +1,4 @@
-/**
- * BmFont JSON types and parser for the MSDF atlas format produced by
- * msdf-bmfont-xml. The parser builds accelerator maps (charMap, kerningMap)
- * for O(1) glyph and kerning lookup during layout.
- */
-interface BmFontInfo {
-    face: string;
-    size: number;
-}
-/** Font-wide vertical metrics and the atlas page dimensions, in pixels. */
-interface BmFontCommon {
-    lineHeight: number;
-    base: number;
-    scaleW: number;
-    scaleH: number;
-}
-/** One glyph: where it sits in the atlas page (`x`/`y`/`width`/`height`),
- *  where to draw it relative to the pen (`xoffset`/`yoffset`), and how far the
- *  pen then advances. */
-interface BmFontChar {
-    id: number;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    xoffset: number;
-    yoffset: number;
-    xadvance: number;
-    page: number;
-}
-/** A kerning pair: `amount` px to add to the advance when `second` follows
- *  `first`. Codepoints, not glyph indices. */
-interface BmFontKerning {
-    first: number;
-    second: number;
-    amount: number;
-}
-/** A parsed MSDF atlas: the BmFont record plus the `charMap` / `kerningMap`
- *  accelerators layout reads per glyph. */
-interface BmFont {
-    info: BmFontInfo;
-    common: BmFontCommon;
-    chars: BmFontChar[];
-    kernings: BmFontKerning[];
-    charMap: Map<number, BmFontChar>;
-    kerningMap: Map<number, Map<number, number>>;
-}
-/** Two-glyph fixture for unit tests. */
-declare const FIXTURE_FONT: {
-    info: {
-        face: string;
-        size: number;
-    };
-    common: {
-        lineHeight: number;
-        base: number;
-        scaleW: number;
-        scaleH: number;
-    };
-    chars: {
-        id: number;
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        xoffset: number;
-        yoffset: number;
-        xadvance: number;
-        page: number;
-    }[];
-    kernings: {
-        first: number;
-        second: number;
-        amount: number;
-    }[];
-};
-/** Validate a BmFont JSON document and build its lookup maps. Throws with the
- *  missing or malformed field named. */
-declare function parseBmFont(raw: unknown): BmFont;
+import { Reflection } from '@weasel-js/registry';
 
 /**
  * The style axis of a font variant, one declaration for the whole stack.
@@ -145,7 +67,7 @@ interface GlyphTextureSink {
  * mip levels blend across glyph rects).
  */
 
-interface FaceMetrics {
+interface FaceMetrics$1 {
     ascent: number;
     descent: number;
 }
@@ -158,7 +80,7 @@ interface RasterizedGlyph {
     advance: number;
 }
 interface GlyphRasterizer {
-    faceMetrics(family: string, weight: number, style: FontStyle): FaceMetrics;
+    faceMetrics(family: string, weight: number, style: FontStyle): FaceMetrics$1;
     rasterize(family: string, weight: number, style: FontStyle, codepoint: number): RasterizedGlyph;
 }
 
@@ -297,6 +219,7 @@ declare function _resetDynamicFontsForTests(): void;
  * parse happens once per glyph, and core caches the *tessellation*, not the
  * text.
  */
+
 /** A parsed font face, viewed only as a source of glyph outlines. See the
  *  module comment for the em-space contract `glyphD` returns. */
 interface OutlineFace {
@@ -307,11 +230,16 @@ interface OutlineFace {
      * Distance from the line top to the baseline, in em units — the outline
      * tier's analogue of a `BmFont`'s `common.base`.
      *
-     * Read from `hhea`, which is what `msdf-bmfont-xml` bakes, so a face used
-     * for metrics puts text on the same baseline as an atlas of the same font.
-     * `docs/TODO.md` tracks the wider disagreement with `sTypoAscender`.
+     * The default parser reports `faceMetrics.ascent`, the ascent a browser
+     * sets the face with, so a face used for metrics puts text on the same
+     * baseline as an atlas of the same font and as the DOM edit overlay.
      */
     ascender: number;
+    /** The face's decoration and script metrics, derived with
+     *  `faceMetricsFromTables` so they match an atlas baked from the same
+     *  font. Optional: a custom parser that omits it leaves layout on its
+     *  defaults. */
+    faceMetrics?: FaceMetrics;
     /**
      * Em-space SVG path data for `cp`, or `null` when this face has no glyph
      * for the codepoint *or* the glyph has no contours (a space). Both answers
@@ -356,10 +284,24 @@ interface FontVariant {
     weight?: number;
     style?: FontStyle;
 }
+/** One family's registered faces, keyed `${weight}|${style}`. */
+type FontFamilyFaces = ReadonlyMap<string, FontEntry>;
+/** Every registered family and its faces, in registration order. `listFonts`
+ *  is the same set shaped for a font picker. */
+declare const fontRegistry: Reflection<FontFamilyFaces>;
 /** Test helper. Do not call from product code. */
 declare function _resetFontRegistryForTests(): void;
 /** Exact lookup — does NOT walk the fallback chain. Use `resolveFontVariant` for that. */
 declare function getFont(family: string, weight?: number, style?: FontStyle): FontEntry | null;
+/**
+ * The decoration and script metrics of an exact `(family, weight, style)` —
+ * the atlas's when one is registered, else a loaded outline face's. Like
+ * {@link getFont}, it walks no fallback chain and enrolls no canvas font,
+ * which suits a caller holding a CSS font name rather than a layout result.
+ * An idle outline face starts loading, as it would for layout.
+ * A run already resolved for layout reads `faceMetricsOf(result)` instead.
+ */
+declare function faceMetricsFor(family: string, weight?: number, style?: FontStyle): FaceMetrics | undefined;
 /** One family in the registry and the variants registered for it — what a
  *  font picker can honestly offer. */
 interface RegisteredFont {
@@ -376,11 +318,72 @@ interface RegisteredFont {
  */
 declare function listFonts(): readonly RegisteredFont[];
 /**
- * Fetch a baked MSDF atlas and its metrics, and register them as one variant
- * of `family`. Resolves once the face is usable; re-registering a variant that
- * is already present is a no-op.
+ * The weights `family` has a real face for, on the atlas tier or the outline
+ * tier, in either style — what a weight picker can honestly offer. Ascending
+ * and deduplicated; empty for a family nothing registered. An outline face
+ * whose load failed is left out. The canvas tier is not consulted: it
+ * rasterizes whatever weight it is asked for, so it has no list to report.
+ */
+declare function listFontWeights(family: string): readonly number[];
+/** Options for {@link registerFont}. */
+interface RegisterFontOptions {
+    /**
+     * Fetch nothing until text first resolves this face. Layout treats the face
+     * as pending from registration on, so a run set in it lays out as nothing —
+     * never in a fallback face's metrics — and relays out when the atlas lands.
+     * The returned promise settles with that load, so it never settles for a
+     * face no text uses.
+     */
+    lazy?: boolean;
+}
+/**
+ * Register a baked MSDF atlas and its metrics as one variant of `family`.
+ * Resolves once the face is usable; re-registering a variant that is already
+ * present is a no-op.
+ *
+ * Eager by default: both files are fetched now. With `{ lazy: true }` they are
+ * fetched the first time text asks for the family, which keeps the atlas off
+ * the critical path of anything that draws no text.
+ */
+declare function registerFont(family: string, variant: FontVariant, metricsUrl: string, atlasUrl: string, opts?: RegisterFontOptions): Promise<void>;
+/** One face text is set in, the way a render asks for it — what
+ *  {@link warmFonts} takes to load that face and nothing else. Weight
+ *  defaults to 400 and style to `'normal'`. */
+interface FontRequest {
+    family: string;
+    weight?: number;
+    style?: FontStyle;
+}
+/**
+ * Load registered atlases ahead of their first use, so a synchronous render —
+ * `renderSceneToPixels`, an export, a print — draws text set in a lazily
+ * registered face rather than nothing. With no list, loads every family
+ * `registerFont` was called for.
+ *
+ * A family name loads every variant registered for it. A {@link FontRequest}
+ * loads what resolving that one variant would draw with: the exact variant
+ * when one was registered, otherwise every variant of the family, since the
+ * within-family chain may land on any; the family the `'substitute'` policy
+ * would draw instead when the requested one has no atlas; and the variant's
+ * outline face when one is registered.
+ *
+ * Starts each lazily declared variant and joins any fetch already running.
+ * Resolves once they have all landed; a registered variant counts as loaded.
+ * Rejects when a load fails, or for a family name `registerFont` never saw —
+ * a request for such a family is not an error, since the canvas and outline
+ * tiers serve families no atlas was registered for.
  */
-declare function registerFont(family: string, variant: FontVariant, metricsUrl: string, atlasUrl: string): Promise<void>;
+declare function warmFonts(fonts?: readonly (string | FontRequest)[]): Promise<void>;
+/**
+ * Could a registration that has not landed yet still serve this request?
+ * True while any `registerFont` for the family is fetching — the within-family
+ * chain may resolve to whichever variant it brings — or while an outline face
+ * registered for this exact variant has not finished loading.
+ *
+ * A face that resolves to nothing right now is either missing or merely late;
+ * this tells the two apart, so "not registered" is reported only when it is.
+ */
+declare function fontPending(family: string, weight?: number, style?: FontStyle): boolean;
 /**
  * Ensure the atlas for `(family, weight, style)` is uploaded to
  * `textureCache`. Cache key is `${family}|${weight}|${style}` so each
@@ -472,6 +475,206 @@ declare function resolveFontVariant(family: string, weight: number, style: FontS
  */
 declare function resolveGlyphFallback(family: string, weight: number, style: FontStyle): ResolveResult | null;
 
+/**
+ * The line, decoration and script metrics a font states for itself, in the
+ * kit's units: em fractions, with a rule's `offset` measured *down* from the
+ * baseline to its top edge (y grows down) and a script's `shift` positive
+ * for a rise.
+ *
+ * Both glyph tiers carry the same record — an atlas bakes it into its JSON,
+ * a parsed face reads it off the font's tables — and both derive it through
+ * {@link faceMetricsFromTables}, so one font yields one set of numbers
+ * whichever tier ends up serving a run.
+ */
+
+/** One rule: the top edge's distance below the baseline, and its weight. */
+interface FaceRuleMetrics {
+    readonly offset: number;
+    readonly thickness: number;
+}
+/** One script preset: `size` scales the inherited font size, `shift` raises
+ *  (positive) or lowers (negative) the baseline, in inherited ems. */
+interface FaceScriptMetrics {
+    readonly size: number;
+    readonly shift: number;
+}
+/** What a face says about its line, rules, scripts and letter heights.
+ *  Every field is optional: a font may carry some of these tables and not
+ *  others. */
+interface FaceMetrics {
+    /** Baseline to the top of the face's line box, in ems — the ascent a
+     *  browser sets this face with. See {@link verticalMetricsFromTables}. */
+    readonly ascent?: number;
+    /** Baseline to the bottom of the face's line box, in ems, positive
+     *  downward. Present exactly when `ascent` is. */
+    readonly descent?: number;
+    readonly underline?: FaceRuleMetrics;
+    readonly strikethrough?: FaceRuleMetrics;
+    readonly superscript?: FaceScriptMetrics;
+    readonly subscript?: FaceScriptMetrics;
+    /** Height of a flat lowercase letter above the baseline, in ems
+     *  (`OS/2.sxHeight`). */
+    readonly xHeight?: number;
+    /** Height of a flat capital above the baseline, in ems
+     *  (`OS/2.sCapHeight`). */
+    readonly capHeight?: number;
+}
+/** The table fields {@link faceMetricsFromTables} reads, in font units, as
+ *  the OpenType `post` and `OS/2` tables state them. */
+interface FaceMetricTables {
+    unitsPerEm: number;
+    hhea?: {
+        ascender?: number;
+        descender?: number;
+    };
+    post?: {
+        underlinePosition?: number;
+        underlineThickness?: number;
+    };
+    os2?: {
+        fsSelection?: number;
+        sTypoAscender?: number;
+        sTypoDescender?: number;
+        usWinAscent?: number;
+        usWinDescent?: number;
+        yStrikeoutPosition?: number;
+        yStrikeoutSize?: number;
+        ySuperscriptYSize?: number;
+        ySuperscriptYOffset?: number;
+        ySubscriptYSize?: number;
+        ySubscriptYOffset?: number;
+        sxHeight?: number;
+        sCapHeight?: number;
+    };
+}
+/**
+ * The ascent and descent a browser sets this face with, in ems, descent
+ * positive downward.
+ *
+ * The OpenType rule: `OS/2` `sTypoAscender`/`sTypoDescender` when the font
+ * sets `USE_TYPO_METRICS`, otherwise `hhea`. It is the browser's rule rather
+ * than a typographer's because the DOM edit overlay stands in for the canvas
+ * and can only ever get the browser's numbers. Firefox, and every engine on
+ * Linux, follow it; Chromium and WebKit on macOS read `hhea` even when the
+ * flag is set, and the overlay's measured baseline correction absorbs the
+ * difference there. `verticalMetrics.browser.test.ts` pins both.
+ *
+ * Falls back to the typo pair, then the win pair, when `hhea` is absent or
+ * zero.
+ */
+declare function verticalMetricsFromTables(t: FaceMetricTables): {
+    ascent: number;
+    descent: number;
+} | undefined;
+/**
+ * Convert raw table values to {@link FaceMetrics}.
+ *
+ * `post.underlinePosition` and `OS/2.yStrikeoutPosition` are the rule's top
+ * edge, positive above the baseline. `ySubscriptYOffset` is positive
+ * *downward*, unlike its superscript twin. A zero weight or size is a font
+ * that left the field blank, not one asking for an invisible rule, so that
+ * entry is dropped and the caller's default applies — which is also how an
+ * `OS/2` table older than version 2 reads, since it has no heights at all.
+ */
+declare function faceMetricsFromTables(t: FaceMetricTables): FaceMetrics | undefined;
+/**
+ * The face metrics behind a resolved run — the outline face's on the outline
+ * tier, the atlas's on the atlas tier. The canvas tier rasterizes through
+ * `CanvasRenderingContext2D`, which exposes no font tables, so it has none
+ * and callers fall back to their defaults.
+ */
+declare function faceMetricsOf(result: ResolveResult): FaceMetrics | undefined;
+
+/**
+ * BmFont JSON types and parser for the MSDF atlas format produced by
+ * msdf-bmfont-xml. The parser builds accelerator maps (charMap, kerningMap)
+ * for O(1) glyph and kerning lookup during layout.
+ */
+
+interface BmFontInfo {
+    face: string;
+    size: number;
+}
+/** Font-wide vertical metrics and the atlas page dimensions, in pixels. */
+interface BmFontCommon {
+    lineHeight: number;
+    base: number;
+    scaleW: number;
+    scaleH: number;
+}
+/** One glyph: where it sits in the atlas page (`x`/`y`/`width`/`height`),
+ *  where to draw it relative to the pen (`xoffset`/`yoffset`), and how far the
+ *  pen then advances. */
+interface BmFontChar {
+    id: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    xoffset: number;
+    yoffset: number;
+    xadvance: number;
+    page: number;
+}
+/** A kerning pair: `amount` px to add to the advance when `second` follows
+ *  `first`. Codepoints, not glyph indices. */
+interface BmFontKerning {
+    first: number;
+    second: number;
+    amount: number;
+}
+/** A parsed MSDF atlas: the BmFont record plus the `charMap` / `kerningMap`
+ *  accelerators layout reads per glyph. */
+interface BmFont {
+    info: BmFontInfo;
+    common: BmFontCommon;
+    chars: BmFontChar[];
+    kernings: BmFontKerning[];
+    charMap: Map<number, BmFontChar>;
+    kerningMap: Map<number, Map<number, number>>;
+    /** The font's own decoration and script metrics, when the bake recorded
+     *  them. Not part of the BMFont format: `gen-font` adds it as a top-level
+     *  `faceMetrics` block, and an atlas without one leaves layout on its
+     *  defaults. */
+    faceMetrics?: FaceMetrics;
+    /** Atlas texels over which the distance field runs from 0 to 1, edge at
+     *  0.5 — msdf-bmfont-xml's `distanceField.distanceRange`. Absent when the
+     *  file does not record it. */
+    distanceRange?: number;
+}
+/** Two-glyph fixture for unit tests. */
+declare const FIXTURE_FONT: {
+    info: {
+        face: string;
+        size: number;
+    };
+    common: {
+        lineHeight: number;
+        base: number;
+        scaleW: number;
+        scaleH: number;
+    };
+    chars: {
+        id: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        xoffset: number;
+        yoffset: number;
+        xadvance: number;
+        page: number;
+    }[];
+    kernings: {
+        first: number;
+        second: number;
+        amount: number;
+    }[];
+};
+/** Validate a BmFont JSON document and build its lookup maps. Throws with the
+ *  missing or malformed field named. */
+declare function parseBmFont(raw: unknown): BmFont;
+
 /**
  * Cross-family fallback policy. The per-family chain in `resolveFontVariant`
  * (weight → style → synthetic) has always been rich; what was missing is what
@@ -504,6 +707,57 @@ declare function getDefaultFontFamily(): string | null;
 /** Test helper. Do not call from product code. */
 declare function _resetFallbackForTests(): void;
 
+/**
+ * The face the canvas draws, handed to DOM text.
+ *
+ * A family name means one thing to the registry and another to CSS: the kit
+ * may draw `sans-serif` from a baked Inter atlas while a `font-family:
+ * sans-serif` in the page resolves to Helvetica. Anything the DOM sets in
+ * place of canvas text — the text edit overlay above all — asks here instead
+ * of writing the name through. The answer names a private `FontFace` loaded
+ * from the family's registered font file, with the family itself as fallback
+ * while that loads.
+ *
+ * The font file is the one `registerFontOutlines` holds; that registry is the
+ * kit's record of which faces have real bytes behind them. An atlas-only
+ * family has none, so the DOM gets the browser's own face for the name and a
+ * one-time warning says which registration would fix it.
+ */
+
+/**
+ * The CSS `font-family` value that sets DOM text in the face the canvas draws
+ * for `family` at this variant.
+ *
+ * - A family the canvas draws through the browser (`registerCanvasFont`, or
+ *   the `'canvas'` fallback policy) comes back unchanged: the DOM already
+ *   resolves the name to the same face.
+ * - A family drawn from a baked atlas or from outlines comes back as a private
+ *   face built from its `registerFontOutlines` file — every registered weight
+ *   and style of it, so the browser picks and synthesizes within the family
+ *   the way the canvas does — followed by `family` as the fallback.
+ * - Under the `'substitute'` policy, the face is the substitute's.
+ *
+ * Starts loading the face on first call and never waits for it; ask
+ * {@link cssFontFamilyLoading} for that. A face whose bytes arrived earlier —
+ * passed to `registerFontOutlines` as an `ArrayBuffer`, or read for the canvas
+ * — was built when they did. Outside a browser, `family` comes back unchanged.
+ */
+declare function cssFontFamily(family: string, variant?: FontVariant): string;
+/**
+ * The load still in flight for the face {@link cssFontFamily} names for
+ * `family` at this variant, or `null` when there is nothing to wait for: it
+ * has loaded or failed, or the DOM uses `family` as it stands. Waits on the
+ * variant's own face when one is registered and on the whole family
+ * otherwise, since the browser then picks among them. Starts the load like
+ * `cssFontFamily` does, and never rejects.
+ *
+ * `null` rather than a settled promise, so a caller whose face is loaded goes
+ * on in the same task instead of a microtask later.
+ */
+declare function cssFontFamilyLoading(family: string, variant?: FontVariant): Promise<void> | null;
+/** @internal Test seam — module state. */
+declare function _resetDomFacesForTests(): void;
+
 /**
  * The outline tier's registry: which faces have real font bytes behind them,
  * and what a given glyph looks like.
@@ -574,9 +828,26 @@ interface OutlineFontOptions {
     /** Override the default opentype.js parser. Mostly a test seam; also the
      *  hook for a consumer who already has a font parser in their bundle. */
     parser?: OutlineParser;
+    /**
+     * The `@font-face` `src` that gives DOM text this face — what the text edit
+     * overlay sets its glyphs in, so they match the canvas's. Defaults to
+     * `url(…)` of a URL source and to the bytes themselves otherwise; a face
+     * whose bytes the browser cannot load directly, such as one member of a
+     * `.ttc`, names it here instead (`local("Helvetica-Bold")`).
+     */
+    cssSrc?: string;
 }
 /** Load state of one registered face. */
 type OutlineStatus = 'idle' | 'loading' | 'ready' | 'failed';
+/** One registered outline face and its load state. */
+interface OutlineFaceInfo {
+    readonly family: string;
+    readonly weight: number;
+    readonly style: FontStyle;
+    readonly status: OutlineStatus;
+}
+/** Every registered outline face, keyed `family|weight|style`. */
+declare const fontOutlineRegistry: Reflection<OutlineFaceInfo>;
 /**
  * Register font file bytes for one face, so text set in it can render from
  * outlines above the size threshold.
@@ -606,12 +877,7 @@ declare function hasFontOutlines(family: string, weight?: number, style?: FontSt
 declare function outlineStatus(family: string, weight?: number, style?: FontStyle): OutlineStatus | null;
 /** Every registered outline face and its load state — the enumeration a
  *  debug overlay or font picker needs, mirroring `listFonts`. */
-declare function listFontOutlines(): readonly {
-    family: string;
-    weight: number;
-    style: FontStyle;
-    status: OutlineStatus;
-}[];
+declare function listFontOutlines(): readonly OutlineFaceInfo[];
 /**
  * Em-space SVG path data for one glyph of a registered outline face, or `null`
  * when there is nothing to draw.
@@ -637,7 +903,18 @@ declare function glyphOutline(family: string, weight: number, style: FontStyle,
  * frame after the bytes land.
  */
 declare function outlineMetrics(family: string, weight: number, style: FontStyle): OutlineFace | null;
+/**
+ * Load a registered face's bytes now and resolve with its settled status:
+ * `'ready'`, `'failed'`, or `null` when nothing is registered for the
+ * variant. Never rejects — a failed load is a status, the same one
+ * `outlineStatus` reports.
+ *
+ * The per-frame readers start a load and answer `null` until it lands, which
+ * suits a renderer and nothing that needs the geometry in one go: converting
+ * text to paths awaits this first.
+ */
+declare function loadFontOutlines(family: string, variant?: OutlineVariant): Promise<OutlineStatus | null>;
 /** @internal Test seam — registry and warn-once keys are module state. */
 declare function _resetFontOutlinesForTests(): void;
 
-export { _resetFontOutlinesForTests as $, outlineMetrics as A, type BmFont as B, type CanvasFontEntry as C, DEFAULT_BAKE_BUDGET as D, outlineStatus as E, type FontStyle as F, type GlyphTextureSink as G, parseBmFont as H, registerCanvasFont as I, registerFont as J, registerFontOutlines as K, resetBakeBudget as L, resolveFontVariant as M, resolveGlyphFallback as N, type OutlineFace as O, setDefaultFontFamily as P, setFontFallbackPolicy as Q, type RegisteredFont as R, syncDynamicPageTexture as S, type TexSource as T, textureCacheKey as U, unregisterCanvasFont as V, unregisterFontOutlines as W, _getPagesForTests as X, _resetDynamicFontsForTests as Y, _resetFallbackForTests as Z, __setGlyphRasterizerForTests as _, type BmFontChar as a, _resetFontRegistryForTests as a0, type BmFontCommon as b, type BmFontInfo as c, type BmFontKerning as d, FIXTURE_FONT as e, type FontEntry as f, type FontFallbackPolicy as g, type FontVariant as h, type OutlineFontOptions as i, type OutlineParser as j, type OutlineSource as k, type OutlineStatus as l, type OutlineVariant as m, type ResolveResult as n, dynamicPageTextureId as o, ensureFontTexture as p, getDefaultFontFamily as q, getFont as r, getFontFallbackPolicy as s, glyphOutline as t, hasFontOutlines as u, isCanvasFont as v, listCanvasFonts as w, listFontOutlines as x, listFonts as y, markAllFontsNotUploaded as z };
+export { outlineStatus as $, faceMetricsFor as A, type BmFont as B, type CanvasFontEntry as C, DEFAULT_BAKE_BUDGET as D, faceMetricsFromTables as E, type FontStyle as F, type GlyphTextureSink as G, faceMetricsOf as H, fontOutlineRegistry as I, fontPending as J, fontRegistry as K, getDefaultFontFamily as L, getFont as M, getFontFallbackPolicy as N, type OutlineFace as O, glyphOutline as P, hasFontOutlines as Q, type RegisterFontOptions as R, isCanvasFont as S, type TexSource as T, listCanvasFonts as U, listFontOutlines as V, listFontWeights as W, listFonts as X, loadFontOutlines as Y, markAllFontsNotUploaded as Z, outlineMetrics as _, type BmFontChar as a, parseBmFont as a0, registerCanvasFont as a1, registerFont as a2, registerFontOutlines as a3, resetBakeBudget as a4, resolveFontVariant as a5, resolveGlyphFallback as a6, setDefaultFontFamily as a7, setFontFallbackPolicy as a8, syncDynamicPageTexture as a9, textureCacheKey as aa, unregisterCanvasFont as ab, unregisterFontOutlines as ac, verticalMetricsFromTables as ad, warmFonts as ae, __setGlyphRasterizerForTests as af, _getPagesForTests as ag, _resetDomFacesForTests as ah, _resetDynamicFontsForTests as ai, _resetFallbackForTests as aj, _resetFontOutlinesForTests as ak, _resetFontRegistryForTests as al, type BmFontCommon as b, type BmFontInfo as c, type BmFontKerning as d, FIXTURE_FONT as e, type FaceMetricTables as f, type FaceMetrics as g, type FaceRuleMetrics as h, type FaceScriptMetrics as i, type FontEntry as j, type FontFallbackPolicy as k, type FontFamilyFaces as l, type FontRequest as m, type FontVariant as n, type OutlineFaceInfo as o, type OutlineFontOptions as p, type OutlineParser as q, type OutlineSource as r, type OutlineStatus as s, type OutlineVariant as t, type RegisteredFont as u, type ResolveResult as v, cssFontFamily as w, cssFontFamilyLoading as x, dynamicPageTextureId as y, ensureFontTexture as z };

package/dist/test-seams.d.ts

@@ -1 +1,2 @@
-export { _ as __setGlyphRasterizerForTests, X as _getPagesForTests, Y as _resetDynamicFontsForTests, Z as _resetFallbackForTests, $ as _resetFontOutlinesForTests, a0 as _resetFontRegistryForTests } from './test-seams-BpiGqWz-.js';
+export { af as __setGlyphRasterizerForTests, ag as _getPagesForTests, ah as _resetDomFacesForTests, ai as _resetDynamicFontsForTests, aj as _resetFallbackForTests, ak as _resetFontOutlinesForTests, al as _resetFontRegistryForTests } from './test-seams-Df2Zqwk8.js';
+import '@weasel-js/registry';

package/dist/test-seams.js

@@ -1,3 +1,3 @@
-export { __setGlyphRasterizerForTests, _getPagesForTests, _resetDynamicFontsForTests, _resetFallbackForTests, _resetFontOutlinesForTests, _resetFontRegistryForTests } from './chunk-QDTJ3CPE.js';
+export { __setGlyphRasterizerForTests, _getPagesForTests, _resetDomFacesForTests, _resetDynamicFontsForTests, _resetFallbackForTests, _resetFontOutlinesForTests, _resetFontRegistryForTests } from './chunk-RYN4NYX4.js';
 //# sourceMappingURL=test-seams.js.map
 //# sourceMappingURL=test-seams.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/font",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "description": "MSDF font atlases, glyph metrics, and runtime glyph rasterization for @weasel-js/core. Registry, kerning-aware glyph layout, and the SDF text shader source.",
   "license": "MIT",
   "type": "module",
@@ -46,6 +46,7 @@
     "provenance": true
   },
   "dependencies": {
+    "@weasel-js/registry": "1.7.1",
     "opentype.js": "2.0.0"
   }
 }