@awacloud/pdf 0.0.0-stage → 1.0.0

package/dist/build/pdf.js

@@ -0,0 +1,2684 @@
+/*!
+ * Copyright (c) 2026 AwaCloud SAS
+ * Author: Matthieu Bouilloux
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Dual-licensed; see the NOTICE file for licensing and any additional terms.
+ */
+/* GENERATED — do not edit. Source: packages/front/office/pdf/tools/generate-bundles.mjs */
+
+/**
+ * @fileoverview `@awacloud/pdf/bundles/prebuilt/pdf-package` — pre-built single-factory bundle.
+ *
+ * Variant **package** : declares the 26 fw modules as dependencies and inlines every
+ * pdf-local factory transitively reachable from `pdf` .
+ *
+ * @module pdf/bundles/prebuilt/pdf-package
+ */
+
+export const pdfPackage = {
+    name: "pdfPackage",
+    dependencies: ["bitstream","huffman","lz77","deflate","adler32","b64","hex","zlib","lzw","utf8","aes","cbc","gcm","sha256","sha384","sha512","bitArray","asn1","asn1Oid","pem","random","bn","hmac","rsa","ecc","ed25519"],
+    factory(bitstream, huffman, lz77, deflate, adler32, b64, hex, zlib, lzw, utf8, aes, cbc, gcm, sha256, sha384, sha512, bitArray, asn1, asn1Oid, pem, random, bn, hmac, rsa, ecc, ed25519) {
+    const __reg = Object.create(null);
+    const __cache = Object.create(null);
+    function __register(m) { __reg[m.name] = m; }
+    function __resolve(name) {
+        if (name in __cache) return __cache[name];
+        const def = __reg[name];
+        if (!def) throw new Error('prebuilt: unknown module ' + name);
+        const args = def.dependencies.map(__resolve);
+        return (__cache[name] = def.factory.apply({}, args));
+    }
+
+    // fw modules — injected by DI.
+    __cache["bitstream"] = bitstream;
+    __cache["huffman"] = huffman;
+    __cache["lz77"] = lz77;
+    __cache["deflate"] = deflate;
+    __cache["adler32"] = adler32;
+    __cache["b64"] = b64;
+    __cache["hex"] = hex;
+    __cache["zlib"] = zlib;
+    __cache["lzw"] = lzw;
+    __cache["utf8"] = utf8;
+    __cache["aes"] = aes;
+    __cache["cbc"] = cbc;
+    __cache["gcm"] = gcm;
+    __cache["sha256"] = sha256;
+    __cache["sha384"] = sha384;
+    __cache["sha512"] = sha512;
+    __cache["bitArray"] = bitArray;
+    __cache["asn1"] = asn1;
+    __cache["asn1Oid"] = asn1Oid;
+    __cache["pem"] = pem;
+    __cache["random"] = random;
+    __cache["bn"] = bn;
+    __cache["hmac"] = hmac;
+    __cache["rsa"] = rsa;
+    __cache["ecc"] = ecc;
+    __cache["ed25519"] = ed25519;
+
+    // pdf-local factories — inlined and topo-ordered.
+    __register({ name: "pdfErrors", dependencies: [], factory: function() {
+    class PdfError extends Error {
+      constructor(code, message, opts) {
+        super(message);
+        this.name = new.target.name;
+        this.code = code;
+        if (opts && opts.context)
+          this.context = opts.context;
+        if (opts && opts.cause)
+          this.cause = opts.cause;
+      }
+    }
+
+    class ParseError extends PdfError {
+    }
+
+    class RenderError extends PdfError {
+    }
+
+    class ContractError extends PdfError {
+    }
+
+    class EncryptionError extends PdfError {
+    }
+    function isPdfError(e) {
+      return e instanceof PdfError;
+    }
+    return {
+      PdfError,
+      ParseError,
+      RenderError,
+      ContractError,
+      EncryptionError,
+      isPdfError
+    };
+  } });
+    __register({ name: "pdfShared", dependencies: [], factory: function() {
+    const HEADER_PREFIX = new Uint8Array([37, 80, 68, 70, 45]), EOF_MARKER = new Uint8Array([37, 37, 69, 79, 70]), BINARY_MARKER = new Uint8Array([37, 226, 227, 207, 211, 10]), ASCII = Object.freeze({
+      NUL: 0,
+      HT: 9,
+      LF: 10,
+      FF: 12,
+      CR: 13,
+      SP: 32,
+      HASH: 35,
+      PERCENT: 37,
+      LPAREN: 40,
+      RPAREN: 41,
+      PLUS: 43,
+      MINUS: 45,
+      DOT: 46,
+      SLASH: 47,
+      ZERO: 48,
+      NINE: 57,
+      LANGLE: 60,
+      RANGLE: 62,
+      A_UP: 65,
+      F_UP: 70,
+      Z_UP: 90,
+      LBRACK: 91,
+      BACKSLASH: 92,
+      RBRACK: 93,
+      A_LO: 97,
+      F_LO: 102,
+      Z_LO: 122,
+      LBRACE: 123,
+      RBRACE: 125
+    });
+    function isWs(b) {
+      return b === 32 || b === 9 || b === 10 || b === 13 || b === 12 || b === 0;
+    }
+    function isEol(b) {
+      return b === 10 || b === 13;
+    }
+    function isDigit(b) {
+      return b >= 48 && b <= 57;
+    }
+    function isHex(b) {
+      return b >= 48 && b <= 57 || b >= 65 && b <= 70 || b >= 97 && b <= 102;
+    }
+    function isDelim(b) {
+      return b === 40 || b === 41 || b === 60 || b === 62 || b === 91 || b === 93 || b === 47 || b === 37 || b === 123 || b === 125;
+    }
+    function isRegular(b) {
+      return !isWs(b) && !isDelim(b);
+    }
+    function hexNibble(b) {
+      if (b >= 48 && b <= 57)
+        return b - 48;
+      if (b >= 65 && b <= 70)
+        return b - 65 + 10;
+      if (b >= 97 && b <= 102)
+        return b - 97 + 10;
+      return -1;
+    }
+    const HEX_LO = function buildHexLo() {
+      const t = new Int8Array(128);
+      t.fill(-1);
+      for (let c = 48;c <= 57; c++)
+        t[c] = c - 48;
+      for (let c = 65;c <= 70; c++)
+        t[c] = c - 65 + 10;
+      for (let c = 97;c <= 102; c++)
+        t[c] = c - 97 + 10;
+      return t;
+    }(), te = new TextEncoder, tdUtf8 = new TextDecoder("utf-8"), tdUtf8Lenient = new TextDecoder("utf-8", { fatal: !1 }), tdLatin1 = new TextDecoder("latin1");
+    function encodeAscii(s) {
+      return te.encode(s);
+    }
+    function decodeUtf8(bytes) {
+      return tdUtf8.decode(bytes);
+    }
+    function decodeUtf8Lenient(b) {
+      return tdUtf8Lenient.decode(b);
+    }
+    function decodeLatin1(bytes) {
+      return tdLatin1.decode(bytes);
+    }
+    function pad10(n) {
+      return String(n).padStart(10, "0");
+    }
+    function hexLit(bytes) {
+      let s = "<";
+      for (let i = 0;i < bytes.length; i++)
+        s += "0123456789ABCDEF"[bytes[i] >> 4] + "0123456789ABCDEF"[bytes[i] & 15];
+      return s + ">";
+    }
+    function bytesEqual(a, b, n) {
+      if (!a || !b)
+        return !1;
+      if (n == null) {
+        if (a.length !== b.length)
+          return !1;
+        n = a.length;
+      } else if (a.length < n || b.length < n)
+        return !1;
+      let diff = 0;
+      for (let i = 0;i < n; i++)
+        diff |= a[i] ^ b[i];
+      return diff === 0;
+    }
+    function concatBytes(arrays) {
+      let total = 0;
+      for (const a of arrays)
+        total += a.length;
+      const out = new Uint8Array(total);
+      let o = 0;
+      for (const a of arrays) {
+        out.set(a, o);
+        o += a.length;
+      }
+      return out;
+    }
+    return {
+      HEADER_PREFIX,
+      EOF_MARKER,
+      BINARY_MARKER,
+      ASCII,
+      isWs,
+      isEol,
+      isDigit,
+      isHex,
+      isDelim,
+      isRegular,
+      hexNibble,
+      HEX_LO,
+      te,
+      tdUtf8,
+      tdUtf8Lenient,
+      tdLatin1,
+      encodeAscii,
+      decodeUtf8,
+      decodeUtf8Lenient,
+      decodeLatin1,
+      pad10,
+      hexLit,
+      bytesEqual,
+      concatBytes
+    };
+  } });
+    __register({ name: "pdfTokenizer", dependencies: ["pdfErrors","pdfShared"], factory: function(errors, shared) {
+    const { ParseError } = errors, { ASCII, isWs, isEol, isDigit, isRegular, hexNibble } = shared, {
+      HT,
+      LF,
+      CR,
+      FF,
+      LPAREN,
+      RPAREN,
+      LANGLE,
+      RANGLE,
+      LBRACK,
+      RBRACK,
+      SLASH,
+      PERCENT,
+      BACKSLASH,
+      PLUS,
+      MINUS,
+      DOT,
+      ZERO,
+      HASH
+    } = ASCII;
+    function tokenize(bytes, opts) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/tokenizer/bad-input", "tokenize() expects a Uint8Array", { context: { typeof: typeof bytes } });
+      const keepWs = !!(opts && opts.keepWhitespace);
+      let i = opts && opts.start | 0 || 0;
+      const N = opts && Number.isFinite(opts.end) ? Math.min(opts.end | 0, bytes.length) : bytes.length;
+      let lookahead = null;
+      function pos() {
+        return i;
+      }
+      function seek(n) {
+        if (n < 0 || n > bytes.length)
+          throw new ParseError("pdf/tokenizer/bad-seek", "seek out of range", { context: { offset: n, total: bytes.length } });
+        i = n;
+        lookahead = null;
+      }
+      function readName() {
+        const start = i;
+        i++;
+        const out = [];
+        while (i < N) {
+          const b = bytes[i];
+          if (!isRegular(b))
+            break;
+          if (b === HASH) {
+            if (i + 2 >= N)
+              throw new ParseError("pdf/tokenizer/bad-name-escape", "truncated #xx escape in name", { context: { offset: i } });
+            const hi = hexNibble(bytes[i + 1]), lo = hexNibble(bytes[i + 2]);
+            if (hi < 0 || lo < 0)
+              throw new ParseError("pdf/tokenizer/bad-name-escape", "invalid hex digits in name escape", { context: { offset: i } });
+            out.push(hi << 4 | lo);
+            i += 3;
+          } else {
+            out.push(b);
+            i++;
+          }
+        }
+        return { kind: "name", value: new TextDecoder("utf-8", { fatal: !1 }).decode(Uint8Array.from(out)), offset: start, end: i };
+      }
+      function readNumber() {
+        const start = i;
+        let isReal = !1;
+        if (bytes[i] === PLUS || bytes[i] === MINUS)
+          i++;
+        while (i < N) {
+          const b = bytes[i];
+          if (isDigit(b)) {
+            i++;
+            continue;
+          }
+          if (b === DOT && !isReal) {
+            isReal = !0;
+            i++;
+            continue;
+          }
+          break;
+        }
+        const raw = new TextDecoder("latin1").decode(bytes.subarray(start, i));
+        if (raw === "" || raw === "+" || raw === "-" || raw === ".")
+          throw new ParseError("pdf/tokenizer/bad-number", "empty number token", { context: { offset: start } });
+        const n = Number(raw);
+        if (!Number.isFinite(n))
+          throw new ParseError("pdf/tokenizer/bad-number", "cannot parse number", { context: { raw, offset: start } });
+        return { kind: isReal ? "real" : "int", value: n, offset: start, end: i, raw };
+      }
+      function readLiteralString() {
+        const start = i;
+        i++;
+        const out = [];
+        let depth = 1;
+        while (i < N && depth > 0) {
+          const b = bytes[i];
+          if (b === LPAREN) {
+            depth++;
+            out.push(b);
+            i++;
+            continue;
+          }
+          if (b === RPAREN) {
+            depth--;
+            if (depth === 0) {
+              i++;
+              break;
+            }
+            out.push(b);
+            i++;
+            continue;
+          }
+          if (b === BACKSLASH) {
+            if (i + 1 >= N)
+              throw new ParseError("pdf/tokenizer/bad-string", "trailing backslash in literal string", { context: { offset: i } });
+            const nxt = bytes[i + 1];
+            if (nxt === LF) {
+              i += 2;
+              continue;
+            }
+            if (nxt === CR) {
+              i += 2;
+              if (i < N && bytes[i] === LF)
+                i++;
+              continue;
+            }
+            if (nxt === 110) {
+              out.push(LF);
+              i += 2;
+              continue;
+            }
+            if (nxt === 114) {
+              out.push(CR);
+              i += 2;
+              continue;
+            }
+            if (nxt === 116) {
+              out.push(HT);
+              i += 2;
+              continue;
+            }
+            if (nxt === 98) {
+              out.push(8);
+              i += 2;
+              continue;
+            }
+            if (nxt === 102) {
+              out.push(FF);
+              i += 2;
+              continue;
+            }
+            if (nxt === LPAREN || nxt === RPAREN || nxt === BACKSLASH) {
+              out.push(nxt);
+              i += 2;
+              continue;
+            }
+            if (nxt >= ZERO && nxt <= ZERO + 7) {
+              let v = 0, k = 0;
+              i++;
+              while (k < 3 && i < N && bytes[i] >= ZERO && bytes[i] <= ZERO + 7) {
+                v = v << 3 | bytes[i] - ZERO;
+                i++;
+                k++;
+              }
+              out.push(v & 255);
+              continue;
+            }
+            i++;
+            continue;
+          }
+          if (b === CR) {
+            out.push(LF);
+            i++;
+            if (i < N && bytes[i] === LF)
+              i++;
+            continue;
+          }
+          out.push(b);
+          i++;
+        }
+        if (depth !== 0)
+          throw new ParseError("pdf/tokenizer/unterminated-string", "literal string was not closed", { context: { offset: start } });
+        return { kind: "string", value: Uint8Array.from(out), offset: start, end: i };
+      }
+      function readHexString() {
+        const start = i;
+        i++;
+        const nibbles = [];
+        while (i < N) {
+          const b = bytes[i];
+          if (b === RANGLE) {
+            i++;
+            break;
+          }
+          if (isWs(b)) {
+            i++;
+            continue;
+          }
+          const v = hexNibble(b);
+          if (v < 0)
+            throw new ParseError("pdf/tokenizer/bad-hex", "non-hex byte in hex string", { context: { offset: i, byte: b } });
+          nibbles.push(v);
+          i++;
+        }
+        if (nibbles.length % 2 === 1)
+          nibbles.push(0);
+        const out = new Uint8Array(nibbles.length / 2);
+        for (let k = 0;k < out.length; k++)
+          out[k] = nibbles[2 * k] << 4 | nibbles[2 * k + 1];
+        return { kind: "hex", value: out, offset: start, end: i };
+      }
+      function readKeyword() {
+        const start = i;
+        while (i < N && isRegular(bytes[i]))
+          i++;
+        const raw = new TextDecoder("latin1").decode(bytes.subarray(start, i));
+        if (raw === "")
+          throw new ParseError("pdf/tokenizer/empty-keyword", "empty keyword", { context: { offset: start } });
+        return { kind: "kw", value: raw, offset: start, end: i };
+      }
+      function next() {
+        if (lookahead) {
+          const t = lookahead;
+          lookahead = null;
+          return t;
+        }
+        while (i < N) {
+          const b = bytes[i];
+          if (isWs(b)) {
+            if (keepWs) {
+              const start = i;
+              while (i < N && isWs(bytes[i]))
+                i++;
+              return { kind: "ws", offset: start, end: i };
+            }
+            i++;
+            continue;
+          }
+          if (b === PERCENT) {
+            if (i + 4 < N && bytes[i + 1] === PERCENT && bytes[i + 2] === 69 && bytes[i + 3] === 79 && bytes[i + 4] === 70) {
+              const start = i;
+              i += 5;
+              return { kind: "eof_marker", offset: start, end: i };
+            }
+            while (i < N && !isEol(bytes[i]))
+              i++;
+            if (i < N && bytes[i] === CR)
+              i++;
+            if (i < N && bytes[i] === LF)
+              i++;
+            continue;
+          }
+          break;
+        }
+        if (i >= N)
+          return null;
+        const b = bytes[i];
+        if (b === SLASH)
+          return readName();
+        if (b === LBRACK)
+          return { kind: "open_arr", offset: i++, end: i };
+        if (b === RBRACK)
+          return { kind: "close_arr", offset: i++, end: i };
+        if (b === LANGLE) {
+          if (i + 1 < N && bytes[i + 1] === LANGLE) {
+            const off = i;
+            i += 2;
+            return { kind: "open_dict", offset: off, end: i };
+          }
+          return readHexString();
+        }
+        if (b === RANGLE) {
+          if (i + 1 < N && bytes[i + 1] === RANGLE) {
+            const off = i;
+            i += 2;
+            return { kind: "close_dict", offset: off, end: i };
+          }
+          throw new ParseError("pdf/tokenizer/unexpected-rangle", "lone > outside hex string", { context: { offset: i } });
+        }
+        if (b === LPAREN)
+          return readLiteralString();
+        if (b === PLUS || b === MINUS || b === DOT || isDigit(b))
+          return readNumber();
+        return readKeyword();
+      }
+      function peek() {
+        if (!lookahead)
+          lookahead = next();
+        return lookahead;
+      }
+      return { next, peek, pos, seek, bytes };
+    }
+    function lastIndexOfBytes(bytes, needle, from) {
+      const N = bytes.length, M = needle.length;
+      if (M === 0 || M > N)
+        return -1;
+      let start = Number.isFinite(from) ? Math.min(from | 0, N - M) : N - M;
+      outer:
+        for (let i = start;i >= 0; i--) {
+          for (let k = 0;k < M; k++)
+            if (bytes[i + k] !== needle[k])
+              continue outer;
+          return i;
+        }
+      return -1;
+    }
+    return { tokenize, lastIndexOfBytes };
+  } });
+    __register({ name: "pdfParserObj", dependencies: [], factory: function() {
+    const obj = {
+      nul: () => ({ type: "null" }),
+      bool: (v) => ({ type: "bool", value: !!v }),
+      int: (v) => ({ type: "int", value: v | 0 }),
+      real: (v) => ({ type: "real", value: +v }),
+      name: (s) => ({ type: "name", value: String(s) }),
+      string: (bytes, syntax) => ({
+        type: "string",
+        value: bytes,
+        syntax: syntax === "hex" ? "hex" : "lit"
+      }),
+      array: (items) => ({ type: "array", items: items || [] }),
+      dict: (entries) => ({ type: "dict", entries: entries || {} }),
+      ref: (num, gen) => ({ type: "ref", num: num | 0, gen: gen | 0 || 0 }),
+      stream: (dict, raw) => ({ type: "stream", dict, raw })
+    };
+    function getEntry(dict, key) {
+      if (!dict || dict.type !== "dict")
+        return;
+      return dict.entries[key];
+    }
+    function isType(v, kind) {
+      return !!(v && v.type === kind);
+    }
+    return { obj, getEntry, isType };
+  } });
+    __register({ name: "pdfParser", dependencies: ["pdfErrors","pdfParserObj","pdfTokenizer"], factory: function(errors, parserObj, tokenizerMod) {
+    const { ParseError } = errors, { obj, getEntry, isType } = parserObj, tokenize = tokenizerMod.tokenize;
+    function resolveStreamLength(streamDict, resolveRef) {
+      const e = streamDict.entries && streamDict.entries.Length;
+      if (!e)
+        return -1;
+      if (e.type === "int")
+        return e.value;
+      if (e.type === "ref" && typeof resolveRef === "function") {
+        const r = resolveRef(e);
+        if (r && r.type === "int")
+          return r.value;
+      }
+      return -1;
+    }
+    function findEndstream(bytes, from, quota) {
+      const needle = [101, 110, 100, 115, 116, 114, 101, 97, 109], lim = Math.min(bytes.length, from + (quota | 0));
+      outer:
+        for (let i = from;i + needle.length <= lim; i++) {
+          for (let k = 0;k < needle.length; k++)
+            if (bytes[i + k] !== needle[k])
+              continue outer;
+          let end = i;
+          if (end > from && bytes[end - 1] === 10)
+            end--;
+          if (end > from && bytes[end - 1] === 13)
+            end--;
+          return end;
+        }
+      return -1;
+    }
+    function skipEolWs(tok) {
+      const b = tok.bytes;
+      let p = tok.pos();
+      while (p < b.length) {
+        const c = b[p];
+        if (c === 32 || c === 9 || c === 10 || c === 13)
+          p++;
+        else
+          break;
+      }
+      tok.seek(p);
+    }
+    const parserLimits = {
+      maxDepth: 200,
+      maxArrayLen: 1e6,
+      maxStreamBytes: 268435456
+    };
+    function setParserLimits(partial) {
+      if (partial && typeof partial === "object") {
+        if (Number.isInteger(partial.maxDepth) && partial.maxDepth > 0)
+          parserLimits.maxDepth = partial.maxDepth;
+        if (Number.isInteger(partial.maxArrayLen) && partial.maxArrayLen > 0)
+          parserLimits.maxArrayLen = partial.maxArrayLen;
+        if (Number.isInteger(partial.maxStreamBytes) && partial.maxStreamBytes > 0)
+          parserLimits.maxStreamBytes = partial.maxStreamBytes;
+      }
+      return parserLimits;
+    }
+    function parseObject(tok) {
+      const t = tok.next();
+      if (!t)
+        throw new ParseError("pdf/parser/eof", "unexpected end of input");
+      return continueParse(tok, t, 0);
+    }
+    function continueParse(tok, t, depth) {
+      if (depth > parserLimits.maxDepth)
+        throw new ParseError("pdf/parser/depth-exceeded", "parser depth limit exceeded", { context: {
+          depth,
+          limit: parserLimits.maxDepth,
+          offset: t && t.offset
+        } });
+      switch (t.kind) {
+        case "kw":
+          if (t.value === "null")
+            return { type: "null" };
+          if (t.value === "true")
+            return { type: "bool", value: !0 };
+          if (t.value === "false")
+            return { type: "bool", value: !1 };
+          throw new ParseError("pdf/parser/unexpected-keyword", `unexpected keyword "${t.value}"`, { context: { offset: t.offset, keyword: t.value } });
+        case "name":
+          return { type: "name", value: t.value };
+        case "string":
+          return { type: "string", value: t.value, syntax: "lit" };
+        case "hex":
+          return { type: "string", value: t.value, syntax: "hex" };
+        case "int":
+          return tryReadRef(tok, t);
+        case "real":
+          return { type: "real", value: t.value };
+        case "open_arr":
+          return readArray(tok, t.offset, depth);
+        case "open_dict":
+          return readDict(tok, t.offset, depth);
+        case "close_arr":
+        case "close_dict":
+          throw new ParseError("pdf/parser/unbalanced", `unexpected ${t.kind}`, { context: { offset: t.offset } });
+        default:
+          throw new ParseError("pdf/parser/unexpected-token", `unexpected token of kind "${t.kind}"`, { context: { offset: t.offset, kind: t.kind } });
+      }
+    }
+    function tryReadRef(tok, intTok) {
+      const at = tok.pos(), p1 = tok.peek();
+      if (!p1 || p1.kind !== "int")
+        return { type: "int", value: intTok.value };
+      tok.next();
+      const p2 = tok.peek();
+      if (p2 && p2.kind === "kw" && p2.value === "R") {
+        tok.next();
+        return { type: "ref", num: intTok.value | 0, gen: p1.value | 0 };
+      }
+      tok.seek(at);
+      return { type: "int", value: intTok.value };
+    }
+    function readArray(tok, startOff, depth) {
+      const items = [];
+      for (;; ) {
+        const p = tok.peek();
+        if (!p)
+          throw new ParseError("pdf/parser/unterminated-array", "array not closed", { context: { offset: startOff } });
+        if (p.kind === "close_arr") {
+          tok.next();
+          return { type: "array", items };
+        }
+        if (items.length >= parserLimits.maxArrayLen)
+          throw new ParseError("pdf/parser/array-too-long", "array exceeds parserLimits.maxArrayLen", { context: {
+            length: items.length,
+            limit: parserLimits.maxArrayLen,
+            offset: startOff
+          } });
+        const sub = tok.next();
+        items.push(continueParse(tok, sub, (depth | 0) + 1));
+      }
+    }
+    function readDict(tok, startOff, depth) {
+      const entries = {};
+      for (;; ) {
+        const p = tok.peek();
+        if (!p)
+          throw new ParseError("pdf/parser/unterminated-dict", "dict not closed", { context: { offset: startOff } });
+        if (p.kind === "close_dict") {
+          tok.next();
+          return { type: "dict", entries };
+        }
+        if (p.kind !== "name")
+          throw new ParseError("pdf/parser/dict-key-not-name", "expected /Name as dict key", { context: { offset: p.offset, kind: p.kind } });
+        const keyTok = tok.next(), sub = tok.next();
+        if (!sub)
+          throw new ParseError("pdf/parser/eof", "unexpected end of input");
+        const value = continueParse(tok, sub, (depth | 0) + 1);
+        entries[keyTok.value] = value;
+      }
+    }
+    function parseIndirect(tok, resolveRef) {
+      const t1 = tok.next();
+      if (!t1 || t1.kind !== "int")
+        throw new ParseError("pdf/parser/indirect-bad-num", "expected object number", { context: { offset: t1 ? t1.offset : tok.pos() } });
+      const t2 = tok.next();
+      if (!t2 || t2.kind !== "int")
+        throw new ParseError("pdf/parser/indirect-bad-gen", "expected generation number", { context: { offset: t2 ? t2.offset : tok.pos() } });
+      const t3 = tok.next();
+      if (!t3 || t3.kind !== "kw" || t3.value !== "obj")
+        throw new ParseError("pdf/parser/indirect-missing-obj", "expected obj keyword", { context: { offset: t3 ? t3.offset : tok.pos() } });
+      const value = parseObject(tok);
+      let body = value;
+      const after = tok.peek();
+      if (value.type === "dict" && after && after.kind === "kw" && after.value === "stream") {
+        tok.next();
+        const bytes = tok.bytes;
+        let p = tok.pos();
+        if (p < bytes.length && bytes[p] === 13)
+          p++;
+        if (p < bytes.length && bytes[p] === 10)
+          p++;
+        tok.seek(p);
+        const dataStart = tok.pos(), length = resolveStreamLength(value, resolveRef);
+        let dataEnd;
+        if (Number.isFinite(length) && length >= 0 && dataStart + length <= bytes.length)
+          dataEnd = dataStart + length;
+        else {
+          dataEnd = findEndstream(bytes, dataStart, parserLimits.maxStreamBytes);
+          if (dataEnd < 0)
+            throw new ParseError("pdf/parser/stream/no-endstream", "cannot locate endstream within quota", { context: {
+              offset: dataStart,
+              num: t1.value,
+              gen: t2.value,
+              quota: parserLimits.maxStreamBytes
+            } });
+        }
+        const raw = bytes.subarray(dataStart, dataEnd);
+        tok.seek(dataEnd);
+        skipEolWs(tok);
+        const endTok = tok.next();
+        if (!endTok || endTok.kind !== "kw" || endTok.value !== "endstream")
+          throw new ParseError("pdf/parser/stream/expected-endstream", "expected endstream", { context: { offset: endTok ? endTok.offset : tok.pos() } });
+        body = { type: "stream", dict: value, raw };
+      }
+      const endObj = tok.next();
+      if (!endObj || endObj.kind !== "kw" || endObj.value !== "endobj")
+        throw new ParseError("pdf/parser/indirect-missing-endobj", "expected endobj", { context: {
+          offset: endObj ? endObj.offset : tok.pos(),
+          num: t1.value,
+          gen: t2.value
+        } });
+      return { num: t1.value, gen: t2.value, value: body };
+    }
+    function parseFromBytes(bytes) {
+      const tok = tokenize(bytes);
+      return parseObject(tok);
+    }
+    function parseIndirectFromBytes(bytes, at, resolveRef) {
+      const tok = tokenize(bytes, { start: at | 0 });
+      return parseIndirect(tok, resolveRef);
+    }
+    return {
+      tokenize,
+      parseObject,
+      parseIndirect,
+      parseFromBytes,
+      parseIndirectFromBytes,
+      parserLimits,
+      setParserLimits,
+      obj,
+      getEntry,
+      isType
+    };
+  } });
+    __register({ name: "pdfXref", dependencies: ["pdfErrors","pdfTokenizer","pdfParser"], factory: function(errors, tokenizerMod, parserMod) {
+    const { ParseError, RenderError } = errors, tokenize = tokenizerMod.tokenize, lastIndexOfBytes = tokenizerMod.lastIndexOfBytes, parseObject = parserMod.parseObject;
+    function locateStartXref(bytes) {
+      const tail = Math.max(0, bytes.length - 8192), idx = lastIndexOfBytes(bytes, new Uint8Array([115, 116, 97, 114, 116, 120, 114, 101, 102]), bytes.length);
+      if (idx < tail)
+        return -1;
+      return idx;
+    }
+    function readStartXref(bytes, at) {
+      const tok = tokenize(bytes, { start: at }), kw = tok.next();
+      if (!kw || kw.kind !== "kw" || kw.value !== "startxref")
+        throw new ParseError("pdf/xref/no-startxref", "startxref keyword not found", { context: { offset: at } });
+      const num = tok.next();
+      if (!num || num.kind !== "int" || num.value < 0)
+        throw new ParseError("pdf/xref/bad-startxref", "startxref must be followed by a non-negative integer", { context: { offset: at } });
+      return num.value;
+    }
+    function parseIntBytes(bytes, off, len) {
+      let n = 0;
+      for (let i = 0;i < len; i++) {
+        const b = bytes[off + i];
+        if (b < 48 || b > 57)
+          throw new ParseError("pdf/xref/bad-digit", "expected ASCII digit in xref entry", { context: { offset: off + i, byte: b } });
+        n = n * 10 + (b - 48);
+      }
+      return n;
+    }
+    function parseXrefTable(bytes, at) {
+      const tok = tokenize(bytes, { start: at }), kw = tok.next();
+      if (!kw || kw.kind !== "kw" || kw.value !== "xref")
+        throw new ParseError("pdf/xref/no-xref-keyword", "expected xref keyword", { context: { offset: at } });
+      const entries = {};
+      for (;; ) {
+        const first = tok.peek();
+        if (!first || first.kind !== "int") {
+          if (first)
+            tok.seek(first.offset);
+          break;
+        }
+        tok.next();
+        const cnt = tok.next();
+        if (!cnt || cnt.kind !== "int" || cnt.value < 0)
+          throw new ParseError("pdf/xref/bad-subsection-header", "xref subsection header must be `<first> <count>`", { context: { offset: first.offset } });
+        let p = tok.pos();
+        if (p < bytes.length && bytes[p] === 13)
+          p++;
+        if (p < bytes.length && bytes[p] === 10)
+          p++;
+        for (let k = 0;k < cnt.value; k++) {
+          if (p + 20 > bytes.length)
+            throw new ParseError("pdf/xref/truncated-entry", "truncated xref entry", { context: { offset: p, expected: 20 } });
+          const off = parseIntBytes(bytes, p, 10);
+          if (bytes[p + 10] !== 32)
+            throw new ParseError("pdf/xref/bad-entry-format", "xref entry missing space at col 10", { context: { offset: p } });
+          const gen = parseIntBytes(bytes, p + 11, 5);
+          if (bytes[p + 16] !== 32)
+            throw new ParseError("pdf/xref/bad-entry-format", "xref entry missing space at col 16", { context: { offset: p } });
+          const tag = bytes[p + 17];
+          if (tag !== 110 && tag !== 102)
+            throw new ParseError("pdf/xref/bad-entry-flag", "xref entry flag must be n or f", { context: { offset: p, byte: tag } });
+          entries[first.value + k] = {
+            offset: off,
+            gen,
+            free: tag === 102
+          };
+          p += 20;
+        }
+        tok.seek(p);
+      }
+      return { entries, end: tok.pos() };
+    }
+    function parseTrailerDict(bytes, at) {
+      const tok = tokenize(bytes, { start: at }), kw = tok.next();
+      if (!kw || kw.kind !== "kw" || kw.value !== "trailer")
+        throw new ParseError("pdf/xref/no-trailer", "expected trailer keyword", { context: { offset: at } });
+      const dict = parseObject(tok);
+      if (dict.type !== "dict")
+        throw new ParseError("pdf/xref/trailer-not-dict", "trailer must be a dictionary", { context: { offset: at } });
+      return { dict, end: tok.pos() };
+    }
+    function readXrefStreamDict(bytes, at) {
+      const notStream = (why) => new ParseError("pdf/xref/not-xref-stream", `no cross-reference stream at offset ${at}: ${why}`, { context: { offset: at } });
+      if (!Number.isInteger(at) || at < 0 || at >= bytes.length)
+        throw notStream("offset outside the file");
+      let num, gen, kw, dict, after;
+      try {
+        const tok = tokenize(bytes, { start: at });
+        num = tok.next();
+        gen = tok.next();
+        kw = tok.next();
+        if (!num || num.kind !== "int" || !gen || gen.kind !== "int" || !kw || kw.kind !== "kw" || kw.value !== "obj")
+          throw notStream("no indirect object header");
+        dict = parseObject(tok);
+        after = tok.peek();
+      } catch (e) {
+        if (e && e.code === "pdf/xref/not-xref-stream")
+          throw e;
+        throw notStream("the object does not parse");
+      }
+      const type = dict && dict.type === "dict" && dict.entries.Type;
+      if (!type || type.type !== "name" || type.value !== "XRef" || !after || after.kind !== "kw" || after.value !== "stream")
+        throw notStream("the object is not a /Type /XRef stream");
+      return { num: num.value, gen: gen.value, dict };
+    }
+    function byteWidth(n) {
+      let w = 1;
+      while (n > 255) {
+        n = Math.floor(n / 256);
+        w++;
+      }
+      return w;
+    }
+    function hexLit(bytes) {
+      let s = "<";
+      for (let i = 0;i < bytes.length; i++)
+        s += "0123456789ABCDEF"[bytes[i] >> 4] + "0123456789ABCDEF"[bytes[i] & 15];
+      return s + ">";
+    }
+    function isRef(r) {
+      return !!r && Number.isInteger(r.num) && r.num >= 1;
+    }
+    function buildXrefStream(opts) {
+      const bad = (why) => new RenderError("pdf/xref/bad-stream-section", `cannot build the cross-reference stream: ${why}`);
+      if (!opts || !Number.isInteger(opts.num) || opts.num < 1)
+        throw bad("num must be an integer >= 1");
+      if (!Number.isInteger(opts.offset) || opts.offset < 0)
+        throw bad("offset must be an integer >= 0");
+      if (!Number.isInteger(opts.prev) || opts.prev < 0)
+        throw bad("prev must be an integer >= 0");
+      if (!isRef(opts.root))
+        throw bad("root must be { num >= 1, gen }");
+      if (opts.encrypt != null && !isRef(opts.encrypt))
+        throw bad("encrypt must be an indirect reference { num >= 1, gen }");
+      const rows = new Map;
+      rows.set(0, [0, 0, 65535]);
+      for (const e of opts.entries || []) {
+        if (!e || !Number.isInteger(e.num) || e.num < 1 || !Number.isInteger(e.offset) || e.offset < 0)
+          throw bad("each entry needs num >= 1 and offset >= 0");
+        rows.set(e.num, [1, e.offset, e.gen | 0]);
+      }
+      rows.set(opts.num, [1, opts.offset, 0]);
+      const nums = Array.from(rows.keys()).sort((a, b) => a - b);
+      let max2 = 0, max3 = 0;
+      for (const r of rows.values()) {
+        if (r[1] > max2)
+          max2 = r[1];
+        if (r[2] > max3)
+          max3 = r[2];
+      }
+      const w = [1, byteWidth(max2), byteWidth(max3)], rec = w[0] + w[1] + w[2], data = new Uint8Array(nums.length * rec);
+      let o = 0;
+      for (const n of nums) {
+        const r = rows.get(n);
+        let at = o;
+        for (let f = 0;f < 3; f++) {
+          let v = r[f];
+          for (let k = w[f] - 1;k >= 0; k--) {
+            data[at + k] = v & 255;
+            v = Math.floor(v / 256);
+          }
+          at += w[f];
+        }
+        o += rec;
+      }
+      const index = [];
+      for (let i = 0;i < nums.length; ) {
+        let j = i;
+        while (j + 1 < nums.length && nums[j + 1] === nums[j] + 1)
+          j++;
+        index.push(`${nums[i]} ${j - i + 1}`);
+        i = j + 1;
+      }
+      let d = `<< /Type /XRef /Size ${Math.max(opts.num + 1, Number.isInteger(opts.size) ? opts.size : 0)} /W [${w.join(" ")}] /Index [${index.join(" ")}] /Root ${opts.root.num} ${opts.root.gen | 0} R`;
+      if (isRef(opts.info))
+        d += ` /Info ${opts.info.num} ${opts.info.gen | 0} R`;
+      if (opts.id && opts.id[0] instanceof Uint8Array && opts.id[1] instanceof Uint8Array)
+        d += ` /ID [${hexLit(opts.id[0])}${hexLit(opts.id[1])}]`;
+      if (isRef(opts.encrypt))
+        d += ` /Encrypt ${opts.encrypt.num} ${opts.encrypt.gen | 0} R`;
+      d += ` /Prev ${opts.prev} /Length ${data.length} >>`;
+      const te = new TextEncoder, head = te.encode(`${opts.num} 0 obj
+${d}
+stream
+`), tail = te.encode(`
+endstream
+endobj
+`), out = new Uint8Array(head.length + data.length + tail.length);
+      out.set(head, 0);
+      out.set(data, head.length);
+      out.set(tail, head.length + data.length);
+      return out;
+    }
+    return {
+      locateStartXref,
+      readStartXref,
+      parseXrefTable,
+      parseTrailerDict,
+      readXrefStreamDict,
+      buildXrefStream
+    };
+  } });
+    __register({ name: "pdfTrailer", dependencies: ["pdfErrors","pdfParserObj"], factory: function(errors, parserObj) {
+    const { ParseError } = errors, { isType } = parserObj;
+    function typeTrailer(dict) {
+      if (!isType(dict, "dict"))
+        throw new ParseError("pdf/trailer/not-dict", "trailer is not a dictionary", { context: { type: dict && dict.type } });
+      const e = dict.entries, size = e.Size;
+      if (!size || size.type !== "int" || size.value < 0)
+        throw new ParseError("pdf/trailer/missing-size", "trailer is missing required /Size entry", { context: { hasSize: !!size } });
+      const root = e.Root;
+      if (!root || root.type !== "ref")
+        throw new ParseError("pdf/trailer/missing-root", "trailer is missing required /Root indirect reference", { context: { hasRoot: !!root, type: root && root.type } });
+      const out = {
+        size: size.value,
+        root: { num: root.num, gen: root.gen },
+        raw: dict
+      };
+      if (e.Info && e.Info.type === "ref")
+        out.info = { num: e.Info.num, gen: e.Info.gen };
+      if (e.Prev && e.Prev.type === "int")
+        out.prev = e.Prev.value;
+      if (e.Encrypt)
+        out.encrypt = e.Encrypt.type === "ref" ? { num: e.Encrypt.num, gen: e.Encrypt.gen } : e.Encrypt;
+      if (e.ID && e.ID.type === "array" && e.ID.items.length === 2 && e.ID.items[0].type === "string" && e.ID.items[1].type === "string")
+        out.id = [e.ID.items[0].value, e.ID.items[1].value];
+      return out;
+    }
+    return { typeTrailer };
+  } });
+    __register({ name: "pdfSerializer", dependencies: ["pdfErrors"], factory: function(errors) {
+    const { RenderError } = errors, te = new TextEncoder;
+    function serializeObject(obj) {
+      if (!obj || typeof obj.type !== "string")
+        throw new RenderError("pdf/serializer/bad-input", "serializeObject expects a typed object", { context: { typeof: typeof obj } });
+      return concat(emitObject(obj));
+    }
+    function serializeIndirect(num, gen, body) {
+      if (!Number.isFinite(num) || num < 0)
+        throw new RenderError("pdf/serializer/bad-num", "object number must be a non-negative integer", { context: { num } });
+      if (!Number.isFinite(gen) || gen < 0)
+        throw new RenderError("pdf/serializer/bad-gen", "generation number must be a non-negative integer", { context: { gen } });
+      const head = te.encode(`${num | 0} ${gen | 0} obj
+`), tail = te.encode(`
+endobj
+`);
+      if (body && body.type === "stream") {
+        const raw = body.raw instanceof Uint8Array ? body.raw : new Uint8Array(0), updated = {
+          type: "dict",
+          entries: {
+            ...(body.dict || { type: "dict", entries: {} }).entries,
+            Length: { type: "int", value: raw.length }
+          }
+        }, dictBytes = concat(emitObject(updated)), streamHead = te.encode(`
+stream
+`), streamTail = te.encode(`
+endstream`);
+        return concatU8([head, dictBytes, streamHead, raw, streamTail, tail]);
+      }
+      return concatU8([head, concat(emitObject(body)), tail]);
+    }
+    function formatReal(n) {
+      if (!Number.isFinite(n))
+        throw new RenderError("pdf/serializer/bad-real", "real number must be finite", { context: { value: n } });
+      if (Number.isInteger(n))
+        return `${n}`;
+      let s = n.toFixed(5);
+      if (s.indexOf(".") >= 0) {
+        s = s.replace(/0+$/, "");
+        if (s.endsWith("."))
+          s = s.slice(0, -1);
+      }
+      if (s === "-0")
+        s = "0";
+      return s;
+    }
+    function emitObject(o) {
+      switch (o.type) {
+        case "null":
+          return ["null"];
+        case "bool":
+          return [o.value ? "true" : "false"];
+        case "int":
+          return [`${o.value | 0}`];
+        case "real":
+          return [formatReal(o.value)];
+        case "name":
+          return [emitName(o.value)];
+        case "string":
+          return [emitString(o)];
+        case "array":
+          return emitArray(o);
+        case "dict":
+          return emitDict(o);
+        case "ref":
+          return [`${o.num | 0} ${o.gen | 0} R`];
+        case "stream":
+          throw new RenderError("pdf/serializer/inline-stream", "stream objects must be serialized via serializeIndirect");
+        default:
+          throw new RenderError("pdf/serializer/unknown-type", `unknown object type "${o.type}"`, { context: { type: o.type } });
+      }
+    }
+    function emitName(value) {
+      let out = "/";
+      for (let i = 0;i < value.length; i++) {
+        const cp = value.codePointAt(i);
+        if (cp > 65535)
+          i++;
+        if (cp < 33 || cp > 126 || cp === 35 || cp === 47 || cp === 40 || cp === 41 || cp === 60 || cp === 62 || cp === 91 || cp === 93 || cp === 123 || cp === 125 || cp === 37) {
+          const enc = te.encode(String.fromCodePoint(cp));
+          for (const b of enc)
+            out += "#" + b.toString(16).padStart(2, "0").toUpperCase();
+        } else
+          out += String.fromCharCode(cp);
+      }
+      return out;
+    }
+    function emitString(o) {
+      const bytes = o.value;
+      if (!(bytes instanceof Uint8Array))
+        throw new RenderError("pdf/serializer/bad-string", "string value must be Uint8Array", { context: { typeof: typeof bytes } });
+      if (o.syntax === "hex" || shouldUseHex(bytes))
+        return emitHexString(bytes);
+      return emitLiteralString(bytes);
+    }
+    function shouldUseHex(bytes) {
+      let bad = 0;
+      for (let i = 0;i < bytes.length; i++) {
+        const b = bytes[i];
+        if (b < 9 || b > 13 && b < 32 || b >= 127)
+          bad++;
+        if (bad > bytes.length / 4)
+          return !0;
+      }
+      return !1;
+    }
+    function emitLiteralString(bytes) {
+      const out = ["("];
+      for (let i = 0;i < bytes.length; i++) {
+        const b = bytes[i];
+        if (b === 92)
+          out.push("\\\\");
+        else if (b === 40)
+          out.push("\\(");
+        else if (b === 41)
+          out.push("\\)");
+        else if (b === 10)
+          out.push("\\n");
+        else if (b === 13)
+          out.push("\\r");
+        else if (b === 9)
+          out.push("\\t");
+        else if (b === 8)
+          out.push("\\b");
+        else if (b === 12)
+          out.push("\\f");
+        else if (b < 32 || b > 126)
+          out.push("\\" + b.toString(8).padStart(3, "0"));
+        else
+          out.push(String.fromCharCode(b));
+      }
+      out.push(")");
+      return out.join("");
+    }
+    function emitHexString(bytes) {
+      let s = "<";
+      for (let i = 0;i < bytes.length; i++)
+        s += "0123456789ABCDEF"[bytes[i] >> 4] + "0123456789ABCDEF"[bytes[i] & 15];
+      return s + ">";
+    }
+    function emitArray(o) {
+      const parts = ["["];
+      let first = !0;
+      for (const it of o.items) {
+        if (!first)
+          parts.push(" ");
+        first = !1;
+        for (const p of emitObject(it))
+          parts.push(p);
+      }
+      parts.push("]");
+      return parts;
+    }
+    function emitDict(o) {
+      const parts = ["<<"];
+      for (const k of Object.keys(o.entries)) {
+        parts.push(" ");
+        parts.push(emitName(k));
+        parts.push(" ");
+        for (const p of emitObject(o.entries[k]))
+          parts.push(p);
+      }
+      parts.push(" >>");
+      return parts;
+    }
+    function concat(parts) {
+      let s = "";
+      for (const p of parts)
+        s += p;
+      return te.encode(s);
+    }
+    function concatU8(arrays) {
+      let n = 0;
+      for (const a of arrays)
+        n += a.length;
+      const out = new Uint8Array(n);
+      let o = 0;
+      for (const a of arrays) {
+        out.set(a, o);
+        o += a.length;
+      }
+      return out;
+    }
+    return { serializeObject, serializeIndirect, formatReal };
+  } });
+    __register({ name: "pdfCatalog", dependencies: ["pdfErrors","pdfParser"], factory: function(errors, parserMod) {
+    const { ParseError } = errors, isType = parserMod && parserMod.isType || ((v, kind) => !!(v && v.type === kind)), KNOWN = new Set([
+      "Type",
+      "Version",
+      "Pages",
+      "PageLabels",
+      "Names",
+      "Dests",
+      "ViewerPreferences",
+      "PageLayout",
+      "PageMode",
+      "Outlines",
+      "Threads",
+      "OpenAction",
+      "AA",
+      "URI",
+      "AcroForm",
+      "Metadata",
+      "StructTreeRoot",
+      "MarkInfo",
+      "Lang",
+      "SpiderInfo",
+      "OutputIntents",
+      "PieceInfo",
+      "OCProperties",
+      "Perms",
+      "Legal",
+      "Requirements",
+      "Collection",
+      "NeedsRendering",
+      "DSS",
+      "AF",
+      "DPartRoot"
+    ]);
+    function typeCatalog(dict) {
+      if (!isType(dict, "dict"))
+        throw new ParseError("pdf/catalog/not-dict", "Catalog must be a dictionary", { context: { type: dict && dict.type } });
+      const e = dict.entries;
+      if (e.Type && (e.Type.type !== "name" || e.Type.value !== "Catalog"))
+        throw new ParseError("pdf/catalog/bad-type", "/Type entry must be /Catalog", { context: { actual: e.Type.value } });
+      if (!e.Pages || e.Pages.type !== "ref")
+        throw new ParseError("pdf/catalog/missing-pages", "Catalog is missing required /Pages reference", { context: { type: e.Pages && e.Pages.type } });
+      const out = {
+        pages: { num: e.Pages.num, gen: e.Pages.gen },
+        raw: dict,
+        _extras: {}
+      };
+      if (e.Version && e.Version.type === "name")
+        out.version = e.Version.value;
+      if (e.PageLayout && e.PageLayout.type === "name")
+        out.pageLayout = e.PageLayout.value;
+      if (e.PageMode && e.PageMode.type === "name")
+        out.pageMode = e.PageMode.value;
+      if (e.Lang && e.Lang.type === "string")
+        out.lang = e.Lang.value;
+      if (e.Outlines && e.Outlines.type === "ref")
+        out.outlines = e.Outlines;
+      if (e.Metadata && e.Metadata.type === "ref")
+        out.metadata = e.Metadata;
+      if (e.StructTreeRoot && e.StructTreeRoot.type === "ref")
+        out.structTreeRoot = e.StructTreeRoot;
+      if (e.AcroForm)
+        out.acroForm = e.AcroForm;
+      if (e.Names)
+        out.names = e.Names;
+      if (e.Dests)
+        out.dests = e.Dests;
+      if (e.ViewerPreferences)
+        out.viewerPrefs = e.ViewerPreferences;
+      if (e.PageLabels)
+        out.pageLabels = e.PageLabels;
+      if (e.MarkInfo)
+        out.markInfo = e.MarkInfo;
+      if (e.OCProperties)
+        out.ocProperties = e.OCProperties;
+      if (e.OutputIntents)
+        out.outputIntents = e.OutputIntents;
+      for (const k of Object.keys(e))
+        if (!KNOWN.has(k))
+          out._extras[k] = e[k];
+      return out;
+    }
+    return { typeCatalog };
+  } });
+    __register({ name: "pdfPages", dependencies: ["pdfErrors","pdfParser"], factory: function(errors, parserMod) {
+    const { ParseError } = errors, isType = parserMod && parserMod.isType || ((v, kind) => !!(v && v.type === kind));
+    function walkPageTree(rootRef, resolveRef, opts) {
+      const maxDepth = opts && opts.maxDepth || 64, maxPages = opts && opts.maxPages || 200000, out = [], visited = new Set;
+      walk(rootRef, 0);
+      return out;
+      function walk(ref, depth) {
+        if (depth > maxDepth)
+          throw new ParseError("pdf/pages/max-depth", "page tree depth limit exceeded", { context: { depth, maxDepth } });
+        const key = ref.num + ":" + ref.gen;
+        if (visited.has(key))
+          throw new ParseError("pdf/pages/cycle", "cycle detected in page tree", { context: { ref } });
+        visited.add(key);
+        const node = resolveRef({ type: "ref", num: ref.num, gen: ref.gen });
+        if (!isType(node, "dict"))
+          throw new ParseError("pdf/pages/not-dict", "page tree node is not a dict", { context: { ref } });
+        const t = node.entries.Type;
+        if (t && t.type === "name" && t.value === "Page" || !node.entries.Kids && !t) {
+          out.push({ num: ref.num, gen: ref.gen });
+          if (out.length > maxPages)
+            throw new ParseError("pdf/pages/too-many", "page count limit exceeded", { context: { maxPages } });
+          return;
+        }
+        const kids = node.entries.Kids;
+        if (!kids || kids.type !== "array")
+          throw new ParseError("pdf/pages/missing-kids", "intermediate page tree node missing /Kids array", { context: { ref, hasKids: !!kids } });
+        for (const k of kids.items) {
+          if (k.type !== "ref")
+            throw new ParseError("pdf/pages/non-ref-kid", "page tree /Kids entries must be indirect refs", { context: { kind: k.type } });
+          walk({ num: k.num, gen: k.gen }, depth + 1);
+        }
+      }
+    }
+    function readPageCount(node) {
+      if (!isType(node, "dict"))
+        return null;
+      const c = node.entries.Count;
+      if (!c || c.type !== "int" && c.type !== "real")
+        return null;
+      return c.value | 0;
+    }
+    return { walkPageTree, readPageCount };
+  } });
+    __register({ name: "pdfPage", dependencies: ["pdfErrors","pdfParser"], factory: function(errors, parserMod) {
+    const { ParseError } = errors, isType = parserMod && parserMod.isType || ((v, kind) => !!(v && v.type === kind)), KNOWN = new Set([
+      "Type",
+      "Parent",
+      "LastModified",
+      "Resources",
+      "MediaBox",
+      "CropBox",
+      "BleedBox",
+      "TrimBox",
+      "ArtBox",
+      "BoxColorInfo",
+      "Contents",
+      "Rotate",
+      "Group",
+      "Thumb",
+      "B",
+      "Dur",
+      "Trans",
+      "Annots",
+      "AA",
+      "Metadata",
+      "PieceInfo",
+      "StructParents",
+      "ID",
+      "PZ",
+      "SeparationInfo",
+      "Tabs",
+      "TemplateInstantiated",
+      "PresSteps",
+      "UserUnit",
+      "VP",
+      "AF",
+      "OutputIntents",
+      "DPart",
+      "AssociatedFiles"
+    ]);
+    function toBox(v) {
+      if (!v || v.type !== "array" || v.items.length !== 4)
+        return null;
+      const r = Array(4);
+      for (let i = 0;i < 4; i++) {
+        const it = v.items[i];
+        if (!it || it.type !== "int" && it.type !== "real")
+          return null;
+        r[i] = it.value;
+      }
+      return r;
+    }
+    function toRotate(v) {
+      if (!v || v.type !== "int" && v.type !== "real")
+        return 0;
+      const m = ((v.value | 0) % 360 + 360) % 360;
+      if (m % 90 !== 0)
+        return 0;
+      return m;
+    }
+    function toContentsRefs(v) {
+      if (!v)
+        return [];
+      if (v.type === "ref")
+        return [{ num: v.num, gen: v.gen }];
+      if (v.type === "array") {
+        const out = [];
+        for (const it of v.items)
+          if (it.type === "ref")
+            out.push({ num: it.num, gen: it.gen });
+        return out;
+      }
+      return [];
+    }
+    function toAnnots(v) {
+      if (!v)
+        return [];
+      if (v.type === "ref")
+        return [v];
+      if (v.type === "array")
+        return v.items.slice();
+      return [];
+    }
+    function typePage(dict) {
+      if (!isType(dict, "dict"))
+        throw new ParseError("pdf/page/not-dict", "Page must be a dictionary", { context: { type: dict && dict.type } });
+      const e = dict.entries;
+      if (e.Type && (e.Type.type !== "name" || e.Type.value !== "Page"))
+        throw new ParseError("pdf/page/bad-type", "/Type must be /Page when present", { context: { actual: e.Type.value } });
+      const out = {
+        parent: e.Parent && e.Parent.type === "ref" ? { num: e.Parent.num, gen: e.Parent.gen } : null,
+        mediaBox: toBox(e.MediaBox),
+        resources: e.Resources || null,
+        contents: toContentsRefs(e.Contents),
+        rotate: toRotate(e.Rotate),
+        annots: toAnnots(e.Annots),
+        raw: dict,
+        _extras: {}
+      };
+      if (e.CropBox)
+        out.cropBox = toBox(e.CropBox);
+      if (e.BleedBox)
+        out.bleedBox = toBox(e.BleedBox);
+      if (e.TrimBox)
+        out.trimBox = toBox(e.TrimBox);
+      if (e.ArtBox)
+        out.artBox = toBox(e.ArtBox);
+      if (e.UserUnit && e.UserUnit.type === "real")
+        out.userUnit = e.UserUnit.value;
+      if (e.UserUnit && e.UserUnit.type === "int")
+        out.userUnit = e.UserUnit.value;
+      if (e.Tabs && e.Tabs.type === "name")
+        out.tabs = e.Tabs.value;
+      if (e.Metadata)
+        out.metadata = e.Metadata;
+      if (e.Group)
+        out.group = e.Group;
+      for (const k of Object.keys(e))
+        if (!KNOWN.has(k))
+          out._extras[k] = e[k];
+      return out;
+    }
+    return { typePage };
+  } });
+    __register({ name: "pdfCrossRefStream", dependencies: ["pdfErrors","pdfParserObj"], factory: function(errors, parserObj) {
+    const { ParseError } = errors, { isType } = parserObj;
+    function readBE(bytes, off, len) {
+      let v = 0;
+      for (let i = 0;i < len; i++)
+        v = v * 256 + bytes[off + i];
+      return v;
+    }
+    function readInt(entry, label) {
+      if (!entry || entry.type !== "int")
+        throw new ParseError("pdf/xrefstm/missing-int", `XRef stream dict missing required /${label}`, { context: { label } });
+      return entry.value;
+    }
+    function parseCrossRefStream(decoded, dict) {
+      if (!(decoded instanceof Uint8Array))
+        throw new ParseError("pdf/xrefstm/bad-input", "parseCrossRefStream expects Uint8Array");
+      if (!isType(dict, "dict"))
+        throw new ParseError("pdf/xrefstm/bad-dict", "XRef stream dict must be a typed dict");
+      const e = dict.entries;
+      if (!e.Type || e.Type.type !== "name" || e.Type.value !== "XRef")
+        throw new ParseError("pdf/xrefstm/wrong-type", "/Type must be /XRef", { context: { actual: e.Type && e.Type.value } });
+      const W = e.W;
+      if (!W || W.type !== "array" || W.items.length !== 3)
+        throw new ParseError("pdf/xrefstm/bad-W", "/W must be a 3-element array", { context: { items: W && W.items && W.items.length } });
+      const w = W.items.map((it) => {
+        if (it.type !== "int" || it.value < 0)
+          throw new ParseError("pdf/xrefstm/bad-W-entry", "/W entries must be non-negative ints");
+        return it.value;
+      }), recordSize = w[0] + w[1] + w[2];
+      if (recordSize <= 0)
+        throw new ParseError("pdf/xrefstm/bad-W-zero", "/W must yield at least one non-zero field");
+      let index;
+      if (e.Index) {
+        if (e.Index.type !== "array" || (e.Index.items.length & 1) !== 0)
+          throw new ParseError("pdf/xrefstm/bad-Index", "/Index must be an array of (first, count) pairs");
+        index = [];
+        for (let i = 0;i < e.Index.items.length; i += 2) {
+          const f = e.Index.items[i], c = e.Index.items[i + 1];
+          if (f.type !== "int" || c.type !== "int")
+            throw new ParseError("pdf/xrefstm/bad-Index-entry", "/Index entries must be ints");
+          index.push([f.value, c.value]);
+        }
+      } else
+        index = [[0, readInt(e.Size, "Size")]];
+      const entries = {};
+      let pos = 0;
+      for (const [first, count] of index)
+        for (let k = 0;k < count; k++) {
+          if (pos + recordSize > decoded.length)
+            throw new ParseError("pdf/xrefstm/truncated", "truncated xref stream payload", { context: { pos, recordSize, length: decoded.length } });
+          const t = w[0] > 0 ? readBE(decoded, pos, w[0]) : 1, f2 = w[1] > 0 ? readBE(decoded, pos + w[0], w[1]) : 0, f3 = w[2] > 0 ? readBE(decoded, pos + w[0] + w[1], w[2]) : 0;
+          pos += recordSize;
+          const num = first + k;
+          if (t === 0)
+            entries[num] = { type: 0, offset: f2, gen: f3, free: !0 };
+          else if (t === 1)
+            entries[num] = { type: 1, offset: f2, gen: f3, free: !1 };
+          else if (t === 2)
+            entries[num] = {
+              type: 2,
+              objStm: f2,
+              index: f3,
+              free: !1,
+              offset: 0,
+              gen: 0
+            };
+          else
+            entries[num] = { type: t, offset: 0, gen: 0, free: !0 };
+        }
+      return {
+        entries,
+        size: e.Size && e.Size.type === "int" ? e.Size.value : Object.keys(entries).length,
+        trailer: dict
+      };
+    }
+    return { parseCrossRefStream };
+  } });
+    __register({ name: "pdfObjStream", dependencies: ["pdfErrors","pdfParserObj","pdfTokenizer","pdfParser"], factory: function(errors, parserObj, tokenizerMod, parserMod) {
+    const { ParseError } = errors, { isType } = parserObj, tokenize = tokenizerMod.tokenize, parseObject = parserMod.parseObject;
+    function readInt(entry, label) {
+      if (!entry || entry.type !== "int")
+        throw new ParseError("pdf/objstm/missing-int", `ObjStm dict missing required /${label}`, { context: { label, hasEntry: !!entry, type: entry && entry.type } });
+      return entry.value;
+    }
+    function parseObjectStream(decoded, dict) {
+      if (!(decoded instanceof Uint8Array))
+        throw new ParseError("pdf/objstm/bad-input", "parseObjectStream expects Uint8Array", { context: { typeof: typeof decoded } });
+      if (!isType(dict, "dict"))
+        throw new ParseError("pdf/objstm/bad-dict", "ObjStm dict must be a typed dict");
+      const e = dict.entries;
+      if (e.Type && (e.Type.type !== "name" || e.Type.value !== "ObjStm"))
+        throw new ParseError("pdf/objstm/wrong-type", "/Type must be /ObjStm", { context: { actual: e.Type.value } });
+      const N = readInt(e.N, "N"), First = readInt(e.First, "First");
+      if (N < 0)
+        throw new ParseError("pdf/objstm/bad-N", "/N must be non-negative", { context: { N } });
+      if (First < 0 || First > decoded.length)
+        throw new ParseError("pdf/objstm/bad-First", "/First out of payload range", { context: { First, length: decoded.length } });
+      const header = tokenize(decoded, { start: 0, end: First }), nums = Array(N), offs = Array(N);
+      for (let i = 0;i < N; i++) {
+        const tNum = header.next(), tOff = header.next();
+        if (!tNum || tNum.kind !== "int" || !tOff || tOff.kind !== "int")
+          throw new ParseError("pdf/objstm/bad-pair", "ObjStm header expects N pairs of integers", { context: { index: i } });
+        nums[i] = tNum.value;
+        offs[i] = tOff.value;
+      }
+      const out = Array(N);
+      for (let i = 0;i < N; i++) {
+        const start = First + offs[i], end = i + 1 < N ? First + offs[i + 1] : decoded.length;
+        if (start < First || end > decoded.length || start > end)
+          throw new ParseError("pdf/objstm/bad-offset", "ObjStm member offset out of range", { context: { index: i, start, end, length: decoded.length } });
+        const tok = tokenize(decoded, { start, end }), value = parseObject(tok);
+        out[i] = { num: nums[i], gen: 0, value };
+      }
+      return out;
+    }
+    return { parseObjectStream };
+  } });
+    __register({ name: "pdfFlate", dependencies: ["pdfErrors","zlib"], factory: function(errors, fwZlib) {
+    const { ParseError } = errors;
+    if (!fwZlib || typeof fwZlib.unzlibSync !== "function" || typeof fwZlib.zlibSync !== "function")
+      throw new ParseError("pdf/flate/missing-fw", "pdfFlate requires the @awacloud/fw zlib module", { context: { keys: fwZlib && Object.keys(fwZlib) } });
+    function paeth(a, b, c) {
+      const p = a + b - c, pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
+      if (pa <= pb && pa <= pc)
+        return a;
+      if (pb <= pc)
+        return b;
+      return c;
+    }
+    function predictorParams(params) {
+      const predictor = params && params.predictor != null ? params.predictor | 0 : params && params.Predictor != null ? params.Predictor | 0 : 1, columns = params && params.columns != null ? params.columns | 0 : params && params.Columns != null ? params.Columns | 0 : 1, colors = params && params.colors != null ? params.colors | 0 : params && params.Colors != null ? params.Colors | 0 : 1, bpc = params && params.bitsPerComponent != null ? params.bitsPerComponent | 0 : params && params.BitsPerComponent != null ? params.BitsPerComponent | 0 : 8;
+      if (predictor !== 1 && predictor !== 2 && (predictor < 10 || predictor > 15))
+        throw new ParseError("pdf/flate/bad-predictor", "unsupported Predictor value", { context: { predictor } });
+      if (columns <= 0 || colors <= 0 || bpc <= 0)
+        throw new ParseError("pdf/flate/bad-predictor-params", "Columns, Colors and BitsPerComponent must be > 0", { context: { columns, colors, bpc } });
+      const bitsPerPixel = colors * bpc, bytesPerPixel = Math.max(1, bitsPerPixel + 7 >> 3), rowBytes = columns * bitsPerPixel + 7 >> 3;
+      return { predictor, columns, colors, bpc, bytesPerPixel, rowBytes };
+    }
+    function pngUnfilterRow(filter, row, prevRow, bpp) {
+      const out = new Uint8Array(row.length);
+      for (let i = 0;i < row.length; i++) {
+        const left = i >= bpp ? out[i - bpp] : 0, up = prevRow ? prevRow[i] : 0, upLeft = prevRow && i >= bpp ? prevRow[i - bpp] : 0;
+        let v = row[i];
+        switch (filter) {
+          case 0:
+            break;
+          case 1:
+            v = v + left & 255;
+            break;
+          case 2:
+            v = v + up & 255;
+            break;
+          case 3:
+            v = v + (left + up >> 1) & 255;
+            break;
+          case 4:
+            v = v + paeth(left, up, upLeft) & 255;
+            break;
+          default:
+            throw new ParseError("pdf/flate/bad-png-filter", "unknown PNG filter tag", { context: { tag: filter } });
+        }
+        out[i] = v;
+      }
+      return out;
+    }
+    function pngFilterRow(filter, row, prevRow, bpp) {
+      const out = new Uint8Array(row.length);
+      for (let i = 0;i < row.length; i++) {
+        const left = i >= bpp ? row[i - bpp] : 0, up = prevRow ? prevRow[i] : 0, upLeft = prevRow && i >= bpp ? prevRow[i - bpp] : 0, v = row[i];
+        switch (filter) {
+          case 0:
+            out[i] = v;
+            break;
+          case 1:
+            out[i] = v - left & 255;
+            break;
+          case 2:
+            out[i] = v - up & 255;
+            break;
+          case 3:
+            out[i] = v - (left + up >> 1) & 255;
+            break;
+          case 4:
+            out[i] = v - paeth(left, up, upLeft) & 255;
+            break;
+          default:
+            throw new ParseError("pdf/flate/bad-png-filter", "unknown PNG filter tag", { context: { tag: filter } });
+        }
+      }
+      return out;
+    }
+    function tiff2Decode(bytes, p) {
+      if (p.bpc !== 8)
+        throw new ParseError("pdf/flate/tiff-bpc-unsupported", "TIFF Predictor 2 requires BitsPerComponent=8", { context: { bpc: p.bpc } });
+      const out = new Uint8Array(bytes.length), stride = p.colors, rowBytes = p.rowBytes, rows = bytes.length / rowBytes | 0;
+      for (let r = 0;r < rows; r++) {
+        const base = r * rowBytes;
+        for (let i = 0;i < rowBytes; i++) {
+          const left = i >= stride ? out[base + i - stride] : 0;
+          out[base + i] = bytes[base + i] + left & 255;
+        }
+      }
+      return out;
+    }
+    function tiff2Encode(bytes, p) {
+      if (p.bpc !== 8)
+        throw new ParseError("pdf/flate/tiff-bpc-unsupported", "TIFF Predictor 2 requires BitsPerComponent=8", { context: { bpc: p.bpc } });
+      const out = new Uint8Array(bytes.length), stride = p.colors, rowBytes = p.rowBytes, rows = bytes.length / rowBytes | 0;
+      for (let r = 0;r < rows; r++) {
+        const base = r * rowBytes;
+        for (let i = 0;i < rowBytes; i++) {
+          const left = i >= stride ? bytes[base + i - stride] : 0;
+          out[base + i] = bytes[base + i] - left & 255;
+        }
+      }
+      return out;
+    }
+    function pngDecode(bytes, p) {
+      const rowBytes = p.rowBytes, stride = rowBytes + 1;
+      if (bytes.length % stride !== 0)
+        throw new ParseError("pdf/flate/png-row-mismatch", "predicted stream length is not a multiple of (rowBytes+1)", { context: { length: bytes.length, stride } });
+      const rows = bytes.length / stride, out = new Uint8Array(rows * rowBytes);
+      let prev = null;
+      for (let r = 0;r < rows; r++) {
+        const tag = bytes[r * stride], row = bytes.subarray(r * stride + 1, r * stride + stride), unfiltered = pngUnfilterRow(tag, row, prev, p.bytesPerPixel);
+        out.set(unfiltered, r * rowBytes);
+        prev = unfiltered;
+      }
+      return out;
+    }
+    function pngEncode(bytes, p) {
+      const rowBytes = p.rowBytes;
+      if (bytes.length % rowBytes !== 0)
+        throw new ParseError("pdf/flate/png-row-mismatch", "input length is not a multiple of rowBytes", { context: { length: bytes.length, rowBytes } });
+      const rows = bytes.length / rowBytes, outStride = rowBytes + 1, out = new Uint8Array(rows * outStride), forced = p.predictor === 15 ? -1 : p.predictor - 10;
+      let prev = null;
+      for (let r = 0;r < rows; r++) {
+        const row = bytes.subarray(r * rowBytes, (r + 1) * rowBytes);
+        let tag = forced;
+        if (tag < 0)
+          tag = r === 0 ? 0 : 2;
+        const filtered = pngFilterRow(tag, row, prev, p.bytesPerPixel);
+        out[r * outStride] = tag;
+        out.set(filtered, r * outStride + 1);
+        prev = row;
+      }
+      return out;
+    }
+    function endedBeforeFinalBlock(e) {
+      return !!e && e.code === 0;
+    }
+    function inflatePrefix(bytes) {
+      const chunks = [];
+      let total = 0;
+      new fwZlib.UnzlibStream((chunk) => {
+        chunks.push(chunk);
+        total += chunk.length;
+      }).push(bytes, !1);
+      const out = new Uint8Array(total);
+      let off = 0;
+      for (const chunk of chunks) {
+        out.set(chunk, off);
+        off += chunk.length;
+      }
+      return out;
+    }
+    function markTruncated(out) {
+      Object.defineProperty(out, "truncated", { value: !0, enumerable: !1 });
+      return out;
+    }
+    function decode(bytes, params) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/flate/bad-input", "FlateDecode expects Uint8Array");
+      let raw, truncated = !1;
+      try {
+        raw = fwZlib.unzlibSync(bytes);
+      } catch (e) {
+        const inflateFailed = () => new ParseError("pdf/flate/inflate-failed", "inflate failed: " + (e && e.message), { context: { length: bytes.length }, cause: e });
+        if (!endedBeforeFinalBlock(e) || typeof fwZlib.UnzlibStream !== "function")
+          throw inflateFailed();
+        let prefix;
+        try {
+          prefix = inflatePrefix(bytes);
+        } catch {
+          throw inflateFailed();
+        }
+        if (prefix.length === 0)
+          throw inflateFailed();
+        raw = prefix;
+        truncated = !0;
+      }
+      const done = (out) => truncated ? markTruncated(out) : out;
+      if (!params)
+        return done(raw);
+      if (!(params.predictor != null && params.predictor !== 1 || params.Predictor != null && params.Predictor !== 1))
+        return done(raw);
+      const p = predictorParams(params);
+      if (p.predictor === 1)
+        return done(raw);
+      const stride = p.predictor === 2 ? p.rowBytes : p.rowBytes + 1;
+      if (truncated)
+        raw = raw.subarray(0, raw.length - raw.length % stride);
+      if (p.predictor === 2)
+        return done(tiff2Decode(raw, p));
+      return done(pngDecode(raw, p));
+    }
+    function encode(bytes, params) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/flate/bad-input", "FlateEncode expects Uint8Array");
+      let payload = bytes;
+      if (params) {
+        if (params.predictor != null && params.predictor !== 1 || params.Predictor != null && params.Predictor !== 1) {
+          const p = predictorParams(params);
+          if (p.predictor === 2)
+            payload = tiff2Encode(bytes, p);
+          else if (p.predictor >= 10)
+            payload = pngEncode(bytes, p);
+        }
+      }
+      try {
+        return fwZlib.zlibSync(payload);
+      } catch (e) {
+        throw new ParseError("pdf/flate/deflate-failed", "deflate failed: " + (e && e.message), { context: { length: payload.length }, cause: e });
+      }
+    }
+    return { decode, encode };
+  } });
+    __register({ name: "pdfAsciiHex", dependencies: ["pdfErrors"], factory: function(errors) {
+    const { ParseError } = errors, HEX_LO = [
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      -1
+    ];
+    function isWs(b) {
+      return b === 32 || b === 9 || b === 10 || b === 13 || b === 12 || b === 0;
+    }
+    function decode(bytes) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/asciiHex/bad-input", "ASCIIHexDecode expects Uint8Array");
+      const out = [];
+      let pending = -1;
+      for (let i = 0;i < bytes.length; i++) {
+        const b = bytes[i];
+        if (b === 62)
+          break;
+        if (isWs(b))
+          continue;
+        const v = b < HEX_LO.length ? HEX_LO[b] : -1;
+        if (v < 0)
+          throw new ParseError("pdf/asciiHex/bad-digit", "invalid hex digit", { context: { offset: i, byte: b } });
+        if (pending < 0)
+          pending = v;
+        else {
+          out.push(pending << 4 | v);
+          pending = -1;
+        }
+      }
+      if (pending >= 0)
+        out.push(pending << 4);
+      return Uint8Array.from(out);
+    }
+    function encode(bytes) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/asciiHex/bad-input", "ASCIIHexEncode expects Uint8Array");
+      const H = "0123456789ABCDEF";
+      let s = "";
+      for (let i = 0;i < bytes.length; i++) {
+        if (i > 0 && (i & 31) === 0)
+          s += `
+`;
+        const b = bytes[i];
+        s += H[b >> 4] + H[b & 15];
+      }
+      s += ">";
+      return new TextEncoder().encode(s);
+    }
+    return { decode, encode };
+  } });
+    __register({ name: "pdfAscii85", dependencies: ["pdfErrors"], factory: function(errors) {
+    const { ParseError } = errors;
+    function isWs(b) {
+      return b === 32 || b === 9 || b === 10 || b === 13 || b === 12 || b === 0;
+    }
+    function decode(bytes) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/ascii85/bad-input", "ASCII85Decode expects Uint8Array");
+      const out = [];
+      let group = 0, count = 0;
+      for (let i = 0;i < bytes.length; i++) {
+        const b = bytes[i];
+        if (isWs(b))
+          continue;
+        if (b === 126) {
+          if (i + 1 < bytes.length && bytes[i + 1] === 62)
+            break;
+          throw new ParseError("pdf/ascii85/bad-eod", "~ not followed by >", { context: { offset: i } });
+        }
+        if (b === 122) {
+          if (count !== 0)
+            throw new ParseError("pdf/ascii85/bad-z", "z must appear at group boundary", { context: { offset: i } });
+          out.push(0, 0, 0, 0);
+          continue;
+        }
+        if (b < 33 || b > 117)
+          throw new ParseError("pdf/ascii85/bad-digit", "character outside ! .. u", { context: { offset: i, byte: b } });
+        group = group * 85 + (b - 33);
+        count++;
+        if (count === 5) {
+          out.push(group >>> 24 & 255, group >>> 16 & 255, group >>> 8 & 255, group & 255);
+          group = 0;
+          count = 0;
+        }
+      }
+      if (count > 0) {
+        for (let k = count;k < 5; k++)
+          group = group * 85 + 84;
+        const decoded = [
+          group >>> 24 & 255,
+          group >>> 16 & 255,
+          group >>> 8 & 255,
+          group & 255
+        ];
+        for (let k = 0;k < count - 1; k++)
+          out.push(decoded[k]);
+      }
+      return Uint8Array.from(out);
+    }
+    function encode(bytes) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/ascii85/bad-input", "ASCII85Encode expects Uint8Array");
+      const chars = [];
+      let i = 0;
+      while (i + 4 <= bytes.length) {
+        const v = bytes[i] * 16777216 + (bytes[i + 1] << 16) + (bytes[i + 2] << 8) + bytes[i + 3];
+        if (v === 0)
+          chars.push(122);
+        else {
+          const g = [0, 0, 0, 0, 0];
+          let n = v;
+          for (let k = 4;k >= 0; k--) {
+            g[k] = n % 85 + 33;
+            n = Math.floor(n / 85);
+          }
+          chars.push(g[0], g[1], g[2], g[3], g[4]);
+        }
+        i += 4;
+      }
+      const rem = bytes.length - i;
+      if (rem > 0) {
+        const padded = new Uint8Array(4);
+        padded.set(bytes.subarray(i));
+        const v = padded[0] * 16777216 + (padded[1] << 16) + (padded[2] << 8) + padded[3], g = [0, 0, 0, 0, 0];
+        let n = v;
+        for (let k = 4;k >= 0; k--) {
+          g[k] = n % 85 + 33;
+          n = Math.floor(n / 85);
+        }
+        for (let k = 0;k < rem + 1; k++)
+          chars.push(g[k]);
+      }
+      chars.push(126, 62);
+      return Uint8Array.from(chars);
+    }
+    return { decode, encode };
+  } });
+    __register({ name: "pdfRunLength", dependencies: ["pdfErrors"], factory: function(errors) {
+    const { ParseError } = errors;
+    function decode(bytes) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/runLength/bad-input", "RunLengthDecode expects Uint8Array");
+      const out = [];
+      let i = 0;
+      while (i < bytes.length) {
+        const n = bytes[i++];
+        if (n === 128)
+          break;
+        if (n < 128) {
+          const count = n + 1;
+          if (i + count > bytes.length)
+            throw new ParseError("pdf/runLength/truncated-literal", "truncated literal run", { context: { offset: i - 1, want: count, have: bytes.length - i } });
+          for (let k = 0;k < count; k++)
+            out.push(bytes[i + k]);
+          i += count;
+        } else {
+          if (i >= bytes.length)
+            throw new ParseError("pdf/runLength/truncated-repeat", "truncated repeat run", { context: { offset: i - 1 } });
+          const v = bytes[i++], count = 257 - n;
+          for (let k = 0;k < count; k++)
+            out.push(v);
+        }
+      }
+      return Uint8Array.from(out);
+    }
+    function encode(bytes) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/runLength/bad-input", "RunLengthEncode expects Uint8Array");
+      const out = [];
+      let i = 0;
+      while (i < bytes.length) {
+        const v = bytes[i];
+        let runLen = 1;
+        while (runLen < 128 && i + runLen < bytes.length && bytes[i + runLen] === v)
+          runLen++;
+        if (runLen >= 3) {
+          out.push(257 - runLen, v);
+          i += runLen;
+          continue;
+        }
+        let litStart = i, litLen = 0;
+        while (litLen < 128 && i < bytes.length) {
+          let look = 1;
+          while (look < 3 && i + look < bytes.length && bytes[i + look] === bytes[i])
+            look++;
+          if (look >= 3 && litLen > 0)
+            break;
+          i++;
+          litLen++;
+        }
+        out.push(litLen - 1);
+        for (let k = 0;k < litLen; k++)
+          out.push(bytes[litStart + k]);
+      }
+      out.push(128);
+      return Uint8Array.from(out);
+    }
+    return { decode, encode };
+  } });
+    __register({ name: "pdfFilterDispatch", dependencies: ["pdfErrors","pdfFlate","pdfAsciiHex","pdfAscii85","pdfRunLength"], factory: function(errors, flate, asciiHex, ascii85, runLength) {
+    const { ParseError } = errors;
+    function isType(node, kind) {
+      return !!(node && node.type === kind);
+    }
+    const ABBREV = {
+      Fl: "FlateDecode",
+      AHx: "ASCIIHexDecode",
+      A85: "ASCII85Decode",
+      RL: "RunLengthDecode",
+      LZW: "LZWDecode",
+      DCT: "DCTDecode",
+      JPX: "JPXDecode",
+      CCF: "CCITTFaxDecode"
+    };
+    function resolveAbbrev(name) {
+      return ABBREV[name] || name;
+    }
+    function passthrough() {
+      return {
+        decode(bytes) {
+          return bytes;
+        },
+        encode(bytes) {
+          return bytes;
+        }
+      };
+    }
+    function normalizeFilterList(filterEntry) {
+      if (!filterEntry)
+        return [];
+      if (filterEntry.type === "name")
+        return [resolveAbbrev(filterEntry.value)];
+      if (filterEntry.type === "array") {
+        const out = [];
+        for (const it of filterEntry.items) {
+          if (it.type !== "name")
+            throw new ParseError("pdf/filter/non-name", "/Filter array entries must be names", { context: { kind: it.type } });
+          out.push(resolveAbbrev(it.value));
+        }
+        return out;
+      }
+      throw new ParseError("pdf/filter/bad-type", "/Filter must be a name or array of names", { context: { type: filterEntry.type } });
+    }
+    function applyDecodeChain(bytes, filters, params, decoders) {
+      let cur = bytes;
+      for (let i = 0;i < filters.length; i++) {
+        const name = filters[i], p = params ? params[i] || null : null, dec = decoders[name];
+        if (!dec)
+          throw new ParseError("pdf/filter/unsupported", `filter "${name}" not registered`, { context: { name, available: Object.keys(decoders) } });
+        cur = dec.decode(cur, p);
+      }
+      return cur;
+    }
+    function applyEncodeChain(bytes, filters, params, decoders) {
+      let cur = bytes;
+      for (let i = 0;i < filters.length; i++) {
+        const name = filters[i], p = params ? params[i] || null : null, enc = decoders[name];
+        if (!enc || typeof enc.encode !== "function")
+          throw new ParseError("pdf/filter/no-encoder", `filter "${name}" has no encoder`, { context: { name } });
+        cur = enc.encode(cur, p);
+      }
+      return cur;
+    }
+    function plainParams(dictNode) {
+      const entries = dictNode.entries || {}, out = {};
+      for (const key of Object.keys(entries)) {
+        const v = entries[key];
+        out[key] = v ? v.value : void 0;
+      }
+      return out;
+    }
+    function decodeParmsList(entry, count) {
+      if (!entry)
+        return null;
+      if (entry.type === "null")
+        return null;
+      if (entry.type === "dict") {
+        const arr = Array(count).fill(null);
+        if (count > 0)
+          arr[0] = plainParams(entry);
+        return arr;
+      }
+      if (entry.type === "array")
+        return entry.items.map((it) => it.type === "dict" ? plainParams(it) : null);
+      throw new ParseError("pdf/filter/bad-decodeparms", "/DecodeParms must be a dict, array, or null", { context: { type: entry.type } });
+    }
+    function decodeStream(streamObj, decoders) {
+      if (!isType(streamObj, "stream"))
+        throw new ParseError("pdf/filter/not-stream", "decodeStream expects a stream object");
+      const dict = streamObj.dict, filters = normalizeFilterList(dict.entries.Filter), params = decodeParmsList(dict.entries.DecodeParms, filters.length);
+      return applyDecodeChain(streamObj.raw, filters, params, decoders);
+    }
+    const decoders = {
+      FlateDecode: flate,
+      ASCIIHexDecode: asciiHex,
+      ASCII85Decode: ascii85,
+      RunLengthDecode: runLength,
+      DCTDecode: passthrough(),
+      JPXDecode: passthrough(),
+      Crypt: passthrough()
+    };
+    function decode(streamObj) {
+      return decodeStream(streamObj, decoders);
+    }
+    function decodeChain(bytes, filters, params) {
+      return applyDecodeChain(bytes, filters, params, decoders);
+    }
+    function encodeChain(bytes, filters, params) {
+      return applyEncodeChain(bytes, filters, params, decoders);
+    }
+    function register(name, impl) {
+      decoders[name] = impl;
+    }
+    function names() {
+      return Object.keys(decoders);
+    }
+    return {
+      decode,
+      decodeChain,
+      encodeChain,
+      register,
+      names,
+      decoders,
+      normalizeFilterList,
+      applyDecodeChain,
+      applyEncodeChain,
+      decodeStream
+    };
+  } });
+    __register({ name: "pdfDocument", dependencies: ["pdfErrors","pdfTokenizer","pdfParser","pdfXref","pdfTrailer","pdfCatalog","pdfPage","pdfPages","pdfCrossRefStream","pdfObjStream","pdfFilterDispatch"], factory: function(errors, tokenizerMod, parserMod, xrefMod, trailerMod, catalogMod, pageMod, pagesMod, crossRefStreamMod, objStreamMod, filterDispatchMod) {
+    const { ParseError } = errors, tokenize = tokenizerMod && tokenizerMod.tokenize, parseIndirect = parserMod && parserMod.parseIndirect, locateStartXref = xrefMod && xrefMod.locateStartXref, readStartXref = xrefMod && xrefMod.readStartXref, parseXrefTable = xrefMod && xrefMod.parseXrefTable, parseTrailerDict = xrefMod && xrefMod.parseTrailerDict, typeTrailer = trailerMod && trailerMod.typeTrailer, typeCatalog = catalogMod && catalogMod.typeCatalog, typePage = pageMod && pageMod.typePage, walkPageTree = pagesMod && pagesMod.walkPageTree, HEADER_PREFIX = new Uint8Array([37, 80, 68, 70, 45]), XREF_KEYWORD = new Uint8Array([120, 114, 101, 102]), PDF_NULL = Object.freeze({ type: "null" }), SECTION_LOCAL_KEYS = new Set([
+      "Prev",
+      "XRefStm",
+      "Type",
+      "W",
+      "Index",
+      "Length",
+      "Filter",
+      "DecodeParms",
+      "F",
+      "FFilter",
+      "FDecodeParms",
+      "DL"
+    ]), EMPTY_PAGES_NODE = Object.freeze({
+      type: "dict",
+      entries: Object.freeze({
+        Type: Object.freeze({ type: "name", value: "Pages" }),
+        Kids: Object.freeze({ type: "array", items: Object.freeze([]) })
+      })
+    });
+    function skipWhitespace(bytes, at) {
+      let p = at < 0 ? 0 : at;
+      while (p < bytes.length) {
+        const b = bytes[p];
+        if (b === 0 || b === 9 || b === 10 || b === 12 || b === 13 || b === 32) {
+          p++;
+          continue;
+        }
+        break;
+      }
+      return p;
+    }
+    function startsXrefTable(bytes, at) {
+      for (let k = 0;k < XREF_KEYWORD.length; k++)
+        if (bytes[at + k] !== XREF_KEYWORD[k])
+          return !1;
+      return !0;
+    }
+    function refuseIndirectLength(ref) {
+      throw new ParseError("pdf/document/xrefstm-indirect-length", "a cross-reference stream may not use an indirect /Length", { context: { num: ref && ref.num, gen: ref && ref.gen } });
+    }
+    function requireStreamWiring(offset) {
+      if (!crossRefStreamMod || !objStreamMod || !filterDispatchMod)
+        throw new ParseError("pdf/document/xref-stream-unwired", "this pdfDocument was built without pdfCrossRefStream, " + "pdfObjStream and pdfFilterDispatch \u2014 cross-reference " + "streams and object streams cannot be read", { context: { offset } });
+    }
+    function readXrefStreamSection(bytes, at) {
+      requireStreamWiring(at);
+      const tok = tokenize(bytes, { start: at }), streamObj = parseIndirect(tok, refuseIndirectLength).value, typeEntry = streamObj && streamObj.dict && streamObj.dict.entries && streamObj.dict.entries.Type;
+      if (!streamObj || streamObj.type !== "stream" || !typeEntry || typeEntry.type !== "name" || typeEntry.value !== "XRef")
+        throw new ParseError("pdf/document/bad-xref-section", "neither an xref table nor a cross-reference stream at startxref", { context: { offset: at } });
+      const decoded = filterDispatchMod.decode(streamObj);
+      return { entries: crossRefStreamMod.parseCrossRefStream(decoded, streamObj.dict).entries, dict: streamObj.dict };
+    }
+    function mergeTrailerDicts(dicts) {
+      if (dicts.length === 1)
+        return dicts[0];
+      for (const d of dicts)
+        if (!d || d.type !== "dict")
+          return d;
+      const entries = { ...dicts[0].entries };
+      for (let i = 1;i < dicts.length; i++)
+        for (const k of Object.keys(dicts[i].entries)) {
+          if (SECTION_LOCAL_KEYS.has(k))
+            continue;
+          if (!(k in entries))
+            entries[k] = dicts[i].entries[k];
+        }
+      return { ...dicts[0], entries };
+    }
+    function readHeader(bytes) {
+      if (bytes.length < 8)
+        throw new ParseError("pdf/document/short", "input too short to contain a PDF header", { context: { length: bytes.length } });
+      let off = -1;
+      const maxScan = Math.min(bytes.length - 5, 1024);
+      outer:
+        for (let i = 0;i <= maxScan; i++) {
+          for (let k = 0;k < 5; k++)
+            if (bytes[i + k] !== HEADER_PREFIX[k])
+              continue outer;
+          off = i;
+          break;
+        }
+      if (off < 0)
+        throw new ParseError("pdf/document/bad-header", "no %PDF- header found in first 1024 bytes");
+      let p = off + 5;
+      const digits = [];
+      while (p < bytes.length) {
+        const b = bytes[p];
+        if (b === 10 || b === 13)
+          break;
+        digits.push(b);
+        p++;
+      }
+      const version = new TextDecoder("latin1").decode(Uint8Array.from(digits));
+      if (p < bytes.length && bytes[p] === 13)
+        p++;
+      if (p < bytes.length && bytes[p] === 10)
+        p++;
+      return { version, end: p };
+    }
+    function readDocument(bytes, opts = {}) {
+      if (!(bytes instanceof Uint8Array))
+        throw new ParseError("pdf/document/bad-input", "readDocument expects a Uint8Array", { context: { typeof: typeof bytes } });
+      const { version, end: headerEnd } = readHeader(bytes), sxAt = locateStartXref(bytes);
+      if (sxAt < 0)
+        throw new ParseError("pdf/document/no-startxref", "startxref keyword not found near EOF");
+      const xrefAt = readStartXref(bytes, sxAt), xref = { entries: {}, sections: [] }, losses = [], trailerDicts = [];
+      let cursor = xrefAt;
+      const seenSections = new Set;
+      function mergeSection(at, kind, entries) {
+        xref.sections.push({ at, kind, entries });
+        for (const k of Object.keys(entries))
+          if (!(k in xref.entries))
+            xref.entries[k] = entries[k];
+      }
+      for (let safety = 0;safety < 32 && cursor >= 0; safety++) {
+        if (seenSections.has(cursor))
+          break;
+        seenSections.add(cursor);
+        let dict;
+        if (startsXrefTable(bytes, skipWhitespace(bytes, cursor))) {
+          const section = parseXrefTable(bytes, cursor);
+          mergeSection(cursor, "table", section.entries);
+          dict = parseTrailerDict(bytes, section.end).dict;
+          const stmAt = dict && dict.entries && dict.entries.XRefStm;
+          if (stmAt && stmAt.type === "int" && stmAt.value >= 0 && stmAt.value < bytes.length) {
+            const hybrid = readXrefStreamSection(bytes, stmAt.value);
+            mergeSection(stmAt.value, "stream", hybrid.entries);
+          }
+        } else {
+          const section = readXrefStreamSection(bytes, cursor);
+          mergeSection(cursor, "stream", section.entries);
+          dict = section.dict;
+        }
+        trailerDicts.push(dict);
+        const prev = dict && dict.type === "dict" && dict.entries && dict.entries.Prev;
+        if (prev && prev.type === "int" && prev.value >= 0 && prev.value !== cursor)
+          cursor = prev.value;
+        else
+          break;
+      }
+      if (trailerDicts.length === 0)
+        throw new ParseError("pdf/document/no-trailer", "no usable trailer dictionary found");
+      const trailerTyped = typeTrailer(mergeTrailerDicts(trailerDicts));
+      if (trailerTyped.encrypt && opts.allowEncrypted !== !0)
+        throw new ParseError("pdf/document/encrypted", "document is encrypted (trailer /Encrypt present) \u2014 " + "no decrypt path is composed for readDocument; pass { allowEncrypted: true } to read the raw ciphertext container", { context: { encrypt: trailerTyped.encrypt } });
+      const indirects = new Map, lossKeys = new Set, freeKeys = new Set, objStmMembers = new Map;
+      function resolve(ref) {
+        if (!ref || ref.type !== "ref")
+          return ref;
+        return resolveByKey(ref.num, ref.gen);
+      }
+      function resolveByKey(num, gen) {
+        const key = num + ":" + gen;
+        if (indirects.has(key))
+          return indirects.get(key).value;
+        let entry = xref.entries[num];
+        if (!entry)
+          throw new ParseError("pdf/document/missing-xref", `object ${num} ${gen} not in xref`, { context: { num, gen } });
+        if (entry.free) {
+          entry = resolveFreeEntry(num, gen);
+          if (!entry)
+            return PDF_NULL;
+        }
+        if (entry.type === 2) {
+          const value = resolveCompressed(num, gen, entry);
+          indirects.set(key, { value, offset: 0, objStm: entry.objStm });
+          return value;
+        }
+        const offset = entry.offset;
+        if (offset <= 0 || offset >= bytes.length)
+          throw new ParseError("pdf/document/bad-offset", `object ${num} ${gen} xref offset out of range`, { context: { num, gen, offset, total: bytes.length } });
+        const tok = tokenize(bytes, { start: offset }), def = parseIndirect(tok, resolve);
+        if (def.num !== num || def.gen !== gen)
+          throw new ParseError("pdf/document/xref-mismatch", "xref points to a different object", { context: { expected: { num, gen }, found: { num: def.num, gen: def.gen } } });
+        indirects.set(key, { value: def.value, offset });
+        return def.value;
+      }
+      function resolveFreeEntry(num, gen) {
+        const key = num + ":" + gen;
+        for (const section of xref.sections) {
+          const e = section.entries[num];
+          if (e && !e.free) {
+            recordLoss("fallback:" + key, {
+              code: "pdf/document/free-entry-fallback",
+              message: `object ${num} is free in the newest xref section; resolved through an older section that defines it`,
+              context: { num, gen, section: { at: section.at, kind: section.kind } }
+            });
+            return e;
+          }
+        }
+        freeKeys.add(key);
+        recordLoss("free:" + key, {
+          code: "pdf/document/free-object",
+          message: `object ${num} is free in every xref section; read as null`,
+          context: { num, gen }
+        });
+        return null;
+      }
+      function recordLoss(dedupeKey, loss) {
+        if (lossKeys.has(dedupeKey))
+          return;
+        lossKeys.add(dedupeKey);
+        losses.push(loss);
+      }
+      function resolveCompressed(num, gen, entry) {
+        if (trailerTyped && trailerTyped.encrypt)
+          throw new ParseError("pdf/document/objstm-encrypted", "object streams of an encrypted document cannot be " + "read \u2014 no decrypt path is composed for readDocument", { context: { num, gen, objStm: entry.objStm } });
+        const containerNum = entry.objStm;
+        let members = objStmMembers.get(containerNum);
+        if (!members) {
+          requireStreamWiring(0);
+          const containerEntry = xref.entries[containerNum];
+          if (containerEntry && containerEntry.type === 2)
+            throw new ParseError("pdf/document/objstm-nested", `object stream ${containerNum} is itself stored in an object stream`, { context: { num, objStm: containerNum } });
+          const container = resolveByKey(containerNum, 0);
+          if (!container || container.type !== "stream")
+            throw new ParseError("pdf/document/objstm-not-stream", `object ${containerNum} is not a stream and cannot hold compressed objects`, { context: {
+              num,
+              objStm: containerNum,
+              type: container && container.type
+            } });
+          members = objStreamMod.parseObjectStream(filterDispatchMod.decode(container), container.dict);
+          objStmMembers.set(containerNum, members);
+        }
+        const member = members[entry.index];
+        if (!member || member.num !== num)
+          throw new ParseError("pdf/document/objstm-mismatch", "object stream member does not carry the expected object number", { context: {
+            num,
+            objStm: containerNum,
+            index: entry.index,
+            found: member ? member.num : null
+          } });
+        return member.value;
+      }
+      const rootRef = trailerTyped.root, catalogDict = resolve({ type: "ref", num: rootRef.num, gen: rootRef.gen });
+      if (freeKeys.has(rootRef.num + ":" + rootRef.gen))
+        throw new ParseError("pdf/document/free-object", `object ${rootRef.num} is free`, { context: { num: rootRef.num, gen: rootRef.gen, role: "catalog" } });
+      const catalog = typeCatalog(catalogDict);
+      function resolvePageTreeNode(ref) {
+        const value = resolve(ref);
+        if (ref && ref.type === "ref" && freeKeys.has(ref.num + ":" + ref.gen))
+          return EMPTY_PAGES_NODE;
+        return value;
+      }
+      const pages = walkPageTree(catalog.pages, resolvePageTreeNode).map((r) => typePage(resolve({ type: "ref", num: r.num, gen: r.gen })));
+      return {
+        version,
+        catalog,
+        pages,
+        trailer: trailerTyped,
+        xref,
+        losses,
+        _raw: {
+          resolve,
+          bytes,
+          headerEnd,
+          indirects
+        }
+      };
+    }
+    return { readDocument, readHeader };
+  } });
+    __register({ name: "pdfWriter", dependencies: ["pdfErrors","pdfSerializer"], factory: function(errors, serializerMod) {
+    const { RenderError } = errors, serializeIndirect = serializerMod.serializeIndirect, te = new TextEncoder;
+    function pad10(n) {
+      return String(n).padStart(10, "0");
+    }
+    function hexLit(bytes) {
+      let s = "<";
+      for (let i = 0;i < bytes.length; i++)
+        s += "0123456789ABCDEF"[bytes[i] >> 4] + "0123456789ABCDEF"[bytes[i] & 15];
+      return s + ">";
+    }
+    function concat(arrays) {
+      let n = 0;
+      for (const a of arrays)
+        n += a.length;
+      const out = new Uint8Array(n);
+      let o = 0;
+      for (const a of arrays) {
+        out.set(a, o);
+        o += a.length;
+      }
+      return out;
+    }
+    function validateIndirects(list) {
+      let prev = -1;
+      for (const it of list) {
+        if (!it || !Number.isFinite(it.num) || it.num < 1)
+          throw new RenderError("pdf/writer/bad-indirect", "each indirect requires num >= 1", { context: { item: it } });
+        if (it.num === prev)
+          throw new RenderError("pdf/writer/duplicate-num", "duplicate object number", { context: { num: it.num } });
+        prev = it.num;
+      }
+    }
+    function buildXref(maxNum, offsets) {
+      let s = `xref
+0 ${maxNum + 1}
+`;
+      s += `0000000000 65535 f 
+`;
+      for (let n = 1;n <= maxNum; n++)
+        if (offsets.has(n))
+          s += pad10(offsets.get(n)) + ` 00000 n 
+`;
+        else
+          s += `0000000000 00000 f 
+`;
+      return te.encode(s);
+    }
+    function buildTrailer(opts) {
+      const parts = [`trailer
+<< /Size ${opts.size}`];
+      parts.push(` /Root ${opts.root.num} ${opts.root.gen | 0} R`);
+      if (opts.info)
+        parts.push(` /Info ${opts.info.num} ${opts.info.gen | 0} R`);
+      if (opts.id) {
+        parts.push(" /ID [");
+        parts.push(hexLit(opts.id[0]));
+        parts.push(hexLit(opts.id[1]));
+        parts.push("]");
+      }
+      parts.push(` >>
+`);
+      parts.push(`startxref
+${opts.xrefOffset}
+%%EOF
+`);
+      return te.encode(parts.join(""));
+    }
+    function writeDocument(opts) {
+      if (!opts || !Array.isArray(opts.indirects))
+        throw new RenderError("pdf/writer/bad-input", "writeDocument expects { indirects: [...] }");
+      if (!opts.root || !Number.isFinite(opts.root.num))
+        throw new RenderError("pdf/writer/no-root", "writeDocument requires opts.root");
+      const version = opts.version || "2.0";
+      if (!/^\d\.\d$/.test(version))
+        throw new RenderError("pdf/writer/bad-version", 'version must look like "x.y"', { context: { version } });
+      const indirects = opts.indirects.slice().sort((a, b) => a.num - b.num);
+      validateIndirects(indirects);
+      const parts = [];
+      let cursor = 0;
+      const offsets = new Map;
+      function push(u8) {
+        parts.push(u8);
+        cursor += u8.length;
+      }
+      push(te.encode(`%PDF-${version}
+`));
+      push(new Uint8Array([37, 226, 227, 207, 211, 10]));
+      const maxNum = indirects.length > 0 ? indirects[indirects.length - 1].num : 0;
+      for (const { num, gen, value } of indirects) {
+        offsets.set(num, cursor);
+        push(serializeIndirect(num, gen, value));
+      }
+      const xrefOffset = cursor;
+      push(buildXref(maxNum, offsets));
+      const size = maxNum + 1;
+      push(buildTrailer({
+        size,
+        root: opts.root,
+        info: opts.info,
+        id: opts.id,
+        xrefOffset
+      }));
+      return concat(parts);
+    }
+    function assembleIndirects(model, opts) {
+      if (!model || !model._raw || typeof model._raw.resolve !== "function")
+        throw new RenderError("pdf/writer/bad-model", "assembleIndirects requires a model produced by pdf.read()");
+      const skipped = [];
+      for (const k of Object.keys(model.xref.entries)) {
+        const e = model.xref.entries[k];
+        if (e.free)
+          continue;
+        try {
+          model._raw.resolve({ type: "ref", num: Number(k), gen: e.gen });
+        } catch (err) {
+          skipped.push({
+            num: Number(k),
+            gen: e.gen,
+            code: errors.isPdfError(err) ? err.code : "unknown"
+          });
+        }
+      }
+      if (skipped.length > 0 && opts && opts.strict === !0)
+        throw new RenderError("pdf/writer/unresolvable-objects", `${skipped.length} object${skipped.length === 1 ? "" : "s"} could not be resolved and would be dropped`, { context: { objects: skipped } });
+      const out = [];
+      for (const [key, rec] of model._raw.indirects.entries()) {
+        const [n, g] = key.split(":").map(Number);
+        out.push({ num: n, gen: g, value: rec.value });
+      }
+      out.sort((a, b) => a.num - b.num);
+      Object.defineProperty(out, "skippedObjects", {
+        value: skipped,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      });
+      return out;
+    }
+    return { writeDocument, assembleIndirects };
+  } });
+    __register({ name: "pdf", dependencies: ["pdfErrors","pdfShared","pdfTokenizer","pdfParserObj","pdfParser","pdfXref","pdfTrailer","pdfSerializer","pdfCatalog","pdfPages","pdfPage","pdfDocument","pdfWriter"], factory: function(errors, shared, tokenizer, parserObj, parser, xref, trailer, serializer, catalog, pages, page, docMod, writerMod) {
+    const { ContractError } = errors, readDocument = docMod.readDocument, readHeader = docMod.readHeader, writeDocument = writerMod.writeDocument, assembleIndirects = writerMod.assembleIndirects, usedExtensions = new Set, api = {
+      read(bytes, opts) {
+        return readDocument(bytes, opts);
+      },
+      header(bytes) {
+        return readHeader(bytes);
+      },
+      write(model, opts) {
+        const o = opts && typeof opts === "object" ? opts : {};
+        let skipped = [], bytes;
+        if (model && model._raw && typeof model._raw.resolve === "function") {
+          const indirects = assembleIndirects(model, o.strict === !0 ? { strict: !0 } : void 0);
+          skipped = indirects.skippedObjects || [];
+          bytes = writeDocument({
+            indirects,
+            root: model.catalog.pages ? { num: model.trailer.root.num, gen: model.trailer.root.gen } : model.trailer.root,
+            info: model.trailer.info,
+            id: model.trailer.id,
+            version: "2.0"
+          });
+        } else
+          bytes = writeDocument(model);
+        if (skipped.length > 0 && typeof o.onSkipped === "function")
+          o.onSkipped(skipped.slice());
+        Object.defineProperty(bytes, "skippedObjects", {
+          value: skipped,
+          enumerable: !1,
+          writable: !0,
+          configurable: !0
+        });
+        return bytes;
+      },
+      use(ext) {
+        if (!ext || typeof ext.name !== "string" || typeof ext.register !== "function")
+          throw new ContractError("pdf/use/bad-extension", ".use() requires { name: string, register: function }", { context: { keys: ext && Object.keys(ext) } });
+        if (usedExtensions.has(ext.name))
+          return api;
+        usedExtensions.add(ext.name);
+        const next = ext.register(api, { usedExtensions });
+        if (next && typeof next === "object") {
+          for (const k of Object.keys(next))
+            if (k !== "use")
+              api[k] = next[k];
+        }
+        return api;
+      },
+      usedExtension(name) {
+        return usedExtensions.has(name);
+      }
+    };
+    return api;
+  } });
+
+    const __core = __resolve("pdf");
+    return __core;
+    }
+};