@strav/pdf 0.4.17 → 0.4.18

package/src/reader/fonts.ts

@@ -0,0 +1,259 @@
+/**
+ * Per-font text decoding (spec §9.6–9.10). Builds a {@link CharMap} that turns
+ * show-string bytes into Unicode + glyph advance widths. Decoding precedence:
+ *   1. /ToUnicode CMap
+ *   2. simple-font /Encoding (base + /Differences) → glyph name → Unicode
+ *   3. Type0 Identity/embedded-CMap → CID (Unicode only via /ToUnicode)
+ *   4. raw byte → WinAnsi/Latin-1 fallback
+ */
+
+import {
+  type PdfObject,
+  type PdfDictionary,
+  isDict,
+  isName,
+  isNum,
+  isArr,
+  isStream,
+} from '../objects/types.ts'
+import {
+  isStandardFontName,
+  standardGlyphWidth,
+  type StandardFontName,
+} from '../fonts/standard_14.ts'
+import {
+  baseEncode,
+  winAnsiToUnicode,
+  glyphNameToUnicode,
+  type BaseEncodingName,
+} from './encodings.ts'
+import { parseCMap, type CMap } from './cmap_parser.ts'
+
+export interface DecodedGlyph {
+  code: number
+  unicode: string
+  /** Advance width in text space units per em/1000 (i.e. glyph-space/1000). */
+  width1000: number
+}
+
+export interface CharMap {
+  decode(bytes: Uint8Array): DecodedGlyph[]
+  /** Width of the space-like glyph (code 32 / CID space), in /1000 units. */
+  spaceWidth: number
+}
+
+interface Doc {
+  resolve(o: PdfObject | undefined): PdfObject | undefined
+  getStreamData(s: Extract<PdfObject, { kind: 'stream' }>, num: number): Uint8Array
+}
+
+const REPLACEMENT = '�'
+
+export function buildCharMap(fontDict: PdfDictionary, doc: Doc): CharMap {
+  const subtype = nameOf(doc.resolve(fontDict.entries.get('Subtype')))
+  const toUni = loadToUnicode(fontDict, doc)
+
+  if (subtype === 'Type0') return type0CharMap(fontDict, doc, toUni)
+  return simpleCharMap(fontDict, doc, toUni)
+}
+
+// ── Simple fonts (Type1 / TrueType / Type3 / MMType1) ──────────────────────
+
+function simpleCharMap(fontDict: PdfDictionary, doc: Doc, toUni?: CMap): CharMap {
+  const base = nameOf(doc.resolve(fontDict.entries.get('BaseFont'))) ?? ''
+  const std = isStandardFontName(base) ? (base as StandardFontName) : undefined
+
+  // Widths
+  const firstChar = numOf(doc.resolve(fontDict.entries.get('FirstChar'))) ?? 0
+  const widthsArr = doc.resolve(fontDict.entries.get('Widths'))
+  const widths: number[] = widthsArr && isArr(widthsArr)
+    ? widthsArr.items.map((w) => {
+        const r = doc.resolve(w)
+        return r && isNum(r) ? r.value : 0
+      })
+    : []
+  let missingWidth = 0
+  const fd = doc.resolve(fontDict.entries.get('FontDescriptor'))
+  if (fd && isDict(fd)) {
+    missingWidth = numOf(doc.resolve(fd.entries.get('MissingWidth'))) ?? 0
+  }
+
+  // Encoding → per-code Unicode (used only when there is no /ToUnicode).
+  const encUnicode = buildSimpleEncoding(fontDict, doc)
+
+  const widthOf = (code: number): number => {
+    const idx = code - firstChar
+    if (idx >= 0 && idx < widths.length && widths[idx]! > 0) return widths[idx]!
+    if (std) return standardGlyphWidth(std, code)
+    return missingWidth
+  }
+
+  const uniOf = (code: number): string => {
+    if (toUni) {
+      const u = toUni.unicodeOf(code)
+      if (u !== undefined && u !== '') return u
+    }
+    const e = encUnicode[code]
+    if (e !== undefined && e >= 0) return String.fromCodePoint(e)
+    const w = winAnsiToUnicode(code)
+    return w ? String.fromCodePoint(w) : ''
+  }
+
+  return {
+    spaceWidth: widthOf(0x20) || (std ? standardGlyphWidth(std, 0x20) : 250),
+    decode(bytes) {
+      const out: DecodedGlyph[] = []
+      for (const code of bytes) {
+        out.push({ code, unicode: uniOf(code), width1000: widthOf(code) })
+      }
+      return out
+    },
+  }
+}
+
+function buildSimpleEncoding(fontDict: PdfDictionary, doc: Doc): number[] {
+  const table: number[] = new Array(256)
+  const enc = doc.resolve(fontDict.entries.get('Encoding'))
+  let baseName: BaseEncodingName | undefined
+  if (enc && isName(enc)) baseName = enc.value as BaseEncodingName
+  else if (enc && isDict(enc)) {
+    const be = doc.resolve(enc.entries.get('BaseEncoding'))
+    if (be && isName(be)) baseName = be.value as BaseEncodingName
+  }
+  for (let c = 0; c < 256; c++) table[c] = baseEncode(baseName, c)
+  // /Differences: [ code /name /name code /name … ]
+  if (enc && isDict(enc)) {
+    const diffs = doc.resolve(enc.entries.get('Differences'))
+    if (diffs && isArr(diffs)) {
+      let cur = 0
+      for (const item of diffs.items) {
+        const r = doc.resolve(item)
+        if (r && isNum(r)) cur = r.value
+        else if (r && isName(r)) {
+          const u = glyphNameToUnicode(r.value)
+          table[cur] = u >= 0 ? u : table[cur]!
+          cur++
+        }
+      }
+    }
+  }
+  return table
+}
+
+// ── Composite (Type0) fonts ────────────────────────────────────────────────
+
+function type0CharMap(fontDict: PdfDictionary, doc: Doc, toUni?: CMap): CharMap {
+  // Encoding: Identity-H/V → 2-byte identity; or an embedded/named CMap.
+  const enc = doc.resolve(fontDict.entries.get('Encoding'))
+  let encCMap: CMap | undefined
+  let identity = true
+  if (enc && isName(enc)) {
+    identity = enc.value === 'Identity-H' || enc.value === 'Identity-V'
+  } else if (enc && isStream(enc)) {
+    encCMap = parseCMap(doc.getStreamData(enc, -1))
+    identity = false
+  }
+
+  // Descendant CIDFont: /DW + /W widths, keyed by CID.
+  let dw = 1000
+  const widthByCid = new Map<number, number>()
+  const desc = doc.resolve(fontDict.entries.get('DescendantFonts'))
+  if (desc && isArr(desc) && desc.items[0]) {
+    const cidFont = doc.resolve(desc.items[0])
+    if (cidFont && isDict(cidFont)) {
+      dw = numOf(doc.resolve(cidFont.entries.get('DW'))) ?? 1000
+      const W = doc.resolve(cidFont.entries.get('W'))
+      if (W && isArr(W)) parseCidWidths(W.items, doc, widthByCid)
+    }
+  }
+
+  const codeBytes = encCMap ? encCMap.codeBytes : 2
+  const cidOf = (code: number): number =>
+    identity ? code : (encCMap?.cidOf(code) ?? code)
+
+  const uniOf = (code: number): string => {
+    if (toUni) {
+      const u = toUni.unicodeOf(code)
+      if (u !== undefined && u !== '') return u
+    }
+    return REPLACEMENT // no ToUnicode for an embedded-cmap-only font (limitation)
+  }
+
+  return {
+    spaceWidth: widthByCid.get(cidOf(0x20)) ?? dw,
+    decode(bytes) {
+      const out: DecodedGlyph[] = []
+      const codes = encCMap ? encCMap.readCodes(bytes) : readFixed(bytes, codeBytes)
+      for (const code of codes) {
+        const cid = cidOf(code)
+        out.push({
+          code,
+          unicode: uniOf(code),
+          width1000: widthByCid.get(cid) ?? dw,
+        })
+      }
+      return out
+    },
+  }
+}
+
+function readFixed(bytes: Uint8Array, n: number): number[] {
+  const out: number[] = []
+  for (let i = 0; i + n <= bytes.length; i += n) {
+    let c = 0
+    for (let k = 0; k < n; k++) c = (c << 8) | bytes[i + k]!
+    out.push(c)
+  }
+  return out
+}
+
+function parseCidWidths(
+  items: PdfObject[],
+  doc: Doc,
+  out: Map<number, number>,
+): void {
+  let i = 0
+  while (i < items.length) {
+    const a = doc.resolve(items[i])
+    if (!a || !isNum(a)) break
+    const next = doc.resolve(items[i + 1])
+    if (next && isArr(next)) {
+      // c [ w1 w2 … ] : CIDs c, c+1, …
+      let cid = a.value
+      for (const w of next.items) {
+        const wr = doc.resolve(w)
+        if (wr && isNum(wr)) out.set(cid++, wr.value)
+      }
+      i += 2
+    } else {
+      // c1 c2 w : CIDs c1..c2 all width w
+      const b = doc.resolve(items[i + 1])
+      const w = doc.resolve(items[i + 2])
+      if (b && isNum(b) && w && isNum(w)) {
+        for (let cid = a.value; cid <= b.value; cid++) out.set(cid, w.value)
+      }
+      i += 3
+    }
+  }
+}
+
+// ── Shared helpers ─────────────────────────────────────────────────────────
+
+function loadToUnicode(fontDict: PdfDictionary, doc: Doc): CMap | undefined {
+  const tu = doc.resolve(fontDict.entries.get('ToUnicode'))
+  if (tu && isStream(tu)) {
+    try {
+      return parseCMap(doc.getStreamData(tu, -1))
+    } catch {
+      return undefined
+    }
+  }
+  return undefined
+}
+
+function nameOf(o: PdfObject | undefined): string | undefined {
+  return o && isName(o) ? o.value : undefined
+}
+function numOf(o: PdfObject | undefined): number | undefined {
+  return o && isNum(o) ? o.value : undefined
+}

package/src/reader/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Read side (M13) sub-module barrel. The headline API plus lower-level pieces
+ * for advanced callers, mirroring how `document/index.ts` exposes internals.
+ */
+
+export { extractText, PdfReader } from './extract.ts'
+export type {
+  ExtractOptions,
+  ExtractResult,
+  ExtractedPage,
+  PdfInfo,
+} from './extract.ts'
+
+export { PdfReaderDocument } from './document.ts'
+export { Lexer } from './lexer.ts'
+export { ObjectParser, parseObjectFrom } from './object_parser.ts'
+export { parseXref, bruteForceXref, findStartXref } from './xref.ts'
+export type { XrefTable, XrefEntry } from './xref.ts'
+export { parseObjStm } from './objstm.ts'
+export { parseCMap, CMap } from './cmap_parser.ts'
+export { buildCharMap } from './fonts.ts'
+export type { CharMap, DecodedGlyph } from './fonts.ts'
+export { interpretText } from './text_interpreter.ts'
+export { runsToText } from './layout.ts'
+export type { Run } from './layout.ts'
+export { buildDecryptor } from './decrypt.ts'
+export type { Decryptor } from './decrypt.ts'

package/src/reader/layout.ts

@@ -0,0 +1,106 @@
+/**
+ * Layout heuristics: positioned glyph runs → readable plain text. Runs are
+ * grouped into lines by baseline proximity; intra-line gaps become spaces
+ * (proportional to the font's space width); inter-line drops become newlines,
+ * with a blank line for paragraph-sized jumps. No column/table reconstruction.
+ */
+
+export interface Run {
+  text: string
+  /** Device-space X of the run's first glyph origin. */
+  x: number
+  /** Device-space X just past the run's last glyph. */
+  endX: number
+  /** Device-space baseline Y. */
+  y: number
+  /** Effective device font size. */
+  fs: number
+  /** Device-space width of the space glyph. */
+  spaceW: number
+}
+
+// Tunable thresholds (fractions of the space-glyph width / font size).
+const SAME_LINE = 0.3 // |Δy| < SAME_LINE·fs ⇒ same line
+const GLUE = 0.2 // gap < GLUE·spaceW ⇒ no separator
+const WIDE = 2.5 // gap ≥ WIDE·spaceW ⇒ multiple spaces
+const MAX_GAP_SPACES = 8
+const PARA = 1.6 // line drop > PARA·fs ⇒ blank line
+
+export function runsToText(runs: Run[], normalize = true): string {
+  const items = runs.filter((r) => r.text.length > 0)
+  if (items.length === 0) return ''
+
+  items.sort((a, b) => (b.y - a.y) || (a.x - b.x))
+
+  // Group into lines by baseline proximity.
+  const lines: Run[][] = []
+  let cur: Run[] = []
+  let lineY = items[0]!.y
+  let lineFs = items[0]!.fs
+  for (const r of items) {
+    if (cur.length && Math.abs(r.y - lineY) > SAME_LINE * Math.max(lineFs, r.fs)) {
+      lines.push(cur)
+      cur = []
+    }
+    if (cur.length === 0) {
+      lineY = r.y
+      lineFs = r.fs
+    }
+    cur.push(r)
+  }
+  if (cur.length) lines.push(cur)
+
+  let out = ''
+  let prevY: number | null = null
+  let prevFs = lineFs
+  for (const line of lines) {
+    line.sort((a, b) => a.x - b.x)
+    const y = line[0]!.y
+    const fs = Math.max(...line.map((r) => r.fs))
+
+    if (prevY !== null) {
+      out += '\n'
+      if (prevY - y > PARA * Math.max(fs, prevFs)) out += '\n'
+    }
+
+    let lineText = ''
+    let prev: Run | null = null
+    for (const r of line) {
+      if (prev) {
+        const gap = r.x - prev.endX
+        const sw = prev.spaceW || r.spaceW || fs * 0.25
+        if (gap >= WIDE * sw) {
+          lineText += ' '.repeat(Math.min(MAX_GAP_SPACES, Math.round(gap / sw)))
+        } else if (gap >= GLUE * sw) {
+          lineText += ' '
+        }
+      }
+      lineText += r.text
+      prev = r
+    }
+    out += lineText
+    prevY = y
+    prevFs = fs
+  }
+
+  return normalize ? normalizeWhitespace(out) : out
+}
+
+function normalizeWhitespace(s: string): string {
+  const lines = s.split('\n').map((l) => l.replace(/[ \t]+/g, ' ').replace(/[ \t]+$/g, ''))
+  // Collapse 3+ blank lines to a single blank line; trim leading/trailing.
+  const collapsed: string[] = []
+  let blanks = 0
+  for (const l of lines) {
+    if (l.trim() === '') {
+      blanks++
+      if (blanks <= 1) collapsed.push('')
+    } else {
+      blanks = 0
+      collapsed.push(l)
+    }
+  }
+  while (collapsed.length && collapsed[0] === '') collapsed.shift()
+  while (collapsed.length && collapsed[collapsed.length - 1] === '') collapsed.pop()
+  return collapsed.join('\n')
+}

package/src/reader/lexer.ts

@@ -0,0 +1,270 @@
+/**
+ * PDF tokenizer (spec §7.2). Scans a byte buffer into the lexical tokens the
+ * object parser consumes. Pure and position-addressable: callers may `seek`
+ * to a known byte offset (from the xref table) and tokenize from there.
+ *
+ * Whitespace = NUL TAB LF FF CR SPACE. Delimiters = ( ) < > [ ] { } / %.
+ * Comments (`%` … EOL) are skipped except the `%PDF`/`%%EOF` markers, which
+ * callers locate by raw byte scanning, not through this lexer.
+ */
+
+export type Token =
+  | { type: 'num'; value: number }
+  | { type: 'name'; value: string }
+  | { type: 'str'; value: Uint8Array; encoding: 'literal' | 'hex' }
+  | { type: 'delim'; value: '[' | ']' | '<<' | '>>' | '{' | '}' }
+  | { type: 'kw'; value: string }
+  | { type: 'eof' }
+
+const WS = new Set([0x00, 0x09, 0x0a, 0x0c, 0x0d, 0x20])
+const DELIM = new Set([0x28, 0x29, 0x3c, 0x3e, 0x5b, 0x5d, 0x7b, 0x7d, 0x2f, 0x25])
+
+const isWs = (b: number) => WS.has(b)
+const isDelim = (b: number) => DELIM.has(b)
+const isRegular = (b: number) => !isWs(b) && !isDelim(b)
+const isDigit = (b: number) => b >= 0x30 && b <= 0x39
+
+export class Lexer {
+  pos: number
+
+  constructor(
+    readonly buf: Uint8Array,
+    start = 0,
+  ) {
+    this.pos = start
+  }
+
+  seek(p: number): void {
+    this.pos = p
+  }
+
+  /** Skip whitespace and `%` comments. */
+  skipWs(): void {
+    const b = this.buf
+    while (this.pos < b.length) {
+      const c = b[this.pos]!
+      if (isWs(c)) {
+        this.pos++
+      } else if (c === 0x25) {
+        // % comment → to end of line
+        this.pos++
+        while (this.pos < b.length && b[this.pos] !== 0x0a && b[this.pos] !== 0x0d) this.pos++
+      } else {
+        break
+      }
+    }
+  }
+
+  /** Peek the next token without consuming (cheap: save/restore pos). */
+  peek(): Token {
+    const save = this.pos
+    const t = this.next()
+    this.pos = save
+    return t
+  }
+
+  next(): Token {
+    this.skipWs()
+    const b = this.buf
+    if (this.pos >= b.length) return { type: 'eof' }
+    const c = b[this.pos]!
+
+    // Delimiters / structured tokens
+    if (c === 0x5b) {
+      this.pos++
+      return { type: 'delim', value: '[' }
+    }
+    if (c === 0x5d) {
+      this.pos++
+      return { type: 'delim', value: ']' }
+    }
+    if (c === 0x7b) {
+      this.pos++
+      return { type: 'delim', value: '{' }
+    }
+    if (c === 0x7d) {
+      this.pos++
+      return { type: 'delim', value: '}' }
+    }
+    if (c === 0x3c) {
+      if (b[this.pos + 1] === 0x3c) {
+        this.pos += 2
+        return { type: 'delim', value: '<<' }
+      }
+      return this.readHexString()
+    }
+    if (c === 0x3e) {
+      if (b[this.pos + 1] === 0x3e) {
+        this.pos += 2
+        return { type: 'delim', value: '>>' }
+      }
+      this.pos++ // stray '>' — tolerate
+      return this.next()
+    }
+    if (c === 0x28) return this.readLiteralString()
+    if (c === 0x2f) return this.readName()
+
+    // Number: digit, sign, or '.'
+    if (isDigit(c) || c === 0x2b || c === 0x2d || c === 0x2e) {
+      const numTok = this.tryReadNumber()
+      if (numTok) return numTok
+      // fall through: treat as keyword (e.g. malformed) below
+    }
+
+    // Keyword / bare token (obj, endobj, stream, R, true, false, null, …)
+    let s = this.pos
+    while (s < b.length && isRegular(b[s]!)) s++
+    if (s === this.pos) {
+      this.pos++ // unknown single byte — skip and continue
+      return this.next()
+    }
+    const kw = latin1(b, this.pos, s)
+    this.pos = s
+    return { type: 'kw', value: kw }
+  }
+
+  /** Raw byte access for stream payloads. */
+  slice(from: number, to: number): Uint8Array {
+    return this.buf.subarray(from, to)
+  }
+
+  private tryReadNumber(): Token | null {
+    const b = this.buf
+    let p = this.pos
+    let seenDigit = false
+    let seenDot = false
+    if (b[p] === 0x2b || b[p] === 0x2d) p++
+    while (p < b.length) {
+      const ch = b[p]!
+      if (isDigit(ch)) {
+        seenDigit = true
+        p++
+      } else if (ch === 0x2e && !seenDot) {
+        seenDot = true
+        p++
+      } else {
+        break
+      }
+    }
+    if (!seenDigit) return null
+    const str = latin1(b, this.pos, p)
+    const value = Number(str)
+    if (Number.isNaN(value)) return null
+    this.pos = p
+    return { type: 'num', value }
+  }
+
+  private readName(): Token {
+    const b = this.buf
+    this.pos++ // skip '/'
+    let out = ''
+    while (this.pos < b.length) {
+      const ch = b[this.pos]!
+      if (isWs(ch) || isDelim(ch)) break
+      if (ch === 0x23 && this.pos + 2 < b.length) {
+        const hi = hexVal(b[this.pos + 1]!)
+        const lo = hexVal(b[this.pos + 2]!)
+        if (hi >= 0 && lo >= 0) {
+          out += String.fromCharCode((hi << 4) | lo)
+          this.pos += 3
+          continue
+        }
+      }
+      out += String.fromCharCode(ch)
+      this.pos++
+    }
+    return { type: 'name', value: out }
+  }
+
+  private readLiteralString(): Token {
+    const b = this.buf
+    this.pos++ // skip '('
+    const out: number[] = []
+    let depth = 1
+    while (this.pos < b.length) {
+      let ch = b[this.pos++]!
+      if (ch === 0x5c) {
+        // backslash escape
+        const e = b[this.pos++]!
+        switch (e) {
+          case 0x6e: out.push(0x0a); break // \n
+          case 0x72: out.push(0x0d); break // \r
+          case 0x74: out.push(0x09); break // \t
+          case 0x62: out.push(0x08); break // \b
+          case 0x66: out.push(0x0c); break // \f
+          case 0x28: out.push(0x28); break // \(
+          case 0x29: out.push(0x29); break // \)
+          case 0x5c: out.push(0x5c); break // \\
+          case 0x0d:
+            if (b[this.pos] === 0x0a) this.pos++ // \ + CRLF line continuation
+            break
+          case 0x0a:
+            break // \ + LF line continuation
+          default:
+            if (e >= 0x30 && e <= 0x37) {
+              // octal escape (1–3 digits)
+              let v = e - 0x30
+              for (let k = 0; k < 2; k++) {
+                const d = b[this.pos]!
+                if (d >= 0x30 && d <= 0x37) {
+                  v = (v << 3) | (d - 0x30)
+                  this.pos++
+                } else break
+              }
+              out.push(v & 0xff)
+            } else {
+              out.push(e) // unknown escape → literal char
+            }
+        }
+        continue
+      }
+      if (ch === 0x28) {
+        depth++
+        out.push(ch)
+        continue
+      }
+      if (ch === 0x29) {
+        depth--
+        if (depth === 0) break
+        out.push(ch)
+        continue
+      }
+      if (ch === 0x0d) {
+        // CR or CRLF → normalize to LF inside literal strings
+        if (b[this.pos] === 0x0a) this.pos++
+        ch = 0x0a
+      }
+      out.push(ch)
+    }
+    return { type: 'str', value: Uint8Array.from(out), encoding: 'literal' }
+  }
+
+  private readHexString(): Token {
+    const b = this.buf
+    this.pos++ // skip '<'
+    const nibbles: number[] = []
+    while (this.pos < b.length) {
+      const ch = b[this.pos++]!
+      if (ch === 0x3e) break
+      const v = hexVal(ch)
+      if (v >= 0) nibbles.push(v)
+    }
+    if (nibbles.length % 2 === 1) nibbles.push(0)
+    const out = new Uint8Array(nibbles.length / 2)
+    for (let i = 0; i < out.length; i++) out[i] = (nibbles[2 * i]! << 4) | nibbles[2 * i + 1]!
+    return { type: 'str', value: out, encoding: 'hex' }
+  }
+}
+
+function hexVal(b: number): number {
+  if (b >= 0x30 && b <= 0x39) return b - 0x30
+  if (b >= 0x41 && b <= 0x46) return b - 0x41 + 10
+  if (b >= 0x61 && b <= 0x66) return b - 0x61 + 10
+  return -1
+}
+
+export function latin1(b: Uint8Array, from: number, to: number): string {
+  let s = ''
+  for (let i = from; i < to; i++) s += String.fromCharCode(b[i]!)
+  return s
+}