@aethervtt/shard-text 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @aethervtt/shard-text
+
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/build.d.ts

@@ -0,0 +1,43 @@
+import { type CharsetName } from './charset.js';
+import { Font, type FontMetricsJson } from './font.js';
+import { FontSource } from './source.js';
+export interface FontBuildOptions {
+    /** `latin`, `latin-extended`, or a string of the characters to include. Default `latin`. */
+    charset?: CharsetName | (string & {});
+    /** Atlas pixels per em. Default 48. */
+    size?: number;
+    /** Distance range in atlas pixels. Default 4. */
+    range?: number;
+    /** Include kerning pairs. Default true. */
+    kerning?: boolean;
+    /** Largest atlas page side (a power of two). Default 2048. */
+    maxPageSize?: number;
+    /** Padding around each glyph in pixels. Default 1. */
+    padding?: number;
+    /** Fallback font project paths, recorded in the metrics. */
+    fallback?: string[];
+}
+export interface FontBuild {
+    metrics: FontMetricsJson;
+    /** RGBA8 atlas pages (MSDF in RGB, alpha 255), row 0 at the top. */
+    pages: {
+        width: number;
+        height: number;
+        pixels: Uint8Array;
+    }[];
+    /** Charset codepoints the font doesn't have. */
+    missing: number[];
+    source: FontSource;
+}
+/**
+ * Generates a font's MSDF atlas and metrics: every charset glyph the font has, packed onto
+ * power-of-two pages, plus kerning between them and a missing-glyph box.
+ */
+export declare function buildFont(input: Uint8Array | FontSource, options?: FontBuildOptions): FontBuild;
+/**
+ * A runtime font straight from a font file (no asset import): builds the atlas in code and keeps
+ * the outlines for on-demand glyphs (unless `outlines` is false).
+ */
+export declare function fontFromBytes(bytes: Uint8Array, options?: FontBuildOptions & {
+    outlines?: boolean;
+}): Font;

package/dist/build.js

@@ -0,0 +1,106 @@
+import { packRects } from "@aethervtt/shard-texture";
+import { charsetCodepoints } from "./charset.js";
+import {
+  Font,
+  GLYPH_PADDING
+} from "./font.js";
+import { FontSource, rasterizeGlyph, TOFU_ADVANCE, tofuShape } from "./source.js";
+const round6 = (v) => Math.round(v * 1e6) / 1e6;
+function buildFont(input, options = {}) {
+  const source = input instanceof FontSource ? input : new FontSource(input);
+  const size = options.size ?? 48;
+  const range = options.range ?? 4;
+  const raster = { size, range };
+  const upem = source.unitsPerEm;
+  const charset = options.charset ?? "latin";
+  const codepoints = charsetCodepoints(charset);
+  const missing = [];
+  const entries = [];
+  for (const cp of codepoints) {
+    const index = source.glyphIndex(cp);
+    if (index === 0) {
+      missing.push(cp);
+      continue;
+    }
+    const bitmap = rasterizeGlyph(source.shape(index), upem, raster);
+    entries.push({ json: { u: cp, a: round6(source.advance(index) / upem) }, bitmap, index });
+  }
+  const notdefShape = source.shape(0);
+  const hasNotdef = notdefShape.contours.length > 0;
+  const notdef = {
+    json: { u: -1, a: hasNotdef ? round6(source.advance(0) / upem) : TOFU_ADVANCE },
+    bitmap: hasNotdef ? rasterizeGlyph(notdefShape, upem, raster) : rasterizeGlyph(tofuShape(), 1, raster),
+    index: 0
+  };
+  const all = [...entries, notdef];
+  const visible = all.filter((e) => e.bitmap.plane);
+  const packing = packRects(
+    visible.map((e) => ({ width: e.bitmap.width, height: e.bitmap.height })),
+    options.maxPageSize ?? 2048,
+    options.padding ?? GLYPH_PADDING
+  );
+  const pages = packing.pages.map((p) => {
+    const pixels = new Uint8Array(p.width * p.height * 4);
+    for (let i = 3; i < pixels.length; i += 4) pixels[i] = 255;
+    return { width: p.width, height: p.height, pixels };
+  });
+  visible.forEach((e, i) => {
+    const place = packing.placements[i];
+    const page = pages[place.page];
+    const bmp = e.bitmap;
+    for (let row = 0; row < bmp.height; row++) {
+      page.pixels.set(
+        bmp.pixels.subarray(row * bmp.width * 4, (row + 1) * bmp.width * 4),
+        ((place.y + row) * page.width + place.x) * 4
+      );
+    }
+    e.json.b = bmp.plane.map(round6);
+    e.json.r = [place.x, place.y, bmp.width, bmp.height];
+    if (place.page !== 0) e.json.p = place.page;
+  });
+  const kerning = [];
+  if (options.kerning !== false) {
+    const byGlyph = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      const list = byGlyph.get(e.index);
+      if (list) list.push(e.json.u);
+      else byGlyph.set(e.index, [e.json.u]);
+    }
+    const pairs = source.kerning(byGlyph.keys());
+    const sorted = [...pairs].sort((a, b) => a[0] - b[0]);
+    for (const [key, value] of sorted) {
+      const lefts = byGlyph.get(Math.floor(key / 65536));
+      const rights = byGlyph.get(key % 65536);
+      for (const l of lefts) for (const r of rights) kerning.push(l, r, value);
+    }
+  }
+  const metrics = {
+    version: 1,
+    name: source.name,
+    size,
+    range,
+    unitsPerEm: upem,
+    ascent: round6(source.ascender / upem),
+    descent: round6(source.descender / upem),
+    lineGap: round6(source.lineGap / upem),
+    pages: packing.pages,
+    glyphs: entries.map((e) => e.json),
+    notdef: notdef.json,
+    kerning,
+    charset: charset === "latin" || charset === "latin-extended" ? charset : "custom"
+  };
+  if (options.fallback?.length) metrics.fallback = [...options.fallback];
+  return { metrics, pages, missing, source };
+}
+function fontFromBytes(bytes, options = {}) {
+  const build = buildFont(bytes, options);
+  const load = {
+    pixels: build.pages.map((p) => p.pixels),
+    ...options.outlines === false ? {} : { source: build.source }
+  };
+  return Font.fromMetrics(build.metrics, load);
+}
+export {
+  buildFont,
+  fontFromBytes
+};

package/dist/charset.d.ts

@@ -0,0 +1,8 @@
+export type CharsetName = 'latin' | 'latin-extended';
+/**
+ * Codepoints of a charset, sorted and unique:
+ * - `latin`: printable ASCII, Latin-1 Supplement, and common typographic punctuation.
+ * - `latin-extended`: `latin` plus Latin Extended-A.
+ * - any other string: exactly its characters (plus the space).
+ */
+export declare function charsetCodepoints(charset: CharsetName | (string & {})): number[];

package/dist/charset.js

@@ -0,0 +1,43 @@
+const PUNCTUATION = [
+  8211,
+  8212,
+  8216,
+  8217,
+  8218,
+  8220,
+  8221,
+  8222,
+  8224,
+  8225,
+  8226,
+  8230,
+  8240,
+  8249,
+  8250,
+  8364,
+  8482
+];
+function range(from, to) {
+  const out = [];
+  for (let c = from; c <= to; c++) out.push(c);
+  return out;
+}
+function charsetCodepoints(charset) {
+  const set = /* @__PURE__ */ new Set();
+  if (charset === "latin" || charset === "latin-extended") {
+    for (const c of range(32, 126)) set.add(c);
+    for (const c of range(160, 255)) set.add(c);
+    for (const c of PUNCTUATION) set.add(c);
+    if (charset === "latin-extended") for (const c of range(256, 383)) set.add(c);
+  } else {
+    set.add(32);
+    for (const ch of charset) {
+      const cp = ch.codePointAt(0);
+      if (cp >= 32 && cp !== 127) set.add(cp);
+    }
+  }
+  return [...set].sort((a, b) => a - b);
+}
+export {
+  charsetCodepoints
+};

package/dist/components.d.ts

@@ -0,0 +1,54 @@
+export declare const TEXT_ALIGNS: readonly ['left', 'center', 'right'];
+export declare const Text: import("@aethervtt/shard-core").ComponentDef<{
+    readonly value: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly key: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly params: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").JsonValue, "object">;
+    readonly font: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Font"> | null, "object">;
+    readonly color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    readonly align: import("@aethervtt/shard-core").FieldType<"center" | "left" | "right", "u8">;
+    readonly anchor: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly maxWidth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly lineHeight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly weight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly outline: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        width: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    }>, "object">;
+    readonly shadow: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        offset: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        softness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    }>, "object">;
+    readonly size: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly billboard: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}>;
+export declare const SCREEN_CORNERS: readonly ['top-left', 'top', 'top-right', 'left', 'center', 'right', 'bottom-left', 'bottom', 'bottom-right'];
+export declare const ScreenText: import("@aethervtt/shard-core").ComponentDef<{
+    readonly value: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly key: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly params: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").JsonValue, "object">;
+    readonly font: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Font"> | null, "object">;
+    readonly color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    readonly align: import("@aethervtt/shard-core").FieldType<"center" | "left" | "right", "u8">;
+    readonly anchor: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly maxWidth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly lineHeight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly weight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly outline: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        width: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    }>, "object">;
+    readonly shadow: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        offset: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        softness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    }>, "object">;
+    readonly size: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly corner: import("@aethervtt/shard-core").FieldType<"bottom" | "bottom-left" | "bottom-right" | "center" | "left" | "right" | "top" | "top-left" | "top-right", "u8">;
+    readonly position: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+}>;
+/** The string a localized text shows: its key resolved in the current locale (0038). */
+export declare const Localized: import("@aethervtt/shard-core").ComponentDef<{
+    readonly value: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly locale: import("@aethervtt/shard-core").FieldType<string, "object">;
+}>;

package/dist/components.js

@@ -0,0 +1,118 @@
+import { defineComponent, t } from "@aethervtt/shard-core";
+import { Visibility } from "@aethervtt/shard-render";
+import { Transform } from "@aethervtt/shard-transform";
+const TEXT_ALIGNS = ["left", "center", "right"];
+const textFields = {
+  value: t.string({
+    description: 'The text. "\\n" breaks a line. With a key, it shows until the key resolves.'
+  }),
+  key: t.string({
+    description: "Localization key in the locales/*.strings.json tables: the text shows the current locale's string for it, and follows locale switches."
+  }),
+  params: t.json({
+    default: {},
+    description: `Values for the key's {name} placeholders: { "amount": 42 }. Numbers format for the locale; "n" (or "count") picks the plural form.`
+  }),
+  font: t.handle("Font", { description: "An imported font (.ttf, .otf)." }),
+  color: t.color({ default: [1, 1, 1, 1], description: "Fill color (linear)." }),
+  align: t.enum(TEXT_ALIGNS, { description: "Line alignment within the block." }),
+  anchor: t.vec2({
+    default: [0.5, 0.5],
+    description: "Pivot of the text block, y up: [0, 0] bottom left, [1, 1] top right."
+  }),
+  maxWidth: t.f32({ min: 0, description: "Wrap lines longer than this (0: never wrap)." }),
+  lineHeight: t.f32({
+    default: 1.2,
+    min: 0.1,
+    description: "Distance between baselines, as a multiple of the size."
+  }),
+  weight: t.f32({
+    min: -0.25,
+    max: 0.25,
+    description: "Thickens (+) or thins (\u2212) the strokes, in em fractions of the distance range."
+  }),
+  outline: t.struct(
+    {
+      width: t.f32({
+        min: 0,
+        max: 0.25,
+        description: "Outline thickness, in em (0: none). At most about half the font's distance range: range \xF7 (2 \xD7 atlas size), 0.04 em at the defaults."
+      }),
+      color: t.color({ default: [0, 0, 0, 1], description: "Outline color (linear)." })
+    },
+    { description: "An outline around the glyphs, from the distance field." }
+  ),
+  shadow: t.struct(
+    {
+      offset: t.vec2({ description: "Shadow offset in em, y up (0, 0 with softness: a glow)." }),
+      softness: t.f32({
+        min: 0,
+        max: 1,
+        description: "Blur of the shadow (0: none unless offset)."
+      }),
+      color: t.color({ default: [0, 0, 0, 0.6], description: "Shadow color (linear, alpha)." })
+    },
+    { description: "A soft shadow or glow behind the glyphs." }
+  )
+};
+const Text = defineComponent(
+  "text/Text",
+  {
+    ...textFields,
+    size: t.f32({
+      default: 1,
+      min: 0,
+      unit: "m",
+      description: "Height of one em, in world units."
+    }),
+    billboard: t.bool({ description: "Always face the camera (labels, markers)." })
+  },
+  {
+    description: "Text in the world, in the entity's XY plane (or facing the camera): MSDF glyphs, sharp at any size and angle.",
+    requires: [Transform, Visibility]
+  }
+);
+const SCREEN_CORNERS = [
+  "top-left",
+  "top",
+  "top-right",
+  "left",
+  "center",
+  "right",
+  "bottom-left",
+  "bottom",
+  "bottom-right"
+];
+const ScreenText = defineComponent(
+  "text/ScreenText",
+  {
+    ...textFields,
+    size: t.f32({ default: 24, min: 0, description: "Height of one em, in pixels." }),
+    corner: t.enum(SCREEN_CORNERS, {
+      description: "The view point it's positioned from."
+    }),
+    position: t.vec2({ description: "Offset from the corner in pixels, x right, y down." })
+  },
+  {
+    description: "Text over the finished image (after tonemapping), placed in pixels from a view corner.",
+    requires: [Visibility]
+  }
+);
+const Localized = defineComponent(
+  "text/Localized",
+  {
+    value: t.string({ readonly: true, description: "The resolved string." }),
+    locale: t.string({ readonly: true, description: 'The locale it came from ("" if missing).' })
+  },
+  {
+    description: "Set by localization on entities whose UiText, Text, or ScreenText has a key: the translated string, shown instead of the text. Derived: never written to scenes or saves.",
+    serialize: false
+  }
+);
+export {
+  Localized,
+  SCREEN_CORNERS,
+  ScreenText,
+  TEXT_ALIGNS,
+  Text
+};

package/dist/font.d.ts

@@ -0,0 +1,193 @@
+import type { AssetRef } from '@aethervtt/shard-core';
+import { SkylinePacker, Texture } from '@aethervtt/shard-texture';
+import { FontSource } from './source.js';
+/** One glyph in the metrics JSON. Lengths are em units; the atlas box is in pixels. */
+export interface GlyphJson {
+    /** Codepoint; -1 for the missing-glyph box. */
+    u: number;
+    /** Advance width. */
+    a: number;
+    /** Quad bounds relative to the pen on the baseline (y up): left, bottom, right, top. */
+    b?: [number, number, number, number];
+    /** Atlas box: x, y (top-left), width, height, in pixels. The quad maps to its texel centers. */
+    r?: [number, number, number, number];
+    /** Atlas page (default 0). */
+    p?: number;
+}
+/**
+ * A font's imported metrics: the `Font` asset's JSON artifact. Everything a layout needs, plus
+ * where each glyph sits in the atlas pages (the `#Atlas` texture sub-assets).
+ */
+export interface FontMetricsJson {
+    version: 1;
+    name: string;
+    /** Atlas pixels per em. */
+    size: number;
+    /** Distance range in atlas pixels. */
+    range: number;
+    /** The source font's units per em (kerning values are in these units). */
+    unitsPerEm: number;
+    /** Em units: ascent above the baseline (positive), descent below it (negative), line gap. */
+    ascent: number;
+    descent: number;
+    lineGap: number;
+    pages: {
+        width: number;
+        height: number;
+    }[];
+    glyphs: GlyphJson[];
+    notdef: GlyphJson;
+    /** Kerning pairs as flat triples: left codepoint, right codepoint, adjustment in font units. */
+    kerning: number[];
+    /** Project paths of fallback fonts, tried in order for missing glyphs. */
+    fallback?: string[];
+    /** What the atlas covers: `latin`, `latin-extended`, or `custom`. */
+    charset?: string;
+}
+/** An atlas page. Imported pages point at their texture asset; runtime pages own a Texture. */
+export declare class FontPage {
+    readonly font: Font;
+    readonly index: number;
+    readonly width: number;
+    readonly height: number;
+    /** The page's texture asset (`font.ttf#Atlas`), for imported fonts. */
+    ref: AssetRef | undefined;
+    /**
+     * The page's pixels, for runtime pages and fonts built in code. Its `version` bumps when glyphs
+     * are added, so the renderer re-uploads it.
+     */
+    texture: Texture | undefined;
+    /** Made at runtime for glyphs outside the imported set. */
+    readonly runtime: boolean;
+    /** @internal Free space, for runtime pages. */
+    packer: SkylinePacker | undefined;
+    constructor(font: Font, index: number, init: {
+        width: number;
+        height: number;
+        ref?: AssetRef;
+        texture?: Texture;
+        runtime?: boolean;
+    });
+}
+/** A glyph ready for layout. Plane bounds in em units; uv in texture space (v down). */
+export declare class Glyph {
+    readonly codepoint: number;
+    /** The font whose atlas holds the glyph (a fallback's, for fallback glyphs). */
+    readonly font: Font;
+    readonly advance: number;
+    readonly left: number;
+    readonly bottom: number;
+    readonly right: number;
+    readonly top: number;
+    /** Index into `font.pages`. */
+    readonly page: number;
+    /** Atlas box in pixels. */
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+    /** Texture coordinates of the quad: (u0, v0) is its top-left. */
+    readonly u0: number;
+    readonly v0: number;
+    readonly u1: number;
+    readonly v1: number;
+    /** Generated at runtime rather than imported. */
+    readonly runtime: boolean;
+    /** Whether it draws anything (spaces don't). */
+    readonly visible: boolean;
+    /** @internal Range of this glyph's kerning pairs (as the left glyph) in its font's tables. */
+    kernStart: number;
+    kernCount: number;
+    constructor(font: Font, json: GlyphJson, runtime: boolean);
+}
+export interface FontLoadOptions {
+    /** RGBA8 pixels per page, for fonts built in code (each becomes a Texture). */
+    pixels?: readonly Uint8Array[];
+    /** Texture asset refs per page, for imported fonts. */
+    pageRefs?: readonly (AssetRef | undefined)[];
+    /** The font file, for on-demand glyphs outside the imported set. */
+    source?: Uint8Array | FontSource;
+    /** Fallback font refs, linked by the `Fonts` store. */
+    fallbackRefs?: readonly AssetRef[];
+}
+/** Side of new runtime atlas pages (pixels). */
+export declare const RUNTIME_PAGE_SIZE = 512;
+/** Padding around glyphs in atlas pages (pixels). */
+export declare const GLYPH_PADDING = 1;
+/**
+ * A runtime font: glyph metrics and atlas pages. `resolve` finds a glyph for any codepoint: this
+ * font's atlas, then an on-demand glyph from its own outlines, then each fallback (atlas, then
+ * on-demand), then the missing-glyph box. Resolved codepoints are cached.
+ */
+export declare class Font {
+    name: string;
+    size: number;
+    range: number;
+    unitsPerEm: number;
+    ascent: number;
+    descent: number;
+    lineGap: number;
+    charset: string;
+    pages: FontPage[];
+    /** Glyphs this font holds (imported and generated), by codepoint. */
+    glyphs: Map<number, Glyph>;
+    notdef: Glyph;
+    /** Bumps when glyphs or pages are added (on-demand glyphs), or on hot reload. */
+    version: number;
+    /** Glyphs generated at runtime so far. */
+    runtimeGlyphs: number;
+    /** Codepoints nothing could draw (they show the missing-glyph box). */
+    readonly missing: Set<number>;
+    /** Fallback fonts from the import settings, before the `Fonts` store links them. */
+    fallbackRefs: AssetRef[];
+    /** The metrics' fallback paths (project paths). */
+    fallbackPaths: string[];
+    /** @internal The store that links this font's fallbacks (set by `FontStore`). */
+    linker: {
+        link(): void;
+    } | undefined;
+    /** @internal Kerning tables: right codepoints and em adjustments, grouped by left glyph. */
+    kernRight: Int32Array;
+    kernValue: Float32Array;
+    private _fallbacks;
+    private resolved;
+    private sourceBytes;
+    private _source;
+    private json;
+    private constructor();
+    /** Builds a font from its metrics JSON and its atlas pages (pixels or texture refs). */
+    static fromMetrics(json: FontMetricsJson, options?: FontLoadOptions): Font;
+    /** The metrics this font was loaded from. */
+    get metrics(): FontMetricsJson;
+    /** Line height in em: ascent - descent + line gap. */
+    get lineHeight(): number;
+    get fallbacks(): readonly Font[];
+    /** Sets the fallback fonts, tried in order. Clears the resolved-glyph cache. */
+    set fallbacks(fonts: readonly Font[]);
+    /** Forgets resolved fallback and missing glyphs (after fallbacks change). */
+    invalidate(): void;
+    /** Whether on-demand glyphs can be generated (the font's outlines are available). */
+    get hasOutlines(): boolean;
+    /** The parsed font file, parsed on first use; undefined without outlines. */
+    get source(): FontSource | undefined;
+    /** This font's own glyph for a codepoint (imported or already generated), no fallbacks. */
+    glyph(codepoint: number): Glyph | undefined;
+    /** A glyph for any codepoint; never undefined (the missing-glyph box at worst). */
+    resolve(codepoint: number): Glyph;
+    /** Whether a codepoint resolves to a real glyph (here, on demand, or in a fallback). */
+    has(codepoint: number): boolean;
+    /** Kerning between two glyphs, in em (0 across fonts). */
+    kerning(left: Glyph, right: Glyph): number;
+    private resolveSlow;
+    private find;
+    /**
+     * Generates a glyph from this font's outlines into a runtime atlas page, if the font has the
+     * codepoint. Bumps `version` and the page texture's version.
+     */
+    generate(codepoint: number): Glyph | undefined;
+    /** Finds room for a w×h box on a runtime page, adding a page when the last one is full. */
+    private allocate;
+    private setKerning;
+    /** Hot reload: takes over another font's data, keeping this object (and its fallbacks). */
+    copyFrom(next: Font): void;
+}