@asterdoc/render 0.0.0-stage → 0.9.0

package/dist/pdf.js

@@ -0,0 +1,4638 @@
+import {
+  requestRenderData
+} from "./chunk-U7LF3GN4.js";
+import {
+  formatFieldData,
+  unwrapFormattedValue,
+  validateFieldBindings
+} from "./chunk-ICQLU4FL.js";
+import {
+  PdfBindingKeyError,
+  PdfBindingSyntaxError,
+  getPath,
+  parseBinding,
+  parseBindings,
+  pathSegments,
+  renderDataPath,
+  resolveLayerBindings,
+  splitPartIndex
+} from "./chunk-4QVR6LUY.js";
+
+// src/pdf/field-appearance.ts
+var PdfFieldFillError = class extends Error {
+  /** Fully qualified name of the PDF form field, or the overlay that failed. */
+  field;
+  reason;
+  limit;
+  character;
+  script;
+  constructor(field, reason, detail, message) {
+    super(`Cannot fill PDF field "${field}": ${message}`);
+    this.name = "PdfFieldFillError";
+    this.field = field;
+    this.reason = reason;
+    if (detail.limit !== void 0) this.limit = detail.limit;
+    if (detail.character !== void 0) this.character = detail.character;
+    if (detail.script !== void 0) this.script = detail.script;
+  }
+};
+var MIN_FONT_SIZE = 6;
+var AUTO_MULTILINE_MAX = 12;
+var PADDING_X = 2;
+var PADDING_Y = 1;
+var LINE_SPACING = 1.15;
+var SHRINK_STEP = 0.5;
+function parseDefaultAppearance(value) {
+  const tokens = (value ?? "").trim().split(/\s+/).filter(Boolean);
+  let size = 0;
+  let fontName;
+  let color = "0 g";
+  const operands = { g: 1, rg: 3, k: 4 };
+  tokens.forEach((token, index) => {
+    if (token === "Tf") {
+      const declared = Number(tokens[index - 1]);
+      size = Number.isFinite(declared) && declared > 0 ? declared : 0;
+      const name2 = tokens[index - 2];
+      if (name2?.startsWith("/")) fontName = name2.slice(1);
+    } else if (token in operands) {
+      const count = operands[token];
+      const values = tokens.slice(index - count, index);
+      if (values.length === count && values.every((item) => Number.isFinite(Number(item)))) {
+        color = `${values.join(" ")} ${token}`;
+      }
+    }
+  });
+  return { size, color, ...fontName && { fontName } };
+}
+var format = (value) => String(Number(value.toFixed(3)));
+function show(font, size, x, y, text) {
+  return `/${font.resourceName} ${format(size)} Tf
+1 0 0 1 ${format(x)} ${format(y)} Tm
+${font.encode(text)} Tj`;
+}
+function alignedX(layout, lineWidth) {
+  if (layout.alignment === 1) return (layout.width - lineWidth) / 2;
+  if (layout.alignment === 2) return layout.width - PADDING_X - lineWidth;
+  return PADDING_X;
+}
+function centeredBaseline(layout, font, size) {
+  const glyphHeight = (font.ascent - font.descent) / 1e3 * size;
+  return (layout.height - glyphHeight) / 2 - font.descent / 1e3 * size;
+}
+function overflow(layout, floor) {
+  throw new PdfFieldFillError(
+    layout.field,
+    "overflow",
+    { limit: floor },
+    `the value does not fit at the minimum size of ${format(floor)} pt`
+  );
+}
+function wrap(text, font, size, width) {
+  const measure2 = (value) => font.width(value) / 1e3 * size;
+  const lines2 = [];
+  for (const paragraph of text.split(/\r\n|\r|\n/)) {
+    let line = "";
+    for (const word of paragraph.split(" ")) {
+      const candidate = line ? `${line} ${word}` : word;
+      if (measure2(candidate) <= width) {
+        line = candidate;
+        continue;
+      }
+      if (line) lines2.push(line);
+      line = "";
+      let rest = word;
+      while (measure2(rest) > width && [...rest].length > 1) {
+        const characters = [...rest];
+        let count = 1;
+        while (count < characters.length && measure2(characters.slice(0, count + 1).join("")) <= width) count++;
+        lines2.push(characters.slice(0, count).join(""));
+        rest = characters.slice(count).join("");
+      }
+      line = rest;
+    }
+    lines2.push(line);
+  }
+  return lines2;
+}
+var sizeFloor = (layout) => layout.appearance.size ? Math.min(MIN_FONT_SIZE, layout.appearance.size) : MIN_FONT_SIZE;
+function oneLineSize(layout, font, unitWidth, width) {
+  const heightFit = (layout.height - 2 * PADDING_Y) / ((font.ascent - font.descent) / 1e3);
+  const widthFit = unitWidth > 0 ? width / unitWidth : Number.POSITIVE_INFINITY;
+  const size = Math.min(layout.appearance.size || Number.POSITIVE_INFINITY, heightFit, widthFit);
+  const floor = sizeFloor(layout);
+  if (size < floor) overflow(layout, floor);
+  return size;
+}
+function singleLine(layout, text, font) {
+  const unitWidth = font.width(text) / 1e3;
+  const size = oneLineSize(layout, font, unitWidth, layout.width - 2 * PADDING_X);
+  return show(font, size, alignedX(layout, unitWidth * size), centeredBaseline(layout, font, size), text);
+}
+function combed(layout, boxes, text, font) {
+  const characters = [...text];
+  if (characters.length > boxes) {
+    throw new PdfFieldFillError(
+      layout.field,
+      "comb-length",
+      { limit: boxes },
+      `the field has ${boxes} comb boxes, but the value has ${characters.length} characters`
+    );
+  }
+  const cell = layout.width / boxes;
+  const widest = Math.max(0, ...characters.map((character) => font.width(character) / 1e3));
+  const size = oneLineSize(layout, font, widest, cell);
+  const unused = boxes - characters.length;
+  const first = layout.alignment === 1 ? Math.floor(unused / 2) : layout.alignment === 2 ? unused : 0;
+  const baseline = centeredBaseline(layout, font, size);
+  return characters.map((character, index) => {
+    const width = font.width(character) / 1e3 * size;
+    const x = (first + index) * cell + (cell - width) / 2;
+    return show(font, size, x, baseline, character);
+  }).join("\n");
+}
+function multiline(layout, text, font) {
+  const floor = sizeFloor(layout);
+  const available = layout.width - 2 * PADDING_X;
+  const fits = (size, lines2) => lines2.every((line) => font.width(line) / 1e3 * size <= available) && 2 * PADDING_Y + (font.ascent - font.descent) / 1e3 * size + (lines2.length - 1) * LINE_SPACING * size <= layout.height;
+  const start = layout.appearance.size || AUTO_MULTILINE_MAX;
+  const candidates = [];
+  for (let size = start; size > floor; size -= SHRINK_STEP) candidates.push(size);
+  candidates.push(floor);
+  for (const size of candidates) {
+    const lines2 = wrap(text, font, size, available);
+    if (!fits(size, lines2)) continue;
+    const firstBaseline = layout.height - PADDING_Y - font.ascent / 1e3 * size;
+    return lines2.map((line, index) => show(
+      font,
+      size,
+      alignedX(layout, font.width(line) / 1e3 * size),
+      firstBaseline - index * LINE_SPACING * size,
+      line
+    )).join("\n");
+  }
+  return overflow(layout, floor);
+}
+function layoutFieldText(layout, text, font) {
+  if (layout.comb !== void 0 && layout.comb > 0 && !layout.multiline) {
+    return combed(layout, layout.comb, text, font);
+  }
+  if (layout.multiline) return multiline(layout, text, font);
+  return singleLine(layout, text.replace(/\r\n|\r|\n/g, " "), font);
+}
+
+// src/pdf/text-string.ts
+var PDF_DOC_DIFFERENCES = [
+  [24, 728],
+  [25, 711],
+  [26, 710],
+  [27, 729],
+  [28, 733],
+  [29, 731],
+  [30, 730],
+  [31, 732],
+  [128, 8226],
+  [129, 8224],
+  [130, 8225],
+  [131, 8230],
+  [132, 8212],
+  [133, 8211],
+  [134, 402],
+  [135, 8260],
+  [136, 8249],
+  [137, 8250],
+  [138, 8722],
+  [139, 8240],
+  [140, 8222],
+  [141, 8220],
+  [142, 8221],
+  [143, 8216],
+  [144, 8217],
+  [145, 8218],
+  [146, 8482],
+  [147, 64257],
+  [148, 64258],
+  [149, 321],
+  [150, 338],
+  [151, 352],
+  [152, 376],
+  [153, 381],
+  [154, 305],
+  [155, 322],
+  [156, 339],
+  [157, 353],
+  [158, 382],
+  [160, 8364]
+];
+var UNDEFINED_PDF_DOC = /* @__PURE__ */ new Set([
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  11,
+  12,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  127,
+  159,
+  173
+]);
+var PDF_DOC_TO_UNICODE = (() => {
+  const table = Array.from({ length: 256 }, (_, code) => code);
+  for (const [code, unicode] of PDF_DOC_DIFFERENCES) table[code] = unicode;
+  return table;
+})();
+var UNICODE_TO_PDF_DOC = new Map(
+  PDF_DOC_TO_UNICODE.flatMap((unicode, code) => UNDEFINED_PDF_DOC.has(code) ? [] : [[unicode, code]])
+);
+var ESCAPE = "\x1B";
+function withoutLanguageEscapes(text) {
+  let result = "";
+  let cursor = 0;
+  while (cursor < text.length) {
+    const start = text.indexOf(ESCAPE, cursor);
+    const end = start === -1 ? -1 : text.indexOf(ESCAPE, start + 1);
+    if (end === -1) return result + text.slice(cursor);
+    result += text.slice(cursor, start);
+    cursor = end + 1;
+  }
+  return result;
+}
+function byteString(bytes) {
+  let result = "";
+  for (let offset = 0; offset < bytes.length; offset += 32768) {
+    result += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+  }
+  return result;
+}
+function stringBytes(value) {
+  const bytes = new Uint8Array(value.length);
+  for (let index = 0; index < value.length; index++) bytes[index] = value.charCodeAt(index);
+  return bytes;
+}
+function decodeTextString(value) {
+  if (value.charCodeAt(0) === 254 && value.charCodeAt(1) === 255) {
+    let text2 = "";
+    for (let index = 2; index + 1 < value.length; index += 2) {
+      text2 += String.fromCharCode(value.charCodeAt(index) << 8 | value.charCodeAt(index + 1));
+    }
+    return withoutLanguageEscapes(text2);
+  }
+  if (value.charCodeAt(0) === 239 && value.charCodeAt(1) === 187 && value.charCodeAt(2) === 191) {
+    return withoutLanguageEscapes(new TextDecoder("utf-8").decode(stringBytes(value.slice(3))));
+  }
+  let text = "";
+  for (let index = 0; index < value.length; index++) text += String.fromCharCode(PDF_DOC_TO_UNICODE[value.charCodeAt(index) & 255]);
+  return text;
+}
+function encodeTextString(text) {
+  let encoded = "";
+  for (let index = 0; index < text.length; index++) {
+    const code = UNICODE_TO_PDF_DOC.get(text.charCodeAt(index));
+    if (code === void 0) return utf16(text);
+    encoded += String.fromCharCode(code);
+  }
+  return encoded;
+}
+function utf16(text) {
+  let encoded = "\xFE\xFF";
+  for (let index = 0; index < text.length; index++) {
+    const unit = text.charCodeAt(index);
+    encoded += String.fromCharCode(unit >> 8, unit & 255);
+  }
+  return encoded;
+}
+
+// src/pdf/writer.ts
+function encodeLatin1(value) {
+  const bytes = new Uint8Array(value.length);
+  for (let index = 0; index < value.length; index++) bytes[index] = value.charCodeAt(index) & 255;
+  return bytes;
+}
+function serializeName(value) {
+  return `/${value.replace(/[^!-'*-.0-;=?-Z\\^-z|~]/g, (char) => `#${char.charCodeAt(0).toString(16).padStart(2, "0")}`)}`;
+}
+function serializeString(value) {
+  let hex = "";
+  let printable = true;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code > 255) throw new Error(`PDF string holds U+${code.toString(16).toUpperCase().padStart(4, "0")}; encode text with encodeTextString before storing it`);
+    if (code < 32 ? code !== 9 && code !== 10 && code !== 13 : code > 126) printable = false;
+    hex += code.toString(16).padStart(2, "0");
+  }
+  if (!printable) return `<${hex}>`;
+  return `(${value.replace(/([\\()])/g, "\\$1").replace(/\r/g, "\\r").replace(/\n/g, "\\n")})`;
+}
+function serializePdfValue(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (typeof value === "string") return serializeString(value);
+  if (Array.isArray(value)) return `[${value.map(serializePdfValue).join(" ")}]`;
+  if (value.kind === "name") return serializeName(value.value);
+  if (value.kind === "ref") return `${value.object} ${value.generation} R`;
+  return `<<${[...value.entries].map(([key, item]) => ` ${serializeName(key)} ${serializePdfValue(item)}`).join("")} >>`;
+}
+function serializeObjects(objects, start) {
+  const chunks = [];
+  const offsets = /* @__PURE__ */ new Map();
+  let offset = start;
+  for (const record of [...objects].sort((a, b) => a.object - b.object)) {
+    offsets.set(record.object, offset);
+    const header = encodeLatin1(`${record.object} ${record.generation} obj
+`);
+    chunks.push(header);
+    offset += header.length;
+    if (record.stream) {
+      if (typeof record.value !== "object" || record.value === null || Array.isArray(record.value) || record.value.kind !== "dict") {
+        throw new Error(`PDF stream object ${record.object} must contain a dictionary`);
+      }
+      const entries = new Map(record.value.entries);
+      entries.set("Length", record.stream.length);
+      const dictionary = encodeLatin1(`${serializePdfValue({ kind: "dict", entries })}
+stream
+`);
+      const footer = encodeLatin1("\nendstream\nendobj\n");
+      chunks.push(dictionary, record.stream, footer);
+      offset += dictionary.length + record.stream.length + footer.length;
+    } else {
+      const body = encodeLatin1(`${serializePdfValue(record.value)}
+endobj
+`);
+      chunks.push(body);
+      offset += body.length;
+    }
+  }
+  return { chunks, offsets, end: offset };
+}
+function trailerSection(trailer, xrefOffset) {
+  return `trailer
+${serializePdfValue({ kind: "dict", entries: new Map(trailer) })}
+startxref
+${xrefOffset}
+%%EOF
+`;
+}
+function concat(chunks) {
+  const output = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
+  let cursor = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, cursor);
+    cursor += chunk.length;
+  }
+  return output;
+}
+function writePdf(objects, trailer) {
+  const header = encodeLatin1("%PDF-1.7\n%\xE2\xE3\xCF\xD3\n");
+  const body = serializeObjects(objects, header.length);
+  const size = objects.reduce((highest, record) => Math.max(highest, record.object), 0) + 1;
+  let table = `xref
+0 ${size}
+0000000000 65535 f 
+`;
+  for (let number = 1; number < size; number++) {
+    const at = body.offsets.get(number);
+    table += at === void 0 ? "0000000000 65535 f \n" : `${String(at).padStart(10, "0")} 00000 n 
+`;
+  }
+  const entries = new Map(trailer);
+  entries.set("Size", size);
+  table += trailerSection(entries, body.end);
+  return concat([header, ...body.chunks, encodeLatin1(table)]);
+}
+function appendPdfUpdate(base, objects, trailer) {
+  const separator = encodeLatin1(base.at(-1) === 10 ? "" : "\n");
+  const body = serializeObjects(objects, base.length + separator.length);
+  let xref = "xref\n";
+  for (const record of [...objects].sort((a, b) => a.object - b.object)) {
+    xref += `${record.object} 1
+${String(body.offsets.get(record.object)).padStart(10, "0")} ${String(record.generation).padStart(5, "0")} n 
+`;
+  }
+  xref += trailerSection(trailer, body.end);
+  return concat([base, separator, ...body.chunks, encodeLatin1(xref)]);
+}
+function collectRefs(model, value, seen, excluded = /* @__PURE__ */ new Set()) {
+  if (value === null || value === void 0 || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const entry of value) collectRefs(model, entry, seen, excluded);
+    return;
+  }
+  if (value.kind === "ref") {
+    if (seen.has(value.object) || excluded.has(value.object)) return;
+    seen.add(value.object);
+    const record = model.objects.get(value.object);
+    if (record) collectRefs(model, record.value, seen, excluded);
+    return;
+  }
+  if (value.kind === "dict") {
+    for (const entry of value.entries.values()) collectRefs(model, entry, seen, excluded);
+  }
+}
+function renumber(value, mapping) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    const references = value.length > 0 && value.every((entry) => isRefValue(entry));
+    const kept = references ? value.filter((entry) => isRefValue(entry) && mapping.has(entry.object)) : value;
+    return kept.map((entry) => renumber(entry, mapping));
+  }
+  if (value.kind === "ref") {
+    const target = mapping.get(value.object);
+    return target === void 0 ? null : { kind: "ref", object: target, generation: 0 };
+  }
+  if (value.kind === "dict") {
+    const entries = /* @__PURE__ */ new Map();
+    for (const [key, entry] of value.entries) entries.set(key, renumber(entry, mapping));
+    return { kind: "dict", entries };
+  }
+  return value;
+}
+function isRefValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && value.kind === "ref";
+}
+
+// src/pdf/syntax.ts
+var isName = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value) && value.kind === "name");
+var isRef = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value) && value.kind === "ref");
+var isDict = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value) && value.kind === "dict");
+var Parser = class {
+  constructor(source2, position = 0) {
+    this.source = source2;
+    this.position = position;
+  }
+  source;
+  position;
+  get offset() {
+    return this.position;
+  }
+  parse() {
+    this.skip();
+    if (this.source.startsWith("<<", this.position)) return this.dictionary();
+    const char = this.source[this.position];
+    if (char === "[") return this.array();
+    if (char === "/") return this.name();
+    if (char === "(") return this.literalString();
+    if (char === "<") return this.hexString();
+    if (this.source.startsWith("true", this.position)) {
+      this.position += 4;
+      return true;
+    }
+    if (this.source.startsWith("false", this.position)) {
+      this.position += 5;
+      return false;
+    }
+    if (this.source.startsWith("null", this.position)) {
+      this.position += 4;
+      return null;
+    }
+    return this.numberOrRef();
+  }
+  dictionary() {
+    this.position += 2;
+    const entries = /* @__PURE__ */ new Map();
+    while (true) {
+      this.skip();
+      this.assertNotAtEnd();
+      if (this.source.startsWith(">>", this.position)) {
+        this.position += 2;
+        return { kind: "dict", entries };
+      }
+      const key = this.name().value;
+      entries.set(key, this.parse());
+    }
+  }
+  array() {
+    this.position++;
+    const values = [];
+    while (true) {
+      this.skip();
+      this.assertNotAtEnd();
+      if (this.source[this.position] === "]") {
+        this.position++;
+        return values;
+      }
+      values.push(this.parse());
+    }
+  }
+  name() {
+    this.position++;
+    const start = this.position;
+    while (!this.atDelimiter()) this.position++;
+    return {
+      kind: "name",
+      value: this.source.slice(start, this.position).replace(/#([0-9a-f]{2})/gi, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+    };
+  }
+  literalString() {
+    this.position++;
+    let depth = 1;
+    let result = "";
+    while (this.position < this.source.length && depth > 0) {
+      const char = this.source[this.position++];
+      if (char === "\\") {
+        const escaped = this.source[this.position++];
+        if (escaped === void 0) break;
+        const simple = { n: "\n", r: "\r", t: "	", b: "\b", f: "\f" };
+        if (simple[escaped]) result += simple[escaped];
+        else if (escaped === "\n") continue;
+        else if (escaped === "\r") {
+          if (this.source[this.position] === "\n") this.position++;
+        } else if (/[0-7]/.test(escaped)) {
+          let octal = escaped;
+          while (octal.length < 3 && /[0-7]/.test(this.source[this.position] ?? "")) octal += this.source[this.position++];
+          result += String.fromCharCode(Number.parseInt(octal, 8) & 255);
+        } else result += escaped;
+      } else if (char === "(") {
+        depth++;
+        result += char;
+      } else if (char === ")") {
+        depth--;
+        if (depth > 0) result += char;
+      } else result += char;
+    }
+    return result;
+  }
+  hexString() {
+    this.position++;
+    const start = this.position;
+    while (this.position < this.source.length && this.source[this.position] !== ">") this.position++;
+    let hex = this.source.slice(start, this.position++).replace(/\s/g, "");
+    if (hex.length % 2 === 1) hex += "0";
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let index = 0; index < bytes.length; index++) bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+    return byteString(bytes);
+  }
+  numberOrRef() {
+    const first = this.number();
+    const saved = this.position;
+    this.skip();
+    if (/[-+\d.]/.test(this.source[this.position] ?? "")) {
+      const second = this.number();
+      this.skip();
+      if (this.source[this.position] === "R" && Number.isInteger(first) && Number.isInteger(second)) {
+        this.position++;
+        return { kind: "ref", object: first, generation: second };
+      }
+    }
+    this.position = saved;
+    return first;
+  }
+  number() {
+    const start = this.position;
+    while (/[-+\d.]/.test(this.source[this.position] ?? "")) this.position++;
+    const value = Number(this.source.slice(start, this.position));
+    if (!Number.isFinite(value)) throw new Error(`Invalid PDF number at byte ${start}`);
+    return value;
+  }
+  assertNotAtEnd() {
+    if (this.position >= this.source.length) throw new Error("Unexpected end of PDF data");
+  }
+  skip() {
+    while (this.position < this.source.length) {
+      if (/\s|\0/.test(this.source[this.position])) this.position++;
+      else if (this.source[this.position] === "%") {
+        while (this.position < this.source.length && !/[\r\n]/.test(this.source[this.position])) this.position++;
+      } else break;
+    }
+  }
+  atDelimiter() {
+    const char = this.source[this.position];
+    return char === void 0 || /\s/.test(char) || ["(", ")", "<", ">", "[", "]", "{", "}", "/", "%"].includes(char);
+  }
+};
+async function inflate(bytes) {
+  if (typeof DecompressionStream === "undefined") throw new Error("FlateDecode is unavailable in this runtime");
+  const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("deflate"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+var PdfEncryptedError = class extends Error {
+  code = "encrypted_pdf";
+  constructor() {
+    super("The PDF is encrypted. Asterdoc reads and writes unencrypted PDFs only; remove the encryption and try again.");
+    this.name = "PdfEncryptedError";
+  }
+};
+var SECTION_KEYS = ["Size", "Prev", "XRefStm", "Type", "Index", "W", "Length", "Filter", "DecodeParms"];
+var isXrefStream = (value) => {
+  if (!isDict(value)) return false;
+  const type = value.entries.get("Type");
+  return isName(type) && type.value === "XRef";
+};
+function trailerDictionaries(source2, bodies) {
+  const trailers = [];
+  for (const match of source2.matchAll(/trailer\s*<</g)) {
+    const at = match.index ?? 0;
+    if (bodies.some(([start, end]) => at >= start && at < end)) continue;
+    try {
+      const value = new Parser(source2, at + "trailer".length).parse();
+      if (isDict(value)) trailers.push({ offset: at, dict: value });
+    } catch {
+    }
+  }
+  return trailers;
+}
+function newestTrailer(source2, startxref, trailers, objects) {
+  if (startxref !== void 0) {
+    if (/^\s*xref\b/.test(source2.slice(startxref, startxref + 16))) {
+      const trailer = trailers.find(({ offset }) => offset > startxref);
+      if (trailer) return trailer.dict;
+    }
+    const header = /^\s*(\d+)\s+\d+\s+obj\b/.exec(source2.slice(startxref, startxref + 32));
+    const stream = header ? objects.get(Number(header[1]))?.value : void 0;
+    if (isXrefStream(stream)) return stream;
+  }
+  if (trailers.length > 0) return trailers.at(-1).dict;
+  return [...objects.values()].map(({ value }) => value).filter(isXrefStream).at(-1);
+}
+var PdfModel = class _PdfModel {
+  constructor(bytes, objects, trailer, startxref) {
+    this.bytes = bytes;
+    this.objects = objects;
+    this.trailer = trailer;
+    this.startxref = startxref;
+  }
+  bytes;
+  objects;
+  trailer;
+  startxref;
+  updated = /* @__PURE__ */ new Set();
+  static async load(bytes) {
+    const source2 = byteString(bytes);
+    const objects = /* @__PURE__ */ new Map();
+    const indirectLengths = [];
+    const bodies = [];
+    const pattern = /(?:^|[\r\n])\s*(\d+)\s+(\d+)\s+obj\b/g;
+    for (const match of source2.matchAll(pattern)) {
+      const object = Number(match[1]);
+      const generation = Number(match[2]);
+      const valueOffset = (match.index ?? 0) + match[0].length;
+      try {
+        const parser = new Parser(source2, valueOffset);
+        const value = parser.parse();
+        const after = parser.offset;
+        const streamMatch = source2.slice(after, after + 32).match(/^\s*stream\r?\n/);
+        let stream;
+        if (streamMatch) {
+          const start = after + streamMatch[0].length;
+          const declaredLength = isDict(value) ? value.entries.get("Length") : void 0;
+          if (typeof declaredLength === "number") {
+            stream = bytes.slice(start, start + declaredLength);
+          } else {
+            if (isRef(declaredLength)) indirectLengths.push({ object, start, length: declaredLength });
+            let end = source2.indexOf("endstream", start);
+            if (end !== -1) {
+              if (bytes[end - 1] === 10) end--;
+              if (bytes[end - 1] === 13) end--;
+              stream = bytes.slice(start, end);
+            }
+          }
+        }
+        objects.set(object, { object, generation, value, stream });
+        bodies.push([valueOffset, streamMatch ? after + streamMatch[0].length + (stream?.length ?? 0) : after]);
+      } catch {
+      }
+    }
+    for (const pending of indirectLengths) {
+      const length = objects.get(pending.length.object)?.value;
+      const record = objects.get(pending.object);
+      if (typeof length === "number" && record) {
+        record.stream = bytes.slice(pending.start, pending.start + length);
+      }
+    }
+    const trailers = trailerDictionaries(source2, bodies);
+    if (trailers.some(({ dict }) => dict.entries.has("Encrypt")) || [...objects.values()].some(({ value }) => isXrefStream(value) && value.entries.has("Encrypt"))) {
+      throw new PdfEncryptedError();
+    }
+    const startxref = lastStartxref(source2);
+    const trailer = newestTrailer(source2, startxref, trailers, objects) ?? { kind: "dict", entries: /* @__PURE__ */ new Map() };
+    const model = new _PdfModel(bytes, objects, trailer, startxref);
+    await model.expandObjectStreams();
+    return model;
+  }
+  /**
+   * The document catalog: the object the newest trailer's `/Root` names. A file
+   * with no readable trailer falls back to the first object typed `Catalog`.
+   */
+  catalog() {
+    const root = this.trailer.entries.get("Root");
+    if (isRef(root)) {
+      const record = this.objects.get(root.object);
+      if (!record || !isDict(record.value)) return void 0;
+      const type = record.value.entries.get("Type");
+      return type === void 0 || isName(type) && type.value === "Catalog" ? record : void 0;
+    }
+    return [...this.objects.values()].find((record) => {
+      if (!isDict(record.value)) return false;
+      const type = record.value.entries.get("Type");
+      return isName(type) && type.value === "Catalog";
+    });
+  }
+  resolve(value) {
+    return isRef(value) ? this.objects.get(value.object)?.value : value;
+  }
+  dict(value) {
+    const resolved = this.resolve(value);
+    return isDict(resolved) ? resolved : void 0;
+  }
+  record(value) {
+    return isRef(value) ? this.objects.get(value.object) : void 0;
+  }
+  markUpdated(value) {
+    if (!value) return;
+    this.updated.add(value.object);
+  }
+  addObject(value, stream) {
+    const object = nextObjectNumber(this.trailer, this.objects);
+    this.objects.set(object, { object, generation: 0, value, stream });
+    this.updated.add(object);
+    return { kind: "ref", object, generation: 0 };
+  }
+  /**
+   * The file with every updated object appended as an incremental update. The
+   * update trailer repeats the newest trailer's document entries (`/Info`,
+   * `/ID`) and points `/Root` at the catalog.
+   */
+  save() {
+    if (this.updated.size === 0) return this.bytes.slice();
+    const catalog = this.catalog();
+    if (!catalog) throw new Error("PDF catalog not found");
+    const records = [...this.updated].map((object) => this.objects.get(object)).filter((record) => record !== void 0);
+    const trailer = new Map(this.trailer.entries);
+    for (const key of SECTION_KEYS) trailer.delete(key);
+    trailer.set("Size", nextObjectNumber(this.trailer, this.objects));
+    trailer.set("Root", { kind: "ref", object: catalog.object, generation: catalog.generation });
+    if (this.startxref !== void 0) trailer.set("Prev", this.startxref);
+    return appendPdfUpdate(this.bytes, records, trailer);
+  }
+  async expandObjectStreams() {
+    for (const record of [...this.objects.values()]) {
+      if (!isDict(record.value) || !record.stream) continue;
+      const type = record.value.entries.get("Type");
+      if (!isName(type) || type.value !== "ObjStm") continue;
+      const count = record.value.entries.get("N");
+      const first = record.value.entries.get("First");
+      if (typeof count !== "number" || typeof first !== "number") continue;
+      const filter = record.value.entries.get("Filter");
+      const inflated = isName(filter) && filter.value === "FlateDecode" ? await inflate(record.stream) : record.stream;
+      const content = byteString(inflated);
+      const header = content.slice(0, first).trim().split(/\s+/).map(Number);
+      for (let index = 0; index < count; index++) {
+        const object = header[index * 2];
+        const offset = header[index * 2 + 1];
+        if (!Number.isInteger(object) || !Number.isInteger(offset)) continue;
+        try {
+          const parser = new Parser(content, first + offset);
+          if (!this.objects.has(object)) {
+            this.objects.set(object, { object, generation: 0, value: parser.parse() });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+};
+function lastStartxref(source2) {
+  const tail = source2.slice(Math.max(0, source2.length - 2048));
+  const value = [...tail.matchAll(/startxref\s+(\d+)/g)].at(-1)?.[1];
+  return value === void 0 ? void 0 : Number(value);
+}
+function nextObjectNumber(trailer, objects) {
+  const size = trailer.entries.get("Size");
+  return Math.max(typeof size === "number" ? size : 0, Math.max(0, ...objects.keys()) + 1);
+}
+
+// src/pdf/acroform.ts
+var MULTILINE = 1 << 12;
+var COMBO = 1 << 17;
+var MULTI_SELECT = 1 << 21;
+var COMB = 1 << 24;
+function nameValue(value) {
+  if (typeof value === "string") return value;
+  return isName(value) ? value.value : void 0;
+}
+function textValue(value) {
+  if (typeof value === "string") return decodeTextString(value);
+  return isName(value) ? value.value : void 0;
+}
+function classifyField(value, flags) {
+  if (value === "Tx") return "text";
+  if (value === "Ch") return "dropdown";
+  if (value === "Sig") return "signature";
+  if (value !== "Btn") return "unknown";
+  if ((flags & 1 << 16) !== 0) return "button";
+  if ((flags & 1 << 15) !== 0) return "radio";
+  return "checkbox";
+}
+function widget(model, value) {
+  const dict = model.dict(value);
+  if (!dict) return void 0;
+  const subtype = dict.entries.get("Subtype");
+  if (!isName(subtype) || subtype.value !== "Widget") return void 0;
+  return { ref: isRef(value) ? value : void 0, dict };
+}
+function isChildField(model, kid) {
+  const dict = model.dict(kid);
+  return widget(model, kid) === void 0 || dict?.entries.has("T") === true || dict?.entries.has("FT") === true || dict?.entries.has("Kids") === true;
+}
+function acroFields(model) {
+  const catalog = model.catalog();
+  if (!catalog || !isDict(catalog.value)) throw new Error("PDF catalog not found");
+  const acroValue = catalog.value.entries.get("AcroForm");
+  const acroForm = model.dict(acroValue);
+  if (!acroForm) return void 0;
+  const roots = model.resolve(acroForm.entries.get("Fields"));
+  const fields = [];
+  const formAppearance = model.resolve(acroForm.entries.get("DA"));
+  const formAlignment = model.resolve(acroForm.entries.get("Q"));
+  const visit = (value, inherited = {}) => {
+    const dict = model.dict(value);
+    if (!dict) return;
+    const ownName = textValue(dict.entries.get("T"));
+    const name2 = ownName ? inherited.name ? `${inherited.name}.${ownName}` : ownName : inherited.name;
+    const typeName = nameValue(dict.entries.get("FT")) ?? inherited.fieldType;
+    const flags = typeof dict.entries.get("Ff") === "number" ? dict.entries.get("Ff") : inherited.flags ?? 0;
+    const ownAppearance = model.resolve(dict.entries.get("DA"));
+    const ownAlignment = model.resolve(dict.entries.get("Q"));
+    const ownMaxLength = model.resolve(dict.entries.get("MaxLen"));
+    const settings = {
+      name: name2,
+      fieldType: typeName,
+      flags,
+      defaultAppearance: typeof ownAppearance === "string" ? ownAppearance : inherited.defaultAppearance,
+      alignment: typeof ownAlignment === "number" ? ownAlignment : inherited.alignment,
+      maxLength: typeof ownMaxLength === "number" ? ownMaxLength : inherited.maxLength
+    };
+    const kids = model.resolve(dict.entries.get("Kids"));
+    const widgets = Array.isArray(kids) ? kids.filter((child) => !isChildField(model, child)).map((child) => widget(model, child)).filter((item) => item !== void 0) : [];
+    const childFields = Array.isArray(kids) ? kids.filter((child) => isChildField(model, child)) : [];
+    if (childFields.length > 0) {
+      childFields.forEach((child) => visit(child, settings));
+      return;
+    }
+    if (!name2) return;
+    const self = widget(model, value);
+    fields.push({
+      ref: isRef(value) ? value : void 0,
+      dict,
+      name: name2,
+      type: classifyField(typeName, flags),
+      flags,
+      widgets: self ? [self] : widgets,
+      defaultAppearance: settings.defaultAppearance ?? (typeof formAppearance === "string" ? formAppearance : void 0),
+      alignment: settings.alignment ?? (typeof formAlignment === "number" ? formAlignment : 0),
+      maxLength: settings.maxLength
+    });
+  };
+  if (Array.isArray(roots)) roots.forEach((field) => visit(field));
+  return {
+    fields,
+    acroForm,
+    acroRef: isRef(acroValue) ? acroValue : void 0,
+    catalogRef: { kind: "ref", object: catalog.object, generation: catalog.generation }
+  };
+}
+function onState(model, widget2) {
+  const appearance = model.dict(widget2.dict.entries.get("AP"));
+  const normal = model.dict(appearance?.entries.get("N"));
+  return [...normal?.entries.keys() ?? []].find((name2) => name2 !== "Off") ?? "Yes";
+}
+function updateWidgetState(model, widget2, state) {
+  widget2.dict.entries.set("AS", { kind: "name", value: state });
+  if (widget2.ref) model.markUpdated(widget2.ref);
+}
+function textFieldDrawing(field) {
+  const multiline2 = (field.flags & MULTILINE) !== 0;
+  const comb = (field.flags & COMB) !== 0 && !multiline2 && field.maxLength !== void 0 && field.maxLength > 0 ? field.maxLength : void 0;
+  return comb === void 0 ? { multiline: multiline2 } : { multiline: multiline2, comb };
+}
+function widgetLayout(model, field, widget2, drawing) {
+  const rawRect = model.resolve(widget2.dict.entries.get("Rect"));
+  if (!Array.isArray(rawRect) || rawRect.length !== 4 || !rawRect.every((item) => typeof item === "number")) return void 0;
+  const [x1, y1, x2, y2] = rawRect;
+  const widgetAppearance = model.resolve(widget2.dict.entries.get("DA"));
+  const widgetAlignment = model.resolve(widget2.dict.entries.get("Q"));
+  return {
+    field: field.name,
+    width: Math.max(1, Math.abs(x2 - x1)),
+    height: Math.max(1, Math.abs(y2 - y1)),
+    appearance: parseDefaultAppearance(typeof widgetAppearance === "string" ? widgetAppearance : field.defaultAppearance),
+    alignment: typeof widgetAlignment === "number" ? widgetAlignment : field.alignment,
+    comb: drawing.comb,
+    multiline: drawing.multiline
+  };
+}
+function textAppearance(model, fonts, field, widget2, value) {
+  const layout = widgetLayout(model, field, widget2, value);
+  if (!layout) return;
+  const { width, height, appearance } = layout;
+  const font = fonts.select(field.name, value.text, appearance.fontName);
+  const text = layoutFieldText(layout, value.text, font);
+  const stream = new TextEncoder().encode(
+    `/Tx BMC
+q
+0 0 ${width} ${height} re W n
+BT
+${appearance.color}
+${text}
+ET
+Q
+EMC`
+  );
+  const appearanceRef2 = model.addObject({
+    kind: "dict",
+    entries: /* @__PURE__ */ new Map([
+      ["Type", { kind: "name", value: "XObject" }],
+      ["Subtype", { kind: "name", value: "Form" }],
+      ["FormType", 1],
+      ["BBox", [0, 0, width, height]],
+      ["Resources", {
+        kind: "dict",
+        entries: /* @__PURE__ */ new Map([
+          ["Font", {
+            kind: "dict",
+            entries: /* @__PURE__ */ new Map([[font.resourceName, font.reference()]])
+          }]
+        ])
+      }]
+    ])
+  }, stream);
+  widget2.dict.entries.set("AP", {
+    kind: "dict",
+    entries: /* @__PURE__ */ new Map([["N", appearanceRef2]])
+  });
+  if (widget2.ref) model.markUpdated(widget2.ref);
+}
+function choiceOptions(model, field) {
+  const options = model.resolve(field.dict.entries.get("Opt"));
+  if (!Array.isArray(options)) return [];
+  return options.flatMap((option) => {
+    const resolved = model.resolve(option);
+    if (typeof resolved === "string") {
+      const text = decodeTextString(resolved);
+      return [{ value: text, display: text }];
+    }
+    if (Array.isArray(resolved)) {
+      const [exported, display] = resolved.map((item) => model.resolve(item));
+      if (typeof exported === "string") {
+        const value = decodeTextString(exported);
+        return [{ value, display: typeof display === "string" ? decodeTextString(display) : value }];
+      }
+    }
+    return [];
+  });
+}
+function setChoiceValue(model, fonts, field, value) {
+  const multiSelect = (field.flags & MULTI_SELECT) !== 0;
+  const selected = multiSelect && Array.isArray(value) ? value.map(String) : [String(value)];
+  const options = choiceOptions(model, field);
+  const stored = selected.map(encodeTextString);
+  field.dict.entries.set("V", multiSelect && stored.length !== 1 ? stored : stored[0] ?? "");
+  const indices = selected.map((item) => options.findIndex((option) => option.value === item));
+  if (indices.length > 0 && indices.every((index) => index >= 0)) {
+    field.dict.entries.set("I", [...new Set(indices)].sort((left, right) => left - right));
+  } else field.dict.entries.delete("I");
+  const shown = selected.map((item) => options.find((option) => option.value === item)?.display ?? item);
+  const listBox = (field.flags & COMBO) === 0;
+  field.widgets.forEach((widget2) => textAppearance(model, fonts, field, widget2, {
+    text: listBox ? shown.join("\n") : shown.join(", "),
+    multiline: listBox
+  }));
+}
+function setTextValue(model, fonts, field, value) {
+  const text = String(value);
+  field.dict.entries.set("V", encodeTextString(text));
+  field.widgets.forEach((widget2) => textAppearance(model, fonts, field, widget2, { text, ...textFieldDrawing(field) }));
+}
+function setAcroFieldValue(model, fonts, field, value) {
+  if (field.type === "text") setTextValue(model, fonts, field, value);
+  else if (field.type === "dropdown") setChoiceValue(model, fonts, field, value);
+  else if (field.type === "checkbox") {
+    const checked = Boolean(value);
+    const state = checked ? onState(model, field.widgets[0] ?? { dict: field.dict }) : "Off";
+    field.dict.entries.set("V", { kind: "name", value: state });
+    field.widgets.forEach((item) => updateWidgetState(model, item, checked ? onState(model, item) : "Off"));
+  } else if (field.type === "radio") {
+    const selected = String(value);
+    field.dict.entries.set("V", { kind: "name", value: selected });
+    field.widgets.forEach((item) => updateWidgetState(model, item, onState(model, item) === selected ? selected : "Off"));
+  } else return;
+  if (field.ref) model.markUpdated(field.ref);
+}
+
+// src/pdf/page-tree.ts
+var INHERITED_PAGE_KEYS = ["Resources", "MediaBox", "CropBox", "Rotate"];
+function pageRecords(model, catalog) {
+  const pages = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (value, inherited = /* @__PURE__ */ new Map()) => {
+    const dict = model.dict(value);
+    if (!dict || visited.has(dict)) return;
+    visited.add(dict);
+    const pageInherited = new Map(inherited);
+    for (const key of INHERITED_PAGE_KEYS) {
+      const own = dict.entries.get(key);
+      if (own !== void 0) pageInherited.set(key, own);
+    }
+    const type = dict.entries.get("Type");
+    if (isName(type) && type.value === "Page") {
+      const ref = isRef(value) ? value : model.addObject(dict);
+      const record = model.record(ref);
+      if (record) pages.push({ record, ref, inherited: pageInherited });
+      return;
+    }
+    const kids = model.resolve(dict.entries.get("Kids"));
+    if (Array.isArray(kids)) kids.forEach((kid) => visit(kid, pageInherited));
+  };
+  visit(catalog.entries.get("Pages"));
+  return pages;
+}
+function documentPages(model) {
+  const catalog = model.catalog();
+  if (!catalog || !isDict(catalog.value)) return [];
+  return pageRecords(model, catalog.value);
+}
+function selfContainedPage(page) {
+  if (!isDict(page.record.value)) throw new Error("PDF page object does not hold a dictionary");
+  const entries = new Map(page.record.value.entries);
+  for (const key of INHERITED_PAGE_KEYS) {
+    if (!entries.has(key)) {
+      const inherited = page.inherited.get(key);
+      if (inherited !== void 0) entries.set(key, inherited);
+    }
+  }
+  entries.delete("Parent");
+  return { kind: "dict", entries };
+}
+function cloneDict(dict) {
+  return { kind: "dict", entries: new Map(dict?.entries) };
+}
+function addPageResource(model, page, category, name2, ref) {
+  if (!isDict(page.record.value)) return name2;
+  const resources = cloneDict(
+    model.dict(page.record.value.entries.get("Resources") ?? page.inherited.get("Resources"))
+  );
+  const entries = cloneDict(model.dict(resources.entries.get(category)));
+  const holds = (candidate, value = entries.entries.get(candidate)) => value !== void 0 && !(isRef(value) && value.object === ref.object && value.generation === ref.generation);
+  let free = name2;
+  for (let suffix = 1; holds(free); suffix++) free = `${name2}_${suffix}`;
+  entries.entries.set(free, ref);
+  resources.entries.set(category, entries);
+  page.record.value.entries.set("Resources", resources);
+  model.markUpdated(page.record);
+  return free;
+}
+function appendPageContent(model, page, stream) {
+  if (!isDict(page.record.value)) return;
+  const current = page.record.value.entries.get("Contents");
+  const resolved = model.resolve(current);
+  if (Array.isArray(resolved)) page.record.value.entries.set("Contents", [...resolved, stream]);
+  else if (current === void 0) page.record.value.entries.set("Contents", stream);
+  else page.record.value.entries.set("Contents", [current, stream]);
+  model.markUpdated(page.record);
+}
+
+// src/pdf/inspect.ts
+async function inspectPdf(template) {
+  const model = await PdfModel.load(template);
+  const pages = documentPages(model).map(({ inherited }, index) => {
+    const box = model.resolve(inherited.get("MediaBox"));
+    if (!Array.isArray(box) || box.length !== 4 || !box.every((item) => typeof item === "number")) {
+      throw new Error(`PDF page ${index + 1} has no readable MediaBox`);
+    }
+    const [left, bottom, right, top] = box;
+    return { page: index + 1, width: right - left, height: top - bottom };
+  });
+  return { pageCount: pages.length, pages };
+}
+async function inspectAcroFormFields(template, options = {}) {
+  const model = await PdfModel.load(template);
+  const form = acroFields(model);
+  if (!form) return [];
+  const pages = new Map(documentPages(model).map(({ ref }, index) => [ref.object, index + 1]));
+  const result = [];
+  for (const field of form.fields) {
+    const { type, flags } = field;
+    if (type === "button" && !options.includeButton) continue;
+    if (type === "signature" && !options.includeSignature) continue;
+    const rawValue = model.resolve(field.dict.entries.get("V"));
+    let fieldValue;
+    if (type === "checkbox") {
+      const state = textValue(rawValue);
+      fieldValue = state !== void 0 && state !== "Off";
+    } else if (type === "dropdown") {
+      const selected = Array.isArray(rawValue) ? rawValue : rawValue === void 0 ? [] : [rawValue];
+      fieldValue = selected.map(textValue).filter((item) => item !== void 0);
+    } else if (Array.isArray(rawValue)) fieldValue = rawValue.map(textValue).filter((item) => item !== void 0);
+    else fieldValue = textValue(rawValue);
+    const widget2 = field.widgets[0]?.dict;
+    const rectangle = model.resolve(widget2?.entries.get("Rect"));
+    const rect = Array.isArray(rectangle) && rectangle.length === 4 && rectangle.every((item) => typeof item === "number") ? rectangle : void 0;
+    const pageRef = widget2?.entries.get("P");
+    const page = isRef(pageRef) ? pages.get(pageRef.object) : void 0;
+    result.push({
+      name: field.name,
+      type,
+      value: fieldValue,
+      required: type === "text" || type === "checkbox" || type === "dropdown" || type === "radio" ? (flags & 2) !== 0 : void 0,
+      page,
+      rect,
+      maxLen: type === "text" ? field.maxLength ?? null : void 0
+    });
+  }
+  return result;
+}
+
+// src/pdf/flatten.ts
+var encoder = new TextEncoder();
+function appearanceRef(model, widget2) {
+  const appearance = model.dict(widget2.dict.entries.get("AP"));
+  const normal = appearance?.entries.get("N");
+  if (isRef(normal) && model.record(normal)?.stream) return normal;
+  const states = model.dict(normal);
+  if (!states) return void 0;
+  const state = widget2.dict.entries.get("AS");
+  const selected = isName(state) ? state.value : "Off";
+  const candidate = states.entries.get(selected) ?? states.entries.get("Off");
+  return isRef(candidate) && model.record(candidate)?.stream ? candidate : void 0;
+}
+var HIDDEN = 2;
+var NO_VIEW = 32;
+function hidden(model, widget2) {
+  const flags = model.resolve(widget2.dict.entries.get("F"));
+  return typeof flags === "number" && (flags & (HIDDEN | NO_VIEW)) !== 0;
+}
+function widgetPage(model, pages, widget2) {
+  const page = widget2.dict.entries.get("P");
+  if (isRef(page)) return pages.find(({ record }) => record.object === page.object);
+  if (!widget2.ref) return void 0;
+  return pages.find(({ record }) => {
+    if (!isDict(record.value)) return false;
+    const annotations = model.resolve(record.value.entries.get("Annots"));
+    return Array.isArray(annotations) && annotations.some((annotation) => isRef(annotation) && annotation.object === widget2.ref.object);
+  });
+}
+function removeWidgetAnnotation(model, page, widget2) {
+  if (!widget2.ref || !isDict(page.record.value)) return;
+  const annotationsValue = page.record.value.entries.get("Annots");
+  const annotations = model.resolve(annotationsValue);
+  if (!Array.isArray(annotations)) return;
+  const filtered = annotations.filter(
+    (annotation) => !isRef(annotation) || annotation.object !== widget2.ref.object
+  );
+  if (filtered.length === annotations.length) return;
+  if (isRef(annotationsValue)) {
+    const record = model.record(annotationsValue);
+    if (record) {
+      record.value = filtered;
+      model.markUpdated(record);
+    }
+  } else {
+    page.record.value.entries.set("Annots", filtered);
+    model.markUpdated(page.record);
+  }
+}
+function placement(model, widget2, appearance) {
+  const rectangle = model.resolve(widget2.dict.entries.get("Rect"));
+  const appearanceDict = model.dict(appearance);
+  const box = model.resolve(appearanceDict?.entries.get("BBox"));
+  if (!Array.isArray(rectangle) || rectangle.length !== 4 || !rectangle.every((value) => typeof value === "number") || !Array.isArray(box) || box.length !== 4 || !box.every((value) => typeof value === "number")) return void 0;
+  const [left, bottom, right, top] = rectangle;
+  const [boxLeft, boxBottom, boxRight, boxTop] = box;
+  const boxWidth = boxRight - boxLeft;
+  const boxHeight = boxTop - boxBottom;
+  if (boxWidth === 0 || boxHeight === 0) return void 0;
+  const scaleX = (right - left) / boxWidth;
+  const scaleY = (top - bottom) / boxHeight;
+  const translateX = left - boxLeft * scaleX;
+  const translateY = bottom - boxBottom * scaleY;
+  return `${scaleX} 0 0 ${scaleY} ${translateX} ${translateY} cm`;
+}
+async function flattenPdf(template) {
+  const model = await PdfModel.load(template);
+  const form = acroFields(model);
+  if (!form) return new Uint8Array(template);
+  const pages = documentPages(model);
+  let appearanceIndex = 0;
+  for (const field of form.fields) {
+    for (const widget2 of field.widgets) {
+      const page = widgetPage(model, pages, widget2);
+      if (!page) continue;
+      const appearance = hidden(model, widget2) ? void 0 : appearanceRef(model, widget2);
+      if (appearance) {
+        const transform = placement(model, widget2, appearance);
+        if (transform) {
+          const name2 = addPageResource(model, page, "XObject", `PdrA${appearanceIndex++}`, appearance);
+          appendPageContent(
+            model,
+            page,
+            model.addObject(
+              { kind: "dict", entries: /* @__PURE__ */ new Map() },
+              encoder.encode(`q
+${transform}
+/${name2} Do
+Q`)
+            )
+          );
+        }
+      }
+      removeWidgetAnnotation(model, page, widget2);
+    }
+  }
+  const catalog = form.catalogRef ? model.record(form.catalogRef) : void 0;
+  if (catalog && isDict(catalog.value)) {
+    catalog.value.entries.delete("AcroForm");
+    model.markUpdated(catalog);
+  }
+  return model.save();
+}
+
+// src/pdf/merge.ts
+var PdfMergeError = class extends Error {
+  /** Zero-based position of the offending source in the input. */
+  source;
+  constructor(source2, detail) {
+    super(`Cannot merge PDF ${source2 + 1}: ${detail}`);
+    this.name = "PdfMergeError";
+    this.source = source2;
+  }
+};
+async function mergePdfs(sources) {
+  if (sources.length === 0) throw new Error("At least one PDF is required to merge");
+  if (sources.length === 1) {
+    await PdfModel.load(new Uint8Array(sources[0]));
+    return new Uint8Array(sources[0]);
+  }
+  const CATALOG = 1;
+  const PAGE_TREE = 2;
+  const pageTree = { kind: "ref", object: PAGE_TREE, generation: 0 };
+  let next = 3;
+  const objects = [];
+  const pageRefs = [];
+  for (const [index, source2] of sources.entries()) {
+    try {
+      const model = await PdfModel.load(new Uint8Array(source2));
+      const catalog = model.catalog();
+      if (!catalog || !isDict(catalog.value)) throw new PdfMergeError(index, "it has no catalog");
+      const pages = pageRecords(model, catalog.value);
+      if (pages.length === 0) throw new PdfMergeError(index, "it has no pages");
+      const dictionaries = pages.map((page) => selfContainedPage(page));
+      const reachable = new Set(pages.map((page) => page.ref.object));
+      for (const dictionary of dictionaries) collectRefs(model, dictionary, reachable);
+      const mapping = /* @__PURE__ */ new Map();
+      for (const object of [...reachable].sort((a, b) => a - b)) {
+        const record = model.objects.get(object);
+        if (record && isDict(record.value)) {
+          const type = record.value.entries.get("Type");
+          if (isName(type) && (type.value === "ObjStm" || type.value === "XRef")) continue;
+        }
+        mapping.set(object, next++);
+      }
+      for (const [position, page] of pages.entries()) {
+        const number = mapping.get(page.ref.object);
+        const value = renumber(dictionaries[position], mapping);
+        value.entries.set("Parent", pageTree);
+        objects.push({ object: number, generation: 0, value, stream: page.record.stream });
+        pageRefs.push({ kind: "ref", object: number, generation: 0 });
+      }
+      const pageObjects = new Set(pages.map((page) => page.ref.object));
+      for (const [object, number] of mapping) {
+        if (pageObjects.has(object)) continue;
+        const record = model.objects.get(object);
+        if (!record) continue;
+        objects.push({ object: number, generation: 0, value: renumber(record.value, mapping), stream: record.stream });
+      }
+    } catch (error) {
+      if (error instanceof PdfMergeError || error instanceof PdfEncryptedError) throw error;
+      throw new PdfMergeError(
+        index,
+        `reading it failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  objects.push({
+    object: PAGE_TREE,
+    generation: 0,
+    value: {
+      kind: "dict",
+      entries: /* @__PURE__ */ new Map([
+        ["Type", { kind: "name", value: "Pages" }],
+        ["Kids", pageRefs],
+        ["Count", pageRefs.length]
+      ])
+    }
+  });
+  objects.push({
+    object: CATALOG,
+    generation: 0,
+    value: {
+      kind: "dict",
+      entries: /* @__PURE__ */ new Map([
+        ["Type", { kind: "name", value: "Catalog" }],
+        ["Pages", pageTree]
+      ])
+    }
+  });
+  return writePdf(objects, /* @__PURE__ */ new Map([["Root", { kind: "ref", object: CATALOG, generation: 0 }]]));
+}
+
+// src/pdf/select-pages.ts
+async function selectPdfPages(template, requestedPages) {
+  if (requestedPages.length === 0) throw new Error("At least one PDF page must be selected");
+  if (requestedPages.some((page) => !Number.isSafeInteger(page) || page < 1)) {
+    throw new Error("PDF pages must be positive one-based integers");
+  }
+  if (new Set(requestedPages).size !== requestedPages.length) {
+    throw new Error("PDF pages must not contain duplicates");
+  }
+  const model = await PdfModel.load(template);
+  const catalog = model.catalog();
+  if (!catalog || !isDict(catalog.value)) throw new Error("PDF catalog not found");
+  const pages = pageRecords(model, catalog.value);
+  const selectedNumbers = [...requestedPages].sort((left, right) => left - right);
+  const invalid = selectedNumbers.filter((page) => page > pages.length);
+  if (invalid.length > 0) {
+    throw new Error(`PDF page ${invalid[0]} does not exist; document has ${pages.length} pages`);
+  }
+  if (selectedNumbers.length === pages.length && selectedNumbers.every((page, index) => page === index + 1)) {
+    return new Uint8Array(template);
+  }
+  const selected = new Set(selectedNumbers.map((page) => page - 1));
+  const kept = pages.filter((_, index) => selected.has(index));
+  const dropped = pages.filter((_, index) => !selected.has(index));
+  const excluded = droppedObjects(model, kept, dropped, catalog.value.entries.get("AcroForm"));
+  const CATALOG = 1;
+  const PAGE_TREE = 2;
+  const pageTree = { kind: "ref", object: PAGE_TREE, generation: 0 };
+  const catalogEntries = new Map(catalog.value.entries);
+  catalogEntries.delete("Pages");
+  const pageDictionaries = kept.map((page) => selfContainedPage(page));
+  const info = model.trailer.entries.get("Info");
+  excluded.add(catalog.object);
+  const oldTree = catalog.value.entries.get("Pages");
+  const reachable = new Set(kept.map((page) => page.ref.object));
+  for (const dictionary of pageDictionaries) collectRefs(model, dictionary, reachable, excluded);
+  collectRefs(model, { kind: "dict", entries: catalogEntries }, reachable, excluded);
+  collectRefs(model, info, reachable, excluded);
+  const mapping = /* @__PURE__ */ new Map([[catalog.object, CATALOG]]);
+  if (isRef(oldTree)) mapping.set(oldTree.object, PAGE_TREE);
+  let next = PAGE_TREE + 1;
+  for (const object of [...reachable].sort((a, b) => a - b)) mapping.set(object, next++);
+  const objects = [];
+  for (const [position, page] of kept.entries()) {
+    const value = renumber(pageDictionaries[position], mapping);
+    if (isDict(value)) value.entries.set("Parent", pageTree);
+    objects.push({ object: mapping.get(page.ref.object), generation: 0, value, stream: page.record.stream });
+  }
+  const keptPages = new Set(kept.map((page) => page.ref.object));
+  for (const [object, number] of mapping) {
+    if (keptPages.has(object) || number <= PAGE_TREE) continue;
+    const record = model.objects.get(object);
+    if (record) objects.push({ object: number, generation: 0, value: renumber(record.value, mapping), stream: record.stream });
+  }
+  const newCatalog = renumber({ kind: "dict", entries: catalogEntries }, mapping);
+  if (isDict(newCatalog)) newCatalog.entries.set("Pages", pageTree);
+  objects.push({ object: CATALOG, generation: 0, value: newCatalog });
+  objects.push({
+    object: PAGE_TREE,
+    generation: 0,
+    value: {
+      kind: "dict",
+      entries: /* @__PURE__ */ new Map([
+        ["Type", { kind: "name", value: "Pages" }],
+        ["Kids", kept.map((page) => ({ kind: "ref", object: mapping.get(page.ref.object), generation: 0 }))],
+        ["Count", kept.length]
+      ])
+    }
+  });
+  const trailer = /* @__PURE__ */ new Map([["Root", { kind: "ref", object: CATALOG, generation: 0 }]]);
+  if (info !== void 0) trailer.set("Info", renumber(info, mapping));
+  const id = model.resolve(model.trailer.entries.get("ID"));
+  if (Array.isArray(id)) trailer.set("ID", id);
+  return writePdf(objects, trailer);
+}
+function droppedObjects(model, kept, dropped, acroForm) {
+  const excluded = new Set(dropped.map((page) => page.ref.object));
+  for (const record of model.objects.values()) {
+    if (!isDict(record.value)) continue;
+    const type = record.value.entries.get("Type");
+    if (isName(type) && ["Pages", "ObjStm", "XRef"].includes(type.value)) excluded.add(record.object);
+  }
+  const annotations = (page) => {
+    const value = isDict(page.record.value) ? model.resolve(page.record.value.entries.get("Annots")) : void 0;
+    return Array.isArray(value) ? value : [];
+  };
+  const keptAnnotations = new Set(kept.flatMap(annotations).filter(isRef).map((ref) => ref.object));
+  for (const annotation of dropped.flatMap(annotations)) {
+    if (isRef(annotation) && !keptAnnotations.has(annotation.object)) excluded.add(annotation.object);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const prune = (value) => {
+    if (!isRef(value)) return false;
+    if (excluded.has(value.object)) return true;
+    if (visited.has(value.object)) return false;
+    visited.add(value.object);
+    const kids = model.resolve(model.dict(value)?.entries.get("Kids"));
+    if (!Array.isArray(kids) || kids.length === 0) return false;
+    const gone = kids.map(prune).every(Boolean);
+    if (gone) excluded.add(value.object);
+    return gone;
+  };
+  const fields = model.resolve(model.dict(acroForm)?.entries.get("Fields"));
+  if (Array.isArray(fields)) fields.forEach(prune);
+  return excluded;
+}
+
+// src/pdf/render.ts
+import { defaultFormatter } from "@asterdoc/format";
+
+// src/pdf/drawing-fonts.ts
+import { zlibSync } from "fflate";
+
+// src/pdf/pages.ts
+async function decodeStream(model, dict, raw) {
+  const filter = model.resolve(dict.entries.get("Filter"));
+  const filters = [];
+  if (isName(filter)) filters.push(filter.value);
+  else if (Array.isArray(filter)) {
+    for (const entry of filter) {
+      const resolved = model.resolve(entry);
+      if (isName(resolved)) filters.push(resolved.value);
+    }
+  }
+  let bytes = raw;
+  for (const name2 of filters) {
+    if (name2 === "FlateDecode") {
+      const parms = model.dict(dict.entries.get("DecodeParms"));
+      const predictor = parms ? model.resolve(parms.entries.get("Predictor")) : void 0;
+      if (typeof predictor === "number" && predictor > 1) {
+        throw new Error("FlateDecode predictors are not supported in content streams");
+      }
+      bytes = await inflate(bytes);
+    } else {
+      throw new Error(`Unsupported stream filter: ${name2}`);
+    }
+  }
+  return bytes;
+}
+function asNumberArray(model, value) {
+  const resolved = model.resolve(value);
+  if (!Array.isArray(resolved)) return void 0;
+  const numbers = resolved.map((entry) => model.resolve(entry)).filter((entry) => typeof entry === "number");
+  return numbers.length === resolved.length ? numbers : void 0;
+}
+async function loadPages(model) {
+  const catalog = model.catalog();
+  if (!catalog || !isDict(catalog.value)) throw new Error("PDF catalog not found");
+  if (!model.dict(catalog.value.entries.get("Pages"))) throw new Error("PDF page tree not found");
+  const pages = [];
+  for (const { record, inherited } of pageRecords(model, catalog.value)) {
+    if (!isDict(record.value)) continue;
+    const mediaBox = asNumberArray(model, inherited.get("MediaBox"));
+    const box = mediaBox && mediaBox.length === 4 ? mediaBox : [0, 0, 612, 792];
+    pages.push({
+      dict: record.value,
+      resources: model.dict(inherited.get("Resources")),
+      mediaBox: [box[0], box[1], box[2], box[3]],
+      content: await pageContent(model, record.value)
+    });
+  }
+  return pages;
+}
+async function pageContent(model, page) {
+  const contents = page.entries.get("Contents");
+  const parts = [];
+  const append = async (value) => {
+    if (isRef(value)) {
+      const record = model.objects.get(value.object);
+      if (record?.stream && isDict(record.value)) {
+        parts.push(await decodeStream(model, record.value, record.stream));
+      }
+      return;
+    }
+    const resolved = model.resolve(value);
+    if (Array.isArray(resolved)) {
+      for (const entry of resolved) await append(entry);
+    }
+  };
+  await append(contents);
+  if (parts.length === 1) return parts[0];
+  const total = parts.reduce((sum, part) => sum + part.length + 1, 0);
+  const joined = new Uint8Array(total);
+  let cursor = 0;
+  for (const part of parts) {
+    joined.set(part, cursor);
+    cursor += part.length;
+    joined[cursor++] = 10;
+  }
+  return joined;
+}
+
+// src/pdf/win-ansi.ts
+var EXTENSIONS = "\u20AC\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\u017D\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\u017E\u0178";
+function winAnsiCodes(value) {
+  return [...value].map((char) => {
+    const code = char.codePointAt(0);
+    if (char === "\n" || char === "\r") return 32;
+    if (code >= 32 && code <= 126) return code;
+    const extension = EXTENSIONS.indexOf(char);
+    const byte = code >= 160 && code <= 255 ? code : extension >= 0 && code > 255 ? extension + 128 : void 0;
+    if (byte === void 0) throw new Error(`Native PDF font cannot render U+${code.toString(16).toUpperCase()}; use a renderer with the required font and script support`);
+    return byte;
+  });
+}
+function winAnsiText(value) {
+  return winAnsiCodes(value).map((code) => {
+    if (code >= 32 && code <= 126) {
+      const char = String.fromCharCode(code);
+      return /[\\()]/.test(char) ? `\\${char}` : char;
+    }
+    return `\\${code.toString(8).padStart(3, "0")}`;
+  }).join("");
+}
+
+// src/pdf/standard-font.ts
+var HELVETICA_WIDTHS = [
+  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,
+  0,
+  556,
+  0,
+  222,
+  556,
+  333,
+  1e3,
+  556,
+  556,
+  333,
+  1e3,
+  667,
+  333,
+  1e3,
+  0,
+  611,
+  0,
+  0,
+  222,
+  222,
+  333,
+  333,
+  350,
+  556,
+  1e3,
+  333,
+  1e3,
+  500,
+  333,
+  944,
+  0,
+  500,
+  500,
+  278,
+  333,
+  556,
+  556,
+  556,
+  556,
+  260,
+  556,
+  333,
+  737,
+  370,
+  556,
+  584,
+  333,
+  737,
+  333,
+  400,
+  584,
+  333,
+  333,
+  333,
+  556,
+  537,
+  278,
+  333,
+  333,
+  365,
+  556,
+  834,
+  834,
+  834,
+  611,
+  667,
+  667,
+  667,
+  667,
+  667,
+  667,
+  1e3,
+  722,
+  667,
+  667,
+  667,
+  667,
+  278,
+  278,
+  278,
+  278,
+  722,
+  722,
+  778,
+  778,
+  778,
+  778,
+  778,
+  584,
+  778,
+  722,
+  722,
+  722,
+  722,
+  667,
+  667,
+  611,
+  556,
+  556,
+  556,
+  556,
+  556,
+  556,
+  889,
+  500,
+  556,
+  556,
+  556,
+  556,
+  278,
+  278,
+  278,
+  278,
+  556,
+  556,
+  556,
+  556,
+  556,
+  556,
+  556,
+  584,
+  611,
+  556,
+  556,
+  556,
+  556,
+  500,
+  556,
+  500
+];
+var helvetica = {
+  ascent: 718,
+  descent: -207,
+  width(text) {
+    return winAnsiCodes(text).reduce((total, code) => total + (HELVETICA_WIDTHS[code - 32] ?? 0), 0);
+  }
+};
+
+// src/pdf/truetype.ts
+var FontProgramError = class extends Error {
+  problem;
+  constructor(problem, detail) {
+    super(detail);
+    this.name = "FontProgramError";
+    this.problem = problem;
+  }
+};
+function tag(bytes, offset) {
+  return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+}
+function parseTrueType(bytes) {
+  if (bytes.length < 12) throw new FontProgramError("unreadable", "the data is too short to be a font");
+  const signature = tag(bytes, 0);
+  if (signature === "OTTO") {
+    throw new FontProgramError("unsupported-format", "it is an OpenType font with CFF outlines; use a font with TrueType outlines (.ttf)");
+  }
+  if (signature === "ttcf") throw new FontProgramError("unsupported-format", "it is a font collection; use a single .ttf font");
+  if (signature === "wOFF" || signature === "wOF2") throw new FontProgramError("unsupported-format", "it is a WOFF web font; use the .ttf font it was made from");
+  const version = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0);
+  if (version !== 65536 && signature !== "true") throw new FontProgramError("unreadable", "it is not a TrueType or OpenType font");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const u16 = (offset) => view.getUint16(offset);
+  const i16 = (offset) => view.getInt16(offset);
+  const u32 = (offset) => view.getUint32(offset);
+  try {
+    const tables = /* @__PURE__ */ new Map();
+    const count = u16(4);
+    for (let index = 0; index < count; index++) {
+      const record = 12 + index * 16;
+      const table = { offset: u32(record + 8), length: u32(record + 12) };
+      if (table.offset + table.length > bytes.length) throw new FontProgramError("unreadable", `its ${tag(bytes, record)} table is truncated`);
+      tables.set(tag(bytes, record), table);
+    }
+    const required = (name2) => {
+      const table = tables.get(name2);
+      if (!table) {
+        throw new FontProgramError(name2 === "glyf" || name2 === "loca" ? "unsupported-format" : "unreadable", `it has no ${name2} table`);
+      }
+      return table;
+    };
+    const head = required("head").offset;
+    const unitsPerEm = u16(head + 18);
+    const bbox = [i16(head + 36), i16(head + 38), i16(head + 40), i16(head + 42)];
+    const longLoca = i16(head + 50) === 1;
+    const hhea = required("hhea").offset;
+    const numberOfHMetrics = u16(hhea + 34);
+    const numGlyphs = u16(required("maxp").offset + 4);
+    const hmtx = required("hmtx").offset;
+    const loca = required("loca").offset;
+    required("glyf");
+    let ascent = i16(hhea + 4);
+    let descent = i16(hhea + 6);
+    let capHeight = ascent;
+    const os2 = tables.get("OS/2");
+    if (os2) {
+      const fsType = u16(os2.offset + 8);
+      if ((fsType & 15) === 2) throw new FontProgramError("not-embeddable", "its license forbids embedding (restricted license)");
+      if ((fsType & 512) !== 0) throw new FontProgramError("not-embeddable", "its license allows embedding bitmaps only");
+      const os2Version = u16(os2.offset);
+      if (os2Version >= 2 && os2.length >= 90) capHeight = i16(os2.offset + 88);
+      if (ascent === 0 && descent === 0) {
+        ascent = i16(os2.offset + 68);
+        descent = i16(os2.offset + 70);
+      }
+    }
+    const post = tables.get("post");
+    const italicAngle = post ? view.getInt32(post.offset + 4) / 65536 : 0;
+    const fixedPitch = post ? u32(post.offset + 12) !== 0 : false;
+    const glyphOffset = (glyph) => longLoca ? u32(loca + glyph * 4) : u16(loca + glyph * 2) * 2;
+    const hasOutline = (glyph) => glyph > 0 && glyph < numGlyphs && glyphOffset(glyph + 1) > glyphOffset(glyph);
+    const advance = (glyph) => {
+      const metric = Math.min(glyph, numberOfHMetrics - 1);
+      return u16(hmtx + metric * 4);
+    };
+    const glyphFor = characterMap(tables.get("cmap"), u16, u32);
+    const postScriptName = nameOf(tables.get("name"), bytes, u16) ?? "EmbeddedFont";
+    return {
+      postScriptName: postScriptName.replace(/[^!-~]|[()<>[\]{}/%#]/g, ""),
+      unitsPerEm,
+      ascent,
+      descent,
+      capHeight,
+      bbox,
+      italicAngle,
+      fixedPitch,
+      numGlyphs,
+      glyphFor: (codePoint) => {
+        const glyph = glyphFor(codePoint);
+        return glyph < numGlyphs ? glyph : 0;
+      },
+      advance,
+      hasOutline
+    };
+  } catch (error) {
+    if (error instanceof FontProgramError) throw error;
+    throw new FontProgramError("unreadable", "its tables could not be read");
+  }
+}
+function characterMap(table, u16, u32) {
+  if (!table) throw new FontProgramError("unreadable", "it has no cmap table");
+  const subtables = [];
+  const count = u16(table.offset + 2);
+  for (let index = 0; index < count; index++) {
+    const record = table.offset + 4 + index * 8;
+    const offset = table.offset + u32(record + 4);
+    subtables.push({ platform: u16(record), encoding: u16(record + 2), offset, format: u16(offset) });
+  }
+  const unicode = (entry) => entry.platform === 0 || entry.platform === 3 && (entry.encoding === 1 || entry.encoding === 10);
+  const full = subtables.find((entry) => unicode(entry) && entry.format === 12);
+  if (full) {
+    const groups = u32(full.offset + 12);
+    return (codePoint) => {
+      let low = 0;
+      let high = groups - 1;
+      while (low <= high) {
+        const middle = low + high >> 1;
+        const group = full.offset + 16 + middle * 12;
+        const start = u32(group);
+        const end = u32(group + 4);
+        if (codePoint < start) high = middle - 1;
+        else if (codePoint > end) low = middle + 1;
+        else return u32(group + 8) + codePoint - start;
+      }
+      return 0;
+    };
+  }
+  const basic = subtables.find((entry) => unicode(entry) && entry.format === 4);
+  if (!basic) throw new FontProgramError("unsupported-format", "it has no Unicode character map");
+  const segments = u16(basic.offset + 6) / 2;
+  const ends = basic.offset + 14;
+  const starts = ends + segments * 2 + 2;
+  const deltas = starts + segments * 2;
+  const ranges = deltas + segments * 2;
+  return (codePoint) => {
+    if (codePoint > 65535) return 0;
+    for (let segment = 0; segment < segments; segment++) {
+      if (codePoint > u16(ends + segment * 2)) continue;
+      const start = u16(starts + segment * 2);
+      if (codePoint < start) return 0;
+      const delta = u16(deltas + segment * 2);
+      const rangeOffset = u16(ranges + segment * 2);
+      if (rangeOffset === 0) return codePoint + delta & 65535;
+      const glyph = u16(ranges + segment * 2 + rangeOffset + (codePoint - start) * 2);
+      return glyph === 0 ? 0 : glyph + delta & 65535;
+    }
+    return 0;
+  };
+}
+function nameOf(table, bytes, u16) {
+  if (!table) return void 0;
+  const count = u16(table.offset + 2);
+  const storage = table.offset + u16(table.offset + 4);
+  for (let index = 0; index < count; index++) {
+    const record = table.offset + 6 + index * 12;
+    if (u16(record + 6) !== 6) continue;
+    const platform = u16(record);
+    const length = u16(record + 8);
+    const start = storage + u16(record + 10);
+    const raw = bytes.subarray(start, start + length);
+    if (platform === 3 || platform === 0) {
+      let text = "";
+      for (let offset = 0; offset + 1 < raw.length; offset += 2) text += String.fromCharCode(raw[offset] << 8 | raw[offset + 1]);
+      return text;
+    }
+    return String.fromCharCode(...raw);
+  }
+  return void 0;
+}
+
+// src/pdf/drawing-fonts.ts
+var PdfFontError = class extends Error {
+  source;
+  problem;
+  constructor(source2, problem, detail) {
+    super(`Cannot use font "${source2}": ${detail}`);
+    this.name = "PdfFontError";
+    this.source = source2;
+    this.problem = problem;
+  }
+};
+var SHAPED_SCRIPTS = [
+  "Arabic",
+  "Hebrew",
+  "Syriac",
+  "Thaana",
+  "Nko",
+  "Adlam",
+  "Mandaic",
+  "Samaritan",
+  "Devanagari",
+  "Bengali",
+  "Gurmukhi",
+  "Gujarati",
+  "Oriya",
+  "Tamil",
+  "Telugu",
+  "Kannada",
+  "Malayalam",
+  "Sinhala",
+  "Thai",
+  "Lao",
+  "Tibetan",
+  "Myanmar",
+  "Khmer",
+  "Mongolian"
+].map((script) => ({ script, pattern: new RegExp(`\\p{Script=${script}}`, "u") }));
+var LINE_BREAK = /[\r\n]/u;
+var WHITESPACE = /\s/u;
+function shapedScript(text) {
+  return SHAPED_SCRIPTS.find(({ pattern }) => pattern.test(text))?.script;
+}
+function programCovers(program, text) {
+  return [...text].every((character) => {
+    if (LINE_BREAK.test(character)) return true;
+    const glyph = program.glyphFor(character.codePointAt(0));
+    return glyph !== 0 && (WHITESPACE.test(character) || program.hasOutline(glyph));
+  });
+}
+var hex4 = (value) => value.toString(16).padStart(4, "0").toUpperCase();
+var StandardHelvetica = class {
+  constructor(model) {
+    this.model = model;
+  }
+  model;
+  resourceName = "PdrFontHelvetica";
+  ascent = helvetica.ascent;
+  descent = helvetica.descent;
+  ref;
+  covers(text) {
+    try {
+      winAnsiCodes(text);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  width(text) {
+    return helvetica.width(text);
+  }
+  encode(text) {
+    return `(${winAnsiText(text)})`;
+  }
+  reference() {
+    this.ref ??= this.model.addObject({
+      kind: "dict",
+      entries: /* @__PURE__ */ new Map([
+        ["Type", { kind: "name", value: "Font" }],
+        ["Subtype", { kind: "name", value: "Type1" }],
+        ["BaseFont", { kind: "name", value: "Helvetica" }],
+        ["Encoding", { kind: "name", value: "WinAnsiEncoding" }]
+      ])
+    });
+    return this.ref;
+  }
+  finish() {
+  }
+};
+var EmbeddedTrueType = class {
+  constructor(model, program, resourceName, file) {
+    this.model = model;
+    this.program = program;
+    this.resourceName = resourceName;
+    this.file = file;
+    this.scale = 1e3 / program.unitsPerEm;
+    this.ascent = program.ascent * this.scale;
+    this.descent = program.descent * this.scale;
+  }
+  model;
+  program;
+  resourceName;
+  file;
+  ascent;
+  descent;
+  scale;
+  used = /* @__PURE__ */ new Map();
+  font;
+  descendant;
+  type0;
+  glyph(character) {
+    return this.program.glyphFor(character.codePointAt(0));
+  }
+  covers(text) {
+    return programCovers(this.program, text);
+  }
+  width(text) {
+    let total = 0;
+    for (const character of text) {
+      if (!LINE_BREAK.test(character)) total += this.program.advance(this.glyph(character)) * this.scale;
+    }
+    return total;
+  }
+  encode(text) {
+    let hex = "";
+    for (const character of text) {
+      if (LINE_BREAK.test(character)) continue;
+      const glyph = this.glyph(character);
+      if (!this.used.has(glyph)) this.used.set(glyph, character);
+      hex += hex4(glyph);
+    }
+    return `<${hex}>`;
+  }
+  reference() {
+    if (this.font) return this.font;
+    const { program, model } = this;
+    const fontFile = this.file instanceof Uint8Array ? model.addObject({
+      kind: "dict",
+      entries: /* @__PURE__ */ new Map([
+        ["Filter", { kind: "name", value: "FlateDecode" }],
+        ["Length1", this.file.length]
+      ])
+    }, zlibSync(this.file)) : this.file;
+    const name2 = { kind: "name", value: program.postScriptName };
+    const descriptor = model.addObject({
+      kind: "dict",
+      entries: /* @__PURE__ */ new Map([
+        ["Type", { kind: "name", value: "FontDescriptor" }],
+        ["FontName", name2],
+        // Symbolic: the glyphs are addressed by index, not by a standard encoding.
+        ["Flags", 4 | (program.fixedPitch ? 1 : 0)],
+        ["FontBBox", program.bbox.map((value) => Math.round(value * this.scale))],
+        ["ItalicAngle", program.italicAngle],
+        ["Ascent", Math.round(this.ascent)],
+        ["Descent", Math.round(this.descent)],
+        ["CapHeight", Math.round(program.capHeight * this.scale)],
+        ["StemV", 80],
+        ["FontFile2", fontFile]
+      ])
+    });
+    this.descendant = {
+      kind: "dict",
+      entries: /* @__PURE__ */ new Map([
+        ["Type", { kind: "name", value: "Font" }],
+        ["Subtype", { kind: "name", value: "CIDFontType2" }],
+        ["BaseFont", name2],
+        ["CIDSystemInfo", {
+          kind: "dict",
+          entries: /* @__PURE__ */ new Map([["Registry", "Adobe"], ["Ordering", "Identity"], ["Supplement", 0]])
+        }],
+        ["FontDescriptor", descriptor],
+        ["CIDToGIDMap", { kind: "name", value: "Identity" }],
+        ["DW", Math.round(program.advance(0) * this.scale)]
+      ])
+    };
+    this.type0 = {
+      kind: "dict",
+      entries: /* @__PURE__ */ new Map([
+        ["Type", { kind: "name", value: "Font" }],
+        ["Subtype", { kind: "name", value: "Type0" }],
+        ["BaseFont", name2],
+        ["Encoding", { kind: "name", value: "Identity-H" }],
+        ["DescendantFonts", [model.addObject(this.descendant)]]
+      ])
+    };
+    this.font = model.addObject(this.type0);
+    return this.font;
+  }
+  finish() {
+    if (!this.descendant || !this.type0) return;
+    const glyphs = [...this.used.keys()].sort((left, right) => left - right);
+    this.descendant.entries.set("W", glyphs.flatMap((glyph) => [
+      glyph,
+      [Math.round(this.program.advance(glyph) * this.scale)]
+    ]));
+    const entries = glyphs.map((glyph) => {
+      const text = this.used.get(glyph);
+      let units = "";
+      for (let index = 0; index < text.length; index++) units += hex4(text.charCodeAt(index));
+      return `<${hex4(glyph)}> <${units}>`;
+    });
+    const blocks = [];
+    for (let start = 0; start < entries.length; start += 100) {
+      const block = entries.slice(start, start + 100);
+      blocks.push(`${block.length} beginbfchar
+${block.join("\n")}
+endbfchar`);
+    }
+    const cmap = [
+      "/CIDInit /ProcSet findresource begin",
+      "12 dict begin",
+      "begincmap",
+      "/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def",
+      "/CMapName /Adobe-Identity-UCS def",
+      "/CMapType 2 def",
+      "1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange",
+      ...blocks,
+      "endcmap",
+      "CMapName currentdict /CMap defineresource pop",
+      "end",
+      "end"
+    ].join("\n");
+    this.type0.entries.set("ToUnicode", this.model.addObject({ kind: "dict", entries: /* @__PURE__ */ new Map() }, new TextEncoder().encode(cmap)));
+  }
+};
+function parseSupplied(font) {
+  try {
+    return parseTrueType(font.bytes);
+  } catch (error) {
+    if (error instanceof FontProgramError) throw new PdfFontError(font.source, error.problem, error.message);
+    throw error;
+  }
+}
+async function formFontProgram(model, font) {
+  const subtype = model.resolve(font.entries.get("Subtype"));
+  let described = font;
+  if (isName(subtype) && subtype.value === "Type0") {
+    const descendants = model.resolve(font.entries.get("DescendantFonts"));
+    described = Array.isArray(descendants) ? model.dict(descendants[0]) : void 0;
+  }
+  const descriptor = model.dict(described?.entries.get("FontDescriptor"));
+  const file = descriptor?.entries.get("FontFile2");
+  const record = model.record(file);
+  if (!isRef(file) || !record?.stream || !model.dict(file)) return void 0;
+  try {
+    return { program: parseTrueType(await decodeStream(model, model.dict(file), record.stream)), file };
+  } catch {
+    return void 0;
+  }
+}
+var PdfFontSet = class _PdfFontSet {
+  constructor(model, supplied) {
+    this.model = model;
+    this.helvetica = new StandardHelvetica(model);
+    this.supplied = supplied;
+  }
+  model;
+  helvetica;
+  supplied;
+  formFonts = /* @__PURE__ */ new Map();
+  overlayFonts = /* @__PURE__ */ new Map();
+  drawn = /* @__PURE__ */ new Set();
+  /** Read the supplied fonts, failing now, naming its source, on one that cannot be used. */
+  static create(model, options = {}) {
+    return new _PdfFontSet(model, [
+      options.font && new EmbeddedTrueType(model, parseSupplied(options.font), "PdrFontOverride", options.font.bytes),
+      options.layerFont && new EmbeddedTrueType(model, parseSupplied(options.layerFont), "PdrFontLayer", options.layerFont.bytes)
+    ].filter((font) => font !== void 0));
+  }
+  /** Read the embedded TrueType fonts in the form's default resources (`/DR`). */
+  async readFormFonts(resources) {
+    const fonts = this.model.dict(resources?.entries.get("Font"));
+    for (const [name2, value] of fonts?.entries ?? []) {
+      const dict = this.model.dict(value);
+      const found = dict ? await formFontProgram(this.model, dict) : void 0;
+      if (found) {
+        this.formFonts.set(name2, new EmbeddedTrueType(this.model, found.program, `PdrFontForm${this.formFonts.size}`, found.file));
+      }
+    }
+  }
+  /** A font one overlay names, read on first use and embedded once however many overlays name it. */
+  overlayFont(font) {
+    let embedded = this.overlayFonts.get(font.bytes);
+    if (!embedded) {
+      embedded = new EmbeddedTrueType(this.model, parseSupplied(font), `PdrFontOverlay${this.overlayFonts.size}`, font.bytes);
+      this.overlayFonts.set(font.bytes, embedded);
+    }
+    return embedded;
+  }
+  /**
+   * The first font that can draw every character of `text`.
+   *
+   * @param subject - The field or overlay, named in errors.
+   * @param formFont - The form font resource the field's appearance names.
+   * @param overlayFont - The font a text overlay names; it is tried first.
+   * @throws {PdfFieldFillError} for a script that needs shaping, or a character no font can draw.
+   * @throws {PdfFontError} when `overlayFont` cannot be used.
+   */
+  select(subject, text, formFont, overlayFont) {
+    const script = shapedScript(text);
+    if (script) {
+      throw new PdfFieldFillError(
+        subject,
+        "unsupported-script",
+        { script },
+        `the value contains ${script} script, which needs glyph shaping that PDF form filling and overlays do not do. Render documents in this script from a React composition layer.`
+      );
+    }
+    const own = formFont === void 0 ? void 0 : this.formFonts.get(formFont);
+    const candidates = [
+      ...overlayFont ? [this.overlayFont(overlayFont)] : [],
+      ...this.supplied,
+      ...own ? [own] : [],
+      this.helvetica
+    ];
+    const chosen = candidates.find((font) => font.covers(text));
+    if (chosen) {
+      this.drawn.add(chosen);
+      return chosen;
+    }
+    const characters = [...text].filter((character2) => !LINE_BREAK.test(character2));
+    const uncovered = characters.find((item) => candidates.every((font) => !font.covers(item)));
+    const character = uncovered ?? characters.find((item) => !candidates[0].covers(item));
+    const code = `U+${hex4(character.codePointAt(0))}`;
+    throw new PdfFieldFillError(
+      subject,
+      "missing-glyph",
+      { character },
+      (uncovered ? `no available font can draw "${character}" (${code}).` : `no single available font can draw every character of the value; the first font lacks "${character}" (${code}).`) + " Declare a font that covers the value on the PDF layer, or supply one at render time."
+    );
+  }
+  /** Write widths and Unicode maps for every embedded font this render drew with. */
+  finish() {
+    for (const font of this.drawn) font.finish();
+  }
+};
+function pdfFontMetrics(font) {
+  const program = parseSupplied(font);
+  return {
+    canDraw: (text) => shapedScript(text) === void 0 && programCovers(program, text),
+    width: (text, size) => {
+      let units = 0;
+      for (const character of text) {
+        if (!LINE_BREAK.test(character)) units += program.advance(program.glyphFor(character.codePointAt(0)));
+      }
+      return units * size / program.unitsPerEm;
+    }
+  };
+}
+
+// src/pdf/overlay.ts
+import { unzlibSync, zlibSync as zlibSync2 } from "fflate";
+function textValue2(overlay, data) {
+  if ("text" in overlay) return overlay.text;
+  return getPath(data, renderDataPath(data, overlay.field));
+}
+function overlaySubject(overlay, index) {
+  return "field" in overlay && overlay.field ? overlay.field : `text overlay ${index + 1} (page ${overlay.page})`;
+}
+function fittedFontSize(text, overlay, font, subject) {
+  const declared = overlay.fontSize ?? 12;
+  let size = Math.min(declared, overlay.height ?? Number.POSITIVE_INFINITY);
+  const width = overlay.width;
+  if (width === void 0) return size;
+  const floor = Math.min(MIN_FONT_SIZE, size);
+  const unitWidth = font.width(text) / 1e3;
+  if (unitWidth * size <= width) return size;
+  size = width / unitWidth;
+  if (size < floor) {
+    throw new PdfFieldFillError(subject, "overflow", { limit: floor }, `the text does not fit its ${width} pt width at the minimum size of ${floor} pt`);
+  }
+  return size;
+}
+function readUint32(bytes, offset) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function concatBytes(chunks) {
+  const bytes = new Uint8Array(chunks.reduce((length, chunk) => length + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+function paeth(left, above, upperLeft) {
+  const estimate = left + above - upperLeft;
+  const leftDistance = Math.abs(estimate - left);
+  const aboveDistance = Math.abs(estimate - above);
+  const upperLeftDistance = Math.abs(estimate - upperLeft);
+  if (leftDistance <= aboveDistance && leftDistance <= upperLeftDistance) return left;
+  return aboveDistance <= upperLeftDistance ? above : upperLeft;
+}
+function decodePng(bytes) {
+  const signature = [137, 80, 78, 71, 13, 10, 26, 10];
+  if (!signature.every((byte, index) => bytes[index] === byte)) throw new Error("Invalid PNG image");
+  let width = 0;
+  let height = 0;
+  let bitDepth = 0;
+  let colorType = 0;
+  let interlace = 0;
+  const idat = [];
+  for (let offset = 8; offset + 12 <= bytes.length; ) {
+    const length = readUint32(bytes, offset);
+    const type = String.fromCharCode(...bytes.slice(offset + 4, offset + 8));
+    const data = bytes.slice(offset + 8, offset + 8 + length);
+    if (type === "IHDR") {
+      width = readUint32(data, 0);
+      height = readUint32(data, 4);
+      bitDepth = data[8];
+      colorType = data[9];
+      interlace = data[12];
+    } else if (type === "IDAT") idat.push(data);
+    offset += length + 12;
+    if (type === "IEND") break;
+  }
+  if (width < 1 || height < 1 || bitDepth !== 8 || interlace !== 0 || ![0, 2, 4, 6].includes(colorType)) {
+    throw new Error("PNG overlays require non-interlaced 8-bit grayscale, RGB, grayscale-alpha, or RGBA images");
+  }
+  const channels = { 0: 1, 2: 3, 4: 2, 6: 4 }[colorType];
+  const rowLength = width * channels;
+  const inflated = unzlibSync(concatBytes(idat));
+  if (inflated.length < (rowLength + 1) * height) throw new Error("PNG image data is truncated");
+  const decoded = new Uint8Array(rowLength * height);
+  let source2 = 0;
+  for (let row = 0; row < height; row++) {
+    const filter = inflated[source2++];
+    const rowOffset = row * rowLength;
+    for (let column = 0; column < rowLength; column++) {
+      const raw = inflated[source2++];
+      const left = column >= channels ? decoded[rowOffset + column - channels] : 0;
+      const above = row > 0 ? decoded[rowOffset + column - rowLength] : 0;
+      const upperLeft = row > 0 && column >= channels ? decoded[rowOffset + column - rowLength - channels] : 0;
+      const predictor = filter === 0 ? 0 : filter === 1 ? left : filter === 2 ? above : filter === 3 ? Math.floor((left + above) / 2) : filter === 4 ? paeth(left, above, upperLeft) : Number.NaN;
+      if (Number.isNaN(predictor)) throw new Error(`Unsupported PNG filter ${filter}`);
+      decoded[rowOffset + column] = raw + predictor & 255;
+    }
+  }
+  const hasAlpha = colorType === 4 || colorType === 6;
+  const colorChannels = colorType === 0 || colorType === 4 ? 1 : 3;
+  const pixels = new Uint8Array(width * height * colorChannels);
+  const alpha = hasAlpha ? new Uint8Array(width * height) : void 0;
+  for (let pixel = 0; pixel < width * height; pixel++) {
+    const input = pixel * channels;
+    const output = pixel * colorChannels;
+    pixels.set(decoded.slice(input, input + colorChannels), output);
+    if (alpha) alpha[pixel] = decoded[input + channels - 1];
+  }
+  return { width, height, colorSpace: colorChannels === 1 ? "DeviceGray" : "DeviceRGB", pixels, alpha };
+}
+function embedPng(model, bytes) {
+  const png = decodePng(bytes);
+  const alphaRef = png.alpha ? model.addObject({
+    kind: "dict",
+    entries: /* @__PURE__ */ new Map([
+      ["Type", { kind: "name", value: "XObject" }],
+      ["Subtype", { kind: "name", value: "Image" }],
+      ["Width", png.width],
+      ["Height", png.height],
+      ["ColorSpace", { kind: "name", value: "DeviceGray" }],
+      ["BitsPerComponent", 8],
+      ["Filter", { kind: "name", value: "FlateDecode" }]
+    ])
+  }, zlibSync2(png.alpha)) : void 0;
+  const entries = /* @__PURE__ */ new Map([
+    ["Type", { kind: "name", value: "XObject" }],
+    ["Subtype", { kind: "name", value: "Image" }],
+    ["Width", png.width],
+    ["Height", png.height],
+    ["ColorSpace", { kind: "name", value: png.colorSpace }],
+    ["BitsPerComponent", 8],
+    ["Filter", { kind: "name", value: "FlateDecode" }]
+  ]);
+  if (alphaRef) entries.set("SMask", alphaRef);
+  return { ref: model.addObject({ kind: "dict", entries }, zlibSync2(png.pixels)), width: png.width, height: png.height };
+}
+function embedJpeg(model, bytes) {
+  if (bytes[0] !== 255 || bytes[1] !== 216) throw new Error("Invalid JPEG image");
+  let offset = 2;
+  while (offset + 9 < bytes.length) {
+    if (bytes[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    const marker = bytes[offset + 1];
+    offset += 2;
+    if (marker === 216 || marker === 217 || marker === 1 || marker >= 208 && marker <= 215) continue;
+    const length = bytes[offset] << 8 | bytes[offset + 1];
+    if ([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207].includes(marker)) {
+      const height = bytes[offset + 3] << 8 | bytes[offset + 4];
+      const width = bytes[offset + 5] << 8 | bytes[offset + 6];
+      const components = bytes[offset + 7];
+      const colorSpace = components === 1 ? "DeviceGray" : components === 4 ? "DeviceCMYK" : "DeviceRGB";
+      const ref = model.addObject({
+        kind: "dict",
+        entries: /* @__PURE__ */ new Map([
+          ["Type", { kind: "name", value: "XObject" }],
+          ["Subtype", { kind: "name", value: "Image" }],
+          ["Width", width],
+          ["Height", height],
+          ["ColorSpace", { kind: "name", value: colorSpace }],
+          ["BitsPerComponent", 8],
+          ["Filter", { kind: "name", value: "DCTDecode" }]
+        ])
+      }, bytes);
+      return { ref, width, height };
+    }
+    if (length < 2) break;
+    offset += length;
+  }
+  throw new Error("JPEG dimensions could not be read");
+}
+var component = (value) => Math.max(0, Math.min(1, value));
+function applyPdfOverlays(model, overlays, data, fonts) {
+  if (overlays.length === 0) return;
+  const pages = documentPages(model);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const overlay of overlays) {
+    if (!Number.isInteger(overlay.page) || overlay.page < 1 || overlay.page > pages.length) {
+      throw new Error(`PDF overlay page ${overlay.page} is outside the document's ${pages.length} pages`);
+    }
+    grouped.set(overlay.page, [...grouped.get(overlay.page) ?? [], overlay]);
+  }
+  let imageIndex = 0;
+  for (const [pageNumber, items] of grouped) {
+    const page = pages[pageNumber - 1];
+    const commands = [];
+    const pageFonts = /* @__PURE__ */ new Map();
+    for (const overlay of items) {
+      if ("image" in overlay) {
+        const embedded = overlay.mediaType === "image/png" ? embedPng(model, overlay.image) : embedJpeg(model, overlay.image);
+        const name2 = addPageResource(model, page, "XObject", `PdrI${imageIndex++}`, embedded.ref);
+        const scale = overlay.fit === "fill" ? void 0 : Math.min(overlay.width / embedded.width, overlay.height / embedded.height);
+        const width = scale === void 0 ? overlay.width : embedded.width * scale;
+        const height = scale === void 0 ? overlay.height : embedded.height * scale;
+        commands.push(`q
+${width} 0 0 ${height} ${overlay.x} ${overlay.y} cm
+/${name2} Do
+Q`);
+        continue;
+      }
+      const text = String(textValue2(overlay, data) ?? "").replace(/\r\n|\r|\n/g, " ");
+      const subject = overlaySubject(overlay, overlays.indexOf(overlay));
+      const font = fonts.select(subject, text, void 0, overlay.font);
+      let fontName = pageFonts.get(font.resourceName);
+      if (fontName === void 0) {
+        fontName = addPageResource(model, page, "Font", font.resourceName, font.reference());
+        pageFonts.set(font.resourceName, fontName);
+      }
+      const size = fittedFontSize(text, overlay, font, subject);
+      const x = overlay.x + (overlay.width === void 0 ? 0 : 1);
+      const y = overlay.y + (overlay.height === void 0 ? 0 : Math.max(1, (overlay.height - size) / 2));
+      const [red, green, blue] = (overlay.color ?? [0, 0, 0]).map(component);
+      commands.push(`BT
+/${fontName} ${size} Tf
+${red} ${green} ${blue} rg
+${x} ${y} Td
+${font.encode(text)} Tj
+ET`);
+    }
+    const stream = model.addObject({ kind: "dict", entries: /* @__PURE__ */ new Map() }, new TextEncoder().encode(`q
+${commands.join("\n")}
+Q`));
+    appendPageContent(model, page, stream);
+  }
+}
+
+// src/pdf/render.ts
+function assign(field, value, model, fonts) {
+  if (!field || value === null || value === void 0) return;
+  setAcroFieldValue(model, fonts, field, field.type === "checkbox" || field.type === "radio" || field.type === "dropdown" ? unwrapFormattedValue(value) : value);
+}
+function sourcePaths(bindings) {
+  return bindings.flatMap(([, parts]) => parts.map((part) => pathSegments(part.path)));
+}
+function fieldDefinition(form, path) {
+  const [root, ...segments] = pathSegments(path);
+  let field = root ? form?.fields?.[root] : void 0;
+  for (const segment of segments) {
+    if (field?.type === "list" && /^\d+$/.test(segment)) field = field.item;
+    else if (field?.type === "fieldset") field = field.fields[segment];
+    else return void 0;
+  }
+  return field;
+}
+function displayPath(segments) {
+  return segments.reduce((path, segment) => /^\d+$/.test(segment) ? `${path}[${segment}]` : path ? `${path}.${segment}` : segment, "");
+}
+function assertListBindingCapacity(form, data, bindings) {
+  if (!form?.fields || bindings.length === 0) return;
+  const paths = sourcePaths(bindings);
+  const visit = (field, value, prefix) => {
+    if (field.type === "list") {
+      if (!Array.isArray(value)) return;
+      const indices = paths.filter((path) => prefix.every((segment, index) => path[index] === segment)).map((path) => path[prefix.length]).filter((segment) => segment !== void 0 && /^\d+$/.test(segment)).map(Number);
+      if (indices.length > 0) {
+        const capacity = Math.max(...indices) + 1;
+        if (value.length > capacity) {
+          throw new Error(`PDF bindings for "${displayPath(prefix)}" support ${capacity} list items, but received ${value.length}`);
+        }
+      }
+      value.forEach((item, index) => visit(field.item, item, [...prefix, String(index)]));
+      return;
+    }
+    if (field.type === "fieldset" && value !== null && typeof value === "object" && !Array.isArray(value)) {
+      for (const [key, nestedField] of Object.entries(field.fields)) {
+        visit(nestedField, value[key], [...prefix, key]);
+      }
+    }
+  };
+  for (const [key, field] of Object.entries(form.fields)) visit(field, data[key], [key]);
+}
+async function renderPdf({
+  template,
+  form,
+  data,
+  bindings,
+  formatter = defaultFormatter,
+  overlays = [],
+  font,
+  layerFont,
+  format: format3
+}) {
+  const preprocessed = form ? formatFieldData(data, form, formatter, { choices: "value", ...format3?.money && { money: format3.money } }) : data;
+  const parsed = parseBindings(bindings ?? {});
+  if (form) {
+    const sources = parsed.flatMap(([, parts]) => parts.map((part) => part.source));
+    sources.push(...overlays.flatMap((overlay) => "field" in overlay && overlay.field ? [overlay.field] : []));
+    validateFieldBindings(form, Object.fromEntries(sources.map((source2, index) => [String(index), source2])));
+  }
+  assertListBindingCapacity(form, data, parsed);
+  const model = await PdfModel.load(template);
+  const fonts = PdfFontSet.create(model, { font, layerFont });
+  const shouldFill = parsed.length > 0 || Boolean(form?.fields && Object.keys(form.fields).length > 0);
+  if (shouldFill) {
+    const acroFormData = acroFields(model);
+    const byName = new Map((acroFormData?.fields ?? []).map((field) => [field.name, field]));
+    const unmatched = parsed.map(([pdfName]) => pdfName).filter((pdfName) => !byName.has(pdfName));
+    if (unmatched.length > 0) {
+      throw new PdfBindingKeyError(unmatched, [...byName.keys()]);
+    }
+    if (acroFormData) {
+      const { acroForm, acroRef, catalogRef } = acroFormData;
+      await fonts.readFormFonts(model.dict(acroForm.entries.get("DR")));
+      acroForm.entries.delete("NeedAppearances");
+      model.markUpdated(acroRef ?? catalogRef);
+      if (bindings) {
+        for (const [pdfName, parts] of parsed) {
+          const field = byName.get(pdfName);
+          if (parts.length > 1) {
+            const combined = parts.map((part) => getPath(preprocessed, renderDataPath(preprocessed, part.source))).filter((value) => value !== null && value !== void 0 && String(value) !== "").join(", ");
+            if (combined) assign(field, combined, model, fonts);
+            continue;
+          }
+          const { path, qualifier } = parts[0];
+          if (qualifier !== void 0) {
+            const value = getPath(data, renderDataPath(data, parts[0].source));
+            if (typeof value === "boolean") assign(field, value, model, fonts);
+            else if (Array.isArray(value)) assign(field, value.includes(qualifier), model, fonts);
+            else if (fieldDefinition(form, path)?.type === "enum") assign(field, String(value) === qualifier, model, fonts);
+            else {
+              const index = splitPartIndex(qualifier);
+              if (index !== void 0 && value !== null && value !== void 0) {
+                const part = String(value).split("-")[index];
+                if (part) assign(field, part, model, fonts);
+              }
+            }
+            continue;
+          }
+          assign(field, getPath(preprocessed, renderDataPath(preprocessed, parts[0].source)), model, fonts);
+        }
+      } else if (form) {
+        for (const [name2, definition] of Object.entries(form.fields ?? {})) {
+          if (definition.type === "fieldset") continue;
+          assign(byName.get(name2), preprocessed.fields?.[name2] ?? preprocessed[name2], model, fonts);
+        }
+      }
+    }
+  }
+  applyPdfOverlays(model, overlays, preprocessed, fonts);
+  fonts.finish();
+  return model.save();
+}
+
+// src/pdf/signature.ts
+var BYTE_RANGE_PLACEHOLDER = 9999999999;
+var BYTE_RANGE_TEXT = `[${Array(4).fill(BYTE_RANGE_PLACEHOLDER).join(" ")}]`;
+var name = (value) => ({ kind: "name", value });
+function pdfDate(date) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return `D:${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`;
+}
+function parsePdfDate(value) {
+  const match = /^D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?(?:([Zz+-])(\d{2})?'?(\d{2})?'?)?/.exec(value);
+  if (!match) return void 0;
+  const [, year, month = "01", day = "01", hour = "00", minute = "00", second = "00", sign, offsetHours = "00", offsetMinutes = "00"] = match;
+  const utc = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second));
+  const offset = (Number(offsetHours) * 60 + Number(offsetMinutes)) * 6e4;
+  return new Date(sign === "+" ? utc - offset : sign === "-" ? utc + offset : utc);
+}
+function editableArray(model, holder, dict, key) {
+  const value = dict.entries.get(key);
+  const indirect = model.record(value);
+  if (indirect && Array.isArray(indirect.value)) {
+    model.markUpdated(indirect);
+    return indirect.value;
+  }
+  const array = Array.isArray(value) ? value : [];
+  dict.entries.set(key, array);
+  model.markUpdated(holder);
+  return array;
+}
+function editableAcroForm(model, catalog) {
+  const value = catalog.value.entries.get("AcroForm");
+  const indirect = model.record(value);
+  if (indirect && isDict(indirect.value)) return { holder: indirect, form: indirect.value };
+  const form = isDict(value) ? value : { kind: "dict", entries: /* @__PURE__ */ new Map() };
+  catalog.value.entries.set("AcroForm", form);
+  return { holder: catalog, form };
+}
+function fieldNames(model, fields) {
+  const names = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    const title = model.dict(field)?.entries.get("T");
+    if (typeof title === "string") names.add(decodeTextString(title));
+  }
+  return names;
+}
+function indexOf(haystack, needle, from) {
+  const bytes = encodeLatin1(needle);
+  outer: for (let index = from; index <= haystack.length - bytes.length; index++) {
+    for (let offset = 0; offset < bytes.length; offset++) {
+      if (haystack[index + offset] !== bytes[offset]) continue outer;
+    }
+    return index;
+  }
+  return -1;
+}
+async function preparePdfSignature(pdf, options) {
+  if (!Number.isInteger(options.contentsSize) || options.contentsSize < 1) {
+    throw new Error("contentsSize must be a positive whole number of bytes");
+  }
+  const model = await PdfModel.load(pdf);
+  const catalog = model.catalog();
+  if (!catalog || !isDict(catalog.value)) throw new Error("PDF catalog not found");
+  const [firstPage] = documentPages(model);
+  if (!firstPage || !isDict(firstPage.record.value)) throw new Error("PDF has no page to hold the signature widget");
+  const signatureEntries = /* @__PURE__ */ new Map([
+    ["Type", name("Sig")],
+    ["Filter", name("Adobe.PPKLite")],
+    ["SubFilter", name("adbe.pkcs7.detached")],
+    ["ByteRange", Array(4).fill(BYTE_RANGE_PLACEHOLDER)],
+    ["Contents", "\0".repeat(options.contentsSize)],
+    ["M", pdfDate(options.signingTime)]
+  ]);
+  const text = [
+    ["Name", options.name],
+    ["Reason", options.reason],
+    ["Location", options.location],
+    ["ContactInfo", options.contactInfo]
+  ];
+  for (const [key, value] of text) if (value) signatureEntries.set(key, encodeTextString(value));
+  const signatureRef = model.addObject({ kind: "dict", entries: signatureEntries });
+  const { holder, form } = editableAcroForm(model, catalog);
+  const fields = editableArray(model, holder, form, "Fields");
+  const taken = fieldNames(model, fields);
+  let ordinal = 1;
+  while (taken.has(`Signature${ordinal}`)) ordinal++;
+  const widgetRef = model.addObject({
+    kind: "dict",
+    entries: /* @__PURE__ */ new Map([
+      ["Type", name("Annot")],
+      ["Subtype", name("Widget")],
+      ["FT", name("Sig")],
+      ["T", `Signature${ordinal}`],
+      ["V", signatureRef],
+      // Print (4) and Locked (128).
+      ["F", 132],
+      ["Rect", [0, 0, 0, 0]],
+      ["P", firstPage.ref]
+    ])
+  });
+  fields.push(widgetRef);
+  form.entries.set("SigFlags", 3);
+  model.markUpdated(holder);
+  editableArray(model, firstPage.record, firstPage.record.value, "Annots").push(widgetRef);
+  const bytes = model.save();
+  const objectStart = indexOf(bytes, `
+${signatureRef.object} 0 obj
+`, pdf.length - 1);
+  if (objectStart === -1) throw new Error("Signature dictionary not found in the saved PDF");
+  const byteRangeKey = indexOf(bytes, `/ByteRange ${BYTE_RANGE_TEXT}`, objectStart);
+  const contentsKey = indexOf(bytes, "/Contents <", objectStart);
+  if (byteRangeKey === -1 || contentsKey === -1) throw new Error("Signature placeholders not found in the saved PDF");
+  const byteRangeAt = byteRangeKey + "/ByteRange ".length;
+  const contentsAt = contentsKey + "/Contents ".length;
+  const gapEnd = contentsAt + options.contentsSize * 2 + 2;
+  const byteRange = [0, contentsAt, gapEnd, bytes.length - gapEnd];
+  const written = `[${byteRange.join(" ")}`;
+  bytes.set(encodeLatin1(`${written}${" ".repeat(BYTE_RANGE_TEXT.length - written.length - 1)}]`), byteRangeAt);
+  return { bytes, byteRange };
+}
+function signedBytes(prepared) {
+  const [start, length, gapEnd, rest] = prepared.byteRange;
+  const output = new Uint8Array(length + rest);
+  output.set(prepared.bytes.subarray(start, start + length), 0);
+  output.set(prepared.bytes.subarray(gapEnd, gapEnd + rest), length);
+  return output;
+}
+function embedPdfSignature(prepared, container) {
+  const [, gapStart, gapEnd] = prepared.byteRange;
+  const capacity = (gapEnd - gapStart - 2) / 2;
+  if (container.length > capacity) {
+    throw new Error(`Signature container is ${container.length} bytes; the field reserves ${capacity}`);
+  }
+  let hex = "";
+  for (const byte of container) hex += byte.toString(16).padStart(2, "0");
+  const output = prepared.bytes.slice();
+  output.set(encodeLatin1(hex.padEnd(capacity * 2, "0")), gapStart + 1);
+  return output;
+}
+function isSignatureDictionary(value) {
+  if (!isDict(value)) return false;
+  const type = value.entries.get("Type");
+  const byteRange = value.entries.get("ByteRange");
+  return (type === void 0 || isName(type) && (type.value === "Sig" || type.value === "DocTimeStamp")) && Array.isArray(byteRange) && byteRange.length === 4 && byteRange.every((entry) => typeof entry === "number" && Number.isInteger(entry) && entry >= 0) && typeof value.entries.get("Contents") === "string";
+}
+function textEntry(dict, key) {
+  const value = dict.entries.get(key);
+  return typeof value === "string" ? decodeTextString(value) : void 0;
+}
+async function readPdfSignature(pdf) {
+  const model = await PdfModel.load(pdf);
+  let newest;
+  let newestEnd = -1;
+  for (const record of model.objects.values()) {
+    if (!isSignatureDictionary(record.value)) continue;
+    const [, , offset, length2] = record.value.entries.get("ByteRange");
+    if (offset + length2 > newestEnd) {
+      newest = record.value;
+      newestEnd = offset + length2;
+    }
+  }
+  if (!newest) return void 0;
+  const byteRange = newest.entries.get("ByteRange");
+  const contents = encodeLatin1(newest.entries.get("Contents"));
+  const [start, length, gapEnd, rest] = byteRange;
+  const inFile = start + length <= gapEnd && gapEnd + rest <= pdf.length;
+  const signed = new Uint8Array(inFile ? length + rest : 0);
+  if (inFile) {
+    signed.set(pdf.subarray(start, start + length), 0);
+    signed.set(pdf.subarray(gapEnd, gapEnd + rest), length);
+  }
+  const gap = byteString(pdf.subarray(start + length, gapEnd));
+  const gapHex = /^<([0-9A-Fa-f]*)>$/.exec(gap)?.[1];
+  const gapIsContents = gapHex !== void 0 && gapHex.length === contents.length * 2 && contents.every((byte, index) => Number.parseInt(gapHex.slice(index * 2, index * 2 + 2), 16) === byte);
+  const signingTime = newest.entries.get("M");
+  return {
+    contents,
+    byteRange,
+    signedBytes: signed,
+    coversWholeFile: inFile && start === 0 && gapEnd + rest === pdf.length && gapIsContents,
+    name: textEntry(newest, "Name"),
+    reason: textEntry(newest, "Reason"),
+    location: textEntry(newest, "Location"),
+    contactInfo: textEntry(newest, "ContactInfo"),
+    signingTime: typeof signingTime === "string" ? parsePdfDate(signingTime) : void 0
+  };
+}
+
+// src/pdf/renderer.ts
+import { defaultFormatter as defaultFormatter2 } from "@asterdoc/format";
+function pdfRenderer(options = {}) {
+  const formatter = options.formatter ?? defaultFormatter2;
+  const fromLayer = (template) => ({
+    font: options.font,
+    layerFont: template.font && { bytes: template.font.content, source: template.font.path },
+    ...template.format && { format: template.format }
+  });
+  return {
+    id: "pdf",
+    render(request) {
+      const { data, form } = requestRenderData(request);
+      return renderPdf({
+        template: request.template.content,
+        data,
+        form,
+        formatter: request.ctx?.formatter ?? formatter,
+        bindings: request.template.bindings,
+        ...fromLayer(request.template)
+      });
+    }
+  };
+}
+
+// src/pdf/encoding.ts
+var ALPHABET = [
+  "\u2800",
+  // Braille Pattern Blank
+  "\u2801",
+  // Braille Pattern Dots-1
+  "\u2802",
+  // Braille Pattern Dots-2
+  "\u2804"
+  // Braille Pattern Dots-3
+];
+var FieldType = {
+  SIGNATURE: 0,
+  INITIALS: 1
+};
+var MAX_SIGNER_INDEX = 4095;
+var MAX_FIELD_TYPE = 15;
+var ENCODING_LENGTH = 8;
+function encode(signerIndex, fieldType) {
+  if (!Number.isInteger(signerIndex) || signerIndex < 0 || signerIndex > MAX_SIGNER_INDEX) {
+    throw new Error(`Signer index must be an integer 0-${MAX_SIGNER_INDEX}, got ${signerIndex}`);
+  }
+  if (!Number.isInteger(fieldType) || fieldType < 0 || fieldType > MAX_FIELD_TYPE) {
+    throw new Error(`Field type must be an integer 0-${MAX_FIELD_TYPE}, got ${fieldType}`);
+  }
+  let result = "";
+  let remaining = signerIndex;
+  for (let index = 0; index < 6; index++) {
+    result = ALPHABET[remaining % 4] + result;
+    remaining = Math.floor(remaining / 4);
+  }
+  result += ALPHABET[Math.floor(fieldType / 4)];
+  result += ALPHABET[fieldType % 4];
+  return result;
+}
+function decodeAll(text) {
+  const results = [];
+  let found = [];
+  let start = -1;
+  for (let index = 0; index < text.length; index++) {
+    const digit = ALPHABET.indexOf(text[index]);
+    if (digit === -1) {
+      found = [];
+      start = -1;
+      continue;
+    }
+    if (found.length === 0) start = index;
+    found.push(digit);
+    if (found.length < ENCODING_LENGTH) continue;
+    let signerIndex = 0;
+    for (let place = 0; place < 6; place++) signerIndex = signerIndex * 4 + found[place];
+    results.push({ signerIndex, fieldType: found[6] * 4 + found[7], position: start });
+    found = [];
+    start = -1;
+  }
+  return results;
+}
+function stripEncoding(text) {
+  const pattern = new RegExp(`[${ALPHABET.join("")}]`, "g");
+  return text.replace(pattern, "");
+}
+function containsEncoding(text) {
+  return ALPHABET.some((character) => text.includes(character));
+}
+function fieldTypeToString(fieldType) {
+  if (fieldType === FieldType.SIGNATURE) return "signature";
+  if (fieldType === FieldType.INITIALS) return "initials";
+  return "unknown";
+}
+
+// src/pdf/fonts.ts
+function parseToUnicode(cmap) {
+  const map = /* @__PURE__ */ new Map();
+  const hexToString = (hex) => {
+    let text = "";
+    for (let index = 0; index + 3 < hex.length + 1; index += 4) {
+      text += String.fromCharCode(Number.parseInt(hex.slice(index, index + 4), 16));
+    }
+    return text;
+  };
+  for (const block of cmap.matchAll(/beginbfchar([\s\S]*?)endbfchar/g)) {
+    for (const entry of block[1].matchAll(/<([0-9a-fA-F]+)>\s*<([0-9a-fA-F]+)>/g)) {
+      map.set(Number.parseInt(entry[1], 16), hexToString(entry[2].padStart(Math.ceil(entry[2].length / 4) * 4, "0")));
+    }
+  }
+  for (const block of cmap.matchAll(/beginbfrange([\s\S]*?)endbfrange/g)) {
+    const body = block[1];
+    for (const entry of body.matchAll(/<([0-9a-fA-F]+)>\s*<([0-9a-fA-F]+)>\s*<([0-9a-fA-F]+)>/g)) {
+      const low = Number.parseInt(entry[1], 16);
+      const high = Number.parseInt(entry[2], 16);
+      const start = entry[3].padStart(Math.ceil(entry[3].length / 4) * 4, "0");
+      const base = hexToString(start);
+      const last = base.charCodeAt(base.length - 1);
+      for (let code = low; code <= high && code - low < 65536; code++) {
+        map.set(code, base.slice(0, -1) + String.fromCharCode(last + (code - low)));
+      }
+    }
+    for (const entry of body.matchAll(/<([0-9a-fA-F]+)>\s*<([0-9a-fA-F]+)>\s*\[([\s\S]*?)\]/g)) {
+      const low = Number.parseInt(entry[1], 16);
+      const targets = [...entry[3].matchAll(/<([0-9a-fA-F]+)>/g)];
+      for (let offset = 0; offset < targets.length; offset++) {
+        map.set(low + offset, hexToString(targets[offset][1].padStart(Math.ceil(targets[offset][1].length / 4) * 4, "0")));
+      }
+    }
+  }
+  return map;
+}
+function simpleWidths(model, font) {
+  const first = model.resolve(font.entries.get("FirstChar"));
+  const widths = model.resolve(font.entries.get("Widths"));
+  if (typeof first !== "number" || !Array.isArray(widths)) return () => 500;
+  const table = widths.map((entry) => model.resolve(entry)).map((entry) => typeof entry === "number" ? entry : 0);
+  return (code) => {
+    const width = table[code - first];
+    return typeof width === "number" && width > 0 ? width : 500;
+  };
+}
+function cidWidths(model, font) {
+  const descendants = model.resolve(font.entries.get("DescendantFonts"));
+  const descendant = Array.isArray(descendants) ? model.dict(descendants[0]) : void 0;
+  if (!descendant) return () => 1e3;
+  const dw = model.resolve(descendant.entries.get("DW"));
+  const defaultWidth = typeof dw === "number" ? dw : 1e3;
+  const w = model.resolve(descendant.entries.get("W"));
+  const table = /* @__PURE__ */ new Map();
+  if (Array.isArray(w)) {
+    let index = 0;
+    while (index < w.length) {
+      const start = model.resolve(w[index]);
+      const next = model.resolve(w[index + 1]);
+      if (typeof start !== "number") break;
+      if (Array.isArray(next)) {
+        const widths = next.map((entry) => model.resolve(entry));
+        for (let offset = 0; offset < widths.length; offset++) {
+          const width = widths[offset];
+          if (typeof width === "number") table.set(start + offset, width);
+        }
+        index += 2;
+      } else if (typeof next === "number") {
+        const width = model.resolve(w[index + 2]);
+        if (typeof width === "number") {
+          for (let code = start; code <= next && code - start < 65536; code++) table.set(code, width);
+        }
+        index += 3;
+      } else break;
+    }
+  }
+  return (code) => table.get(code) ?? defaultWidth;
+}
+async function buildFontDecoder(model, font) {
+  const subtype = model.resolve(font.entries.get("Subtype"));
+  const twoByte = isName(subtype) && subtype.value === "Type0";
+  let toUnicode;
+  const toUnicodeRecord = model.record(font.entries.get("ToUnicode"));
+  if (toUnicodeRecord?.stream && isDict(toUnicodeRecord.value)) {
+    const bytes = await decodeStream(model, toUnicodeRecord.value, toUnicodeRecord.stream);
+    toUnicode = parseToUnicode(byteString(bytes));
+  }
+  const widthOf = twoByte ? cidWidths(model, font) : simpleWidths(model, font);
+  return {
+    twoByte,
+    decode(bytes) {
+      const glyphs = [];
+      if (twoByte) {
+        for (let index = 0; index + 1 < bytes.length; index += 2) {
+          const code = bytes[index] << 8 | bytes[index + 1];
+          glyphs.push({ code, unicode: toUnicode?.get(code) ?? "", width: widthOf(code) });
+        }
+      } else {
+        for (const code of bytes) {
+          glyphs.push({ code, unicode: toUnicode?.get(code) ?? String.fromCharCode(code), width: widthOf(code) });
+        }
+      }
+      return glyphs;
+    }
+  };
+}
+
+// src/pdf/scanner.ts
+function mergeRuns(runs) {
+  const merged = [];
+  for (const run of runs) {
+    const previous = merged[merged.length - 1];
+    const boundary = !previous || containsEncoding(previous.text) || containsEncoding(run.text);
+    if (!boundary && Math.abs(run.y - previous.y) < 0.5 && Math.abs(run.x - (previous.x + previous.width)) < 1) {
+      previous.text += run.text;
+      previous.width = run.x + run.width - previous.x;
+      previous.height = Math.max(previous.height, run.height);
+      continue;
+    }
+    merged.push({ ...run });
+  }
+  return merged;
+}
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function multiply(m, n) {
+  return [
+    m[0] * n[0] + m[1] * n[2],
+    m[0] * n[1] + m[1] * n[3],
+    m[2] * n[0] + m[3] * n[2],
+    m[2] * n[1] + m[3] * n[3],
+    m[4] * n[0] + m[5] * n[2] + n[4],
+    m[4] * n[1] + m[5] * n[3] + n[5]
+  ];
+}
+function tokenize(content) {
+  const source2 = byteString(content);
+  const tokens = [];
+  let position = 0;
+  const stack = [tokens];
+  const isWhitespace = (char) => /[\s\0]/.test(char);
+  const isDelimiter = (char) => char === void 0 || isWhitespace(char) || "()<>[]{}/%".includes(char);
+  while (position < source2.length) {
+    const char = source2[position];
+    if (isWhitespace(char)) {
+      position++;
+      continue;
+    }
+    if (char === "%") {
+      while (position < source2.length && !"\r\n".includes(source2[position])) position++;
+      continue;
+    }
+    const sink = stack[stack.length - 1];
+    if (char === "[") {
+      const items = [];
+      sink.push({ kind: "array", items });
+      stack.push(items);
+      position++;
+      continue;
+    }
+    if (char === "]") {
+      if (stack.length > 1) stack.pop();
+      position++;
+      continue;
+    }
+    if (char === "(") {
+      position++;
+      const bytes = [];
+      let depth = 1;
+      while (position < source2.length && depth > 0) {
+        const current = source2[position++];
+        if (current === "\\") {
+          const escaped = source2[position++];
+          if (escaped === void 0) break;
+          const simple = { n: 10, r: 13, t: 9, b: 8, f: 12, "(": 40, ")": 41, "\\": 92 };
+          if (simple[escaped] !== void 0) bytes.push(simple[escaped]);
+          else if (escaped === "\n") continue;
+          else if (escaped === "\r") {
+            if (source2[position] === "\n") position++;
+          } else if (/[0-7]/.test(escaped)) {
+            let octal = escaped;
+            while (octal.length < 3 && /[0-7]/.test(source2[position] ?? "")) octal += source2[position++];
+            bytes.push(Number.parseInt(octal, 8) & 255);
+          } else bytes.push(escaped.charCodeAt(0));
+        } else if (current === "(") {
+          depth++;
+          bytes.push(40);
+        } else if (current === ")") {
+          depth--;
+          if (depth > 0) bytes.push(41);
+        } else bytes.push(current.charCodeAt(0) & 255);
+      }
+      sink.push({ kind: "string", bytes });
+      continue;
+    }
+    if (char === "<" && source2[position + 1] === "<") {
+      let depth = 0;
+      while (position < source2.length) {
+        if (source2.startsWith("<<", position)) {
+          depth++;
+          position += 2;
+        } else if (source2.startsWith(">>", position)) {
+          depth--;
+          position += 2;
+          if (depth === 0) break;
+        } else position++;
+      }
+      continue;
+    }
+    if (char === "<") {
+      position++;
+      const start2 = position;
+      while (position < source2.length && source2[position] !== ">") position++;
+      let hex = source2.slice(start2, position++).replace(/\s/g, "");
+      if (hex.length % 2 === 1) hex += "0";
+      const bytes = [];
+      for (let index = 0; index < hex.length; index += 2) bytes.push(Number.parseInt(hex.slice(index, index + 2), 16));
+      sink.push({ kind: "string", bytes });
+      continue;
+    }
+    if (char === "/") {
+      position++;
+      const start2 = position;
+      while (!isDelimiter(source2[position])) position++;
+      sink.push({
+        kind: "name",
+        value: source2.slice(start2, position).replace(/#([0-9a-f]{2})/gi, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+      });
+      continue;
+    }
+    if (/[-+.\d]/.test(char)) {
+      const start2 = position;
+      while (/[-+.\d]/.test(source2[position] ?? "")) position++;
+      const value = Number(source2.slice(start2, position));
+      sink.push({ kind: "number", value: Number.isFinite(value) ? value : 0 });
+      continue;
+    }
+    const start = position;
+    while (!isDelimiter(source2[position]) && !/[-+.\d]/.test(source2[position] ?? "")) position++;
+    const operator = source2.slice(start, position);
+    if (operator === "BI") {
+      const match = /\sEI(?=[\s\0]|$)/.exec(source2.slice(position));
+      position = match ? position + match.index + match[0].length : source2.length;
+      continue;
+    }
+    if (operator.length > 0) sink.push({ kind: "operator", value: operator });
+    else position++;
+  }
+  return tokens;
+}
+async function scanPage(model, page) {
+  const runs = [];
+  const fontCache = /* @__PURE__ */ new Map();
+  const fontFor = async (resources, name2) => {
+    const fonts = resources ? model.dict(resources.entries.get("Font")) : void 0;
+    const dict = fonts ? model.dict(fonts.entries.get(name2)) : void 0;
+    if (!dict) return void 0;
+    let cached = fontCache.get(dict);
+    if (!cached) {
+      cached = await buildFontDecoder(model, dict);
+      fontCache.set(dict, cached);
+    }
+    return cached;
+  };
+  const interpret = async (content, resources, base, depth) => {
+    if (depth > 8) return;
+    const tokens = tokenize(content);
+    const state = {
+      ctm: base,
+      font: void 0,
+      fontSize: 0,
+      charSpacing: 0,
+      wordSpacing: 0,
+      horizontalScale: 1,
+      leading: 0,
+      rise: 0
+    };
+    const saved = [];
+    let textMatrix = IDENTITY;
+    let lineMatrix = IDENTITY;
+    const operands = [];
+    const numbers = (count) => {
+      const slice = operands.slice(-count);
+      return slice.map((token) => token.kind === "number" ? token.value : 0);
+    };
+    const nextLine = (tx, ty) => {
+      lineMatrix = multiply([1, 0, 0, 1, tx, ty], lineMatrix);
+      textMatrix = lineMatrix;
+    };
+    const show2 = (bytes) => {
+      if (!state.font || bytes.length === 0) return;
+      const glyphs = state.font.decode(bytes);
+      const trm = multiply(
+        multiply([state.fontSize * state.horizontalScale, 0, 0, state.fontSize, 0, state.rise], textMatrix),
+        state.ctm
+      );
+      let advance = 0;
+      let text = "";
+      for (const glyph of glyphs) {
+        text += glyph.unicode;
+        const word = !state.font.twoByte && glyph.code === 32 ? state.wordSpacing : 0;
+        advance += (glyph.width / 1e3 * state.fontSize + state.charSpacing + word) * state.horizontalScale;
+      }
+      const scale = Math.hypot(multiply(textMatrix, state.ctm)[0], multiply(textMatrix, state.ctm)[1]);
+      runs.push({
+        text,
+        x: trm[4],
+        y: trm[5],
+        width: advance * scale,
+        height: Math.hypot(trm[2], trm[3])
+      });
+      textMatrix = multiply([1, 0, 0, 1, advance, 0], textMatrix);
+    };
+    const adjust = (amount) => {
+      const tx = -amount / 1e3 * state.fontSize * state.horizontalScale;
+      textMatrix = multiply([1, 0, 0, 1, tx, 0], textMatrix);
+    };
+    for (const token of tokens) {
+      if (token.kind !== "operator") {
+        operands.push(token);
+        continue;
+      }
+      const op = token.value;
+      switch (op) {
+        case "q":
+          saved.push({ ...state });
+          break;
+        case "Q": {
+          const restored = saved.pop();
+          if (restored) Object.assign(state, restored);
+          break;
+        }
+        case "cm": {
+          const [a, b, c, d, e, f] = numbers(6);
+          state.ctm = multiply([a, b, c, d, e, f], state.ctm);
+          break;
+        }
+        case "BT":
+          textMatrix = IDENTITY;
+          lineMatrix = IDENTITY;
+          break;
+        case "ET":
+          break;
+        case "Tf": {
+          const size = numbers(1)[0] ?? 0;
+          const name2 = operands.at(-2);
+          state.fontSize = size;
+          if (name2?.kind === "name") state.font = await fontFor(resources, name2.value);
+          break;
+        }
+        case "Td": {
+          const [tx, ty] = numbers(2);
+          nextLine(tx, ty);
+          break;
+        }
+        case "TD": {
+          const [tx, ty] = numbers(2);
+          state.leading = -ty;
+          nextLine(tx, ty);
+          break;
+        }
+        case "Tm": {
+          const [a, b, c, d, e, f] = numbers(6);
+          textMatrix = [a, b, c, d, e, f];
+          lineMatrix = textMatrix;
+          break;
+        }
+        case "T*":
+          nextLine(0, -state.leading);
+          break;
+        case "TL":
+          state.leading = numbers(1)[0] ?? 0;
+          break;
+        case "Tc":
+          state.charSpacing = numbers(1)[0] ?? 0;
+          break;
+        case "Tw":
+          state.wordSpacing = numbers(1)[0] ?? 0;
+          break;
+        case "Tz":
+          state.horizontalScale = (numbers(1)[0] ?? 100) / 100;
+          break;
+        case "Ts":
+          state.rise = numbers(1)[0] ?? 0;
+          break;
+        case "Tj": {
+          const operand = operands.at(-1);
+          if (operand?.kind === "string") show2(operand.bytes);
+          break;
+        }
+        case "'": {
+          nextLine(0, -state.leading);
+          const operand = operands.at(-1);
+          if (operand?.kind === "string") show2(operand.bytes);
+          break;
+        }
+        case '"': {
+          const spacing = numbers(3);
+          state.wordSpacing = spacing[0] ?? 0;
+          state.charSpacing = spacing[1] ?? 0;
+          nextLine(0, -state.leading);
+          const operand = operands.at(-1);
+          if (operand?.kind === "string") show2(operand.bytes);
+          break;
+        }
+        case "TJ": {
+          const operand = operands.at(-1);
+          if (operand?.kind === "array") {
+            for (const item of operand.items) {
+              if (item.kind === "string") show2(item.bytes);
+              else if (item.kind === "number") adjust(item.value);
+            }
+          }
+          break;
+        }
+        case "Do": {
+          const name2 = operands.at(-1);
+          if (name2?.kind !== "name") break;
+          const xobjects = resources ? model.dict(resources.entries.get("XObject")) : void 0;
+          const record = xobjects ? model.record(xobjects.entries.get(name2.value)) : void 0;
+          if (!record?.stream || !isDict(record.value)) break;
+          const subtype = model.resolve(record.value.entries.get("Subtype"));
+          if (!isName(subtype) || subtype.value !== "Form") break;
+          const matrixValues = model.resolve(record.value.entries.get("Matrix"));
+          const matrix = Array.isArray(matrixValues) && matrixValues.length === 6 && matrixValues.every((entry) => typeof entry === "number") ? matrixValues : IDENTITY;
+          const formResources = model.dict(record.value.entries.get("Resources")) ?? resources;
+          const bytes = await decodeStream(model, record.value, record.stream);
+          await interpret(bytes, formResources, multiply(matrix, state.ctm), depth + 1);
+          break;
+        }
+        default:
+          break;
+      }
+      operands.length = 0;
+    }
+  };
+  await interpret(page.content, page.resources, IDENTITY, 0);
+  return runs;
+}
+
+// src/pdf/extract.ts
+var DEFAULT_INITIALS_DIMENSIONS = { width: 80, height: 40 };
+var UnknownMarkerError = class extends Error {
+  constructor(markers) {
+    const names = markers.map((marker) => `page ${marker.page} signer ${marker.signerIndex} field type ${marker.fieldType}`).join(", ");
+    super(`PDF contains ${markers.length} marker${markers.length === 1 ? "" : "s"} with an unknown field type: ${names}`);
+    this.markers = markers;
+    this.name = "UnknownMarkerError";
+  }
+  markers;
+};
+function findEncodingPosition(runs, charPosition) {
+  let cursor = 0;
+  let foundIndex = -1;
+  for (let index = 0; index < runs.length; index++) {
+    const end = cursor + runs[index].text.length;
+    if (charPosition >= cursor && charPosition < end) {
+      foundIndex = index;
+      break;
+    }
+    cursor = end;
+  }
+  if (foundIndex === -1) return null;
+  const found = runs[foundIndex];
+  const fontHeight = found.height > 0 ? found.height : 12;
+  let placeholderWidth = 0;
+  const lineTolerance = 5;
+  const scanStart = Math.max(0, foundIndex - 10);
+  const scanEnd = Math.min(foundIndex + 10, runs.length);
+  for (let index = scanStart; index < scanEnd; index++) {
+    const run = runs[index];
+    const underscores = (run.text.match(/_/g) ?? []).length;
+    if (underscores === 0 || Math.abs(run.y - found.y) > lineTolerance) continue;
+    if (run.width > 0) {
+      placeholderWidth += run.width / run.text.length * underscores;
+    } else {
+      placeholderWidth += fontHeight * 0.4 * underscores;
+    }
+    break;
+  }
+  return {
+    x: found.x,
+    y: found.y,
+    width: Math.max(placeholderWidth, 30),
+    height: Math.max(fontHeight * 2.5, 25)
+  };
+}
+async function extractFieldsFromPdf(pdf) {
+  return fieldsFromPageRuns(await pageTextRuns(pdf));
+}
+function fieldsFromPageRuns(pages) {
+  const fields = [];
+  const unknown = [];
+  for (let pageIndex = 0; pageIndex < pages.length; pageIndex++) {
+    const { mediaBox, runs } = pages[pageIndex];
+    const pageHeight = mediaBox[3] - mediaBox[1];
+    const originX = mediaBox[0];
+    const originY = mediaBox[1];
+    const accumulated = runs.map((run) => run.text).join("");
+    for (const encoding of decodeAll(accumulated)) {
+      const position = findEncodingPosition(runs, encoding.position);
+      if (!position) continue;
+      const name2 = fieldTypeToString(encoding.fieldType);
+      if (name2 === "unknown") {
+        unknown.push({ page: pageIndex + 1, signerIndex: encoding.signerIndex, fieldType: encoding.fieldType });
+        continue;
+      }
+      const isInitials = name2 === "initials";
+      const width = isInitials ? Math.min(position.width, DEFAULT_INITIALS_DIMENSIONS.width) : position.width;
+      const height = isInitials ? Math.min(position.height * 0.8, DEFAULT_INITIALS_DIMENSIONS.height) : position.height;
+      const rawY = position.y - originY;
+      fields.push({
+        signerIndex: encoding.signerIndex,
+        fieldType: name2,
+        page: pageIndex + 1,
+        x: position.x - originX,
+        y: pageHeight - rawY - height,
+        width: Math.round(width),
+        height: Math.round(height),
+        rawY,
+        pageHeight
+      });
+    }
+  }
+  if (unknown.length > 0) throw new UnknownMarkerError(unknown);
+  return fields;
+}
+async function pageTextRuns(pdf) {
+  const model = await PdfModel.load(pdf);
+  const pages = await loadPages(model);
+  const result = [];
+  for (const page of pages) {
+    result.push({ mediaBox: page.mediaBox, runs: mergeRuns(await scanPage(model, page)) });
+  }
+  return result;
+}
+async function pdfContainsEncoding(pdf) {
+  const model = await PdfModel.load(pdf);
+  for (const page of await loadPages(model)) {
+    const runs = await scanPage(model, page);
+    for (const run of runs) {
+      if (ALPHABET.some((character) => run.text.includes(character))) return true;
+    }
+  }
+  return false;
+}
+
+// src/pdf/locate.ts
+function locator() {
+  return { locate };
+}
+var LocateError = class extends Error {
+  constructor(message, failures) {
+    super(message);
+    this.failures = failures;
+    this.name = "LocateError";
+  }
+  failures;
+};
+function lines(runs) {
+  const byLine = [];
+  for (const run of runs) {
+    const line = byLine.find((candidate) => Math.abs(candidate[0].y - run.y) < 2);
+    if (line) line.push(run);
+    else byLine.push([run]);
+  }
+  for (const line of byLine) line.sort((a, b) => a.x - b.x);
+  byLine.sort((a, b) => b[0].y - a[0].y);
+  return byLine;
+}
+function findAnchorMatches(pagesRuns, text) {
+  const matches = [];
+  for (let pageIndex = 0; pageIndex < pagesRuns.length; pageIndex++) {
+    for (const line of lines(pagesRuns[pageIndex])) {
+      let lineText = "";
+      const owners = [];
+      for (const run of line) {
+        owners.push({ run, start: lineText.length });
+        lineText += run.text;
+      }
+      let from = 0;
+      while (true) {
+        const index = lineText.indexOf(text, from);
+        if (index === -1) break;
+        from = index + 1;
+        const owner = [...owners].reverse().find((candidate) => candidate.start <= index);
+        const offsetChars = index - owner.start;
+        const perChar = owner.run.text.length > 0 ? owner.run.width / owner.run.text.length : 0;
+        const matchWidth = perChar * text.length;
+        matches.push({
+          page: pageIndex + 1,
+          x: owner.run.x + perChar * offsetChars,
+          y: owner.run.y,
+          width: matchWidth,
+          height: owner.run.height > 0 ? owner.run.height : 12
+        });
+      }
+    }
+  }
+  return matches;
+}
+async function locate(pdf, queries) {
+  if (queries.length === 0) return [];
+  for (const query of queries) {
+    if (query.kind === "anchor" && query.occurrence !== void 0 && !(Number.isInteger(query.occurrence) && query.occurrence >= 1)) {
+      throw new RangeError(`Placement "${query.id}": occurrence must be a positive integer, got ${query.occurrence}`);
+    }
+  }
+  const pages = await pageTextRuns(pdf);
+  const pageHeights = pages.map((page) => page.mediaBox[3] - page.mediaBox[1]);
+  const pageOrigins = pages.map((page) => ({ x: page.mediaBox[0], y: page.mediaBox[1] }));
+  const pagesRuns = pages.map((page) => page.runs);
+  const markerFields = queries.some((query) => query.kind === "marker") ? fieldsFromPageRuns(pages) : [];
+  const hits = [];
+  const failures = [];
+  for (const query of queries) {
+    if (query.kind === "marker") {
+      const matches2 = markerFields.filter(
+        (field) => field.signerIndex === query.signerIndex && field.fieldType === fieldTypeToString(query.fieldType)
+      );
+      if (matches2.length === 0) {
+        failures.push({ id: query.id, reason: "missing" });
+      } else if (matches2.length > 1) {
+        failures.push({ id: query.id, reason: "ambiguous", matches: matches2.length });
+      } else {
+        const field = matches2[0];
+        hits.push({
+          id: query.id,
+          page: field.page,
+          x: field.x,
+          y: field.y,
+          width: field.width,
+          height: field.height
+        });
+      }
+      continue;
+    }
+    const matches = findAnchorMatches(pagesRuns, query.text);
+    if (matches.length === 0) {
+      failures.push({ id: query.id, reason: "missing" });
+      continue;
+    }
+    if (query.occurrence === void 0 && matches.length > 1) {
+      failures.push({ id: query.id, reason: "ambiguous", matches: matches.length });
+      continue;
+    }
+    const pick = matches[(query.occurrence ?? 1) - 1];
+    if (!pick) {
+      failures.push({ id: query.id, reason: "missing", matches: matches.length });
+      continue;
+    }
+    const origin = pageOrigins[pick.page - 1];
+    const pageHeight = pageHeights[pick.page - 1];
+    hits.push({
+      id: query.id,
+      page: pick.page,
+      x: pick.x - origin.x,
+      y: pageHeight - (pick.y - origin.y) - pick.height,
+      width: pick.width,
+      height: pick.height
+    });
+  }
+  if (failures.length > 0) {
+    const summary = failures.map(
+      (failure) => failure.reason === "ambiguous" ? `${failure.id} (ambiguous: ${failure.matches} matches, pass occurrence)` : `${failure.id} (not found)`
+    ).join(", ");
+    throw new LocateError(`Could not resolve ${failures.length} of ${queries.length} placements: ${summary}`, failures);
+  }
+  return hits;
+}
+
+// src/pdf/read-form.ts
+import { defaultFormatter as defaultFormatter3 } from "@asterdoc/format";
+var PdfExtractionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "PdfExtractionError";
+    this.code = code;
+  }
+};
+function stateName(value) {
+  if (isName(value)) return value.value;
+  return typeof value === "string" ? value : void 0;
+}
+function buttonState(model, field) {
+  const value = stateName(model.resolve(field.dict.entries.get("V")));
+  if (value !== void 0) return value;
+  const states = field.widgets.map((widget2) => stateName(model.resolve(widget2.dict.entries.get("AS")))).filter((state) => state !== void 0);
+  return states.find((state) => state !== "Off") ?? states[0];
+}
+function readField(model, field) {
+  if (field.type === "checkbox" || field.type === "radio") {
+    const raw = buttonState(model, field);
+    return { field, raw, on: raw !== void 0 && raw !== "Off" };
+  }
+  const value = model.resolve(field.dict.entries.get("V"));
+  if (field.type === "dropdown") {
+    const selected = (Array.isArray(value) ? value : [value]).map((entry) => typeof entry === "string" ? decodeTextString(entry) : void 0).filter((entry) => entry !== void 0 && entry.trim() !== "");
+    return { field, raw: selected.length > 0 ? selected.join(", ") : void 0, selected };
+  }
+  const decoded = typeof value === "string" ? decodeTextString(value) : void 0;
+  const text = decoded !== void 0 && decoded.trim() !== "" ? decoded : void 0;
+  return { field, raw: text };
+}
+function assertReadablePdf(bytes) {
+  const head = byteString(bytes.subarray(0, 1024));
+  if (!head.includes("%PDF-")) {
+    throw new PdfExtractionError("malformed_pdf", "The input is not a PDF: it has no %PDF- header.");
+  }
+  const tail = byteString(bytes.subarray(Math.max(0, bytes.length - 2048)));
+  const end = tail.lastIndexOf("%%EOF");
+  if (end === -1 || !/^[\s\0]*$/.test(tail.slice(end + 5))) {
+    throw new PdfExtractionError("malformed_pdf", "The PDF is truncated: it does not end with an end-of-file marker.");
+  }
+}
+async function loadFormFields(bytes) {
+  assertReadablePdf(bytes);
+  let model;
+  try {
+    model = await PdfModel.load(bytes);
+  } catch (error) {
+    if (error instanceof PdfEncryptedError) throw error;
+    throw new PdfExtractionError("malformed_pdf", `The PDF could not be parsed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let fields;
+  try {
+    fields = acroFields(model)?.fields ?? [];
+  } catch (error) {
+    throw new PdfExtractionError("malformed_pdf", `The PDF could not be read: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const fillable = fields.filter((field) => field.type !== "signature" && field.type !== "button" && field.type !== "unknown");
+  if (fillable.length === 0) {
+    throw new PdfExtractionError(
+      "no_form_fields",
+      "The PDF has no AcroForm fields to read. Flattened and scanned documents need the hosted Asterdoc extraction service."
+    );
+  }
+  return { model, fields: fillable, names: new Set(fields.map((field) => field.name)) };
+}
+var numericMembers = {
+  money: /* @__PURE__ */ new Set(["amount"]),
+  coordinate: /* @__PURE__ */ new Set(["lat", "lon"]),
+  bbox: /* @__PURE__ */ new Set(["southWest.lat", "southWest.lon", "northEast.lat", "northEast.lon"])
+};
+function targetFor(form, path) {
+  const segments = pathSegments(path);
+  const [root, ...rest] = segments;
+  if (root === "parties") {
+    return rest.length >= 2 && !(rest.length === 2 && /^\d+$/.test(rest[1])) ? { kind: "member", type: "text" } : { kind: "fixed", reason: "A whole party is written as formatted text; bind its parts to recover them." };
+  }
+  if (root === "defs") return { kind: "fixed", reason: "Computed values are derived from other data, not read back." };
+  if (root === "annexes") return { kind: "fixed", reason: "Annexes are attachments, not form field values." };
+  let field = root ? form.fields?.[root] : void 0;
+  if (!field) return { kind: "fixed", reason: "The path is artifact metadata, not a data value." };
+  for (let index = 0; index < rest.length; index++) {
+    const segment = rest[index];
+    if (field.type === "list" && /^\d+$/.test(segment)) field = field.item;
+    else if (field.type === "fieldset" && field.fields[segment]) field = field.fields[segment];
+    else return { kind: "member", type: numericMembers[field.type]?.has(rest.slice(index).join(".")) ? "number" : "text" };
+  }
+  return { kind: "field", field };
+}
+var ok = (value) => ({ ok: true, value });
+var fail = (reason) => ({ ok: false, reason });
+function numberSymbols(locale) {
+  try {
+    const parts = new Intl.NumberFormat(locale).formatToParts(12345.6);
+    return {
+      group: parts.find((part) => part.type === "group")?.value ?? ",",
+      decimal: parts.find((part) => part.type === "decimal")?.value ?? "."
+    };
+  } catch {
+    return { group: ",", decimal: "." };
+  }
+}
+function parseNumber(raw, locale) {
+  const text = raw.trim();
+  if (/^[-+]?\d+(\.\d+)?$/.test(text)) return Number(text);
+  const { group, decimal } = numberSymbols(locale);
+  const grouped = text.split(group).join("").replace(/[\s\u00a0\u202f]/g, "").replace(/\u2212/g, "-");
+  const normalized = decimal === "." ? grouped : grouped.split(decimal).join(".");
+  if (!/^[-+]?\d+(\.\d+)?$/.test(normalized)) return void 0;
+  const value = Number(normalized);
+  return Number.isFinite(value) ? value : void 0;
+}
+function isoDate(year, month, day) {
+  if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) return void 0;
+  const date = new Date(Date.UTC(year, month - 1, day));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) return void 0;
+  return `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+function numericDateOrder(locale) {
+  try {
+    return new Intl.DateTimeFormat(locale, { year: "numeric", month: "2-digit", day: "2-digit", timeZone: "UTC" }).formatToParts(new Date(Date.UTC(2e3, 0, 2))).map((part) => part.type).filter((type) => type === "year" || type === "month" || type === "day");
+  } catch {
+    return ["month", "day", "year"];
+  }
+}
+function monthIndex(token, locale) {
+  const needle = token.replace(/\.$/, "").toLocaleLowerCase(locale);
+  for (const style of ["long", "short"]) {
+    const format3 = new Intl.DateTimeFormat(locale, { month: style, timeZone: "UTC" });
+    for (let month = 0; month < 12; month++) {
+      const name2 = format3.format(new Date(Date.UTC(2e3, month, 1))).replace(/\.$/, "").toLocaleLowerCase(locale);
+      if (name2 === needle) return month + 1;
+    }
+  }
+  return void 0;
+}
+function parseDate(raw, locale) {
+  const text = raw.trim();
+  const iso = text.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (iso) return isoDate(Number(iso[1]), Number(iso[2]), Number(iso[3]));
+  const numeric = text.match(/^(\d{1,4})[/.-](\d{1,2})[/.-](\d{1,4})$/);
+  if (numeric) {
+    const values = [Number(numeric[1]), Number(numeric[2]), Number(numeric[3])];
+    const order = numericDateOrder(locale);
+    if (order.length !== 3) return void 0;
+    const part = (type) => values[order.indexOf(type)];
+    const yearText = numeric[order.indexOf("year") + 1];
+    if (yearText.length !== 4) return void 0;
+    return isoDate(part("year"), part("month"), part("day"));
+  }
+  const tokens = text.split(/[\s,]+/).filter(Boolean);
+  if (tokens.length !== 3) return void 0;
+  let month;
+  const numbers = [];
+  for (const token of tokens) {
+    if (/^\d+\.?$/.test(token)) numbers.push(token.replace(/\.$/, ""));
+    else if (month === void 0) month = monthIndex(token, locale);
+    else return void 0;
+  }
+  if (month === void 0 || numbers.length !== 2) return void 0;
+  const year = numbers.find((value) => value.length === 4);
+  const day = numbers.find((value) => value.length <= 2);
+  if (!year || !day) return void 0;
+  return isoDate(Number(year), month, Number(day));
+}
+function parseTime(raw) {
+  const text = raw.trim();
+  const clock = text.match(/^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?$/);
+  if (clock) return text;
+  const meridiem = text.match(/^(\d{1,2}):([0-5]\d)(?::([0-5]\d))?\s*([AaPp])\.?\s*[Mm]\.?$/);
+  if (!meridiem) return void 0;
+  const hour = Number(meridiem[1]);
+  if (hour < 1 || hour > 12) return void 0;
+  const pm = meridiem[4].toLowerCase() === "p";
+  const hours = String(hour % 12 + (pm ? 12 : 0)).padStart(2, "0");
+  return `${hours}:${meridiem[2]}${meridiem[3] ? `:${meridiem[3]}` : ""}`;
+}
+function matchOption(raw, options, formatter) {
+  const label = (option) => {
+    const result = formatter.safeFormatEnum(option.value, { options });
+    return result.success ? result.value : option.label ?? String(option.value);
+  };
+  const byValue = options.filter((option) => String(option.value) === raw);
+  if (byValue.length === 1) return byValue[0];
+  const byLabel = options.filter((option) => label(option) === raw);
+  if (byLabel.length === 1) return byLabel[0];
+  const folded = raw.trim().toLowerCase();
+  const loose = options.filter((option) => String(option.value).toLowerCase() === folded || label(option).toLowerCase() === folded);
+  return loose.length === 1 ? loose[0] : void 0;
+}
+var currencyCodes;
+function currencies() {
+  if (currencyCodes) return currencyCodes;
+  const intl = Intl;
+  try {
+    currencyCodes = intl.supportedValuesOf?.("currency") ?? [];
+  } catch {
+    currencyCodes = [];
+  }
+  if (currencyCodes.length === 0) currencyCodes = ["USD", "EUR", "GBP", "CAD", "AUD", "JPY", "CHF", "CNY", "INR", "MXN"];
+  return currencyCodes;
+}
+function parseMoney(raw, field, formatter) {
+  const text = raw.trim();
+  const amountText = text.replace(/^[^\d(+\-\u2212]+|[^\d)]+$/g, "").replace(/^\((.*)\)$/, "-$1");
+  const amount = parseNumber(amountText, formatter.locale);
+  if (amount === void 0) return fail("The value is not an amount of money.");
+  const declared = field.type === "money" ? field.currency : void 0;
+  const preferred = field.type === "money" && field.default?.currency ? [field.default.currency] : [];
+  const candidates = declared ? [declared] : [...preferred, ...currencies().filter((code) => !preferred.includes(code))];
+  const matches = /* @__PURE__ */ new Set();
+  for (const currency of candidates) {
+    const result = formatter.safeFormatMoney({ amount, currency });
+    if (result.success && result.value === text) matches.add(currency);
+    if (matches.size > 1) break;
+  }
+  if (matches.size === 1) return ok({ amount, currency: [...matches][0] });
+  return fail(matches.size === 0 ? "The currency cannot be determined from the text; write the amount with its currency symbol, or bind the amount on its own." : "The text matches more than one currency; declare the field's currency, or write the amount with its currency symbol.");
+}
+var composite = /* @__PURE__ */ new Set(["address", "person", "organization", "identification", "coordinate", "bbox", "list", "fieldset"]);
+function parseFieldValue(raw, field, formatter) {
+  if (composite.has(field.type)) {
+    return fail(`A ${field.type} value written as one piece of text cannot be split back into its parts; bind its parts to recover it.`);
+  }
+  switch (field.type) {
+    case "text":
+    case "email":
+    case "uuid":
+    case "uri":
+      return ok(raw);
+    case "enum": {
+      const option = matchOption(raw, field.enum, formatter);
+      return option ? ok(option.value) : fail("The text matches none of the field's options.");
+    }
+    case "multiselect": {
+      for (const parts of [raw.split(", "), raw.split(",")]) {
+        const values = parts.map((part) => part.trim()).filter(Boolean);
+        const options = values.map((value) => matchOption(value, field.enum, formatter));
+        if (options.every((option) => option !== void 0)) return ok(options.map((option) => option.value));
+      }
+      return fail("The selection includes a value that matches none of the field's options.");
+    }
+    case "boolean": {
+      const text = raw.trim();
+      const yes = formatter.safeFormatBoolean(true);
+      const no = formatter.safeFormatBoolean(false);
+      if (yes.success && text === yes.value) return ok(true);
+      if (no.success && text === no.value) return ok(false);
+      const folded = text.toLowerCase();
+      if (folded === "true" || folded === "yes") return ok(true);
+      if (folded === "false" || folded === "no") return ok(false);
+      return fail("The text is not a yes or no value.");
+    }
+    case "number":
+    case "rating": {
+      const value = parseNumber(raw, formatter.locale);
+      return value === void 0 ? fail("The text is not a number.") : ok(value);
+    }
+    case "percentage": {
+      const value = parseNumber(raw.trim().replace(/\s*%$/, ""), formatter.locale);
+      return value === void 0 ? fail("The text is not a percentage.") : ok(value);
+    }
+    case "money":
+      return parseMoney(raw, field, formatter);
+    case "date": {
+      const value = parseDate(raw, formatter.locale);
+      return value === void 0 ? fail("The text is not a date.") : ok(value);
+    }
+    case "datetime": {
+      const text = raw.trim();
+      return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})$/.test(text) && !Number.isNaN(Date.parse(text)) ? ok(text) : fail("Only an ISO 8601 date and time can be read back exactly.");
+    }
+    case "time": {
+      const value = parseTime(raw);
+      return value === void 0 ? fail("The text is not a time of day.") : ok(value);
+    }
+    case "duration": {
+      const text = raw.trim();
+      return /^P(?!$)(\d+(\.\d+)?Y)?(\d+(\.\d+)?M)?(\d+(\.\d+)?W)?(\d+(\.\d+)?D)?(T(?=\d)(\d+(\.\d+)?H)?(\d+(\.\d+)?M)?(\d+(\.\d+)?S)?)?$/.test(text) ? ok(text) : fail("Only an ISO 8601 duration can be read back exactly.");
+    }
+    case "phone": {
+      const text = raw.trim().replace(/[\s().-]/g, "");
+      return /^\+[1-9]\d{1,14}$/.test(text) ? ok({ number: text }) : fail("The text is not an international phone number.");
+    }
+  }
+  return fail(`Values of type ${field.type} cannot be read back.`);
+}
+function parseTarget(raw, target, formatter) {
+  if (target.kind === "fixed") return fail(target.reason);
+  if (target.kind === "field") return parseFieldValue(raw, target.field, formatter);
+  if (target.type === "number") {
+    const value = parseNumber(raw, formatter.locale);
+    return value === void 0 ? fail("The text is not a number.") : ok(value);
+  }
+  return ok(raw);
+}
+function source(state, name2) {
+  return state?.raw === void 0 ? { field: name2 } : { field: name2, value: state.raw };
+}
+function readDirect(state, target, formatter) {
+  const { field } = state;
+  if (field.type === "checkbox") {
+    const isBoolean = target.kind === "field" ? target.field.type === "boolean" : false;
+    if (!isBoolean) {
+      return state.on ? { kind: "unparseable", reason: "A checkbox can only be read back into a yes or no field." } : { kind: "empty" };
+    }
+    return state.on ? { kind: "value", value: true } : { kind: "empty" };
+  }
+  if (field.type === "radio") {
+    if (!state.on || state.raw === void 0) return { kind: "empty" };
+    const parsed2 = parseTarget(state.raw, target, formatter);
+    return parsed2.ok ? { kind: "value", value: parsed2.value } : { kind: "unparseable", reason: parsed2.reason };
+  }
+  if (field.type === "dropdown") {
+    if (!state.selected || state.selected.length === 0) return { kind: "empty" };
+    const raw = state.selected.join(", ");
+    const parsed2 = parseTarget(raw, target, formatter);
+    return parsed2.ok ? { kind: "value", value: parsed2.value } : { kind: "unparseable", reason: parsed2.reason };
+  }
+  if (state.raw === void 0) return { kind: "empty" };
+  if (target.kind === "fixed") return { kind: "not_recoverable", reason: target.reason };
+  if (target.kind === "field" && composite.has(target.field.type)) {
+    return { kind: "not_recoverable", reason: `A ${target.field.type} value written as one piece of text cannot be split back into its parts; bind its parts to recover it.` };
+  }
+  const parsed = parseTarget(state.raw, target, formatter);
+  return parsed.ok ? { kind: "value", value: parsed.value } : { kind: "unparseable", reason: parsed.reason };
+}
+function sameValue(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function resolvePath(work, target, formatter) {
+  const readings = [...work.readings];
+  if (work.parts.size > 0) {
+    const positions = [...work.parts.keys()].sort((left, right) => left - right);
+    const values2 = positions.map((position) => work.parts.get(position));
+    const lastFilled = values2.reduce((last, value, index) => value === void 0 ? last : index, -1);
+    if (lastFilled === -1) readings.push({ kind: "empty" });
+    else if (positions.some((position, index) => position !== index + 1)) {
+      readings.push({ kind: "not_recoverable", reason: "The split parts are not all bound, so the value cannot be joined back." });
+    } else if (values2.slice(0, lastFilled).some((value) => value === void 0)) {
+      readings.push({ kind: "unparseable", reason: "A part before the last filled part is empty, so the parts cannot be joined in order." });
+    } else {
+      const parsed = parseTarget(values2.slice(0, lastFilled + 1).join("-"), target, formatter);
+      readings.push(parsed.ok ? { kind: "value", value: parsed.value } : { kind: "unparseable", reason: parsed.reason });
+    }
+  }
+  if (work.options.size > 0) {
+    const checked = [...work.options].filter(([, on]) => on).map(([qualifier]) => qualifier);
+    const declared = target.kind === "field" && (target.field.type === "enum" || target.field.type === "multiselect") ? target.field.enum : [];
+    const valueOf = (qualifier) => declared.find((option) => String(option.value) === qualifier)?.value ?? qualifier;
+    if (checked.length === 0) readings.push({ kind: "empty" });
+    else if (work.optionKind === "multiselect") readings.push({ kind: "value", value: checked.map(valueOf) });
+    else if (checked.length === 1) readings.push({ kind: "value", value: valueOf(checked[0]) });
+    else readings.push({ kind: "unparseable", reason: "More than one option is checked for a field that takes one." });
+  }
+  const problems = readings.filter((reading) => reading.kind === "unparseable");
+  if (problems.length > 0) return { status: "unparseable", reason: problems.map((problem) => problem.reason).join(" ") };
+  const values = readings.filter((reading) => reading.kind === "value");
+  if (values.length > 0) {
+    const [first] = values;
+    if (values.every((reading) => sameValue(reading.value, first.value))) return { status: "recovered", value: first.value };
+    return { status: "unparseable", reason: "The PDF fields that carry this path hold different values." };
+  }
+  const lost = readings.find((reading) => reading.kind === "not_recoverable");
+  if (lost) return { status: "not_recoverable", reason: lost.reason };
+  return { status: "empty" };
+}
+function setValue(root, segments, value) {
+  let current = root;
+  for (let index = 0; index < segments.length - 1; index++) {
+    const key = segments[index];
+    const nextIsIndex = /^\d+$/.test(segments[index + 1]);
+    const container = current;
+    if (container[key] === void 0 || container[key] === null || typeof container[key] !== "object") {
+      container[key] = nextIsIndex ? [] : {};
+    }
+    current = container[key];
+  }
+  ;
+  current[segments.at(-1)] = value;
+}
+function placeValue(data, path, value) {
+  const segments = pathSegments(path);
+  const [root, ...rest] = segments;
+  if (root === "parties" && rest.length > 0) {
+    data.parties ??= {};
+    setValue(data.parties, rest, value);
+    return;
+  }
+  setValue(data.fields, segments, value);
+}
+async function extractPdfData({ pdf, form, bindings, formatter: filledWith = defaultFormatter3, format: format3 }) {
+  const formatter = format3?.money ? filledWith.compose({ money: format3.money }) : filledWith;
+  const parsed = parseBindings(bindings);
+  const sources = parsed.flatMap(([, parts]) => parts.map((part) => part.source));
+  validateFieldBindings(form, Object.fromEntries(sources.map((source2, index) => [String(index), source2])));
+  const { model, fields, names } = await loadFormFields(pdf);
+  const states = new Map(fields.map((field) => [field.name, readField(model, field)]));
+  const bindingNames = Object.keys(bindings);
+  const missing = bindingNames.filter((name2) => !names.has(name2));
+  if (missing.length === bindingNames.length) {
+    throw new PdfExtractionError(
+      "not_matching",
+      `None of the PDF's ${fields.length} form fields match the layer's ${bindingNames.length} bindings. Check that the PDF is this artifact's form.`
+    );
+  }
+  if (missing.length > 0) {
+    throw new PdfExtractionError(
+      "not_matching",
+      `The PDF has no field for ${missing.length} of the layer's ${bindingNames.length} bindings: ${missing.join(", ")}. Check that the PDF is this artifact's form.`
+    );
+  }
+  const work = /* @__PURE__ */ new Map();
+  const workFor = (path) => {
+    let entry = work.get(path);
+    if (!entry) {
+      entry = { sources: [], readings: [], parts: /* @__PURE__ */ new Map(), options: /* @__PURE__ */ new Map() };
+      work.set(path, entry);
+    }
+    return entry;
+  };
+  for (const [pdfName, parts] of parsed) {
+    const state = states.get(pdfName);
+    if (parts.length > 1) {
+      for (const part of parts) {
+        const entry2 = workFor(part.path);
+        entry2.sources.push(source(state, pdfName));
+        entry2.readings.push(state?.raw === void 0 ? { kind: "empty" } : { kind: "not_recoverable", reason: "Several values are joined into one PDF field, and extraction does not guess how to split them." });
+      }
+      continue;
+    }
+    const { path, qualifier } = parts[0];
+    const entry = workFor(path);
+    entry.sources.push(source(state, pdfName));
+    const target = targetFor(form, path);
+    const fieldType = target.kind === "field" ? target.field.type : void 0;
+    const isPart = qualifier !== void 0 && fieldType !== "boolean" && fieldType !== "enum" && fieldType !== "multiselect" && splitPartIndex(qualifier) !== void 0;
+    if (!state) {
+      if (isPart) entry.parts.set(Number(qualifier), void 0);
+      else entry.readings.push({ kind: "empty" });
+      continue;
+    }
+    if (qualifier === void 0) {
+      entry.readings.push(readDirect(state, target, formatter));
+      continue;
+    }
+    if (fieldType === "boolean") {
+      entry.readings.push(readDirect(state, target, formatter));
+    } else if (fieldType === "enum" || fieldType === "multiselect") {
+      entry.optionKind = fieldType;
+      entry.options.set(qualifier, state.field.type === "checkbox" || state.field.type === "radio" ? Boolean(state.on) : state.raw !== void 0);
+    } else if (isPart) {
+      entry.parts.set(Number(qualifier), state.raw);
+    } else {
+      entry.readings.push(state.raw === void 0 ? { kind: "empty" } : { kind: "not_recoverable", reason: `The qualifier "${qualifier}" has no reverse mapping for this field.` });
+    }
+  }
+  const data = { fields: {} };
+  const entries = [];
+  for (const [path, entry] of work) {
+    const resolved = resolvePath(entry, targetFor(form, path), formatter);
+    if (resolved.status === "recovered") placeValue(data, path, resolved.value);
+    entries.push({
+      path,
+      status: resolved.status,
+      sources: entry.sources,
+      ...resolved.reason ? { reason: resolved.reason } : {}
+    });
+  }
+  const boundNames = new Set(Object.keys(bindings));
+  const unbound = [];
+  for (const state of states.values()) {
+    if (boundNames.has(state.field.name)) continue;
+    const type = state.field.type;
+    if (type !== "text" && type !== "checkbox" && type !== "radio" && type !== "dropdown") continue;
+    const hasValue = type === "checkbox" || type === "radio" ? state.on : state.raw !== void 0;
+    if (hasValue && state.raw !== void 0) unbound.push({ field: state.field.name, type, value: state.raw });
+  }
+  return { data, report: { entries, unbound } };
+}
+function selectPdfExtractionLayer(layers, requested) {
+  const all = layers ?? {};
+  const pdfKeys = Object.keys(all).filter((key2) => all[key2]?.mimeType?.toLowerCase() === "application/pdf");
+  let key = requested;
+  if (key !== void 0) {
+    const layer2 = all[key];
+    if (!layer2) {
+      throw new PdfExtractionError("layer_not_found", `Layer "${key}" not found. PDF layers: ${pdfKeys.join(", ") || "(none)"}.`);
+    }
+    if (layer2.mimeType?.toLowerCase() !== "application/pdf") {
+      throw new PdfExtractionError("not_pdf_layer", `Layer "${key}" is ${layer2.mimeType ?? "not a PDF"}. PDF layers: ${pdfKeys.join(", ") || "(none)"}.`);
+    }
+  } else if (pdfKeys.length === 0) {
+    throw new PdfExtractionError("no_pdf_layer", `The artifact has no PDF layer to read against. Layers: ${Object.keys(all).join(", ") || "(none)"}.`);
+  } else if (pdfKeys.length > 1) {
+    throw new PdfExtractionError("layer_required", `The artifact has several PDF layers; name one: ${pdfKeys.join(", ")}.`);
+  } else {
+    key = pdfKeys[0];
+  }
+  const layer = all[key];
+  if (layer.bindingsFrom !== void 0 && !layer.bindings && !all[layer.bindingsFrom]) {
+    throw new PdfExtractionError(
+      "unknown_bindings_source",
+      `Layer "${key}" takes its bindings from "${layer.bindingsFrom}", which is not a layer. Layers: ${Object.keys(all).join(", ")}.`
+    );
+  }
+  const bindings = resolveLayerBindings(all, layer);
+  if (!bindings || Object.keys(bindings).length === 0) {
+    throw new PdfExtractionError("not_matching", `Layer "${key}" has no bindings, so no PDF field maps to the artifact.`);
+  }
+  return { key, bindings, ...layer.format && { format: layer.format } };
+}
+
+// src/pdf/pattern-bounds.ts
+var REFERENCE_REPERTOIRE = [
+  ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  ..."abcdefghijklmnopqrstuvwxyz",
+  ..."0123456789"
+];
+var MAX_RANGE = 256;
+var Unsupported = class extends Error {
+};
+var DIGITS = [..."0123456789"];
+var WORD = [...REFERENCE_REPERTOIRE, "_"];
+var ANY = { any: true };
+var set = (chars) => ({ any: false, chars });
+var Parser2 = class {
+  constructor(source2) {
+    this.source = source2;
+  }
+  source;
+  index = 0;
+  parse() {
+    const node = this.alternation();
+    if (this.index < this.source.length) throw new Unsupported(`unexpected ${this.source[this.index]}`);
+    return node;
+  }
+  peek() {
+    return this.source[this.index];
+  }
+  alternation() {
+    const options = [this.sequence()];
+    while (this.peek() === "|") {
+      this.index++;
+      options.push(this.sequence());
+    }
+    return options.length === 1 ? options[0] : { kind: "alt", options };
+  }
+  sequence() {
+    const items = [];
+    while (this.index < this.source.length && this.peek() !== "|" && this.peek() !== ")") {
+      const atom = this.atom();
+      items.push(this.quantified(atom));
+    }
+    return { kind: "seq", items };
+  }
+  quantified(node) {
+    const char = this.peek();
+    let bounds;
+    if (char === "*") bounds = [0, Infinity];
+    else if (char === "+") bounds = [1, Infinity];
+    else if (char === "?") bounds = [0, 1];
+    if (bounds) this.index++;
+    else if (char === "{") {
+      const match = /^\{(\d+)(,(\d*))?\}/.exec(this.source.slice(this.index));
+      if (!match) return node;
+      this.index += match[0].length;
+      const min = Number(match[1]);
+      bounds = [min, match[2] === void 0 ? min : match[3] ? Number(match[3]) : Infinity];
+    } else return node;
+    if (this.peek() === "?") this.index++;
+    return this.quantified({ kind: "repeat", node, min: bounds[0], max: bounds[1] });
+  }
+  atom() {
+    const char = this.source[this.index++];
+    if (char === "^" || char === "$") return { kind: "empty" };
+    if (char === ".") return { kind: "chars", set: ANY };
+    if (char === "[") return { kind: "chars", set: this.characterClass() };
+    if (char === "\\") return this.escape(false);
+    if (char === "(") {
+      let lookaround = false;
+      if (this.peek() === "?") {
+        const rest = this.source.slice(this.index);
+        if (rest.startsWith("?:")) this.index += 2;
+        else if (/^\?(=|!|<=|<!)/.test(rest)) {
+          lookaround = true;
+          this.index += rest.startsWith("?<") ? 3 : 2;
+        } else if (/^\?<[A-Za-z_$][\w$]*>/.test(rest)) this.index += rest.indexOf(">") + 1;
+        else throw new Unsupported("group modifier");
+      }
+      const inner = this.alternation();
+      if (this.peek() !== ")") throw new Unsupported("unclosed group");
+      this.index++;
+      return lookaround ? { kind: "empty" } : inner;
+    }
+    if (char === ")" || char === "*" || char === "+" || char === "?") throw new Unsupported(`unexpected ${char}`);
+    return { kind: "chars", set: set([char]) };
+  }
+  /** An escape after the backslash; inside a class, `\b` is a backspace. */
+  escape(inClass) {
+    const char = this.source[this.index++];
+    if (char === void 0) throw new Unsupported("trailing backslash");
+    if (char === "d") return { kind: "chars", set: set(DIGITS) };
+    if (char === "w") return { kind: "chars", set: set(WORD) };
+    if (char === "s") return { kind: "chars", set: set([" "]) };
+    if (char === "D" || char === "W" || char === "S") return { kind: "chars", set: ANY };
+    if (!inClass && (char === "b" || char === "B")) return { kind: "empty" };
+    if (/[1-9]/.test(char) || char === "k") throw new Unsupported("backreference");
+    return { kind: "chars", set: set([this.escapedCharacter(char)]) };
+  }
+  escapedCharacter(char) {
+    const code = (length) => {
+      const hex = this.source.slice(this.index, this.index + length);
+      if (!new RegExp(`^[0-9a-fA-F]{${length}}$`).test(hex)) throw new Unsupported("escape");
+      this.index += length;
+      return String.fromCodePoint(Number.parseInt(hex, 16));
+    };
+    if (char === "u") {
+      if (this.peek() === "{") {
+        const end = this.source.indexOf("}", this.index);
+        if (end < 0) throw new Unsupported("escape");
+        const value = String.fromCodePoint(Number.parseInt(this.source.slice(this.index + 1, end), 16));
+        this.index = end + 1;
+        return value;
+      }
+      return code(4);
+    }
+    if (char === "x") return code(2);
+    if (char === "t") return "	";
+    if (char === "n") return "\n";
+    if (char === "r") return "\r";
+    if (char === "b") return "\b";
+    if (char === "p" || char === "P") throw new Unsupported("property escape");
+    return char;
+  }
+  characterClass() {
+    const negated = this.peek() === "^";
+    if (negated) this.index++;
+    const chars = [];
+    let any = false;
+    let first = true;
+    while (this.peek() !== "]" || first) {
+      first = false;
+      let char = this.source[this.index++];
+      if (char === void 0) throw new Unsupported("unclosed class");
+      if (char === "\\") {
+        const escaped = this.escape(true);
+        if (escaped.kind !== "chars") continue;
+        if (escaped.set.any) {
+          any = true;
+          continue;
+        }
+        if (escaped.set.chars.length > 1) {
+          chars.push(...escaped.set.chars);
+          continue;
+        }
+        char = escaped.set.chars[0];
+      }
+      if (this.peek() === "-" && this.source[this.index + 1] !== "]" && this.source[this.index + 1] !== void 0) {
+        this.index++;
+        let end = this.source[this.index++];
+        if (end === "\\") {
+          const escaped = this.escape(true);
+          if (escaped.kind !== "chars" || escaped.set.any || escaped.set.chars.length !== 1) throw new Unsupported("range");
+          end = escaped.set.chars[0];
+        }
+        const from = char.codePointAt(0);
+        const to = end.codePointAt(0);
+        if (to < from) throw new Unsupported("range");
+        if (to - from > MAX_RANGE) any = true;
+        else for (let point = from; point <= to; point++) chars.push(String.fromCodePoint(point));
+        continue;
+      }
+      chars.push(char);
+    }
+    this.index++;
+    return negated || any ? ANY : set([...new Set(chars)]);
+  }
+};
+function parsePattern(pattern) {
+  try {
+    return new Parser2(pattern).parse();
+  } catch (error) {
+    if (error instanceof Unsupported) return void 0;
+    throw error;
+  }
+}
+function maxLength(node) {
+  switch (node.kind) {
+    case "chars":
+      return 1;
+    case "empty":
+      return 0;
+    case "seq":
+      return node.items.reduce((total, item) => total + maxLength(item), 0);
+    case "alt":
+      return Math.max(...node.options.map(maxLength));
+    case "repeat":
+      return node.max === 0 ? 0 : node.max * maxLength(node.node);
+  }
+}
+function charSets(node) {
+  switch (node.kind) {
+    case "chars":
+      return [node.set];
+    case "empty":
+      return [];
+    case "seq":
+      return node.items.flatMap(charSets);
+    case "alt":
+      return node.options.flatMap(charSets);
+    case "repeat":
+      return node.max === 0 ? [] : charSets(node.node);
+  }
+}
+function longestValue(node, pick, width, start = 0) {
+  switch (node.kind) {
+    case "chars":
+      return pick(node.set, start);
+    case "empty":
+      return "";
+    case "seq": {
+      let text = "";
+      for (const item of node.items) {
+        const part = longestValue(item, pick, width, start + [...text].length);
+        if (part === void 0) return void 0;
+        text += part;
+      }
+      return text;
+    }
+    case "alt": {
+      const options = node.options.map((option) => longestValue(option, pick, width, start));
+      if (options.some((option) => option === void 0)) return void 0;
+      return options.reduce((best, option) => width(option) > width(best) ? option : best);
+    }
+    case "repeat": {
+      if (node.max === Infinity) return void 0;
+      let text = "";
+      for (let count = 0; count < node.max; count++) {
+        const part = longestValue(node.node, pick, width, start + [...text].length);
+        if (part === void 0) return void 0;
+        text += part;
+      }
+      return text;
+    }
+  }
+}
+function isHyphen(node) {
+  return node.kind === "chars" && !node.set.any && node.set.chars.length === 1 && node.set.chars[0] === "-";
+}
+function canHoldHyphen(node) {
+  return charSets(node).some((item) => item.any || item.chars.includes("-"));
+}
+function topLevelItems(node) {
+  if (node.kind === "seq") {
+    return node.items.flatMap((item) => item.kind === "seq" ? topLevelItems(item) ?? [item] : [item]);
+  }
+  if (node.kind === "alt") return void 0;
+  return [node];
+}
+function analyzePattern(pattern) {
+  const node = parsePattern(pattern);
+  return node && new PatternAnalysis(node);
+}
+var PatternAnalysis = class {
+  constructor(node) {
+    this.node = node;
+  }
+  node;
+  /** The whole value's shape. */
+  shape(width, pick) {
+    return shapeOf(this.node, width, pick);
+  }
+  /**
+   * The shape of the `index`th (0-based) part of a value split on `-`, when
+   * the pattern is a sequence whose hyphens are fixed separators. Undefined
+   * when the pattern does not fix where the hyphens fall.
+   */
+  part(index, width, pick) {
+    const items = topLevelItems(this.node);
+    if (!items) return void 0;
+    const parts = [[]];
+    for (const item of items) {
+      if (isHyphen(item)) parts.push([]);
+      else if (canHoldHyphen(item)) return void 0;
+      else parts.at(-1).push(item);
+    }
+    const part = parts[index];
+    return part ? shapeOf({ kind: "seq", items: part }, width, pick) : void 0;
+  }
+  /** Every character set the pattern allows anywhere. */
+  sets() {
+    return charSets(this.node);
+  }
+};
+function shapeOf(node, width, pick) {
+  const value = longestValue(node, pick, width);
+  return {
+    maxLength: maxLength(node),
+    sets: charSets(node),
+    ...value !== void 0 && { value }
+  };
+}
+
+// src/pdf/binding-fit.ts
+var TYPICAL_TEXT = "The quick brown fox jumps over the lazy dog ";
+var TEXT_TYPES = /* @__PURE__ */ new Set(["text", "email", "uuid", "uri"]);
+var UUID_PATTERN = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
+var ANY2 = { any: true };
+var SHOWN_LENGTH = 40;
+var format2 = (value) => String(Number(value.toFixed(3)));
+var displayPath2 = (path) => `fields.${path}`;
+function widestCharacter(font, sets) {
+  const pool = sets.some((item) => item.any) ? [.../* @__PURE__ */ new Set([...REFERENCE_REPERTOIRE, ...sets.flatMap((item) => item.any ? [] : item.chars)])] : [...new Set(sets.flatMap((item) => item.any ? [] : item.chars))];
+  const drawable = pool.filter((character) => font.covers(character));
+  const candidates = drawable.length > 0 ? drawable : pool;
+  return candidates.reduce((best, character) => measure(font, character) > measure(font, best) ? character : best, candidates[0] ?? "W");
+}
+function typicalCharacter(font, set2, position) {
+  const sample = TYPICAL_TEXT[position % TYPICAL_TEXT.length];
+  if (set2.any || set2.chars.includes(sample)) return sample;
+  const drawable = set2.chars.filter((character) => font.covers(character));
+  const pool = drawable.length > 0 ? drawable : set2.chars;
+  const mean = pool.reduce((total, character) => total + measure(font, character), 0) / pool.length;
+  return pool.reduce((best, character) => Math.abs(measure(font, character) - mean) < Math.abs(measure(font, best) - mean) ? character : best, pool[0]);
+}
+function picker(font, kind) {
+  return kind === "widest" ? (set2) => widestCharacter(font, [set2]) : (set2, position) => typicalCharacter(font, set2, position);
+}
+function unionSet(sets) {
+  return sets.some((item) => item.any) ? ANY2 : { any: false, chars: [...new Set(sets.flatMap((item) => item.any ? [] : item.chars))] };
+}
+function measure(font, text) {
+  return font.covers(text) ? font.width(text) : 0;
+}
+function probeOf(sets) {
+  const chars = new Set(sets.flatMap((item) => item.any ? REFERENCE_REPERTOIRE : item.chars));
+  return [...chars].join("");
+}
+function textSource(path, field, part) {
+  const declared = field.pattern ?? (field.type === "uuid" ? UUID_PATTERN : void 0);
+  const analysis = declared === void 0 ? void 0 : analyzePattern(declared);
+  const shapeFor = (font, kind) => {
+    const width = (text) => measure(font, text);
+    const pick = picker(font, kind);
+    return part === void 0 ? analysis?.shape(width, pick) : analysis?.part(part, width, pick);
+  };
+  const lengthOnly = { width: (text) => text.length, covers: () => true };
+  const shape = shapeFor(lengthOnly, "widest");
+  const maxLength2 = Math.min(field.maxLength ?? Infinity, shape?.maxLength ?? Infinity);
+  if (maxLength2 === Infinity) return { kind: "unbounded", path };
+  const sets = shape?.sets ?? analysis?.sets() ?? [ANY2];
+  const byPattern = shape !== void 0 && shape.value !== void 0 && (field.maxLength === void 0 || shape.maxLength <= field.maxLength);
+  const partLabel = part === void 0 ? "" : ` (part ${part + 1})`;
+  const basis = byPattern ? `pattern ${declared}${partLabel}` : `maxLength ${field.maxLength}${partLabel}`;
+  return {
+    kind: "bounded",
+    source: {
+      path,
+      probe: probeOf(sets),
+      basis,
+      exact: false,
+      value(font, kind) {
+        const measured = shapeFor(font, kind);
+        if (byPattern && measured?.value !== void 0) return measured.value;
+        const pick = picker(font, kind);
+        const set2 = unionSet(sets);
+        return Array.from({ length: maxLength2 }, (_, position) => pick(set2, position)).join("");
+      }
+    }
+  };
+}
+function choiceSource(path, field) {
+  if (field.type !== "enum" && field.type !== "multiselect") return { kind: "other" };
+  const values = field.enum.map((option) => String(option.value));
+  if (values.length === 0) return { kind: "other" };
+  const count = field.type === "multiselect" ? Math.min(field.max ?? values.length, values.length) : 1;
+  return {
+    kind: "bounded",
+    source: {
+      path,
+      probe: values.join(""),
+      basis: field.type === "enum" ? "its widest option value" : count === values.length ? "all its option values" : `its ${count} widest option values`,
+      exact: true,
+      value(font) {
+        return [...values].sort((left, right) => measure(font, right) - measure(font, left)).slice(0, count).join(", ");
+      }
+    }
+  };
+}
+function analyzeSource(form, { path, qualifier }) {
+  const field = fieldDefinition(form, path);
+  if (!field) return { kind: "other" };
+  if (qualifier !== void 0) {
+    if (!TEXT_TYPES.has(field.type)) return { kind: "other" };
+    const part = splitPartIndex(qualifier);
+    return part === void 0 ? { kind: "other" } : textSource(path, field, part);
+  }
+  if (TEXT_TYPES.has(field.type)) return textSource(path, field);
+  return choiceSource(path, field);
+}
+function analyzeBinding(form, binding) {
+  const sources = parseBinding(binding).map((part) => analyzeSource(form, part));
+  if (sources.some((source2) => source2.kind === "other")) return void 0;
+  return sources;
+}
+function describe(layout) {
+  return `${format2(layout.width)} \xD7 ${format2(layout.height)} pt box`;
+}
+function fitFailure(field, binding, sources, layout, text, kind, error) {
+  if (error.reason !== "overflow" && error.reason !== "comb-length") return void 0;
+  const length = [...text].length;
+  const paths = sources.map((source2) => displayPath2(source2.path));
+  const shown = length <= SHOWN_LENGTH ? `: "${text}"` : "";
+  const exact = sources.every((source2) => source2.exact);
+  const adjective = exact || error.reason === "comb-length" ? "longest" : kind;
+  const what = sources.length === 1 ? `the ${adjective} value ${paths[0]} accepts under ${sources[0].basis} (${length} characters${shown})` : `the ${adjective} joined value of ${paths.join(", ")} (${length} characters)`;
+  const message = error.reason === "comb-length" ? `${what} has more characters than the field's ${error.limit} comb boxes` : `${what} does not fit the ${describe(layout)} at the minimum size of ${format2(error.limit ?? MIN_FONT_SIZE)} pt` + (kind === "widest" ? "; a typical value fits, but one made mostly of wide letters such as W does not" : "");
+  return {
+    field: field.name,
+    binding,
+    paths,
+    severity: kind === "typical" ? "error" : "warning",
+    reason: error.reason,
+    value: kind,
+    ...error.limit !== void 0 && { limit: error.limit },
+    length,
+    message
+  };
+}
+async function checkPdfBindingFit({ template, form, bindings, layerFont }) {
+  const model = await PdfModel.load(template);
+  const acro = acroFields(model);
+  if (!acro) return [];
+  const fonts = PdfFontSet.create(model, { layerFont });
+  await fonts.readFormFonts(model.dict(acro.acroForm.entries.get("DR")));
+  const byName = new Map(acro.fields.map((field) => [field.name, field]));
+  const entries = bindings ? Object.entries(bindings) : Object.entries(form.fields ?? {}).filter(([, field]) => field.type !== "fieldset").map(([name2]) => [name2, name2]);
+  const issues = [];
+  for (const [name2, binding] of entries) {
+    const field = byName.get(name2);
+    if (!field || field.type !== "text") continue;
+    const analyzed = analyzeBinding(form, binding);
+    if (!analyzed) continue;
+    const drawing = textFieldDrawing(field);
+    const layouts = field.widgets.map((widget2) => widgetLayout(model, field, widget2, drawing)).filter((layout) => layout !== void 0);
+    if (layouts.length === 0) continue;
+    const unbounded = analyzed.filter((source2) => source2.kind === "unbounded");
+    if (unbounded.length > 0) {
+      const paths = unbounded.map((source2) => displayPath2(source2.path));
+      issues.push({
+        field: field.name,
+        binding,
+        paths,
+        severity: "warning",
+        reason: "unbounded",
+        message: `${paths.join(", ")} has no maxLength or pattern that bounds its length, so a long value can fail to fill the ${describe(layouts[0])}${drawing.comb ? ` with ${drawing.comb} comb boxes` : ""}`
+      });
+      continue;
+    }
+    const sources = analyzed.map((source2) => source2.source);
+    for (const layout of layouts) {
+      const issue = checkLayout(fonts, field, binding, sources, layout);
+      if (issue) {
+        issues.push(issue);
+        break;
+      }
+    }
+  }
+  return issues;
+}
+function checkLayout(fonts, field, binding, sources, layout) {
+  let chosen;
+  try {
+    chosen = fonts.select(field.name, sources.map((source2) => source2.probe).join(""), layout.appearance.fontName);
+  } catch (error) {
+    if (error instanceof PdfFieldFillError) return void 0;
+    throw error;
+  }
+  for (const kind of ["typical", "widest"]) {
+    if (kind === "widest" && sources.every((source2) => source2.exact)) break;
+    const text = sources.map((source2) => source2.value(chosen, kind)).join(", ");
+    try {
+      layoutFieldText(layout, text, fonts.select(field.name, text, layout.appearance.fontName));
+    } catch (error) {
+      if (!(error instanceof PdfFieldFillError)) throw error;
+      return fitFailure(field, binding, sources, layout, text, kind, error);
+    }
+  }
+  return void 0;
+}
+export {
+  FieldType,
+  LocateError,
+  MIN_FONT_SIZE,
+  PdfBindingKeyError,
+  PdfBindingSyntaxError,
+  PdfEncryptedError,
+  PdfExtractionError,
+  PdfFieldFillError,
+  PdfFontError,
+  PdfMergeError,
+  TYPICAL_TEXT,
+  UnknownMarkerError,
+  checkPdfBindingFit,
+  containsEncoding,
+  decodeAll,
+  embedPdfSignature,
+  encode,
+  extractFieldsFromPdf,
+  extractPdfData,
+  flattenPdf,
+  inspectAcroFormFields,
+  inspectPdf,
+  locate,
+  locator,
+  mergePdfs,
+  pageTextRuns,
+  parseBinding,
+  pdfContainsEncoding,
+  pdfFontMetrics,
+  pdfRenderer,
+  preparePdfSignature,
+  readPdfSignature,
+  renderPdf,
+  selectPdfExtractionLayer,
+  selectPdfPages,
+  signedBytes,
+  stripEncoding
+};