@strav/pdf 0.4.17

package/src/document/types.ts

@@ -0,0 +1,65 @@
+/** Public value types for the document layer (spec §6). */
+
+/** A page size in PDF points. */
+export interface PageSize {
+  widthPt: number
+  heightPt: number
+}
+
+/** A rectangle in PDF points, origin bottom-left. */
+export interface Rect {
+  x: number
+  y: number
+  w: number
+  h: number
+}
+
+/** Conformance target. `null` = plain PDF 1.7. Enforced in M11. */
+export type ConformanceLevel = 'PDF/A-2b' | 'PDF/X-4' | null
+
+/** Document metadata written to the Info dictionary (spec §14.1). */
+export interface DocumentInfo {
+  title?: string
+  author?: string
+  subject?: string
+  keywords?: string
+  creator?: string
+}
+
+export interface CreateOptions {
+  info?: DocumentInfo
+  /** Conformance target (validated at save in M11; accepted now). */
+  conformance?: ConformanceLevel
+  /**
+   * Fixed creation date for deterministic output (spec §16.3). Defaults to
+   * `new Date()` at save time.
+   */
+  creationDate?: Date
+  /**
+   * Fixed 16-byte document ID for deterministic output. Hex string of 32
+   * chars, or raw bytes. Defaults to a content-derived hash.
+   */
+  documentId?: string | Uint8Array
+}
+
+export interface AddPageOptions {
+  size: PageSize
+  rotation?: 0 | 90 | 180 | 270
+}
+
+/** Output intent (spec §9.3) — embeds a destination ICC profile. */
+export interface OutputIntentConfig {
+  /** `GTS_PDFX` (print) or `GTS_PDFA1` (archival). */
+  subtype: 'GTS_PDFX' | 'GTS_PDFA1' | string
+  outputConditionIdentifier: string
+  outputCondition?: string
+  registryName?: string
+  info?: string
+  /** Raw ICC profile bytes (CMYK or Gray for PDF/X). */
+  destOutputProfile: Uint8Array
+}
+
+/** Convert a {@link Rect} to a PDF box array `[llx lly urx ury]`. */
+export function rectToBox(r: Rect): [number, number, number, number] {
+  return [r.x, r.y, r.x + r.w, r.y + r.h]
+}

package/src/document/xref.ts

@@ -0,0 +1,68 @@
+/**
+ * Serialize pass: file header, body, classic cross-reference table, and
+ * trailer (spec §6.5). v1 emits a classic xref table only; cross-reference
+ * streams are deferred to v1.1 (this module is the seam for that swap).
+ */
+
+import { ascii } from '../util/ascii.ts'
+import type { ByteSink } from '../output/byte_sink.ts'
+import type { IndirectRef } from '../objects/types.ts'
+import { arr, dict, num } from '../objects/types.ts'
+import { hexBytes } from '../objects/string.ts'
+import { encodeObject } from '../objects/encode.ts'
+import type { ObjectTable } from './object_table.ts'
+
+// "%PDF-1.7\n" then a comment of four >=128 bytes so transfer tools treat the
+// file as binary (ISO 32000-1 §7.5.2).
+const HEADER = Uint8Array.from([
+  0x25, 0x50, 0x44, 0x46, 0x2d, 0x31, 0x2e, 0x37, 0x0a, // %PDF-1.7\n
+  0x25, 0xe2, 0xe3, 0xcf, 0xd3, 0x0a, // %âãÏÓ\n
+])
+
+function pad10(n: number): string {
+  return String(n).padStart(10, '0')
+}
+
+export interface SerializeInput {
+  table: ObjectTable
+  root: IndirectRef
+  info: IndirectRef
+  /** Permanent id and per-save id (each exactly 16 bytes). */
+  id: [Uint8Array, Uint8Array]
+  sink: ByteSink
+}
+
+export function serializeDocument(input: SerializeInput): void {
+  const { table, root, info, id, sink } = input
+
+  sink.write(HEADER)
+
+  // Body. Offsets are recorded at the byte position of "N 0 obj".
+  const offsets = new Map<number, number>()
+  for (const [n, value] of table.entries()) {
+    offsets.set(n, sink.length)
+    sink.write(ascii(`${n} 0 obj\n`))
+    sink.write(encodeObject(value))
+    sink.write(ascii('\nendobj\n'))
+  }
+
+  const size = table.size // includes object 0
+  const xrefOffset = sink.length
+
+  // Classic xref table. Every entry line is exactly 20 bytes (incl. "\r\n").
+  let xref = `xref\n0 ${size}\n0000000000 65535 f\r\n`
+  for (let n = 1; n < size; n++) {
+    xref += `${pad10(offsets.get(n)!)} 00000 n\r\n`
+  }
+  sink.write(ascii(xref))
+
+  const trailer = dict({
+    Size: num(size),
+    Root: root,
+    Info: info,
+    ID: arr([hexBytes(id[0]), hexBytes(id[1])]),
+  })
+  sink.write(ascii('trailer\n'))
+  sink.write(encodeObject(trailer))
+  sink.write(ascii(`\nstartxref\n${xrefOffset}\n%%EOF\n`))
+}

package/src/ext-gstate/ext_gstate.ts

@@ -0,0 +1,69 @@
+/**
+ * Extended graphics state (spec §13). Transparency lives in an ExtGState
+ * object selected with the `gs` operator: stroke/fill constant alpha and a
+ * blend mode. The object is registered in `/Resources /ExtGState`.
+ */
+
+import { dict, name, num } from '../objects/types.ts'
+import type { PdfObject } from '../objects/types.ts'
+import type { ObjectTable } from '../document/object_table.ts'
+
+export type BlendMode =
+  | 'Normal'
+  | 'Multiply'
+  | 'Screen'
+  | 'Overlay'
+  | 'Darken'
+  | 'Lighten'
+  | 'ColorDodge'
+  | 'ColorBurn'
+  | 'HardLight'
+  | 'SoftLight'
+  | 'Difference'
+  | 'Exclusion'
+  | 'Hue'
+  | 'Saturation'
+  | 'Color'
+  | 'Luminosity'
+
+export interface ExtGStateOptions {
+  /** Stroking constant alpha `CA` in [0,1]. */
+  strokeAlpha?: number
+  /** Non-stroking (fill) constant alpha `ca` in [0,1]. */
+  fillAlpha?: number
+  /** Blend mode `BM` (default `Normal`). */
+  blendMode?: BlendMode
+}
+
+class ExtGState {
+  readonly id: string
+
+  constructor(
+    private readonly opts: ExtGStateOptions,
+    tag: number
+  ) {
+    const parts = [
+      opts.strokeAlpha !== undefined ? `CA${opts.strokeAlpha}` : '',
+      opts.fillAlpha !== undefined ? `ca${opts.fillAlpha}` : '',
+      opts.blendMode ?? '',
+    ]
+    this.id = `gs:${parts.join('|')}:${tag}`
+  }
+
+  build(_table: ObjectTable): PdfObject {
+    const d = dict({ Type: name('ExtGState') })
+    if (this.opts.strokeAlpha !== undefined) d.entries.set('CA', num(this.opts.strokeAlpha))
+    if (this.opts.fillAlpha !== undefined) d.entries.set('ca', num(this.opts.fillAlpha))
+    if (this.opts.blendMode) d.entries.set('BM', name(this.opts.blendMode))
+    return d
+  }
+}
+
+let gsCounter = 0
+
+/** Create an ExtGState handle (use with `ContentStream.setExtGState`). */
+export function extGState(opts: ExtGStateOptions): ExtGState {
+  return new ExtGState(opts, gsCounter++)
+}
+
+export type { ExtGState }

package/src/ext-gstate/index.ts

@@ -0,0 +1,2 @@
+export { extGState } from './ext_gstate.ts'
+export type { ExtGState, ExtGStateOptions, BlendMode } from './ext_gstate.ts'

package/src/fonts/cff.ts

@@ -0,0 +1,123 @@
+/**
+ * Minimal CFF (`CFF `) table parsing (spec §10.1, Adobe TN #5176).
+ *
+ * Milestone 7 embeds the CFF program **whole** (CFF subsetting is deferred per
+ * spec §23 decision 1), so we only need: the PostScript name, whether the CFF
+ * is CID-keyed, and the glyph count (CharStrings INDEX count). Charstring
+ * outline interpretation is out of scope until CFF subsetting lands.
+ */
+
+export interface CffInfo {
+  /** PostScript name from the Name INDEX. */
+  name: string
+  /** True if the Top DICT has a ROS operator (CID-keyed CFF). */
+  isCID: boolean
+  /** Number of glyphs (CharStrings INDEX count). */
+  numGlyphs: number
+}
+
+interface IndexResult {
+  items: Uint8Array[]
+  /** Byte offset just past this INDEX. */
+  end: number
+}
+
+function readOffset(b: Uint8Array, pos: number, size: number): number {
+  let v = 0
+  for (let i = 0; i < size; i++) v = (v << 8) | b[pos + i]!
+  return v >>> 0
+}
+
+/** Read a CFF INDEX at `pos`. */
+function readIndex(b: Uint8Array, pos: number): IndexResult {
+  const count = (b[pos]! << 8) | b[pos + 1]!
+  if (count === 0) return { items: [], end: pos + 2 }
+  const offSize = b[pos + 2]!
+  const offArr = pos + 3
+  const dataBase = offArr + (count + 1) * offSize - 1
+  const items: Uint8Array[] = []
+  for (let i = 0; i < count; i++) {
+    const start = readOffset(b, offArr + i * offSize, offSize)
+    const next = readOffset(b, offArr + (i + 1) * offSize, offSize)
+    items.push(b.subarray(dataBase + start, dataBase + next))
+  }
+  const end = dataBase + readOffset(b, offArr + count * offSize, offSize)
+  return { items, end }
+}
+
+/** Parse a Top DICT, returning the CharStrings offset and CID-keyed flag. */
+function parseTopDict(d: Uint8Array): { charStrings: number; isCID: boolean } {
+  let charStrings = 0
+  let isCID = false
+  const operands: number[] = []
+  let i = 0
+  while (i < d.length) {
+    const b0 = d[i]!
+    if (b0 <= 21) {
+      // Operator (12 = escape → two-byte operator).
+      if (b0 === 12) {
+        const op2 = d[i + 1]!
+        if (op2 === 30) isCID = true // ROS
+        i += 2
+      } else {
+        if (b0 === 17) charStrings = operands[operands.length - 1] ?? 0 // CharStrings
+        i += 1
+      }
+      operands.length = 0
+    } else if (b0 === 28) {
+      operands.push(((d[i + 1]! << 8) | d[i + 2]!) << 16 >> 16)
+      i += 3
+    } else if (b0 === 29) {
+      operands.push(
+        ((d[i + 1]! << 24) | (d[i + 2]! << 16) | (d[i + 3]! << 8) | d[i + 4]!) | 0
+      )
+      i += 5
+    } else if (b0 === 30) {
+      // Real number: BCD nibbles until 0xf terminator.
+      i += 1
+      while (i < d.length) {
+        const hi = d[i]! >> 4
+        const lo = d[i]! & 0xf
+        i += 1
+        if (hi === 0xf || lo === 0xf) break
+      }
+      operands.push(0)
+    } else if (b0 >= 32 && b0 <= 246) {
+      operands.push(b0 - 139)
+      i += 1
+    } else if (b0 >= 247 && b0 <= 250) {
+      operands.push((b0 - 247) * 256 + d[i + 1]! + 108)
+      i += 2
+    } else if (b0 >= 251 && b0 <= 254) {
+      operands.push(-(b0 - 251) * 256 - d[i + 1]! - 108)
+      i += 2
+    } else {
+      i += 1 // reserved (22..27, 31, 255) — skip defensively
+    }
+  }
+  return { charStrings, isCID }
+}
+
+export function parseCff(cff: Uint8Array): CffInfo {
+  const hdrSize = cff[2]!
+  const nameIdx = readIndex(cff, hdrSize)
+  const topIdx = readIndex(cff, nameIdx.end)
+
+  const first = nameIdx.items[0]
+  let name = 'CFFFont'
+  if (first) {
+    let s = ''
+    for (const ch of first) s += String.fromCharCode(ch)
+    name = s
+  }
+
+  const top = topIdx.items[0]
+  if (!top) return { name, isCID: false, numGlyphs: 0 }
+  const { charStrings, isCID } = parseTopDict(top)
+
+  let numGlyphs = 0
+  if (charStrings > 0 && charStrings + 2 <= cff.length) {
+    numGlyphs = (cff[charStrings]! << 8) | cff[charStrings + 1]!
+  }
+  return { name, isCID, numGlyphs }
+}

package/src/fonts/cid_encoding.ts

@@ -0,0 +1,45 @@
+/**
+ * Identity-H CID encoding helpers (spec §10.5). With Identity-H the CID equals
+ * the glyph index and codes are 2-byte big-endian. This builds the `/W` width
+ * array (compact consecutive runs) keyed by CID.
+ */
+
+import { arr, num } from '../objects/types.ts'
+import type { PdfArray } from '../objects/types.ts'
+
+/** Encode a glyph-index sequence as 2-byte big-endian codes. */
+export function encodeIdentityH(gids: number[]): Uint8Array {
+  const out = new Uint8Array(gids.length * 2)
+  for (let i = 0; i < gids.length; i++) {
+    out[i * 2] = (gids[i]! >> 8) & 0xff
+    out[i * 2 + 1] = gids[i]! & 0xff
+  }
+  return out
+}
+
+/**
+ * Build the CIDFont `/W` array for the used glyphs. Scales font-unit advances
+ * to PDF glyph space (1000-unit em). Consecutive CIDs collapse to the
+ * `c [w1 w2 …]` form: `[ c0 [w w w] c5 [w] … ]`.
+ */
+export function buildWidthsArray(
+  usedGids: number[],
+  advanceFontUnits: (gid: number) => number,
+  unitsPerEm: number
+): PdfArray {
+  const sorted = [...new Set(usedGids)].sort((a, b) => a - b)
+  const scale = 1000 / unitsPerEm
+  const items = []
+  for (let i = 0; i < sorted.length; ) {
+    const start = sorted[i]!
+    const run: number[] = [Math.round(advanceFontUnits(start) * scale)]
+    let j = i
+    while (j + 1 < sorted.length && sorted[j + 1] === sorted[j]! + 1) {
+      j++
+      run.push(Math.round(advanceFontUnits(sorted[j]!) * scale))
+    }
+    items.push(num(start), arr(run.map(num)))
+    i = j + 1
+  }
+  return arr(items)
+}

package/src/fonts/cmap_table.ts

@@ -0,0 +1,180 @@
+/**
+ * `cmap` table parsing (spec §10.2). Maps Unicode code points to glyph
+ * indices. Subtable formats 0, 4, 6 and 12 are supported — enough for the
+ * Unicode BMP (format 4), full Unicode (format 12), and legacy fonts.
+ *
+ * The best available Unicode subtable is selected; symbol fonts (3,0) are
+ * also tried with the 0xF000 private-use offset.
+ */
+
+import { BinaryReader } from '../util/binary.ts'
+import { UnsupportedFontError } from '../util/errors.ts'
+
+export interface CmapLookup {
+  /** Glyph index for a code point, or 0 (.notdef) if unmapped. */
+  gidFor(codePoint: number): number
+}
+
+function parseFormat0(b: Uint8Array, o: number): CmapLookup {
+  const table = b.subarray(o + 6, o + 6 + 256)
+  return { gidFor: cp => (cp < 256 ? table[cp]! : 0) }
+}
+
+function parseFormat4(b: Uint8Array, o: number): CmapLookup {
+  const r = new BinaryReader(b, o)
+  r.seek(o + 6)
+  const segX2 = r.u16()
+  const segs = segX2 / 2
+  const endBase = o + 14
+  const startBase = endBase + segX2 + 2
+  const deltaBase = startBase + segX2
+  const rangeBase = deltaBase + segX2
+  const u16 = (base: number, i: number) =>
+    (b[base + i * 2]! << 8) | b[base + i * 2 + 1]!
+  return {
+    gidFor(cp) {
+      if (cp > 0xffff) return 0
+      for (let i = 0; i < segs; i++) {
+        if (cp > u16(endBase, i)) continue
+        const start = u16(startBase, i)
+        if (cp < start) return 0
+        const delta = u16(deltaBase, i)
+        const ro = u16(rangeBase, i)
+        if (ro === 0) return (cp + delta) & 0xffff
+        // glyphId address = rangeBase+i*2 + ro + (cp-start)*2
+        const gi = rangeBase + i * 2 + ro + (cp - start) * 2
+        const g = (b[gi]! << 8) | b[gi + 1]!
+        return g === 0 ? 0 : (g + delta) & 0xffff
+      }
+      return 0
+    },
+  }
+}
+
+function parseFormat6(b: Uint8Array, o: number): CmapLookup {
+  const first = (b[o + 6]! << 8) | b[o + 7]!
+  const count = (b[o + 8]! << 8) | b[o + 9]!
+  return {
+    gidFor(cp) {
+      const i = cp - first
+      if (i < 0 || i >= count) return 0
+      const a = o + 10 + i * 2
+      return (b[a]! << 8) | b[a + 1]!
+    },
+  }
+}
+
+function parseFormat12(b: Uint8Array, o: number): CmapLookup {
+  const r = new BinaryReader(b, o + 12)
+  const nGroups = r.u32()
+  const base = o + 16
+  return {
+    gidFor(cp) {
+      let lo = 0
+      let hi = nGroups - 1
+      while (lo <= hi) {
+        const mid = (lo + hi) >> 1
+        const g = base + mid * 12
+        const start = (b[g]! << 24) | (b[g + 1]! << 16) | (b[g + 2]! << 8) | b[g + 3]!
+        const end = (b[g + 4]! << 24) | (b[g + 5]! << 16) | (b[g + 6]! << 8) | b[g + 7]!
+        if (cp < start >>> 0) hi = mid - 1
+        else if (cp > end >>> 0) lo = mid + 1
+        else {
+          const sg = (b[g + 8]! << 24) | (b[g + 9]! << 16) | (b[g + 10]! << 8) | b[g + 11]!
+          return ((sg >>> 0) + (cp - (start >>> 0))) & 0xffffffff
+        }
+      }
+      return 0
+    },
+  }
+}
+
+/** Format 13: like 12, but every code in a group maps to the SAME glyph
+ *  (used by LastResort and many fallback fonts). */
+function parseFormat13(b: Uint8Array, o: number): CmapLookup {
+  const r = new BinaryReader(b, o + 12)
+  const nGroups = r.u32()
+  const base = o + 16
+  return {
+    gidFor(cp) {
+      let lo = 0
+      let hi = nGroups - 1
+      while (lo <= hi) {
+        const mid = (lo + hi) >> 1
+        const g = base + mid * 12
+        const start =
+          ((b[g]! << 24) | (b[g + 1]! << 16) | (b[g + 2]! << 8) | b[g + 3]!) >>> 0
+        const end =
+          ((b[g + 4]! << 24) | (b[g + 5]! << 16) | (b[g + 6]! << 8) | b[g + 7]!) >>> 0
+        if (cp < start) hi = mid - 1
+        else if (cp > end) lo = mid + 1
+        else return ((b[g + 8]! << 24) | (b[g + 9]! << 16) | (b[g + 10]! << 8) | b[g + 11]!) >>> 0
+      }
+      return 0
+    },
+  }
+}
+
+function parseSubtable(b: Uint8Array, o: number): CmapLookup | null {
+  const format = (b[o]! << 8) | b[o + 1]!
+  switch (format) {
+    case 0:
+      return parseFormat0(b, o)
+    case 4:
+      return parseFormat4(b, o)
+    case 6:
+      return parseFormat6(b, o)
+    case 12:
+      return parseFormat12(b, o)
+    case 13:
+      return parseFormat13(b, o)
+    default:
+      return null
+  }
+}
+
+/** Parse a `cmap` table and return a Unicode lookup. */
+export function parseCmap(cmap: Uint8Array): CmapLookup {
+  const numTables = (cmap[2]! << 8) | cmap[3]!
+  type Cand = { platform: number; encoding: number; offset: number }
+  const cands: Cand[] = []
+  for (let i = 0; i < numTables; i++) {
+    const rec = 4 + i * 8
+    const platform = (cmap[rec]! << 8) | cmap[rec + 1]!
+    const encoding = (cmap[rec + 2]! << 8) | cmap[rec + 3]!
+    const offset =
+      (cmap[rec + 4]! << 24) |
+      (cmap[rec + 5]! << 16) |
+      (cmap[rec + 6]! << 8) |
+      cmap[rec + 7]!
+    cands.push({ platform, encoding, offset: offset >>> 0 })
+  }
+
+  // Preference: full Unicode → BMP Unicode → any Unicode → symbol.
+  const pick = (p: number, e: number) =>
+    cands.find(c => c.platform === p && c.encoding === e)
+  const order = [
+    pick(3, 10),
+    pick(0, 6),
+    pick(0, 4),
+    pick(3, 1),
+    pick(0, 3),
+    pick(0, 2),
+    pick(0, 1),
+    pick(0, 0),
+    pick(3, 0), // symbol
+  ]
+
+  for (const cand of order) {
+    if (!cand) continue
+    const sub = parseSubtable(cmap, cand.offset)
+    if (!sub) continue
+    if (cand.platform === 3 && cand.encoding === 0) {
+      // Symbol cmap: glyphs live in the 0xF000 private-use block.
+      return { gidFor: cp => sub.gidFor(cp) || sub.gidFor(0xf000 + (cp & 0xff)) }
+    }
+    return sub
+  }
+
+  throw new UnsupportedFontError('Font has no usable Unicode cmap subtable')
+}