@flighthq/font-formats 0.3.1-next.1041.35b950c

package/src/openTypeMetrics.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  readOpenTypeAdvances,
+  readOpenTypeGlyphCount,
+  readOpenTypeLocaFormat,
+  readOpenTypeMetrics,
+} from './openTypeMetrics';
+import { createSyntheticFont, emptySyntheticGlyph, squareSyntheticGlyph } from './openTypeTestHelper';
+import { readSfntTableDirectory } from './sfntTableDirectory';
+
+describe('readOpenTypeAdvances', () => {
+  it('reads one advance per glyph', () => {
+    const font = createSyntheticFont({
+      advances: [300, 750],
+      glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(10)],
+    });
+    expect([...readOpenTypeAdvances(font, readSfntTableDirectory(font)!, 2)!]).toEqual([300, 750]);
+  });
+
+  // `hmtx` is run-length shaped: glyphs past `numberOfHMetrics` repeat the last stated advance. Reading
+  // it flat gives every one of them a wrong width, which is exactly how monospaced and CJK fonts stay
+  // small — so the bug would be invisible on a Latin test font and wrong on the fonts that use it.
+  it('repeats the last stated advance past the long-metric count rather than reading zero', () => {
+    const font = createSyntheticFont({
+      advances: [600],
+      glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(10), squareSyntheticGlyph(20)],
+    });
+    expect([...readOpenTypeAdvances(font, readSfntTableDirectory(font)!, 3)!]).toEqual([600, 600, 600]);
+  });
+
+  it('returns the sentinel when hmtx or hhea is absent', () => {
+    for (const table of ['hmtx', 'hhea']) {
+      const font = createSyntheticFont({ omitTable: table });
+      expect(readOpenTypeAdvances(font, readSfntTableDirectory(font)!, 1)).toBeNull();
+    }
+  });
+});
+
+describe('readOpenTypeGlyphCount', () => {
+  it('reads the count maxp declares', () => {
+    const font = createSyntheticFont({ glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(10)] });
+    expect(readOpenTypeGlyphCount(font, readSfntTableDirectory(font)!)).toBe(2);
+  });
+
+  it('returns -1 rather than a count when maxp is absent, so every index is out of range', () => {
+    const font = createSyntheticFont({ omitTable: 'maxp' });
+    expect(readOpenTypeGlyphCount(font, readSfntTableDirectory(font)!)).toBe(-1);
+  });
+});
+
+describe('readOpenTypeLocaFormat', () => {
+  it('reads the index-to-loc format head declares', () => {
+    const font = createSyntheticFont();
+    expect(readOpenTypeLocaFormat(font, readSfntTableDirectory(font)!)).toBe(1);
+  });
+
+  it('returns -1 for a value that is neither of the two the format defines', () => {
+    const font = createSyntheticFont();
+    const directory = readSfntTableDirectory(font)!;
+    // Guessing here would produce plausible garbage outlines instead of a clean rejection.
+    new DataView(font.buffer).setInt16(directory.tables.get('head')!.offset + 50, 7);
+    expect(readOpenTypeLocaFormat(font, directory)).toBe(-1);
+  });
+
+  it('returns -1 when head is absent', () => {
+    const font = createSyntheticFont({ omitTable: 'head' });
+    expect(readOpenTypeLocaFormat(font, readSfntTableDirectory(font)!)).toBe(-1);
+  });
+});
+
+describe('readOpenTypeMetrics', () => {
+  it('reads the design-unit scale from head', () => {
+    const font = createSyntheticFont({ unitsPerEm: 2048 });
+    expect(readOpenTypeMetrics(font, readSfntTableDirectory(font)!)?.unitsPerEm).toBe(2048);
+  });
+
+  // `hhea` states descender as a negative distance; `GlyphOutlineMetrics` documents both ascent and
+  // descent as POSITIVE distances from the baseline. The flip happens once, here, at the seam.
+  it('reports descent as a positive distance although the table stores it negative', () => {
+    const font = createSyntheticFont();
+    expect(readOpenTypeMetrics(font, readSfntTableDirectory(font)!)).toEqual({
+      ascent: 800,
+      descent: 200,
+      lineGap: 100,
+      unitsPerEm: 1000,
+    });
+  });
+
+  it('returns the sentinel for a zero unitsPerEm rather than a scale that divides by zero', () => {
+    const font = createSyntheticFont();
+    const directory = readSfntTableDirectory(font)!;
+    new DataView(font.buffer).setUint16(directory.tables.get('head')!.offset + 18, 0);
+    expect(readOpenTypeMetrics(font, directory)).toBeNull();
+  });
+
+  it('returns the sentinel when head or hhea is absent', () => {
+    for (const table of ['head', 'hhea']) {
+      const font = createSyntheticFont({ omitTable: table });
+      expect(readOpenTypeMetrics(font, readSfntTableDirectory(font)!)).toBeNull();
+    }
+  });
+});

package/src/sfntAssembly.test.ts

@@ -0,0 +1,228 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  assembleSfntFont,
+  computeSfntTableChecksum,
+  encodeSfntCompositeGlyph,
+  encodeSfntLoca,
+  encodeSfntSimpleGlyph,
+  packSfntTag,
+} from './sfntAssembly';
+
+describe('assembleSfntFont', () => {
+  it('writes the directory in tag order whatever order it was given', () => {
+    // Reversed on purpose. A pre-sorted input would pass whether or not anything sorted, which is how
+    // the WOFF tag-order test was once vacuous.
+    const font = assembleSfntFont(0x00010000, [
+      { data: Uint8Array.from([9]), tag: packSfntTag('name') },
+      { data: Uint8Array.from([7]), tag: packSfntTag('head') },
+      { data: Uint8Array.from([8]), tag: packSfntTag('cmap') },
+    ]);
+    const view = new DataView(font.buffer);
+    const tags = Array.from({ length: view.getUint16(4) }, (_, index) => view.getUint32(12 + index * 16));
+    expect(tags).toEqual([packSfntTag('cmap'), packSfntTag('head'), packSfntTag('name')]);
+  });
+
+  it('starts every table on a four-byte boundary', () => {
+    // Lengths chosen so that unpadded placement would land tables at odd offsets — without this the
+    // assertion would hold whether or not any padding ran.
+    const font = assembleSfntFont(0x00010000, [
+      { data: Uint8Array.from([1]), tag: packSfntTag('aaaa') },
+      { data: Uint8Array.from([2, 3, 4]), tag: packSfntTag('bbbb') },
+      { data: Uint8Array.from([5, 6]), tag: packSfntTag('cccc') },
+    ]);
+    const view = new DataView(font.buffer);
+    const count = view.getUint16(4);
+    const offsets = Array.from({ length: count }, (_, index) => view.getUint32(12 + index * 16 + 8));
+    expect(offsets.filter((offset) => offset % 4 !== 0)).toEqual([]);
+  });
+
+  it('preserves each table byte for byte at its declared offset and length', () => {
+    const payload = Uint8Array.from([11, 22, 33, 44, 55]);
+    const font = assembleSfntFont(0x4f54544f, [{ data: payload, tag: packSfntTag('CFF ') }]);
+    const view = new DataView(font.buffer);
+    const offset = view.getUint32(12 + 8);
+    const length = view.getUint32(12 + 12);
+    expect(length).toBe(payload.byteLength);
+    expect([...font.subarray(offset, offset + length)]).toEqual([...payload]);
+  });
+
+  it('writes each table a real checksum rather than a zero', () => {
+    const payload = Uint8Array.from([0, 0, 0, 7]);
+    const font = assembleSfntFont(0x00010000, [{ data: payload, tag: packSfntTag('cmap') }]);
+    const view = new DataView(font.buffer);
+    expect(view.getUint32(12 + 4)).toBe(7);
+    expect(view.getUint32(12 + 4)).toBe(computeSfntTableChecksum(payload));
+  });
+
+  it('carries the flavor it was given rather than inferring one', () => {
+    const font = assembleSfntFont(0x4f54544f, [{ data: Uint8Array.from([0]), tag: packSfntTag('CFF ') }]);
+    expect(new DataView(font.buffer).getUint32(0)).toBe(0x4f54544f);
+  });
+});
+
+describe('computeSfntTableChecksum', () => {
+  it('sums big-endian words', () => {
+    expect(computeSfntTableChecksum(Uint8Array.from([0, 0, 0, 1, 0, 0, 0, 2]))).toBe(3);
+  });
+
+  it('pads a partial final word with zeros rather than dropping it', () => {
+    // [0,0,1] is one short of a word. Dropping the tail would give 0; padding gives 0x100.
+    expect(computeSfntTableChecksum(Uint8Array.from([0, 0, 1]))).toBe(0x100);
+  });
+
+  it('treats head checkSumAdjustment as zero, which is what stops every real font mismatching', () => {
+    // Byte 8 begins checkSumAdjustment. The same bytes must sum differently for head than for any
+    // other table, so the two calls below are what separates the exception from a no-op.
+    const head = new Uint8Array(16);
+    head[8] = 0xff;
+    head[9] = 0xff;
+    expect(computeSfntTableChecksum(head, false)).toBe(0xffff0000);
+    expect(computeSfntTableChecksum(head, true)).toBe(0);
+  });
+
+  it('wraps modulo 2^32 rather than growing past a uint32', () => {
+    const big = Uint8Array.from([0xff, 0xff, 0xff, 0xff, 0, 0, 0, 2]);
+    expect(computeSfntTableChecksum(big)).toBe(1);
+  });
+});
+
+describe('encodeSfntCompositeGlyph', () => {
+  const box = { xMax: 9, xMin: 1, yMax: 8, yMin: 2 };
+  const comps = Uint8Array.from([0x00, 0x20, 0x00, 0x03, 0x01, 0x02]);
+  const none = new Uint8Array(0);
+
+  it('marks the glyph composite with a negative contour count', () => {
+    // Readers switch on the sign alone. A positive count here makes every reader parse the component
+    // records as an endPtsOfContours array.
+    const out = encodeSfntCompositeGlyph(comps, none, box, false);
+    expect(new DataView(out.buffer, out.byteOffset, out.byteLength).getInt16(0)).toBeLessThan(0);
+  });
+
+  it('copies the component records unchanged', () => {
+    const out = encodeSfntCompositeGlyph(comps, none, box, false);
+    expect([...out.subarray(10, 16)]).toEqual([...comps]);
+  });
+
+  it('omits the instruction length entirely when no component asked for instructions', () => {
+    // A zero length written unconditionally adds two bytes no reader expects, shifting every glyph
+    // that follows.
+    expect(encodeSfntCompositeGlyph(comps, none, box, false).byteLength).toBe(16);
+  });
+
+  it('writes the instruction length and bytes when a component did ask', () => {
+    const out = encodeSfntCompositeGlyph(comps, Uint8Array.from([0xb0]), box, true);
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    expect(out.byteLength).toBe(19);
+    expect(view.getUint16(16)).toBe(1);
+    expect(out[18]).toBe(0xb0);
+  });
+
+  it('carries the bounds it was given, since a composite cannot compute its own', () => {
+    const out = encodeSfntCompositeGlyph(comps, none, box, false);
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    expect([view.getInt16(2), view.getInt16(4), view.getInt16(6), view.getInt16(8)]).toEqual([1, 2, 9, 8]);
+  });
+});
+
+describe('encodeSfntLoca', () => {
+  it('writes one more offset than there are glyphs', () => {
+    // The last entry is the end of the final glyph, which is how its length is expressed at all.
+    expect(encodeSfntLoca([4, 6], 1)!.byteLength).toBe(12);
+    expect(encodeSfntLoca([4, 6], 0)!.byteLength).toBe(6);
+  });
+
+  it('accumulates offsets in glyph order', () => {
+    const out = encodeSfntLoca([4, 6, 2], 1)!;
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    expect([0, 1, 2, 3].map((i) => view.getUint32(i * 4))).toEqual([0, 4, 10, 12]);
+  });
+
+  it('halves the offset in the short form', () => {
+    const out = encodeSfntLoca([4, 6], 0)!;
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    expect([0, 1, 2].map((i) => view.getUint16(i * 2))).toEqual([0, 2, 5]);
+  });
+
+  it('gives equal consecutive offsets for a blank glyph', () => {
+    const out = encodeSfntLoca([4, 0, 4], 1)!;
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    expect(view.getUint32(4)).toBe(view.getUint32(8));
+  });
+
+  it('refuses the short form for an odd offset rather than truncating it', () => {
+    // Truncation here would point the reader one byte before the glyph, inside its predecessor.
+    expect(encodeSfntLoca([5, 4], 0)).toBeNull();
+    expect(encodeSfntLoca([5, 4], 1)).not.toBeNull();
+  });
+
+  it('refuses the short form when the font outgrows its reach', () => {
+    expect(encodeSfntLoca([0x20000, 2], 0)).toBeNull();
+  });
+});
+
+describe('encodeSfntSimpleGlyph', () => {
+  const box = { xMax: 10, xMin: 0, yMax: 10, yMin: 0 };
+  const none = new Uint8Array(0);
+
+  it('writes the contour count and bounds as signed values', () => {
+    const out = encodeSfntSimpleGlyph([0], [5], [5], [true], none, { xMax: 5, xMin: -5, yMax: 5, yMin: -5 });
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    expect(view.getInt16(0)).toBe(1);
+    // Negative bounds are ordinary: a glyph descending below the baseline has a negative yMin, and
+    // reading these unsigned turns it into a huge positive box.
+    expect(view.getInt16(2)).toBe(-5);
+    expect(view.getInt16(4)).toBe(-5);
+  });
+
+  it('returns nothing at all for a glyph with no contours', () => {
+    // Zero length is how the format spells a blank glyph. A ten-byte record with a zero contour count
+    // would give every space character a bounding box.
+    expect(encodeSfntSimpleGlyph([], [], [], [], none, box).byteLength).toBe(0);
+  });
+
+  it('spends no coordinate bytes on a point that does not move', () => {
+    const moved = encodeSfntSimpleGlyph([1], [0, 7], [0, 0], [true, true], none, box);
+    const still = encodeSfntSimpleGlyph([1], [0, 0], [0, 0], [true, true], none, box);
+    expect(moved.byteLength - still.byteLength).toBe(1);
+  });
+
+  it('collapses a run of identical flags into one repeat group', () => {
+    // Ten identical points cost one flag plus a count, not ten flags.
+    const xs = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const packed = encodeSfntSimpleGlyph(
+      [9],
+      xs,
+      xs,
+      xs.map(() => true),
+      none,
+      box,
+    );
+    // 10 header + 2 endPts + 2 instructionLength + 2 flag bytes, and no coordinate bytes at all.
+    expect(packed.byteLength).toBe(16);
+  });
+
+  it('carries the instructions and their length', () => {
+    const out = encodeSfntSimpleGlyph([0], [0], [0], [true], Uint8Array.from([0xb0, 0x01]), box);
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    expect(view.getUint16(12)).toBe(2);
+    expect([...out.subarray(14, 16)]).toEqual([0xb0, 0x01]);
+  });
+
+  it('writes a delta beyond a byte as two bytes rather than truncating it', () => {
+    const short = encodeSfntSimpleGlyph([0], [255], [0], [true], none, box);
+    const long = encodeSfntSimpleGlyph([0], [256], [0], [true], none, box);
+    expect(long.byteLength - short.byteLength).toBe(1);
+  });
+});
+
+describe('packSfntTag', () => {
+  it('packs four characters big-endian', () => {
+    expect(packSfntTag('glyf')).toBe(0x676c7966);
+  });
+
+  it('pads a short tag with spaces, which is how the format spells its own', () => {
+    expect(packSfntTag('cvt')).toBe(packSfntTag('cvt '));
+    expect(packSfntTag('cvt')).toBe(0x63767420);
+  });
+});

package/src/sfntTableDirectory.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+
+import { createSyntheticFont } from './openTypeTestHelper';
+import { readSfntTableDirectory, readSfntTag } from './sfntTableDirectory';
+
+describe('readSfntTableDirectory', () => {
+  it('reads every table a well-formed font declares', () => {
+    const directory = readSfntTableDirectory(createSyntheticFont())!;
+    expect(directory.tables.has('glyf')).toBe(true);
+    expect(directory.tables.has('cmap')).toBe(true);
+    expect(directory.declaredTableCount).toBe(directory.tables.size);
+  });
+
+  it('reports the container flavor from the sfnt version', () => {
+    expect(readSfntTableDirectory(createSyntheticFont())?.sfntVersion).toBe(0x00010000);
+    // 'OTTO' — the same directory layout, PostScript outlines behind it.
+    expect(readSfntTableDirectory(createSyntheticFont({ flavor: 'opentype' }))?.sfntVersion).toBe(0x4f54544f);
+  });
+
+  it('gives each table a byte range that lies inside the file', () => {
+    const font = createSyntheticFont();
+    for (const range of readSfntTableDirectory(font)!.tables.values()) {
+      expect(range.offset + range.length).toBeLessThanOrEqual(font.byteLength);
+    }
+  });
+
+  // The distinction the explanation is built on: a truncated file still DECLARES every table, and the
+  // gap between what it declares and what is readable is what localizes the damage.
+  it('keeps the declared count while dropping tables that fall outside a truncated file', () => {
+    const font = createSyntheticFont();
+    const whole = readSfntTableDirectory(font)!;
+    const truncated = readSfntTableDirectory(font.subarray(0, font.length - 8))!;
+    expect(truncated.declaredTableCount).toBe(whole.declaredTableCount);
+    expect(truncated.tables.size).toBeLessThan(whole.tables.size);
+  });
+
+  it('returns the sentinel for bytes shorter than the header', () => {
+    expect(readSfntTableDirectory(new Uint8Array(11))).toBeNull();
+    expect(readSfntTableDirectory(new Uint8Array(0))).toBeNull();
+  });
+
+  it('stops rather than reading past the buffer when the header overstates the table count', () => {
+    const bytes = new Uint8Array(12);
+    new DataView(bytes.buffer).setUint16(4, 500);
+    const directory = readSfntTableDirectory(bytes)!;
+    expect(directory.declaredTableCount).toBe(500);
+    expect(directory.tables.size).toBe(0);
+  });
+});
+
+describe('readSfntTag', () => {
+  it('reads four bytes as the characters every specification spells a tag with', () => {
+    expect(readSfntTag(new Uint8Array([0x67, 0x6c, 0x79, 0x66]), 0)).toBe('glyf');
+  });
+
+  it('preserves a significant trailing space', () => {
+    // `CFF ` is four characters, the last one a space. Trimming it makes the tag miss its own table.
+    expect(readSfntTag(new Uint8Array([0x43, 0x46, 0x46, 0x20]), 0)).toBe('CFF ');
+  });
+
+  it('reads from the given offset rather than the start', () => {
+    expect(readSfntTag(new Uint8Array([0, 0, 0x68, 0x65, 0x61, 0x64]), 2)).toBe('head');
+  });
+});

package/src/woff2Font.test.ts

@@ -0,0 +1,129 @@
+import type { Decompressor } from '@flighthq/types/contract';
+import { Compression, CompressionFraming } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import { createSyntheticFont, encodeSyntheticWoff2 } from './openTypeTestHelper';
+import { readSfntTableDirectory } from './sfntTableDirectory';
+import { readWoff2Font, readWoff2TableDirectory, WOFF2_COMPRESSION } from './woff2Font';
+
+// The synthetic container stores its stream uncompressed, so the whole container path is reachable with
+// an identity decompressor and no Brotli implementation anywhere near the suite.
+const identity: Decompressor = (compressed, _uncompressedLength, framing) => {
+  expect(framing).toBe(CompressionFraming.Raw);
+  return compressed as Uint8Array;
+};
+
+describe('readWoff2Font', () => {
+  it('rebuilds an sfnt carrying the same tables as the original', () => {
+    const original = createSyntheticFont();
+    const rebuilt = readWoff2Font(encodeSyntheticWoff2(original), identity, null)!;
+    const before = readSfntTableDirectory(original)!;
+    const after = readSfntTableDirectory(rebuilt)!;
+    expect([...after.tables.keys()].sort()).toEqual([...before.tables.keys()].sort());
+  });
+
+  it('preserves each table byte for byte through the unwrap', () => {
+    const original = createSyntheticFont();
+    const rebuilt = readWoff2Font(encodeSyntheticWoff2(original), identity, null)!;
+    const before = readSfntTableDirectory(original)!;
+    const after = readSfntTableDirectory(rebuilt)!;
+    for (const [tag, table] of before.tables) {
+      const mirror = after.tables.get(tag)!;
+      expect([...rebuilt.subarray(mirror.offset, mirror.offset + mirror.length)]).toEqual([
+        ...original.subarray(table.offset, table.offset + table.length),
+      ]);
+    }
+  });
+
+  it('carries the original flavor through, rather than inferring one', () => {
+    const original = createSyntheticFont({ flavor: 'opentype' });
+    const rebuilt = readWoff2Font(encodeSyntheticWoff2(original), identity, null)!;
+    expect(new DataView(rebuilt.buffer).getUint32(0)).toBe(0x4f54544f);
+  });
+
+  it('returns the sentinel when no decompressor is available', () => {
+    expect(readWoff2Font(encodeSyntheticWoff2(createSyntheticFont()), null, null)).toBeNull();
+  });
+
+  it('returns the sentinel for a transformed table when no transform reversal is supplied', () => {
+    // Refusing is the point: emitting the transformed bytes under the table's own tag would produce a
+    // font whose directory says `glyf` over something that is not one.
+    const wrapped = encodeSyntheticWoff2(createSyntheticFont(), ['glyf']);
+    expect(readWoff2Font(wrapped, identity, null)).toBeNull();
+  });
+
+  it('hands a transformed table to the reversal and uses what it returns', () => {
+    const replacement = Uint8Array.from([1, 2, 3, 4]);
+    const seen: string[] = [];
+    const wrapped = encodeSyntheticWoff2(createSyntheticFont(), ['glyf']);
+    const rebuilt = readWoff2Font(wrapped, identity, (tag) => {
+      seen.push(tag);
+      return replacement;
+    })!;
+    expect(seen).toEqual(['glyf']);
+    const glyf = readSfntTableDirectory(rebuilt)!.tables.get('glyf')!;
+    expect([...rebuilt.subarray(glyf.offset, glyf.offset + glyf.length)]).toEqual([...replacement]);
+  });
+
+  it('returns the sentinel when the transform reversal declines', () => {
+    const wrapped = encodeSyntheticWoff2(createSyntheticFont(), ['glyf']);
+    expect(readWoff2Font(wrapped, identity, () => null)).toBeNull();
+  });
+
+  it('returns the sentinel for a truncated container rather than a partial font', () => {
+    const wrapped = encodeSyntheticWoff2(createSyntheticFont());
+    expect(readWoff2Font(wrapped.subarray(0, 40), identity, null)).toBeNull();
+  });
+});
+
+describe('readWoff2TableDirectory', () => {
+  it('resolves tags carried as an index into the known-tag table', () => {
+    const directory = readWoff2TableDirectory(encodeSyntheticWoff2(createSyntheticFont()))!;
+    expect(directory.entries.map((entry) => entry.tag)).toContain('glyf');
+    expect(directory.entries.map((entry) => entry.tag)).toContain('cmap');
+  });
+
+  it('points streamStart past the directory rather than at a guess from the end', () => {
+    const wrapped = encodeSyntheticWoff2(createSyntheticFont());
+    const directory = readWoff2TableDirectory(wrapped)!;
+    expect(directory.streamStart).toBeGreaterThan(48);
+    // The stream runs from there to the end of the file, so the two must agree exactly. Deriving the
+    // start by subtracting instead lands in the format's trailing padding.
+    expect(directory.streamStart + directory.totalUncompressedLength).toBe(wrapped.byteLength);
+  });
+
+  it('reads the transform flag with the sense inverted for the glyph pair', () => {
+    // `glyf` is marked transformed here and `cmap` is not. Both are encoded with the version whose
+    // meaning is opposite between them, so a reader applying one rule to both gets both answers wrong.
+    const directory = readWoff2TableDirectory(encodeSyntheticWoff2(createSyntheticFont(), ['glyf']))!;
+    const glyf = directory.entries.find((entry) => entry.tag === 'glyf')!;
+    const cmap = directory.entries.find((entry) => entry.tag === 'cmap')!;
+    expect(glyf.transformed).toBe(true);
+    expect(glyf.transformVersion).toBe(0);
+    expect(cmap.transformed).toBe(false);
+    expect(cmap.transformVersion).toBe(0);
+  });
+
+  it('treats the glyph pair as untransformed only at version three', () => {
+    const directory = readWoff2TableDirectory(encodeSyntheticWoff2(createSyntheticFont()))!;
+    const glyf = directory.entries.find((entry) => entry.tag === 'glyf')!;
+    expect(glyf.transformVersion).toBe(3);
+    expect(glyf.transformed).toBe(false);
+  });
+
+  it('returns the sentinel for a container declaring no tables', () => {
+    const wrapped = encodeSyntheticWoff2(createSyntheticFont());
+    new DataView(wrapped.buffer).setUint16(12, 0);
+    expect(readWoff2TableDirectory(wrapped)).toBeNull();
+  });
+
+  it('returns the sentinel when the directory runs past the buffer', () => {
+    expect(readWoff2TableDirectory(encodeSyntheticWoff2(createSyntheticFont()).subarray(0, 50))).toBeNull();
+  });
+});
+
+describe('WOFF2_COMPRESSION', () => {
+  it('names Brotli through the shared vocabulary so a caller registers what this asks for', () => {
+    expect(WOFF2_COMPRESSION).toBe(Compression.Brotli);
+  });
+});