@knowvah/dot-engine 0.1.0

package/src/common/taper.ts

@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: EPL-2.0
+//
+// Tapered edges — faithful port of lib/common/taper.c (based on lines.ps by
+// Denis Moskowitz). Given an edge's first Bézier and a half-width radius
+// function, returns a closed polygon that renders the spline as a tapered
+// stroke (full width at one end, zero at the other). Used by the SVG edge
+// emit for `style="tapered"`.
+//
+// @see lib/common/taper.c:taper
+
+import type { Point, Bezier } from '../model/geom.js';
+
+/** Sample points per Bézier segment. @see taper.c:BEZIERSUBDIVISION */
+const BEZIER_SUBDIVISION = 20;
+/** @see taper.c:currentmiterlimit */
+const MITER_LIMIT = 10.0;
+/** Degrees→radians, matching C's D2R macro. @see taper.c:D2R */
+const D2R = (d: number): number => (Math.PI * d) / 180.0;
+
+/** Half-width function along the curve. @see taper.c:radfunc_t */
+export type RadFunc = (curlen: number, totallen: number, initwid: number) => number;
+
+/** Taper from initwid/2 at the start to 0 at the end. @see taper.c:forfunc */
+export const forfunc: RadFunc = (cur, total, init) => ((1 - cur / total) * init) / 2.0;
+/** Taper from 0 to initwid/2. @see taper.c:revfunc */
+export const revfunc: RadFunc = (cur, total, init) => ((cur / total) * init) / 2.0;
+/** Constant half-width. @see taper.c:nonefunc */
+export const nonefunc: RadFunc = (_cur, _total, init) => init / 2.0;
+/** Widen to the midpoint then taper. @see taper.c:bothfunc */
+export const bothfunc: RadFunc = (cur, total, init) => {
+  const fr = cur / total;
+  return fr <= 0.5 ? fr * init : (1 - fr) * init;
+};
+
+/**
+ * Select the taper radius function from the edge's `dir`. Undirected graphs
+ * default to `none`, directed to `forward`. @see taper.c:taperfun
+ */
+export function taperfun(dir: string | undefined, directed: boolean): RadFunc {
+  if (dir === 'forward') return forfunc;
+  if (dir === 'back') return revfunc;
+  if (dir === 'both') return bothfunc;
+  if (dir === 'none') return nonefunc;
+  return directed ? forfunc : nonefunc;
+}
+
+/** atan2 mapped to [0, 2π), with (0,0)→0. @see taper.c:myatan */
+function myatan(y: number, x: number): number {
+  if (x === 0 && y === 0) return 0;
+  const v = Math.atan2(y, x);
+  return v >= 0 ? v : v + 2 * Math.PI;
+}
+
+/** Float modulus that maps negatives positive. @see taper.c:mymod */
+function mymod(original: number, modulus: number): number {
+  if (original < 0 || original >= modulus) {
+    const v = -Math.floor(original / modulus);
+    return v * modulus + original;
+  }
+  return original;
+}
+
+/** Euclidean distance. @see taper.c:l2dist */
+function l2dist(p0: Point, p1: Point): number {
+  return Math.hypot(p0.x - p1.x, p0.y - p1.y);
+}
+
+/** Evaluate a cubic Bézier at t via de Casteljau. @see lib/common/utils.c:Bezier */
+function bezierPoint(v: readonly Point[], t: number): Point {
+  const vx = [v[0]!.x, v[1]!.x, v[2]!.x, v[3]!.x];
+  const vy = [v[0]!.y, v[1]!.y, v[2]!.y, v[3]!.y];
+  for (let i = 1; i <= 3; i++) {
+    for (let j = 0; j <= 3 - i; j++) {
+      vx[j] = (1.0 - t) * vx[j]! + t * vx[j + 1]!;
+      vy[j] = (1.0 - t) * vy[j]! + t * vy[j + 1]!;
+    }
+  }
+  return { x: vx[0]!, y: vy[0]! };
+}
+
+interface PathPoint {
+  x: number;
+  y: number;
+  lengthsofar: number;
+  dir: number;
+  lout: number;
+  bevel: boolean;
+  dir2: number;
+}
+
+/**
+ * Turn the Bézier into a polyline, recording cumulative arc length per point.
+ * @see taper.c:pathtolines
+ */
+function pathtolines(bez: Bezier): PathPoint[] {
+  const arr: PathPoint[] = [];
+  const A = bez.list;
+  const n = bez.size;
+  const push = (p: Point, l: number): void => {
+    arr.push({ x: p.x, y: p.y, lengthsofar: l, dir: 0, lout: 0, bevel: false, dir2: 0 });
+  };
+  push(A[0]!, 0);
+  const V: Point[] = [A[0]!, A[0]!, A[0]!, A[0]!];
+  let linelen = 0;
+  for (let i = 0; i + 3 < n; i += 3) {
+    V[0] = V[3]!;
+    for (let j = 1; j <= 3; j++) V[j] = A[i + j]!;
+    let p0 = V[0]!;
+    for (let step = 1; step <= BEZIER_SUBDIVISION; step++) {
+      const p1 = bezierPoint(V, step / BEZIER_SUBDIVISION);
+      linelen += l2dist(p0, p1);
+      push(p1, linelen);
+      p0 = p1;
+    }
+  }
+  return arr;
+}
+
+/**
+ * Miter/bevel geometry for one interior point (i not an endpoint). Writes
+ * dir/lout/bevel/dir2 onto pp[i]. @see taper.c:taper (interior branch)
+ */
+function annotateInterior(
+  pp: PathPoint[], i: number, ndir: number, ldir: number, linerad: number,
+): void {
+  let theta = ndir - ldir;
+  if (theta < 0) theta += D2R(360);
+  const phi = D2R(90) - theta / 2;
+  let lineout = Math.cos(phi) === 0 ? 0 : linerad / Math.cos(phi);
+  let direction = ndir + D2R(90) + phi;
+  let direction2 = direction;
+  let bevel = false;
+  if (lineout > MITER_LIMIT * linerad) {
+    bevel = i !== pp.length - 1;
+    lineout = linerad;
+    direction = mymod(ldir - D2R(90), D2R(360));
+    direction2 = mymod(ndir + D2R(90), D2R(360));
+  }
+  pp[i]!.dir = direction;
+  pp[i]!.lout = lineout;
+  pp[i]!.bevel = bevel;
+  pp[i]!.dir2 = direction2;
+}
+
+/**
+ * First pass: determine each point's miter/bevel offset direction and length.
+ * @see taper.c:taper (first for-loop)
+ */
+function annotate(pp: PathPoint[], linelen: number, radfunc: RadFunc, initwid: number): void {
+  const count = pp.length;
+  for (let i = 0; i < count; i++) {
+    const l = i === 0 ? count - 1 : i - 1;
+    const next = (i + 1) % count;
+    const { x, y, lengthsofar } = pp[i]!;
+    const ndir = myatan(pp[next]!.y - y, pp[next]!.x - x);
+    const ldir = myatan(pp[l]!.y - y, pp[l]!.x - x);
+    const linerad = radfunc(lengthsofar, linelen, initwid);
+    if (i === 0 || i === count - 1) {
+      const direction = i === 0 ? ndir + D2R(90) : ldir - D2R(90);
+      pp[i]!.dir = direction;
+      pp[i]!.lout = linerad;
+      pp[i]!.dir2 = direction;
+    } else {
+      annotateInterior(pp, i, ndir, ldir, linerad);
+    }
+  }
+}
+
+/**
+ * Append a bevel vertex at angle `a2`. C's drawbevel picks a2 = dir2 when
+ * forward (side 1), else dir (side 2); the caller passes the resolved angle.
+ * The `x`-for-y in the second coordinate faithfully reproduces C's drawbevel,
+ * which is handed only x, not y. @see taper.c:drawbevel
+ */
+function drawbevel(out: Point[], x: number, lineout: number, a2: number): void {
+  out.push({ x: x + lineout * Math.cos(a2), y: x + lineout * Math.sin(a2) });
+}
+
+/**
+ * Second pass: emit side 1, the end cap, and side 2 as one closed polygon.
+ * @see taper.c:taper (second/third for-loops)
+ */
+function emitStroke(pp: PathPoint[]): Point[] {
+  const out: Point[] = [];
+  const count = pp.length;
+  let x = 0, y = 0, direction = 0, lineout = 0;
+  for (let i = 0; i < count; i++) {
+    ({ x, y, dir: direction, lout: lineout } = pp[i]!);
+    out.push({ x: x + Math.cos(direction) * lineout, y: y + Math.sin(direction) * lineout });
+    if (pp[i]!.bevel) drawbevel(out, x, lineout, pp[i]!.dir2); // forward: a2 = dir2
+  }
+  // end circle
+  direction += D2R(180);
+  out.push({ x: x + Math.cos(direction) * lineout, y: y + Math.sin(direction) * lineout });
+  // side 2
+  for (let i = count - 2; i >= 0; i--) {
+    const cur = pp[i]!;
+    x = cur.x;
+    y = cur.y;
+    direction = cur.dir + D2R(180);
+    const direction2 = cur.dir2 + D2R(180);
+    lineout = cur.lout;
+    out.push({ x: x + Math.cos(direction2) * lineout, y: y + Math.sin(direction2) * lineout });
+    if (cur.bevel) drawbevel(out, x, lineout, direction); // side 2 (not forward): a2 = dir
+  }
+  return out;
+}
+
+/**
+ * Given a Bézier `bez`, return a polygon representing the spline as a tapered
+ * edge of starting width `initwid`; `radfunc` sets the half-width along the
+ * curve. @see taper.c:taper
+ */
+export function taper(bez: Bezier, radfunc: RadFunc, initwid: number): Point[] {
+  const pp = pathtolines(bez);
+  const linelen = pp[pp.length - 1]!.lengthsofar;
+  annotate(pp, linelen, radfunc, initwid);
+  return emitStroke(pp);
+}

package/src/common/textmeasure-factory.ts

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Text-measurer selection.
+ *
+ * Resolution order (when no explicit override is set):
+ *   1. explicit override via setTextMeasurer (tests, host-faithful Node opt-in)
+ *   2. GV_TEXT_MEASURER=estimate|lut — test/CI hook to force a specific measurer
+ *   3. browser (document present) — CanvasTextMeasurer over the page canvas
+ *      (host-faithful: the same font the browser renders the SVG with)
+ *   4. Node default               — EstimateTextMeasurer (deterministic; matches
+ *      graphviz's own headless estimate_textspan_size)
+ *
+ * Host-faithful Node measurement (node-canvas) is intentionally NOT auto-loaded:
+ * the library has ZERO runtime deps and ships a single browser+Node bundle, so
+ * `canvas` must never be imported from src. Node consumers opt in explicitly:
+ *   `setTextMeasurer(new CanvasTextMeasurer(createCanvas(0,0).getContext('2d')))`
+ *
+ * @see lib/common/textspan.c:estimate_textspan_size
+ * @see plans/fix-xcoord-position/DESIGN.md
+ */
+
+import {
+  LutTextMeasurer, CanvasTextMeasurer, EstimateTextMeasurer, type TextMeasurer,
+} from './textmeasure.js';
+
+let override: TextMeasurer | undefined;
+
+/**
+ * Install a process-wide text measurer, overriding auto-resolution. Pass
+ * `undefined` to clear and restore auto-resolution. Takes effect on the next
+ * render (renderSvg resolves the measurer per call). Use for deterministic
+ * tests or to wire a host-faithful Node measurer (e.g. node-canvas) — see the
+ * resolution note above.
+ */
+export function setTextMeasurer(m: TextMeasurer | undefined): void {
+  override = m;
+}
+
+/** The current explicit override, or undefined when auto-resolving. */
+export function getTextMeasurer(): TextMeasurer | undefined {
+  return override;
+}
+
+/** Browser-safe read of an env var (Node only; undefined in the browser). */
+function envMeasurer(): string | undefined {
+  return typeof process !== 'undefined' ? process.env?.GV_TEXT_MEASURER : undefined;
+}
+
+/** One-time latch for the Node host-faithful advice note (process-global). */
+let adviceShown = false;
+
+/**
+ * Emit a one-time note that Node is using built-in (approximate) metrics and how
+ * to get host-faithful measurement. Interactive-only (TTY) so it never spams CI,
+ * tests, or piped output; silence with GV_FONT_QUIET. @see ADR-5
+ */
+function adviseHostFaithful(): void {
+  if (adviceShown || typeof process === 'undefined') return;
+  if (process.env?.GV_FONT_QUIET || !process.stderr?.isTTY) return;
+  adviceShown = true;
+  process.stderr.write(
+    'graphviz-ts: measuring text with built-in metrics (kerning/shaping not applied). '
+    + 'For host-faithful sizing matching the rendering font, install `canvas` and call '
+    + "setTextMeasurer(new CanvasTextMeasurer(createCanvas(0,0).getContext('2d'))). "
+    + 'Silence with GV_FONT_QUIET=1.\n',
+  );
+}
+
+/** Resolve the text measurer for this render (see resolution order above). */
+export function createMeasurer(): TextMeasurer {
+  if (override) return override;
+  const forced = envMeasurer(); // test/CI hook: force a specific measurer
+  if (forced === 'estimate') return new EstimateTextMeasurer();
+  if (forced === 'lut') return new LutTextMeasurer();
+  if (typeof document !== 'undefined') {
+    try {
+      const ctx2d = document.createElement('canvas').getContext('2d');
+      if (ctx2d) return new CanvasTextMeasurer(ctx2d);
+    } catch { /* canvas unavailable */ }
+  }
+  adviseHostFaithful(); // Node, no host canvas → built-in deterministic metrics
+  // Node default = EstimateTextMeasurer: the deterministic reference that matches
+  // graphviz's own headless (estimate_textspan_size) output. The hinted
+  // LutTextMeasurer is retained as an opt-in (ADR-4). @see DESIGN.md
+  return new EstimateTextMeasurer();
+}

package/src/common/textmeasure-lookup.ts

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Font-family lookup helpers for the text measurement LUT.
+ * @see lib/common/textspan_lut.c:get_metrics_for_font_family
+ */
+
+import {
+  ALL_FONT_METRICS,
+  type FontFamilyData,
+} from "./textmeasure-lut-data.js";
+
+/** Times is always present; used as the fallback family. */
+export const TIMES_FALLBACK: FontFamilyData = ALL_FONT_METRICS[0]!;
+
+/**
+ * Normalize a font name for permissive matching.
+ * Lowercases and strips all non-ASCII-letter characters.
+ * "Times New Roman" → "timesnewroman", "Times-Roman" → "timesroman".
+ * @see lib/common/textspan_lut.c:font_name_equal_permissive
+ */
+export function normalizeFontName(name: string): string {
+  let result = "";
+  for (let i = 0; i < name.length; i++) {
+    const ch = name[i]!;
+    const code = ch.charCodeAt(0);
+    const isLetter =
+      (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+    if (isLetter) result += ch.toLowerCase();
+  }
+  return result;
+}
+
+/** Set of font names that have already triggered the fallback warning. */
+const warnedFontNames = new Set<string>();
+
+/** @see lib/common/textspan_lut.c:get_metrics_for_font_family */
+export function getFamilyMetrics(fontName: string): FontFamilyData {
+  const key = normalizeFontName(fontName);
+  for (const family of ALL_FONT_METRICS) {
+    if (family.names.includes(key)) return family;
+  }
+  if (!warnedFontNames.has(fontName)) {
+    warnedFontNames.add(fontName);
+    console.warn(
+      `Warning: no hard-coded metrics for '${fontName}'.  ` +
+        `Falling back to 'Times' metrics`,
+    );
+  }
+  return TIMES_FALLBACK;
+}

package/src/common/textmeasure-lut-data-a.ts

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Raw width tables for Times, Arial/Helvetica, Courier, and Nunito.
+ * Ported from lib/common/textspan_lut.c (all_font_metrics[0..3]).
+ *
+ * Widths are in (unitsPerEm × 1) pt.  A value of -1 means unknown.
+ * @see lib/common/textspan_lut.c:all_font_metrics
+ */
+
+import type { FontFamilyData } from "./textmeasure-lut-data.js";
+
+// ── Times New Roman ──────────────────────────────────────────────────────────
+// Times_New_Roman.ttf (+ variants) from ttf-mscorefonts-installer.
+
+const TR: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,512,682,836,1024,1024,1706,1593,369,
+  682,682,1024,1155,512,682,512,569,1024,1024,1024,1024,1024,1024,1024,
+  1024,1024,1024,569,569,1155,1155,1155,909,1886,1479,1366,1366,1479,
+  1251,1139,1479,1479,682,797,1479,1251,1821,1479,1479,1139,1479,1366,
+  1139,1251,1479,1479,1933,1479,1479,1251,682,569,682,961,1024,682,909,
+  1024,909,1024,909,682,1024,1024,569,569,1024,569,1593,1024,1024,1024,
+  1024,682,797,569,1024,1024,1479,1024,1024,909,983,410,983,1108,-1,
+];
+
+const TB: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,512,682,1137,1024,1024,2048,1706,569,
+  682,682,1024,1167,512,682,512,569,1024,1024,1024,1024,1024,1024,1024,
+  1024,1024,1024,682,682,1167,1167,1167,1024,1905,1479,1366,1479,1479,
+  1366,1251,1593,1593,797,1024,1593,1366,1933,1479,1593,1251,1593,1479,
+  1139,1366,1479,1479,2048,1479,1479,1366,682,569,682,1190,1024,682,
+  1024,1139,909,1139,909,682,1024,1139,569,682,1139,569,1706,1139,1024,
+  1139,1139,909,797,682,1139,1024,1479,1024,1024,909,807,451,807,1065,-1,
+];
+
+const TI: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,512,682,860,1024,1024,1706,1593,438,
+  682,682,1024,1382,512,682,512,569,1024,1024,1024,1024,1024,1024,1024,
+  1024,1024,1024,682,682,1382,1382,1382,1024,1884,1251,1251,1366,1479,
+  1251,1251,1479,1479,682,909,1366,1139,1706,1366,1479,1251,1479,1251,
+  1024,1139,1479,1251,1706,1251,1139,1139,797,569,797,864,1024,682,1024,
+  1024,909,1024,909,569,1024,1024,569,569,909,569,1479,1024,1024,1024,
+  1024,797,797,569,1024,909,1366,909,909,797,819,563,819,1108,-1,
+];
+
+const TBI: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,512,797,1137,1024,1024,1706,1593,569,
+  682,682,1024,1167,512,682,512,569,1024,1024,1024,1024,1024,1024,1024,
+  1024,1024,1024,682,682,1167,1167,1167,1024,1704,1366,1366,1366,1479,
+  1366,1366,1479,1593,797,1024,1366,1251,1821,1479,1479,1251,1479,1366,
+  1139,1251,1479,1366,1821,1366,1251,1251,682,569,682,1167,1024,682,1024,
+  1024,909,1024,909,682,1024,1139,569,569,1024,569,1593,1139,1024,1024,
+  1024,797,797,569,1139,909,1366,1024,909,797,713,451,713,1167,-1,
+];
+
+export const TIMES_FAMILY: FontFamilyData = {
+  names: [
+    "times","timesroman","timesnewroman","freeserif",
+    "liberationserif","nimbusroman","texgyretermes","tinos","thorndale",
+  ],
+  unitsPerEm: 2048,
+  regular: TR, bold: TB, italic: TI, boldItalic: TBI,
+};
+
+// ── Arial / Helvetica ────────────────────────────────────────────────────────
+// Arial.ttf (+ variants) from ttf-mscorefonts-installer.
+// Italic arrays are identical to regular; bold-italic identical to bold.
+
+const AR: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,569,569,727,1139,1139,1821,1366,391,
+  682,682,797,1196,569,682,569,569,1139,1139,1139,1139,1139,1139,1139,
+  1139,1139,1139,569,569,1196,1196,1196,1139,2079,1366,1366,1479,1479,
+  1366,1251,1593,1479,569,1024,1366,1139,1706,1479,1593,1366,1593,1479,
+  1366,1251,1479,1366,1933,1366,1366,1251,569,569,569,961,1139,682,1139,
+  1139,1024,1139,1139,569,1139,1139,455,455,1024,455,1706,1139,1139,1139,
+  1139,682,1024,569,1139,1024,1479,1024,1024,1024,684,532,684,1196,-1,
+];
+
+const ABold: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,569,682,971,1139,1139,1821,1479,487,
+  682,682,797,1196,569,682,569,569,1139,1139,1139,1139,1139,1139,1139,
+  1139,1139,1139,682,682,1196,1196,1196,1251,1997,1479,1479,1479,1479,
+  1366,1251,1593,1479,569,1139,1479,1251,1706,1479,1593,1366,1593,1479,
+  1366,1251,1479,1366,1933,1366,1366,1251,682,569,682,1196,1139,682,1139,
+  1251,1139,1251,1139,682,1251,1251,569,569,1139,569,1821,1251,1251,1251,
+  1251,797,1139,682,1251,1139,1593,1139,1139,1024,797,573,797,1196,-1,
+];
+
+export const ARIAL_FAMILY: FontFamilyData = {
+  names: [
+    "helvetica","arial","arialmt","freesans",
+    "liberationsans","arimo","albany","nimbussans",
+    "nimbussansa","texgyreheros",
+  ],
+  unitsPerEm: 2048,
+  regular: AR, bold: ABold, italic: AR, boldItalic: ABold,
+};
+
+// ── Courier New ──────────────────────────────────────────────────────────────
+// Courier_New.ttf (+ variants) from ttf-mscorefonts-installer.
+// All four variants are identical monospace arrays.
+
+const CW: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1229,1229,1229,1229,1229,1229,1229,1229,
+  1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,
+  1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,
+  1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,
+  1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,
+  1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,
+  1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,1229,
+  1229,1229,1229,-1,
+];
+
+export const COURIER_FAMILY: FontFamilyData = {
+  names: [
+    "cour","courier","couriernew","nimbusmono",
+    "texgyrecursor","freemono","liberationmono","cousine","cumberland",
+  ],
+  unitsPerEm: 2048,
+  regular: CW, bold: CW, italic: CW, boldItalic: CW,
+};
+
+// ── Nunito ───────────────────────────────────────────────────────────────────
+// https://fonts.google.com/specimen/Nunito
+// Italic differs from regular at only three glyphs: 'M' (77)=856, 'N' (78)=739,
+// 'V' (86)=688 (vs regular 855/740/689); every other index is identical.
+
+const NR: readonly number[] = [
+  0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,258,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,258,228,392,600,600,930,693,221,317,
+  317,450,600,228,424,228,283,600,600,600,600,600,600,600,600,600,600,
+  228,228,600,600,600,443,946,729,676,673,742,583,548,726,761,257,324,
+  625,543,855,740,767,633,767,669,615,602,728,689,1101,650,596,589,315,
+  283,315,600,500,500,530,583,463,583,532,333,586,568,232,236,500,296,
+  856,568,556,583,583,358,481,350,561,515,841,525,514,463,352,265,352,
+  600,-1,
+];
+
+const NI: readonly number[] = [
+  0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,258,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,258,228,392,600,600,930,693,221,317,
+  317,450,600,228,424,228,283,600,600,600,600,600,600,600,600,600,600,
+  228,228,600,600,600,443,946,729,676,673,742,583,548,726,761,257,324,
+  625,543,856,739,767,633,767,669,615,602,728,688,1101,650,596,589,315,
+  283,315,600,500,500,530,583,463,583,532,333,586,568,232,236,500,296,
+  856,568,556,583,583,358,481,350,561,515,841,525,514,463,352,265,352,
+  600,-1,
+];
+
+const NB: readonly number[] = [
+  0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,271,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,271,248,448,600,600,945,726,243,358,
+  358,453,600,248,434,248,313,600,600,600,600,600,600,600,600,600,600,
+  248,248,600,600,600,459,950,744,688,680,762,597,562,736,773,282,354,
+  665,562,868,748,785,652,785,686,631,621,738,713,1113,672,618,605,354,
+  313,354,600,500,500,547,600,472,600,542,364,604,585,255,259,536,319,
+  877,585,576,600,600,392,488,384,579,527,853,546,526,474,391,288,391,
+  600,-1,
+];
+
+const NBI: readonly number[] = [
+  0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,271,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,271,248,448,600,600,945,726,243,358,
+  358,453,600,248,434,248,313,600,600,600,600,600,600,600,600,600,600,
+  248,248,600,600,600,459,950,744,688,680,762,597,562,736,773,282,354,
+  664,562,869,747,785,652,785,686,631,621,738,713,1113,672,618,605,354,
+  313,354,600,500,500,547,600,472,600,542,364,604,585,255,259,536,319,
+  877,585,576,600,600,392,488,384,579,527,853,546,526,474,391,288,391,
+  600,-1,
+];
+
+export const NUNITO_FAMILY: FontFamilyData = {
+  names: ["nunito"],
+  unitsPerEm: 1000,
+  regular: NR, bold: NB, italic: NI, boldItalic: NBI,
+};

package/src/common/textmeasure-lut-data-b.ts

@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Raw width tables for DejaVu Sans, Consolas, and Trebuchet MS.
+ * Ported from lib/common/textspan_lut.c (all_font_metrics[4..6]).
+ *
+ * Widths are in (unitsPerEm × 1) pt.  A value of -1 means unknown.
+ * @see lib/common/textspan_lut.c:all_font_metrics
+ */
+
+import type { FontFamilyData } from "./textmeasure-lut-data.js";
+
+// ── DejaVu Sans ───────────────────────────────────────────────────────────────
+// Based on DejaVuSans, DejaVuSans-Bold, DejaVuSans-Oblique,
+// DejaVuSans-BoldOblique (oblique, not italic).
+// Oblique arrays are identical to upright arrays.
+
+const DR: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,651,821,942,1716,1303,1946,1597,563,799,
+  799,1024,1716,651,739,651,690,1303,1303,1303,1303,1303,1303,1303,1303,
+  1303,1303,690,690,1716,1716,1716,1087,2048,1401,1405,1430,1577,1294,
+  1178,1587,1540,604,604,1343,1141,1767,1532,1612,1235,1612,1423,1300,
+  1251,1499,1401,2025,1403,1251,1403,799,690,799,1716,1024,1024,1255,
+  1300,1126,1300,1260,721,1300,1298,569,569,1186,569,1995,1298,1253,1300,
+  1300,842,1067,803,1298,1212,1675,1212,1212,1075,1303,690,1303,1716,-1,
+];
+
+const DB: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,713,934,1067,1716,1425,2052,1786,627,936,
+  936,1071,1716,778,850,778,748,1425,1425,1425,1425,1425,1425,1425,1425,
+  1425,1425,819,819,1716,1716,1716,1188,2048,1585,1561,1503,1700,1399,
+  1399,1681,1714,762,762,1587,1305,2038,1714,1741,1501,1741,1577,1475,
+  1397,1663,1585,2259,1579,1483,1485,936,748,936,1716,1024,1024,1382,
+  1466,1214,1466,1389,891,1466,1458,702,702,1362,702,2134,1458,1407,1466,
+  1466,1010,1219,979,1458,1335,1892,1321,1335,1192,1458,748,1458,1716,-1,
+];
+
+const DBI: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,713,934,1067,1425,1425,2052,1786,627,936,
+  936,1071,1716,778,850,778,748,1425,1425,1425,1425,1425,1425,1425,1425,
+  1425,1425,819,819,1716,1716,1716,1188,2048,1585,1561,1503,1700,1399,
+  1399,1681,1714,762,762,1587,1305,2038,1714,1741,1501,1741,1577,1475,
+  1397,1663,1585,2259,1579,1483,1485,936,748,936,1716,1024,1024,1382,
+  1466,1214,1466,1389,891,1466,1458,702,702,1362,702,2134,1458,1407,1466,
+  1466,1010,1219,979,1458,1335,1892,1321,1335,1192,1458,748,1458,1716,-1,
+];
+
+export const DEJAVU_FAMILY: FontFamilyData = {
+  names: ["dejavusans"],
+  unitsPerEm: 2048,
+  regular: DR, bold: DB, italic: DR, boldItalic: DBI,
+};
+
+// ── Consolas ─────────────────────────────────────────────────────────────────
+// Regular, bold, and italic variants share the same monospace array.
+// Bold-italic has no entry for index 0 or 13 (NUL / CR).
+
+const CR: readonly number[] = [
+  1126,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,-1,
+];
+
+const CBI: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
+  1126,1126,1126,-1,
+];
+
+export const CONSOLAS_FAMILY: FontFamilyData = {
+  names: ["consola","consolas"],
+  unitsPerEm: 2048,
+  regular: CR, bold: CR, italic: CR, boldItalic: CBI,
+};
+
+// ── Trebuchet MS ──────────────────────────────────────────────────────────────
+
+const TRBR: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,617,752,665,1074,1074,1229,1446,327,752,
+  752,752,1074,752,752,752,1074,1074,1074,1074,1074,1074,1074,1074,1074,
+  1074,1074,752,752,1074,1074,1074,752,1578,1208,1159,1225,1256,1097,
+  1075,1385,1340,570,976,1179,1037,1453,1307,1380,1142,1384,1192,985,
+  1189,1328,1203,1745,1140,1168,1127,752,728,752,1074,1074,1074,1076,
+  1141,1014,1141,1117,757,1028,1119,584,751,1033,604,1700,1119,1099,1141,
+  1141,796,829,812,1119,1003,1524,1026,1010,972,752,1074,752,1074,-1,
+];
+
+const TRBB: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,617,752,751,1200,1200,1401,1446,470,752,
+  752,885,1200,752,752,752,799,1200,1200,1200,1200,1200,1200,1200,1200,
+  1200,1200,752,752,1200,1200,1200,897,1578,1297,1219,1253,1316,1165,
+  1195,1375,1400,570,1091,1264,1132,1526,1367,1440,1202,1452,1251,1047,
+  1253,1388,1273,1810,1230,1256,1147,823,728,823,1200,1200,1200,1091,
+  1191,1048,1189,1177,757,1028,1214,611,751,1122,604,1760,1209,1159,1193,
+  1196,875,882,812,1210,1080,1605,1131,1093,1082,888,1200,888,1200,-1,
+];
+
+const TRBI: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,617,752,665,1074,985,1229,1446,327,752,
+  752,752,1074,752,752,752,1074,1074,1074,1074,1074,1074,1074,1074,1074,
+  1074,1074,752,752,1074,1074,1074,752,1578,1251,1159,1225,1256,1097,
+  1075,1385,1340,570,976,1179,1037,1559,1307,1380,1113,1380,1192,985,
+  1189,1328,1203,1745,1140,1168,1127,752,728,752,1074,1074,1074,1076,
+  1141,942,1141,1100,822,1028,1141,628,751,1033,656,1700,1119,1099,1141,
+  1141,853,829,860,1140,1003,1524,1026,1010,972,752,1074,752,1074,-1,
+];
+
+const TRBBI: readonly number[] = [
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,617,752,800,1200,1200,1500,1446,617,752,
+  752,885,1200,752,752,752,813,1200,1200,1200,1200,1200,1200,1200,1200,
+  1200,1200,752,752,1200,1200,1200,813,1578,1257,1208,1255,1295,1215,
+  1199,1385,1389,570,1021,1331,1082,1610,1352,1438,1195,1576,1277,1027,
+  1403,1355,1399,1897,1345,1400,1252,994,978,994,1200,1200,1200,1214,
+  1215,1009,1215,1130,840,1096,1151,669,794,1105,655,1700,1151,1167,1226,
+  1226,915,940,897,1141,1131,1584,1179,1155,1091,994,1200,994,1200,-1,
+];
+
+export const TREBUCHET_FAMILY: FontFamilyData = {
+  names: ["trebuchetms","trebuchet"],
+  unitsPerEm: 2048,
+  regular: TRBR, bold: TRBB, italic: TRBI, boldItalic: TRBBI,
+};