@strav/pdf 0.4.17

package/src/fonts/font.ts

@@ -0,0 +1,342 @@
+/**
+ * `PdfFont` (spec §10, §16). The public font handle.
+ *
+ * - `PdfFont.standard(name)` — a Standard-14 referenced font (never embedded).
+ * - `PdfFont.fromTrueType(bytes)` — a fully-embedded TrueType font emitted as
+ *   a Type0 / CIDFontType2 with Identity-H encoding and a ToUnicode CMap
+ *   (selectable, copy/pasteable text). Subsetting is milestone 6.
+ *
+ * A font registers itself into the object table via `register(table)`, which
+ * adds however many indirect objects it needs and returns the `/Font` ref to
+ * place in the page resource dictionary.
+ */
+
+import { PdfGenError, UnsupportedFontError } from '../util/errors.ts'
+import { ascii } from '../util/ascii.ts'
+import { arr, dict, name, num } from '../objects/types.ts'
+import type { IndirectRef } from '../objects/types.ts'
+import type { ObjectTable } from '../document/object_table.ts'
+import { makeStream } from '../streams/stream.ts'
+import { encodeWinAnsi } from './win_ansi.ts'
+import {
+  type StandardFontName,
+  isStandardFontName,
+  standardGlyphWidth,
+  usesWinAnsi,
+} from './standard_14.ts'
+import { SfntFont } from './sfnt.ts'
+import { parseCmap, type CmapLookup } from './cmap_table.ts'
+import { Hmtx } from './hmtx.ts'
+import { parseName } from './name_table.ts'
+import { parseOs2, type Os2Metrics } from './os2.ts'
+import { encodeIdentityH, buildWidthsArray } from './cid_encoding.ts'
+import { buildToUnicode } from './to_unicode.ts'
+import { subsetTrueType } from './subset.ts'
+import { parseCff } from './cff.ts'
+
+export type { StandardFontName }
+
+export interface TrueTypeOptions {
+  /** Face to select from a `.ttc` collection (default 0). */
+  faceIndex?: number
+  /** Subset to the glyphs actually used (default true). */
+  subset?: boolean
+}
+
+export abstract class PdfFont {
+  abstract readonly id: string
+  abstract readonly baseFont: string
+  abstract readonly isStandard14: boolean
+
+  /** Encode a string into the bytes that go inside a `Tj`/`TJ` string. */
+  abstract encode(text: string): Uint8Array
+
+  /** Rendered width of `text` in points at `sizePt`. */
+  abstract widthOfText(text: string, sizePt: number): number
+
+  /** Add the font's objects to the table; return the `/Font` reference. */
+  abstract register(table: ObjectTable): IndirectRef
+
+  /** Reference one of the Standard-14 fonts (never embedded, spec §10.1). */
+  static standard(fontName: StandardFontName): PdfFont {
+    return new Standard14Font(fontName)
+  }
+
+  /**
+   * Embed an SFNT font from its `.ttf`/`.otf`/`.ttc` bytes. TrueType (`glyf`)
+   * is subsetted by default; OpenType/CFF (`OTTO`) is embedded whole as a
+   * CIDFontType0 (CFF subsetting is deferred — `subset` is ignored for CFF).
+   */
+  static fromTrueType(bytes: Uint8Array, opts: TrueTypeOptions = {}): PdfFont {
+    return new EmbeddedTrueTypeFont(bytes, opts.faceIndex ?? 0, opts.subset !== false)
+  }
+
+  /** Alias of {@link fromTrueType} — clearer when embedding an `.otf`. */
+  static fromOpenType(bytes: Uint8Array, opts: TrueTypeOptions = {}): PdfFont {
+    return PdfFont.fromTrueType(bytes, opts)
+  }
+}
+
+// ── Standard-14 (referenced, never embedded) ──────────────────────────────
+
+class Standard14Font extends PdfFont {
+  readonly id: string
+  readonly baseFont: string
+  readonly isStandard14 = true
+  private readonly winAnsi: boolean
+
+  constructor(private readonly fontName: StandardFontName) {
+    super()
+    if (!isStandardFontName(fontName)) {
+      throw new PdfGenError('PDF_UNSUPPORTED_FONT', `Unknown Standard-14 font: ${fontName}`)
+    }
+    this.baseFont = fontName
+    this.id = `std14:${fontName}`
+    this.winAnsi = usesWinAnsi(fontName)
+  }
+
+  encode(text: string): Uint8Array {
+    if (this.winAnsi) return encodeWinAnsi(text)
+    const out = new Uint8Array(text.length)
+    for (let i = 0; i < text.length; i++) {
+      const c = text.charCodeAt(i)
+      if (c > 0xff) {
+        throw new PdfGenError(
+          'PDF_TEXT_ENCODING',
+          `${this.baseFont} uses a built-in 8-bit encoding; char U+${c.toString(16)} is out of range`
+        )
+      }
+      out[i] = c
+    }
+    return out
+  }
+
+  widthOfText(text: string, sizePt: number): number {
+    let units = 0
+    for (const byte of this.encode(text)) units += standardGlyphWidth(this.fontName, byte)
+    return (units * sizePt) / 1000
+  }
+
+  register(table: ObjectTable): IndirectRef {
+    const d = dict({
+      Type: name('Font'),
+      Subtype: name('Type1'),
+      BaseFont: name(this.baseFont),
+    })
+    if (this.winAnsi) d.entries.set('Encoding', name('WinAnsiEncoding'))
+    return table.add(d)
+  }
+}
+
+// ── Embedded TrueType → Type0 / CIDFontType2 (Identity-H) ──────────────────
+
+class EmbeddedTrueTypeFont extends PdfFont {
+  readonly id: string
+  readonly baseFont: string
+  readonly isStandard14 = false
+
+  private readonly sfnt: SfntFont
+  private readonly cmap: CmapLookup
+  private readonly hmtx: Hmtx
+  private readonly os2: Os2Metrics | null
+  private readonly italicAngle: number
+  private readonly fixedPitch: boolean
+  /** OpenType/CFF (embedded whole as FontFile3 / CIDFontType0). */
+  private readonly isCFF: boolean
+
+  /** Glyphs referenced so far (drives `/W`); gid → code points for ToUnicode. */
+  private readonly usedGids = new Set<number>()
+  private readonly gidToCps = new Map<number, number[]>()
+
+  private static counter = 0
+
+  constructor(
+    bytes: Uint8Array,
+    faceIndex: number,
+    private readonly doSubset: boolean
+  ) {
+    super()
+    this.sfnt = new SfntFont(bytes, faceIndex)
+
+    const cmap = this.sfnt.table('cmap')
+    if (!cmap) throw new UnsupportedFontError("Font is missing the required 'cmap' table")
+    this.cmap = parseCmap(cmap)
+
+    const hmtx = this.sfnt.table('hmtx')
+    if (!hmtx) throw new UnsupportedFontError("Font is missing the required 'hmtx' table")
+    this.hmtx = new Hmtx(hmtx, this.sfnt.hhea.numberOfHMetrics, this.sfnt.numGlyphs)
+
+    this.os2 = parseOs2(this.sfnt.table('OS/2'))
+
+    this.isCFF = this.sfnt.isCFF
+    const cffTable = this.isCFF ? this.sfnt.table('CFF ') : undefined
+    const cffInfo = cffTable ? parseCff(cffTable) : null
+
+    const nameTable = this.sfnt.table('name')
+    const names = nameTable ? parseName(nameTable) : { postScriptName: null, family: null }
+    const ps = (
+      names.postScriptName ||
+      cffInfo?.name ||
+      names.family ||
+      'EmbeddedFont'
+    ).replace(/[\s()<>[\]{}/%]/g, '')
+    this.baseFont = ps
+    this.id = `${this.isCFF ? 'otf' : 'ttf'}:${ps}:${(EmbeddedTrueTypeFont.counter++).toString()}`
+
+    const post = this.sfnt.table('post')
+    if (post && post.length >= 16) {
+      // italicAngle: Fixed 16.16 at offset 4; isFixedPitch: uint32 at 12.
+      const raw = (post[4]! << 24) | (post[5]! << 16) | (post[6]! << 8) | post[7]!
+      this.italicAngle = raw / 65536
+      this.fixedPitch =
+        ((post[12]! << 24) | (post[13]! << 16) | (post[14]! << 8) | post[15]!) !== 0
+    } else {
+      this.italicAngle = 0
+      this.fixedPitch = false
+    }
+  }
+
+  private gid(cp: number): number {
+    return this.cmap.gidFor(cp)
+  }
+
+  encode(text: string): Uint8Array {
+    const gids: number[] = []
+    for (const ch of text) {
+      const cp = ch.codePointAt(0)!
+      const g = this.gid(cp)
+      gids.push(g)
+      this.usedGids.add(g)
+      if (g !== 0) {
+        const existing = this.gidToCps.get(g)
+        if (!existing) this.gidToCps.set(g, [cp])
+      }
+    }
+    return encodeIdentityH(gids)
+  }
+
+  widthOfText(text: string, sizePt: number): number {
+    const upm = this.sfnt.head.unitsPerEm
+    let units1000 = 0
+    for (const ch of text) {
+      const g = this.gid(ch.codePointAt(0)!)
+      units1000 += (this.hmtx.advance(g) * 1000) / upm
+    }
+    return (units1000 * sizePt) / 1000
+  }
+
+  private get isItalic(): boolean {
+    return (
+      (this.os2 != null && (this.os2.fsSelection & 0x01) !== 0) ||
+      (this.sfnt.head.macStyle & 0x02) !== 0 ||
+      this.italicAngle !== 0
+    )
+  }
+
+  /** PDF FontDescriptor /Flags (spec Table 121). */
+  private flags(): number {
+    let f = 1 << 5 // Nonsymbolic
+    if (this.fixedPitch) f |= 1 << 0 // FixedPitch
+    const fam = this.os2 ? (this.os2.sFamilyClass >> 8) & 0xff : 0
+    if (fam >= 1 && fam <= 7 && fam !== 8) f |= 1 << 1 // Serif
+    if (this.isItalic) f |= 1 << 6 // Italic
+    return f
+  }
+
+  register(table: ObjectTable): IndirectRef {
+    const upm = this.sfnt.head.unitsPerEm
+    const scale = 1000 / upm
+    const s = (v: number) => Math.round(v * scale)
+
+    // Font program. TrueType: FontFile2 (subset by default, `TAG+` name).
+    // OpenType/CFF: the bare `CFF ` table as FontFile3 /CIDFontType0C,
+    // embedded whole — CFF subsetting is deferred (spec §10.3, §23).
+    let program: Uint8Array
+    let fontName: string
+    let fontFileRef: IndirectRef
+    let fontFileKey: 'FontFile2' | 'FontFile3'
+
+    if (this.isCFF) {
+      program = this.sfnt.table('CFF ')!
+      fontName = this.baseFont
+      fontFileKey = 'FontFile3'
+      fontFileRef = table.add(
+        makeStream(program, {
+          filter: 'FlateDecode',
+          extra: { Subtype: name('CIDFontType0C') },
+        })
+      )
+    } else {
+      if (this.doSubset) {
+        const { bytes, tag } = subsetTrueType(this.sfnt, this.usedGids)
+        program = bytes
+        fontName = `${tag}+${this.baseFont}`
+      } else {
+        program = this.sfnt.programBytes
+        fontName = this.baseFont
+      }
+      fontFileKey = 'FontFile2'
+      fontFileRef = table.add(
+        makeStream(program, { filter: 'FlateDecode', extra: { Length1: num(program.length) } })
+      )
+    }
+
+    const ascent = this.os2 && this.os2.typoAscender ? this.os2.typoAscender : this.sfnt.hhea.ascent
+    const descent =
+      this.os2 && this.os2.typoDescender ? this.os2.typoDescender : this.sfnt.hhea.descent
+    const capHeight = this.os2 && this.os2.capHeight ? this.os2.capHeight : Math.round(ascent * 0.7)
+    const stemV = this.os2 && this.os2.weightClass >= 600 ? 120 : 80
+
+    const descriptorRef = table.add(
+      dict({
+        Type: name('FontDescriptor'),
+        FontName: name(fontName),
+        Flags: num(this.flags()),
+        FontBBox: arr(
+          [this.sfnt.head.xMin, this.sfnt.head.yMin, this.sfnt.head.xMax, this.sfnt.head.yMax]
+            .map(s)
+            .map(num)
+        ),
+        ItalicAngle: num(this.italicAngle),
+        Ascent: num(s(ascent)),
+        Descent: num(s(descent)),
+        CapHeight: num(s(capHeight)),
+        StemV: num(stemV),
+        [fontFileKey]: fontFileRef,
+      })
+    )
+
+    const usedGids = [...this.usedGids]
+    const cidFont = dict({
+      Type: name('Font'),
+      Subtype: name(this.isCFF ? 'CIDFontType0' : 'CIDFontType2'),
+      BaseFont: name(fontName),
+      CIDSystemInfo: dict({
+        Registry: { kind: 'str', value: ascii('Adobe'), encoding: 'literal' },
+        Ordering: { kind: 'str', value: ascii('Identity'), encoding: 'literal' },
+        Supplement: num(0),
+      }),
+      FontDescriptor: descriptorRef,
+      DW: num(Math.round(this.hmtx.advance(0) * scale) || 1000),
+      W: buildWidthsArray(usedGids, g => this.hmtx.advance(g), upm),
+    })
+    // CIDToGIDMap applies only to CIDFontType2 (TrueType).
+    if (!this.isCFF) cidFont.entries.set('CIDToGIDMap', name('Identity'))
+    const cidFontRef = table.add(cidFont)
+
+    const toUnicodeRef = table.add(
+      makeStream(ascii(buildToUnicode(this.gidToCps)), { filter: 'FlateDecode' })
+    )
+
+    return table.add(
+      dict({
+        Type: name('Font'),
+        Subtype: name('Type0'),
+        BaseFont: name(fontName),
+        Encoding: name('Identity-H'),
+        DescendantFonts: arr([cidFontRef]),
+        ToUnicode: toUnicodeRef,
+      })
+    )
+  }
+}

package/src/fonts/glyf.ts

@@ -0,0 +1,59 @@
+/**
+ * `loca` + `glyf` reading (spec §10.2). Milestone 5 embeds the whole font, so
+ * this isn't on the embed path yet — but it provides the loca offsets and
+ * composite-glyph component closure that milestone-6 subsetting builds on.
+ */
+
+import { BinaryReader } from '../util/binary.ts'
+
+const ARG_1_AND_2_ARE_WORDS = 0x0001
+const WE_HAVE_A_SCALE = 0x0008
+const MORE_COMPONENTS = 0x0020
+const WE_HAVE_AN_X_AND_Y_SCALE = 0x0040
+const WE_HAVE_A_TWO_BY_TWO = 0x0080
+
+export class GlyfTable {
+  /** Glyph data offsets, length numGlyphs+1 (offset[i+1]-offset[i] = size). */
+  readonly loca: number[] = []
+
+  constructor(
+    loca: Uint8Array,
+    private readonly glyf: Uint8Array,
+    numGlyphs: number,
+    longLoca: boolean
+  ) {
+    const r = new BinaryReader(loca)
+    for (let i = 0; i <= numGlyphs; i++) {
+      this.loca.push(longLoca ? r.u32() : r.u16() * 2)
+    }
+  }
+
+  /** Raw glyph bytes for `gid` (empty for whitespace/.notdef). */
+  glyphData(gid: number): Uint8Array {
+    const start = this.loca[gid] ?? 0
+    const end = this.loca[gid + 1] ?? start
+    return this.glyf.subarray(start, end)
+  }
+
+  /** Component glyph indices referenced by a composite glyph (else []). */
+  componentGids(gid: number): number[] {
+    const data = this.glyphData(gid)
+    if (data.length < 10) return []
+    const r = new BinaryReader(data)
+    const numberOfContours = r.i16()
+    if (numberOfContours >= 0) return [] // simple glyph
+    r.seek(10) // skip bbox
+    const out: number[] = []
+    for (;;) {
+      const flags = r.u16()
+      out.push(r.u16())
+      let skip = flags & ARG_1_AND_2_ARE_WORDS ? 4 : 2
+      if (flags & WE_HAVE_A_SCALE) skip += 2
+      else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) skip += 4
+      else if (flags & WE_HAVE_A_TWO_BY_TWO) skip += 8
+      r.seek(r.position + skip)
+      if (!(flags & MORE_COMPONENTS)) break
+    }
+    return out
+  }
+}

package/src/fonts/hmtx.ts

@@ -0,0 +1,21 @@
+/**
+ * `hmtx` table (spec §10.2): per-glyph advance widths in font units. The last
+ * `numberOfHMetrics` entry's advance applies to all trailing glyphs (which
+ * carry only a left-side bearing).
+ */
+
+export class Hmtx {
+  constructor(
+    private readonly hmtx: Uint8Array,
+    private readonly numberOfHMetrics: number,
+    private readonly numGlyphs: number
+  ) {}
+
+  /** Advance width of a glyph in font units. */
+  advance(gid: number): number {
+    if (gid < 0 || gid >= this.numGlyphs) return 0
+    const i = gid < this.numberOfHMetrics ? gid : this.numberOfHMetrics - 1
+    const o = i * 4
+    return (this.hmtx[o]! << 8) | this.hmtx[o + 1]!
+  }
+}

package/src/fonts/index.ts

@@ -0,0 +1,20 @@
+export { PdfFont } from './font.ts'
+export type { StandardFontName, TrueTypeOptions } from './font.ts'
+export { isStandardFontName, usesWinAnsi, standardGlyphWidth } from './standard_14.ts'
+export { encodeWinAnsi, winAnsiByte } from './win_ansi.ts'
+export { SfntFont, tableChecksum } from './sfnt.ts'
+export type { TableRecord, HeadTable, HheaTable } from './sfnt.ts'
+export { parseCmap } from './cmap_table.ts'
+export type { CmapLookup } from './cmap_table.ts'
+export { Hmtx } from './hmtx.ts'
+export { parseName } from './name_table.ts'
+export type { FontNames } from './name_table.ts'
+export { parseOs2 } from './os2.ts'
+export type { Os2Metrics } from './os2.ts'
+export { GlyfTable } from './glyf.ts'
+export { encodeIdentityH, buildWidthsArray } from './cid_encoding.ts'
+export { buildToUnicode } from './to_unicode.ts'
+export { subsetTrueType } from './subset.ts'
+export type { SubsetResult } from './subset.ts'
+export { parseCff } from './cff.ts'
+export type { CffInfo } from './cff.ts'

package/src/fonts/name_table.ts

@@ -0,0 +1,50 @@
+/**
+ * `name` table (spec §10.2). We only need the PostScript name (nameID 6) for
+ * `/BaseFont`; family (1) is read as a fallback.
+ */
+
+import { BinaryReader } from '../util/binary.ts'
+
+function decode(bytes: Uint8Array, platformId: number): string {
+  // Windows (3) and Unicode (0) are UTF-16BE; Mac (1) is ASCII-ish.
+  if (platformId === 1) {
+    let s = ''
+    for (const b of bytes) s += String.fromCharCode(b)
+    return s
+  }
+  let s = ''
+  for (let i = 0; i + 1 < bytes.length; i += 2) {
+    s += String.fromCharCode((bytes[i]! << 8) | bytes[i + 1]!)
+  }
+  return s
+}
+
+export interface FontNames {
+  postScriptName: string | null
+  family: string | null
+}
+
+export function parseName(name: Uint8Array): FontNames {
+  const r = new BinaryReader(name)
+  r.u16() // format
+  const count = r.u16()
+  const stringOffset = r.u16()
+
+  let postScriptName: string | null = null
+  let family: string | null = null
+
+  for (let i = 0; i < count; i++) {
+    const platformId = r.u16()
+    r.u16() // encodingId
+    r.u16() // languageId
+    const nameId = r.u16()
+    const length = r.u16()
+    const offset = r.u16()
+    if (nameId !== 6 && nameId !== 1) continue
+    const start = stringOffset + offset
+    const value = decode(name.subarray(start, start + length), platformId)
+    if (nameId === 6 && !postScriptName) postScriptName = value
+    if (nameId === 1 && !family) family = value
+  }
+  return { postScriptName, family }
+}

package/src/fonts/os2.ts

@@ -0,0 +1,41 @@
+/**
+ * `OS/2` table (spec §10.2): the metrics the PDF Font Descriptor needs
+ * (cap height, weight, typographic ascender/descender, fsSelection). All
+ * fields are optional — callers fall back to `hhea`/derived values.
+ */
+
+import { BinaryReader } from '../util/binary.ts'
+
+export interface Os2Metrics {
+  weightClass: number
+  fsSelection: number
+  sFamilyClass: number
+  typoAscender: number
+  typoDescender: number
+  capHeight: number | null
+  xHeight: number | null
+}
+
+export function parseOs2(os2: Uint8Array | undefined): Os2Metrics | null {
+  if (!os2 || os2.length < 78) return null
+  const r = new BinaryReader(os2)
+  const version = r.u16()
+  r.seek(4)
+  const weightClass = r.u16()
+  r.seek(30)
+  const sFamilyClass = r.i16()
+  r.seek(62)
+  const fsSelection = r.u16()
+  r.seek(68)
+  const typoAscender = r.i16()
+  const typoDescender = r.i16()
+
+  let capHeight: number | null = null
+  let xHeight: number | null = null
+  if (version >= 2 && os2.length >= 90) {
+    r.seek(86)
+    xHeight = r.i16()
+    capHeight = r.i16()
+  }
+  return { weightClass, fsSelection, sFamilyClass, typoAscender, typoDescender, capHeight, xHeight }
+}