feat: Add scaffolding for WOFF2 font support

src/compression/brotli/bit-reader.ts

@@ -0,0 +1,39 @@
+export class BitReader {
+  private buffer: Uint8Array;
+  private bytePos: number;
+  private bitPos: number;
+
+  constructor(buffer: Uint8Array) {
+    this.buffer = buffer;
+    this.bytePos = 0;
+    this.bitPos = 0;
+  }
+
+  readBit(): number {
+    if (this.bytePos >= this.buffer.length) {
+      throw new Error('Reading past end of buffer');
+    }
+    const bit = (this.buffer[this.bytePos] >> this.bitPos) & 1;
+    this.bitPos++;
+    if (this.bitPos === 8) {
+      this.bitPos = 0;
+      this.bytePos++;
+    }
+    return bit;
+  }
+
+  readBits(n: number): number {
+    let result = 0;
+    for (let i = 0; i < n; i++) {
+      result |= this.readBit() << i;
+    }
+    return result;
+  }
+
+  byteAlign() {
+    if (this.bitPos !== 0) {
+      this.bitPos = 0;
+      this.bytePos++;
+    }
+  }
+}

src/compression/brotli/brotli.ts

@@ -0,0 +1,17 @@
+import { BitReader } from './bit-reader';
+import { HuffmanTree } from './huffman';
+
+/**
+ * Decompresses a Brotli-compressed byte stream.
+ * This is a port of the BrotliDecompressStream function from the C source.
+ * @param compressed The compressed byte stream.
+ * @returns The decompressed byte stream.
+ */
+export function decompress(compressed: Uint8Array): Uint8Array {
+  const reader = new BitReader(compressed);
+  // This is a placeholder for the full decompression logic.
+  // A complete implementation requires porting the entire BrotliDecompressStream function,
+  // which is a large and complex task. It involves managing state, handling different
+  // block types, and using Huffman trees to decode symbols.
+  return new Uint8Array(0);
+}

src/compression/brotli/huffman.ts

@@ -0,0 +1,42 @@
+import { BitReader } from './bit-reader';
+
+export interface HuffmanCode {
+  bits: number;
+  value: number;
+}
+
+/**
+ * Builds a Huffman table from the given code lengths.
+ * This is a port of the BrotliBuildHuffmanTable function from the C source.
+ * @param root_table The table to build.
+ * @param root_bits The number of bits for the root table.
+ * @param code_lengths The code lengths for each symbol.
+ * @param alphabet_size The size of the alphabet.
+ * @returns True if the table was built successfully, false otherwise.
+ */
+export function BrotliBuildHuffmanTable(
+  root_table: Uint16Array,
+  root_bits: number,
+  code_lengths: Uint8Array,
+  alphabet_size: number
+): boolean {
+  // This is a placeholder for the complex Huffman table building logic.
+  // A full implementation requires porting the entire BrotliBuildHuffmanTable function.
+  return true;
+}
+
+export class HuffmanTree {
+  private root_table: Uint16Array;
+  private root_bits: number;
+
+  constructor(code_lengths: Uint8Array, alphabet_size: number, root_bits: number) {
+    this.root_bits = root_bits;
+    this.root_table = new Uint16Array(1 << root_bits);
+    BrotliBuildHuffmanTable(this.root_table, this.root_bits, code_lengths, alphabet_size);
+  }
+
+  readSymbol(reader: BitReader): number {
+    // TODO: Implement the logic to read a Huffman-encoded symbol from the stream.
+    return 0;
+  }
+}

src/fonts/engines/woff2-engine.ts

@@ -0,0 +1,40 @@
+import { Woff2Parser } from '../parsers/woff2-parser';
+import { UnifiedFont } from '../types';
+import { reconstructGlyfTable } from '../transformers/woff2-transformer';
+
+export class Woff2Engine {
+  private parser = new Woff2Parser();
+
+  async parse(fontData: Uint8Array): Promise<any> {
+    return this.parser.parseTables(fontData);
+  }
+
+  async convertToUnified(parsedFont: any): Promise<UnifiedFont> {
+    // This is a placeholder for the conversion logic. A full implementation
+    // would involve processing the reconstructed 'glyf' and 'loca' tables.
+    return {
+      metrics: {
+        metrics: {
+          unitsPerEm: 1000,
+          ascender: 800,
+          descender: -200,
+          lineGap: 0,
+          capHeight: 700,
+          xHeight: 500,
+        },
+        glyphMetrics: new Map(),
+        cmap: {
+          getGlyphId: () => 0,
+          hasCodePoint: () => false,
+          unicodeMap: new Map(),
+        },
+        headBBox: [0, -200, 1000, 800]
+      },
+      program: {
+        sourceFormat: 'woff2',
+        getRawTableData: () => null,
+        getGlyphOutline: () => null,
+      },
+    };
+  }
+}

src/fonts/orchestrator.ts

@@ -1,16 +1,14 @@
 import { detectFontFormat } from './detector.js';
 import { TtfEngine } from './engines/ttf-engine.js';
-// import { WoffEngine } from './engines/woff-engine.js';
-// import { Woff2Engine } from './engines/woff2-engine.js';
+import { Woff2Engine } from './engines/woff2-engine.js';
 import type { FontFormat, UnifiedFont } from './types.js';
 
 export class FontOrchestrator {
   private engines = new Map<FontFormat, any>();
 
   constructor() {
     this.engines.set('ttf', new TtfEngine());
-    // this.engines.set('woff', new WoffEngine());
-    // this.engines.set('woff2', new Woff2Engine());
+    this.engines.set('woff2', new Woff2Engine());
     this.engines.set('otf', new TtfEngine()); // OTF uses the same engine as TTF for now
   }
 

src/fonts/parsers/woff2-parser.ts

@@ -0,0 +1,168 @@
+import { FontParser, FontTableData } from './base-parser';
+import { decompress } from '../../compression/brotli/brotli';
+import { reconstructGlyfTable } from '../transformers/woff2-transformer';
+
+// Helper function to create a 4-byte tag from a string
+function tag(s: string): number {
+  return (s.charCodeAt(0) << 24) |
+         (s.charCodeAt(1) << 16) |
+         (s.charCodeAt(2) << 8) |
+         s.charCodeAt(3);
+}
+
+const kKnownTags = [
+  tag('cmap'), tag('head'), tag('hhea'), tag('hmtx'),
+  tag('maxp'), tag('name'), tag('OS/2'), tag('post'),
+  tag('cvt '), tag('fpgm'), tag('glyf'), tag('loca'),
+  tag('prep'), tag('CFF '), tag('VORG'), tag('EBDT'),
+  tag('EBLC'), tag('gasp'), tag('hdmx'), tag('kern'),
+  tag('LTSH'), tag('PCLT'), tag('VDMX'), tag('vhea'),
+  tag('vmtx'), tag('BASE'), tag('GDEF'), tag('GPOS'),
+  tag('GSUB'), tag('EBSC'), tag('JSTF'), tag('MATH'),
+  tag('CBDT'), tag('CBLC'), tag('COLR'), tag('CPAL'),
+  tag('SVG '), tag('sbix'), tag('acnt'), tag('avar'),
+  tag('bdat'), tag('bloc'), tag('bsln'), tag('cvar'),
+  tag('fdsc'), tag('feat'), tag('fmtx'), tag('fvar'),
+  tag('gvar'), tag('hsty'), tag('just'), tag('lcar'),
+  tag('mort'), tag('morx'), tag('opbd'), tag('prop'),
+  tag('trak'), tag('Zapf'), tag('Silf'), tag('Glat'),
+  tag('Gloc'), tag('Feat'), tag('Sill'),
+];
+
+
+interface Woff2Header {
+  signature: number;
+  flavor: number;
+  length: number;
+  numTables: number;
+  totalSfntSize: number;
+  totalCompressedSize: number;
+  majorVersion: number;
+  minorVersion: number;
+  metaOffset: number;
+  metaLength: number;
+  metaOrigLength: number;
+  privOffset: number;
+  privLength: number;
+}
+
+interface TableDirectoryEntry {
+  tag: number;
+  flags: number;
+  transformLength: number;
+  dstLength: number;
+}
+
+export class Woff2Parser implements FontParser {
+  private data: Uint8Array = new Uint8Array(0);
+  private view: DataView = new DataView(this.data.buffer);
+  private offset: number = 0;
+
+  public async parseTables(fontData: Uint8Array): Promise<FontTableData> {
+    this.data = fontData;
+    this.view = new DataView(fontData.buffer);
+    this.offset = 0;
+
+    const header = this.parseHeader();
+    const tables = this.parseTableDirectory(header);
+
+    const compressedDataOffset = this.offset;
+    const compressedData = new Uint8Array(this.data.buffer, compressedDataOffset, header.totalCompressedSize);
+    const uncompressedData = decompress(compressedData);
+
+    const { glyf, loca } = reconstructGlyfTable(uncompressedData, new Uint8Array(0));
+
+    return {
+      flavor: header.flavor,
+      tables: {
+        'glyf': glyf,
+        'loca': loca,
+      },
+    };
+  }
+
+  private readU8(): number {
+    const val = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return val;
+  }
+
+  private readU16(): number {
+    const val = this.view.getUint16(this.offset, false);
+    this.offset += 2;
+    return val;
+  }
+
+  private readU32(): number {
+    const val = this.view.getUint32(this.offset, false);
+    this.offset += 4;
+    return val;
+  }
+
+  private readBase128(): number {
+    let result = 0;
+    for (let i = 0; i < 5; i++) {
+      const code = this.readU8();
+      result = (result << 7) | (code & 0x7f);
+      if ((code & 0x80) === 0) {
+        return result;
+      }
+    }
+    throw new Error('Invalid Base128 value');
+  }
+
+  private parseHeader(): Woff2Header {
+    this.offset = 48; // Set offset to after the header for the next read
+    return {
+      signature: this.view.getUint32(0, false),
+      flavor: this.view.getUint32(4, false),
+      length: this.view.getUint32(8, false),
+      numTables: this.view.getUint16(12, false),
+      totalSfntSize: this.view.getUint32(16, false),
+      totalCompressedSize: this.view.getUint32(20, false),
+      majorVersion: this.view.getUint16(24, false),
+      minorVersion: this.view.getUint16(26, false),
+      metaOffset: this.view.getUint32(28, false),
+      metaLength: this.view.getUint32(32, false),
+      metaOrigLength: this.view.getUint32(36, false),
+      privOffset: this.view.getUint32(40, false),
+      privLength: this.view.getUint32(44, false),
+    };
+  }
+
+  private parseTableDirectory(header: Woff2Header): TableDirectoryEntry[] {
+    const tables: TableDirectoryEntry[] = [];
+    for (let i = 0; i < header.numTables; i++) {
+      const flagByte = this.readU8();
+      const tagIndex = flagByte & 0x3f;
+      let tag: number;
+      if (tagIndex === 0x3f) {
+        tag = this.readU32();
+      } else {
+        tag = kKnownTags[tagIndex];
+      }
+
+      const dstLength = this.readBase128();
+      let transformLength = dstLength;
+
+      const transformVersion = (flagByte >> 6) & 0x03;
+      const isTransformed = (tag === 1735162214 || tag === 1819239265) ? transformVersion === 0 : transformVersion !== 0;
+
+      if (isTransformed) {
+        transformLength = this.readBase128();
+      }
+
+      tables.push({
+        tag: tag,
+        flags: transformVersion,
+        dstLength: dstLength,
+        transformLength: transformLength,
+      });
+    }
+    return tables;
+  }
+
+  public getFormat(): string {
+    return 'woff2';
+  }
+}

src/fonts/transformers/woff2-transformer.ts

@@ -0,0 +1,67 @@
+// This file will contain the logic for reversing WOFF2 table transformations.
+// The primary focus will be on the 'glyf' and 'loca' tables.
+// The implementation will be ported from the C++ source in _ext/woff2_original_cpp/src/woff2_dec.cc.
+import { BitReader } from '../../compression/brotli/bit-reader';
+
+interface Point {
+  x: number;
+  y: number;
+  onCurve: boolean;
+}
+
+function withSign(flag: number, baseval: number): number {
+  return (flag & 1) ? baseval : -baseval;
+}
+
+function tripletDecode(flagsIn: Uint8Array, inStream: BitReader, nPoints: number): Point[] {
+  const points: Point[] = [];
+  let x = 0;
+  let y = 0;
+
+  for (let i = 0; i < nPoints; i++) {
+    const flag = flagsIn[i];
+    const onCurve = !(flag >> 7);
+    const flagBits = flag & 0x7f;
+    let dx: number, dy: number;
+
+    if (flagBits < 84) {
+      const b0 = flagBits - 20;
+      const b1 = inStream.readBits(8);
+      dx = withSign(flag, 1 + (b0 & 0x30) + (b1 >> 4));
+      dy = withSign(flag >> 1, 1 + ((b0 & 0x0c) << 2) + (b1 & 0x0f));
+    } else if (flagBits < 120) {
+      const b0 = flagBits - 84;
+      dx = withSign(flag, 1 + ((b0 / 12) << 8) + inStream.readBits(8));
+      dy = withSign(flag >> 1, 1 + (((b0 % 12) >> 2) << 8) + inStream.readBits(8));
+    } else if (flagBits < 124) {
+      const b2 = inStream.readBits(8);
+      dx = withSign(flag, (inStream.readBits(8) << 4) + (b2 >> 4));
+      dy = withSign(flag >> 1, ((b2 & 0x0f) << 8) + inStream.readBits(8));
+    } else {
+      dx = withSign(flag, (inStream.readBits(8) << 8) | inStream.readBits(8));
+      dy = withSign(flag >> 1, (inStream.readBits(8) << 8) | inStream.readBits(8));
+    }
+
+    x += dx;
+    y += dy;
+    points.push({ x, y, onCurve });
+  }
+
+  return points;
+}
+
+
+export function reconstructGlyfTable(transformedData: Uint8Array, locaData: Uint8Array): { glyf: Uint8Array, loca: Uint8Array } {
+  const reader = new BitReader(transformedData);
+  const version = reader.readBits(16);
+  const numGlyphs = reader.readBits(16);
+  const indexFormat = reader.readBits(16);
+
+  // This is a simplified placeholder for the full 'glyf' table reconstruction.
+  // A complete implementation requires porting the entire ReconstructGlyf function,
+  // which includes handling composite glyphs, instructions, and substreams.
+  const glyfTable = new Uint8Array(0);
+  const locaTable = new Uint8Array((numGlyphs + 1) * (indexFormat === 0 ? 2 : 4));
+
+  return { glyf: glyfTable, loca: locaTable };
+}