@weasel-js/font 1.0.1 → 1.0.3

package/dist/chunk-3RSTZDXH.js

@@ -0,0 +1,1008 @@
+// 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/glyphReady.ts
+var subscribers = /* @__PURE__ */ new Set();
+var generation = 0;
+function glyphGeneration() {
+  return generation;
+}
+function subscribeGlyphReady(cb) {
+  subscribers.add(cb);
+  return () => {
+    subscribers.delete(cb);
+  };
+}
+function notifyGlyphReady() {
+  generation++;
+  for (const cb of subscribers) cb();
+}
+function _clearGlyphReadySubscribers() {
+  subscribers.clear();
+}
+
+// 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 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 listCanvasFonts() {
+  const out = [];
+  for (const family of canvasFamilies) {
+    if (!isCanvasFont(family)) continue;
+    out.push({ family, enrollment: autoEnrolledFamilies.has(family) ? "auto" : "explicit" });
+  }
+  return out.sort((a, b) => a.family.localeCompare(b.family));
+}
+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();
+  notifyGlyphReady();
+}
+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;
+  _clearGlyphReadySubscribers();
+  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 });
+    notifyGlyphReady();
+  } 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/outline/OutlineFace.ts
+var OUTLINE_PRECISION = 5;
+
+// src/outline/sfnt.ts
+var SFNT_HEADER_BYTES = 12;
+var TABLE_RECORD_BYTES = 16;
+function tagAt(view, offset) {
+  return String.fromCharCode(
+    view.getUint8(offset),
+    view.getUint8(offset + 1),
+    view.getUint8(offset + 2),
+    view.getUint8(offset + 3)
+  );
+}
+function isFontCollection(bytes) {
+  if (bytes.byteLength < 4) return false;
+  return tagAt(new DataView(bytes), 0) === "ttcf";
+}
+var FONT_SIGNATURES = /* @__PURE__ */ new Set([
+  "\0
\0\0",
+  "true",
+  "typ1",
+  "OTTO",
+  "ttcf",
+  "wOFF",
+  "wOF2"
+]);
+var RESOURCE_HEADER_BYTES = 16;
+function isDataForkFont(bytes) {
+  if (bytes.byteLength < RESOURCE_HEADER_BYTES) return false;
+  const view = new DataView(bytes);
+  if (FONT_SIGNATURES.has(tagAt(view, 0))) return false;
+  const dataOffset = view.getUint32(0);
+  const mapOffset = view.getUint32(4);
+  const dataLength = view.getUint32(8);
+  const mapLength = view.getUint32(12);
+  return dataOffset >= RESOURCE_HEADER_BYTES && dataOffset + dataLength === mapOffset && mapOffset + mapLength <= bytes.byteLength;
+}
+function readTableDirectory(view, dirOffset) {
+  const numTables = view.getUint16(dirOffset + 4);
+  const records = [];
+  for (let i = 0; i < numTables; i++) {
+    const at = dirOffset + SFNT_HEADER_BYTES + i * TABLE_RECORD_BYTES;
+    records.push({
+      tag: tagAt(view, at),
+      checksum: view.getUint32(at + 4),
+      offset: view.getUint32(at + 8),
+      length: view.getUint32(at + 12)
+    });
+  }
+  return records;
+}
+function postScriptNameAt(view, records) {
+  const name = records.find((r) => r.tag === "name");
+  if (!name) return null;
+  const base = name.offset;
+  const count = view.getUint16(base + 2);
+  const stringOffset = view.getUint16(base + 4);
+  for (let i = 0; i < count; i++) {
+    const rec = base + 6 + i * 12;
+    if (view.getUint16(rec + 6) !== 6) continue;
+    const length = view.getUint16(rec + 8);
+    const offset = view.getUint16(rec + 10);
+    let out = "";
+    for (let b = 0; b < length; b++) {
+      const code = view.getUint8(base + stringOffset + offset + b);
+      if (code !== 0) out += String.fromCharCode(code);
+    }
+    if (out.length > 0) return out;
+  }
+  return null;
+}
+function extractFont(source, view, dirOffset) {
+  const records = readTableDirectory(view, dirOffset);
+  const padded = (n) => n + 3 & -4;
+  let total = SFNT_HEADER_BYTES + records.length * TABLE_RECORD_BYTES;
+  for (const r of records) total += padded(r.length);
+  const out = new ArrayBuffer(total);
+  const dst = new DataView(out);
+  const dstBytes = new Uint8Array(out);
+  const srcBytes = new Uint8Array(source);
+  dst.setUint32(0, view.getUint32(dirOffset));
+  dst.setUint16(4, records.length);
+  const entrySelector = Math.floor(Math.log2(records.length));
+  const searchRange = 2 ** entrySelector * 16;
+  dst.setUint16(6, searchRange);
+  dst.setUint16(8, entrySelector);
+  dst.setUint16(10, records.length * 16 - searchRange);
+  let cursor = SFNT_HEADER_BYTES + records.length * TABLE_RECORD_BYTES;
+  records.forEach((r, i) => {
+    const at = SFNT_HEADER_BYTES + i * TABLE_RECORD_BYTES;
+    for (let b = 0; b < 4; b++) dst.setUint8(at + b, r.tag.charCodeAt(b));
+    dst.setUint32(at + 4, r.checksum);
+    dst.setUint32(at + 8, cursor);
+    dst.setUint32(at + 12, r.length);
+    dstBytes.set(srcBytes.subarray(r.offset, r.offset + r.length), cursor);
+    cursor += padded(r.length);
+  });
+  return out;
+}
+function sfntFromCollection(bytes, postScriptName) {
+  if (isDataForkFont(bytes)) {
+    throw new Error(
+      "Datafork TrueType (.dfont) is not supported \u2014 the outline tier reads sfnt tables and a .dfont holds them inside a Macintosh resource map."
+    );
+  }
+  if (!isFontCollection(bytes)) return { bytes, matched: true };
+  const view = new DataView(bytes);
+  const numFonts = view.getUint32(8);
+  if (numFonts === 0) throw new Error("font collection contains no fonts");
+  const offsets = [];
+  for (let i = 0; i < numFonts; i++) offsets.push(view.getUint32(12 + i * 4));
+  if (postScriptName) {
+    for (const dirOffset of offsets) {
+      const records = readTableDirectory(view, dirOffset);
+      if (postScriptNameAt(view, records) === postScriptName) {
+        return { bytes: extractFont(bytes, view, dirOffset), matched: true };
+      }
+    }
+  }
+  return { bytes: extractFont(bytes, view, offsets[0]), matched: !postScriptName };
+}
+
+// src/outline/opentypeParser.ts
+var modulePromise = null;
+function loadOpenType() {
+  modulePromise ??= import('opentype.js');
+  return modulePromise;
+}
+function faceFor(font) {
+  return {
+    unitsPerEm: font.unitsPerEm,
+    glyphD(cp) {
+      const index = font.charToGlyphIndex(String.fromCodePoint(cp));
+      if (!index) return null;
+      const d = font.glyphs.get(index).getPath(0, 0, 1).toPathData(OUTLINE_PRECISION);
+      return d.length > 0 ? d : null;
+    }
+  };
+}
+function createOpenTypeParser(postScriptName) {
+  return async (bytes) => {
+    const opentype = await loadOpenType();
+    const { bytes: single } = sfntFromCollection(bytes, postScriptName);
+    return faceFor(opentype.parse(single));
+  };
+}
+var openTypeParser = createOpenTypeParser();
+
+// src/outline/outlineRegistry.ts
+var slots = /* @__PURE__ */ new Map();
+function slotKey(family, weight, style) {
+  return `${family}|${weight}|${style}`;
+}
+function normalize(v) {
+  return { weight: v.weight ?? 400, style: v.style ?? "normal" };
+}
+function registerFontOutlines(family, variant, source, opts = {}) {
+  const { weight, style } = normalize(variant);
+  slots.set(slotKey(family, weight, style), {
+    family,
+    weight,
+    style,
+    source,
+    parser: opts.parser ?? openTypeParser,
+    status: "idle",
+    face: null,
+    glyphs: /* @__PURE__ */ new Map()
+  });
+}
+function unregisterFontOutlines(family, variant = {}) {
+  const { weight, style } = normalize(variant);
+  slots.delete(slotKey(family, weight, style));
+}
+function hasFontOutlines(family, weight = 400, style = "normal") {
+  return slots.has(slotKey(family, weight, style));
+}
+function outlineStatus(family, weight = 400, style = "normal") {
+  return slots.get(slotKey(family, weight, style))?.status ?? null;
+}
+function listFontOutlines() {
+  return [...slots.values()].map(({ family, weight, style, status }) => ({ family, weight, style, status })).sort((a, b) => a.family.localeCompare(b.family) || a.weight - b.weight || a.style.localeCompare(b.style));
+}
+function closeContours(d) {
+  let out = "";
+  let start = 0;
+  for (let i = 1; i < d.length; i++) {
+    const c = d[i];
+    if (c !== "M" && c !== "m") continue;
+    out += closeOne(d.slice(start, i));
+    start = i;
+  }
+  return out + closeOne(d.slice(start));
+}
+function closeOne(contour) {
+  const trimmed = contour.trimEnd();
+  if (trimmed.length === 0) return "";
+  const last = trimmed[trimmed.length - 1];
+  return last === "Z" || last === "z" ? trimmed : `${trimmed}Z`;
+}
+function glyphOutline(family, weight, style, cp) {
+  const slot = slots.get(slotKey(family, weight, style));
+  if (!slot) return null;
+  if (slot.status === "idle") {
+    void beginLoad(slot);
+    return null;
+  }
+  if (slot.status !== "ready") return null;
+  const cached = slot.glyphs.get(cp);
+  if (cached !== void 0) return cached;
+  let d = null;
+  try {
+    const raw = slot.face.glyphD(cp);
+    d = raw === null ? null : closeContours(raw);
+  } catch (err) {
+    warnOnce(
+      `glyph|${slotKey(family, weight, style)}`,
+      `weasel: outline face "${family}" (${weight}/${style}) could not produce a glyph for U+${cp.toString(16).toUpperCase().padStart(4, "0")} \u2014 ${err instanceof Error ? err.message : String(err)}. Falling back to the SDF tier.`
+    );
+  }
+  slot.glyphs.set(cp, d);
+  return d;
+}
+async function beginLoad(slot) {
+  slot.status = "loading";
+  try {
+    slot.face = await slot.parser(await readSource(slot.source));
+    slot.status = "ready";
+    notifyGlyphReady();
+  } catch (err) {
+    slot.status = "failed";
+    warnOnce(
+      `load|${slotKey(slot.family, slot.weight, slot.style)}`,
+      `weasel registerFontOutlines("${slot.family}" ${slot.weight}/${slot.style}): ${err instanceof Error ? err.message : String(err)}. Large text in this face keeps rendering from the SDF tier.`
+    );
+  }
+}
+async function readSource(source) {
+  const resolved = typeof source === "function" ? await source() : source;
+  if (typeof resolved === "string") {
+    const res = await fetch(resolved);
+    if (!res.ok) throw new Error(`HTTP ${res.status} fetching ${resolved}`);
+    return res.arrayBuffer();
+  }
+  if (resolved instanceof ArrayBuffer) return resolved;
+  return resolved.arrayBuffer();
+}
+var warned = /* @__PURE__ */ new Set();
+function warnOnce(key, message) {
+  if (warned.has(key)) return;
+  warned.add(key);
+  console.warn(message);
+}
+function _resetFontOutlinesForTests() {
+  slots = /* @__PURE__ */ new Map();
+  warned.clear();
+}
+
+export { DEFAULT_BAKE_BUDGET, FIXTURE_FONT, __setGlyphRasterizerForTests, _getPagesForTests, _resetDynamicFontsForTests, _resetFallbackForTests, _resetFontOutlinesForTests, _resetFontRegistryForTests, createOpenTypeParser, dynamicPageTextureId, ensureFontTexture, getDefaultFontFamily, getFont, getFontFallbackPolicy, glyphGeneration, glyphOutline, hasFontOutlines, isCanvasFont, listCanvasFonts, listFontOutlines, listFonts, markAllFontsNotUploaded, outlineStatus, parseBmFont, registerCanvasFont, registerFont, registerFontOutlines, resetBakeBudget, resolveFontVariant, resolveGlyphFallback, setDefaultFontFamily, setFontFallbackPolicy, subscribeGlyphReady, syncDynamicPageTexture, textureCacheKey, unregisterCanvasFont, unregisterFontOutlines };
+//# sourceMappingURL=chunk-3RSTZDXH.js.map
+//# sourceMappingURL=chunk-3RSTZDXH.js.map