@strav/pdf 0.4.17

package/src/fonts/win_ansi.ts

@@ -0,0 +1,69 @@
+/**
+ * WinAnsiEncoding (spec §10.4) — the encoding used for Standard-14 simple
+ * text fonts. It is Latin-1 except for the 0x80–0x9F band, which holds the
+ * CP1252 printable characters instead of C1 controls.
+ *
+ * `encodeWinAnsi` maps a JS string (iterated by code point) to the single-byte
+ * sequence that goes inside a PDF `(...)` / `<...>` string for `Tj`/`TJ`.
+ * Unrepresentable characters throw — silent substitution corrupts text.
+ */
+
+import { PdfGenError } from '../util/errors.ts'
+
+/** Unicode code point → byte for the CP1252 0x80–0x9F band. */
+const CP1252_HIGH: ReadonlyArray<[number, number]> = [
+  [0x20ac, 0x80], // €
+  [0x201a, 0x82], // ‚
+  [0x0192, 0x83], // ƒ
+  [0x201e, 0x84], // „
+  [0x2026, 0x85], // …
+  [0x2020, 0x86], // †
+  [0x2021, 0x87], // ‡
+  [0x02c6, 0x88], // ˆ
+  [0x2030, 0x89], // ‰
+  [0x0160, 0x8a], // Š
+  [0x2039, 0x8b], // ‹
+  [0x0152, 0x8c], // Œ
+  [0x017d, 0x8e], // Ž
+  [0x2018, 0x91], // ‘
+  [0x2019, 0x92], // ’
+  [0x201c, 0x93], // “
+  [0x201d, 0x94], // ”
+  [0x2022, 0x95], // •
+  [0x2013, 0x96], // –
+  [0x2014, 0x97], // —
+  [0x02dc, 0x98], // ˜
+  [0x2122, 0x99], // ™
+  [0x0161, 0x9a], // š
+  [0x203a, 0x9b], // ›
+  [0x0153, 0x9c], // œ
+  [0x017e, 0x9e], // ž
+  [0x0178, 0x9f], // Ÿ
+]
+
+const HIGH = new Map<number, number>(CP1252_HIGH)
+
+/** Map one Unicode code point to its WinAnsi byte, or `null` if unmappable. */
+export function winAnsiByte(cp: number): number | null {
+  // ASCII and the Latin-1 upper half map identically.
+  if ((cp >= 0x20 && cp <= 0x7e) || (cp >= 0xa0 && cp <= 0xff)) return cp
+  return HIGH.get(cp) ?? null
+}
+
+/** Encode a string to WinAnsi bytes; throws on the first unmappable char. */
+export function encodeWinAnsi(text: string): Uint8Array {
+  const out: number[] = []
+  for (const ch of text) {
+    const cp = ch.codePointAt(0)!
+    const b = winAnsiByte(cp)
+    if (b === null) {
+      throw new PdfGenError(
+        'PDF_TEXT_ENCODING',
+        `U+${cp.toString(16).toUpperCase().padStart(4, '0')} (${JSON.stringify(ch)}) ` +
+          'is not representable in WinAnsiEncoding; embed a Unicode font (milestone 5)'
+      )
+    }
+    out.push(b)
+  }
+  return Uint8Array.from(out)
+}

package/src/images/image.ts

@@ -0,0 +1,111 @@
+/**
+ * `PdfImage` (spec §11, §16). The public image handle.
+ *
+ * - `PdfImage.fromJpeg(bytes)` — embedded verbatim as a `/DCTDecode` XObject.
+ * - `PdfImage.fromPng(bytes)`  — decoded and re-emitted as a `/FlateDecode`
+ *   XObject; alpha becomes an `/SMask`, a palette an `/Indexed` color space.
+ *
+ * Like {@link PdfFont}, an image registers itself into the object table via
+ * `register(table)` and returns the XObject reference for the page resources.
+ */
+
+import type { IndirectRef, PdfObject } from '../objects/types.ts'
+import { arr, name, num } from '../objects/types.ts'
+import { hexBytes } from '../objects/string.ts'
+import type { ObjectTable } from '../document/object_table.ts'
+import { makeStream } from '../streams/stream.ts'
+import { parseJpeg } from './jpeg.ts'
+import { parsePng, type PngColorSpace } from './png.ts'
+import { buildSMask } from './smask.ts'
+
+export abstract class PdfImage {
+  /** Pixel dimensions (independent of the drawn size). */
+  abstract readonly width: number
+  abstract readonly height: number
+
+  /** Add the image (and any soft mask) to the table; return the XObject ref. */
+  abstract register(table: ObjectTable): IndirectRef
+
+  /** A baseline/progressive JPEG, embedded without re-encoding. */
+  static fromJpeg(bytes: Uint8Array): PdfImage {
+    return new JpegImage(bytes)
+  }
+
+  /** A non-interlaced PNG, decoded and re-encoded as FlateDecode. */
+  static fromPng(bytes: Uint8Array): PdfImage {
+    return new PngImage(bytes)
+  }
+}
+
+function deviceColorSpace(components: 1 | 3 | 4): PdfObject {
+  return name(components === 1 ? 'DeviceGray' : components === 3 ? 'DeviceRGB' : 'DeviceCMYK')
+}
+
+class JpegImage extends PdfImage {
+  readonly width: number
+  readonly height: number
+  private readonly info: ReturnType<typeof parseJpeg>
+
+  constructor(bytes: Uint8Array) {
+    super()
+    this.info = parseJpeg(bytes)
+    this.width = this.info.width
+    this.height = this.info.height
+  }
+
+  register(table: ObjectTable): IndirectRef {
+    const extra: Record<string, PdfObject> = {
+      Type: name('XObject'),
+      Subtype: name('Image'),
+      Width: num(this.info.width),
+      Height: num(this.info.height),
+      ColorSpace: deviceColorSpace(this.info.components),
+      BitsPerComponent: num(8),
+      Filter: name('DCTDecode'),
+    }
+    // Photoshop CMYK JPEGs store inverted samples (Adobe APP14).
+    if (this.info.adobeInverted) {
+      extra.Decode = arr([1, 0, 1, 0, 1, 0, 1, 0].map(num))
+    }
+    // filter:'none' → bytes embedded verbatim; /Filter set above.
+    return table.add(makeStream(this.info.data, { filter: 'none', extra }))
+  }
+}
+
+function pngColorSpaceObject(cs: PngColorSpace): PdfObject {
+  if (cs.kind === 'Indexed') {
+    return arr([name('Indexed'), name('DeviceRGB'), num(cs.hival), hexBytes(cs.palette)])
+  }
+  return name(cs.kind)
+}
+
+class PngImage extends PdfImage {
+  readonly width: number
+  readonly height: number
+  private readonly png: ReturnType<typeof parsePng>
+
+  constructor(bytes: Uint8Array) {
+    super()
+    this.png = parsePng(bytes)
+    this.width = this.png.width
+    this.height = this.png.height
+  }
+
+  register(table: ObjectTable): IndirectRef {
+    let smaskRef: IndirectRef | undefined
+    if (this.png.alpha) {
+      smaskRef = table.add(buildSMask(this.png.alpha, this.png.width, this.png.height))
+    }
+    const extra: Record<string, PdfObject> = {
+      Type: name('XObject'),
+      Subtype: name('Image'),
+      Width: num(this.png.width),
+      Height: num(this.png.height),
+      ColorSpace: pngColorSpaceObject(this.png.colorSpace),
+      BitsPerComponent: num(this.png.bitsPerComponent),
+    }
+    if (smaskRef) extra.SMask = smaskRef
+    if (this.png.colorKey) extra.Mask = arr(this.png.colorKey.map(num))
+    return table.add(makeStream(this.png.samples, { filter: 'FlateDecode', extra }))
+  }
+}

package/src/images/index.ts

@@ -0,0 +1,6 @@
+export { PdfImage } from './image.ts'
+export { parseJpeg } from './jpeg.ts'
+export type { JpegInfo } from './jpeg.ts'
+export { parsePng } from './png.ts'
+export type { PngImageData, PngColorSpace } from './png.ts'
+export { buildSMask } from './smask.ts'

package/src/images/jpeg.ts

@@ -0,0 +1,103 @@
+/**
+ * JPEG (JFIF/EXIF) parsing (spec §11.1).
+ *
+ * JPEG image data is embedded **verbatim** with `/DCTDecode` — we never
+ * re-encode. We only walk the marker segments to learn the dimensions,
+ * component count and bit depth, and whether an Adobe APP14 marker is present
+ * (Photoshop CMYK JPEGs store inverted samples → a `/Decode` inversion).
+ */
+
+import { InvalidImageError } from '../util/errors.ts'
+
+export interface JpegInfo {
+  width: number
+  height: number
+  /** 1 = Gray, 3 = RGB/YCbCr, 4 = CMYK/YCCK. */
+  components: 1 | 3 | 4
+  bitsPerComponent: number
+  /** Adobe APP14 present — 4-component data is inverted (set `/Decode`). */
+  adobeInverted: boolean
+  /** The original JPEG bytes, embedded as-is. */
+  data: Uint8Array
+}
+
+export function parseJpeg(data: Uint8Array): JpegInfo {
+  if (data.length < 4 || data[0] !== 0xff || data[1] !== 0xd8) {
+    throw new InvalidImageError('Not a JPEG (missing SOI marker)')
+  }
+
+  let hasAdobe = false
+  let width = 0
+  let height = 0
+  let components: 1 | 3 | 4 = 3
+  let precision = 8
+  let sawSOF = false
+
+  let i = 2
+  while (i + 1 < data.length) {
+    if (data[i] !== 0xff) {
+      i++
+      continue
+    }
+    let marker = data[i + 1]!
+    // Skip fill bytes (0xFF padding).
+    while (marker === 0xff && i + 2 < data.length) {
+      i++
+      marker = data[i + 1]!
+    }
+    i += 2
+    // Standalone markers (no length): RSTn, SOI, EOI, TEM.
+    if (marker === 0xd9 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+      continue
+    }
+    if (i + 1 >= data.length) break
+    const segLen = (data[i]! << 8) | data[i + 1]!
+    const segStart = i + 2
+    const segEnd = i + segLen
+
+    if (marker === 0xee) {
+      // APP14 "Adobe"
+      if (
+        segLen >= 7 &&
+        data[segStart] === 0x41 && // 'A'
+        data[segStart + 1] === 0x64 && // 'd'
+        data[segStart + 2] === 0x6f // 'o'
+      ) {
+        hasAdobe = true
+      }
+    } else if (
+      // SOF0..SOF15 except DHT(C4), DAC(CC), and the JPG marker (C8).
+      marker >= 0xc0 &&
+      marker <= 0xcf &&
+      marker !== 0xc4 &&
+      marker !== 0xc8 &&
+      marker !== 0xcc
+    ) {
+      precision = data[segStart]!
+      height = (data[segStart + 1]! << 8) | data[segStart + 2]!
+      width = (data[segStart + 3]! << 8) | data[segStart + 4]!
+      components = data[segStart + 5]! as 1 | 3 | 4
+      sawSOF = true
+    } else if (marker === 0xda) {
+      break // SOS — entropy-coded data follows; stop scanning.
+    }
+    i = segEnd
+  }
+
+  if (!sawSOF) throw new InvalidImageError('JPEG has no Start-Of-Frame marker')
+  if (precision !== 8) {
+    throw new InvalidImageError(`Unsupported JPEG precision ${precision} (only 8-bit is supported)`)
+  }
+  if (components !== 1 && components !== 3 && components !== 4) {
+    throw new InvalidImageError(`Unsupported JPEG component count ${components}`)
+  }
+
+  return {
+    width,
+    height,
+    components,
+    bitsPerComponent: 8,
+    adobeInverted: components === 4 && hasAdobe,
+    data,
+  }
+}

package/src/images/png.ts

@@ -0,0 +1,239 @@
+/**
+ * PNG parsing (spec §11.2).
+ *
+ * PDF has no PNG filter, so we decode: parse chunks, inflate IDAT, undo the
+ * PNG line filters, and hand back raw samples (re-encoded as FlateDecode by
+ * image.ts, with no PDF predictor in v1). Alpha (color type 4/6 or `tRNS`) is
+ * split into a separate soft-mask plane; an indexed PNG keeps its palette.
+ *
+ * Limits (v1): interlaced PNGs and 16-bit depth are rejected; an embedded
+ * `iCCP` profile is ignored (device color space) until ICC support (M9).
+ */
+
+import { InvalidImageError } from '../util/errors.ts'
+import { flateDecode } from '../streams/flate.ts'
+
+export type PngColorSpace =
+  | { kind: 'DeviceGray' }
+  | { kind: 'DeviceRGB' }
+  | { kind: 'Indexed'; palette: Uint8Array; hival: number }
+
+export interface PngImageData {
+  width: number
+  height: number
+  bitsPerComponent: number
+  colorSpace: PngColorSpace
+  /** Color samples, line-filters removed (no alpha). */
+  samples: Uint8Array
+  /** 8-bit alpha plane (width×height), if the image has transparency. */
+  alpha?: Uint8Array
+  /** Color-key mask `[min max …]` for `tRNS` on gray/RGB images. */
+  colorKey?: number[]
+}
+
+const SIG = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]
+
+function u32(b: Uint8Array, o: number): number {
+  return ((b[o]! << 24) | (b[o + 1]! << 16) | (b[o + 2]! << 8) | b[o + 3]!) >>> 0
+}
+
+function paeth(a: number, b: number, c: number): number {
+  const p = a + b - c
+  const pa = Math.abs(p - a)
+  const pb = Math.abs(p - b)
+  const pc = Math.abs(p - c)
+  if (pa <= pb && pa <= pc) return a
+  return pb <= pc ? b : c
+}
+
+/** Reverse the PNG line filters, returning `height` rows of `rowBytes`. */
+function unfilter(
+  raw: Uint8Array,
+  height: number,
+  rowBytes: number,
+  bpp: number
+): Uint8Array {
+  const out = new Uint8Array(height * rowBytes)
+  let pos = 0
+  for (let y = 0; y < height; y++) {
+    const filter = raw[pos++]!
+    const o = y * rowBytes
+    const p = (y - 1) * rowBytes
+    for (let x = 0; x < rowBytes; x++) {
+      const v = raw[pos++]!
+      const a = x >= bpp ? out[o + x - bpp]! : 0
+      const b = y > 0 ? out[p + x]! : 0
+      const c = y > 0 && x >= bpp ? out[p + x - bpp]! : 0
+      let s: number
+      switch (filter) {
+        case 0:
+          s = v
+          break
+        case 1:
+          s = v + a
+          break
+        case 2:
+          s = v + b
+          break
+        case 3:
+          s = v + ((a + b) >> 1)
+          break
+        case 4:
+          s = v + paeth(a, b, c)
+          break
+        default:
+          throw new InvalidImageError(`Unknown PNG filter type ${filter}`)
+      }
+      out[o + x] = s & 0xff
+    }
+  }
+  return out
+}
+
+export function parsePng(data: Uint8Array): PngImageData {
+  for (let i = 0; i < 8; i++) {
+    if (data[i] !== SIG[i]) throw new InvalidImageError('Not a PNG (bad signature)')
+  }
+
+  let width = 0
+  let height = 0
+  let bitDepth = 8
+  let colorType = 0
+  let palette: Uint8Array | undefined
+  let trns: Uint8Array | undefined
+  const idat: Uint8Array[] = []
+
+  let pos = 8
+  while (pos + 8 <= data.length) {
+    const len = u32(data, pos)
+    const type = String.fromCharCode(
+      data[pos + 4]!,
+      data[pos + 5]!,
+      data[pos + 6]!,
+      data[pos + 7]!
+    )
+    const body = data.subarray(pos + 8, pos + 8 + len)
+    if (type === 'IHDR') {
+      width = u32(body, 0)
+      height = u32(body, 4)
+      bitDepth = body[8]!
+      colorType = body[9]!
+      if (body[12] !== 0) {
+        throw new InvalidImageError('Interlaced PNGs are not supported (de-interlace first)')
+      }
+    } else if (type === 'PLTE') {
+      palette = body.slice()
+    } else if (type === 'tRNS') {
+      trns = body.slice()
+    } else if (type === 'IDAT') {
+      idat.push(body.slice())
+    } else if (type === 'IEND') {
+      break
+    }
+    pos += 12 + len // length + type + data + CRC
+  }
+
+  if (bitDepth === 16) {
+    throw new InvalidImageError('16-bit PNGs are not supported in v1 (downsample to 8-bit)')
+  }
+
+  const channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[colorType]
+  if (channels === undefined) {
+    throw new InvalidImageError(`Unsupported PNG color type ${colorType}`)
+  }
+  if (colorType !== 0 && colorType !== 3 && bitDepth !== 8) {
+    throw new InvalidImageError(`Unsupported PNG bit depth ${bitDepth} for color type ${colorType}`)
+  }
+
+  // Concatenate + inflate IDAT, then undo line filters.
+  let total = 0
+  for (const c of idat) total += c.length
+  const comp = new Uint8Array(total)
+  {
+    let o = 0
+    for (const c of idat) {
+      comp.set(c, o)
+      o += c.length
+    }
+  }
+  const rowBytes = Math.ceil((width * channels * bitDepth) / 8)
+  const bpp = Math.max(1, Math.ceil((channels * bitDepth) / 8))
+  const raw = unfilter(flateDecode(comp), height, rowBytes, bpp)
+
+  // Split colour vs. alpha and pick the PDF color space.
+  if (colorType === 0) {
+    const res: PngImageData = {
+      width,
+      height,
+      bitsPerComponent: bitDepth,
+      colorSpace: { kind: 'DeviceGray' },
+      samples: raw,
+    }
+    if (trns && trns.length >= 2) res.colorKey = [trns[1]!, trns[1]!]
+    return res
+  }
+  if (colorType === 2) {
+    const res: PngImageData = {
+      width,
+      height,
+      bitsPerComponent: 8,
+      colorSpace: { kind: 'DeviceRGB' },
+      samples: raw,
+    }
+    if (trns && trns.length >= 6) {
+      res.colorKey = [trns[1]!, trns[1]!, trns[3]!, trns[3]!, trns[5]!, trns[5]!]
+    }
+    return res
+  }
+  if (colorType === 3) {
+    if (!palette) throw new InvalidImageError('Indexed PNG missing PLTE chunk')
+    const res: PngImageData = {
+      width,
+      height,
+      bitsPerComponent: bitDepth,
+      colorSpace: { kind: 'Indexed', palette, hival: palette.length / 3 - 1 },
+      samples: raw,
+    }
+    if (trns) {
+      // Per-palette-entry alpha → an 8-bit soft mask plane.
+      const alpha = new Uint8Array(width * height)
+      const perRow = rowBytes
+      let k = 0
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const idx = readIndex(raw, y * perRow, x, bitDepth)
+          alpha[k++] = idx < trns.length ? trns[idx]! : 255
+        }
+      }
+      res.alpha = alpha
+    }
+    return res
+  }
+  // colorType 4 (gray+alpha) or 6 (RGBA) — 8-bit, split the alpha channel.
+  const colorCh = colorType === 4 ? 1 : 3
+  const px = width * height
+  const samples = new Uint8Array(px * colorCh)
+  const alpha = new Uint8Array(px)
+  for (let i = 0; i < px; i++) {
+    const src = i * (colorCh + 1)
+    for (let ch = 0; ch < colorCh; ch++) samples[i * colorCh + ch] = raw[src + ch]!
+    alpha[i] = raw[src + colorCh]!
+  }
+  return {
+    width,
+    height,
+    bitsPerComponent: 8,
+    colorSpace: colorType === 4 ? { kind: 'DeviceGray' } : { kind: 'DeviceRGB' },
+    samples,
+    alpha,
+  }
+}
+
+/** Read the palette index of pixel `x` in a sub-byte-packed scanline. */
+function readIndex(raw: Uint8Array, rowOff: number, x: number, bitDepth: number): number {
+  if (bitDepth === 8) return raw[rowOff + x]!
+  const perByte = 8 / bitDepth
+  const byte = raw[rowOff + Math.floor(x / perByte)]!
+  const shift = 8 - bitDepth * ((x % perByte) + 1)
+  return (byte >> shift) & ((1 << bitDepth) - 1)
+}

package/src/images/smask.ts

@@ -0,0 +1,24 @@
+/**
+ * Soft mask for image alpha (spec §11.2). An 8-bit alpha plane becomes a
+ * standalone DeviceGray image XObject referenced from the parent image's
+ * `/SMask` entry.
+ */
+
+import { name, num } from '../objects/types.ts'
+import type { PdfStream } from '../objects/types.ts'
+import { makeStream } from '../streams/stream.ts'
+
+/** Build the soft-mask image XObject stream from an alpha plane. */
+export function buildSMask(alpha: Uint8Array, width: number, height: number): PdfStream {
+  return makeStream(alpha, {
+    filter: 'FlateDecode',
+    extra: {
+      Type: name('XObject'),
+      Subtype: name('Image'),
+      Width: num(width),
+      Height: num(height),
+      ColorSpace: name('DeviceGray'),
+      BitsPerComponent: num(8),
+    },
+  })
+}

package/src/index.ts

@@ -0,0 +1,57 @@
+/**
+ * `@strav/pdf` — low-level, zero-dependency PDF generation (write side).
+ *
+ * This effort delivers spec milestones 1–3: object model & serialization,
+ * pages + content streams + device color, and stream filters. Fonts, images,
+ * color management, transparency and conformance modes are later milestones.
+ */
+
+export { PdfDocument } from './document/pdf_document.ts'
+export { Page } from './document/page.ts'
+export type {
+  PageSize,
+  Rect,
+  ConformanceLevel,
+  DocumentInfo,
+  CreateOptions,
+  AddPageOptions,
+} from './document/types.ts'
+
+export { BufferSink } from './output/buffer_sink.ts'
+export { StreamSink } from './output/stream_sink.ts'
+export type { ByteSink } from './output/byte_sink.ts'
+
+export { ContentStream } from './content/content_stream.ts'
+export type { TextObject, RunPart } from './content/text_object.ts'
+
+export { PdfFont } from './fonts/font.ts'
+export type { StandardFontName, TrueTypeOptions } from './fonts/font.ts'
+
+export { PdfImage } from './images/image.ts'
+
+export { Color, rgb, cmyk, gray } from './color/color.ts'
+export type { Color as ColorValue, ColorSpace, DeviceColor } from './color/color.ts'
+export { rgbToGray, cmykToRgb, rgbToCmyk } from './color/conversion.ts'
+export { separation } from './color/separation.ts'
+export { iccBased, parseIccProfile } from './color/icc.ts'
+export { deviceN } from './color/devicen.ts'
+export { calGray, calRGB, lab } from './color/cie.ts'
+export type { ManagedColorSpace } from './color/space.ts'
+export type { OutputIntentConfig } from './document/types.ts'
+
+export { extGState } from './ext-gstate/ext_gstate.ts'
+export type { ExtGState, ExtGStateOptions, BlendMode } from './ext-gstate/ext_gstate.ts'
+export { tilingPattern } from './patterns/tiling_pattern.ts'
+export type { TilingPattern, TilingPatternOptions } from './patterns/tiling_pattern.ts'
+export { axialShading, radialShading, shadingPattern } from './patterns/shading.ts'
+export type { Shading, ShadingPattern, ColorStop } from './patterns/shading.ts'
+
+export { mm, cm, inch, pt } from './util/units.ts'
+
+export {
+  PdfGenError,
+  ConformanceError,
+  UnsupportedFontError,
+  InvalidImageError,
+} from './util/errors.ts'
+export type { PdfGenErrorCode } from './util/errors.ts'

package/src/metadata/index.ts

@@ -0,0 +1,3 @@
+export { buildInfoDict } from './info_dict.ts'
+export { buildXmpPacket, buildXmpStream } from './xmp.ts'
+export type { XmpOptions } from './xmp.ts'

package/src/metadata/info_dict.ts

@@ -0,0 +1,28 @@
+/**
+ * The legacy Info dictionary (spec §14.1). Kept for old readers and the
+ * trailer `/Info`; XMP (metadata/xmp.ts) is the authoritative source and is
+ * built from the same values so the two stay in sync.
+ */
+
+import { dict } from '../objects/types.ts'
+import type { PdfDictionary, PdfObject } from '../objects/types.ts'
+import { textString, dateString } from '../objects/string.ts'
+import type { DocumentInfo } from '../document/types.ts'
+
+export function buildInfoDict(
+  info: DocumentInfo,
+  creationDate: Date,
+  producer: string
+): PdfDictionary {
+  const d = dateString(creationDate)
+  const entries: Record<string, PdfObject> = {}
+  if (info.title) entries.Title = textString(info.title)
+  if (info.author) entries.Author = textString(info.author)
+  if (info.subject) entries.Subject = textString(info.subject)
+  if (info.keywords) entries.Keywords = textString(info.keywords)
+  if (info.creator) entries.Creator = textString(info.creator)
+  entries.Producer = textString(producer)
+  entries.CreationDate = d
+  entries.ModDate = d
+  return dict(entries)
+}