@weasel-js/font 0.7.0

package/dist/index.js

@@ -0,0 +1,825 @@
+// src/FontAtlas.ts
+var FIXTURE_FONT = {
+  info: { face: "Inter", size: 32 },
+  common: { lineHeight: 38, base: 29, scaleW: 512, scaleH: 512 },
+  chars: [
+    { id: 65, x: 0, y: 0, width: 22, height: 28, xoffset: 1, yoffset: 4, xadvance: 23, page: 0 },
+    { id: 66, x: 24, y: 0, width: 20, height: 28, xoffset: 2, yoffset: 4, xadvance: 22, page: 0 }
+  ],
+  kernings: [
+    { first: 65, second: 66, amount: -1 }
+  ]
+};
+function parseBmFont(raw) {
+  if (typeof raw !== "object" || raw === null) throw new Error("parseBmFont: expected object");
+  const r = raw;
+  if (!r.info || typeof r.info !== "object") throw new Error("parseBmFont: missing info");
+  if (!r.common || typeof r.common !== "object") throw new Error("parseBmFont: missing common");
+  if (!Array.isArray(r.chars)) throw new Error("parseBmFont: chars must be an array");
+  const info = r.info;
+  const common = r.common;
+  const chars = r.chars;
+  const kernings = Array.isArray(r.kernings) ? r.kernings : [];
+  const charMap = /* @__PURE__ */ new Map();
+  for (const ch of chars) charMap.set(ch.id, ch);
+  const kerningMap = /* @__PURE__ */ new Map();
+  for (const k of kernings) {
+    let inner = kerningMap.get(k.first);
+    if (!inner) {
+      inner = /* @__PURE__ */ new Map();
+      kerningMap.set(k.first, inner);
+    }
+    inner.set(k.second, k.amount);
+  }
+  return { info, common, chars, kernings, charMap, kerningMap };
+}
+
+// src/fallback.ts
+var policy = "substitute";
+var defaultFamily = null;
+function setFontFallbackPolicy(next) {
+  policy = next;
+}
+function getFontFallbackPolicy() {
+  return policy;
+}
+function setDefaultFontFamily(family) {
+  defaultFamily = family;
+}
+function getDefaultFontFamily() {
+  return defaultFamily;
+}
+var warnedFallbacks = /* @__PURE__ */ new Set();
+function claimFallbackWarning(key) {
+  if (warnedFallbacks.has(key)) return false;
+  warnedFallbacks.add(key);
+  return true;
+}
+function _clearFallbackWarnings() {
+  warnedFallbacks.clear();
+}
+function _resetFallbackForTests() {
+  policy = "substitute";
+  defaultFamily = null;
+  warnedFallbacks.clear();
+}
+
+// src/dynamic/shelfPack.ts
+var ShelfPacker = class {
+  constructor(pageSize, maxPages) {
+    this.pageSize = pageSize;
+    this.maxPages = maxPages;
+  }
+  pageSize;
+  maxPages;
+  pages = [];
+  warned = false;
+  get pageCount() {
+    return this.pages.length;
+  }
+  /** Allocate a w×h rect. Returns null (warning once) when capacity is out. */
+  alloc(w, h) {
+    if (w > this.pageSize || h > this.pageSize) return this.fail();
+    for (let p = 0; p < this.pages.length; p++) {
+      const spot = this.allocInPage(this.pages[p], w, h);
+      if (spot) return { page: p, ...spot };
+    }
+    if (this.pages.length < this.maxPages) {
+      const page = { shelves: [], nextY: 0 };
+      this.pages.push(page);
+      const spot = this.allocInPage(page, w, h);
+      if (spot) return { page: this.pages.length - 1, ...spot };
+    }
+    return this.fail();
+  }
+  allocInPage(page, w, h) {
+    for (const shelf of page.shelves) {
+      if (h <= shelf.height && shelf.x + w <= this.pageSize) {
+        const x = shelf.x;
+        shelf.x += w;
+        return { x, y: shelf.y };
+      }
+    }
+    if (page.nextY + h <= this.pageSize) {
+      const shelf = { y: page.nextY, height: h, x: w };
+      page.shelves.push(shelf);
+      page.nextY += h;
+      return { x: 0, y: shelf.y };
+    }
+    return null;
+  }
+  fail() {
+    if (!this.warned) {
+      this.warned = true;
+      console.warn(
+        `weasel DynamicGlyphAtlas: glyph pages full (${this.maxPages} \xD7 ${this.pageSize}\xB2); further dynamic glyphs will not render.`
+      );
+    }
+    return null;
+  }
+};
+
+// src/dynamic/distanceTransform.ts
+var INF = 1e20;
+function edt1d(f, d, v, z, n) {
+  v[0] = 0;
+  z[0] = -INF;
+  z[1] = INF;
+  let k = 0;
+  for (let q = 1; q < n; q++) {
+    let s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);
+    while (s <= z[k]) {
+      k--;
+      s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);
+    }
+    k++;
+    v[k] = q;
+    z[k] = s;
+    z[k + 1] = INF;
+  }
+  k = 0;
+  for (let q = 0; q < n; q++) {
+    while (z[k + 1] < q) k++;
+    d[q] = (q - v[k]) * (q - v[k]) + f[v[k]];
+  }
+}
+function edt2d(grid, width, height, f, d, v, z) {
+  for (let x = 0; x < width; x++) {
+    for (let y = 0; y < height; y++) f[y] = grid[y * width + x];
+    edt1d(f, d, v, z, height);
+    for (let y = 0; y < height; y++) grid[y * width + x] = d[y];
+  }
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) f[x] = grid[y * width + x];
+    edt1d(f, d, v, z, width);
+    for (let x = 0; x < width; x++) grid[y * width + x] = d[x];
+  }
+}
+function alphaToSdf(alpha, width, height, radius, cutoff) {
+  const n = width * height;
+  const gridOuter = new Float64Array(n);
+  const gridInner = new Float64Array(n);
+  const size = Math.max(width, height);
+  const f = new Float64Array(size);
+  const d = new Float64Array(size);
+  const v = new Int32Array(size);
+  const z = new Float64Array(size + 1);
+  for (let i = 0; i < n; i++) {
+    const a = alpha[i] / 255;
+    gridOuter[i] = a === 1 ? 0 : a === 0 ? INF : Math.max(0, 0.5 - a) ** 2;
+    gridInner[i] = a === 1 ? INF : a === 0 ? 0 : Math.max(0, a - 0.5) ** 2;
+  }
+  edt2d(gridOuter, width, height, f, d, v, z);
+  edt2d(gridInner, width, height, f, d, v, z);
+  const out = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    const dist = Math.sqrt(gridOuter[i]) - Math.sqrt(gridInner[i]);
+    const byte = Math.round(255 - 255 * (dist / radius + cutoff));
+    out[i] = byte < 0 ? 0 : byte > 255 ? 255 : byte;
+  }
+  return out;
+}
+
+// src/dynamic/glyphRasterizer.ts
+var BAKE_SIZE = 48;
+var PAD = 8;
+function cssFontString(weight, style, family) {
+  return `${style === "italic" ? "italic " : ""}${weight} ${BAKE_SIZE}px ${JSON.stringify(family)}`;
+}
+function createCanvasRasterizer() {
+  let canvas;
+  if (typeof OffscreenCanvas !== "undefined") {
+    canvas = new OffscreenCanvas(BAKE_SIZE * 3, BAKE_SIZE * 3);
+  } else if (typeof document !== "undefined") {
+    canvas = document.createElement("canvas");
+    canvas.width = BAKE_SIZE * 3;
+    canvas.height = BAKE_SIZE * 3;
+  } else {
+    throw new Error("weasel DynamicGlyphAtlas: no canvas available for glyph rasterization");
+  }
+  const ctx = canvas.getContext("2d", { willReadFrequently: true });
+  if (!ctx) throw new Error("weasel DynamicGlyphAtlas: 2D context unavailable");
+  function setFont(family, weight, style) {
+    ctx.font = cssFontString(weight, style, family);
+    ctx.textBaseline = "alphabetic";
+    ctx.textAlign = "left";
+  }
+  return {
+    faceMetrics(family, weight, style) {
+      setFont(family, weight, style);
+      const m = ctx.measureText("Hg");
+      return {
+        ascent: m.fontBoundingBoxAscent ?? BAKE_SIZE * 0.8,
+        descent: m.fontBoundingBoxDescent ?? BAKE_SIZE * 0.2
+      };
+    },
+    rasterize(family, weight, style, codepoint) {
+      setFont(family, weight, style);
+      const chStr = String.fromCodePoint(codepoint);
+      const m = ctx.measureText(chStr);
+      const advance = m.width;
+      const inkLeft = Math.ceil(m.actualBoundingBoxLeft ?? 0);
+      const inkRight = Math.ceil(m.actualBoundingBoxRight ?? advance);
+      const inkAscent = Math.ceil(m.actualBoundingBoxAscent ?? BAKE_SIZE * 0.8);
+      const inkDescent = Math.ceil(m.actualBoundingBoxDescent ?? BAKE_SIZE * 0.2);
+      const inkW = inkLeft + inkRight;
+      const inkH = inkAscent + inkDescent;
+      if (inkW <= 0 || inkH <= 0) {
+        return { width: 0, height: 0, alpha: new Uint8ClampedArray(0), left: 0, top: 0, advance };
+      }
+      const w = inkW + 2 * PAD;
+      const h = inkH + 2 * PAD;
+      if (canvas.width < w || canvas.height < h) {
+        canvas.width = Math.max(canvas.width, w);
+        canvas.height = Math.max(canvas.height, h);
+        setFont(family, weight, style);
+      }
+      ctx.clearRect(0, 0, w, h);
+      ctx.fillStyle = "#fff";
+      ctx.fillText(chStr, PAD + inkLeft, PAD + inkAscent);
+      const img = ctx.getImageData(0, 0, w, h);
+      const alpha = new Uint8ClampedArray(w * h);
+      for (let i = 0; i < alpha.length; i++) alpha[i] = img.data[i * 4 + 3];
+      return {
+        width: w,
+        height: h,
+        alpha,
+        left: -(inkLeft + PAD),
+        top: inkAscent + PAD,
+        advance
+      };
+    }
+  };
+}
+
+// src/dynamic/dynamicAtlas.ts
+var PAGE_SIZE = 1024;
+var MAX_PAGES = 4;
+var SDF_RADIUS = 8;
+var SDF_CUTOFF = 0.5;
+var DEFAULT_BAKE_BUDGET = 16;
+var canvasFamilies = /* @__PURE__ */ new Set();
+var autoEnrolledFamilies = /* @__PURE__ */ new Set();
+var faces = /* @__PURE__ */ new Map();
+var pages = [];
+var packer = new ShelfPacker(PAGE_SIZE, MAX_PAGES);
+var pending = [];
+var flushScheduled = false;
+var budget = DEFAULT_BAKE_BUDGET;
+var subscribers = /* @__PURE__ */ new Set();
+var rasterizer = null;
+function getRasterizer() {
+  if (!rasterizer) rasterizer = createCanvasRasterizer();
+  return rasterizer;
+}
+function registerCanvasFont(family) {
+  canvasFamilies.add(family);
+  autoEnrolledFamilies.delete(family);
+}
+function isCanvasFont(family) {
+  if (!canvasFamilies.has(family)) return false;
+  return !autoEnrolledFamilies.has(family) || getFontFallbackPolicy() === "canvas";
+}
+function autoEnrollCanvasFont(family) {
+  if (canvasFamilies.has(family) && !autoEnrolledFamilies.has(family)) return;
+  canvasFamilies.add(family);
+  autoEnrolledFamilies.add(family);
+}
+function isExplicitCanvasFont(family) {
+  return canvasFamilies.has(family) && !autoEnrolledFamilies.has(family);
+}
+function unregisterCanvasFont(family) {
+  canvasFamilies.delete(family);
+  autoEnrolledFamilies.delete(family);
+  for (const key of [...faces.keys()]) {
+    if (faces.get(key).family === family) faces.delete(key);
+  }
+}
+function getDynamicFace(family, weight, style) {
+  const key = `${family}|${weight}|${style}`;
+  const existing = faces.get(key);
+  if (existing) return existing;
+  const r = getRasterizer();
+  const metrics = r.faceMetrics(family, weight, style);
+  const base = Math.round(metrics.ascent);
+  const font = {
+    info: { face: family, size: BAKE_SIZE },
+    common: {
+      lineHeight: Math.round(metrics.ascent + metrics.descent),
+      base,
+      scaleW: PAGE_SIZE,
+      scaleH: PAGE_SIZE
+    },
+    chars: [],
+    kernings: [],
+    // no kerning in v1 (measured-pair kerning is future work)
+    charMap: /* @__PURE__ */ new Map(),
+    kerningMap: /* @__PURE__ */ new Map()
+  };
+  const face = {
+    family,
+    weight,
+    style,
+    font,
+    requestGlyph(cp) {
+      const cached = font.charMap.get(cp);
+      if (cached) return cached;
+      const raster = r.rasterize(family, weight, style, cp);
+      const char = {
+        id: cp,
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        xoffset: raster.left,
+        yoffset: base - raster.top,
+        xadvance: raster.advance,
+        page: -1
+      };
+      font.charMap.set(cp, char);
+      font.chars.push(char);
+      if (raster.width === 0 || raster.height === 0) {
+        char.page = 0;
+        return char;
+      }
+      if (budget > 0) {
+        budget--;
+        bake(char, raster);
+      } else {
+        pending.push({ char, raster });
+        scheduleFlush();
+      }
+      return char;
+    }
+  };
+  faces.set(key, face);
+  return face;
+}
+function bake(char, raster) {
+  const spot = packer.alloc(raster.width, raster.height);
+  if (!spot) return;
+  const sdf = alphaToSdf(raster.alpha, raster.width, raster.height, SDF_RADIUS, SDF_CUTOFF);
+  while (pages.length <= spot.page) {
+    pages.push({ data: new Uint8Array(PAGE_SIZE * PAGE_SIZE), version: 0, patches: [] });
+  }
+  const page = pages[spot.page];
+  for (let row = 0; row < raster.height; row++) {
+    page.data.set(
+      sdf.subarray(row * raster.width, (row + 1) * raster.width),
+      (spot.y + row) * PAGE_SIZE + spot.x
+    );
+  }
+  page.version++;
+  page.patches.push({ seq: page.version, x: spot.x, y: spot.y, w: raster.width, h: raster.height });
+  char.x = spot.x;
+  char.y = spot.y;
+  char.width = raster.width;
+  char.height = raster.height;
+  char.page = spot.page;
+}
+function scheduleFlush() {
+  if (flushScheduled) return;
+  flushScheduled = true;
+  setTimeout(flushPending, 0);
+}
+function flushPending() {
+  flushScheduled = false;
+  let n = 0;
+  while (pending.length > 0 && n < DEFAULT_BAKE_BUDGET) {
+    const job = pending.shift();
+    if (job.char.page !== -1) continue;
+    bake(job.char, job.raster);
+    n++;
+  }
+  if (pending.length > 0) scheduleFlush();
+  for (const cb of subscribers) cb();
+}
+function subscribeGlyphReady(cb) {
+  subscribers.add(cb);
+  return () => {
+    subscribers.delete(cb);
+  };
+}
+function resetBakeBudget(n = DEFAULT_BAKE_BUDGET) {
+  budget = n;
+}
+function dynamicPageTextureId(page) {
+  return `weasel-dyn-sdf-page-${page}`;
+}
+var uploadedVersions = /* @__PURE__ */ new WeakMap();
+function syncDynamicPageTexture(cache, pageIndex) {
+  const page = pages[pageIndex];
+  if (!page) return false;
+  const id = dynamicPageTextureId(pageIndex);
+  let seen = uploadedVersions.get(cache);
+  if (!seen) {
+    seen = /* @__PURE__ */ new Map();
+    uploadedVersions.set(cache, seen);
+  }
+  if (!cache.has(id)) {
+    cache.uploadR8(id, PAGE_SIZE, PAGE_SIZE, page.data);
+    seen.set(pageIndex, page.version);
+    return true;
+  }
+  const last = seen.get(pageIndex) ?? 0;
+  if (last >= page.version) return true;
+  for (const patch of page.patches) {
+    if (patch.seq <= last) continue;
+    const tight = new Uint8Array(patch.w * patch.h);
+    for (let row = 0; row < patch.h; row++) {
+      const src = (patch.y + row) * PAGE_SIZE + patch.x;
+      tight.set(page.data.subarray(src, src + patch.w), row * patch.w);
+    }
+    cache.subImageR8(id, patch.x, patch.y, patch.w, patch.h, tight);
+  }
+  seen.set(pageIndex, page.version);
+  return true;
+}
+function __setGlyphRasterizerForTests(r) {
+  rasterizer = r;
+}
+function _getPagesForTests() {
+  return pages;
+}
+function _resetDynamicFontsForTests() {
+  canvasFamilies.clear();
+  autoEnrolledFamilies.clear();
+  faces = /* @__PURE__ */ new Map();
+  pages = [];
+  packer = new ShelfPacker(PAGE_SIZE, MAX_PAGES);
+  pending = [];
+  flushScheduled = false;
+  budget = DEFAULT_BAKE_BUDGET;
+  subscribers.clear();
+  rasterizer = null;
+}
+
+// src/registerFont.ts
+var registry = /* @__PURE__ */ new Map();
+function variantKey(weight, style) {
+  return `${weight}|${style}`;
+}
+function normalizeVariant(v) {
+  return {
+    weight: v.weight ?? 400,
+    style: v.style ?? "normal"
+  };
+}
+function _resetFontRegistryForTests() {
+  registry = /* @__PURE__ */ new Map();
+  _clearFallbackWarnings();
+}
+function getFont(family, weight = 400, style = "normal") {
+  return registry.get(family)?.get(variantKey(weight, style)) ?? null;
+}
+function listFonts() {
+  const out = [];
+  for (const [family, variantMap] of registry) {
+    const variants = [...variantMap.keys()].map((key) => {
+      const [w, s] = key.split("|");
+      return { weight: Number(w), style: s };
+    }).sort((a, b) => a.weight - b.weight || a.style.localeCompare(b.style));
+    out.push({ family, variants });
+  }
+  return out;
+}
+async function registerFont(family, variant, metricsUrl, atlasUrl) {
+  const { weight, style } = normalizeVariant(variant);
+  const key = variantKey(weight, style);
+  if (registry.get(family)?.has(key)) return;
+  try {
+    const [metricsRes, atlasRes] = await Promise.all([
+      fetch(metricsUrl),
+      fetch(atlasUrl)
+    ]);
+    if (!metricsRes.ok) {
+      throw new Error(`HTTP ${metricsRes.status} fetching metrics from ${metricsUrl}`);
+    }
+    if (!atlasRes.ok) {
+      throw new Error(`HTTP ${atlasRes.status} fetching atlas from ${atlasUrl}`);
+    }
+    const [rawJson, blob] = await Promise.all([
+      metricsRes.json(),
+      atlasRes.blob()
+    ]);
+    const font = parseBmFont(rawJson);
+    const bitmap = await createImageBitmap(blob);
+    let familyMap = registry.get(family);
+    if (!familyMap) {
+      familyMap = /* @__PURE__ */ new Map();
+      registry.set(family, familyMap);
+    }
+    familyMap.set(key, { font, bitmap });
+  } catch (err) {
+    throw new Error(
+      `weasel registerFont("${family}" ${weight}/${style}): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function ensureFontTexture(family, weight, style, textureCache) {
+  const entry = getFont(family, weight, style);
+  if (!entry) return false;
+  textureCache.upload(textureCacheKey(family, weight, style), entry.bitmap);
+  return true;
+}
+function textureCacheKey(family, weight, style) {
+  return `${family}|${weight}|${style}`;
+}
+function markAllFontsNotUploaded() {
+}
+function missResolveResult(family, weight, style, suppressWarn = false) {
+  if (isExplicitCanvasFont(family)) {
+    return {
+      entry: null,
+      dynamicFace: getDynamicFace(family, weight, style),
+      resolved: { family, weight, style },
+      synthetic: { bold: false, italic: false },
+      source: "canvas"
+    };
+  }
+  const policy2 = getFontFallbackPolicy();
+  if (policy2 === "canvas") {
+    autoEnrollCanvasFont(family);
+    return {
+      entry: null,
+      dynamicFace: getDynamicFace(family, weight, style),
+      resolved: { family, weight, style },
+      synthetic: { bold: false, italic: false },
+      source: "canvas"
+    };
+  }
+  if (policy2 === "substitute") {
+    const fallback = getDefaultFontFamily() ?? firstRegisteredFamily();
+    if (fallback !== null && fallback !== family) {
+      if (registry.has(fallback) || isCanvasFont(fallback)) {
+        const result = resolveFontVariantInternal(fallback, weight, style, true);
+        if (result.entry !== null || result.dynamicFace !== void 0) {
+          if (!suppressWarn) warnMissingFamilyOnce(family, weight, style, fallback);
+          return { ...result, substituted: { requested: family, resolved: fallback } };
+        }
+      }
+      if (!suppressWarn) warnUnusableDefaultOnce(family, weight, style, fallback);
+    } else if (fallback === family && !suppressWarn) {
+      if (registry.has(family)) {
+        warnSelfUnusableDefaultOnce(family, weight, style);
+      } else {
+        warnUnregisteredDefaultOnce(family, weight, style);
+      }
+    }
+  }
+  return {
+    entry: null,
+    resolved: { family, weight, style },
+    synthetic: { bold: false, italic: false },
+    source: "atlas"
+  };
+}
+function firstRegisteredFamily() {
+  for (const family of registry.keys()) return family;
+  return null;
+}
+function warnMissingFamilyOnce(family, weight, style, resolved) {
+  if (!claimFallbackWarning(`substituted|${family}|${weight}|${style}`)) return;
+  const cause = registry.has(family) ? `has no variant matching ${weight}/${style}, and none of its registered variants are close enough for the within-family chain to substitute \u2014 rendering with "${resolved}" instead. Bake that variant with registerFont("${family}", { weight: ${weight}, style: '${style}' }, \u2026)` : `is not registered \u2014 rendering with "${resolved}" instead. Call registerFont("${family}", \u2026)`;
+  console.warn(
+    `weasel: font family "${family}" (${weight}/${style}) ${cause}. Advance widths will differ from the requested font. Use setFontFallbackPolicy('none') to make this a hard miss instead.`
+  );
+}
+function warnUnusableDefaultOnce(family, weight, style, fallback) {
+  if (!claimFallbackWarning(`unusable-default|${family}|${weight}|${style}`)) return;
+  const origin = getDefaultFontFamily() === fallback ? "set via setDefaultFontFamily" : "the first registered family, since setDefaultFontFamily was never called";
+  const gap = registry.has(fallback) || isCanvasFont(fallback) ? `has no variant that can serve ${weight}/${style}` : "is not registered either";
+  console.warn(
+    `weasel: font family "${family}" (${weight}/${style}) is not available, and the fallback family "${fallback}" (${origin}) ${gap} \u2014 this text will not render at all. Bake that variant with registerFont("${fallback}", { weight: ${weight}, style: '${style}' }, \u2026), or point setDefaultFontFamily() at a family that covers it.`
+  );
+}
+function warnSelfUnusableDefaultOnce(family, weight, style) {
+  if (!claimFallbackWarning(`self-unusable-default|${family}|${weight}|${style}`)) return;
+  const origin = getDefaultFontFamily() === family ? "set via setDefaultFontFamily" : "the first registered family, since setDefaultFontFamily was never called";
+  console.warn(
+    `weasel: font family "${family}" (${weight}/${style}) has no variant that can serve this request, and "${family}" is also the fallback family (${origin}) \u2014 there is nothing left to fall back to, so this text will not render at all. Bake that variant with registerFont("${family}", { weight: ${weight}, style: '${style}' }, \u2026), or point setDefaultFontFamily() at a different family.`
+  );
+}
+function warnUnregisteredDefaultOnce(family, weight, style) {
+  if (!claimFallbackWarning(`unregistered-default|${family}|${weight}|${style}`)) return;
+  console.warn(
+    `weasel: font family "${family}" (${weight}/${style}) was never registered, and it is also the fallback family \u2014 setDefaultFontFamily("${family}") names a family with no registered variants at all, so there is nothing left to fall back to and this text will not render at all. Call registerFont("${family}", { weight: ${weight}, style: '${style}' }, \u2026), or point setDefaultFontFamily() at a family you have registered.`
+  );
+}
+function weightBucket(w) {
+  return w >= 600 ? "bold" : "regular";
+}
+function resolveFontVariant(family, weight, style) {
+  return resolveFontVariantInternal(family, weight, style, false);
+}
+function resolveGlyphFallback(family, weight, style) {
+  if (getFontFallbackPolicy() === "none") return null;
+  try {
+    return {
+      entry: null,
+      dynamicFace: getDynamicFace(family, weight, style),
+      resolved: { family, weight, style },
+      // The dynamic tier rasterizes the real weight and style, so there is
+      // nothing for the shader to fake.
+      synthetic: { bold: false, italic: false },
+      source: "canvas"
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveFontVariantInternal(family, weight, style, suppressWarn) {
+  const familyMap = registry.get(family);
+  if (!familyMap || familyMap.size === 0) {
+    return missResolveResult(family, weight, style, suppressWarn);
+  }
+  const exact = familyMap.get(variantKey(weight, style));
+  if (exact) {
+    return {
+      entry: exact,
+      resolved: { family, weight, style },
+      synthetic: { bold: false, italic: false },
+      source: "atlas"
+    };
+  }
+  const requestedBucket = weightBucket(weight);
+  let bestSameStyle = null;
+  for (const [key, entry] of familyMap) {
+    const [wStr, s] = key.split("|");
+    const w = Number(wStr);
+    if (s !== style) continue;
+    if (weightBucket(w) !== requestedBucket) continue;
+    const distance = Math.abs(w - weight);
+    if (bestSameStyle === null || distance < bestSameStyle.distance || distance === bestSameStyle.distance && w > bestSameStyle.weight) {
+      bestSameStyle = { entry, weight: w, distance };
+    }
+  }
+  if (bestSameStyle) {
+    return {
+      entry: bestSameStyle.entry,
+      resolved: { family, weight: bestSameStyle.weight, style },
+      synthetic: { bold: false, italic: false },
+      source: "atlas"
+    };
+  }
+  const sameStyleRegular = familyMap.get(variantKey(400, style));
+  if (sameStyleRegular) {
+    return {
+      entry: sameStyleRegular,
+      resolved: { family, weight: 400, style },
+      synthetic: {
+        bold: weight >= 600,
+        italic: false
+      },
+      source: "atlas"
+    };
+  }
+  const sameWeightNormal = familyMap.get(variantKey(weight, "normal"));
+  if (sameWeightNormal) {
+    return {
+      entry: sameWeightNormal,
+      resolved: { family, weight, style: "normal" },
+      synthetic: {
+        bold: false,
+        italic: style === "italic"
+      },
+      source: "atlas"
+    };
+  }
+  let bestNormal = null;
+  for (const [key, entry] of familyMap) {
+    const [wStr, s] = key.split("|");
+    const w = Number(wStr);
+    if (s !== "normal") continue;
+    if (weightBucket(w) !== requestedBucket) continue;
+    const distance = Math.abs(w - weight);
+    if (bestNormal === null || distance < bestNormal.distance || distance === bestNormal.distance && w > bestNormal.weight) {
+      bestNormal = { entry, weight: w, distance };
+    }
+  }
+  if (bestNormal) {
+    return {
+      entry: bestNormal.entry,
+      resolved: { family, weight: bestNormal.weight, style: "normal" },
+      synthetic: {
+        bold: false,
+        italic: style === "italic"
+      },
+      source: "atlas"
+    };
+  }
+  const regular = familyMap.get(variantKey(400, "normal"));
+  if (regular) {
+    return {
+      entry: regular,
+      resolved: { family, weight: 400, style: "normal" },
+      synthetic: {
+        bold: weight >= 600,
+        italic: style === "italic"
+      },
+      source: "atlas"
+    };
+  }
+  return missResolveResult(family, weight, style, suppressWarn);
+}
+
+// src/textSdf.ts
+var TEXT_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+in vec2 a_uv;
+in float a_baselineY;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+uniform float u_synthItalic;
+out vec2 v_uv;
+void main() {
+  // Synthetic italic: shift x by (a_baselineY - a_position.y) * tan(angle).
+  // Above-baseline vertices (lower y in screen coords) lean further right.
+  vec2 skewed = vec2(
+    a_position.x + (a_baselineY - a_position.y) * tan(u_synthItalic),
+    a_position.y
+  );
+  vec3 screen = u_model * vec3(skewed, 1.0);
+  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  v_uv = a_uv;
+}
+`
+);
+var TEXT_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_atlas;
+uniform vec4 u_color;
+uniform float u_alpha;
+uniform float u_synthBold;
+uniform mat4 u_colorMatrix;
+uniform vec4 u_colorBias;
+out vec4 outColor;
+
+float median(float r, float g, float b) {
+  return max(min(r, g), min(max(r, g), b));
+}
+
+void main() {
+  vec3 sdf = texture(u_atlas, v_uv).rgb;
+  float sdfVal = median(sdf.r, sdf.g, sdf.b);
+  // Screen-space AA band \u2014 see the file header. Half of fwidth spans ~1px.
+  float aaW = max(0.5 * fwidth(sdfVal), 0.0005);
+  // u_synthBold shifts the SDF threshold to thicken strokes when the
+  // resolver fell back from a missing bold variant to the regular atlas.
+  float threshold = 0.5 - u_synthBold;
+  float msdfAlpha = smoothstep(threshold - aaW, threshold + aaW, sdfVal);
+  vec4 src = vec4(u_color.rgb, u_color.a);
+  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * msdfAlpha * u_alpha;
+  outColor = vec4(mapped.rgb * a, a);
+}
+`
+);
+var TEXT_FRAG_R8_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_atlas;
+uniform vec4 u_color;
+uniform float u_alpha;
+uniform float u_synthBold;
+uniform mat4 u_colorMatrix;
+uniform vec4 u_colorBias;
+out vec4 outColor;
+
+void main() {
+  float sdfVal = texture(u_atlas, v_uv).r;
+  // Screen-space AA band \u2014 see the file header. Half of fwidth spans ~1px.
+  float aaW = max(0.5 * fwidth(sdfVal), 0.0005);
+  float threshold = 0.5 - u_synthBold;
+  float sdfAlpha = smoothstep(threshold - aaW, threshold + aaW, sdfVal);
+  vec4 src = vec4(u_color.rgb, u_color.a);
+  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * sdfAlpha * u_alpha;
+  outColor = vec4(mapped.rgb * a, a);
+}
+`
+);
+var TEXT_SDF_UNIFORMS = [
+  "u_proj",
+  "u_model",
+  "u_atlas",
+  "u_color",
+  "u_alpha",
+  "u_synthBold",
+  "u_synthItalic",
+  "u_colorMatrix",
+  "u_colorBias"
+];
+var TEXT_SDF_ATTRIBUTES = ["a_position", "a_uv", "a_baselineY"];
+
+export { DEFAULT_BAKE_BUDGET, FIXTURE_FONT, TEXT_FRAG_R8_SRC, TEXT_FRAG_SRC, TEXT_SDF_ATTRIBUTES, TEXT_SDF_UNIFORMS, TEXT_VERT_SRC, __setGlyphRasterizerForTests, _getPagesForTests, _resetDynamicFontsForTests, _resetFallbackForTests, _resetFontRegistryForTests, dynamicPageTextureId, ensureFontTexture, getDefaultFontFamily, getFont, getFontFallbackPolicy, isCanvasFont, listFonts, markAllFontsNotUploaded, parseBmFont, registerCanvasFont, registerFont, resetBakeBudget, resolveFontVariant, resolveGlyphFallback, setDefaultFontFamily, setFontFallbackPolicy, subscribeGlyphReady, syncDynamicPageTexture, textureCacheKey, unregisterCanvasFont };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map