pagyra-js 0.0.1

package/src/pdf/font/ttf-cmap.ts

@@ -0,0 +1,180 @@
+import type { CmapData } from "../../types/fonts.js";
+import { TtfTableParser } from "./ttf-table-parser.js";
+
+// cmap table tags / helpers could live here if needed
+
+export class CmapParser implements CmapData {
+  public readonly unicodeMap = new Map<number, number>();
+
+  constructor(parser: TtfTableParser, cmapTable: DataView) {
+    this.parseCmapTable(parser, cmapTable);
+  }
+
+  private parseCmapTable(parser: TtfTableParser, table: DataView): void {
+    if (table.byteLength < 4) throw new Error("Truncated cmap header");
+
+    const version = table.getUint16(0, false);
+    if (version !== 0) return; // only support version 0 for now
+
+    const numSubtables = table.getUint16(2, false);
+    const subtables: { platformId: number; encodingId: number; offset: number }[] = [];
+
+    // collect subtables with bounds checks
+    const expectedDirLen = 4 + numSubtables * 8;
+    if (expectedDirLen > table.byteLength) throw new Error("Truncated cmap subtables directory");
+
+    for (let i = 0; i < numSubtables; i++) {
+      const subtableOffset = 4 + i * 8;
+      const platformId = table.getUint16(subtableOffset, false);
+      const encodingId = table.getUint16(subtableOffset + 2, false);
+      const offset = table.getUint32(subtableOffset + 4, false);
+
+      if (offset >= table.byteLength) {
+        throw new Error("Invalid subtable offset in cmap");
+      }
+
+      subtables.push({ platformId, encodingId, offset });
+    }
+
+    // Selection strategy: prefer Platform 0 (Unicode) format 12/4, then Platform 3 encIDs 10/1 (format 12/4),
+    // otherwise fall back to any format 4 available.
+    const pickSubtable = (): { platformId: number; encodingId: number; offset: number } | null => {
+      const findPreferred = (platforms: { pid: number; eids: number[] }[]) => {
+        for (const p of platforms) {
+          for (const st of subtables) {
+            if (st.platformId !== p.pid) continue;
+            if (p.eids.length > 0 && !p.eids.includes(st.encodingId)) continue;
+
+            if (st.offset + 2 <= table.byteLength) {
+              const fmt = table.getUint16(st.offset, false);
+              if (fmt === 12) return st;
+            }
+          }
+        }
+        for (const p of platforms) {
+          for (const st of subtables) {
+            if (st.platformId !== p.pid) continue;
+            if (p.eids.length > 0 && !p.eids.includes(st.encodingId)) continue;
+            if (st.offset + 2 <= table.byteLength) {
+              const fmt = table.getUint16(st.offset, false);
+              if (fmt === 4) return st;
+            }
+          }
+        }
+        return null;
+      };
+
+      let chosen = findPreferred([{ pid: 0, eids: [] }]);
+      if (chosen) return chosen;
+
+      chosen = findPreferred([{ pid: 3, eids: [10] }, { pid: 3, eids: [1] }]);
+      if (chosen) return chosen;
+
+      for (const st of subtables) {
+        if (st.offset + 2 <= table.byteLength && table.getUint16(st.offset, false) === 4) return st;
+      }
+
+      return null;
+    };
+
+    const selected = pickSubtable();
+    if (!selected) {
+      // No suitable cmap found — leave unicodeMap empty.
+      return;
+    }
+
+    const format = table.getUint16(selected.offset, false);
+    if (format === 4) {
+      this.parseFormat4Table(parser, table, selected.offset);
+    } else if (format === 12) {
+      this.parseFormat12Table(parser, table, selected.offset);
+    } else {
+      // unsupported format for now; leave empty
+      return;
+    }
+  }
+
+  private parseFormat4Table(_parser: TtfTableParser, table: DataView, offset: number): void {
+    if (offset + 8 > table.byteLength) throw new Error("Truncated cmap format 4 header");
+    const format = table.getUint16(offset, false);
+    if (format !== 4) throw new Error("Unexpected cmap format (not 4)");
+
+    const length = table.getUint16(offset + 2, false);
+    if (offset + length > table.byteLength) throw new Error("Truncated cmap format 4 table");
+
+    const segCountX2 = table.getUint16(offset + 6, false);
+    const segCount = segCountX2 / 2;
+
+    const endCodeOffset = offset + 14;
+    const startCodeOffset = endCodeOffset + segCount * 2 + 2;
+    const idDeltaOffset = startCodeOffset + segCount * 2;
+    const idRangeOffsetOffset = idDeltaOffset + segCount * 2;
+
+    if (idRangeOffsetOffset > offset + length) throw new Error("Truncated cmap format 4 arrays");
+
+    for (let i = 0; i < segCount; i++) {
+      const endCode = table.getUint16(endCodeOffset + i * 2, false);
+      const startCode = table.getUint16(startCodeOffset + i * 2, false);
+      const idDelta = table.getInt16(idDeltaOffset + i * 2, false); // signed
+      const idRangeOffset = table.getUint16(idRangeOffsetOffset + i * 2, false);
+
+      if (startCode === 0xffff) break;
+
+      if (startCode > endCode) throw new Error("Invalid cmap segment (startCode > endCode)");
+
+      for (let code = startCode; code <= endCode; code++) {
+        let glyphId = 0;
+
+        if (idRangeOffset === 0) {
+          glyphId = (code + idDelta) & 0xffff;
+        } else {
+          const idRangeWordOffset = idRangeOffsetOffset + i * 2;
+          const glyphIndexOffset = idRangeWordOffset + idRangeOffset + (code - startCode) * 2;
+
+          if (glyphIndexOffset + 2 > offset + length) {
+            throw new Error("Truncated cmap glyphIndexArray");
+          }
+
+          glyphId = table.getUint16(glyphIndexOffset, false);
+          if (glyphId !== 0) {
+            glyphId = (glyphId + idDelta) & 0xffff;
+          }
+        }
+
+        this.unicodeMap.set(code, glyphId);
+      }
+    }
+  }
+
+  private parseFormat12Table(_parser: TtfTableParser, table: DataView, offset: number): void {
+    // Format 12 uses 32-bit fields
+    if (offset + 16 > table.byteLength) throw new Error("Truncated cmap format 12 header");
+    const format = table.getUint16(offset, false);
+    if (format !== 12) throw new Error("Unexpected cmap format (not 12)");
+    const nGroups = table.getUint32(offset + 12, false);
+    const groupsOffset = offset + 16;
+    const required = groupsOffset + nGroups * 12;
+    if (required > table.byteLength) throw new Error("Truncated cmap format 12 groups");
+
+    let p = groupsOffset;
+    for (let g = 0; g < nGroups; g++, p += 12) {
+      const startCode = table.getUint32(p, false);
+      const endCode = table.getUint32(p + 4, false);
+      const startGID = table.getUint32(p + 8, false);
+
+      if (startCode > endCode) throw new Error("Invalid cmap format 12 group (startCode > endCode)");
+
+      for (let cp = startCode; cp <= endCode; cp++) {
+        this.unicodeMap.set(cp, startGID + (cp - startCode));
+      }
+    }
+  }
+
+  getGlyphId(codePoint: number): number {
+    return this.unicodeMap.get(codePoint) ?? 0;
+  }
+
+  hasCodePoint(codePoint: number): boolean {
+    return this.unicodeMap.has(codePoint);
+  }
+}

package/src/pdf/font/ttf-global-metrics.ts

@@ -0,0 +1,58 @@
+import type { TtfMetrics } from "../../types/fonts.js";
+import { TtfTableParser } from "./ttf-table-parser.js";
+
+// Table tags
+const HEAD = 0x68656164; // 'head'
+const HHEA = 0x68686561; // 'hhea'
+const OS_2 = 0x4f532f32; // 'OS/2'
+
+export function parseGlobalMetrics(parser: TtfTableParser): { metrics: TtfMetrics; numberOfHMetricsRaw: number; headBBox?: readonly [number, number, number, number] } {
+  const headTable = parser.getTable(HEAD);
+  if (!headTable) throw new Error("Missing head table");
+
+  const unitsPerEm = parser.getUint16(headTable, 18);
+
+  const hheaTable = parser.getTable(HHEA);
+  if (!hheaTable) throw new Error("Missing hhea table");
+
+  const ascender = parser.getInt16(hheaTable, 4);
+  const descender = parser.getInt16(hheaTable, 6);
+  const lineGap = parser.getInt16(hheaTable, 8);
+  const numberOfHMetricsRaw = parser.getUint16(hheaTable, 34);
+
+  // Parse OS/2 table for optional cap/x heights
+  const os2Table = parser.getTable(OS_2);
+  let capHeight = ascender;
+  let xHeight = Math.round(ascender * 0.5);
+
+  // Only use OS/2 capHeight/xHeight if the table exists and version >= 2 (fields present)
+  if (os2Table && os2Table.byteLength >= 4) {
+    const os2Version = parser.getUint16(os2Table, 0);
+    if (os2Version >= 2 && os2Table.byteLength >= 96) {
+      capHeight = parser.getInt16(os2Table, 88);
+      xHeight = parser.getInt16(os2Table, 86);
+    }
+  }
+
+  // Read head bbox (xMin, yMin, xMax, yMax) if present
+  let headBBox: readonly [number, number, number, number] | undefined = undefined;
+  // head table contains bbox at offsets 36..42 (int16)
+  if (headTable.byteLength >= 44) {
+    const xMin = parser.getInt16(headTable, 36);
+    const yMin = parser.getInt16(headTable, 38);
+    const xMax = parser.getInt16(headTable, 40);
+    const yMax = parser.getInt16(headTable, 42);
+    headBBox = [xMin, yMin, xMax, yMax];
+  }
+
+  const metrics: TtfMetrics = {
+    unitsPerEm,
+    ascender,
+    descender,
+    lineGap,
+    capHeight,
+    xHeight
+  };
+
+  return { metrics, numberOfHMetricsRaw, headBBox };
+}

package/src/pdf/font/ttf-glyf.ts

@@ -0,0 +1,125 @@
+import type { GlyphOutlineCmd } from "../../types/fonts.js";
+import type { GlyphTableProvider } from "./ttf-table-provider.js";
+import type { GlyphOutlineProvider } from "./composite-glyph-parser.js";
+import { LocaTableReader } from "./loca-reader.js";
+import { SimpleGlyphParser } from "./simple-glyph-parser.js";
+import { CompositeGlyphParser } from "./composite-glyph-parser.js";
+
+// Table tags
+const LOCA = 0x6c6f6361; // 'loca'
+const GLYF = 0x676c7966; // 'glyf'
+const HEAD = 0x68656164; // 'head'
+
+/**
+ * Minimal TrueType glyf/loca parser.
+ *
+ * - Supports simple glyphs (contours with on-curve + off-curve quadratic points).
+ * - Supports composite glyphs (components with transformations).
+ * - Provides robust bounds checks and defensive behavior.
+ *
+ * Produces a function getGlyphOutline(gid) => GlyphOutlineCmd[] | null
+ */
+
+/**
+ * Creates a glyph outline provider function for a TrueType font.
+ * @param parser - Provider for accessing font tables and reading binary data
+ * @returns Function that returns glyph outline commands for a given glyph ID
+ */
+export function createGlyfOutlineProvider(
+  parser: GlyphTableProvider
+): (gid: number) => GlyphOutlineCmd[] | null {
+
+  // Read head table to determine loca format
+  const headTable = parser.getTable(HEAD);
+  if (!headTable) {
+    return () => null; // Cannot determine loca format
+  }
+
+  const indexToLocFormat = readIndexToLocFormat(headTable, parser);
+
+  // Get required tables
+  const locaTable = parser.getTable(LOCA);
+  const glyfTable = parser.getTable(GLYF);
+
+  if (!locaTable || !glyfTable) {
+    return () => null;
+  }
+
+  // Initialize parsers and readers
+  const locaReader = new LocaTableReader(locaTable, indexToLocFormat, parser);
+  const simpleParser = new SimpleGlyphParser(parser);
+  const compositeParser = new CompositeGlyphParser(parser);
+
+  /**
+   * Internal recursive function for getting glyph outlines.
+   * @param gid - Glyph ID
+   * @param depth - Current recursion depth
+   * @returns Glyph outline commands or null
+   */
+  const getOutlineInternal = (gid: number, depth: number = 0): GlyphOutlineCmd[] | null => {
+    // Get glyph offset range from loca table
+    const range = locaReader.getGlyphOffset(gid);
+    if (!range) return null;
+
+    // Check for empty glyph
+    if (range.start === range.end) return null;
+
+    // Validate range against glyf table size
+    if (!locaReader.validateRange(range, glyfTable.byteLength)) return null;
+
+    // Create DataView for this glyph's data
+    const view = createGlyphView(glyfTable, range.start, range.end);
+    if (!view || view.byteLength < 10) return null;
+
+    // Read numberOfContours to determine glyph type
+    const numberOfContours = view.getInt16(0, false);
+
+    if (numberOfContours >= 0) {
+      // Simple glyph
+      return simpleParser.parse(view);
+    } else {
+      // Composite glyph
+      const provider: GlyphOutlineProvider = {
+        getOutline: (componentGid: number, componentDepth?: number) =>
+          getOutlineInternal(componentGid, componentDepth ?? 0)
+      };
+      return compositeParser.parse(view, provider, depth);
+    }
+  };
+
+  // Return the public provider function
+  return (gid: number) => getOutlineInternal(gid, 0);
+}
+
+/**
+ * Reads the indexToLocFormat field from the head table.
+ * @param headTable - DataView of the head table
+ * @param reader - Binary data reader
+ * @returns Format value (0 = short, 1 = long)
+ */
+function readIndexToLocFormat(headTable: DataView, reader: GlyphTableProvider): number {
+  try {
+    // indexToLocFormat is at offset 50 in the head table
+    return reader.getUint16(headTable, 50);
+  } catch {
+    return 0; // Default to short format on error
+  }
+}
+
+/**
+ * Creates a DataView for a specific glyph's data within the glyf table.
+ * @param glyfTable - DataView of the glyf table
+ * @param start - Start offset
+ * @param end - End offset
+ * @returns DataView for the glyph data, or null if invalid
+ */
+function createGlyphView(glyfTable: DataView, start: number, end: number): DataView | null {
+  try {
+    return new DataView(glyfTable.buffer, glyfTable.byteOffset + start, end - start);
+  } catch {
+    return null;
+  }
+}
+
+// Re-export types for convenience
+export type { GlyphTableProvider } from "./ttf-table-provider.js";

package/src/pdf/font/ttf-glyph-metrics.ts

@@ -0,0 +1,43 @@
+import type { GlyphMetrics } from "../../types/fonts.js";
+import { TtfTableParser } from "./ttf-table-parser.js";
+
+// Table tags
+const HMTX = 0x686d7478; // 'hmtx'
+
+export function parseGlyphMetrics(
+  parser: TtfTableParser,
+  numberOfHMetrics: number,
+  numGlyphs: number
+): Map<number, GlyphMetrics> {
+  const hmtxTable = parser.getTable(HMTX);
+  if (!hmtxTable) throw new Error("Missing hmtx table");
+
+  const glyphMetrics = new Map<number, GlyphMetrics>();
+
+  // Validate long metrics length
+  const longBytes = numberOfHMetrics * 4;
+  if (hmtxTable.byteLength < longBytes) {
+    throw new Error("Truncated hmtx long metrics");
+  }
+
+  // Read first numberOfHMetrics entries (advanceWidth + lsb)
+  let lastAdvanceWidth = 0;
+  for (let gid = 0; gid < numGlyphs; gid++) {
+    if (gid < numberOfHMetrics) {
+      const off = gid * 4;
+      if (off + 4 > hmtxTable.byteLength) throw new Error("Truncated hmtx entry");
+      const advanceWidth = parser.getUint16(hmtxTable, off);
+      const leftSideBearing = parser.getInt16(hmtxTable, off + 2);
+      glyphMetrics.set(gid, { advanceWidth, leftSideBearing });
+      lastAdvanceWidth = advanceWidth;
+    } else {
+      // LSBs follow after long metrics
+      const lsbOff = longBytes + (gid - numberOfHMetrics) * 2;
+      if (lsbOff + 2 > hmtxTable.byteLength) throw new Error("Truncated hmtx LSB array");
+      const leftSideBearing = parser.getInt16(hmtxTable, lsbOff);
+      glyphMetrics.set(gid, { advanceWidth: lastAdvanceWidth, leftSideBearing });
+    }
+  }
+
+  return glyphMetrics;
+}

package/src/pdf/font/ttf-lite.ts

@@ -0,0 +1,269 @@
+import { readFileSync } from "fs";
+import { TtfFontMetrics } from "../../types/fonts.js";
+import { TtfTableParser } from "./ttf-table-parser.js";
+import { parseGlobalMetrics } from "./ttf-global-metrics.js";
+import { parseGlyphMetrics } from "./ttf-glyph-metrics.js";
+import { CmapParser } from "./ttf-cmap.js";
+import { createGlyfOutlineProvider } from "./ttf-glyf.js";
+import type { KerningMap } from "../../types/fonts.js";
+
+export function parseTtfBuffer(buffer: ArrayBuffer): TtfFontMetrics {
+  const parser = new TtfTableParser(buffer);
+
+  // Parse global metrics (head, hhea, OS/2)
+  const { metrics, numberOfHMetricsRaw, headBBox } = parseGlobalMetrics(parser);
+
+  // Parse maxp for numGlyphs
+  const MAXP = 0x6d617870; // 'maxp'
+  const maxpTable = parser.getTable(MAXP);
+  if (!maxpTable) throw new Error("Missing maxp table");
+
+  const numGlyphs = parser.getUint16(maxpTable, 4);
+
+  // Clamp numberOfHMetrics to glyph count
+  const numberOfHMetrics = Math.min(numberOfHMetricsRaw, numGlyphs);
+
+  // Parse glyph metrics
+  const glyphMetrics = parseGlyphMetrics(parser, numberOfHMetrics, numGlyphs);
+
+  // Parse cmap
+  const CMAP = 0x636d6170; // 'cmap'
+  const cmapTable = parser.getTable(CMAP);
+  if (!cmapTable) throw new Error("Missing cmap table");
+
+  const cmap = new CmapParser(parser, cmapTable);
+  const kerning = mergeKerningMaps(parseKerningTable(parser), parseGposKerning(parser));
+
+  const glyfProvider = createGlyfOutlineProvider(parser);
+  return new TtfFontMetrics(metrics, glyphMetrics, cmap, headBBox, glyfProvider, kerning);
+}
+
+export function parseTtfFont(filePath: string): TtfFontMetrics {
+  const buffer = readFileSync(filePath);
+  const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  return parseTtfBuffer(arrayBuffer);
+}
+
+/**
+ * Parse the 'kern' table (format 0) into a nested map of adjustments in font units.
+ * Returns undefined when the table is missing or unsupported.
+ */
+function parseKerningTable(parser: TtfTableParser): KerningMap | undefined {
+  const KERN = 0x6b65726e; // 'kern'
+  const table = parser.getTable(KERN);
+  if (!table) return undefined;
+
+  // kern header: version (uint16), nTables (uint16)
+  if (table.byteLength < 4) return undefined;
+  const nTables = table.getUint16(2, false);
+  let offset = 4;
+  const result: KerningMap = new Map();
+
+  for (let i = 0; i < nTables; i++) {
+    if (offset + 6 > table.byteLength) break;
+    const subtableVersion = table.getUint16(offset, false);
+    const length = table.getUint16(offset + 2, false);
+    const coverage = table.getUint16(offset + 4, false);
+    const format = coverage >> 8;
+    // Only support format 0 (uni-directional kerning pairs)
+    if (subtableVersion === 0 && format === 0) {
+      if (offset + length > table.byteLength) break;
+      const stOffset = offset + 6;
+      if (stOffset + 8 > table.byteLength) break;
+      const pairCount = table.getUint16(stOffset, false);
+      // skip searchRange, entrySelector, rangeShift (next 6 bytes)
+      let cursor = stOffset + 8;
+      for (let p = 0; p < pairCount; p++) {
+        if (cursor + 6 > table.byteLength) break;
+        const left = table.getUint16(cursor, false);
+        const right = table.getUint16(cursor + 2, false);
+        const value = table.getInt16(cursor + 4, false);
+        if (value !== 0) {
+          const rightMap = result.get(left) ?? new Map<number, number>();
+          rightMap.set(right, value);
+          result.set(left, rightMap);
+        }
+        cursor += 6;
+      }
+    }
+    offset += length;
+  }
+
+  return result.size > 0 ? result : undefined;
+}
+
+/**
+ * Parse GPOS PairPos (format 1) kerning into a nested map.
+ * Supports value1 xAdvance/xPlacement adjustments; ignores class-based and other lookup types.
+ */
+function parseGposKerning(parser: TtfTableParser): KerningMap | undefined {
+  const GPOS = 0x47504f53; // 'GPOS'
+  const table = parser.getTable(GPOS);
+  if (!table) return undefined;
+
+  // Header
+  if (table.byteLength < 10) return undefined;
+  const gposStart = 0;
+  const lookupListOffset = table.getUint16(gposStart + 8, false);
+  if (lookupListOffset === 0 || lookupListOffset >= table.byteLength) return undefined;
+
+  const kerning: KerningMap = new Map();
+
+  // Lookup list
+  const lookupCount = table.getUint16(gposStart + lookupListOffset, false);
+  let lookupOffsetsPos = gposStart + lookupListOffset + 2;
+  for (let li = 0; li < lookupCount; li++) {
+    if (lookupOffsetsPos + 2 > table.byteLength) break;
+    const lookupOffset = table.getUint16(lookupOffsetsPos, false);
+    lookupOffsetsPos += 2;
+    if (lookupOffset === 0 || gposStart + lookupOffset >= table.byteLength) continue;
+
+    const lookupStart = gposStart + lookupOffset;
+    if (lookupStart + 6 > table.byteLength) continue;
+    const lookupType = table.getUint16(lookupStart, false);
+    const subTableCount = table.getUint16(lookupStart + 4, false);
+    let subTableOffsetsPos = lookupStart + 6;
+
+    if (lookupType !== 2) {
+      // Only Pair Adjustment lookups
+      continue;
+    }
+
+    for (let si = 0; si < subTableCount; si++) {
+      if (subTableOffsetsPos + 2 > table.byteLength) break;
+      const stOffset = table.getUint16(subTableOffsetsPos, false);
+      subTableOffsetsPos += 2;
+      if (stOffset === 0 || lookupStart + stOffset >= table.byteLength) continue;
+      const stStart = lookupStart + stOffset;
+      if (stStart + 10 > table.byteLength) continue;
+
+      const format = table.getUint16(stStart, false);
+      if (format !== 1) {
+        // Only handle PairPos format 1 (per-glyph pair sets)
+        continue;
+      }
+
+      const coverageOffset = table.getUint16(stStart + 2, false);
+      const valueFormat1 = table.getUint16(stStart + 4, false);
+      const valueFormat2 = table.getUint16(stStart + 6, false);
+      const pairSetCount = table.getUint16(stStart + 8, false);
+
+      const coverage = parseCoverageTable(table, stStart + coverageOffset);
+      const pairSetOffsetsStart = stStart + 10;
+
+      for (let pi = 0; pi < pairSetCount; pi++) {
+        const leftGlyph = coverage[pi];
+        if (leftGlyph === undefined) continue;
+
+        const pairSetOffsetPos = pairSetOffsetsStart + pi * 2;
+        if (pairSetOffsetPos + 2 > table.byteLength) break;
+        const pairSetOffset = table.getUint16(pairSetOffsetPos, false);
+        if (pairSetOffset === 0 || stStart + pairSetOffset >= table.byteLength) continue;
+
+        const pairSetStart = stStart + pairSetOffset;
+        if (pairSetStart + 2 > table.byteLength) continue;
+        const pairValueCount = table.getUint16(pairSetStart, false);
+        let recPos = pairSetStart + 2;
+
+        for (let r = 0; r < pairValueCount; r++) {
+          if (recPos + 2 > table.byteLength) break;
+          const rightGlyph = table.getUint16(recPos, false);
+          recPos += 2;
+
+          const val1 = readValueRecord(table, recPos, valueFormat1);
+          recPos += val1.length;
+
+          const val2 = readValueRecord(table, recPos, valueFormat2);
+          recPos += val2.length;
+
+          const adjust = (val1.xAdvance ?? 0) + (val1.xPlacement ?? 0) + (val2.xPlacement ?? 0);
+          if (adjust !== 0) {
+            const rightMap = kerning.get(leftGlyph) ?? new Map<number, number>();
+            rightMap.set(rightGlyph, adjust);
+            kerning.set(leftGlyph, rightMap);
+          }
+        }
+      }
+    }
+  }
+
+  return kerning.size > 0 ? kerning : undefined;
+}
+
+function parseCoverageTable(table: DataView, offset: number): number[] {
+  if (offset + 4 > table.byteLength) return [];
+  const format = table.getUint16(offset, false);
+  if (format === 1) {
+    const count = table.getUint16(offset + 2, false);
+    const glyphs: number[] = [];
+    let pos = offset + 4;
+    for (let i = 0; i < count; i++) {
+      if (pos + 2 > table.byteLength) break;
+      glyphs.push(table.getUint16(pos, false));
+      pos += 2;
+    }
+    return glyphs;
+  }
+  if (format === 2) {
+    const rangeCount = table.getUint16(offset + 2, false);
+    const glyphs: number[] = [];
+    let pos = offset + 4;
+    for (let i = 0; i < rangeCount; i++) {
+      if (pos + 6 > table.byteLength) break;
+      const start = table.getUint16(pos, false);
+      const end = table.getUint16(pos + 2, false);
+      const startCoverage = table.getUint16(pos + 4, false);
+      for (let g = 0; g <= end - start; g++) {
+        glyphs[startCoverage + g] = start + g;
+      }
+      pos += 6;
+    }
+    return glyphs;
+  }
+  return [];
+}
+
+function readValueRecord(table: DataView, offset: number, valueFormat: number): { xAdvance?: number; xPlacement?: number; length: number } {
+  let pos = offset;
+  let xPlacement: number | undefined;
+  let xAdvance: number | undefined;
+
+  const consume = (flag: number) => {
+    const v = table.getInt16(pos, false);
+    pos += 2;
+    return v;
+  };
+
+  if (valueFormat & 0x0001) xPlacement = consume(0x0001);
+  if (valueFormat & 0x0002) consume(0x0002); // yPlacement (ignored)
+  if (valueFormat & 0x0004) xAdvance = consume(0x0004);
+  if (valueFormat & 0x0008) consume(0x0008); // yAdvance (ignored)
+
+  // Skip Device/Variation tables if present (we don't apply them; consume offsets)
+  const deviceFlags = [0x0010, 0x0020, 0x0040, 0x0080];
+  for (const flag of deviceFlags) {
+    if (valueFormat & flag) {
+      pos += 2;
+    }
+  }
+
+  return { xAdvance, xPlacement, length: pos - offset };
+}
+
+function mergeKerningMaps(a?: KerningMap, b?: KerningMap): KerningMap | undefined {
+  if (!a && !b) return undefined;
+  const result: KerningMap = new Map();
+  const add = (map?: KerningMap) => {
+    if (!map) return;
+    for (const [left, rights] of map.entries()) {
+      const target = result.get(left) ?? new Map<number, number>();
+      for (const [right, val] of rights.entries()) {
+        target.set(right, (target.get(right) ?? 0) + val);
+      }
+      result.set(left, target);
+    }
+  };
+  add(a);
+  add(b);
+  return result;
+}