animl 0.0.0-stage → 0.1.0

package/modules/fonts/core/index.js

@@ -0,0 +1,56 @@
+import { after } from "../manifest.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { installOptions } from "./options.js";
+import { cssFont } from "./css.js";
+const fonts = {
+  name: "fonts",
+  after: [...after, "hostedit"],
+  entries: [],
+  use(entries, set) {
+    fonts.setMeasurer = set;
+    const entry = entries[0];
+    const fields = [
+      entry.shapes.styles.of.p,
+      entry.elements.style.shape.p
+    ];
+    const tags = {
+      k: "map",
+      of: { k: "num" },
+      key: /^[a-zA-Z0-9 ]{4}$/,
+      feature: "fonts"
+    };
+    for (const field of fields)
+      Object.assign(field, {
+        axes: tags,
+        features: { ...tags, of: { k: "num", min: 0, int: true } }
+      });
+  },
+  init(_registry, shared) {
+    if (V) installOptions(fonts);
+    const get = Object.getOwnPropertyDescriptor(shared.Player.prototype, "data")?.get;
+    if (get) {
+      const seen = /* @__PURE__ */ new WeakSet();
+      Object.defineProperty(shared.Player.prototype, "data", {
+        configurable: true,
+        get() {
+          const api = get.call(this);
+          if (!seen.has(api)) {
+            seen.add(api);
+            const font = api.font.bind(api);
+            api.font = (path) => {
+              const handle = font(path), set = handle.set;
+              handle.set = (value) => fonts.accepts?.(value) ? fonts.assign?.(api, path, value) : set(value);
+              return handle;
+            };
+          }
+          return api;
+        }
+      });
+    }
+    return fonts;
+  }
+};
+export {
+  cssFont,
+  fonts
+};

package/modules/fonts/core/info.d.ts

@@ -0,0 +1,37 @@
+import { Font } from './opentype/reader.js';
+export interface FontOptions {
+    axes?: Record<string, number>;
+    features?: Record<string, number>;
+}
+/** Immutable options over a shared decoded face. All metrics and paths use font units. */
+export declare class FontInfo {
+    readonly options: {
+        axes: Readonly<Record<string, number>>;
+        features: Readonly<Record<string, number>>;
+    };
+    readonly metrics: Readonly<{
+        unitsPerEm: number;
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        capHeight: number;
+        xHeight: number;
+        glyphCount: number;
+    }>;
+    private face;
+    constructor(face: Font, options?: FontOptions);
+    hasGlyph(codepoint: number | string): boolean;
+    derive(options: FontOptions): FontInfo;
+    /** Raw glyph path by index. +Y points down, with baseline zero, like Anima geometry. */
+    glyphPath(glyph: number, size?: number): string;
+    /** Context-free GSUB with the same bounded shaping contract as the tool measurer. */
+    glyphs(text: string): {
+        advance: number;
+        path: string;
+        glyph: number;
+        start: number;
+        end: number;
+    }[];
+}
+/** Browser-neutral SFNT decoder. Compressed web containers must be normalized by the tool. */
+export declare function decodeFont(bytes: Uint8Array): FontInfo;

package/modules/fonts/core/info.js

@@ -0,0 +1,79 @@
+import { Font } from "./opentype/reader.js";
+import { Bytes, fault, MAX_FONT } from "./opentype/binary.js";
+import { featureTags, substitute } from "./opentype/features.js";
+class FontInfo {
+  options;
+  metrics;
+  face;
+  constructor(face, options = {}) {
+    this.face = face;
+    const axes = Object.fromEntries(face.axes.map((a) => [a.tag, a.default]));
+    for (const [tag, value] of Object.entries(options.axes ?? {})) {
+      const axis = face.axes.find((a) => a.tag === tag);
+      if (!axis || !Number.isFinite(value))
+        fault("unknown or invalid variation axis " + tag, "font-axis");
+      axes[tag] = Math.max(axis.min, Math.min(axis.max, value));
+    }
+    const available = featureTags(face);
+    const features = Object.fromEntries(
+      ["ccmp", "locl", "rlig", "liga", "clig", "kern"].filter((t) => available.has(t)).map((t) => [t, 1])
+    );
+    for (const [tag, value] of Object.entries(options.features ?? {})) {
+      if (!/^[a-zA-Z0-9 ]{4}$/.test(tag) || !Number.isInteger(value) || value < 0 || !available.has(tag))
+        fault("unknown or invalid font feature " + tag, "font-feature");
+      features[tag] = value;
+    }
+    this.options = Object.freeze({ axes: Object.freeze(axes), features: Object.freeze(features) });
+    const { unitsPerEm, ascent, descent, lineGap, capHeight, xHeight, glyphCount } = face;
+    this.metrics = Object.freeze({
+      unitsPerEm,
+      ascent,
+      descent,
+      lineGap,
+      capHeight,
+      xHeight,
+      glyphCount
+    });
+  }
+  hasGlyph(codepoint) {
+    return this.face.hasGlyph(codepoint);
+  }
+  derive(options) {
+    return new FontInfo(this.face, {
+      axes: { ...this.options.axes, ...options.axes },
+      features: { ...this.options.features, ...options.features }
+    });
+  }
+  /** Raw glyph path by index. +Y points down, with baseline zero, like Anima geometry. */
+  glyphPath(glyph, size = this.metrics.unitsPerEm) {
+    if (!Number.isFinite(size) || size < 0) fault("invalid glyph path size");
+    return this.face.path(glyph, size, 0, 0, { ...this.options.axes });
+  }
+  /** Context-free GSUB with the same bounded shaping contract as the tool measurer. */
+  glyphs(text) {
+    return substitute(this.face, text, { ...this.options.features }).map((g) => ({
+      ...g,
+      advance: this.face.advance(g.glyph, { ...this.options.axes }),
+      path: this.glyphPath(g.glyph)
+    }));
+  }
+}
+function decodeFont(bytes) {
+  if (bytes.byteLength > MAX_FONT) fault("font exceeds the 32 MiB limit", "font-limit");
+  const b = new Bytes(Uint8Array.from(bytes));
+  const flavor = b.u32(0);
+  if (![65536, 1330926671, 1953658213].includes(flavor))
+    fault("introspection requires SFNT TTF or OTF bytes", "font-format");
+  const n = b.u16(4), tables = /* @__PURE__ */ new Map();
+  if (!n || n > 256) fault("invalid sfnt table count");
+  for (let i = 0; i < n; i++) {
+    const p = 12 + i * 16, tag = b.tag(p);
+    if (tables.has(tag)) fault("duplicate font table " + tag);
+    tables.set(tag, b.slice(b.u32(p + 8), b.u32(p + 12)));
+  }
+  return new FontInfo(new Font({ tables, flavor }));
+}
+export {
+  FontInfo,
+  decodeFont
+};

package/modules/fonts/core/opentype/binary.d.ts

@@ -0,0 +1,21 @@
+import type { Diagnostic } from '../../../../packages/core/src/index.js';
+export declare const MAX_FONT: number;
+export declare function fault(message: string, code?: string): never;
+export declare function diagnostic(error: unknown, pointer?: string): Diagnostic;
+/** Every read is range checked, including sub-table offsets; bounded before allocation. */
+export declare class Bytes {
+    #private;
+    readonly data: Uint8Array;
+    private view;
+    constructor(data: Uint8Array);
+    check(p: number, n: number): number;
+    u8(p: number): number;
+    i8(p: number): number;
+    u16(p: number): number;
+    i16(p: number): number;
+    u32(p: number): number;
+    i32(p: number): number;
+    fixed(p: number): number;
+    slice(p: number, n: number): Uint8Array;
+    tag(p: number): string;
+}

package/modules/fonts/core/opentype/binary.js

@@ -0,0 +1,68 @@
+import { VERBOSE as V } from "../../../../packages/core/src/flags.js";
+const MAX_FONT = 32 * 1024 * 1024;
+function fault(message, code = "font-invalid") {
+  throw Object.assign(new Error(message), {
+    code,
+    pointer: "",
+    hint: "use a valid, supported OpenType font"
+  });
+}
+function diagnostic(error, pointer = "") {
+  const e = error;
+  return {
+    severity: "error",
+    code: e.code?.startsWith("font-") ? e.code : "font-invalid",
+    pointer,
+    message: e.message || "invalid font bytes",
+    hint: e.hint ?? "check the font source bytes and format"
+  };
+}
+class Bytes {
+  data;
+  view;
+  #reads = 2e6;
+  constructor(data) {
+    this.data = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  check(p, n) {
+    if (--this.#reads < 0) fault(V ? "font table operation limit" : "", "font-limit");
+    if (!Number.isSafeInteger(p) || !Number.isSafeInteger(n) || p < 0 || n < 0 || p + n > this.data.length)
+      fault(V ? "font table is truncated or has an invalid offset" : "");
+    return p;
+  }
+  u8(p) {
+    return this.view.getUint8(this.check(p, 1));
+  }
+  i8(p) {
+    return this.view.getInt8(this.check(p, 1));
+  }
+  u16(p) {
+    return this.view.getUint16(this.check(p, 2));
+  }
+  i16(p) {
+    return this.view.getInt16(this.check(p, 2));
+  }
+  u32(p) {
+    return this.view.getUint32(this.check(p, 4));
+  }
+  i32(p) {
+    return this.view.getInt32(this.check(p, 4));
+  }
+  fixed(p) {
+    return this.i32(p) / 65536;
+  }
+  slice(p, n) {
+    this.check(p, n);
+    return this.data.subarray(p, p + n);
+  }
+  tag(p) {
+    return String.fromCharCode(...this.slice(p, 4));
+  }
+}
+export {
+  Bytes,
+  MAX_FONT,
+  diagnostic,
+  fault
+};

package/modules/fonts/core/opentype/cff.d.ts

@@ -0,0 +1,11 @@
+import { Bytes } from './binary.js';
+import type { Font } from './reader.js';
+export declare function index(b: Bytes, p: number): {
+    items: Uint8Array[];
+    end: number;
+};
+export declare function dict(raw: Uint8Array): Map<number, number[]>;
+/** CFF1 Type 2 charstrings. No library code; operators follow OpenType CFF/Type2. */
+export declare function cffOutline(font: Font, glyph: number, scale: number, x0: number, y0: number, budget?: {
+    remaining: number;
+}): string;

package/modules/fonts/core/opentype/cff.js

@@ -0,0 +1,273 @@
+import { VERBOSE as V } from "../../../../packages/core/src/flags.js";
+import { Bytes, fault } from "./binary.js";
+function index(b, p) {
+  const count = b.u16(p);
+  p += 2;
+  if (!count) return { items: [], end: p };
+  const size = b.u8(p++);
+  if (size < 1 || size > 4) fault(V ? "invalid CFF INDEX offset size" : "");
+  const offset = (i) => {
+    let value = 0;
+    for (let j = 0; j < size; j++) value = value * 256 + b.u8(p + i * size + j);
+    return value;
+  };
+  const base = p + (count + 1) * size - 1, items = [];
+  if (offset(0) !== 1) fault(V ? "invalid CFF first offset" : "");
+  for (let i = 0; i < count; i++) {
+    const a = offset(i), z = offset(i + 1);
+    items.push(b.slice(base + a, z - a));
+  }
+  return { items, end: base + offset(count) };
+}
+function number(b, c, first) {
+  if (first >= 32 && first <= 246) return first - 139;
+  if (first >= 247 && first <= 250) return (first - 247) * 256 + b.u8(c.p++) + 108;
+  if (first >= 251 && first <= 254) return -(first - 251) * 256 - b.u8(c.p++) - 108;
+  if (first === 28) {
+    const v = b.i16(c.p);
+    c.p += 2;
+    return v;
+  }
+  if (first === 29) {
+    const v = b.i32(c.p);
+    c.p += 4;
+    return v;
+  }
+  if (first === 255) {
+    const v = b.i32(c.p) / 65536;
+    c.p += 4;
+    return v;
+  }
+  if (first === 30) {
+    let value = "", end = false;
+    const tokens = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ".", "e", "e-", "", "-", ""];
+    while (!end) {
+      const byte = b.u8(c.p++);
+      for (const n of [byte >> 4, byte & 15]) {
+        if (n === 15) {
+          end = true;
+          break;
+        }
+        value += tokens[n];
+      }
+    }
+    const v = Number(value);
+    if (!Number.isFinite(v)) fault(V ? "invalid CFF real" : "");
+    return v;
+  }
+  return fault(V ? "invalid CFF number" : "");
+}
+function dict(raw) {
+  const b = new Bytes(raw), c = { p: 0 }, out = /* @__PURE__ */ new Map();
+  let stack = [];
+  while (c.p < raw.length) {
+    const op = b.u8(c.p++);
+    if (op >= 28 || op === 30) stack.push(number(b, c, op));
+    else {
+      out.set(op === 12 ? 1200 + b.u8(c.p++) : op, stack);
+      stack = [];
+    }
+    if (stack.length > 96) fault(V ? "CFF dictionary stack limit" : "", "font-limit");
+  }
+  return out;
+}
+const cache = /* @__PURE__ */ new WeakMap();
+function cffData(font) {
+  const source = font.tables.get("CFF ") ?? fault(V ? "missing CFF table" : "");
+  const old = cache.get(font);
+  if (old?.source === source) return old;
+  const b = font.table("CFF ");
+  if (b.u8(0) !== 1) fault(V ? "CFF2 is not supported" : "", "font-unsupported");
+  const names = index(b, b.u8(2)), top = index(b, names.end), strings = index(b, top.end), global = index(b, strings.end);
+  if (top.items.length !== 1) fault(V ? "CFF font sets are not supported" : "", "font-unsupported");
+  const info = dict(top.items[0]), charstrings = index(b, info.get(17)?.[0] ?? fault(V ? "missing CFF CharStrings" : ""));
+  const data = { source, info, charstrings, global, locals: /* @__PURE__ */ new Map() };
+  cache.set(font, data);
+  return data;
+}
+function cffOutline(font, glyph, scale, x0, y0, budget = { remaining: 1e5 }) {
+  const data = cffData(font), { info, charstrings, global } = data, b = font.table("CFF ");
+  if (!charstrings.items[glyph]) fault(V ? "CFF glyph index out of range" : "");
+  let privateInfo = info.get(18), local = [];
+  if (info.has(1230)) {
+    const fds = data.fdArray ??= index(
+      b,
+      info.get(1236)?.[0] ?? fault(V ? "missing CFF FDArray" : "")
+    ).items, select = info.get(1237)?.[0] ?? fault(V ? "missing CFF FDSelect" : "");
+    if (fds.length > 256) fault(V ? "CFF FDArray limit" : "", "font-limit");
+    let fd = -1;
+    if (b.u8(select) === 0) fd = b.u8(select + 1 + glyph);
+    else if (b.u8(select) === 3) {
+      const n = b.u16(select + 1);
+      for (let i = 0; i < n; i++) {
+        if (--budget.remaining < 0) fault(V ? "CFF selection operation limit" : "", "font-limit");
+        const p = select + 3 + i * 3;
+        if (glyph >= b.u16(p) && glyph < (i === n - 1 ? b.u16(select + 3 + n * 3) : b.u16(p + 3)))
+          fd = b.u8(p + 2);
+      }
+    } else fault(V ? "unsupported CFF FDSelect" : "", "font-unsupported");
+    if (!fds[fd]) fault(V ? "invalid CFF FD index" : "");
+    privateInfo = dict(fds[fd]).get(18);
+  }
+  if (privateInfo) {
+    const [len, off] = privateInfo;
+    if (len === void 0 || off === void 0) fault(V ? "invalid CFF private dictionary" : "");
+    const key = off + ":" + len, cached = data.locals.get(key);
+    if (cached) local = cached;
+    else {
+      budget.remaining -= len;
+      if (budget.remaining < 0) fault(V ? "CFF dictionary operation limit" : "", "font-limit");
+      const d = dict(b.slice(off, len));
+      if (d.has(19)) local = index(b, off + d.get(19)[0]).items;
+      data.locals.set(key, local);
+    }
+  }
+  let x = 0, y = 0, path = "", open = false, hints = 0;
+  const stack = [];
+  const pt = (x2, y2) => `${Number((x0 + x2 * scale).toFixed(6))} ${Number((y0 - y2 * scale).toFixed(6))}`;
+  const close = () => {
+    if (open) path += "Z";
+    open = false;
+  };
+  const move = (dx, dy) => {
+    close();
+    x += dx;
+    y += dy;
+    path += "M" + pt(x, y);
+    open = true;
+  };
+  const line = (dx, dy) => {
+    x += dx;
+    y += dy;
+    path += "L" + pt(x, y);
+  };
+  const curve = (a, c, d, e, f, g) => {
+    path += "C" + pt(x + a, y + c) + " " + pt(x + a + d, y + c + e) + " ";
+    x += a + d + f;
+    y += c + e + g;
+    path += pt(x, y);
+  };
+  const execute = (raw, depth) => {
+    if (depth > 16) fault(V ? "CFF subroutine nesting limit" : "", "font-limit");
+    const r = new Bytes(raw), cursor = { p: 0 };
+    while (cursor.p < raw.length) {
+      if (--budget.remaining < 0) fault(V ? "CFF instruction limit" : "", "font-limit");
+      const op = r.u8(cursor.p++);
+      if (op === 28 || op >= 32) {
+        stack.push(number(r, cursor, op));
+        if (stack.length > 96) fault(V ? "CFF operand stack limit" : "", "font-limit");
+        continue;
+      }
+      if (op === 10 || op === 29) {
+        const subrs = op === 10 ? local : global.items, index2 = stack.pop();
+        if (index2 === void 0) fault(V ? "missing CFF subroutine index" : "");
+        const bias = subrs.length < 1240 ? 107 : subrs.length < 33900 ? 1131 : 32768;
+        const sub = subrs[index2 + bias];
+        if (!sub) fault(V ? "invalid CFF subroutine index" : "");
+        execute(sub, depth + 1);
+        continue;
+      }
+      if (op === 11) return;
+      if (op === 1 || op === 3 || op === 18 || op === 23) {
+        if (stack.length % 2) stack.shift();
+        hints += stack.length / 2;
+        stack.length = 0;
+        continue;
+      }
+      if (op === 19 || op === 20) {
+        if (stack.length % 2) stack.shift();
+        hints += stack.length / 2;
+        stack.length = 0;
+        cursor.p += Math.ceil(hints / 8);
+        r.check(cursor.p, 0);
+        continue;
+      }
+      if (op === 14) {
+        if (stack.length > 1)
+          fault(V ? "CFF seac outlines are not supported" : "", "font-unsupported");
+        stack.length = 0;
+        close();
+        return;
+      }
+      if (op === 4 || op === 21 || op === 22) {
+        const n = op === 21 ? 2 : 1;
+        if (stack.length === n + 1) stack.shift();
+        if (stack.length !== n) fault(V ? "invalid CFF moveto" : "");
+        move(op === 4 ? 0 : stack[0], op === 22 ? 0 : stack.at(-1));
+        stack.length = 0;
+        continue;
+      }
+      if (op === 12) {
+        const escape = r.u8(cursor.p++), s2 = stack.splice(0);
+        if (escape === 34 && s2.length === 7) {
+          curve(s2[0], 0, s2[1], s2[2], s2[3], 0);
+          curve(s2[4], 0, s2[5], -s2[2], s2[6], 0);
+        } else if (escape === 35 && s2.length === 13) {
+          curve(...s2.slice(0, 6));
+          curve(...s2.slice(6, 12));
+        } else if (escape === 36 && s2.length === 9) {
+          curve(s2[0], s2[1], s2[2], s2[3], s2[4], 0);
+          curve(s2[5], 0, s2[6], s2[7], s2[8], -s2[1] - s2[3] - s2[7]);
+        } else if (escape === 37 && s2.length === 11) {
+          const dx = s2[0] + s2[2] + s2[4] + s2[6] + s2[8], dy = s2[1] + s2[3] + s2[5] + s2[7] + s2[9];
+          curve(...s2.slice(0, 6));
+          curve(
+            s2[6],
+            s2[7],
+            s2[8],
+            s2[9],
+            Math.abs(dx) > Math.abs(dy) ? s2[10] : -dx,
+            Math.abs(dx) > Math.abs(dy) ? -dy : s2[10]
+          );
+        } else fault("unsupported CFF escaped operator " + escape, "font-unsupported");
+        continue;
+      }
+      const s = stack.splice(0);
+      let p = 0;
+      const take = () => {
+        if (p >= s.length) fault(V ? "invalid CFF operator arity" : "");
+        return s[p++];
+      };
+      if (op === 5) {
+        while (p < s.length) line(take(), take());
+      } else if (op === 6 || op === 7) {
+        let horizontal = op === 6;
+        while (p < s.length) {
+          line(horizontal ? take() : 0, horizontal ? 0 : take());
+          horizontal = !horizontal;
+        }
+      } else if (op === 8) {
+        while (p < s.length) curve(take(), take(), take(), take(), take(), take());
+      } else if (op === 24) {
+        while (s.length - p > 2) curve(take(), take(), take(), take(), take(), take());
+        line(take(), take());
+      } else if (op === 25) {
+        while (s.length - p > 6) line(take(), take());
+        curve(take(), take(), take(), take(), take(), take());
+      } else if (op === 26 || op === 27) {
+        let optional = s.length % 4 ? take() : 0;
+        while (p < s.length) {
+          if (op === 26) curve(optional, take(), take(), take(), 0, take());
+          else curve(take(), optional, take(), take(), take(), 0);
+          optional = 0;
+        }
+      } else if (op === 30 || op === 31) {
+        let horizontal = op === 31;
+        while (p < s.length) {
+          const a = take(), c = take(), d = take(), e = take(), last = s.length - p === 1 ? take() : 0;
+          if (horizontal) curve(a, 0, c, d, last, e);
+          else curve(0, a, c, d, e, last);
+          horizontal = !horizontal;
+        }
+      } else fault("unsupported CFF operator " + op, "font-unsupported");
+    }
+  };
+  execute(charstrings.items[glyph], 0);
+  close();
+  return path;
+}
+export {
+  cffOutline,
+  dict,
+  index
+};

package/modules/fonts/core/opentype/features.d.ts

@@ -0,0 +1,8 @@
+import type { Font } from './reader.js';
+export type ShapedGlyph = {
+    glyph: number;
+    start: number;
+    end: number;
+};
+export declare function featureTags(font: Font): Set<string>;
+export declare function substitute(font: Font, text: string, features?: Record<string, number>): ShapedGlyph[];

package/modules/fonts/core/opentype/features.js

@@ -0,0 +1,103 @@
+import { VERBOSE as V } from "../../../../packages/core/src/flags.js";
+import { fault } from "./binary.js";
+function featureTags(font) {
+  const tags = new Set(font.tables.has("kern") ? ["kern"] : []);
+  for (const table of ["GSUB", "GPOS"]) {
+    if (!font.tables.has(table)) continue;
+    const b = font.table(table), list = b.u16(6);
+    for (let i = 0; i < b.u16(list); i++) tags.add(b.tag(list + 2 + i * 6));
+  }
+  return tags;
+}
+function coverage(b, at, glyph) {
+  const kind = b.u16(at), n = b.u16(at + 2);
+  for (let i = 0; i < n; i++) {
+    if (kind === 1) {
+      if (b.u16(at + 4 + i * 2) === glyph) return i;
+    } else if (kind === 2) {
+      const p = at + 4 + i * 6, lo = b.u16(p), hi = b.u16(p + 2);
+      if (glyph >= lo && glyph <= hi) return b.u16(p + 4) + glyph - lo;
+    } else fault(V ? "unsupported GSUB coverage" : "", "font-unsupported");
+  }
+  return -1;
+}
+function substitute(font, text, features = {}) {
+  let offset = 0;
+  const glyphs = [...text].map((char) => {
+    const start = offset;
+    offset += char.length;
+    return { glyph: font.glyph(char.codePointAt(0)), start, end: offset };
+  });
+  if (!font.tables.has("GSUB")) return glyphs;
+  const b = font.table("GSUB"), list = b.u16(8), f = b.u16(6), selected = /* @__PURE__ */ new Map();
+  for (let i = 0; i < b.u16(f); i++) {
+    const p = f + 2 + i * 6, tag = b.tag(p);
+    const value = features[tag] ?? (["ccmp", "locl", "rlig", "liga", "clig"].includes(tag) ? 1 : 0);
+    if (!value) continue;
+    const entry = f + b.u16(p + 4);
+    for (let j = 0; j < b.u16(entry + 2); j++) selected.set(b.u16(entry + 4 + j * 2), value);
+  }
+  for (const [index, value] of [...selected].sort(([a], [c]) => a - c)) {
+    if (index >= b.u16(list)) fault(V ? "invalid GSUB lookup index" : "");
+    const lookup = list + b.u16(list + 2 + index * 2), type = b.u16(lookup);
+    if (b.u16(lookup + 2))
+      fault(
+        V ? "GSUB lookup flags need complex shaping; use --browser-text" : "",
+        "font-unsupported"
+      );
+    for (let i = 0; i < glyphs.length; i++) {
+      for (let j = 0; j < b.u16(lookup + 4); j++) {
+        let p = lookup + b.u16(lookup + 6 + j * 2), kind = type;
+        if (kind === 7) {
+          if (b.u16(p) !== 1) fault(V ? "invalid GSUB extension" : "");
+          kind = b.u16(p + 2);
+          p += b.u32(p + 4);
+        }
+        if (![1, 3, 4].includes(kind))
+          fault(
+            V ? "GSUB lookup needs contextual shaping; use --browser-text" : "",
+            "font-unsupported"
+          );
+        const format = b.u16(p), ci = coverage(b, p + b.u16(p + 2), glyphs[i].glyph);
+        if (ci < 0) continue;
+        if (kind === 1) {
+          if (format === 1) glyphs[i].glyph = glyphs[i].glyph + b.i16(p + 4) & 65535;
+          else if (format === 2 && ci < b.u16(p + 4)) glyphs[i].glyph = b.u16(p + 6 + ci * 2);
+          else fault(V ? "invalid GSUB single substitution" : "");
+        } else {
+          if (format !== 1 || ci >= b.u16(p + 4)) fault(V ? "invalid GSUB set index" : "");
+          const set = p + b.u16(p + 6 + ci * 2), count = b.u16(set);
+          if (kind === 3) {
+            if (value <= count) glyphs[i].glyph = b.u16(set + value * 2);
+          } else {
+            let matched = false;
+            for (let k = 0; k < count; k++) {
+              const lig = set + b.u16(set + 2 + k * 2), n = b.u16(lig + 2);
+              if (n < 2) fault(V ? "invalid GSUB ligature component count" : "");
+              if (i + n > glyphs.length) continue;
+              let same = true;
+              for (let c = 1; c < n; c++)
+                if (glyphs[i + c].glyph !== b.u16(lig + 2 + c * 2)) same = false;
+              if (!same) continue;
+              glyphs.splice(i, n, {
+                glyph: b.u16(lig),
+                start: glyphs[i].start,
+                end: glyphs[i + n - 1].end
+              });
+              matched = true;
+              break;
+            }
+            if (!matched) continue;
+          }
+        }
+        if (glyphs[i].glyph >= font.glyphCount) fault(V ? "GSUB glyph index out of range" : "");
+        break;
+      }
+    }
+  }
+  return glyphs;
+}
+export {
+  featureTags,
+  substitute
+};