@mark1russell7/typeset 0.1.1 → 0.1.2

package/src/fonts/joining.ts

@@ -0,0 +1,141 @@
+/**
+ * The joining of the Arabic shaper. This module follows `hb-ot-shaper-arabic.cc` of HarfBuzz. It has the joining types of
+ * the characters and the state machine that gives the form of each letter. It also has the order of the GSUB features.
+ * The table of the joining types comes from `ArabicShaping.txt` of the Unicode Character Database, version 18.0.0.
+ * It covers the Arabic, Syriac, NKo and Mandaic blocks, with their supplements and extensions.
+ */
+
+/** The joining form of a letter, as the tag of the GSUB feature that makes it. */
+export type JoiningForm = "isol" | "fina" | "fin2" | "fin3" | "medi" | "med2" | "init";
+
+/** The forms in the order of the features of the shaper. The index of a form gives its bit in a feature mask. */
+export const joiningFeatures: readonly JoiningForm[] = ["isol", "fina", "fin2", "fin3", "medi", "med2", "init"];
+
+/** The OpenType script tags that use the joining of the Arabic shaper in this model. */
+export const joiningScripts: readonly string[] = ["arab", "syrc"];
+
+// The columns of the state machine of HarfBuzz: the joining types U, L, R and D (C is D), and the Syriac joining groups.
+// The type L is the column 1. No character of these blocks has the type L.
+const U = 0;
+const R = 2;
+const D = 3;
+const ALAPH = 4;
+const DALATH_RISH = 5;
+/** The joining type T: a transparent character, for example a mark. The state machine does not see it. */
+const T = 6;
+
+/**
+ * The joining types of `ArabicShaping.txt`. Each triple has the first code point, the last code point and the type.
+ * The type `C` (join causing) is `D` here, as in HarfBuzz. A code point that is not in the table has the type `U`.
+ * When its general category is `Mn`, `Me` or `Cf`, it has the type `T`.
+ */
+const joiningTable: readonly number[] = [
+  0x600, 0x605, U, 0x608, 0x608, U, 0x60b, 0x60b, U, 0x620, 0x620, D, 0x621, 0x621, U, 0x622, 0x625, R, 0x626, 0x626, D,
+  0x627, 0x627, R, 0x628, 0x628, D, 0x629, 0x629, R, 0x62a, 0x62e, D, 0x62f, 0x632, R, 0x633, 0x63f, D, 0x640, 0x640, D,
+  0x641, 0x647, D, 0x648, 0x648, R, 0x649, 0x64a, D, 0x66e, 0x66f, D, 0x671, 0x673, R, 0x674, 0x674, U, 0x675, 0x677, R,
+  0x678, 0x687, D, 0x688, 0x699, R, 0x69a, 0x6bf, D, 0x6c0, 0x6c0, R, 0x6c1, 0x6c2, D, 0x6c3, 0x6cb, R, 0x6cc, 0x6cc, D,
+  0x6cd, 0x6cd, R, 0x6ce, 0x6ce, D, 0x6cf, 0x6cf, R, 0x6d0, 0x6d1, D, 0x6d2, 0x6d3, R, 0x6d5, 0x6d5, R, 0x6dd, 0x6dd, U,
+  0x6ee, 0x6ef, R, 0x6fa, 0x6fc, D, 0x6ff, 0x6ff, D, 0x70f, 0x70f, T, 0x710, 0x710, ALAPH, 0x712, 0x714, D,
+  0x715, 0x716, DALATH_RISH, 0x717, 0x719, R, 0x71a, 0x71d, D, 0x71e, 0x71e, R, 0x71f, 0x727, D, 0x728, 0x728, R,
+  0x729, 0x729, D, 0x72a, 0x72a, DALATH_RISH, 0x72b, 0x72b, D, 0x72c, 0x72c, R, 0x72d, 0x72e, D, 0x72f, 0x72f, DALATH_RISH,
+  0x74d, 0x74d, R, 0x74e, 0x758, D, 0x759, 0x75b, R, 0x75c, 0x76a, D, 0x76b, 0x76c, R, 0x76d, 0x770, D, 0x771, 0x771, R,
+  0x772, 0x772, D, 0x773, 0x774, R, 0x775, 0x777, D, 0x778, 0x779, R, 0x77a, 0x77f, D, 0x7ca, 0x7ea, D, 0x7fa, 0x7fa, D,
+  0x840, 0x840, R, 0x841, 0x845, D, 0x846, 0x847, R, 0x848, 0x848, D, 0x849, 0x849, R, 0x84a, 0x853, D, 0x854, 0x854, R,
+  0x855, 0x855, D, 0x856, 0x858, R, 0x860, 0x860, D, 0x861, 0x861, U, 0x862, 0x865, D, 0x866, 0x866, U, 0x867, 0x867, R,
+  0x868, 0x868, D, 0x869, 0x86a, R, 0x870, 0x882, R, 0x883, 0x885, D, 0x886, 0x886, D, 0x887, 0x888, U, 0x889, 0x88d, D,
+  0x88e, 0x88e, R, 0x88f, 0x88f, D, 0x890, 0x891, U, 0x8a0, 0x8a9, D, 0x8aa, 0x8ac, R, 0x8ad, 0x8ad, U, 0x8ae, 0x8ae, R,
+  0x8af, 0x8b0, D, 0x8b1, 0x8b2, R, 0x8b3, 0x8b8, D, 0x8b9, 0x8b9, R, 0x8ba, 0x8c8, D, 0x8e2, 0x8e2, U, 0x200c, 0x200c, U,
+  0x200d, 0x200d, D,
+];
+
+const transparent = /[\p{Mn}\p{Me}\p{Cf}]/u;
+
+/** This function gives the joining type of a code point: a column of the state machine, or `T`. */
+function joiningType(codePoint: number): number {
+  let low = 0;
+  let high = joiningTable.length / 3 - 1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    if (codePoint < joiningTable[middle * 3]!) high = middle - 1;
+    else if (codePoint > joiningTable[middle * 3 + 1]!) low = middle + 1;
+    else return joiningTable[middle * 3 + 2]!;
+  }
+  return transparent.test(String.fromCodePoint(codePoint)) ? T : U;
+}
+
+// The actions of the state machine: the index of a form in `joiningFeatures`, or NONE
+const ISOL = 0;
+const FINA = 1;
+const FIN2 = 2;
+const FIN3 = 3;
+const MEDI = 4;
+const MED2 = 5;
+const INIT = 6;
+const NONE = 7;
+
+/**
+ * The state machine of `arabic_state_table` of HarfBuzz. Each row is a state, with one entry for each column. An entry
+ * has the action for the previous letter, the action for the current letter and the next state.
+ */
+const states: readonly (readonly (readonly [number, number, number])[])[] = [
+  // State 0: the previous letter was U, and it does not join
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [NONE, ISOL, 1], [NONE, ISOL, 2], [NONE, ISOL, 1], [NONE, ISOL, 6]],
+  // State 1: the previous letter was R, or ISOL ALAPH, and it does not join
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [NONE, ISOL, 1], [NONE, ISOL, 2], [NONE, FIN2, 5], [NONE, ISOL, 6]],
+  // State 2: the previous letter was D or L in the form ISOL, and it can join
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [INIT, FINA, 1], [INIT, FINA, 3], [INIT, FINA, 4], [INIT, FINA, 6]],
+  // State 3: the previous letter was D in the form FINA, and it can join
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [MEDI, FINA, 1], [MEDI, FINA, 3], [MEDI, FINA, 4], [MEDI, FINA, 6]],
+  // State 4: the previous letter was FINA ALAPH, and it does not join
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [MED2, ISOL, 1], [MED2, ISOL, 2], [MED2, FIN2, 5], [MED2, ISOL, 6]],
+  // State 5: the previous letter was FIN2 or FIN3 ALAPH, and it does not join
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [ISOL, ISOL, 1], [ISOL, ISOL, 2], [ISOL, FIN2, 5], [ISOL, ISOL, 6]],
+  // State 6: the previous letter was DALATH or RISH, and it does not join
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [NONE, ISOL, 1], [NONE, ISOL, 2], [NONE, FIN3, 5], [NONE, ISOL, 6]],
+];
+
+/**
+ * This function gives the joining form of each code point of a text, in logical order. A transparent character, for
+ * example a mark, and a character that does not join get `undefined`. The text before and after the code points is not
+ * known, so the function sees it as a character of the type U.
+ */
+export function joiningForms(codePoints: readonly number[]): (JoiningForm | undefined)[] {
+  const actions: number[] = codePoints.map(() => NONE);
+  let previous = -1;
+  let state = 0;
+  codePoints.forEach((codePoint, i) => {
+    const type = joiningType(codePoint);
+    if (type === T) return;
+    const [previousAction, currentAction, next] = states[state]![type]!;
+    if (previousAction !== NONE && previous >= 0) actions[previous] = previousAction;
+    actions[i] = currentAction;
+    previous = i;
+    state = next;
+  });
+  return actions.map((action) => joiningFeatures[action]);
+}
+
+/**
+ * One stage of the GSUB features of the Arabic shaper. The lookups of one stage go in the order of the lookup list.
+ * A stage with a `form` applies only to the glyphs of that joining form.
+ */
+export interface JoiningStage {
+  readonly features: readonly string[];
+  readonly form?: JoiningForm;
+}
+
+/**
+ * This function gives the stages of the Arabic shaper of HarfBuzz for a list of features. The stages are `ccmp` and
+ * `locl`, then each joining form alone, then `rlig`, then `calt`, then the other features. When the font has `rclt`,
+ * `calt` and the other features are one stage, as in HarfBuzz. The list `features` gives the features apart from the
+ * joining forms, so a feature that is not in the list is not in a stage.
+ */
+export function joiningStages(features: readonly string[], hasRclt: boolean): JoiningStage[] {
+  const take = (tags: readonly string[]) => features.filter((tag) => tags.includes(tag));
+  const first = ["ccmp", "locl"];
+  const rest = features.filter((tag) => !first.includes(tag) && tag !== "rlig" && (hasRclt || tag !== "calt"));
+  const stages: JoiningStage[] = [{ features: take(first) }, ...joiningFeatures.map((form) => ({ features: [form], form })), { features: take(["rlig"]) }];
+  if (!hasRclt) stages.push({ features: take(["calt"]) });
+  stages.push({ features: rest });
+  return stages.filter((stage) => stage.features.length > 0);
+}

package/src/fonts/kerning.ts

@@ -0,0 +1,217 @@
+import type { Reader } from "./binary.ts";
+import type { GlyphFilter } from "./substitution.ts";
+import { classOf, coverageIndex } from "./tables.ts";
+import type { VariationStore } from "./variations.ts";
+
+/** The change of the advances of two glyphs, in font units. A variable font can give a value that is not a whole number. */
+export interface PairValue {
+  readonly first: number;
+  readonly second: number;
+  /** The part of `first` that comes from a VariationIndex table. HarfBuzz scales this part and the rest in different ways. */
+  readonly firstDelta?: number;
+  /** The part of `second` that comes from a VariationIndex table. */
+  readonly secondDelta?: number;
+  /** It is true when the subtable has a value for the second glyph. Then the next pair starts after the second glyph. */
+  readonly skipSecond: boolean;
+}
+
+/** A lookup of pair adjustments, with the flags that tell which glyphs it skips. */
+export interface PairLookup {
+  readonly flags: number;
+  /**
+   * This function tells if the lookup skips a glyph, when the lookup uses a mark filtering set. Then the lookup skips each
+   * mark that is not in the set. Without the function, the flags alone tell which glyphs the lookup skips.
+   */
+  readonly skip?: (glyph: number) => boolean;
+  /** This function gives the value for a pair, or `undefined` when no subtable applies. */
+  pair(first: number, second: number): PairValue | undefined;
+}
+
+/** The lookup flags of OpenType. */
+export const IGNORE_BASE = 0x2;
+export const IGNORE_LIGATURES = 0x4;
+export const IGNORE_MARKS = 0x8;
+
+/** This function gives the size in bytes of a ValueRecord of the format `format`. */
+function valueSize(format: number): number {
+  let bits = format & 0xff;
+  let size = 0;
+  while (bits !== 0) {
+    size += bits & 1;
+    bits >>= 1;
+  }
+  return size * 2;
+}
+
+/**
+ * This function gives the XAdvance of a ValueRecord at `offset`, or 0 when the format has none. The offset of a device table
+ * is relative to `parent`. A VariationIndex table adds its delta from `store`, not rounded, as HarfBuzz adds it. A device
+ * table of hinting deltas adds nothing, because the shaper of the browser does not set a ppem.
+ */
+function xAdvance(table: Reader, offset: number, format: number, parent: Reader, store: VariationStore | undefined): { value: number; delta: number } {
+  const value = (format & 0x4) === 0 ? 0 : table.i16(offset + valueSize(format & 0x3));
+  let delta = 0;
+  if ((format & 0x40) !== 0 && store !== undefined) {
+    const device = table.u16(offset + valueSize(format & 0x3f));
+    if (device !== 0 && parent.u16(device + 4) === 0x8000) delta = store.delta(parent.u16(device), parent.u16(device + 2));
+  }
+  return { value: value + delta, delta };
+}
+
+/** This function makes the value of a pair from the XAdvance of its two glyphs. */
+function pairValue(first: { value: number; delta: number }, second: { value: number; delta: number }, skipSecond: boolean): PairValue {
+  return { first: first.value, second: second.value, firstDelta: first.delta, secondDelta: second.delta, skipSecond };
+}
+
+/** This function makes the pair function of one PairPos subtable. */
+function pairSubtable(table: Reader, store: VariationStore | undefined): (first: number, second: number) => PairValue | undefined {
+  const format = table.u16(0);
+  const coverage = table.part(table.u16(2));
+  const format1 = table.u16(4);
+  const format2 = table.u16(6);
+  const size1 = valueSize(format1);
+  const size2 = valueSize(format2);
+  const skipSecond = format2 !== 0;
+  if (format === 1) {
+    return (first, second) => {
+      const index = coverageIndex(coverage, first);
+      if (index < 0) return undefined;
+      const set = table.part(table.u16(10 + index * 2));
+      const recordSize = 2 + size1 + size2;
+      let low = 0;
+      let high = set.u16(0) - 1;
+      while (low <= high) {
+        const middle = (low + high) >> 1;
+        const at = 2 + middle * recordSize;
+        const glyph = set.u16(at);
+        if (second < glyph) high = middle - 1;
+        else if (second > glyph) low = middle + 1;
+        else return pairValue(xAdvance(set, at + 2, format1, set, store), xAdvance(set, at + 2 + size1, format2, set, store), skipSecond);
+      }
+      return undefined;
+    };
+  }
+  if (format === 2) {
+    const classes1 = table.part(table.u16(8));
+    const classes2 = table.part(table.u16(10));
+    const count1 = table.u16(12);
+    const count2 = table.u16(14);
+    return (first, second) => {
+      if (coverageIndex(coverage, first) < 0) return undefined;
+      const class1 = classOf(classes1, first);
+      const class2 = classOf(classes2, second);
+      if (class1 >= count1 || class2 >= count2) return undefined;
+      const at = 16 + (class1 * count2 + class2) * (size1 + size2);
+      return pairValue(xAdvance(table, at, format1, table, store), xAdvance(table, at + size1, format2, table, store), skipSecond);
+    };
+  }
+  throw new Error(`the PairPos format ${format} is unknown`);
+}
+
+/** This function gives the tags of the scripts to try, in order, for a script tag, as HarfBuzz tries them. */
+export function scriptTags(script: string): string[] {
+  const tags = script === "deva" ? ["dev2", "deva"] : [script];
+  return [...tags, "DFLT", "dflt", "latn"];
+}
+
+/** The GPOS features with pair lookups that HarfBuzz applies to horizontal text. */
+const pairFeatures = new Set(["kern", "dist"]);
+
+/** The lookup flag that selects a mark filtering set of GDEF. */
+const USE_MARK_FILTERING_SET = 0x10;
+
+/**
+ * This function gives the pair lookups of the features `kern` and `dist` of GPOS for a script, in the order of the lookup
+ * list. The store gives the deltas of a variable font at its instance. The filter gives the mark filtering sets of GDEF.
+ */
+export function readGposKerning(gpos: Reader, script: string, store?: VariationStore, filter?: GlyphFilter): PairLookup[] {
+  const scripts = gpos.part(gpos.u16(4));
+  const features = gpos.part(gpos.u16(6));
+  const lookups = gpos.part(gpos.u16(8));
+  const scriptCount = scripts.u16(0);
+  let langSys: Reader | undefined;
+  for (const wanted of scriptTags(script)) {
+    for (let i = 0; i < scriptCount && langSys === undefined; i++) {
+      if (scripts.tag(2 + i * 6) !== wanted) continue;
+      const table = scripts.part(scripts.u16(2 + i * 6 + 4));
+      const fallback = table.u16(0);
+      if (fallback !== 0) langSys = table.part(fallback);
+    }
+    if (langSys !== undefined) break;
+  }
+  if (langSys === undefined) return [];
+  const indices = new Set<number>();
+  const featureCount = langSys.u16(4);
+  for (let i = 0; i < featureCount; i++) {
+    const record = 2 + langSys.u16(6 + i * 2) * 6;
+    if (!pairFeatures.has(features.tag(record))) continue;
+    const feature = features.part(features.u16(record + 4));
+    for (let k = 0; k < feature.u16(2); k++) indices.add(feature.u16(4 + k * 2));
+  }
+  return [...indices].sort((a, b) => a - b).flatMap((index) => {
+    const lookup = lookups.part(lookups.u16(2 + index * 2));
+    const subtables: ((first: number, second: number) => PairValue | undefined)[] = [];
+    const type = lookup.u16(0);
+    for (let s = 0; s < lookup.u16(4); s++) {
+      let subtable = lookup.part(lookup.u16(6 + s * 2));
+      let subtype = type;
+      if (type === 9) {
+        subtype = subtable.u16(2);
+        subtable = subtable.part(subtable.u32(4));
+      }
+      if (subtype === 2) subtables.push(pairSubtable(subtable, store));
+    }
+    if (subtables.length === 0) return [];
+    const flags = lookup.u16(2);
+    const markSet = (flags & USE_MARK_FILTERING_SET) !== 0 && filter !== undefined ? lookup.u16(6 + lookup.u16(4) * 2) : -1;
+    const skip = markSet < 0 ? undefined : (glyph: number): boolean => {
+      const kind = filter!.glyphClass(glyph);
+      if ((flags & IGNORE_BASE) !== 0 && kind === 1) return true;
+      if ((flags & IGNORE_LIGATURES) !== 0 && kind === 2) return true;
+      if (kind !== 3) return false;
+      return (flags & IGNORE_MARKS) !== 0 || !filter!.inMarkSet(markSet, glyph);
+    };
+    return [{
+      flags,
+      ...(skip === undefined ? {} : { skip }),
+      pair(first: number, second: number): PairValue | undefined {
+        for (const subtable of subtables) {
+          const value = subtable(first, second);
+          if (value !== undefined) return value;
+        }
+        return undefined;
+      },
+    }];
+  });
+}
+
+/** This function gives the pairs of format 0 of the `kern` table, as one lookup. */
+export function readKernTable(kern: Reader): PairLookup[] {
+  // Only the version 0 of Microsoft. The version 1 of Apple starts with the 32-bit number 0x00010000
+  if (kern.u16(0) !== 0) return [];
+  const pairs = new Map<number, number>();
+  const count = kern.u16(2);
+  let offset = 4;
+  for (let t = 0; t < count; t++) {
+    const length = kern.u16(offset + 2);
+    const coverage = kern.u16(offset + 4);
+    // Only the horizontal kerning of format 0, with no minimum values and no cross-stream values
+    if ((coverage & 0xff07) === 0x0001) {
+      const n = kern.u16(offset + 6);
+      for (let i = 0; i < n; i++) {
+        const at = offset + 14 + i * 6;
+        const key = kern.u16(at) * 0x10000 + kern.u16(at + 2);
+        pairs.set(key, (pairs.get(key) ?? 0) + kern.i16(at + 4));
+      }
+    }
+    offset += length;
+  }
+  if (pairs.size === 0) return [];
+  return [{
+    flags: 0,
+    pair(first: number, second: number): PairValue | undefined {
+      const value = pairs.get(first * 0x10000 + second);
+      return value === undefined ? undefined : { first: value, second: 0, skipSecond: false };
+    },
+  }];
+}

package/src/fonts/sfnt.ts

@@ -0,0 +1,102 @@
+import { Reader } from "./binary.ts";
+
+/** A function that decompresses Brotli data. Node gives one as `brotliDecompressSync` of `node:zlib`. */
+export type Decompress = (data: Uint8Array) => Uint8Array;
+
+/** The tables of a font, by tag. A table that the decoder does not need can be absent. */
+export type TableMap = ReadonlyMap<string, Reader>;
+
+/** The tags of the WOFF2 table directory, in the order of the WOFF2 specification. */
+const knownTags = [
+  "cmap", "head", "hhea", "hmtx", "maxp", "name", "OS/2", "post", "cvt ", "fpgm", "glyf", "loca", "prep", "CFF ", "VORG", "EBDT",
+  "EBLC", "gasp", "hdmx", "kern", "LTSH", "PCLT", "VDMX", "vhea", "vmtx", "BASE", "GDEF", "GPOS", "GSUB", "EBSC", "JSTF", "MATH",
+  "CBDT", "CBLC", "COLR", "CPAL", "SVG ", "sbix", "acnt", "avar", "bdat", "bloc", "bsln", "cvar", "fdsc", "feat", "fmtx", "fvar",
+  "gvar", "hsty", "just", "lcar", "mort", "morx", "opbd", "prop", "trak", "Zapf", "Silf", "Glat", "Gloc", "Feat", "Sill",
+] as const;
+
+/** This function gives the tables of a TrueType, OpenType or WOFF2 file. */
+export function readTables(bytes: Uint8Array, decompress?: Decompress): TableMap {
+  const file = new Reader(bytes);
+  if (file.length < 12) throw new RangeError("the file is too short for a font");
+  const signature = file.tag(0);
+  if (signature === "wOF2") {
+    if (decompress === undefined) throw new Error("a WOFF2 file needs a Brotli decompress function");
+    return readWoff2(file, decompress);
+  }
+  if (signature === "wOFF") throw new Error("WOFF 1 files are not supported");
+  if (signature === "ttcf") throw new Error("font collections are not supported");
+  if (file.u32(0) !== 0x00010000 && signature !== "OTTO" && signature !== "true") throw new Error(`the signature ${JSON.stringify(signature)} is not a font`);
+  const tables = new Map<string, Reader>();
+  const count = file.u16(4);
+  for (let i = 0; i < count; i++) {
+    const record = 12 + i * 16;
+    tables.set(file.tag(record), file.part(file.u32(record + 8), file.u32(record + 12)));
+  }
+  return tables;
+}
+
+/** This function reads a UIntBase128 number of WOFF2 and gives the number and the next offset. */
+function base128(file: Reader, offset: number): [value: number, next: number] {
+  let value = 0;
+  for (let i = 0; i < 5; i++) {
+    const byte = file.u8(offset + i);
+    if (i === 0 && byte === 0x80) throw new RangeError("a UIntBase128 has a leading zero");
+    value = value * 128 + (byte & 0x7f);
+    if ((byte & 0x80) === 0) return [value, offset + i + 1];
+  }
+  throw new RangeError("a UIntBase128 is longer than 5 bytes");
+}
+
+/**
+ * This function gives the tables of a WOFF2 file. The `glyf` and `loca` tables stay in their transformed form,
+ * because the width does not use them. A transformed `hmtx` table becomes a plain table again.
+ */
+function readWoff2(file: Reader, decompress: Decompress): TableMap {
+  const flavor = file.u32(4);
+  if (flavor === 0x74746366) throw new Error("WOFF2 font collections are not supported");
+  const count = file.u16(12);
+  const compressedLength = file.u32(20);
+  let offset = 48;
+  const entries: { tag: string; length: number; transformed: boolean }[] = [];
+  for (let i = 0; i < count; i++) {
+    const flags = file.u8(offset++);
+    let tag: string;
+    if ((flags & 0x3f) === 0x3f) {
+      tag = file.tag(offset);
+      offset += 4;
+    } else {
+      const known = knownTags[flags & 0x3f];
+      if (known === undefined) throw new RangeError(`the WOFF2 tag index ${flags & 0x3f} is unknown`);
+      tag = known;
+    }
+    const version = (flags >> 6) & 3;
+    let length: number;
+    [length, offset] = base128(file, offset);
+    // For glyf and loca, the version 0 is the transform. For the other tables, each version other than 0 is a transform
+    const transformed = tag === "glyf" || tag === "loca" ? version === 0 : version !== 0;
+    if (transformed) [length, offset] = base128(file, offset);
+    entries.push({ tag, length, transformed });
+  }
+  const data = new Reader(decompress(file.bytes.subarray(offset, offset + compressedLength)));
+  const tables = new Map<string, Reader>();
+  let at = 0;
+  for (const entry of entries) {
+    tables.set(entry.tag, data.part(at, entry.length));
+    at += entry.length;
+  }
+  const hmtx = entries.find((entry) => entry.tag === "hmtx");
+  if (hmtx?.transformed === true) tables.set("hmtx", untransformHmtx(tables));
+  return tables;
+}
+
+/** This function gives a plain `hmtx` table from the transform of WOFF2. Only the advances matter, so each side bearing is 0. */
+function untransformHmtx(tables: Map<string, Reader>): Reader {
+  const source = tables.get("hmtx")!;
+  const hhea = tables.get("hhea");
+  if (hhea === undefined) throw new Error("a transformed hmtx needs hhea");
+  const metrics = hhea.u16(34);
+  const plain = new Uint8Array(metrics * 4);
+  const view = new DataView(plain.buffer);
+  for (let i = 0; i < metrics; i++) view.setUint16(i * 4, source.u16(1 + i * 2));
+  return new Reader(plain);
+}