animl-cli 0.0.0-stage → 0.1.0

package/packages/cli/src/font/import.js

@@ -0,0 +1,92 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { fault, MAX_FONT } from "./binary.js";
+import { normalizeFont } from "./container.js";
+import { Font } from "./reader.js";
+import { subsetFont } from "./subset.js";
+function importFont(path, out, chars) {
+  const input = readFileSync(path), font = new Font(input), bytes = chars === void 0 ? normalizeFont(input) : subsetFont(input, chars);
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, bytes);
+  return {
+    type: "font",
+    family: font.family,
+    weight: font.weight,
+    style: font.style,
+    source: out,
+    mime: font.flavor === 1330926671 ? "font/otf" : "font/ttf",
+    size: bytes.length
+  };
+}
+async function googleFonts(query, out, chars, fetcher = fetch) {
+  if (!/^[\w +-]+(?::[a-zA-Z,]+@[\d.;,-]+)?$/.test(query))
+    fault("invalid Google Fonts family/axis query", "font-option");
+  const url = new URL("https://fonts.googleapis.com/css2");
+  url.searchParams.set("family", query);
+  if (chars !== void 0) url.searchParams.set("text", chars);
+  const get = async (url2) => {
+    const response = await fetcher(url2);
+    if (!response.ok) fault("font download failed: HTTP " + response.status, "font-download");
+    const chunks = [];
+    let size = 0;
+    if (!response.body) return Buffer.alloc(0);
+    const reader = response.body.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        size += value.byteLength;
+        if (size > MAX_FONT) {
+          await reader.cancel();
+          fault("font download exceeds limit", "font-limit");
+        }
+        chunks.push(Buffer.from(value));
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return Buffer.concat(chunks);
+  };
+  let css;
+  try {
+    css = await get(url.href);
+  } catch (e) {
+    if (e instanceof Error && "code" in e && String(e.code).startsWith("font-")) throw e;
+    fault("cannot fetch Google Fonts CSS", "font-download");
+  }
+  const sources = [
+    ...new Set(
+      [
+        ...css.toString("utf8").matchAll(/url\(\s*['"]?(https:\/\/fonts\.gstatic\.com\/[^\s'"()]+)['"]?\s*\)/g)
+      ].map((m) => m[1])
+    )
+  ];
+  if (!sources.length) fault("Google Fonts returned no supported font sources", "font-download");
+  const results = [];
+  for (const [i, source] of sources.entries()) {
+    let bytes;
+    try {
+      bytes = await get(source);
+    } catch (e) {
+      if (e instanceof Error && "code" in e && String(e.code).startsWith("font-")) throw e;
+      fault("cannot fetch Google Fonts font bytes", "font-download");
+    }
+    const font = new Font(bytes), result = chars === void 0 ? normalizeFont(bytes) : subsetFont(bytes, chars), file = sources.length === 1 ? out : out.replace(/(\.[^./]+)?$/, `-${i + 1}$1`);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, result);
+    results.push({
+      type: "font",
+      family: font.family,
+      weight: font.weight,
+      style: font.style,
+      source: file,
+      mime: font.flavor === 1330926671 ? "font/otf" : "font/ttf",
+      size: result.length
+    });
+  }
+  return results;
+}
+export {
+  googleFonts,
+  importFont
+};

package/packages/cli/src/font/index.d.ts

@@ -0,0 +1,8 @@
+export { Font, readFont, type Axis, type Instance, type Contour, type Point } from './reader.js';
+export { ToolMeasurer, shapingDiagnostic, type FontSpec, type Measured, type TextMeasurer, } from './measure.js';
+export { documentFonts, installToolMeasurer, buildFont, documentCharacters } from './document.js';
+export { subsetFont } from './subset.js';
+export { normalizeFont } from './container.js';
+export { outlineSVG } from './svg.js';
+export { flattenText } from './flatten.js';
+export { importFont, googleFonts } from './import.js';

package/packages/cli/src/font/index.js

@@ -0,0 +1,27 @@
+import { Font, readFont } from "./reader.js";
+import {
+  ToolMeasurer,
+  shapingDiagnostic
+} from "./measure.js";
+import { documentFonts, installToolMeasurer, buildFont, documentCharacters } from "./document.js";
+import { subsetFont } from "./subset.js";
+import { normalizeFont } from "./container.js";
+import { outlineSVG } from "./svg.js";
+import { flattenText } from "./flatten.js";
+import { importFont, googleFonts } from "./import.js";
+export {
+  Font,
+  ToolMeasurer,
+  buildFont,
+  documentCharacters,
+  documentFonts,
+  flattenText,
+  googleFonts,
+  importFont,
+  installToolMeasurer,
+  normalizeFont,
+  outlineSVG,
+  readFont,
+  shapingDiagnostic,
+  subsetFont
+};

package/packages/cli/src/font/measure.d.ts

@@ -0,0 +1,37 @@
+import type { Diagnostic } from 'animl';
+import { Font } from './reader.js';
+export type FontSpec = {
+    family: string;
+    size: number;
+    weight: number;
+    style: 'normal' | 'italic';
+    axes?: Record<string, number>;
+    features?: Record<string, number>;
+    tracking: number;
+};
+export type Measured = {
+    advances: Float64Array;
+    ascent: number;
+    descent: number;
+    capHeight: number;
+    xHeight: number;
+    lineGap: number;
+};
+export interface TextMeasurer {
+    measure(font: FontSpec, text: string): Measured;
+}
+export declare const graphemes: (text: string) => string[];
+export declare function shapingDiagnostic(text: string, pointer?: string): Diagnostic[];
+export declare class ToolMeasurer implements TextMeasurer {
+    onDiagnostic?: (diagnostic: Diagnostic) => void;
+    readonly fonts: Map<string, {
+        font: Font;
+        weight: number;
+        style: "normal" | "italic";
+    }[]>;
+    register(family: string, font: Font, weight?: number, style?: 'normal' | 'italic'): void;
+    resolve(spec: FontSpec): Font;
+    axes(spec: FontSpec, font?: Font): Record<string, number>;
+    measure(spec: FontSpec, text: string): Measured;
+    outline(spec: FontSpec, text: string, x?: number, baseline?: number): string;
+}

package/packages/cli/src/font/measure.js

@@ -0,0 +1,131 @@
+import { fault } from "./binary.js";
+import { featureTags, substitute } from "./features.js";
+const graphemes = (text) => [...new Intl.Segmenter("und", { granularity: "grapheme" }).segment(text)].map((s) => s.segment);
+function shapingDiagnostic(text, pointer = "") {
+  return /[\p{Mark}\u0590-\u08ff\u0900-\u0dff\u200c\u200d]/u.test(text) ? [
+    {
+      code: "text-shaping-approximate",
+      severity: "warning",
+      pointer,
+      message: "tool text uses cmap and pair kerning; this run needs complex shaping",
+      hint: "use anima render --browser-text for browser shaping and mark positioning"
+    }
+  ] : [];
+}
+class ToolMeasurer {
+  onDiagnostic;
+  fonts = /* @__PURE__ */ new Map();
+  register(family, font, weight = 400, style = "normal") {
+    const key = family.toLowerCase(), entries = this.fonts.get(key) ?? [];
+    entries.push({ font, weight, style });
+    this.fonts.set(key, entries);
+  }
+  resolve(spec) {
+    for (const family of spec.family.split(",")) {
+      const entries = this.fonts.get(
+        family.trim().replace(/^['"]|['"]$/g, "").toLowerCase()
+      );
+      if (entries?.length)
+        return [...entries].sort(
+          (a, b) => (a.style !== spec.style ? 1e4 : 0) + Math.abs(a.weight - spec.weight) - (b.style !== spec.style ? 1e4 : 0) - Math.abs(b.weight - spec.weight)
+        )[0].font;
+    }
+    throw Object.assign(new Error("no local font registered for " + spec.family), {
+      code: "font-missing",
+      pointer: "",
+      hint: "register a local font with --font Name=path (requested family: " + spec.family + ")"
+    });
+  }
+  axes(spec, font = this.resolve(spec)) {
+    for (const [tag, value] of Object.entries(spec.axes ?? {})) {
+      if (!font.axes.some((a) => a.tag === tag))
+        fault("unknown variation axis " + tag, "font-axis");
+      if (!Number.isFinite(value)) fault("variation coordinate must be finite", "font-axis");
+    }
+    for (const [tag, value] of Object.entries(spec.features ?? {})) {
+      if (!Number.isInteger(value) || value < 0)
+        fault("feature value must be a nonnegative integer", "font-feature");
+      if (!featureTags(font).has(tag))
+        this.onDiagnostic?.({
+          code: "font-feature",
+          severity: "warning",
+          pointer: "/features/" + tag,
+          message: "font has no feature " + tag,
+          hint: "choose a feature advertised by the font; absent features have no effect"
+        });
+    }
+    return {
+      ...font.axes.some((a) => a.tag === "wght") ? { wght: spec.weight } : {},
+      ...spec.axes
+    };
+  }
+  measure(spec, text) {
+    for (const diagnostic of shapingDiagnostic(text)) this.onDiagnostic?.(diagnostic);
+    if (!Number.isFinite(spec.size) || spec.size <= 0 || !Number.isFinite(spec.tracking))
+      fault("invalid text size or tracking");
+    const font = this.resolve(spec), scale = spec.size / font.unitsPerEm, clusters = graphemes(text), advances = new Float64Array(clusters.length), axes = this.axes(spec, font);
+    const shaped = substitute(font, text, spec.features);
+    let pen = 0, previous, offset = 0, gi = 0;
+    clusters.forEach((cluster, i) => {
+      if (i) pen += spec.tracking;
+      offset += cluster.length;
+      while (gi < shaped.length && shaped[gi].start < offset) {
+        const g = shaped[gi++].glyph;
+        if (previous !== void 0) pen += font.kerning(previous, g, spec.features) * scale;
+        pen += font.advance(g, axes) * scale;
+        previous = g;
+      }
+      advances[i] = pen;
+    });
+    return {
+      advances,
+      ascent: font.ascent * scale,
+      descent: font.descent * scale,
+      capHeight: font.capHeight * scale,
+      xHeight: font.xHeight * scale,
+      lineGap: font.lineGap * scale
+    };
+  }
+  outline(spec, text, x = 0, baseline = 0) {
+    const font = this.resolve(spec), scale = spec.size / font.unitsPerEm, axes = this.axes(spec, font);
+    const glyphs = [];
+    const clusters = [...new Intl.Segmenter("und", { granularity: "grapheme" }).segment(text)];
+    let previousCluster = -1;
+    for (const shaped of substitute(font, text, spec.features)) {
+      const glyph = shaped.glyph;
+      const cluster = clusters.findIndex(
+        (c) => shaped.start >= c.index && shaped.start < c.index + c.segment.length
+      );
+      const current = {
+        glyph,
+        x: 0,
+        y: 0,
+        advanceX: font.advance(glyph, axes),
+        advanceY: 0,
+        tracking: previousCluster >= 0 && cluster !== previousCluster ? spec.tracking : 0
+      }, previous = glyphs.at(-1);
+      if (previous) {
+        const pair = font.positionPair(previous.glyph, glyph, spec.features);
+        for (const key of ["x", "y", "advanceX", "advanceY"]) {
+          previous[key] += pair.first[key];
+          current[key] += pair.second[key];
+        }
+      }
+      glyphs.push(current);
+      previousCluster = cluster;
+    }
+    let pen = x, y = baseline;
+    return glyphs.map((g) => {
+      pen += g.tracking;
+      const path = font.path(g.glyph, spec.size, pen + g.x * scale, y - g.y * scale, axes);
+      pen += g.advanceX * scale;
+      y -= g.advanceY * scale;
+      return path;
+    }).join("");
+  }
+}
+export {
+  ToolMeasurer,
+  graphemes,
+  shapingDiagnostic
+};

package/packages/cli/src/font/reader.d.ts

@@ -0,0 +1,13 @@
+import type { Diagnostic } from 'animl';
+import { Font as OpenType } from 'animl/internal/modules/fonts/core/opentype/reader.js';
+import { Bytes } from './binary.js';
+export { contoursPath } from 'animl/internal/modules/fonts/core/opentype/reader.js';
+export type { Axis, Instance, Point, Contour, GlyphAdjustment, PairAdjustment, } from 'animl/internal/modules/fonts/core/opentype/reader.js';
+export declare class Font extends OpenType<Buffer> {
+    constructor(bytes: Uint8Array);
+    table(tag: string): Bytes;
+}
+export declare function readFont(bytes: Uint8Array, pointer?: string): {
+    font?: Font;
+    diagnostics: Diagnostic[];
+};

package/packages/cli/src/font/reader.js

@@ -0,0 +1,26 @@
+import { Font as OpenType } from "animl/internal/modules/fonts/core/opentype/reader.js";
+import { Bytes, diagnostic, fault } from "./binary.js";
+import { unpack } from "./container.js";
+import { contoursPath } from "animl/internal/modules/fonts/core/opentype/reader.js";
+class Font extends OpenType {
+  constructor(bytes) {
+    super(unpack(bytes));
+  }
+  table(tag) {
+    const b = this.tables.get(tag);
+    if (!b) fault("missing font table " + tag);
+    return new Bytes(b);
+  }
+}
+function readFont(bytes, pointer = "") {
+  try {
+    return { font: new Font(bytes), diagnostics: [] };
+  } catch (error) {
+    return { diagnostics: [diagnostic(error, pointer)] };
+  }
+}
+export {
+  Font,
+  contoursPath,
+  readFont
+};

package/packages/cli/src/font/subset.d.ts

@@ -0,0 +1,6 @@
+export declare function cmap12(coverage: ReadonlyMap<number, number>): Buffer;
+/** Preserve glyph IDs (layout/variation references stay valid); remove unused glyf payloads.
+ * Composite dependencies are closed transitively. GSUB is retained conservatively: if present,
+ * keep all outlines because arbitrary substitutions can introduce unencoded glyphs.
+ */
+export declare function subsetFont(bytes: Uint8Array, characters: string): Buffer;

package/packages/cli/src/font/subset.js

@@ -0,0 +1,87 @@
+import { subsetCFF } from "./cff.js";
+import { Bytes, fault, sfnt } from "./binary.js";
+import { Font } from "./reader.js";
+function cmap12(coverage) {
+  const entries = [...coverage].sort(([a], [b]) => a - b), groups = [];
+  for (const [cp, glyph] of entries) {
+    const last = groups.at(-1);
+    if (last && cp === last.end + 1 && glyph === last.glyph + cp - last.start) last.end = cp;
+    else groups.push({ start: cp, end: cp, glyph });
+  }
+  const out = Buffer.alloc(28 + groups.length * 12);
+  out.writeUInt16BE(1, 2);
+  out.writeUInt16BE(3, 4);
+  out.writeUInt16BE(10, 6);
+  out.writeUInt32BE(12, 8);
+  out.writeUInt16BE(12, 12);
+  out.writeUInt32BE(out.length - 12, 16);
+  out.writeUInt32BE(groups.length, 24);
+  groups.forEach((g, i) => {
+    out.writeUInt32BE(g.start, 28 + i * 12);
+    out.writeUInt32BE(g.end, 32 + i * 12);
+    out.writeUInt32BE(g.glyph, 36 + i * 12);
+  });
+  return out;
+}
+function subsetFont(bytes, characters) {
+  const font = new Font(bytes), tables = new Map(font.tables);
+  const keep = /* @__PURE__ */ new Set([0]), coverage = /* @__PURE__ */ new Map();
+  for (const char of characters) {
+    const cp = char.codePointAt(0), g = font.glyph(cp);
+    if (g) {
+      coverage.set(cp, g);
+      keep.add(g);
+    }
+  }
+  if (tables.has("GSUB")) for (let i = 0; i < font.glyphCount; i++) keep.add(i);
+  if (!tables.has("glyf")) {
+    tables.set("CFF ", subsetCFF(font, keep));
+    tables.set("cmap", cmap12(coverage));
+    tables.delete("DSIG");
+    return sfnt(tables, font.flavor);
+  }
+  const loca = font.table("loca"), long = font.table("head").i16(50), glyf = font.table("glyf");
+  const offset = (g) => long ? loca.u32(g * 4) : loca.u16(g * 2) * 2;
+  const visit = (g, depth = 0) => {
+    if (depth > 16) fault("recursive subset components", "font-limit");
+    const a = offset(g), z = offset(g + 1);
+    if (a === z) return;
+    const b = new Bytes(glyf.slice(a, z - a));
+    if (b.i16(0) >= 0) return;
+    let p = 10, flags;
+    do {
+      flags = b.u16(p);
+      const child = b.u16(p + 2);
+      if (child >= font.glyphCount) fault("invalid composite glyph");
+      p += 4 + (flags & 1 ? 4 : 2) + (flags & 8 ? 2 : flags & 64 ? 4 : flags & 128 ? 8 : 0);
+      if (!keep.has(child)) {
+        keep.add(child);
+        visit(child, depth + 1);
+      }
+    } while (flags & 32);
+  };
+  for (const g of [...keep]) visit(g);
+  const chunks = [], locations = Buffer.alloc((font.glyphCount + 1) * 4);
+  let total = 0;
+  for (let i = 0; i < font.glyphCount; i++) {
+    locations.writeUInt32BE(total, i * 4);
+    if (keep.has(i)) {
+      const chunk = glyf.slice(offset(i), offset(i + 1) - offset(i));
+      chunks.push(chunk);
+      total += chunk.length;
+    }
+  }
+  locations.writeUInt32BE(total, font.glyphCount * 4);
+  const head = Buffer.from(tables.get("head"));
+  head.writeInt16BE(1, 50);
+  tables.set("head", head);
+  tables.set("glyf", Buffer.concat(chunks));
+  tables.set("loca", locations);
+  tables.set("cmap", cmap12(coverage));
+  tables.delete("DSIG");
+  return sfnt(tables, font.flavor);
+}
+export {
+  cmap12,
+  subsetFont
+};

package/packages/cli/src/font/svg.d.ts

@@ -0,0 +1,3 @@
+import { ToolMeasurer } from './measure.js';
+/** Replace SVG text/tspan with paths, retaining inherited paint, transforms and clipping. */
+export declare function outlineSVG(svg: string, measurer: ToolMeasurer): string;

package/packages/cli/src/font/svg.js

@@ -0,0 +1,109 @@
+import { parseXml } from "animl/internal/packages/markup/src/xml.js";
+import { fault } from "./binary.js";
+const xml = (s) => s.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const attr = (e) => Object.fromEntries(e.attrs.map((a) => [a.name, a.value]));
+const attrs = (a) => Object.entries(a).map(([k, v]) => ` ${k}="${xml(v)}"`).join("");
+const num = (value, fallback) => {
+  if (value === void 0) return fallback;
+  const n = Number(value);
+  if (!Number.isFinite(n))
+    fault(
+      "text outline conversion needs scalar SVG positions and grid-unit sizes",
+      "font-unsupported"
+    );
+  return n;
+};
+const textStyle = (own) => {
+  for (const declaration of (own.style ?? "").split(";")) {
+    if (!declaration.trim()) continue;
+    const colon = declaration.indexOf(":");
+    const key = declaration.slice(0, colon).trim();
+    const value = declaration.slice(colon + 1).trim();
+    if (colon < 0 || !/^(font-(family|size|weight|style|variation-settings|feature-settings)|letter-spacing|white-space|text-rendering|fill|fill-opacity|stroke|stroke-width|stroke-opacity|stroke-linecap|stroke-linejoin|opacity)$/.test(
+      key
+    ))
+      fault("unsupported text SVG style property: " + key, "font-unsupported");
+    own[key] = value;
+  }
+  delete own.style;
+};
+const settings = (s) => s ? Object.fromEntries(
+  [...s.matchAll(/['"]([\w ]{4})['"]\s+(-?[\d.]+)/g)].map((m) => [m[1], Number(m[2])])
+) : void 0;
+function outlineSVG(svg, measurer) {
+  if (!/<text[\s>]/.test(svg)) return svg;
+  const parsed = parseXml(svg);
+  if (!parsed.doc.root) fault("cannot parse rendered SVG");
+  const render = (element, inherited, pen) => {
+    const own = attr(element);
+    const isText = element.name === "text" || element.name === "tspan";
+    if (isText) textStyle(own);
+    const a = { ...inherited, ...own };
+    let content = "";
+    if (isText) {
+      pen ??= { x: 0, y: 0 };
+      pen.x = num(own.x, pen.x) + num(own.dx, 0);
+      pen.y = num(own.y, pen.y) + num(own.dy, 0);
+      const spec = {
+        family: a["font-family"] ?? "sans-serif",
+        size: num(a["font-size"], 16),
+        weight: a["font-weight"] === "bold" ? 700 : num(a["font-weight"], 400),
+        style: a["font-style"] === "italic" ? "italic" : "normal",
+        tracking: num(a["letter-spacing"], 0),
+        axes: settings(a["font-variation-settings"]),
+        features: settings(a["font-feature-settings"])
+      };
+      if (a.direction === "rtl")
+        fault(
+          "RTL outline conversion requires shaping; use --browser-text to render",
+          "font-unsupported"
+        );
+      for (const child of element.children) {
+        if (child.kind === "text") {
+          const m = measurer.measure(spec, child.value), width = m.advances.at(-1) ?? 0;
+          let x = pen.x;
+          if (own["text-anchor"] === "middle") x -= width / 2;
+          else if (own["text-anchor"] === "end") x -= width;
+          const path = measurer.outline(spec, child.value, x, pen.y);
+          content += `<path d="${path}"/>`;
+          pen.x += width;
+        } else if (child.kind === "element") content += render(child, a, pen);
+      }
+      const group = Object.fromEntries(
+        Object.entries(own).filter(
+          ([k]) => !k.startsWith("font-") && ![
+            "letter-spacing",
+            "word-spacing",
+            "white-space",
+            "text-rendering",
+            "xml:space",
+            "direction",
+            "dominant-baseline",
+            "alignment-baseline",
+            "x",
+            "y",
+            "dx",
+            "dy",
+            "text-anchor",
+            "rotate",
+            "textLength",
+            "lengthAdjust"
+          ].includes(k)
+        )
+      );
+      if (own.rotate && own.rotate !== "0")
+        fault(
+          "SVG glyph rotations are not implemented by the outline converter",
+          "font-unsupported"
+        );
+      return `<g${attrs(group)}>${content}</g>`;
+    }
+    for (const child of element.children)
+      content += child.kind === "element" ? render(child, a) : child.kind === "text" ? xml(child.value) : "";
+    return `<${element.name}${attrs(own)}>${content}</${element.name}>`;
+  };
+  return render(parsed.doc.root, {});
+}
+export {
+  outlineSVG
+};

package/packages/cli/src/font/truetype.d.ts

@@ -0,0 +1,3 @@
+import type { Contour } from './reader.js';
+/** Unhinted, uncompressed TrueType simple glyph, with explicit signed coordinate deltas. */
+export declare function encodeGlyph(contours: Contour[], instructions?: Buffer, overlap?: boolean): Buffer;

package/packages/cli/src/font/truetype.js

@@ -0,0 +1,38 @@
+import { fault } from "./binary.js";
+function encodeGlyph(contours, instructions = Buffer.alloc(0), overlap = false) {
+  const points = contours.flat();
+  if (!points.length) return Buffer.alloc(0);
+  const n = points.length;
+  if (n > 65535 || contours.length > 32767) fault("glyph point limit", "font-limit");
+  const out = Buffer.alloc(12 + contours.length * 2 + n * 5 + instructions.length);
+  out.writeInt16BE(contours.length, 0);
+  const xs = points.map((p2) => Math.round(p2.x)), ys = points.map((p2) => Math.round(p2.y));
+  [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)].forEach(
+    (v, i) => out.writeInt16BE(v, 2 + i * 2)
+  );
+  let p = 10, end = -1;
+  contours.forEach((c) => {
+    end += c.length;
+    out.writeUInt16BE(end, p);
+    p += 2;
+  });
+  out.writeUInt16BE(instructions.length, p);
+  p += 2;
+  instructions.copy(out, p);
+  p += instructions.length;
+  points.forEach((pt, i) => out[p++] = (pt.on ? 1 : 0) | (overlap && i === 0 ? 64 : 0));
+  for (const values of [xs, ys]) {
+    let prev = 0;
+    for (const v of values) {
+      const delta = v - prev;
+      if (delta < -32768 || delta > 32767) fault("glyph delta outside int16 range");
+      out.writeInt16BE(delta, p);
+      p += 2;
+      prev = v;
+    }
+  }
+  return out;
+}
+export {
+  encodeGlyph
+};

package/packages/cli/src/font/variation.d.ts

@@ -0,0 +1 @@
+export * from 'animl/internal/modules/fonts/core/opentype/variation.js';

package/packages/cli/src/font/variation.js

@@ -0,0 +1 @@
+export * from "animl/internal/modules/fonts/core/opentype/variation.js";

package/packages/cli/src/font/woff2.d.ts

@@ -0,0 +1,3 @@
+/** W3C WOFF2 §5.1–5.4 inverse transforms, producing canonical sfnt tables. */
+export declare function restoreGlyf(tables: Map<string, Buffer>, expectedLoca: number): void;
+export declare function restoreHmtx(tables: Map<string, Buffer>): void;