@poe-platform/safe-bash 0.1.811 → 0.1.813

package/dist/safe-bash-command-pdftk/index.js

@@ -1,16 +1,51 @@
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
-// packages/safe-bash-command-pdftk/src/retained.ts
-import { PdfError, PdfFileSource, PdfRetainedDocument, retainedCosObjects } from "../pdf-ast/index.js";
-import { FsError } from "../safe-bash-contracts/errors.js";
-import { writeBytes } from "../safe-bash-contracts/io.js";
-import { resolvePath } from "../safe-bash-contracts/path.js";
-import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
+// packages/safe-bash-command-pdftk/src/burst-filename.ts
+function formatBurstFilename(pattern, pageNum) {
+  let out = "";
+  let replaced = false;
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] !== "%") {
+      out += pattern[i];
+      continue;
+    }
+    if (pattern[i + 1] === "%") {
+      out += "%";
+      i++;
+      continue;
+    }
+    if (!replaced) {
+      let j = i + 1;
+      let zeroPad = false;
+      if (pattern[j] === "0") {
+        zeroPad = true;
+        j++;
+      }
+      let widthStr = "";
+      while (j < pattern.length && pattern[j] >= "0" && pattern[j] <= "9") {
+        widthStr += pattern[j];
+        j++;
+      }
+      if (pattern[j] === "d") {
+        const width = widthStr ? Number.parseInt(widthStr, 10) : 1;
+        out += zeroPad ? String(pageNum).padStart(width, "0") : String(pageNum);
+        replaced = true;
+        i = j;
+        continue;
+      }
+    }
+    out += "%";
+  }
+  return out;
+}
 
-// packages/safe-bash-command-pdftk/src/retained-annots.ts
+// packages/safe-bash-command-pdftk/src/retained-burst.ts
+import { createRetainedPageCopy, saveRetainedDocumentChunks } from "../pdf-ast/index.js";
+
+// packages/safe-bash-command-pdftk/src/retained-inspection.ts
 import { IntegerTable, PagedStorage } from "@poe-platform/safe-fs/storage";
-import { PdfMutableObjectStore, decodePdfString, dictGet } from "../pdf-ast/index.js";
-async function* retainedAnnotationReport(document, storage, utf8, signal) {
+import { PdfMutableObjectStore, PdfNameIndex, cosArray, cosNumber, decodePdfString, dictGet } from "../pdf-ast/index.js";
+async function* retainedInspectionReport(document, storage, utf8, signal, kind) {
   const backing = new PagedStorage({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pages = new IntegerTable(backing, 64);
   let pageCount = 0, work = 0, failed = false;
   const encoder = new TextEncoder();
@@ -41,26 +76,34 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
     if (!start) return;
     const stack = new PdfMutableObjectStore(storage, { signal }), seen = new IntegerTable(backing, 64);
     let pending = 0, failed2 = false;
-    const push = async (value) => {
+    const push = async (value, level = 1) => {
       await checkpoint();
-      await stack.set({ objectNumber: ++pending, generationNumber: 0, value });
+      await stack.set({ objectNumber: ++pending, generationNumber: 0, value: cosArray([value, cosNumber(level)]) });
     };
     try {
       await push(start);
       while (pending) {
         await checkpoint();
-        const raw = (await stack.get(pending--)).value;
+        const frame = (await stack.get(pending--)).value;
+        if (frame.kind !== "array") continue;
+        const raw = frame.items[0], levelNode = frame.items[1], level = levelNode.kind === "number" ? levelNode.value : 1;
         if (raw.kind === "ref") {
           if (await seen.get(BigInt(raw.objectNumber))) continue;
           await seen.set(BigInt(raw.objectNumber), 1n);
         }
         const value = await resolve(raw);
         if (value?.kind === "array" && key === "Next") {
-          for (let i = value.items.length - 1; i >= 0; i--) await push(value.items[i]);
+          for (let i = value.items.length - 1; i >= 0; i--) await push(value.items[i], level);
           continue;
         }
         if (value?.kind !== "dict") continue;
-        yield value;
+        yield { dict: value, level };
+        if (key === "Outlines") {
+          const next = dictGet(value, "Next"), first = dictGet(value, "First");
+          if (next) await push(next, level);
+          if (first) await push(first, level + 1);
+          continue;
+        }
         const child = dictGet(value, key);
         if (key === "Next") {
           if (child) await push(child);
@@ -93,7 +136,7 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
         if (legacy?.kind === "dict") target = dictGet(legacy, name);
         if (!target) {
           const names = await resolve(dictGet(root, "Names"));
-          if (names?.kind === "dict") for await (const branch of walk(dictGet(names, "Dests"), "Kids")) {
+          if (names?.kind === "dict") for await (const { dict: branch } of walk(dictGet(names, "Dests"), "Kids")) {
             const pairs = await resolve(dictGet(branch, "Names"));
             if (pairs?.kind === "array") for (let i = 0; i + 1 < pairs.items.length; i += 2) {
               const key = await resolve(pairs.items[i]);
@@ -147,6 +190,40 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
       pageCount++;
       if (page.reference && !await pages.get(BigInt(page.reference.objectNumber))) await pages.set(BigInt(page.reference.objectNumber), BigInt(page.index + 1));
     }
+    if (kind === "document") {
+      const emitted = new PdfNameIndex(storage, Infinity, signal);
+      let failed2 = false;
+      try {
+        const info = await resolve(document.crossReference.infoRef);
+        if (info?.kind === "dict") {
+          for (const key of ["Title", "Author", "Subject", "Keywords", "Creator", "Producer"]) {
+            const node = await resolve(dictGet(info, key));
+            const value = node?.kind === "string" ? decodePdfString(node) : node?.kind === "name" ? node.decoded : "";
+            if (value) {
+              await emitted.intern(key);
+              yield* line("", "InfoBegin");
+              yield* line("InfoKey: ", key, true);
+              yield* line("InfoValue: ", value, true);
+            }
+          }
+          for (const entry of info.entries) {
+            const node = await resolve(entry.value), value = node?.kind === "string" ? decodePdfString(node) : "";
+            if (value && (await emitted.intern(entry.key.decoded)).added) {
+              yield* line("", "InfoBegin");
+              yield* line("InfoKey: ", entry.key.decoded, true);
+              yield* line("InfoValue: ", value, true);
+            }
+          }
+        }
+      } catch (error) {
+        failed2 = true;
+        throw error;
+      } finally {
+        await emitted.close().catch((error) => {
+          if (!failed2) throw error;
+        });
+      }
+    }
     for (let i = 0; i < 2; i++) {
       const id = await resolve(document.crossReference.idArray?.items[i]);
       if (id?.kind !== "string") yield* line(`PdfID${i}: `, "00000000000000000000000000000000");
@@ -162,6 +239,75 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
       }
     }
     yield* line("NumberOfPages: ", pageCount);
+    if (kind === "document") {
+      const catalog = await resolve(document.crossReference.rootRef);
+      const outlines = catalog?.kind === "dict" ? await resolve(dictGet(catalog, "Outlines")) : void 0;
+      if (outlines?.kind === "dict") for await (const { dict, level } of walk(dictGet(outlines, "First"), "Outlines")) {
+        const titleNode = await resolve(dictGet(dict, "Title"));
+        const title = titleNode?.kind === "string" ? decodePdfString(titleNode) : titleNode?.kind === "name" ? titleNode.decoded : "";
+        const index = await destinationIndex(dictGet(dict, "Dest") ?? dictGet(dict, "A"));
+        if (title) {
+          yield* line("", "BookmarkBegin");
+          yield* line("BookmarkTitle: ", title, true);
+          yield* line("BookmarkLevel: ", level);
+          yield* line("BookmarkPageNumber: ", index === void 0 ? 1 : index + 1);
+        }
+      }
+      async function rectangle(raw, strict) {
+        const node = await resolve(raw);
+        if (node?.kind !== "array" || node.items.length < 4) return;
+        const result = [];
+        for (const item of node.items.slice(0, 4)) {
+          const number = await resolve(item);
+          if (strict && number?.kind !== "number") return;
+          result.push(number?.kind === "number" ? number.value : 0);
+        }
+        return result;
+      }
+      for await (const page of document.pages()) {
+        let media, rotate, hasMedia = false, hasRotate = false;
+        for await (const parent of document.pageAncestors(page.dict)) {
+          if (!hasMedia && dictGet(parent, "MediaBox")) {
+            hasMedia = true;
+            media = dictGet(parent, "MediaBox");
+          }
+          if (!hasRotate && dictGet(parent, "Rotate")) {
+            hasRotate = true;
+            rotate = dictGet(parent, "Rotate");
+          }
+          if (hasMedia && hasRotate) break;
+        }
+        const box = await rectangle(media, true) ?? [0, 0, 612, 792], width = Math.abs(box[2] - box[0]), height = Math.abs(box[3] - box[1]);
+        const rotation = await resolve(rotate), norm = rotation?.kind === "number" ? (rotation.value % 360 + 360) % 360 : 0;
+        const direct = await rectangle(dictGet(page.dict, "MediaBox"), false) ?? [0, 0, width, height];
+        yield* line("", "PageMediaBegin");
+        yield* line("PageMediaNumber: ", page.index + 1);
+        yield* line("PageMediaRotation: ", norm === 90 || norm === 180 || norm === 270 ? norm : 0);
+        yield* line("PageMediaRect: ", direct.join(" "));
+        yield* line("PageMediaDimensions: ", `${width} ${height}`);
+        const crop = await rectangle(dictGet(page.dict, "CropBox"), false);
+        if (crop) {
+          yield* line("PageMediaCropBox: ", crop.join(" "));
+          yield* line("PageMediaCropRect: ", crop.join(" "));
+        }
+      }
+      const styles = { D: "DecimalArabicNumerals", R: "UppercaseRomanNumerals", r: "LowercaseRomanNumerals", A: "UppercaseLetters", a: "LowercaseLetters" };
+      if (catalog?.kind === "dict") for await (const { dict } of walk(dictGet(catalog, "PageLabels"), "Kids")) {
+        const pairs = await resolve(dictGet(dict, "Nums"));
+        if (pairs?.kind !== "array") continue;
+        for (let i = 0; i + 1 < pairs.items.length; i += 2) {
+          const number = await resolve(pairs.items[i]), label = await resolve(pairs.items[i + 1]);
+          if (number?.kind !== "number" || label?.kind !== "dict") continue;
+          const start = await resolve(dictGet(label, "St")), prefix = await resolve(dictGet(label, "P")), style = await resolve(dictGet(label, "S"));
+          yield* line("", "PageLabelBegin");
+          yield* line("PageLabelNewIndex: ", Math.max(1, number.value + 1));
+          yield* line("PageLabelStart: ", start?.kind === "number" ? start.value : 1);
+          if (prefix?.kind === "string" && decodePdfString(prefix)) yield* line("PageLabelPrefix: ", decodePdfString(prefix), true);
+          yield* line("PageLabelNumStyle: ", style?.kind === "name" ? styles[style.decoded] ?? "NoNumber" : "NoNumber");
+        }
+      }
+      return;
+    }
     for await (const page of document.pages()) {
       const annotations = await resolve(dictGet(page.dict, "Annots"));
       if (annotations?.kind !== "array") continue;
@@ -195,7 +341,7 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
         yield* line("AnnotFlags: ", flags?.kind === "number" ? flags.value : 0);
         yield* line("AnnotPageNumber: ", page.index + 1);
         const action = dictGet(annotation, "A");
-        if (action) for await (const dict of walk(action, "Next")) {
+        if (action) for await (const { dict } of walk(action, "Next")) {
           const type = await resolve(dictGet(dict, "S"));
           if (type?.kind === "name" && type.decoded) yield* line("AnnotActionType: ", type.decoded);
           yield* stringField(dict, "URI", "AnnotActionURI: ");
@@ -229,10 +375,466 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
   }
 }
 
+// packages/safe-bash-command-pdftk/src/retained-burst.ts
+async function* retainedBurst(document, storage, options, pageCount, signal) {
+  const pattern = options.outputTarget ?? "pg_%04d.pdf";
+  const slash = pattern.lastIndexOf("/");
+  const report = slash < 0 ? "doc_data.txt" : `${pattern.slice(0, slash + 1)}doc_data.txt`;
+  const repeated = formatBurstFilename(pattern, 1) === formatBurstFilename(pattern, 2);
+  for (let index = repeated ? Math.max(0, pageCount - 1) : 0; index < pageCount; index++) {
+    signal.throwIfAborted();
+    const path = formatBurstFilename(pattern, index + 1);
+    if (path === "-" || path === report) continue;
+    const copy = await createRetainedPageCopy(document, [index], storage, { signal });
+    let failed = false;
+    try {
+      const chunks = options.compressStreams || options.uncompressStreams ? saveRetainedDocumentChunks(await copy.openDocument(), storage, { signal, streamMode: options.uncompressStreams ? "uncompress" : "compress" }) : copy.chunks();
+      yield { path, chunks };
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      await copy.close().catch((error) => {
+        if (!failed) throw error;
+      });
+    }
+  }
+  yield { path: report, chunks: retainedInspectionReport(document, storage, false, signal, "document") };
+}
+
+// packages/safe-bash-command-pdftk/src/retained-rotate.ts
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+async function* retainedRotations(args, handles, primaryHandle, pageCount, storage, signal) {
+  const records = new PagedStorage2({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const base = records.allocate(pageCount * 16);
+  let failed = false, work = 0;
+  try {
+    for (const arg of args) for (const selection of iteratePdftkRangeToken(arg, handles, primaryHandle)) {
+      signal.throwIfAborted();
+      if (++work % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+      if (!selection.rotation || selection.pageNumber > pageCount) continue;
+      const bytes = new Uint8Array(16), view = new DataView(bytes.buffer);
+      view.setFloat64(0, selection.rotation.kind === "relative" ? 2 : 1);
+      view.setFloat64(8, selection.rotation.degrees);
+      await records.write(base + (selection.pageNumber - 1) * 16, bytes);
+    }
+    for (let pageIndex = 0; pageIndex < pageCount; pageIndex++) {
+      signal.throwIfAborted();
+      if (++work % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+      const bytes = await records.read(base + pageIndex * 16, 16), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length), kind = view.getFloat64(0);
+      if (kind) yield { pageIndex, degrees: view.getFloat64(8), relative: kind === 2 };
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    await records.close().catch((error) => {
+      if (!failed) throw error;
+    });
+  }
+}
+
+// packages/safe-bash-command-pdftk/src/retained-output.ts
+import { editRetainedDocument, PdfFileSource, PdfMutableObjectStore as PdfMutableObjectStore2, PdfRetainedDocument, cosBool, dictDelete, dictGet as dictGet2, dictSet, encryptRetainedPdfChunks, retainedCosObjects, saveRetainedDocumentChunks as saveRetainedDocumentChunks2 } from "../pdf-ast/index.js";
+async function* retainedOutput(source, storage, options, selectedId, signal, handles, pageCount, attachments, attachmentPage, stamps) {
+  const store = new PdfMutableObjectStore2(storage, { signal });
+  let edited;
+  let document, plaintext, failed = false;
+  try {
+    if (options.operation === "attach_files" || stamps) {
+      const pageIndex = attachmentPage !== void 0 && pageCount > 0 ? attachmentPage.toLowerCase() === "end" ? pageCount - 1 : Math.max(0, Math.min(pageCount - 1, (Number.parseInt(attachmentPage, 10) || 1) - 1)) : void 0;
+      edited = await editRetainedDocument(source, storage, { signal, ...options.operation === "attach_files" ? { appendAttachments: attachments } : {}, ...stamps ? { stamps } : {}, ...pageIndex !== void 0 ? { attachmentPageIndex: pageIndex } : {} });
+    }
+    const input = edited?.document ?? source;
+    const pageReferences = edited ? { pageReferences: async function* () {
+      for await (const page of input.pages()) if (page.reference) yield page.reference;
+    } } : {};
+    for await (const object of retainedCosObjects(input, storage, { signal })) await store.set(object);
+    const reference = source.crossReference;
+    const idArray = options.keepFinalId || options.keepFirstId ? selectedId ?? reference.idArray : reference.idArray ?? selectedId;
+    document = await PdfRetainedDocument.openStore(store, storage, { rootRef: reference.rootRef, version: reference.version, ...pageReferences, ...reference.infoRef ? { infoRef: reference.infoRef } : {}, ...idArray ? { idArray } : {}, signal });
+    const root = await document.lookup(reference.rootRef);
+    if (root?.value.kind === "dict" && !root.stream && root.reference) {
+      const form = await document.lookup(dictGet2(root.value, "AcroForm"));
+      if (form?.value.kind === "dict" && !form.stream) {
+        if (options.dropXfa) dictDelete(form.value, "XFA");
+        if (options.needAppearances) dictSet(form.value, "NeedAppearances", cosBool(true));
+        if (form.reference) await store.set({ objectNumber: form.reference.objectNumber, generationNumber: form.reference.generationNumber, value: form.value });
+        else dictSet(root.value, "AcroForm", form.value);
+      }
+      await store.set({ objectNumber: root.reference.objectNumber, generationNumber: root.reference.generationNumber, value: root.value });
+    }
+    const chunks = saveRetainedDocumentChunks2(document, storage, { signal, ...options.operation === "rotate" ? { rotations: retainedRotations(options.opArgs, handles, options.inputs[0].handle, pageCount, storage, signal) } : {}, removeMetadata: options.dropXmp, streamMode: options.uncompressStreams ? "uncompress" : options.compressStreams ? "compress" : "preserve" });
+    if (!options.userPassword && !options.ownerPassword) {
+      yield* chunks;
+      return;
+    }
+    plaintext = await PdfFileSource.fromStream(storage.fs, storage.directory, chunks, { signal });
+    const allow = options.allowPermissions, all = allow.has("allfeatures");
+    yield* encryptRetainedPdfChunks(plaintext, storage, {
+      userPassword: options.userPassword ?? "",
+      ownerPassword: options.ownerPassword ?? options.userPassword ?? "owner",
+      revision: 6,
+      signal,
+      ...allow.size ? { permissions: { print: all || allow.has("printing") || allow.has("degradedprinting"), modify: all || allow.has("modifycontents"), copy: all || allow.has("copycontents"), addNotes: all || allow.has("modifyannotations"), fillForms: all || allow.has("fillin") || allow.has("modifyannotations"), extractAccessibility: all || allow.has("screenreaders"), assemble: all || allow.has("assembly") || allow.has("modifycontents"), printHighRes: all || allow.has("printing") } } : {}
+    });
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([document?.close(), plaintext?.close(), store.close(), edited?.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
+// packages/safe-bash-command-pdftk/src/retained-unpack.ts
+import { IntegerTable as IntegerTable2, PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+import { PdfFileSource as PdfFileSource2, PdfMutableObjectStore as PdfMutableObjectStore3, PdfNameIndex as PdfNameIndex2, cosDict, cosString, decodePdfString as decodePdfString2, dictGet as dictGet3 } from "../pdf-ast/index.js";
+async function* retainedUnpack(document, storage, directory, inputNames, signal) {
+  const names = new PdfNameIndex2(storage, Infinity, signal), outputs = new PdfMutableObjectStore3(storage, { signal });
+  const stack = new PdfMutableObjectStore3(storage, { signal }), backing = new PagedStorage3({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), seen = new IntegerTable2(backing, 64);
+  const cleanDir = directory.endsWith("/") ? directory.slice(0, -1) : directory;
+  let pending = 0, work = 0, failed = false;
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+    signal.throwIfAborted();
+  }
+  async function resolve(node) {
+    await checkpoint();
+    const found = await document.lookup(node);
+    return found?.stream ? void 0 : found?.value;
+  }
+  async function spec(raw, fallback = "attachment.bin") {
+    const dict = await resolve(raw);
+    if (dict?.kind !== "dict") return;
+    const filename = await resolve(dictGet3(dict, "UF") ?? dictGet3(dict, "F"));
+    const name = filename?.kind === "string" ? decodePdfString2(filename) : fallback;
+    const leaf = name.slice(Math.max(name.lastIndexOf("/"), name.lastIndexOf("\\")) + 1);
+    if (!leaf || leaf === "." || leaf === ".." || leaf.includes("\0")) throw new Error("Invalid embedded attachment filename");
+    const ef = await resolve(dictGet3(dict, "EF"));
+    if (ef?.kind !== "dict") return;
+    const data = await document.lookup(dictGet3(ef, "UF") ?? dictGet3(ef, "F") ?? dictGet3(ef, "DOS") ?? dictGet3(ef, "Mac") ?? dictGet3(ef, "Unix"));
+    if (!data?.stream || !data.reference) return;
+    const path = cleanDir && cleanDir !== "." ? `${cleanDir}/${leaf}` : leaf;
+    const nameIndex = await names.intern(path);
+    const staged = await PdfFileSource2.fromStream(storage.fs, storage.directory, document.objects.decodeStream(data.reference.objectNumber, data.reference.generationNumber), { signal });
+    let failed2 = false;
+    try {
+      await outputs.set({ objectNumber: nameIndex.index + 1, generationNumber: 0, value: cosDict({ Path: cosString(path) }), stream: { length: staged.size, chunks: staged.stream(0, staged.size, signal) } });
+    } catch (error) {
+      failed2 = true;
+      throw error;
+    } finally {
+      await staged.close().catch((error) => {
+        if (!failed2) throw error;
+      });
+    }
+  }
+  const push = async (value) => {
+    await checkpoint();
+    await stack.set({ objectNumber: ++pending, generationNumber: 0, value });
+  };
+  async function associated(raw) {
+    const array = await resolve(raw);
+    if (array?.kind === "array") for (const item of array.items) await spec(item);
+  }
+  try {
+    for (const name of inputNames) await names.intern(name);
+    const root = await resolve(document.crossReference.rootRef);
+    if (root?.kind === "dict") {
+      const dictionary = await resolve(dictGet3(root, "Names")), tree = dictionary?.kind === "dict" ? dictGet3(dictionary, "EmbeddedFiles") : void 0;
+      if (tree) await push(tree);
+      while (pending) {
+        await checkpoint();
+        const raw = (await stack.get(pending--)).value;
+        if (raw.kind === "ref") {
+          if (await seen.get(BigInt(raw.objectNumber))) continue;
+          await seen.set(BigInt(raw.objectNumber), 1n);
+        }
+        const branch = await resolve(raw);
+        if (branch?.kind !== "dict") continue;
+        const pairs = await resolve(dictGet3(branch, "Names"));
+        if (pairs?.kind === "array") for (let i = 0; i + 1 < pairs.items.length; i += 2) {
+          const name = await resolve(pairs.items[i]);
+          await spec(pairs.items[i + 1], name?.kind === "string" ? decodePdfString2(name) : "attachment.bin");
+        }
+        const kids = await resolve(dictGet3(branch, "Kids"));
+        if (kids?.kind === "array") for (let i = kids.items.length - 1; i >= 0; i--) await push(kids.items[i]);
+      }
+      await associated(dictGet3(root, "AF"));
+    }
+    for await (const page of document.pages()) {
+      await associated(dictGet3(page.dict, "AF"));
+      const annotations = await resolve(dictGet3(page.dict, "Annots"));
+      if (annotations?.kind === "array") for (const raw of annotations.items) {
+        const annotation = await resolve(raw);
+        if (annotation?.kind !== "dict") continue;
+        const type = await resolve(dictGet3(annotation, "Subtype"));
+        if (type?.kind === "name" && type.decoded === "FileAttachment") await spec(dictGet3(annotation, "FS"));
+      }
+    }
+    for await (const output of outputs.objects()) {
+      const path = output.value.kind === "dict" ? dictGet3(output.value, "Path") : void 0;
+      if (path?.kind === "string" && output.stream) {
+        const name = decodePdfString2(path);
+        if (name !== "-") yield { path: name, chunks: output.stream.chunks };
+      }
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([names.close(), outputs.close(), stack.close(), backing.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
+// packages/safe-bash-command-pdftk/src/retained-fdf.ts
+import { PdfError, PdfFileSource as PdfFileSource3, PdfMutableObjectStore as PdfMutableObjectStore4, PdfNameIndex as PdfNameIndex3, cosArray as cosArray2, cosDict as cosDict2, cosNumber as cosNumber2, cosString as cosString2, decodePdfString as decodePdfString3, dictGet as dictGet4 } from "../pdf-ast/index.js";
+async function* retainedFdf(document, storage, signal) {
+  const names = new PdfNameIndex3(storage, Infinity, signal);
+  const values = new PdfMutableObjectStore4(storage, { signal });
+  const tree = new PdfMutableObjectStore4(storage, { signal });
+  const encoder = new TextEncoder();
+  let work = 0, failed = false;
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+    signal.throwIfAborted();
+  }
+  async function resolve(node) {
+    await checkpoint();
+    const found = await document.lookup(node);
+    return found?.stream ? void 0 : found?.value;
+  }
+  async function* text(value, escape = false) {
+    let chunk = "";
+    for (const char of value) {
+      chunk += escape ? char === "\\" || char === "(" || char === ")" ? `\\${char}` : char === "\r" ? "\\r" : char === "\n" ? "\\n" : char : char;
+      if (chunk.length >= 4096) {
+        await checkpoint();
+        yield encoder.encode(chunk);
+        chunk = "";
+      }
+    }
+    if (chunk) {
+      signal.throwIfAborted();
+      yield encoder.encode(chunk);
+    }
+  }
+  async function* fieldValue(field) {
+    if (field.checked !== void 0) {
+      yield* text(`/${field.checked ? field.stateValue ?? "Yes" : "Off"}`);
+      return;
+    }
+    let count = 0;
+    for await (const ignored of field.values()) {
+      void ignored;
+      if (++count > 1) break;
+    }
+    if (count > 1) yield* text("[ ");
+    let first = true;
+    for await (const value of field.values()) {
+      if (!first) yield* text(" ");
+      first = false;
+      yield* text("(");
+      yield* text(value, true);
+      yield* text(")");
+    }
+    if (count > 1) yield* text(" ]");
+  }
+  async function record(id) {
+    const node = (await tree.get(id))?.value;
+    if (node?.kind !== "array") throw new PdfError("E_PARSE", "Invalid FDF traversal record");
+    return node.items;
+  }
+  const number = (items, at) => {
+    const node = items[at];
+    if (node?.kind !== "number") throw new PdfError("E_PARSE", "Invalid FDF traversal number");
+    return node.value;
+  };
+  const string = (items, at) => {
+    const node = items[at];
+    if (node?.kind !== "string") throw new PdfError("E_PARSE", "Invalid FDF traversal name");
+    return decodePdfString3(node);
+  };
+  const save = async (id, items) => tree.set({ objectNumber: id, generationNumber: 0, value: cosArray2(items) });
+  try {
+    for await (const field of document.formFieldDetails()) {
+      for await (const ignored of field.options()) void ignored;
+      const name = await names.intern(field.name);
+      const staged = await PdfFileSource3.fromStream(storage.fs, storage.directory, fieldValue(field), { signal });
+      let valueFailed = false;
+      try {
+        await values.set({ objectNumber: name.index + 1, generationNumber: 0, value: cosDict2({}), stream: { length: staged.size, chunks: staged.stream(0, staged.size, signal) } });
+      } catch (error) {
+        valueFailed = true;
+        throw error;
+      } finally {
+        await staged.close().catch((error) => {
+          if (!valueFailed) throw error;
+        });
+      }
+    }
+    const catalog = await resolve(document.crossReference.rootRef);
+    const form = catalog?.kind === "dict" ? await resolve(dictGet4(catalog, "AcroForm")) : void 0;
+    const roots = form?.kind === "dict" ? await resolve(dictGet4(form, "Fields")) : void 0;
+    await save(1, [cosDict2({}), cosString2(""), cosString2(""), ...Array.from({ length: 6 }, () => cosNumber2(0))]);
+    let top = 1, next = 1;
+    while (top) {
+      await checkpoint();
+      const frame = await record(top), node = await resolve(frame[0]);
+      const kids = top === 1 ? roots : node?.kind === "dict" ? await resolve(dictGet4(node, "Kids")) : void 0;
+      let descended = false, cursor = number(frame, 3);
+      while (kids?.kind === "array" && cursor < kids.items.length) {
+        const childNode = kids.items[cursor++], child = await resolve(childNode);
+        if (child?.kind !== "dict" || top !== 1 && !dictGet4(child, "T")) continue;
+        const name = await resolve(dictGet4(child, "T")), partial = name?.kind === "string" ? decodePdfString3(name) : "";
+        const prefix = string(frame, 1), full = prefix && partial ? `${prefix}.${partial}` : partial || prefix;
+        const depth = number(frame, 8) + 1;
+        if (depth > document.depthLimit) throw new PdfError("E_LIMIT", "PDF FDF field depth limit exceeded");
+        frame[3] = cosNumber2(cursor);
+        await save(top, frame);
+        await save(++next, [childNode, cosString2(full), cosString2(partial), cosNumber2(0), cosNumber2(0), cosNumber2(0), cosNumber2(0), cosNumber2(top), cosNumber2(depth)]);
+        top = next;
+        descended = true;
+        break;
+      }
+      if (descended) continue;
+      const parent = number(frame, 7);
+      if (parent && (number(frame, 4) || string(frame, 1) || string(frame, 2))) {
+        const owner = await record(parent), last = number(owner, 5);
+        if (last) {
+          const sibling = await record(last);
+          sibling[6] = cosNumber2(top);
+          await save(last, sibling);
+        } else owner[4] = cosNumber2(top);
+        owner[5] = cosNumber2(top);
+        await save(parent, owner);
+      }
+      top = parent;
+    }
+    yield* text("%FDF-1.2\n1 0 obj\n<< /FDF << /Fields [\n");
+    let current = number(await record(1), 4);
+    if (current) yield* text("  ");
+    while (current) {
+      await checkpoint();
+      const frame = await record(current), child = number(frame, 4);
+      yield* text("<< /T (");
+      yield* text(string(frame, 2) || string(frame, 1), true);
+      yield* text(")");
+      if (child) {
+        yield* text(" /Kids [ ");
+        current = child;
+        continue;
+      }
+      yield* text(" /V ");
+      const name = await names.intern(string(frame, 1)), value = name.added ? void 0 : await values.get(name.index + 1);
+      if (value?.stream) yield* value.stream.chunks;
+      else {
+        const dict = await resolve(frame[0]), raw = dict?.kind === "dict" ? await resolve(dictGet4(dict, "V")) : void 0;
+        if (raw?.kind === "name") yield* text(`/${raw.decoded}`);
+        else {
+          yield* text("(");
+          if (raw?.kind === "string") yield* text(decodePdfString3(raw), true);
+          yield* text(")");
+        }
+      }
+      yield* text(" >>");
+      while (current) {
+        const done = await record(current), sibling = number(done, 6), parent = number(done, 7);
+        if (sibling) {
+          yield* text(parent === 1 ? "\n  " : " ");
+          current = sibling;
+          break;
+        }
+        current = parent === 1 ? 0 : parent;
+        if (current) yield* text(" ] >>");
+      }
+    }
+    yield* text("\n] >> >>\nendobj\ntrailer\n<< /Root 1 0 R >>\n%%EOF\n");
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([names.close(), values.close(), tree.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
+// packages/safe-bash-command-pdftk/src/retained-fields.ts
+async function* retainedFieldReport(document, utf8, signal) {
+  const encoder = new TextEncoder();
+  let work = 0;
+  async function* line(prefix, value) {
+    let part = prefix;
+    for (const char of String(value)) {
+      const code = char.codePointAt(0);
+      part += !utf8 && code > 127 ? `&#${code};` : char;
+      if (part.length >= 4096) {
+        signal.throwIfAborted();
+        if (++work % 16 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+        yield encoder.encode(part);
+        part = "";
+      }
+    }
+    signal.throwIfAborted();
+    yield encoder.encode(part + "\n");
+  }
+  for await (const field of document.formFieldDetails()) {
+    yield encoder.encode("---\n");
+    yield* line("FieldType: ", field.type === "checkbox" ? "Button" : field.type === "choice" ? "Choice" : "Text");
+    yield* line("FieldName: ", field.name);
+    if (field.altName) yield* line("FieldNameAlt: ", field.altName);
+    yield* line("FieldFlags: ", field.flags);
+    for await (const value of field.values()) yield* line("FieldValue: ", value);
+    if (field.defaultValue !== void 0 && field.defaultValue !== "") yield* line("FieldValueDefault: ", field.defaultValue);
+    yield* line("FieldJustification: ", field.justification);
+    for await (const option of field.options()) yield* line("FieldStateOption: ", option);
+    if (field.maxLength !== void 0) yield* line("FieldMaxLength: ", field.maxLength);
+  }
+}
+
 // packages/safe-bash-command-pdftk/src/retained.ts
+import { PdfError as PdfError2, PdfFileSource as PdfFileSource4, PdfRetainedDocument as PdfRetainedDocument2, retainedCosObjects as retainedCosObjects2 } from "../pdf-ast/index.js";
+import { FsError } from "../safe-bash-contracts/errors.js";
+import { writeBytes } from "../safe-bash-contracts/io.js";
+import { resolvePath } from "../safe-bash-contracts/path.js";
+import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 async function executeRetainedPdftk(context, options) {
   const signal = context.signal, storage = { fs: context.fs, directory: resolvePath(context.cwd, context.env.TMPDIR || "/tmp") };
+  const handles = /* @__PURE__ */ new Map();
+  for (const input of options.inputs) {
+    handles.set(input.handle, input);
+    if (!handles.has("")) handles.set("", input);
+  }
+  const primary = options.inputs[0];
+  let idInput = handles.values().next().value;
+  if (options.keepFinalId) for (const input of handles.values()) idInput = input;
+  let selectedId;
+  const counts = /* @__PURE__ */ new Map();
   const inputs = /* @__PURE__ */ new Map();
+  const overlayPath = ["stamp", "multistamp", "background", "multibackground"].includes(options.operation) ? options.opArgs[0] ?? "-" : void 0;
+  const attachmentPaths = [];
+  let attachmentPage;
+  if (options.operation === "attach_files") for (let i = 0; i < options.opArgs.length; i++) {
+    if (options.opArgs[i].toLowerCase() === "to_page") attachmentPage = options.opArgs[++i];
+    else attachmentPaths.push(options.opArgs[i]);
+  }
+  async function* attachments() {
+    for (const path of attachmentPaths) {
+      const source = inputs.get(path);
+      if (source) yield { filename: path.slice(path.lastIndexOf("/") + 1), chunks: source.stream(0, source.size, signal) };
+    }
+  }
+  let overlayDocument;
   let document, output, total = 0, failed = false;
   const diagnostic = async (message) => {
     await writeBytes(context.stderr, new TextEncoder().encode(message), signal);
@@ -241,20 +843,20 @@ async function executeRetainedPdftk(context, options) {
   try {
     await context.fs.mkdir(storage.directory, { recursive: true, signal });
     const maximum = context.inputBudget?.maxBytes ?? Infinity;
-    if (options.inputs.some((input) => input.file === "-")) {
-      const source = await PdfFileSource.fromStream(context.fs, storage.directory, context.stdin, { signal, maxInputBytes: maximum });
+    if (options.inputs.some((input) => input.file === "-") || attachmentPaths.includes("-") || overlayPath === "-") {
+      const source = await PdfFileSource4.fromStream(context.fs, storage.directory, context.stdin, { signal, maxInputBytes: maximum });
       inputs.set("-", source);
       total += source.size;
       context.inputBudget?.check(total);
     }
-    for (const input of options.inputs) {
+    for (const input of [...options.inputs, ...attachmentPaths.map((file) => ({ file })), ...overlayPath !== void 0 ? [{ file: overlayPath }] : []]) {
       if (inputs.has(input.file)) continue;
       let source;
       try {
-        source = await PdfFileSource.open(context.fs, resolvePath(context.cwd, input.file), { signal, maxInputBytes: maximum - total });
+        source = await PdfFileSource4.open(context.fs, resolvePath(context.cwd, input.file), { signal, maxInputBytes: maximum - total });
       } catch (error) {
         signal.throwIfAborted();
-        if (error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR", "EACCES", "EISDIR"].includes(String(error.code)) || error instanceof PdfError && error.message === "PDF source must be a regular file") {
+        if (error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR", "EACCES", "EISDIR"].includes(String(error.code)) || error instanceof PdfError2 && error.message === "PDF source must be a regular file") {
           inputs.set(input.file, void 0);
           continue;
         }
@@ -269,12 +871,18 @@ async function executeRetainedPdftk(context, options) {
       if (!source) return await diagnostic(`Error: Unable to find file '${input.file}'
 `);
       try {
-        document = await PdfRetainedDocument.open(source, storage, { signal, recovery: "strict", ...input.password ? { password: input.password } : {} });
-        for await (const object of retainedCosObjects(document, storage, { signal })) if (object.stream) for await (const ignored of object.stream.chunks) void ignored;
-        for await (const ignored of document.pages()) void ignored;
+        document = await PdfRetainedDocument2.open(source, storage, { signal, recovery: "strict", ...input.password ? { password: input.password } : {} });
+        if (input === idInput) selectedId = document.crossReference.idArray;
+        for await (const object of retainedCosObjects2(document, storage, { signal })) if (object.stream) for await (const ignored of object.stream.chunks) void ignored;
+        let count = 0;
+        for await (const ignored of document.pages()) {
+          void ignored;
+          count++;
+        }
+        counts.set(input, count);
       } catch (error) {
         signal.throwIfAborted();
-        if (!(error instanceof PdfError) || error.code === "E_LIMIT" || error.code === "E_CANCELLED") throw error;
+        if (!(error instanceof PdfError2) || error.code === "E_LIMIT" || error.code === "E_CANCELLED") throw error;
         return await diagnostic(`Error: Failed to open PDF '${input.file}': ${error.message}
 `);
       }
@@ -282,14 +890,42 @@ async function executeRetainedPdftk(context, options) {
       document = void 0;
       await source.releaseCache();
     }
-    const primary = options.inputs[0];
-    document = await PdfRetainedDocument.open(inputs.get(primary.file), storage, { signal, recovery: "strict", ...primary.password ? { password: primary.password } : {} });
-    output = await PdfFileSource.fromStream(context.fs, storage.directory, retainedAnnotationReport(document, storage, options.operation.endsWith("_utf8"), signal), { signal });
+    document = await PdfRetainedDocument2.open(inputs.get(primary.file), storage, { signal, recovery: "strict", ...primary.password ? { password: primary.password } : {} });
+    let overlayPages = 0;
+    if (overlayPath !== void 0) {
+      const source = inputs.get(overlayPath);
+      if (!source) return await diagnostic(`Error: Unable to open '${overlayPath}'
+`);
+      overlayDocument = await PdfRetainedDocument2.open(source, storage, { signal, recovery: "strict" });
+      for await (const object of retainedCosObjects2(overlayDocument, storage, { signal })) if (object.stream) for await (const ignored of object.stream.chunks) void ignored;
+      for await (const ignored of overlayDocument.pages()) {
+        void ignored;
+        overlayPages++;
+      }
+    }
+    async function* stampPages() {
+      if (overlayPages) for (let targetIndex = 0; targetIndex < counts.get(primary); targetIndex++) yield { targetIndex, sourceIndex: options.operation.startsWith("multi") ? Math.min(targetIndex, overlayPages - 1) : 0 };
+    }
+    if (options.operation === "unpack_files" || options.operation === "burst") {
+      const files = options.operation === "burst" ? retainedBurst(document, storage, options, counts.get(primary), signal) : retainedUnpack(document, storage, options.outputTarget ?? ".", inputs.keys(), signal);
+      for await (const file of files) {
+        try {
+          await publish(context, resolvePath(context.cwd, file.path), file.chunks);
+        } catch (error) {
+          signal.throwIfAborted();
+          if (!(error instanceof Error) || !("code" in error)) throw error;
+          return await diagnostic(`Error: Failed to open output file '${file.path}': ${error.code}.
+`);
+        }
+      }
+      return { exitCode: 0 };
+    }
+    output = await PdfFileSource4.fromStream(context.fs, storage.directory, ["output", "rotate", "attach_files", "stamp", "multistamp", "background", "multibackground"].includes(options.operation) ? retainedOutput(document, storage, options, selectedId, signal, new Map([...handles].map(([handle, input]) => [handle, { pageCount: counts.get(input) }])), counts.get(primary), attachments(), attachmentPage, overlayDocument ? [{ source: overlayDocument, mode: options.operation.includes("background") ? "underlay" : "overlay", preserveStreams: true, pages: stampPages() }] : void 0) : options.operation === "generate_fdf" ? retainedFdf(document, storage, signal) : options.operation === "dump_data_fields" || options.operation === "dump_data_fields_utf8" ? retainedFieldReport(document, options.operation.endsWith("_utf8"), signal) : retainedInspectionReport(document, storage, options.operation.endsWith("_utf8"), signal, options.operation === "dump_data" || options.operation === "dump_data_utf8" ? "document" : "annotations"), { signal });
     const destination = options.outputTarget;
     if (!destination || destination === "-") for await (const bytes of output.stream(0, output.size, signal)) await writeBytes(context.stdout, bytes, signal);
     else {
       try {
-        await publish(context, resolvePath(context.cwd, destination), output);
+        await publish(context, resolvePath(context.cwd, destination), output.stream(0, output.size, signal));
       } catch (error) {
         signal.throwIfAborted();
         if (!(error instanceof Error) || !("code" in error)) throw error;
@@ -302,13 +938,13 @@ async function executeRetainedPdftk(context, options) {
     failed = true;
     throw error;
   } finally {
-    const results = await Promise.allSettled([document?.close(), output?.close(), ...[...inputs.values()].map((source) => source?.close())]);
+    const results = await Promise.allSettled([document?.close(), overlayDocument?.close(), output?.close(), ...[...inputs.values()].map((source) => source?.close())]);
     if (!failed) {
       for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
     }
   }
 }
-async function publish(context, path, source) {
+async function publish(context, path, chunks) {
   const fs = context.fs, signal = context.signal;
   const capabilities = await fs.capabilitiesFor?.(path, { signal, create: true, stagingAncestry: true }) ?? fs.capabilities;
   if (!capabilities.atomicFileStaging || !capabilities.retainedStagingWrite || !capabilities.retainedStagingCleanup || !capabilities.atomicStagingAncestry || !fs.prepareStagingResolution || !fs.createStagedFile || !fs.publishStagedFile) throw new FsError("ENOTSUP", { path, message: "PDF output requires retained atomic staging" });
@@ -317,7 +953,7 @@ async function publish(context, path, source) {
   let failed = false;
   try {
     if (!staging.writer || !staging.cleanup) throw new FsError("ENOTSUP", { path, message: "PDF backend omitted retained staging handles" });
-    for await (const bytes of source.stream(0, source.size, signal)) await writeFileOutput(context, bytes, (data) => staging.writer.write(data, { signal }));
+    for await (const bytes of chunks) await writeFileOutput(context, bytes, (data) => staging.writer.write(data, { signal }));
     const stat = await staging.writer.finish({ signal });
     await fs.publishStagedFile({ ...staging, file: { ...staging.file, stat } }, resolution.path, { parent: resolution.parent, destination: resolution.destination, ancestors: resolution.ancestors, commitGuard: resolution.validate, signal });
   } catch (error) {
@@ -515,17 +1151,17 @@ import { readBytes, writeBytes as writeBytes2 } from "../safe-bash-contracts/io.
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
 import {
   PdfDocument,
-  cosArray,
-  cosDict,
+  cosArray as cosArray3,
+  cosDict as cosDict3,
   cosHexString,
   cosName,
-  cosNumber,
+  cosNumber as cosNumber3,
   cosStream,
-  cosString,
-  decodePdfString as decodePdfString2,
-  dictDelete,
-  dictGet as dictGet2,
-  dictSet,
+  cosString as cosString3,
+  decodePdfString as decodePdfString4,
+  dictDelete as dictDelete2,
+  dictGet as dictGet5,
+  dictSet as dictSet2,
   flattenDocumentFormFields,
   getDocumentFormFields,
   parseFormDataBytes,
@@ -583,6 +1219,9 @@ function resolvePageEndpoint(token, totalPages) {
   return Number.isFinite(num) && num >= 1 ? Math.min(totalPages, num) : 1;
 }
 function parsePdftkRangeToken(token, handles, defaultHandle) {
+  return Array.from(iteratePdftkRangeToken(token, handles, defaultHandle));
+}
+function* iteratePdftkRangeToken(token, handles, defaultHandle) {
   let work = token.trim();
   let handle = defaultHandle;
   const sortedHandleKeys = [...handles.keys()].sort((a, b) => b.length - a.length);
@@ -628,22 +1267,11 @@ function parsePdftkRangeToken(token, handles, defaultHandle) {
       endPage = resolvePageEndpoint(work.slice(dashIdx + 1), totalPages);
     }
   }
-  const pages = [];
-  if (startPage <= endPage) {
-    for (let p = startPage; p <= endPage; p++) pages.push(p);
-  } else {
-    for (let p = startPage; p >= endPage; p--) pages.push(p);
+  const step = startPage <= endPage ? 1 : -1;
+  for (let pageNumber = startPage; step > 0 ? pageNumber <= endPage : pageNumber >= endPage; pageNumber += step) {
+    if (qualifier === "even" && pageNumber % 2 !== 0 || qualifier === "odd" && pageNumber % 2 !== 1) continue;
+    yield { handle, pageNumber, rotation };
   }
-  const filtered = pages.filter((p) => {
-    if (qualifier === "even") return p % 2 === 0;
-    if (qualifier === "odd") return p % 2 === 1;
-    return true;
-  });
-  return filtered.map((pageNumber) => ({
-    handle,
-    pageNumber,
-    rotation
-  }));
 }
 function encodePdftkText(str, utf8) {
   if (utf8) return str;
@@ -740,40 +1368,40 @@ function formatDumpDataAnnots(doc, utf8 = false) {
   lines.push(`NumberOfPages: ${doc.pageCount}`);
   for (let p = 0; p < doc.pageCount; p++) {
     const pageDict = doc.getPage(p).pageDict;
-    const annotsArr = doc.cos.resolveArray(dictGet2(pageDict, "Annots"));
+    const annotsArr = doc.cos.resolveArray(dictGet5(pageDict, "Annots"));
     if (!annotsArr) continue;
     for (const item of annotsArr.items) {
       const annotDict = doc.cos.resolveDict(item);
       if (!annotDict) continue;
-      const subNode = doc.cos.resolve(dictGet2(annotDict, "Subtype"));
+      const subNode = doc.cos.resolve(dictGet5(annotDict, "Subtype"));
       const subtype = subNode?.kind === "name" ? subNode.decoded : "Annot";
-      const rectArr = doc.cos.resolveArray(dictGet2(annotDict, "Rect"));
+      const rectArr = doc.cos.resolveArray(dictGet5(annotDict, "Rect"));
       const rectNums = rectArr ? rectArr.items.map((it) => {
         const r = doc.cos.resolve(it);
         return r?.kind === "number" ? r.value : 0;
       }) : [0, 0, 0, 0];
-      const flagsNode = doc.cos.resolve(dictGet2(annotDict, "F"));
+      const flagsNode = doc.cos.resolve(dictGet5(annotDict, "F"));
       const flags = flagsNode?.kind === "number" ? flagsNode.value : 0;
       lines.push("---");
       lines.push(`AnnotSubtype: ${subtype}`);
       lines.push(`AnnotRect: ${rectNums.slice(0, 4).join(" ")}`);
-      const nmNode = doc.cos.resolve(dictGet2(annotDict, "NM"));
+      const nmNode = doc.cos.resolve(dictGet5(annotDict, "NM"));
       if (nmNode?.kind === "string") {
-        lines.push(`AnnotName: ${encodePdftkText(decodePdfString2(nmNode), utf8)}`);
+        lines.push(`AnnotName: ${encodePdftkText(decodePdfString4(nmNode), utf8)}`);
       }
-      const tNode = doc.cos.resolve(dictGet2(annotDict, "T"));
+      const tNode = doc.cos.resolve(dictGet5(annotDict, "T"));
       if (tNode?.kind === "string") {
-        lines.push(`AnnotTitle: ${encodePdftkText(decodePdfString2(tNode), utf8)}`);
+        lines.push(`AnnotTitle: ${encodePdftkText(decodePdfString4(tNode), utf8)}`);
       }
-      const subjNode = doc.cos.resolve(dictGet2(annotDict, "Subj"));
+      const subjNode = doc.cos.resolve(dictGet5(annotDict, "Subj"));
       if (subjNode?.kind === "string") {
-        lines.push(`AnnotSubj: ${encodePdftkText(decodePdfString2(subjNode), utf8)}`);
+        lines.push(`AnnotSubj: ${encodePdftkText(decodePdfString4(subjNode), utf8)}`);
       }
-      const cNode = doc.cos.resolve(dictGet2(annotDict, "Contents"));
+      const cNode = doc.cos.resolve(dictGet5(annotDict, "Contents"));
       if (cNode?.kind === "string") {
-        lines.push(`AnnotContents: ${encodePdftkText(decodePdfString2(cNode), utf8)}`);
+        lines.push(`AnnotContents: ${encodePdftkText(decodePdfString4(cNode), utf8)}`);
       }
-      const colArr = doc.cos.resolveArray(dictGet2(annotDict, "C"));
+      const colArr = doc.cos.resolveArray(dictGet5(annotDict, "C"));
       if (colArr && colArr.items.length >= 3) {
         const colNums = colArr.items.slice(0, 3).map((it) => {
           const r = doc.cos.resolve(it);
@@ -781,20 +1409,20 @@ function formatDumpDataAnnots(doc, utf8 = false) {
         });
         lines.push(`AnnotColor: ${colNums.join(" ")}`);
       }
-      const openNode = doc.cos.resolve(dictGet2(annotDict, "Open"));
+      const openNode = doc.cos.resolve(dictGet5(annotDict, "Open"));
       if (openNode?.kind === "boolean") {
         lines.push(`AnnotOpen: ${openNode.value}`);
       }
-      const mNode = doc.cos.resolve(dictGet2(annotDict, "M"));
+      const mNode = doc.cos.resolve(dictGet5(annotDict, "M"));
       if (mNode?.kind === "string") {
-        lines.push(`AnnotModificationDate: ${encodePdftkText(decodePdfString2(mNode), utf8)}`);
+        lines.push(`AnnotModificationDate: ${encodePdftkText(decodePdfString4(mNode), utf8)}`);
       }
       lines.push(`AnnotFlags: ${flags}`);
       lines.push(`AnnotPageNumber: ${p + 1}`);
       const formatDestTarget = (dRaw) => {
         if (!dRaw) return void 0;
         const resolved = doc.cos.resolve(dRaw);
-        if (resolved?.kind === "string") return decodePdfString2(resolved);
+        if (resolved?.kind === "string") return decodePdfString4(resolved);
         if (resolved?.kind === "name") return resolved.decoded;
         if (resolved?.kind === "array" && resolved.items.length > 0) {
           const first = resolved.items[0];
@@ -827,16 +1455,16 @@ function formatDumpDataAnnots(doc, utf8 = false) {
         }
         const actionDict = doc.cos.resolveDict(aNode);
         if (!actionDict) return;
-        const sNode = doc.cos.resolve(dictGet2(actionDict, "S"));
+        const sNode = doc.cos.resolve(dictGet5(actionDict, "S"));
         const sType = sNode?.kind === "name" ? sNode.decoded : "";
         if (sType) {
           lines.push(`AnnotActionType: ${sType}`);
         }
-        const uriNode = doc.cos.resolve(dictGet2(actionDict, "URI"));
+        const uriNode = doc.cos.resolve(dictGet5(actionDict, "URI"));
         if (uriNode?.kind === "string") {
-          lines.push(`AnnotActionURI: ${encodePdftkText(decodePdfString2(uriNode), utf8)}`);
+          lines.push(`AnnotActionURI: ${encodePdftkText(decodePdfString4(uriNode), utf8)}`);
         }
-        const dNode = dictGet2(actionDict, "D");
+        const dNode = dictGet5(actionDict, "D");
         const destTarget = formatDestTarget(dNode);
         if (destTarget) {
           lines.push(`AnnotActionDest: ${encodePdftkText(destTarget, utf8)}`);
@@ -845,23 +1473,23 @@ function formatDumpDataAnnots(doc, utf8 = false) {
         if (resolvedIdx !== void 0) {
           lines.push(`AnnotActionPageNumber: ${resolvedIdx + 1}`);
         }
-        const fRaw = doc.cos.resolve(dictGet2(actionDict, "F"));
+        const fRaw = doc.cos.resolve(dictGet5(actionDict, "F"));
         if (fRaw?.kind === "string") {
-          lines.push(`AnnotActionFile: ${encodePdftkText(decodePdfString2(fRaw), utf8)}`);
+          lines.push(`AnnotActionFile: ${encodePdftkText(decodePdfString4(fRaw), utf8)}`);
         } else if (fRaw?.kind === "dict") {
-          const ufNode = doc.cos.resolve(dictGet2(fRaw, "UF") ?? dictGet2(fRaw, "F"));
+          const ufNode = doc.cos.resolve(dictGet5(fRaw, "UF") ?? dictGet5(fRaw, "F"));
           if (ufNode?.kind === "string") {
-            lines.push(`AnnotActionFile: ${encodePdftkText(decodePdfString2(ufNode), utf8)}`);
+            lines.push(`AnnotActionFile: ${encodePdftkText(decodePdfString4(ufNode), utf8)}`);
           }
         }
-        emitActionChain(dictGet2(actionDict, "Next"), visited);
+        emitActionChain(dictGet5(actionDict, "Next"), visited);
       };
-      const rawA = dictGet2(annotDict, "A");
+      const rawA = dictGet5(annotDict, "A");
       if (rawA) {
         emitActionChain(rawA);
-      } else if (dictGet2(annotDict, "Dest")) {
+      } else if (dictGet5(annotDict, "Dest")) {
         lines.push("AnnotActionType: GoTo");
-        const dNode = dictGet2(annotDict, "Dest");
+        const dNode = dictGet5(annotDict, "Dest");
         const destTarget = formatDestTarget(dNode);
         if (destTarget) {
           lines.push(`AnnotActionDest: ${encodePdftkText(destTarget, utf8)}`);
@@ -907,18 +1535,18 @@ function collectOutlineBookmarks(doc, firstNode, level, out, visited = /* @__PUR
     }
     const dict = doc.cos.resolveDict(curr);
     if (!dict) break;
-    const titleNode = doc.cos.resolve(dictGet2(dict, "Title"));
-    const title = titleNode?.kind === "string" ? decodePdfString2(titleNode) : titleNode?.kind === "name" ? titleNode.decoded : "";
-    const resolvedIdx = resolveDestinationPageIndex(doc, dictGet2(dict, "Dest") ?? dictGet2(dict, "A"));
+    const titleNode = doc.cos.resolve(dictGet5(dict, "Title"));
+    const title = titleNode?.kind === "string" ? decodePdfString4(titleNode) : titleNode?.kind === "name" ? titleNode.decoded : "";
+    const resolvedIdx = resolveDestinationPageIndex(doc, dictGet5(dict, "Dest") ?? dictGet5(dict, "A"));
     const pageNumber = resolvedIdx !== void 0 ? resolvedIdx + 1 : 1;
     if (title) {
       out.push({ title, level, pageNumber });
     }
-    const childFirst = dictGet2(dict, "First");
+    const childFirst = dictGet5(dict, "First");
     if (childFirst) {
       collectOutlineBookmarks(doc, childFirst, level + 1, out, visited);
     }
-    curr = dictGet2(dict, "Next");
+    curr = dictGet5(dict, "Next");
   }
 }
 function collectNameTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ new Set()) {
@@ -929,16 +1557,16 @@ function collectNameTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ new
   }
   const dict = doc.cos.resolveDict(nodeOrRef);
   if (!dict) return;
-  const namesArr = doc.cos.resolveArray(dictGet2(dict, "Names"));
+  const namesArr = doc.cos.resolveArray(dictGet5(dict, "Names"));
   if (namesArr) {
     for (let i = 0; i + 1 < namesArr.items.length; i += 2) {
       const k = doc.cos.resolve(namesArr.items[i]);
       const v = namesArr.items[i + 1];
-      const name = k?.kind === "string" ? decodePdfString2(k) : "attachment.bin";
+      const name = k?.kind === "string" ? decodePdfString4(k) : "attachment.bin";
       out.push({ name, value: v });
     }
   }
-  const kidsArr = doc.cos.resolveArray(dictGet2(dict, "Kids"));
+  const kidsArr = doc.cos.resolveArray(dictGet5(dict, "Kids"));
   if (kidsArr) {
     for (const kid of kidsArr.items) {
       collectNameTreePairs(doc, kid, out, visited);
@@ -953,7 +1581,7 @@ function collectNumberTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ n
   }
   const dict = doc.cos.resolveDict(nodeOrRef);
   if (!dict) return;
-  const numsArr = doc.cos.resolveArray(dictGet2(dict, "Nums"));
+  const numsArr = doc.cos.resolveArray(dictGet5(dict, "Nums"));
   if (numsArr) {
     for (let i = 0; i + 1 < numsArr.items.length; i += 2) {
       const k = doc.cos.resolve(numsArr.items[i]);
@@ -963,7 +1591,7 @@ function collectNumberTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ n
       }
     }
   }
-  const kidsArr = doc.cos.resolveArray(dictGet2(dict, "Kids"));
+  const kidsArr = doc.cos.resolveArray(dictGet5(dict, "Kids"));
   if (kidsArr) {
     for (const kid of kidsArr.items) {
       collectNumberTreePairs(doc, kid, out, visited);
@@ -1017,7 +1645,7 @@ function formatDumpData(doc, utf8 = true) {
         if (emittedKeys.has(k)) continue;
         const r = doc.cos.resolve(entry.value);
         if (r?.kind === "string") {
-          const val = decodePdfString2(r);
+          const val = decodePdfString4(r);
           if (val) {
             emittedKeys.add(k);
             lines.push(
@@ -1038,10 +1666,10 @@ function formatDumpData(doc, utf8 = true) {
   lines.push(`PdfID1: ${id1Hex}`);
   lines.push(`NumberOfPages: ${doc.pageCount}`);
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
-  const outlinesDict = catalog ? doc.cos.resolveDict(dictGet2(catalog, "Outlines")) : void 0;
+  const outlinesDict = catalog ? doc.cos.resolveDict(dictGet5(catalog, "Outlines")) : void 0;
   if (outlinesDict) {
     const bookmarks = [];
-    collectOutlineBookmarks(doc, dictGet2(outlinesDict, "First"), 1, bookmarks);
+    collectOutlineBookmarks(doc, dictGet5(outlinesDict, "First"), 1, bookmarks);
     for (const bm of bookmarks) {
       lines.push(
         "BookmarkBegin",
@@ -1055,7 +1683,7 @@ function formatDumpData(doc, utf8 = true) {
     const page = doc.getPage(i);
     const { width, height } = page.getSize();
     const rot = page.getRotation();
-    const mbArr = doc.cos.resolveArray(dictGet2(page.pageDict, "MediaBox"));
+    const mbArr = doc.cos.resolveArray(dictGet5(page.pageDict, "MediaBox"));
     let mbRectStr = `0 0 ${width} ${height}`;
     if (mbArr && mbArr.items.length >= 4) {
       const mbNums = mbArr.items.slice(0, 4).map((item) => {
@@ -1071,7 +1699,7 @@ function formatDumpData(doc, utf8 = true) {
       `PageMediaRect: ${mbRectStr}`,
       `PageMediaDimensions: ${width} ${height}`
     );
-    const cbArr = doc.cos.resolveArray(dictGet2(page.pageDict, "CropBox"));
+    const cbArr = doc.cos.resolveArray(dictGet5(page.pageDict, "CropBox"));
     if (cbArr && cbArr.items.length >= 4) {
       const nums = cbArr.items.slice(0, 4).map((item) => {
         const r = doc.cos.resolve(item);
@@ -1083,17 +1711,17 @@ function formatDumpData(doc, utf8 = true) {
   }
   const pageLabelsPairs = [];
   if (catalog) {
-    collectNumberTreePairs(doc, dictGet2(catalog, "PageLabels"), pageLabelsPairs);
+    collectNumberTreePairs(doc, dictGet5(catalog, "PageLabels"), pageLabelsPairs);
   }
   for (const pair of pageLabelsPairs) {
     const lblDict = doc.cos.resolveDict(pair.value);
     if (lblDict) {
       const newIndex = Math.max(1, pair.num + 1);
-      const stNode = doc.cos.resolve(dictGet2(lblDict, "St"));
+      const stNode = doc.cos.resolve(dictGet5(lblDict, "St"));
       const startNum = stNode?.kind === "number" ? stNode.value : 1;
-      const pNode = doc.cos.resolve(dictGet2(lblDict, "P"));
-      const prefix = pNode?.kind === "string" ? decodePdfString2(pNode) : void 0;
-      const sNode = doc.cos.resolve(dictGet2(lblDict, "S"));
+      const pNode = doc.cos.resolve(dictGet5(lblDict, "P"));
+      const prefix = pNode?.kind === "string" ? decodePdfString4(pNode) : void 0;
+      const sNode = doc.cos.resolve(dictGet5(lblDict, "S"));
       const styleCode = sNode?.kind === "name" ? sNode.decoded : "";
       const numStyle = PDF_TO_PAGE_LABEL_STYLE[styleCode] ?? "NoNumber";
       lines.push(
@@ -1124,23 +1752,23 @@ function formatGenerateFdf(doc) {
       }
       return `(${escapeFdfString(String(f.value ?? ""))})`;
     }
-    const vNode = doc.cos.resolve(dictGet2(dict, "V"));
+    const vNode = doc.cos.resolve(dictGet5(dict, "V"));
     if (vNode?.kind === "name") return `/${vNode.decoded}`;
-    if (vNode?.kind === "string") return `(${escapeFdfString(decodePdfString2(vNode))})`;
+    if (vNode?.kind === "string") return `(${escapeFdfString(decodePdfString4(vNode))})`;
     return "()";
   };
   const serializeCosFieldNode = (nodeOrRef, prefix) => {
     const dict = doc.cos.resolveDict(nodeOrRef);
     if (!dict) return void 0;
-    const tNode = doc.cos.resolve(dictGet2(dict, "T"));
-    const partialName = tNode?.kind === "string" ? decodePdfString2(tNode) : "";
+    const tNode = doc.cos.resolve(dictGet5(dict, "T"));
+    const partialName = tNode?.kind === "string" ? decodePdfString4(tNode) : "";
     const fullName = prefix && partialName ? `${prefix}.${partialName}` : partialName || prefix;
-    const kidsArr = doc.cos.resolveArray(dictGet2(dict, "Kids"));
+    const kidsArr = doc.cos.resolveArray(dictGet5(dict, "Kids"));
     const namedKids = [];
     if (kidsArr) {
       for (const k of kidsArr.items) {
         const kDict = doc.cos.resolveDict(k);
-        if (kDict && dictGet2(kDict, "T")) {
+        if (kDict && dictGet5(kDict, "T")) {
           const serializedKid = serializeCosFieldNode(k, fullName);
           if (serializedKid) namedKids.push(serializedKid);
         }
@@ -1154,8 +1782,8 @@ function formatGenerateFdf(doc) {
   };
   const entries = [];
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
-  const acroForm = catalog ? doc.cos.resolveDict(dictGet2(catalog, "AcroForm")) : void 0;
-  const fieldsArr = acroForm ? doc.cos.resolveArray(dictGet2(acroForm, "Fields")) : void 0;
+  const acroForm = catalog ? doc.cos.resolveDict(dictGet5(catalog, "AcroForm")) : void 0;
+  const fieldsArr = acroForm ? doc.cos.resolveArray(dictGet5(acroForm, "Fields")) : void 0;
   if (fieldsArr && fieldsArr.items.length > 0) {
     for (const item of fieldsArr.items) {
       const s = serializeCosFieldNode(item, "");
@@ -1163,7 +1791,7 @@ function formatGenerateFdf(doc) {
     }
   } else {
     for (const f of fields) {
-      entries.push(`<< /T (${escapeFdfString(f.name)}) /V ${formatFieldVal(f.name, cosDict({}))} >>`);
+      entries.push(`<< /T (${escapeFdfString(f.name)}) /V ${formatFieldVal(f.name, cosDict3({}))} >>`);
     }
   }
   return `%FDF-1.2
@@ -1181,9 +1809,9 @@ function setDocumentBookmarks(doc, bookmarks) {
   if (bookmarks.length === 0 || doc.pageCount === 0) return;
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
   if (!catalog) return;
-  const outlinesDict = cosDict({ Type: cosName("Outlines") });
+  const outlinesDict = cosDict3({ Type: cosName("Outlines") });
   const outlinesRef = doc.cos.allocateObject(outlinesDict);
-  dictSet(catalog, "Outlines", outlinesRef);
+  dictSet2(catalog, "Outlines", outlinesRef);
   const stack = [{ ref: outlinesRef, dict: outlinesDict, children: [] }];
   for (const bm of bookmarks) {
     const targetLevel = Math.max(1, bm.level);
@@ -1202,22 +1830,22 @@ function setDocumentBookmarks(doc, bookmarks) {
     const parentState = stack[stack.length - 1];
     const pageIdx = Math.max(0, Math.min(doc.pageCount - 1, bm.pageNumber - 1));
     const pageRef = doc.getPage(pageIdx).ref;
-    const itemDict = cosDict({
-      Title: cosString(bm.title),
+    const itemDict = cosDict3({
+      Title: cosString3(bm.title),
       Parent: parentState.ref,
-      Dest: cosArray([pageRef, cosName("XYZ"), { kind: "null" }, { kind: "null" }, { kind: "null" }])
+      Dest: cosArray3([pageRef, cosName("XYZ"), { kind: "null" }, { kind: "null" }, { kind: "null" }])
     });
     const itemRef = doc.cos.allocateObject(itemDict);
     const prevSibling = parentState.children[parentState.children.length - 1];
     if (prevSibling) {
-      dictSet(prevSibling.dict, "Next", itemRef);
-      dictSet(itemDict, "Prev", prevSibling.ref);
+      dictSet2(prevSibling.dict, "Next", itemRef);
+      dictSet2(itemDict, "Prev", prevSibling.ref);
     } else {
-      dictSet(parentState.dict, "First", itemRef);
+      dictSet2(parentState.dict, "First", itemRef);
     }
-    dictSet(parentState.dict, "Last", itemRef);
+    dictSet2(parentState.dict, "Last", itemRef);
     parentState.children.push({ ref: itemRef, dict: itemDict });
-    dictSet(parentState.dict, "Count", cosNumber(parentState.children.length));
+    dictSet2(parentState.dict, "Count", cosNumber3(parentState.children.length));
   }
 }
 function applyUpdateInfoText(doc, text) {
@@ -1308,7 +1936,7 @@ function applyUpdateInfoText(doc, text) {
         }
         const infoDict = doc.cos.infoRef ? doc.cos.resolveDict(doc.cos.infoRef) : void 0;
         if (infoDict) {
-          dictSet(infoDict, curKey, cosString(val));
+          dictSet2(infoDict, curKey, cosString3(val));
         }
       }
       mode = "none";
@@ -1355,7 +1983,7 @@ function applyUpdateInfoText(doc, text) {
     const existing1 = doc.cos.idArray?.items[1] && doc.cos.resolve(doc.cos.idArray.items[1])?.kind === "string" ? doc.cos.resolve(doc.cos.idArray.items[1]).bytes : existing0;
     const b0 = pdfId0Hex !== void 0 ? hexToBytes(pdfId0Hex) : existing0;
     const b1 = pdfId1Hex !== void 0 ? hexToBytes(pdfId1Hex) : existing1;
-    doc.cos.idArray = cosArray([cosHexString(b0), cosHexString(b1)]);
+    doc.cos.idArray = cosArray3([cosHexString(b0), cosHexString(b1)]);
   }
   for (const [pageNum, rot] of pageRotations.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
@@ -1364,28 +1992,28 @@ function applyUpdateInfoText(doc, text) {
   }
   for (const [pageNum, [w, h]] of pageDimensions.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
-      dictSet(
+      dictSet2(
         doc.getPage(pageNum - 1).pageDict,
         "MediaBox",
-        cosArray([cosNumber(0), cosNumber(0), cosNumber(w), cosNumber(h)])
+        cosArray3([cosNumber3(0), cosNumber3(0), cosNumber3(w), cosNumber3(h)])
       );
     }
   }
   for (const [pageNum, [x0, y0, x1, y1]] of pageMediaRects.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
-      dictSet(
+      dictSet2(
         doc.getPage(pageNum - 1).pageDict,
         "MediaBox",
-        cosArray([cosNumber(x0), cosNumber(y0), cosNumber(x1), cosNumber(y1)])
+        cosArray3([cosNumber3(x0), cosNumber3(y0), cosNumber3(x1), cosNumber3(y1)])
       );
     }
   }
   for (const [pageNum, [x0, y0, x1, y1]] of pageCropBoxes.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
-      dictSet(
+      dictSet2(
         doc.getPage(pageNum - 1).pageDict,
         "CropBox",
-        cosArray([cosNumber(x0), cosNumber(y0), cosNumber(x1), cosNumber(y1)])
+        cosArray3([cosNumber3(x0), cosNumber3(y0), cosNumber3(x1), cosNumber3(y1)])
       );
     }
   }
@@ -1394,21 +2022,21 @@ function applyUpdateInfoText(doc, text) {
     if (catalog) {
       const numsItems = [];
       for (const pl of pageLabels) {
-        numsItems.push(cosNumber(Math.max(0, pl.newIndex - 1)));
+        numsItems.push(cosNumber3(Math.max(0, pl.newIndex - 1)));
         const lblEntries = {
-          St: cosNumber(pl.start)
+          St: cosNumber3(pl.start)
         };
         if (pl.prefix) {
-          lblEntries.P = cosString(pl.prefix);
+          lblEntries.P = cosString3(pl.prefix);
         }
         const pdfStyle = PAGE_LABEL_STYLE_TO_PDF[pl.style];
         if (pdfStyle) {
           lblEntries.S = cosName(pdfStyle);
         }
-        numsItems.push(cosDict(lblEntries));
+        numsItems.push(cosDict3(lblEntries));
       }
-      const plDict = cosDict({ Nums: cosArray(numsItems) });
-      dictSet(catalog, "PageLabels", doc.cos.allocateObject(plDict));
+      const plDict = cosDict3({ Nums: cosArray3(numsItems) });
+      dictSet2(catalog, "PageLabels", doc.cos.allocateObject(plDict));
     }
   }
   setDocumentBookmarks(doc, bookmarks);
@@ -1416,20 +2044,20 @@ function applyUpdateInfoText(doc, text) {
 function attachFilesToDocument(doc, filePaths, files, toPageSpec) {
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
   if (!catalog) return;
-  let namesDict = doc.cos.resolveDict(dictGet2(catalog, "Names"));
+  let namesDict = doc.cos.resolveDict(dictGet5(catalog, "Names"));
   if (!namesDict) {
-    namesDict = cosDict({});
-    dictSet(catalog, "Names", doc.cos.allocateObject(namesDict));
+    namesDict = cosDict3({});
+    dictSet2(catalog, "Names", doc.cos.allocateObject(namesDict));
   }
-  let efTree = doc.cos.resolveDict(dictGet2(namesDict, "EmbeddedFiles"));
+  let efTree = doc.cos.resolveDict(dictGet5(namesDict, "EmbeddedFiles"));
   if (!efTree) {
-    efTree = cosDict({ Names: cosArray([]) });
-    dictSet(namesDict, "EmbeddedFiles", doc.cos.allocateObject(efTree));
+    efTree = cosDict3({ Names: cosArray3([]) });
+    dictSet2(namesDict, "EmbeddedFiles", doc.cos.allocateObject(efTree));
   }
-  let namesArr = doc.cos.resolveArray(dictGet2(efTree, "Names"));
+  let namesArr = doc.cos.resolveArray(dictGet5(efTree, "Names"));
   if (!namesArr) {
-    namesArr = cosArray([]);
-    dictSet(efTree, "Names", namesArr);
+    namesArr = cosArray3([]);
+    dictSet2(efTree, "Names", namesArr);
   }
   const targetPageIdx = toPageSpec !== void 0 && doc.pageCount > 0 ? toPageSpec.toLowerCase() === "end" ? doc.pageCount - 1 : Math.max(0, Math.min(doc.pageCount - 1, (Number.parseInt(toPageSpec, 10) || 1) - 1)) : void 0;
   for (const fp of filePaths) {
@@ -1438,34 +2066,34 @@ function attachFilesToDocument(doc, filePaths, files, toPageSpec) {
     const baseName = fp.slice(fp.lastIndexOf("/") + 1);
     const efStreamRef = doc.cos.allocateObject(
       cosStream(bytes, {
-        dict: cosDict({ Type: cosName("EmbeddedFile") }),
+        dict: cosDict3({ Type: cosName("EmbeddedFile") }),
         compress: true
       })
     );
     const filespecRef = doc.cos.allocateObject(
-      cosDict({
+      cosDict3({
         Type: cosName("Filespec"),
-        F: cosString(baseName),
-        UF: cosString(baseName),
-        EF: cosDict({ F: efStreamRef })
+        F: cosString3(baseName),
+        UF: cosString3(baseName),
+        EF: cosDict3({ F: efStreamRef })
       })
     );
-    namesArr.items.push(cosString(baseName), filespecRef);
+    namesArr.items.push(cosString3(baseName), filespecRef);
     if (targetPageIdx !== void 0) {
       const pageDict = doc.getPage(targetPageIdx).pageDict;
-      let annotsArr = doc.cos.resolveArray(dictGet2(pageDict, "Annots"));
+      let annotsArr = doc.cos.resolveArray(dictGet5(pageDict, "Annots"));
       if (!annotsArr) {
-        annotsArr = cosArray([]);
-        dictSet(pageDict, "Annots", annotsArr);
+        annotsArr = cosArray3([]);
+        dictSet2(pageDict, "Annots", annotsArr);
       }
       const annotRef = doc.cos.allocateObject(
-        cosDict({
+        cosDict3({
           Type: cosName("Annot"),
           Subtype: cosName("FileAttachment"),
           Name: cosName("PushPin"),
-          Contents: cosString(baseName),
+          Contents: cosString3(baseName),
           FS: filespecRef,
-          Rect: cosArray([cosNumber(20), cosNumber(20), cosNumber(40), cosNumber(40)])
+          Rect: cosArray3([cosNumber3(20), cosNumber3(20), cosNumber3(40), cosNumber3(40)])
         })
       );
       annotsArr.items.push(annotRef);
@@ -1482,11 +2110,11 @@ function attachmentBasename(name) {
 function unpackFilesFromDocument(doc, outDir, files) {
   const cleanDir = outDir.endsWith("/") ? outDir.slice(0, -1) : outDir;
   const writeSpecDict = (specDict, fallbackName = "attachment.bin") => {
-    const ufNode = doc.cos.resolve(dictGet2(specDict, "UF") ?? dictGet2(specDict, "F"));
-    const fileName = attachmentBasename(ufNode?.kind === "string" ? decodePdfString2(ufNode) : fallbackName);
-    const efDict = doc.cos.resolveDict(dictGet2(specDict, "EF"));
+    const ufNode = doc.cos.resolve(dictGet5(specDict, "UF") ?? dictGet5(specDict, "F"));
+    const fileName = attachmentBasename(ufNode?.kind === "string" ? decodePdfString4(ufNode) : fallbackName);
+    const efDict = doc.cos.resolveDict(dictGet5(specDict, "EF"));
     const fStream = efDict ? doc.cos.resolve(
-      dictGet2(efDict, "UF") ?? dictGet2(efDict, "F") ?? dictGet2(efDict, "DOS") ?? dictGet2(efDict, "Mac") ?? dictGet2(efDict, "Unix")
+      dictGet5(efDict, "UF") ?? dictGet5(efDict, "F") ?? dictGet5(efDict, "DOS") ?? dictGet5(efDict, "Mac") ?? dictGet5(efDict, "Unix")
     ) : void 0;
     if (fStream?.kind === "stream") {
       const decoded = doc.cos.decodeStream(fStream);
@@ -1496,10 +2124,10 @@ function unpackFilesFromDocument(doc, outDir, files) {
   };
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
   if (catalog) {
-    const namesDict = doc.cos.resolveDict(dictGet2(catalog, "Names"));
+    const namesDict = doc.cos.resolveDict(dictGet5(catalog, "Names"));
     const efPairs = [];
     if (namesDict) {
-      collectNameTreePairs(doc, dictGet2(namesDict, "EmbeddedFiles"), efPairs);
+      collectNameTreePairs(doc, dictGet5(namesDict, "EmbeddedFiles"), efPairs);
     }
     for (const pair of efPairs) {
       const specDict = doc.cos.resolveDict(pair.value);
@@ -1507,7 +2135,7 @@ function unpackFilesFromDocument(doc, outDir, files) {
         writeSpecDict(specDict, pair.name);
       }
     }
-    const rootAfArr = doc.cos.resolveArray(dictGet2(catalog, "AF"));
+    const rootAfArr = doc.cos.resolveArray(dictGet5(catalog, "AF"));
     if (rootAfArr) {
       for (const item of rootAfArr.items) {
         const specDict = doc.cos.resolveDict(item);
@@ -1516,69 +2144,32 @@ function unpackFilesFromDocument(doc, outDir, files) {
     }
   }
   for (let p = 0; p < doc.pageCount; p++) {
-    const pageAfArr = doc.cos.resolveArray(dictGet2(doc.getPage(p).pageDict, "AF"));
+    const pageAfArr = doc.cos.resolveArray(dictGet5(doc.getPage(p).pageDict, "AF"));
     if (pageAfArr) {
       for (const item of pageAfArr.items) {
         const specDict = doc.cos.resolveDict(item);
         if (specDict) writeSpecDict(specDict);
       }
     }
-    const annotsArr = doc.cos.resolveArray(dictGet2(doc.getPage(p).pageDict, "Annots"));
+    const annotsArr = doc.cos.resolveArray(dictGet5(doc.getPage(p).pageDict, "Annots"));
     if (!annotsArr) continue;
     for (const item of annotsArr.items) {
       const annotDict = doc.cos.resolveDict(item);
       if (!annotDict) continue;
-      const subNode = doc.cos.resolve(dictGet2(annotDict, "Subtype"));
+      const subNode = doc.cos.resolve(dictGet5(annotDict, "Subtype"));
       if (subNode?.kind === "name" && subNode.decoded === "FileAttachment") {
-        const specDict = doc.cos.resolveDict(dictGet2(annotDict, "FS"));
+        const specDict = doc.cos.resolveDict(dictGet5(annotDict, "FS"));
         if (specDict) writeSpecDict(specDict);
       }
     }
   }
 }
-function formatBurstFilename(pattern, pageNum) {
-  let out = "";
-  let replaced = false;
-  for (let i = 0; i < pattern.length; i++) {
-    if (pattern[i] !== "%") {
-      out += pattern[i];
-      continue;
-    }
-    if (pattern[i + 1] === "%") {
-      out += "%";
-      i++;
-      continue;
-    }
-    if (!replaced) {
-      let j = i + 1;
-      let zeroPad = false;
-      if (pattern[j] === "0") {
-        zeroPad = true;
-        j++;
-      }
-      let widthStr = "";
-      while (j < pattern.length && pattern[j] >= "0" && pattern[j] <= "9") {
-        widthStr += pattern[j];
-        j++;
-      }
-      if (pattern[j] === "d") {
-        const width = widthStr ? Number.parseInt(widthStr, 10) : 1;
-        out += zeroPad ? String(pageNum).padStart(width, "0") : String(pageNum);
-        replaced = true;
-        i = j;
-        continue;
-      }
-    }
-    out += "%";
-  }
-  return out;
-}
 function cloneCosSubgraphInto(srcDoc, dstDoc, node, memo = /* @__PURE__ */ new Map()) {
   if (!node) return void 0;
   if (node.kind === "ref") {
     const cached = memo.get(node.objectNumber);
     if (cached) return cached;
-    const placeholder = dstDoc.cos.allocateObject(cosDict({}));
+    const placeholder = dstDoc.cos.allocateObject(cosDict3({}));
     memo.set(node.objectNumber, placeholder);
     const resolved = srcDoc.cos.resolve(node);
     const cloned = cloneCosSubgraphInto(srcDoc, dstDoc, resolved, memo);
@@ -1592,14 +2183,14 @@ function cloneCosSubgraphInto(srcDoc, dstDoc, node, memo = /* @__PURE__ */ new M
     return placeholder;
   }
   if (node.kind === "array") {
-    return cosArray(node.items.map((it) => cloneCosSubgraphInto(srcDoc, dstDoc, it, memo)).filter(Boolean));
+    return cosArray3(node.items.map((it) => cloneCosSubgraphInto(srcDoc, dstDoc, it, memo)).filter(Boolean));
   }
   if (node.kind === "dict") {
-    const next = cosDict({});
+    const next = cosDict3({});
     for (const entry of node.entries) {
       if (entry.key.decoded === "Parent") continue;
       const clonedVal = cloneCosSubgraphInto(srcDoc, dstDoc, entry.value, memo);
-      if (clonedVal) dictSet(next, entry.key.decoded, clonedVal);
+      if (clonedVal) dictSet2(next, entry.key.decoded, clonedVal);
     }
     return next;
   }
@@ -1664,31 +2255,31 @@ function applyOverlayToDocument(targetDoc, overlayDoc, mode, multi) {
     const srcRes = srcPage.getResourcesDict();
     const renamedResources = /* @__PURE__ */ new Map();
     for (const subKey of ["Font", "XObject", "ExtGState", "ColorSpace", "Pattern", "Shading", "Properties"]) {
-      const srcSub = overlayDoc.cos.resolveDict(dictGet2(srcRes, subKey));
+      const srcSub = overlayDoc.cos.resolveDict(dictGet5(srcRes, subKey));
       if (!srcSub) continue;
-      let dstSub = targetDoc.cos.resolveDict(dictGet2(dstRes, subKey));
+      let dstSub = targetDoc.cos.resolveDict(dictGet5(dstRes, subKey));
       if (!dstSub) {
-        dstSub = cosDict({});
-        dictSet(dstRes, subKey, dstSub);
+        dstSub = cosDict3({});
+        dictSet2(dstRes, subKey, dstSub);
       }
       for (const entry of srcSub.entries) {
         const origKey = entry.key.decoded;
         const cloned = cloneCosSubgraphInto(overlayDoc, targetDoc, entry.value, memo);
         if (!cloned) continue;
-        if (!dictGet2(dstSub, origKey)) {
-          dictSet(dstSub, origKey, cloned);
+        if (!dictGet5(dstSub, origKey)) {
+          dictSet2(dstSub, origKey, cloned);
         } else {
           let newKey = `Ov_${i}_${origKey}`;
           let suffix = 1;
-          while (dictGet2(dstSub, newKey)) {
+          while (dictGet5(dstSub, newKey)) {
             newKey = `Ov_${i}_${suffix++}_${origKey}`;
           }
-          dictSet(dstSub, newKey, cloned);
+          dictSet2(dstSub, newKey, cloned);
           renamedResources.set(origKey, newKey);
         }
       }
     }
-    const srcContents = dictGet2(srcPage.pageDict, "Contents");
+    const srcContents = dictGet5(srcPage.pageDict, "Contents");
     if (!srcContents) continue;
     const rawSrcNodes = [];
     const resolvedSrcContents = overlayDoc.cos.resolve(srcContents);
@@ -1714,7 +2305,7 @@ function applyOverlayToDocument(targetDoc, overlayDoc, mode, multi) {
       }
     }
     if (srcList.length === 0) continue;
-    const dstContents = dictGet2(dstPage.pageDict, "Contents");
+    const dstContents = dictGet5(dstPage.pageDict, "Contents");
     const toStreamList = (c) => {
       if (!c) return [];
       const r = targetDoc.cos.resolve(c);
@@ -1763,7 +2354,7 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
     const qOpenSrc = targetDoc.cos.allocateObject(cosStream(new TextEncoder().encode(srcOpenCmd), { compress: false }));
     const qClose = targetDoc.cos.allocateObject(cosStream(new TextEncoder().encode("\nQ\n"), { compress: false }));
     const combined = mode === "background" ? [qOpenSrc, ...srcList, qClose, qOpenDst, ...dstList, qClose] : [qOpenDst, ...dstList, qClose, qOpenSrc, ...srcList, qClose];
-    dictSet(dstPage.pageDict, "Contents", cosArray(combined));
+    dictSet2(dstPage.pageDict, "Contents", cosArray3(combined));
   }
 }
 function normalizeQuarterTurn(degrees) {
@@ -1837,8 +2428,8 @@ function* runPdftkCliSteps(argv, files, signal) {
           if (obj.value.kind !== "stream")
             continue;
           const raw = singleDoc.cos.decodeStream(obj.value);
-          dictDelete(obj.value.dict, "Filter");
-          dictDelete(obj.value.dict, "DecodeParms");
+          dictDelete2(obj.value.dict, "Filter");
+          dictDelete2(obj.value.dict, "DecodeParms");
           singleDoc.cos.objects.set(obj.objectNumber, {
             ...obj,
             value: cosStream(raw, {
@@ -1947,9 +2538,9 @@ function* runPdftkCliSteps(argv, files, signal) {
       if (!cached) {
         cached = [];
         const cat = d.cos.resolveDict(d.cos.rootRef);
-        const outDict = cat ? d.cos.resolveDict(dictGet2(cat, "Outlines")) : void 0;
+        const outDict = cat ? d.cos.resolveDict(dictGet5(cat, "Outlines")) : void 0;
         if (outDict) {
-          collectOutlineBookmarks(d, dictGet2(outDict, "First"), 1, cached);
+          collectOutlineBookmarks(d, dictGet5(outDict, "First"), 1, cached);
         }
         bookmarksByDoc.set(d, cached);
       }
@@ -2039,14 +2630,14 @@ function* runPdftkCliSteps(argv, files, signal) {
   }
   if (dropXfa) {
     const root = resultDoc.cos.resolveDict(resultDoc.cos.rootRef);
-    const acroForm = root ? resultDoc.cos.resolveDict(dictGet2(root, "AcroForm")) : void 0;
+    const acroForm = root ? resultDoc.cos.resolveDict(dictGet5(root, "AcroForm")) : void 0;
     if (acroForm)
-      dictDelete(acroForm, "XFA");
+      dictDelete2(acroForm, "XFA");
   }
   if (dropXmp) {
     const root = resultDoc.cos.resolveDict(resultDoc.cos.rootRef);
     if (root)
-      dictDelete(root, "Metadata");
+      dictDelete2(root, "Metadata");
   }
   if (replacementFont && operation === "fill_form") {
     const cleanFontName = replacementFont.startsWith("/") ? replacementFont.slice(1) : replacementFont;
@@ -2054,28 +2645,28 @@ function* runPdftkCliSteps(argv, files, signal) {
       if (++cooperativeWork % 64 === 0)
         yield;
       if (obj.value.kind === "dict") {
-        const stNode = dictGet2(obj.value, "Subtype");
-        const bfNode = dictGet2(obj.value, "BaseFont");
+        const stNode = dictGet5(obj.value, "Subtype");
+        const bfNode = dictGet5(obj.value, "BaseFont");
         const subtype = stNode?.kind === "name" ? stNode.decoded : void 0;
         const baseFont = bfNode?.kind === "name" ? bfNode.decoded : void 0;
         if (subtype === "Type1" && baseFont === "Helvetica") {
-          dictSet(obj.value, "BaseFont", cosName(cleanFontName));
+          dictSet2(obj.value, "BaseFont", cosName(cleanFontName));
         }
       }
     }
   }
   if (operation === "fill_form" && !shouldFlatten) {
     const root = resultDoc.cos.resolveDict(resultDoc.cos.rootRef);
-    const acroForm = root ? resultDoc.cos.resolveDict(dictGet2(root, "AcroForm")) : void 0;
+    const acroForm = root ? resultDoc.cos.resolveDict(dictGet5(root, "AcroForm")) : void 0;
     if (acroForm) {
-      dictSet(acroForm, "NeedAppearances", { kind: "boolean", value: needAppearances });
+      dictSet2(acroForm, "NeedAppearances", { kind: "boolean", value: needAppearances });
     }
   } else if (needAppearances && !shouldFlatten) {
     const root = resultDoc.cos.resolveDict(resultDoc.cos.rootRef);
     if (root) {
-      const acroForm = resultDoc.cos.resolveDict(dictGet2(root, "AcroForm"));
+      const acroForm = resultDoc.cos.resolveDict(dictGet5(root, "AcroForm"));
       if (acroForm) {
-        dictSet(acroForm, "NeedAppearances", { kind: "boolean", value: true });
+        dictSet2(acroForm, "NeedAppearances", { kind: "boolean", value: true });
       }
     }
   }
@@ -2083,12 +2674,12 @@ function* runPdftkCliSteps(argv, files, signal) {
   if (keepFinalId) {
     const lastInput = handleDocs[handleDocs.length - 1];
     if (lastInput?.cos.idArray) {
-      resultDoc.cos.idArray = cosArray([...lastInput.cos.idArray.items]);
+      resultDoc.cos.idArray = cosArray3([...lastInput.cos.idArray.items]);
     }
   } else if (keepFirstId || !resultDoc.cos.idArray) {
     const firstInput = handleDocs[0];
     if (firstInput?.cos.idArray) {
-      resultDoc.cos.idArray = cosArray([...firstInput.cos.idArray.items]);
+      resultDoc.cos.idArray = cosArray3([...firstInput.cos.idArray.items]);
     }
   }
   if (uncompressStreams || compressStreams) {
@@ -2098,8 +2689,8 @@ function* runPdftkCliSteps(argv, files, signal) {
       if (obj.value.kind !== "stream")
         continue;
       const raw = resultDoc.cos.decodeStream(obj.value);
-      dictDelete(obj.value.dict, "Filter");
-      dictDelete(obj.value.dict, "DecodeParms");
+      dictDelete2(obj.value.dict, "Filter");
+      dictDelete2(obj.value.dict, "DecodeParms");
       resultDoc.cos.objects.set(obj.objectNumber, {
         ...obj,
         value: cosStream(raw, {
@@ -2147,7 +2738,7 @@ function runPdftkCliSync(argv, files, signal) {
   }
   return next.value;
 }
-async function executePdftk(context) {
+async function executePdftk(context, retainedContext = context) {
   let cooperativeWork = 63;
   const invocation = createOutputOperation(context, { write: async () => {
   } });
@@ -2155,8 +2746,8 @@ async function executePdftk(context) {
     const carrier = getCommandArguments(context);
     const argv = [...carrier.args];
     const parsed = await drainSteps(parsePdftkArgumentsSteps(argv), invocation.signal);
-    if (parsed.options && ["dump_data_annots", "dump_data_annots_utf8"].includes(parsed.options.operation)) {
-      return await executeRetainedPdftk({ ...context, signal: invocation.signal, stdout: invocation.child(context.stdout).output }, parsed.options);
+    if (parsed.options && (["output", "rotate", "attach_files", "stamp", "multistamp", "background", "multibackground", "burst"].includes(parsed.options.operation) && !parsed.options.shouldFlatten || ["dump_data", "dump_data_utf8", "dump_data_annots", "dump_data_annots_utf8", "dump_data_fields", "dump_data_fields_utf8", "generate_fdf", "unpack_files"].includes(parsed.options.operation))) {
+      return await executeRetainedPdftk({ ...retainedContext, signal: invocation.signal, stdout: invocation.child(context.stdout).output }, parsed.options);
     }
     const vfsFiles = /* @__PURE__ */ new Map();
     let accountedBytes = 0;
@@ -2257,7 +2848,7 @@ function createPdftkCommand(options = {}) {
     runtimeIdentity: commandRuntimeIdentity,
     description: "Manipulate PDF documents, fill/flatten AcroForms, and assemble pages via @poe-code/pdf-ast",
     execute(context) {
-      return new InputByteBudget(maxInputBytes).run(context, executePdftk);
+      return new InputByteBudget(maxInputBytes).run(context, (limited) => executePdftk(limited, { ...context, inputBudget: limited.inputBudget }));
     }
   });
 }
@@ -2279,6 +2870,7 @@ function createPdftkCommands(options = {}) {
 export {
   createPdftkCommand,
   createPdftkCommands,
+  iteratePdftkRangeToken,
   parsePdftkRangeToken,
   pdftkCommand,
   pdftkCommands,