@strav/pdf 0.4.17

package/src/fonts/sfnt.ts

@@ -0,0 +1,224 @@
+/**
+ * SFNT container parsing (spec §10.2). Reads the table directory and the
+ * `head` / `hhea` / `maxp` tables. TrueType (`glyf`) is the milestone-5 path;
+ * OpenType/CFF (`OTTO`) is rejected here and arrives in milestone 7.
+ *
+ * Supports a single-face `.ttf`/`.otf` and a `.ttc` collection (face picked by
+ * index). For a `.ttc` face the referenced tables are re-serialized into a
+ * standalone SFNT so it can be embedded as a `FontFile2`.
+ */
+
+import { BinaryReader } from '../util/binary.ts'
+import { UnsupportedFontError, PdfGenError } from '../util/errors.ts'
+
+const TTF_TRUE = 0x00010000
+const TTF_TAG_true = 0x74727565 // 'true'
+const TTF_TAG_ttcf = 0x74746366 // 'ttcf'
+const TTF_TAG_OTTO = 0x4f54544f // 'OTTO'
+
+export interface TableRecord {
+  tag: string
+  offset: number
+  length: number
+}
+
+export interface HeadTable {
+  unitsPerEm: number
+  /** 0 = short loca (offsets ×2), 1 = long loca. */
+  indexToLocFormat: 0 | 1
+  xMin: number
+  yMin: number
+  xMax: number
+  yMax: number
+  macStyle: number
+}
+
+export interface HheaTable {
+  ascent: number
+  descent: number
+  lineGap: number
+  numberOfHMetrics: number
+}
+
+function tagToStr(n: number): string {
+  return String.fromCharCode((n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff)
+}
+
+export class SfntFont {
+  readonly tables = new Map<string, TableRecord>()
+  readonly head: HeadTable
+  readonly hhea: HheaTable
+  readonly numGlyphs: number
+
+  /** The standalone SFNT bytes to embed (verbatim, or rebuilt for a TTC). */
+  readonly programBytes: Uint8Array
+
+  constructor(bytes: Uint8Array, faceIndex = 0) {
+    const r = new BinaryReader(bytes)
+    const sfntVersion = r.u32()
+
+    if (sfntVersion === TTF_TAG_ttcf) {
+      r.u32() // major/minor version
+      const numFonts = r.u32()
+      if (faceIndex < 0 || faceIndex >= numFonts) {
+        throw new PdfGenError(
+          'PDF_UNSUPPORTED_FONT',
+          `TTC face index ${faceIndex} out of range (0..${numFonts - 1})`
+        )
+      }
+      const offsets: number[] = []
+      for (let i = 0; i < numFonts; i++) offsets.push(r.u32())
+      this.readDirectory(bytes, offsets[faceIndex]!)
+      this.programBytes = this.rebuildSfnt(bytes)
+    } else if (
+      sfntVersion === TTF_TRUE ||
+      sfntVersion === TTF_TAG_true ||
+      sfntVersion === TTF_TAG_OTTO // OpenType/CFF — same SFNT container
+    ) {
+      this.readDirectory(bytes, 0)
+      this.programBytes = bytes // single face — embed verbatim
+    } else {
+      throw new UnsupportedFontError(
+        `Unrecognized font format (sfnt version 0x${sfntVersion.toString(16)})`
+      )
+    }
+
+    this.head = this.parseHead()
+    this.hhea = this.parseHhea()
+    this.numGlyphs = this.parseMaxpNumGlyphs()
+  }
+
+  /** True for an OpenType/CFF font (`CFF ` outlines, no `glyf`/`loca`). */
+  get isCFF(): boolean {
+    return this.tables.has('CFF ')
+  }
+
+  private readDirectory(bytes: Uint8Array, dirOffset: number): void {
+    const r = new BinaryReader(bytes, dirOffset)
+    r.u32() // sfnt version (already validated for the chosen face)
+    const numTables = r.u16()
+    r.u16() // searchRange
+    r.u16() // entrySelector
+    r.u16() // rangeShift
+    for (let i = 0; i < numTables; i++) {
+      const tag = tagToStr(r.u32())
+      r.u32() // checksum
+      const offset = r.u32()
+      const length = r.u32()
+      this.tables.set(tag, { tag, offset, length })
+    }
+  }
+
+  private require(tag: string): TableRecord {
+    const t = this.tables.get(tag)
+    if (!t) {
+      throw new UnsupportedFontError(`Font is missing the required '${tag}' table`)
+    }
+    return t
+  }
+
+  /** Raw bytes of a table (subarray, no copy), or undefined if absent. */
+  table(tag: string): Uint8Array | undefined {
+    const t = this.tables.get(tag)
+    return t ? this.bytes.subarray(t.offset, t.offset + t.length) : undefined
+  }
+
+  private get bytes(): Uint8Array {
+    return this.programBytes
+  }
+
+  private parseHead(): HeadTable {
+    const t = this.require('head')
+    const r = new BinaryReader(this.bytes, t.offset)
+    r.seek(t.offset + 18)
+    const unitsPerEm = r.u16()
+    r.seek(t.offset + 36)
+    const xMin = r.i16()
+    const yMin = r.i16()
+    const xMax = r.i16()
+    const yMax = r.i16()
+    const macStyle = r.u16()
+    r.seek(t.offset + 50)
+    const indexToLocFormat = r.i16() as 0 | 1
+    return { unitsPerEm, indexToLocFormat, xMin, yMin, xMax, yMax, macStyle }
+  }
+
+  private parseHhea(): HheaTable {
+    const t = this.require('hhea')
+    const r = new BinaryReader(this.bytes, t.offset)
+    r.seek(t.offset + 4)
+    const ascent = r.i16()
+    const descent = r.i16()
+    const lineGap = r.i16()
+    r.seek(t.offset + 34)
+    const numberOfHMetrics = r.u16()
+    return { ascent, descent, lineGap, numberOfHMetrics }
+  }
+
+  private parseMaxpNumGlyphs(): number {
+    const t = this.require('maxp')
+    const r = new BinaryReader(this.bytes, t.offset + 4)
+    return r.u16()
+  }
+
+  /** Rebuild a standalone, 4-byte-aligned SFNT from this face's tables. */
+  private rebuildSfnt(src: Uint8Array): Uint8Array {
+    const entries = [...this.tables.values()].sort((a, b) => (a.tag < b.tag ? -1 : 1))
+    const numTables = entries.length
+    const headerLen = 12 + numTables * 16
+
+    const blocks: { rec: TableRecord; data: Uint8Array; offset: number }[] = []
+    let cursor = headerLen
+    for (const rec of entries) {
+      const data = src.subarray(rec.offset, rec.offset + rec.length)
+      blocks.push({ rec, data, offset: cursor })
+      cursor += (rec.length + 3) & ~3 // pad each table to 4 bytes
+    }
+
+    const out = new Uint8Array(cursor)
+    const dv = new DataView(out.buffer)
+    dv.setUint32(0, TTF_TRUE)
+    dv.setUint16(4, numTables)
+    const maxPow = Math.floor(Math.log2(numTables))
+    const searchRange = 16 * 2 ** maxPow
+    dv.setUint16(6, searchRange)
+    dv.setUint16(8, maxPow)
+    dv.setUint16(10, numTables * 16 - searchRange)
+
+    let p = 12
+    for (const b of blocks) {
+      for (let i = 0; i < 4; i++) out[p + i] = b.rec.tag.charCodeAt(i)
+      dv.setUint32(p + 4, tableChecksum(b.data))
+      dv.setUint32(p + 8, b.offset)
+      dv.setUint32(p + 12, b.rec.length)
+      out.set(b.data, b.offset)
+      p += 16
+    }
+
+    // Patch head.checkSumAdjustment, then rewrite this.tables to the new layout.
+    const head = blocks.find(b => b.rec.tag === 'head')
+    if (head) {
+      const adj = (0xb1b0afba - tableChecksum(out)) >>> 0
+      new DataView(out.buffer).setUint32(head.offset + 8, adj)
+    }
+    this.tables.clear()
+    for (const b of blocks) {
+      this.tables.set(b.rec.tag, { tag: b.rec.tag, offset: b.offset, length: b.rec.length })
+    }
+    return out
+  }
+}
+
+/** SFNT table checksum: sum of big-endian uint32s, zero-padded (ISO/OpenType). */
+export function tableChecksum(data: Uint8Array): number {
+  let sum = 0
+  const n = (data.length + 3) & ~3
+  for (let i = 0; i < n; i += 4) {
+    const b0 = data[i] ?? 0
+    const b1 = data[i + 1] ?? 0
+    const b2 = data[i + 2] ?? 0
+    const b3 = data[i + 3] ?? 0
+    sum = (sum + (((b0 << 24) | (b1 << 16) | (b2 << 8) | b3) >>> 0)) >>> 0
+  }
+  return sum >>> 0
+}

package/src/fonts/standard_14.ts

@@ -0,0 +1,132 @@
+/**
+ * The Standard-14 fonts (spec §10.1). Referenced only — never embedded; the
+ * viewer is assumed to have them. Under a conformance mode they are rejected
+ * (enforced in `PdfDocument`); embedded fonts arrive in milestone 5.
+ *
+ * Width tables are the canonical Adobe Core-14 AFM metrics (units per 1000 em)
+ * for the printable ASCII range (codes 32–126). We do **not** emit a `/Widths`
+ * array for Standard-14 fonts (the viewer supplies metrics), so these are used
+ * only by the optional `PdfFont.widthOfText()` helper. Metrics for the
+ * non-ASCII WinAnsi range are approximated by a per-font default and refined
+ * in a later milestone — rendering is unaffected.
+ */
+
+export type StandardFontName =
+  | 'Helvetica'
+  | 'Helvetica-Bold'
+  | 'Helvetica-Oblique'
+  | 'Helvetica-BoldOblique'
+  | 'Times-Roman'
+  | 'Times-Bold'
+  | 'Times-Italic'
+  | 'Times-BoldItalic'
+  | 'Courier'
+  | 'Courier-Bold'
+  | 'Courier-Oblique'
+  | 'Courier-BoldOblique'
+  | 'Symbol'
+  | 'ZapfDingbats'
+
+// Widths for codes 32..126 (index = code - 32).
+const HELVETICA = [
+  278, 278, 355, 556, 556, 889, 667, 191, 333, 333, 389, 584, 278, 333, 278,
+  278, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 278, 278, 584, 584,
+  584, 556, 1015, 667, 667, 722, 722, 667, 611, 778, 722, 278, 500, 667, 556,
+  833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 278,
+  278, 278, 469, 556, 333, 556, 556, 500, 556, 556, 278, 556, 556, 222, 222,
+  500, 222, 833, 556, 556, 556, 556, 333, 500, 278, 556, 500, 722, 500, 500,
+  500, 334, 260, 334, 584,
+]
+
+const HELVETICA_BOLD = [
+  278, 333, 474, 556, 556, 889, 722, 238, 333, 333, 389, 584, 278, 333, 278,
+  278, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 333, 333, 584, 584,
+  584, 611, 975, 722, 722, 722, 722, 667, 611, 778, 722, 278, 556, 722, 611,
+  833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 333,
+  278, 333, 584, 556, 333, 556, 611, 556, 611, 556, 333, 611, 611, 278, 278,
+  556, 278, 889, 611, 611, 611, 611, 389, 556, 333, 611, 556, 778, 556, 556,
+  500, 389, 280, 389, 584,
+]
+
+const TIMES_ROMAN = [
+  250, 333, 408, 500, 500, 833, 778, 180, 333, 333, 500, 564, 250, 333, 250,
+  278, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 278, 278, 564, 564,
+  564, 444, 921, 722, 667, 667, 722, 611, 556, 722, 722, 333, 389, 722, 611,
+  889, 722, 722, 556, 722, 667, 556, 611, 722, 722, 944, 722, 722, 611, 333,
+  278, 333, 469, 500, 333, 444, 500, 444, 500, 444, 333, 500, 500, 278, 278,
+  500, 278, 778, 500, 500, 500, 500, 333, 389, 278, 500, 500, 722, 500, 500,
+  444, 480, 200, 480, 541,
+]
+
+const TIMES_BOLD = [
+  250, 333, 555, 500, 500, 1000, 833, 278, 333, 333, 500, 570, 250, 333, 250,
+  278, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 333, 333, 570, 570,
+  570, 500, 930, 722, 667, 722, 722, 667, 611, 778, 778, 389, 500, 778, 667,
+  944, 722, 778, 611, 778, 722, 556, 667, 722, 722, 1000, 722, 722, 667, 333,
+  278, 333, 581, 500, 333, 500, 556, 444, 556, 444, 333, 500, 556, 278, 333,
+  556, 278, 833, 556, 500, 556, 556, 444, 389, 333, 556, 500, 722, 500, 500,
+  444, 394, 220, 394, 520,
+]
+
+const TIMES_ITALIC = [
+  250, 333, 420, 500, 500, 833, 778, 214, 333, 333, 500, 675, 250, 333, 250,
+  278, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 333, 333, 675, 675,
+  675, 500, 920, 611, 611, 667, 722, 611, 611, 722, 722, 333, 444, 667, 556,
+  833, 667, 722, 611, 722, 611, 500, 556, 722, 611, 833, 611, 556, 556, 389,
+  278, 389, 422, 500, 333, 500, 500, 444, 500, 444, 278, 500, 500, 278, 278,
+  444, 278, 722, 500, 500, 500, 500, 389, 389, 278, 500, 444, 667, 444, 444,
+  389, 400, 275, 400, 541,
+]
+
+const TIMES_BOLD_ITALIC = [
+  250, 389, 555, 500, 500, 833, 778, 278, 333, 333, 500, 570, 250, 333, 250,
+  278, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 333, 333, 570, 570,
+  570, 500, 832, 667, 667, 667, 722, 667, 667, 722, 778, 389, 500, 667, 611,
+  889, 722, 722, 611, 722, 667, 556, 611, 722, 667, 889, 667, 611, 611, 333,
+  278, 333, 570, 500, 333, 500, 500, 444, 500, 444, 333, 500, 556, 278, 278,
+  500, 278, 778, 556, 500, 500, 500, 389, 389, 278, 556, 444, 667, 500, 444,
+  389, 348, 220, 348, 570,
+]
+
+const COURIER_WIDTH = 600 // monospaced — every glyph
+
+interface FontMeta {
+  /** ASCII 32..126 width table, or null for monospaced/symbolic. */
+  ascii: number[] | null
+  /** Width for codes outside 32..126 (and the symbolic fonts). */
+  fallback: number
+  /** WinAnsiEncoding applies (text fonts); Symbol/ZapfDingbats use built-in. */
+  winAnsi: boolean
+}
+
+const META: Record<StandardFontName, FontMeta> = {
+  Helvetica: { ascii: HELVETICA, fallback: 556, winAnsi: true },
+  'Helvetica-Oblique': { ascii: HELVETICA, fallback: 556, winAnsi: true },
+  'Helvetica-Bold': { ascii: HELVETICA_BOLD, fallback: 611, winAnsi: true },
+  'Helvetica-BoldOblique': { ascii: HELVETICA_BOLD, fallback: 611, winAnsi: true },
+  'Times-Roman': { ascii: TIMES_ROMAN, fallback: 500, winAnsi: true },
+  'Times-Bold': { ascii: TIMES_BOLD, fallback: 500, winAnsi: true },
+  'Times-Italic': { ascii: TIMES_ITALIC, fallback: 500, winAnsi: true },
+  'Times-BoldItalic': { ascii: TIMES_BOLD_ITALIC, fallback: 500, winAnsi: true },
+  Courier: { ascii: null, fallback: COURIER_WIDTH, winAnsi: true },
+  'Courier-Bold': { ascii: null, fallback: COURIER_WIDTH, winAnsi: true },
+  'Courier-Oblique': { ascii: null, fallback: COURIER_WIDTH, winAnsi: true },
+  'Courier-BoldOblique': { ascii: null, fallback: COURIER_WIDTH, winAnsi: true },
+  Symbol: { ascii: null, fallback: 600, winAnsi: false },
+  ZapfDingbats: { ascii: null, fallback: 600, winAnsi: false },
+}
+
+export function isStandardFontName(name: string): name is StandardFontName {
+  return name in META
+}
+
+export function usesWinAnsi(name: StandardFontName): boolean {
+  return META[name].winAnsi
+}
+
+/** Glyph width in 1000-em units for a WinAnsi byte (0–255). */
+export function standardGlyphWidth(name: StandardFontName, byte: number): number {
+  const m = META[name]
+  if (m.ascii && byte >= 32 && byte <= 126) return m.ascii[byte - 32]!
+  return m.fallback
+}

package/src/fonts/subset.ts

@@ -0,0 +1,221 @@
+/**
+ * TrueType glyph subsetting (spec §10.3).
+ *
+ * Strategy (per spec): keep the original glyph indices — unused glyphs become
+ * zero-length, trailing unused glyphs are dropped (numGlyphs = maxUsedGid+1).
+ * Because indices are preserved, the content stream's Identity-H codes, the
+ * CIDFont `/W` array, `ToUnicode` and `CIDToGIDMap /Identity` need no rewrite.
+ *
+ * Tables rewritten: `glyf`, `loca` (long), `hmtx`, `maxp.numGlyphs`,
+ * `hhea.numberOfHMetrics`, `head` (indexToLocFormat + checkSumAdjustment).
+ * Every other table is passed through unchanged.
+ *
+ * The 6-letter subset tag is derived from the subset content (sorted glyph
+ * set + source numGlyphs), so identical input → identical font (determinism).
+ */
+
+import { tableChecksum, type SfntFont } from './sfnt.ts'
+import { GlyfTable } from './glyf.ts'
+
+export interface SubsetResult {
+  bytes: Uint8Array
+  /** Six uppercase letters, e.g. `ABCDEF` (caller forms `ABCDEF+Name`). */
+  tag: string
+}
+
+function pad4(n: number): number {
+  return (n + 3) & ~3
+}
+
+/** FNV-1a over the subset's identifying content → 6 uppercase A–Z letters. */
+function subsetTag(sortedGids: number[], srcNumGlyphs: number): string {
+  let h = 0x811c9dc5
+  const mix = (x: number) => {
+    h ^= x & 0xff
+    h = Math.imul(h, 0x01000193) >>> 0
+  }
+  mix(srcNumGlyphs & 0xff)
+  mix((srcNumGlyphs >> 8) & 0xff)
+  for (const g of sortedGids) {
+    mix(g & 0xff)
+    mix((g >> 8) & 0xff)
+  }
+  let tag = ''
+  let v = h >>> 0
+  for (let i = 0; i < 6; i++) {
+    tag += String.fromCharCode(65 + (v % 26))
+    v = Math.floor(v / 26) + 0x9e3779b1 // re-stir so all 6 letters vary
+    v >>>= 0
+  }
+  return tag
+}
+
+/** Read (advance, lsb) for every glyph 0..n-1 from the original hmtx. */
+function readMetrics(
+  hmtx: Uint8Array,
+  numberOfHMetrics: number,
+  count: number
+): { adv: number; lsb: number }[] {
+  const out: { adv: number; lsb: number }[] = []
+  let lastAdv = 0
+  for (let g = 0; g < count; g++) {
+    if (g < numberOfHMetrics) {
+      const o = g * 4
+      lastAdv = (hmtx[o]! << 8) | hmtx[o + 1]!
+      const lsbRaw = (hmtx[o + 2]! << 8) | hmtx[o + 3]!
+      out.push({ adv: lastAdv, lsb: (lsbRaw << 16) >> 16 })
+    } else {
+      const o = numberOfHMetrics * 4 + (g - numberOfHMetrics) * 2
+      const lsbRaw = ((hmtx[o] ?? 0) << 8) | (hmtx[o + 1] ?? 0)
+      out.push({ adv: lastAdv, lsb: (lsbRaw << 16) >> 16 })
+    }
+  }
+  return out
+}
+
+/** Assemble a standalone, 4-byte-aligned SFNT and patch head.checkSumAdjustment. */
+function assembleSfnt(tables: Map<string, Uint8Array>): Uint8Array {
+  const tags = [...tables.keys()].sort()
+  const numTables = tags.length
+  const headerLen = 12 + numTables * 16
+
+  const placed: { tag: string; data: Uint8Array; offset: number; length: number }[] = []
+  let cursor = headerLen
+  for (const tag of tags) {
+    const data = tables.get(tag)!
+    placed.push({ tag, data, offset: cursor, length: data.length })
+    cursor += pad4(data.length)
+  }
+
+  const out = new Uint8Array(cursor)
+  const dv = new DataView(out.buffer)
+  dv.setUint32(0, 0x00010000)
+  dv.setUint16(4, numTables)
+  const maxPow = Math.floor(Math.log2(numTables))
+  const searchRange = 16 * 2 ** maxPow
+  dv.setUint16(6, searchRange)
+  dv.setUint16(8, maxPow)
+  dv.setUint16(10, numTables * 16 - searchRange)
+
+  let p = 12
+  for (const b of placed) {
+    for (let i = 0; i < 4; i++) out[p + i] = b.tag.charCodeAt(i)
+    dv.setUint32(p + 4, tableChecksum(b.data))
+    dv.setUint32(p + 8, b.offset)
+    dv.setUint32(p + 12, b.length)
+    out.set(b.data, b.offset)
+    p += 16
+  }
+
+  const head = placed.find(b => b.tag === 'head')
+  if (head) {
+    dv.setUint32(head.offset + 8, 0) // zero before computing
+    const adj = (0xb1b0afba - tableChecksum(out)) >>> 0
+    dv.setUint32(head.offset + 8, adj)
+  }
+  return out
+}
+
+export function subsetTrueType(
+  sfnt: SfntFont,
+  used: Iterable<number>
+): SubsetResult {
+  const loca = sfnt.table('loca')
+  const glyf = sfnt.table('glyf')
+  if (!loca || !glyf) {
+    throw new Error('subsetTrueType requires a glyf-based TrueType font')
+  }
+  const srcN = sfnt.numGlyphs
+  const glyfTable = new GlyfTable(loca, glyf, srcN, sfnt.head.indexToLocFormat === 1)
+
+  // Used set + transitive composite-component closure; .notdef always in.
+  const keep = new Set<number>([0])
+  const stack: number[] = [0]
+  for (const g of used) {
+    if (g >= 0 && g < srcN && !keep.has(g)) {
+      keep.add(g)
+      stack.push(g)
+    }
+  }
+  while (stack.length) {
+    const g = stack.pop()!
+    for (const comp of glyfTable.componentGids(g)) {
+      if (comp >= 0 && comp < srcN && !keep.has(comp)) {
+        keep.add(comp)
+        stack.push(comp)
+      }
+    }
+  }
+
+  const sortedGids = [...keep].sort((a, b) => a - b)
+  const maxGid = sortedGids[sortedGids.length - 1]!
+  const newN = maxGid + 1
+
+  // Rebuild glyf + long loca, keeping original indices (empty if unused).
+  const glyphs: Uint8Array[] = []
+  const locaOffsets: number[] = []
+  let off = 0
+  for (let gid = 0; gid < newN; gid++) {
+    locaOffsets.push(off)
+    if (keep.has(gid)) {
+      const data = glyfTable.glyphData(gid)
+      const padded = pad4(data.length)
+      const buf = new Uint8Array(padded)
+      buf.set(data)
+      glyphs.push(buf)
+      off += padded
+    }
+  }
+  locaOffsets.push(off)
+
+  const newGlyf = new Uint8Array(off)
+  {
+    let o = 0
+    for (const g of glyphs) {
+      newGlyf.set(g, o)
+      o += g.length
+    }
+  }
+  const newLoca = new Uint8Array((newN + 1) * 4)
+  {
+    const dv = new DataView(newLoca.buffer)
+    for (let i = 0; i <= newN; i++) dv.setUint32(i * 4, locaOffsets[i]!)
+  }
+
+  // Fresh hmtx: full (advance, lsb) pair for every kept glyph.
+  const hmtxTable = sfnt.table('hmtx')!
+  const metrics = readMetrics(hmtxTable, sfnt.hhea.numberOfHMetrics, newN)
+  const newHmtx = new Uint8Array(newN * 4)
+  {
+    const dv = new DataView(newHmtx.buffer)
+    for (let g = 0; g < newN; g++) {
+      dv.setUint16(g * 4, metrics[g]!.adv)
+      dv.setInt16(g * 4 + 2, metrics[g]!.lsb)
+    }
+  }
+
+  // Patched head / hhea / maxp (copies of the originals).
+  const head = Uint8Array.from(sfnt.table('head')!)
+  new DataView(head.buffer, head.byteOffset).setUint32(8, 0) // checkSumAdjustment
+  new DataView(head.buffer, head.byteOffset).setInt16(50, 1) // indexToLocFormat=long
+
+  const hhea = Uint8Array.from(sfnt.table('hhea')!)
+  new DataView(hhea.buffer, hhea.byteOffset).setUint16(34, newN) // numberOfHMetrics
+
+  const maxp = Uint8Array.from(sfnt.table('maxp')!)
+  new DataView(maxp.buffer, maxp.byteOffset).setUint16(4, newN) // numGlyphs
+
+  const out = new Map<string, Uint8Array>()
+  for (const tag of sfnt.tables.keys()) {
+    const data = sfnt.table(tag)
+    if (data) out.set(tag, data)
+  }
+  out.set('glyf', newGlyf)
+  out.set('loca', newLoca)
+  out.set('hmtx', newHmtx)
+  out.set('head', head)
+  out.set('hhea', hhea)
+  out.set('maxp', maxp)
+
+  return { bytes: assembleSfnt(out), tag: subsetTag(sortedGids, srcN) }
+}

package/src/fonts/to_unicode.ts

@@ -0,0 +1,82 @@
+/**
+ * ToUnicode CMap writer (spec §10.6). Maps each used CID/GID back to its
+ * Unicode code point(s) so text is searchable and copy/pasteable (mandatory
+ * for PDF/A). `bfrange` is used for consecutive runs, `bfchar` otherwise.
+ */
+
+function hex4(n: number): string {
+  return n.toString(16).toUpperCase().padStart(4, '0')
+}
+
+/** UTF-16BE hex for one code point (surrogate pair when astral). */
+function utf16beHex(cp: number): string {
+  if (cp <= 0xffff) return hex4(cp)
+  const v = cp - 0x10000
+  return hex4(0xd800 + (v >> 10)) + hex4(0xdc00 + (v & 0x3ff))
+}
+
+const HEADER =
+  '/CIDInit /ProcSet findresource begin\n' +
+  '12 dict begin\n' +
+  'begincmap\n' +
+  '/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n' +
+  '/CMapName /Adobe-Identity-UCS def\n' +
+  '/CMapType 2 def\n' +
+  '1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange\n'
+
+const FOOTER = 'endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend\n'
+
+/**
+ * Build the ToUnicode CMap stream content from a `gid → code point(s)` map.
+ * Single-code-point entries that form consecutive GID→cp runs collapse into
+ * `bfrange`; everything else (and multi-cp entries) uses `bfchar`.
+ */
+export function buildToUnicode(map: Map<number, number[]>): string {
+  const gids = [...map.keys()].sort((a, b) => a - b)
+
+  const ranges: { start: number; end: number; cp: number }[] = []
+  const chars: { gid: number; cps: number[] }[] = []
+
+  for (let i = 0; i < gids.length; ) {
+    const gid = gids[i]!
+    const cps = map.get(gid)!
+    if (cps.length === 1) {
+      let j = i
+      for (;;) {
+        const nextGid = gids[j + 1]
+        if (nextGid === undefined || nextGid !== gids[j]! + 1) break
+        const cur = map.get(gids[j]!)!
+        const nxt = map.get(nextGid)!
+        if (cur.length !== 1 || nxt.length !== 1 || nxt[0]! !== cur[0]! + 1) break
+        j++
+      }
+      if (j > i) {
+        ranges.push({ start: gid, end: gids[j]!, cp: cps[0]! })
+        i = j + 1
+        continue
+      }
+    }
+    chars.push({ gid, cps })
+    i++
+  }
+
+  let body = ''
+  for (let k = 0; k < chars.length; k += 100) {
+    const slice = chars.slice(k, k + 100)
+    body += `${slice.length} beginbfchar\n`
+    for (const { gid, cps } of slice) {
+      body += `<${hex4(gid)}> <${cps.map(utf16beHex).join('')}>\n`
+    }
+    body += 'endbfchar\n'
+  }
+  for (let k = 0; k < ranges.length; k += 100) {
+    const slice = ranges.slice(k, k + 100)
+    body += `${slice.length} beginbfrange\n`
+    for (const { start, end, cp } of slice) {
+      body += `<${hex4(start)}> <${hex4(end)}> <${utf16beHex(cp)}>\n`
+    }
+    body += 'endbfrange\n'
+  }
+
+  return HEADER + body + FOOTER
+}