@flighthq/font-formats 0.3.1-next.209.43ef1bc

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,125 @@
+import { Compression } 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 = (compressed: Readonly<Uint8Array>): Uint8Array => 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);
+  });
+});

package/src/woff2GlyfTransform.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+
+import { readWoff2GlyfStreams, readWoff2Short } from './woff2GlyfTransform';
+
+// Builds a transformed `glyf` header over seven streams of the given sizes, filled with a distinct byte
+// each so a mis-ordered carve shows up as the wrong contents rather than only the wrong length.
+function transformedGlyf(sizes: readonly number[], glyphCount = 3, indexFormat = 0): Uint8Array {
+  const total = 36 + sizes.reduce((sum, size) => sum + size, 0);
+  const out = new Uint8Array(total);
+  const view = new DataView(out.buffer);
+  view.setUint16(4, glyphCount);
+  view.setUint16(6, indexFormat);
+  sizes.forEach((size, index) => view.setUint32(8 + index * 4, size));
+  let at = 36;
+  sizes.forEach((size, index) => {
+    out.fill(index + 1, at, at + size);
+    at += size;
+  });
+  return out;
+}
+
+describe('readWoff2GlyfStreams', () => {
+  it('carves the seven streams in their declared order', () => {
+    // Distinct sizes AND distinct fills: equal sizes would let a wrongly-ordered carve pass.
+    const streams = readWoff2GlyfStreams(transformedGlyf([6, 1, 2, 3, 4, 5, 7]))!;
+    expect(streams.nContourStream.byteLength).toBe(6);
+    expect(streams.nPointsStream.byteLength).toBe(1);
+    expect(streams.flagStream.byteLength).toBe(2);
+    expect(streams.glyphStream.byteLength).toBe(3);
+    expect(streams.compositeStream.byteLength).toBe(4);
+    expect(streams.bboxStream.byteLength).toBe(5);
+    expect(streams.instructionStream.byteLength).toBe(7);
+    // Each stream was filled with its own index, so this pins WHICH bytes each name got.
+    expect([...streams.nContourStream]).toEqual([1, 1, 1, 1, 1, 1]);
+    expect([...streams.instructionStream]).toEqual([7, 7, 7, 7, 7, 7, 7]);
+  });
+
+  it('carries the glyph count and loca width from the header', () => {
+    const streams = readWoff2GlyfStreams(transformedGlyf([2, 1, 1, 1, 1, 1, 1], 41, 1))!;
+    expect(streams.glyphCount).toBe(41);
+    expect(streams.indexFormat).toBe(1);
+  });
+
+  it('returns the sentinel when the sizes do not account for the table exactly', () => {
+    // A truncated stream still decodes into real-looking contour counts, so a partial carve would be
+    // silently wrong rather than visibly broken.
+    const short = transformedGlyf([4, 1, 1, 1, 1, 1, 1]).subarray(0, 40);
+    expect(readWoff2GlyfStreams(short)).toBeNull();
+  });
+
+  it('returns the sentinel when the table carries bytes no stream claims', () => {
+    const table = transformedGlyf([4, 1, 1, 1, 1, 1, 1]);
+    const padded = new Uint8Array(table.byteLength + 3);
+    padded.set(table);
+    expect(readWoff2GlyfStreams(padded)).toBeNull();
+  });
+
+  it('returns the sentinel for a table shorter than its own header', () => {
+    expect(readWoff2GlyfStreams(new Uint8Array(20))).toBeNull();
+  });
+});
+
+describe('readWoff2Short', () => {
+  it('reads a plain byte below the first escape code', () => {
+    const cursor = { at: 0 };
+    expect(readWoff2Short(Uint8Array.from([200]), cursor, 1)).toBe(200);
+    expect(cursor.at).toBe(1);
+  });
+
+  it('reads the two-byte word form', () => {
+    const cursor = { at: 0 };
+    expect(readWoff2Short(Uint8Array.from([253, 0x12, 0x34]), cursor, 3)).toBe(0x1234);
+    expect(cursor.at).toBe(3);
+  });
+
+  it('offsets the two one-more-byte forms by different amounts', () => {
+    // 254 and 255 differ only in their offset, so a reader that swapped them would still return a
+    // plausible small number. Pinning both against the same payload byte is what separates them.
+    expect(readWoff2Short(Uint8Array.from([255, 10]), { at: 0 }, 2)).toBe(263);
+    expect(readWoff2Short(Uint8Array.from([254, 10]), { at: 0 }, 2)).toBe(516);
+  });
+
+  it('returns the sentinel rather than a short value when the stream ends mid-escape', () => {
+    expect(readWoff2Short(Uint8Array.from([253, 0x12]), { at: 0 }, 2)).toBe(-1);
+    expect(readWoff2Short(Uint8Array.from([255]), { at: 0 }, 1)).toBe(-1);
+    expect(readWoff2Short(Uint8Array.from([]), { at: 0 }, 0)).toBe(-1);
+  });
+});

package/src/woffFont.test.ts

@@ -0,0 +1,167 @@
+import { registerDeflateDecompressor, unregisterDecompressor } from '@flighthq/compression/contract';
+import { Compression } from '@flighthq/types/contract';
+import type { Path } from '@flighthq/types/contract';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { createGlyphOutlineSourceFromOpenTypeFont } from './openTypeGlyphOutlineSource';
+import {
+  createSyntheticFont,
+  encodeSyntheticWoff,
+  squareSyntheticGlyph,
+  emptySyntheticGlyph,
+} from './openTypeTestHelper';
+import { readSfntTableDirectory } from './sfntTableDirectory';
+import { readWoffChecksumMismatches, readWoffFont } from './woffFont';
+
+afterEach(() => unregisterDecompressor(Compression.Deflate));
+
+describe('readWoffChecksumMismatches', () => {
+  it('reports nothing when the container states its tables truthfully', () => {
+    expect(readWoffChecksumMismatches(encodeSyntheticWoff(createSyntheticFont()), null)).toEqual([]);
+  });
+
+  it('names the table, what the file claimed, and what the bytes actually sum to', () => {
+    const woff = encodeSyntheticWoff(createSyntheticFont());
+    // Corrupt the FIRST entry's stored checksum only, so the report must single it out rather than
+    // flagging everything — a check that reported all tables would pass a weaker assertion.
+    const view = new DataView(woff.buffer);
+    const tag = view.getUint32(44);
+    view.setUint32(44 + 16, 0xdeadbeef);
+    const found = readWoffChecksumMismatches(woff, null);
+    expect(found.length).toBe(1);
+    expect(found[0]!.stored).toBe(0xdeadbeef);
+    expect(found[0]!.computed).not.toBe(0xdeadbeef);
+    expect(found[0]!.tag).toBe(
+      String.fromCharCode((tag >>> 24) & 0xff, (tag >>> 16) & 0xff, (tag >>> 8) & 0xff, tag & 0xff),
+    );
+  });
+
+  it('still loads the font it reported a mismatch for, rather than refusing it', () => {
+    // The whole point of the seam: a mismatch is information, not a verdict.
+    const woff = encodeSyntheticWoff(createSyntheticFont());
+    new DataView(woff.buffer).setUint32(44 + 16, 0xdeadbeef);
+    expect(readWoffChecksumMismatches(woff, null).length).toBe(1);
+    expect(readWoffFont(woff, null)).not.toBeNull();
+  });
+
+  it('returns an empty report for a container it cannot read at all', () => {
+    expect(readWoffChecksumMismatches(new Uint8Array(8), null)).toEqual([]);
+  });
+});
+
+describe('readWoffFont', () => {
+  it('produces the same glyph outlines as the uncompressed font it wraps', () => {
+    // The end-to-end falsifier: byte-equality of table CONTENTS is a stronger claim per table, but it
+    // never runs the outline readers. This drives the whole producer — directory, offsets, `loca`,
+    // `glyf` — through both the plain font and its wrapper and compares what a caller actually gets.
+    const original = createSyntheticFont({ glyphs: [emptySyntheticGlyph(), squareSyntheticGlyph(100)] });
+    const rebuilt = readWoffFont(encodeSyntheticWoff(original), null)!;
+    const before = createGlyphOutlineSourceFromOpenTypeFont(original)!;
+    const after = createGlyphOutlineSourceFromOpenTypeFont(rebuilt)!;
+    const a: Path = { commands: [], data: [], winding: 'nonZero' };
+    const b: Path = { commands: [], data: [], winding: 'nonZero' };
+    expect(before.getGlyphOutline(a, 1)).toBe(true);
+    expect(after.getGlyphOutline(b, 1)).toBe(true);
+    expect(b.commands).toEqual(a.commands);
+    expect(b.data).toEqual(a.data);
+    expect(a.commands.length).toBeGreaterThan(0);
+    expect(after.getGlyphOutlineAdvance(1)).toBe(before.getGlyphOutlineAdvance(1));
+  });
+
+  it('rebuilds an sfnt whose tables match the original', () => {
+    const original = createSyntheticFont();
+    const rebuilt = readWoffFont(encodeSyntheticWoff(original), 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 = readWoffFont(encodeSyntheticWoff(original), null)!;
+    const before = readSfntTableDirectory(original)!;
+    const after = readSfntTableDirectory(rebuilt)!;
+    for (const [tag, range] of before.tables) {
+      const other = after.tables.get(tag)!;
+      expect(rebuilt.subarray(other.offset, other.offset + other.length)).toEqual(
+        original.subarray(range.offset, range.offset + range.length),
+      );
+    }
+  });
+
+  // The wrapper carries the sfnt version the tables belonged to, so a wrapped CFF font must come out
+  // declaring itself a CFF font rather than one inferred from which tables happen to be present.
+  it('carries the original flavor through, rather than inferring one', () => {
+    const cff = createSyntheticFont({ flavor: 'opentype' });
+    const rebuilt = readWoffFont(encodeSyntheticWoff(cff), null)!;
+    expect(readSfntTableDirectory(rebuilt)?.sfntVersion).toBe(0x4f54544f);
+  });
+
+  // The sfnt directory is defined as tag-ordered, so a reader entitled to binary-search it would find the
+  // wrong table if the rebuild preserved WOFF's order instead.
+  it('writes the rebuilt directory in tag order even when the container is not', () => {
+    // The container is built in DESCENDING tag order on purpose. A sorted fixture would let this pass
+    // whether or not the rebuild sorted anything, which is how the first version of this test was
+    // useless — mutation testing found it, not review.
+    const rebuilt = readWoffFont(encodeSyntheticWoff(createSyntheticFont(), true), null)!;
+    const view = new DataView(rebuilt.buffer, rebuilt.byteOffset, rebuilt.byteLength);
+    const count = view.getUint16(4);
+    const tags = Array.from({ length: count }, (_, index) => view.getUint32(12 + index * 16));
+    expect(tags).toEqual([...tags].sort((a, b) => a - b));
+  });
+
+  it('starts every rebuilt table on a four-byte boundary', () => {
+    // The rebuilt sfnt is a public output, so it follows the alignment every real font is written
+    // with. Justified as a PRODUCER convention, not as a consumer requirement: a misaligned font was
+    // measured against fontconfig/FreeType and accepted, so the claim that a consumer rejects one is
+    // not supported and is deliberately not the reason recorded here.
+    //
+    // This reader indexes tables by explicit offset and length, so nothing else in the suite can
+    // notice if the padding stops — which is why the assertion is on the byte layout rather than on
+    // a round trip.
+    const rebuilt = readWoffFont(encodeSyntheticWoff(createSyntheticFont()), null)!;
+    const view = new DataView(rebuilt.buffer, rebuilt.byteOffset, rebuilt.byteLength);
+    const count = view.getUint16(4);
+    const lengths = Array.from({ length: count }, (_, index) => view.getUint32(12 + index * 16 + 12));
+    // A fixture whose tables all happened to be multiples of four would satisfy the alignment claim
+    // without any padding ever running, which is how the tag-order test above was once vacuous.
+    expect(lengths.some((length) => length % 4 !== 0)).toBe(true);
+    const offsets = Array.from({ length: count }, (_, index) => view.getUint32(12 + index * 16 + 8));
+    expect(offsets.filter((offset) => offset % 4 !== 0)).toEqual([]);
+  });
+
+  it('reads a deflated table when a decompressor is registered', () => {
+    registerDeflateDecompressor();
+    // The synthetic wrapper stores tables uncompressed, so this proves the registered path is reached
+    // and returns the same bytes rather than proving inflate itself, which compression owns.
+    const rebuilt = readWoffFont(encodeSyntheticWoff(createSyntheticFont()), null);
+    expect(rebuilt).not.toBeNull();
+  });
+
+  it('returns the sentinel for a truncated container rather than a partial font', () => {
+    const woff = encodeSyntheticWoff(createSyntheticFont());
+    expect(readWoffFont(woff.subarray(0, 20), null)).toBeNull();
+    expect(readWoffFont(woff.subarray(0, woff.length - 8), null)).toBeNull();
+  });
+
+  it('returns the sentinel for a container declaring no tables', () => {
+    const woff = encodeSyntheticWoff(createSyntheticFont());
+    new DataView(woff.buffer).setUint16(12, 0);
+    expect(readWoffFont(woff, null)).toBeNull();
+  });
+
+  // A decompressor returning the wrong length has produced something that is not this table, and
+  // reassembling it would yield a directory whose lengths lie about its own contents.
+  it('returns the sentinel when a decompressor yields the wrong length', () => {
+    const woff = encodeSyntheticWoff(createSyntheticFont());
+    // Mark the first table as compressed so the decompressor path is taken.
+    new DataView(woff.buffer).setUint32(44 + 8, 4);
+    expect(readWoffFont(woff, () => new Uint8Array(3))).toBeNull();
+  });
+
+  it('returns the sentinel for a compressed table when no decompressor is available', () => {
+    const woff = encodeSyntheticWoff(createSyntheticFont());
+    new DataView(woff.buffer).setUint32(44 + 8, 4);
+    expect(readWoffFont(woff, null)).toBeNull();
+  });
+});