@poe-platform/safe-bash 0.1.813 → 0.1.815

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

@@ -1,5 +1,38 @@
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
+// packages/safe-bash-command-pdftk/src/info-text.ts
+function decodePdftkEntities(str) {
+  let out = "";
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] === "&" && str[i + 1] === "#") {
+      const semi = str.indexOf(";", i + 2);
+      if (semi !== -1) {
+        const body = str.slice(i + 2, semi);
+        const cp = body.startsWith("x") || body.startsWith("X") ? Number.parseInt(body.slice(1), 16) : Number.parseInt(body, 10);
+        if (Number.isFinite(cp) && cp >= 0) {
+          out += String.fromCodePoint(cp);
+          i = semi + 1;
+          continue;
+        }
+      }
+    }
+    out += str[i];
+    i++;
+  }
+  return out;
+}
+function hexToBytes(hex) {
+  const clean = hex.trim();
+  const len = Math.floor(clean.length / 2);
+  const out = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    const byteVal = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+    out[i] = Number.isNaN(byteVal) ? 0 : byteVal;
+  }
+  return out;
+}
+
 // packages/safe-bash-command-pdftk/src/burst-filename.ts
 function formatBurstFilename(pattern, pageNum) {
   let out = "";
@@ -39,14 +72,422 @@ function formatBurstFilename(pattern, pageNum) {
   return out;
 }
 
+// packages/safe-bash-command-pdftk/src/retained-assembly.ts
+import { IntegerTable as IntegerTable2, PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+import { PdfMutableObjectStore as PdfMutableObjectStore2, PdfNameIndex as PdfNameIndex2, PdfFileSource as PdfFileSource2, createRetainedPageCopy, editRetainedDocument, cosArray, cosDict as cosDict2, cosNumber, cosString as cosString2, decodePdfString as decodePdfString2, dictGet as dictGet2, dictSet } from "../pdf-ast/index.js";
+
+// packages/safe-bash-command-pdftk/src/retained-unpack.ts
+import { IntegerTable, PagedStorage } from "@poe-platform/safe-fs/storage";
+import { PdfFileSource, PdfMutableObjectStore, PdfNameIndex, cosDict, cosString, decodePdfString, dictGet } from "../pdf-ast/index.js";
+async function* retainedUnpack(document, storage, directory, inputNames, signal, includeSentinel = false) {
+  const names = new PdfNameIndex(storage, Infinity, signal), outputs = new PdfMutableObjectStore(storage, { signal });
+  const stack = new PdfMutableObjectStore(storage, { signal }), backing = new PagedStorage({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), seen = new IntegerTable(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(dictGet(dict, "UF") ?? dictGet(dict, "F"));
+    const name = filename?.kind === "string" ? decodePdfString(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(dictGet(dict, "EF"));
+    if (ef?.kind !== "dict") return;
+    const data = await document.lookup(dictGet(ef, "UF") ?? dictGet(ef, "F") ?? dictGet(ef, "DOS") ?? dictGet(ef, "Mac") ?? dictGet(ef, "Unix"));
+    if (!data?.stream || !data.reference) return;
+    const path = cleanDir && cleanDir !== "." ? `${cleanDir}/${leaf}` : leaf;
+    const nameIndex = await names.intern(path);
+    const staged = await PdfFileSource.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(dictGet(root, "Names")), tree = dictionary?.kind === "dict" ? dictGet(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(dictGet(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" ? decodePdfString(name) : "attachment.bin");
+        }
+        const kids = await resolve(dictGet(branch, "Kids"));
+        if (kids?.kind === "array") for (let i = kids.items.length - 1; i >= 0; i--) await push(kids.items[i]);
+      }
+      await associated(dictGet(root, "AF"));
+    }
+    for await (const page of document.pages()) {
+      await associated(dictGet(page.dict, "AF"));
+      const annotations = await resolve(dictGet(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(dictGet(annotation, "Subtype"));
+        if (type?.kind === "name" && type.decoded === "FileAttachment") await spec(dictGet(annotation, "FS"));
+      }
+    }
+    for await (const output of outputs.objects()) {
+      const path = output.value.kind === "dict" ? dictGet(output.value, "Path") : void 0;
+      if (path?.kind === "string" && output.stream) {
+        const name = decodePdfString(path);
+        if (includeSentinel || 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-assembly.ts
+async function assembleRetainedPdftk(primary, storage, options, counts, handles, open, signal) {
+  const backing = new PagedStorage2({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const sourceBookmarks = new PdfMutableObjectStore2(storage, { signal }), outputBookmarks = new PdfMutableObjectStore2(storage, { signal }), rotations = new PdfMutableObjectStore2(storage, { signal }), attachments = new PdfMutableObjectStore2(storage, { signal });
+  const names = new PdfNameIndex2(storage, Infinity, signal);
+  const states = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set(), rangeHandles = new Map([...handles].map(([handle, input]) => [handle, { pageCount: counts.get(input) }]));
+  let current, currentInput, copy, edited;
+  let work = 0, attachmentCount = 0, failed = false;
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+    signal.throwIfAborted();
+  }
+  async function document(input) {
+    if (currentInput !== input) {
+      await current?.close();
+      current = void 0;
+      currentInput = void 0;
+      current = await open(input);
+      currentInput = input;
+    }
+    return current;
+  }
+  function* selections() {
+    if (!options.opArgs.length) {
+      for (const input of options.inputs) for (let pageNumber = 1; pageNumber <= counts.get(input); pageNumber++) yield { handle: input.handle, pageNumber };
+    } else if (options.operation === "shuffle") {
+      const iterators = options.opArgs.map((arg) => iteratePdftkRangeToken(arg, rangeHandles, options.inputs[0].handle));
+      try {
+        let pending = true;
+        while (pending) {
+          pending = false;
+          for (const iterator of iterators) {
+            const next = iterator.next();
+            if (!next.done) {
+              pending = true;
+              yield next.value;
+            }
+          }
+        }
+      } finally {
+        for (const iterator of iterators) iterator.return(void 0);
+      }
+    } else for (const arg of options.opArgs) yield* iteratePdftkRangeToken(arg, rangeHandles, options.inputs[0].handle);
+  }
+  async function state(input, source) {
+    let result = states.get(input);
+    if (result) return result;
+    result = { bookmarks: new IntegerTable2(backing, 64), resources: new IntegerTable2(backing, 64) };
+    states.set(input, result);
+    for await (const bookmark of source.outlineDetails()) {
+      await checkpoint();
+      const key = BigInt(bookmark.pageIndex) * 2n, previous = await result.bookmarks.get(key + 1n);
+      const ref = await sourceBookmarks.allocate(cosDict2({ Title: cosString2(bookmark.title), Level: cosNumber(bookmark.level), Next: cosNumber(0) }));
+      if (previous) {
+        const row = await sourceBookmarks.get(Number(previous));
+        if (row.value.kind === "dict") {
+          dictSet(row.value, "Next", cosNumber(ref.objectNumber));
+          await sourceBookmarks.set(row);
+        }
+      } else await result.bookmarks.set(key, BigInt(ref.objectNumber));
+      await result.bookmarks.set(key + 1n, BigInt(ref.objectNumber));
+    }
+    return result;
+  }
+  async function* sources() {
+    let ordinal = 0, pageIndex = 0;
+    for (const selection of selections()) {
+      await checkpoint();
+      ordinal++;
+      const input = handles.get(selection.handle) ?? options.inputs[0], source = await document(input), record = await state(input, source);
+      used.add(input);
+      yield { document: source, indices: [selection.pageNumber - 1], resourceState: { has: async (index) => Boolean(await record.resources.get(BigInt(index))), add: async (index) => {
+        await record.resources.set(BigInt(index), 1n);
+      } } };
+      if (selection.rotation) await rotations.allocate(cosArray([cosNumber(pageIndex), cosNumber(selection.rotation.degrees), cosNumber(selection.rotation.kind === "relative" ? 1 : 0)]));
+      pageIndex++;
+      let item = Number(await record.bookmarks.get(BigInt(selection.pageNumber - 1) * 2n) ?? 0n);
+      while (item) {
+        await checkpoint();
+        const row = (await sourceBookmarks.get(item)).value;
+        if (row.kind !== "dict") throw new Error("Invalid bookmark record");
+        await outputBookmarks.allocate(cosArray([dictGet2(row, "Title"), dictGet2(row, "Level"), cosNumber(ordinal)]));
+        const next = dictGet2(row, "Next");
+        item = next?.kind === "number" ? next.value : 0;
+      }
+    }
+  }
+  async function* bookmarkEdits() {
+    for await (const object of outputBookmarks.objects()) {
+      await checkpoint();
+      const value = object.value;
+      if (value.kind !== "array" || value.items[0]?.kind !== "string" || value.items[1]?.kind !== "number" || value.items[2]?.kind !== "number") throw new Error("Invalid output bookmark");
+      yield { title: decodePdfString2(value.items[0]), level: value.items[1].value, pageNumber: value.items[2].value };
+    }
+  }
+  async function* rotationEdits() {
+    for await (const object of rotations.objects()) {
+      await checkpoint();
+      const value = object.value;
+      if (value.kind !== "array" || value.items[0]?.kind !== "number" || value.items[1]?.kind !== "number" || value.items[2]?.kind !== "number") throw new Error("Invalid output rotation");
+      yield { pageIndex: value.items[0].value, degrees: value.items[1].value, relative: value.items[2].value === 1 };
+    }
+  }
+  async function* attachmentEdits() {
+    for await (const object of attachments.objects()) {
+      await checkpoint();
+      const name = object.value.kind === "dict" ? dictGet2(object.value, "Filename") : void 0, filename = name?.kind === "string" ? decodePdfString2(name) : "";
+      if (object.stream) yield { filename, chunks: (async function* () {
+        yield* object.stream.chunks;
+      })() };
+    }
+  }
+  try {
+    copy = await createRetainedPageCopy(sources(), storage, { signal, metadata: await primary.info() });
+    for (const input of used) {
+      await checkpoint();
+      const source = await document(input);
+      for await (const file of retainedUnpack(source, storage, ".", [], signal, true)) {
+        const name = await names.intern(file.path);
+        if (name.added) attachmentCount++;
+        const payload = await PdfFileSource2.fromStream(storage.fs, storage.directory, file.chunks, { signal });
+        let failed2 = false;
+        try {
+          await attachments.set({ objectNumber: name.index + 1, generationNumber: 0, value: cosDict2({ Filename: cosString2(file.path) }), stream: { length: payload.size, chunks: payload.stream(0, payload.size, signal) } });
+        } catch (error) {
+          failed2 = true;
+          throw error;
+        } finally {
+          await payload.close().catch((error) => {
+            if (!failed2) throw error;
+          });
+        }
+      }
+    }
+    edited = await editRetainedDocument(await copy.openDocument(), storage, { signal, rotations: rotationEdits(), bookmarks: bookmarkEdits(), ...attachmentCount ? { appendAttachments: attachmentEdits() } : {} });
+    const result = edited, pages = copy;
+    return { document: result.document, async close() {
+      const results = await Promise.allSettled([result.close(), pages.close()]);
+      for (const outcome of results) if (outcome.status === "rejected") throw outcome.reason;
+    } };
+  } catch (error) {
+    failed = true;
+    await Promise.allSettled([edited?.close(), copy?.close()]);
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([current?.close(), sourceBookmarks.close(), outputBookmarks.close(), rotations.close(), attachments.close(), names.close(), backing.close()]);
+    if (!failed) {
+      for (const outcome of results) if (outcome.status === "rejected") {
+        await Promise.allSettled([edited?.close(), copy?.close()]);
+        await Promise.reject(outcome.reason);
+      }
+    }
+  }
+}
+
+// packages/safe-bash-command-pdftk/src/retained-info-updates.ts
+var styles = { DecimalArabicNumerals: "D", UppercaseRomanNumerals: "R", LowercaseRomanNumerals: "r", UppercaseLetters: "A", LowercaseLetters: "a" };
+async function* lines(chunks, signal) {
+  const decoder = new TextDecoder();
+  let pending = "", work = 0;
+  for await (const bytes of chunks) {
+    signal.throwIfAborted();
+    pending += decoder.decode(bytes, { stream: true });
+    let offset = 0, end;
+    while ((end = pending.indexOf("\n", offset)) >= 0) {
+      if (++work % 64 === 0) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        signal.throwIfAborted();
+      }
+      yield pending.slice(offset, end);
+      offset = end + 1;
+    }
+    pending = pending.slice(offset);
+  }
+  pending += decoder.decode();
+  if (pending) yield pending;
+}
+async function* retainedInfoUpdates(chunks, signal) {
+  let mode = "none";
+  let curKey = "";
+  let bmTitle = "";
+  let bmLevel = 1;
+  let bmPage = 1;
+  const pending = [];
+  let plNewIndex = 1;
+  let plStart = 1;
+  let plPrefix = "";
+  let plStyle = "DecimalArabicNumerals";
+  let pmNumber = 0;
+  let pmRotation;
+  let pmMediaRect;
+  let pmDimensions;
+  let pmCropBox;
+  const flushStanza = () => {
+    if (mode === "bookmark" && bmTitle) {
+      pending.push({ kind: "bookmark", title: bmTitle, level: Math.min(Number.MAX_SAFE_INTEGER, Math.max(1, bmLevel)), pageNumber: Math.min(Number.MAX_SAFE_INTEGER, Math.max(1, bmPage)) });
+    } else if (mode === "pagelabel") {
+      pending.push({
+        kind: "label",
+        index: Math.max(0, plNewIndex - 1),
+        start: Math.max(1, plStart),
+        prefix: plPrefix,
+        ...styles[plStyle] ? { style: styles[plStyle] } : {}
+      });
+    } else if (mode === "pagemedia" && pmNumber >= 1) {
+      if (pmRotation !== void 0) pending.push({ kind: "page", pageNumber: pmNumber, property: "rotation", values: [Number.isFinite(pmRotation) ? pmRotation : 0] });
+      if (pmMediaRect !== void 0) pending.push({ kind: "page", pageNumber: pmNumber, property: "media", values: pmMediaRect });
+      if (pmDimensions !== void 0) pending.push({ kind: "page", pageNumber: pmNumber, property: "dimensions", values: pmDimensions });
+      if (pmCropBox !== void 0) pending.push({ kind: "page", pageNumber: pmNumber, property: "crop", values: pmCropBox });
+    }
+    bmTitle = "";
+    bmLevel = 1;
+    bmPage = 1;
+    plNewIndex = 1;
+    plStart = 1;
+    plPrefix = "";
+    plStyle = "DecimalArabicNumerals";
+    pmNumber = 0;
+    pmRotation = void 0;
+    pmMediaRect = void 0;
+    pmDimensions = void 0;
+    pmCropBox = void 0;
+  };
+  for await (const raw of lines(chunks, signal)) {
+    const line = raw.trim();
+    if (line === "InfoBegin") {
+      flushStanza();
+      yield* pending;
+      pending.length = 0;
+      mode = "info";
+      curKey = "";
+    } else if (line === "BookmarkBegin") {
+      flushStanza();
+      yield* pending;
+      pending.length = 0;
+      mode = "bookmark";
+    } else if (line === "PageLabelBegin") {
+      flushStanza();
+      yield* pending;
+      pending.length = 0;
+      mode = "pagelabel";
+    } else if (line === "PageMediaBegin") {
+      flushStanza();
+      yield* pending;
+      pending.length = 0;
+      mode = "pagemedia";
+    } else if (line.startsWith("PdfID0:")) {
+      yield { kind: "id", index: 0, bytes: hexToBytes(line.slice("PdfID0:".length)) };
+    } else if (line.startsWith("PdfID1:")) {
+      yield { kind: "id", index: 1, bytes: hexToBytes(line.slice("PdfID1:".length)) };
+    } else if (mode === "info" && line.startsWith("InfoKey:")) {
+      curKey = decodePdftkEntities(line.slice("InfoKey:".length).trim());
+    } else if (mode === "info" && line.startsWith("InfoValue:") && curKey) {
+      const val = decodePdftkEntities(line.slice("InfoValue:".length).trim());
+      yield { kind: "info", key: curKey, value: val };
+      mode = "none";
+      curKey = "";
+    } else if (mode === "bookmark" && line.startsWith("BookmarkTitle:")) {
+      bmTitle = decodePdftkEntities(line.slice("BookmarkTitle:".length).trim());
+    } else if (mode === "bookmark" && line.startsWith("BookmarkLevel:")) {
+      bmLevel = Number.parseInt(line.slice("BookmarkLevel:".length).trim(), 10) || 1;
+    } else if (mode === "bookmark" && line.startsWith("BookmarkPageNumber:")) {
+      bmPage = Number.parseInt(line.slice("BookmarkPageNumber:".length).trim(), 10) || 1;
+    } else if (mode === "pagelabel" && line.startsWith("PageLabelNewIndex:")) {
+      plNewIndex = Number.parseInt(line.slice("PageLabelNewIndex:".length).trim(), 10) || 1;
+    } else if (mode === "pagelabel" && line.startsWith("PageLabelStart:")) {
+      plStart = Number.parseInt(line.slice("PageLabelStart:".length).trim(), 10) || 1;
+    } else if (mode === "pagelabel" && line.startsWith("PageLabelPrefix:")) {
+      plPrefix = decodePdftkEntities(line.slice("PageLabelPrefix:".length).trim());
+    } else if (mode === "pagelabel" && line.startsWith("PageLabelNumStyle:")) {
+      plStyle = line.slice("PageLabelNumStyle:".length).trim();
+    } else if (mode === "pagemedia" && line.startsWith("PageMediaNumber:")) {
+      pmNumber = Number.parseInt(line.slice("PageMediaNumber:".length).trim(), 10) || 0;
+    } else if (mode === "pagemedia" && line.startsWith("PageMediaRotation:")) {
+      pmRotation = Number.parseInt(line.slice("PageMediaRotation:".length).trim(), 10) || 0;
+    } else if (mode === "pagemedia" && line.startsWith("PageMediaRect:")) {
+      const parts = line.slice("PageMediaRect:".length).trim().split(" ").filter(Boolean).map(Number);
+      if (parts.length >= 4 && parts.every(Number.isFinite)) {
+        pmMediaRect = [parts[0], parts[1], parts[2], parts[3]];
+      }
+    } else if (mode === "pagemedia" && line.startsWith("PageMediaDimensions:")) {
+      const parts = line.slice("PageMediaDimensions:".length).trim().split(" ").filter(Boolean).map(Number);
+      if (parts.length >= 2 && Number.isFinite(parts[0]) && Number.isFinite(parts[1])) {
+        pmDimensions = [parts[0], parts[1]];
+      }
+    } else if (mode === "pagemedia" && (line.startsWith("PageMediaCropBox:") || line.startsWith("PageMediaCropRect:"))) {
+      const prefix = line.startsWith("PageMediaCropRect:") ? "PageMediaCropRect:" : "PageMediaCropBox:";
+      const parts = line.slice(prefix.length).trim().split(" ").filter(Boolean).map(Number);
+      if (parts.length >= 4 && parts.every(Number.isFinite)) {
+        pmCropBox = [parts[0], parts[1], parts[2], parts[3]];
+      }
+    }
+  }
+  flushStanza();
+  yield* pending;
+}
+
 // packages/safe-bash-command-pdftk/src/retained-burst.ts
-import { createRetainedPageCopy, saveRetainedDocumentChunks } from "../pdf-ast/index.js";
+import { createRetainedPageCopy as createRetainedPageCopy2, 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, PdfNameIndex, cosArray, cosNumber, decodePdfString, dictGet } from "../pdf-ast/index.js";
+import { IntegerTable as IntegerTable3, PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+import { PdfMutableObjectStore as PdfMutableObjectStore3, PdfNameIndex as PdfNameIndex3, cosArray as cosArray2, cosNumber as cosNumber2, decodePdfString as decodePdfString3, dictGet as dictGet3 } 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);
+  const backing = new PagedStorage3({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pages = new IntegerTable3(backing, 64);
   let pageCount = 0, work = 0, failed = false;
   const encoder = new TextEncoder();
   async function checkpoint() {
@@ -74,11 +515,11 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
   }
   async function* walk(start, key) {
     if (!start) return;
-    const stack = new PdfMutableObjectStore(storage, { signal }), seen = new IntegerTable(backing, 64);
+    const stack = new PdfMutableObjectStore3(storage, { signal }), seen = new IntegerTable3(backing, 64);
     let pending = 0, failed2 = false;
     const push = async (value, level = 1) => {
       await checkpoint();
-      await stack.set({ objectNumber: ++pending, generationNumber: 0, value: cosArray([value, cosNumber(level)]) });
+      await stack.set({ objectNumber: ++pending, generationNumber: 0, value: cosArray2([value, cosNumber2(level)]) });
     };
     try {
       await push(start);
@@ -99,12 +540,12 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
         if (value?.kind !== "dict") continue;
         yield { dict: value, level };
         if (key === "Outlines") {
-          const next = dictGet(value, "Next"), first = dictGet(value, "First");
+          const next = dictGet3(value, "Next"), first = dictGet3(value, "First");
           if (next) await push(next, level);
           if (first) await push(first, level + 1);
           continue;
         }
-        const child = dictGet(value, key);
+        const child = dictGet3(value, key);
         if (key === "Next") {
           if (child) await push(child);
         } else {
@@ -124,23 +565,23 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
   async function destinationIndex(raw) {
     let node = await resolve(raw);
     if (node?.kind === "dict") {
-      const target = dictGet(node, "D") ?? dictGet(node, "Dest");
+      const target = dictGet3(node, "D") ?? dictGet3(node, "Dest");
       if (target) node = await resolve(target);
     }
     if (node?.kind === "string" || node?.kind === "name") {
-      const name = node.kind === "string" ? decodePdfString(node) : node.decoded;
+      const name = node.kind === "string" ? decodePdfString3(node) : node.decoded;
       const root = await resolve(document.crossReference.rootRef);
       let target;
       if (root?.kind === "dict") {
-        const legacy = await resolve(dictGet(root, "Dests"));
-        if (legacy?.kind === "dict") target = dictGet(legacy, name);
+        const legacy = await resolve(dictGet3(root, "Dests"));
+        if (legacy?.kind === "dict") target = dictGet3(legacy, name);
         if (!target) {
-          const names = await resolve(dictGet(root, "Names"));
-          if (names?.kind === "dict") for await (const { dict: branch } of walk(dictGet(names, "Dests"), "Kids")) {
-            const pairs = await resolve(dictGet(branch, "Names"));
+          const names = await resolve(dictGet3(root, "Names"));
+          if (names?.kind === "dict") for await (const { dict: branch } of walk(dictGet3(names, "Dests"), "Kids")) {
+            const pairs = await resolve(dictGet3(branch, "Names"));
             if (pairs?.kind === "array") for (let i = 0; i + 1 < pairs.items.length; i += 2) {
               const key = await resolve(pairs.items[i]);
-              if ((key?.kind === "string" ? decodePdfString(key) : key?.kind === "name" ? key.decoded : "") === name) {
+              if ((key?.kind === "string" ? decodePdfString3(key) : key?.kind === "name" ? key.decoded : "") === name) {
                 target = pairs.items[i + 1];
                 break;
               }
@@ -151,7 +592,7 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
       }
       node = await resolve(target);
       if (node?.kind === "dict") {
-        const inner = dictGet(node, "D");
+        const inner = dictGet3(node, "D");
         if (inner) node = await resolve(inner);
       }
     }
@@ -166,7 +607,7 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
   }
   async function destinationText(raw) {
     const node = await resolve(raw);
-    if (node?.kind === "string") return decodePdfString(node);
+    if (node?.kind === "string") return decodePdfString3(node);
     if (node?.kind === "name") return node.decoded;
     if (node?.kind === "array") {
       const first = node.items[0];
@@ -182,8 +623,8 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
     return;
   }
   async function* stringField(dict, key, label) {
-    const node = await resolve(dictGet(dict, key));
-    if (node?.kind === "string") yield* line(label, decodePdfString(node), true);
+    const node = await resolve(dictGet3(dict, key));
+    if (node?.kind === "string") yield* line(label, decodePdfString3(node), true);
   }
   try {
     for await (const page of document.pages()) {
@@ -191,14 +632,14 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
       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);
+      const emitted = new PdfNameIndex3(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 : "";
+            const node = await resolve(dictGet3(info, key));
+            const value = node?.kind === "string" ? decodePdfString3(node) : node?.kind === "name" ? node.decoded : "";
             if (value) {
               await emitted.intern(key);
               yield* line("", "InfoBegin");
@@ -207,7 +648,7 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
             }
           }
           for (const entry of info.entries) {
-            const node = await resolve(entry.value), value = node?.kind === "string" ? decodePdfString(node) : "";
+            const node = await resolve(entry.value), value = node?.kind === "string" ? decodePdfString3(node) : "";
             if (value && (await emitted.intern(entry.key.decoded)).added) {
               yield* line("", "InfoBegin");
               yield* line("InfoKey: ", entry.key.decoded, true);
@@ -241,11 +682,11 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
     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"));
+      const outlines = catalog?.kind === "dict" ? await resolve(dictGet3(catalog, "Outlines")) : void 0;
+      if (outlines?.kind === "dict") for await (const { dict, level } of walk(dictGet3(outlines, "First"), "Outlines")) {
+        const titleNode = await resolve(dictGet3(dict, "Title"));
+        const title = titleNode?.kind === "string" ? decodePdfString3(titleNode) : titleNode?.kind === "name" ? titleNode.decoded : "";
+        const index = await destinationIndex(dictGet3(dict, "Dest") ?? dictGet3(dict, "A"));
         if (title) {
           yield* line("", "BookmarkBegin");
           yield* line("BookmarkTitle: ", title, true);
@@ -267,54 +708,54 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
       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")) {
+          if (!hasMedia && dictGet3(parent, "MediaBox")) {
             hasMedia = true;
-            media = dictGet(parent, "MediaBox");
+            media = dictGet3(parent, "MediaBox");
           }
-          if (!hasRotate && dictGet(parent, "Rotate")) {
+          if (!hasRotate && dictGet3(parent, "Rotate")) {
             hasRotate = true;
-            rotate = dictGet(parent, "Rotate");
+            rotate = dictGet3(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];
+        const direct = await rectangle(dictGet3(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);
+        const crop = await rectangle(dictGet3(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"));
+      const styles2 = { D: "DecimalArabicNumerals", R: "UppercaseRomanNumerals", r: "LowercaseRomanNumerals", A: "UppercaseLetters", a: "LowercaseLetters" };
+      if (catalog?.kind === "dict") for await (const { dict } of walk(dictGet3(catalog, "PageLabels"), "Kids")) {
+        const pairs = await resolve(dictGet3(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"));
+          const start = await resolve(dictGet3(label, "St")), prefix = await resolve(dictGet3(label, "P")), style = await resolve(dictGet3(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");
+          if (prefix?.kind === "string" && decodePdfString3(prefix)) yield* line("PageLabelPrefix: ", decodePdfString3(prefix), true);
+          yield* line("PageLabelNumStyle: ", style?.kind === "name" ? styles2[style.decoded] ?? "NoNumber" : "NoNumber");
         }
       }
       return;
     }
     for await (const page of document.pages()) {
-      const annotations = await resolve(dictGet(page.dict, "Annots"));
+      const annotations = await resolve(dictGet3(page.dict, "Annots"));
       if (annotations?.kind !== "array") continue;
       for (const item of annotations.items) {
         const annotation = await resolve(item);
         if (annotation?.kind !== "dict") continue;
-        const subtype = await resolve(dictGet(annotation, "Subtype")), rect = await resolve(dictGet(annotation, "Rect"));
+        const subtype = await resolve(dictGet3(annotation, "Subtype")), rect = await resolve(dictGet3(annotation, "Rect"));
         const numbers = [];
         if (rect?.kind === "array") for (const value of rect.items) {
           const number = await resolve(value);
@@ -325,7 +766,7 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
         yield* line("AnnotSubtype: ", subtype?.kind === "name" ? subtype.decoded : "Annot");
         yield* line("AnnotRect: ", numbers.join(" "));
         for (const [key, label] of [["NM", "Name"], ["T", "Title"], ["Subj", "Subj"], ["Contents", "Contents"]]) yield* stringField(annotation, key, `Annot${label}: `);
-        const color = await resolve(dictGet(annotation, "C"));
+        const color = await resolve(dictGet3(annotation, "C"));
         if (color?.kind === "array" && color.items.length >= 3) {
           const channels = [];
           for (const value of color.items.slice(0, 3)) {
@@ -334,31 +775,31 @@ async function* retainedInspectionReport(document, storage, utf8, signal, kind)
           }
           yield* line("AnnotColor: ", channels.join(" "));
         }
-        const open = await resolve(dictGet(annotation, "Open"));
+        const open = await resolve(dictGet3(annotation, "Open"));
         if (open?.kind === "boolean") yield* line("AnnotOpen: ", open.value);
         yield* stringField(annotation, "M", "AnnotModificationDate: ");
-        const flags = await resolve(dictGet(annotation, "F"));
+        const flags = await resolve(dictGet3(annotation, "F"));
         yield* line("AnnotFlags: ", flags?.kind === "number" ? flags.value : 0);
         yield* line("AnnotPageNumber: ", page.index + 1);
-        const action = dictGet(annotation, "A");
+        const action = dictGet3(annotation, "A");
         if (action) for await (const { dict } of walk(action, "Next")) {
-          const type = await resolve(dictGet(dict, "S"));
+          const type = await resolve(dictGet3(dict, "S"));
           if (type?.kind === "name" && type.decoded) yield* line("AnnotActionType: ", type.decoded);
           yield* stringField(dict, "URI", "AnnotActionURI: ");
-          const dest = dictGet(dict, "D"), text = await destinationText(dest);
+          const dest = dictGet3(dict, "D"), text = await destinationText(dest);
           if (text) yield* line("AnnotActionDest: ", text, true);
           const index = await destinationIndex(dest ?? dict);
           if (index !== void 0) yield* line("AnnotActionPageNumber: ", index + 1);
-          const file = await resolve(dictGet(dict, "F"));
-          if (file?.kind === "string") yield* line("AnnotActionFile: ", decodePdfString(file), true);
+          const file = await resolve(dictGet3(dict, "F"));
+          if (file?.kind === "string") yield* line("AnnotActionFile: ", decodePdfString3(file), true);
           else if (file?.kind === "dict") {
-            const name = await resolve(dictGet(file, "UF") ?? dictGet(file, "F"));
-            if (name?.kind === "string") yield* line("AnnotActionFile: ", decodePdfString(name), true);
+            const name = await resolve(dictGet3(file, "UF") ?? dictGet3(file, "F"));
+            if (name?.kind === "string") yield* line("AnnotActionFile: ", decodePdfString3(name), true);
           }
         }
-        else if (dictGet(annotation, "Dest")) {
+        else if (dictGet3(annotation, "Dest")) {
           yield* line("AnnotActionType: ", "GoTo");
-          const dest = dictGet(annotation, "Dest"), text = await destinationText(dest);
+          const dest = dictGet3(annotation, "Dest"), text = await destinationText(dest);
           if (text) yield* line("AnnotActionDest: ", text, true);
           const index = await destinationIndex(dest);
           if (index !== void 0) yield* line("AnnotActionPageNumber: ", index + 1);
@@ -385,7 +826,7 @@ async function* retainedBurst(document, storage, options, pageCount, signal) {
     signal.throwIfAborted();
     const path = formatBurstFilename(pattern, index + 1);
     if (path === "-" || path === report) continue;
-    const copy = await createRetainedPageCopy(document, [index], storage, { signal });
+    const copy = await createRetainedPageCopy2(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();
@@ -403,9 +844,9 @@ async function* retainedBurst(document, storage, options, pageCount, signal) {
 }
 
 // packages/safe-bash-command-pdftk/src/retained-rotate.ts
-import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage4 } 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 records = new PagedStorage4({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const base = records.allocate(pageCount * 16);
   let failed = false, work = 0;
   try {
@@ -435,32 +876,40 @@ async function* retainedRotations(args, handles, primaryHandle, pageCount, stora
 }
 
 // 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 });
+import { parseRetainedFormData, editRetainedDocument as editRetainedDocument2, PdfFileSource as PdfFileSource3, PdfMutableObjectStore as PdfMutableObjectStore4, PdfRetainedDocument, cosBool, cosName, dictDelete, dictGet as dictGet4, dictSet as dictSet2, encryptRetainedPdfChunks, retainedCosObjects, saveRetainedDocumentChunks as saveRetainedDocumentChunks2 } from "../pdf-ast/index.js";
+async function* retainedOutput(source, storage, options, selectedId, signal, handles, pageCount, attachments, attachmentPage, stamps, info, formData) {
+  const infoUpdates = info?.updates;
+  const store = new PdfMutableObjectStore4(storage, { signal });
   let edited;
   let document, plaintext, failed = false;
   try {
-    if (options.operation === "attach_files" || stamps) {
+    if (options.operation === "attach_files" || stamps || infoUpdates || formData) {
       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 } : {} });
+      edited = await editRetainedDocument2(source, storage, { signal, ...formData ? { formUpdates: parseRetainedFormData(formData, storage, { signal }) } : {}, ...infoUpdates ? { infoUpdates } : {}, ...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;
+    for await (const object of retainedCosObjects(input, storage, { signal })) {
+      if (formData && options.replacementFont && object.value.kind === "dict") {
+        const subtype = dictGet4(object.value, "Subtype"), font = dictGet4(object.value, "BaseFont");
+        if (subtype?.kind === "name" && subtype.decoded === "Type1" && font?.kind === "name" && font.decoded === "Helvetica") dictSet2(object.value, "BaseFont", cosName(options.replacementFont.startsWith("/") ? options.replacementFont.slice(1) : options.replacementFont));
+      }
+      await store.set(object);
+    }
+    const reference = input.crossReference;
+    const chosenId = info?.useUpdatedId ? reference.idArray : selectedId;
+    const idArray = options.keepFinalId || options.keepFirstId ? chosenId ?? reference.idArray : reference.idArray ?? chosenId;
     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"));
+      const form = await document.lookup(dictGet4(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 (formData || options.needAppearances) dictSet2(form.value, "NeedAppearances", cosBool(options.needAppearances));
         if (form.reference) await store.set({ objectNumber: form.reference.objectNumber, generationNumber: form.reference.generationNumber, value: form.value });
-        else dictSet(root.value, "AcroForm", form.value);
+        else dictSet2(root.value, "AcroForm", form.value);
       }
       await store.set({ objectNumber: root.reference.objectNumber, generationNumber: root.reference.generationNumber, value: root.value });
     }
@@ -469,7 +918,7 @@ async function* retainedOutput(source, storage, options, selectedId, signal, han
       yield* chunks;
       return;
     }
-    plaintext = await PdfFileSource.fromStream(storage.fs, storage.directory, chunks, { signal });
+    plaintext = await PdfFileSource3.fromStream(storage.fs, storage.directory, chunks, { signal });
     const allow = options.allowPermissions, all = allow.has("allfeatures");
     yield* encryptRetainedPdfChunks(plaintext, storage, {
       userPassword: options.userPassword ?? "",
@@ -489,117 +938,12 @@ async function* retainedOutput(source, storage, options, selectedId, signal, han
   }
 }
 
-// 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";
+import { PdfError, PdfFileSource as PdfFileSource4, PdfMutableObjectStore as PdfMutableObjectStore5, PdfNameIndex as PdfNameIndex4, cosArray as cosArray3, cosDict as cosDict3, cosNumber as cosNumber3, cosString as cosString3, decodePdfString as decodePdfString4, dictGet as dictGet5 } 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 names = new PdfNameIndex4(storage, Infinity, signal);
+  const values = new PdfMutableObjectStore5(storage, { signal });
+  const tree = new PdfMutableObjectStore5(storage, { signal });
   const encoder = new TextEncoder();
   let work = 0, failed = false;
   async function checkpoint() {
@@ -661,17 +1005,17 @@ async function* retainedFdf(document, storage, signal) {
   const string = (items, at) => {
     const node = items[at];
     if (node?.kind !== "string") throw new PdfError("E_PARSE", "Invalid FDF traversal name");
-    return decodePdfString3(node);
+    return decodePdfString4(node);
   };
-  const save = async (id, items) => tree.set({ objectNumber: id, generationNumber: 0, value: cosArray2(items) });
+  const save = async (id, items) => tree.set({ objectNumber: id, generationNumber: 0, value: cosArray3(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 });
+      const staged = await PdfFileSource4.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) } });
+        await values.set({ objectNumber: name.index + 1, generationNumber: 0, value: cosDict3({}), stream: { length: staged.size, chunks: staged.stream(0, staged.size, signal) } });
       } catch (error) {
         valueFailed = true;
         throw error;
@@ -682,25 +1026,25 @@ async function* retainedFdf(document, storage, signal) {
       }
     }
     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))]);
+    const form = catalog?.kind === "dict" ? await resolve(dictGet5(catalog, "AcroForm")) : void 0;
+    const roots = form?.kind === "dict" ? await resolve(dictGet5(form, "Fields")) : void 0;
+    await save(1, [cosDict3({}), cosString3(""), cosString3(""), ...Array.from({ length: 6 }, () => cosNumber3(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;
+      const kids = top === 1 ? roots : node?.kind === "dict" ? await resolve(dictGet5(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) : "";
+        if (child?.kind !== "dict" || top !== 1 && !dictGet5(child, "T")) continue;
+        const name = await resolve(dictGet5(child, "T")), partial = name?.kind === "string" ? decodePdfString4(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);
+        frame[3] = cosNumber3(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)]);
+        await save(++next, [childNode, cosString3(full), cosString3(partial), cosNumber3(0), cosNumber3(0), cosNumber3(0), cosNumber3(0), cosNumber3(top), cosNumber3(depth)]);
         top = next;
         descended = true;
         break;
@@ -711,10 +1055,10 @@ async function* retainedFdf(document, storage, signal) {
         const owner = await record(parent), last = number(owner, 5);
         if (last) {
           const sibling = await record(last);
-          sibling[6] = cosNumber2(top);
+          sibling[6] = cosNumber3(top);
           await save(last, sibling);
-        } else owner[4] = cosNumber2(top);
-        owner[5] = cosNumber2(top);
+        } else owner[4] = cosNumber3(top);
+        owner[5] = cosNumber3(top);
         await save(parent, owner);
       }
       top = parent;
@@ -737,11 +1081,11 @@ async function* retainedFdf(document, storage, signal) {
       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;
+        const dict = await resolve(frame[0]), raw = dict?.kind === "dict" ? await resolve(dictGet5(dict, "V")) : void 0;
         if (raw?.kind === "name") yield* text(`/${raw.decoded}`);
         else {
           yield* text("(");
-          if (raw?.kind === "string") yield* text(decodePdfString3(raw), true);
+          if (raw?.kind === "string") yield* text(decodePdfString4(raw), true);
           yield* text(")");
         }
       }
@@ -803,7 +1147,7 @@ async function* retainedFieldReport(document, utf8, signal) {
 }
 
 // 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 { PdfError as PdfError2, PdfFileSource as PdfFileSource5, 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";
@@ -821,6 +1165,8 @@ async function executeRetainedPdftk(context, options) {
   let selectedId;
   const counts = /* @__PURE__ */ new Map();
   const inputs = /* @__PURE__ */ new Map();
+  const formPath = options.operation === "fill_form" ? options.opArgs[0] ?? "-" : void 0;
+  const infoPath = options.operation === "update_info" || options.operation === "update_info_utf8" ? options.opArgs[0] ?? "-" : void 0;
   const overlayPath = ["stamp", "multistamp", "background", "multibackground"].includes(options.operation) ? options.opArgs[0] ?? "-" : void 0;
   const attachmentPaths = [];
   let attachmentPage;
@@ -834,6 +1180,7 @@ async function executeRetainedPdftk(context, options) {
       if (source) yield { filename: path.slice(path.lastIndexOf("/") + 1), chunks: source.stream(0, source.size, signal) };
     }
   }
+  let assembled;
   let overlayDocument;
   let document, output, total = 0, failed = false;
   const diagnostic = async (message) => {
@@ -843,17 +1190,17 @@ 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 === "-") || attachmentPaths.includes("-") || overlayPath === "-") {
-      const source = await PdfFileSource4.fromStream(context.fs, storage.directory, context.stdin, { signal, maxInputBytes: maximum });
+    if (options.inputs.some((input) => input.file === "-") || attachmentPaths.includes("-") || overlayPath === "-" || infoPath === "-" || formPath === "-") {
+      const source = await PdfFileSource5.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, ...attachmentPaths.map((file) => ({ file })), ...overlayPath !== void 0 ? [{ file: overlayPath }] : []]) {
+    for (const input of [...options.inputs, ...attachmentPaths.map((file) => ({ file })), ...overlayPath !== void 0 ? [{ file: overlayPath }] : [], ...infoPath !== void 0 ? [{ file: infoPath }] : [], ...formPath !== void 0 ? [{ file: formPath }] : []]) {
       if (inputs.has(input.file)) continue;
       let source;
       try {
-        source = await PdfFileSource4.open(context.fs, resolvePath(context.cwd, input.file), { signal, maxInputBytes: maximum - total });
+        source = await PdfFileSource5.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 PdfError2 && error.message === "PDF source must be a regular file") {
@@ -891,6 +1238,12 @@ async function executeRetainedPdftk(context, options) {
       await source.releaseCache();
     }
     document = await PdfRetainedDocument2.open(inputs.get(primary.file), storage, { signal, recovery: "strict", ...primary.password ? { password: primary.password } : {} });
+    const formSource = formPath === void 0 ? void 0 : inputs.get(formPath);
+    if (formPath !== void 0 && !formSource) return await diagnostic(`Error: Unable to open form data file '${formPath}'
+`);
+    const infoSource = infoPath === void 0 ? void 0 : inputs.get(infoPath);
+    if (infoPath !== void 0 && !infoSource) return await diagnostic(`Error: Unable to open info file '${infoPath}'
+`);
     let overlayPages = 0;
     if (overlayPath !== void 0) {
       const source = inputs.get(overlayPath);
@@ -920,7 +1273,10 @@ async function executeRetainedPdftk(context, options) {
       }
       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 });
+    if (options.operation === "cat" || options.operation === "shuffle") {
+      assembled = await assembleRetainedPdftk(document, storage, options, counts, handles, async (input) => PdfRetainedDocument2.open(inputs.get(input.file), storage, { signal, recovery: "strict", ...input.password ? { password: input.password } : {} }), signal);
+    }
+    output = await PdfFileSource5.fromStream(context.fs, storage.directory, ["output", "rotate", "attach_files", "stamp", "multistamp", "background", "multibackground", "update_info", "update_info_utf8", "cat", "shuffle", "fill_form"].includes(options.operation) ? retainedOutput(assembled?.document ?? 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, infoSource ? { updates: retainedInfoUpdates(infoSource.stream(0, infoSource.size, signal), signal), useUpdatedId: idInput === primary } : void 0, formSource) : 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 {
@@ -938,7 +1294,7 @@ async function executeRetainedPdftk(context, options) {
     failed = true;
     throw error;
   } finally {
-    const results = await Promise.allSettled([document?.close(), overlayDocument?.close(), output?.close(), ...[...inputs.values()].map((source) => source?.close())]);
+    const results = await Promise.allSettled([assembled?.close(), 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);
     }
@@ -1151,17 +1507,17 @@ import { readBytes, writeBytes as writeBytes2 } from "../safe-bash-contracts/io.
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
 import {
   PdfDocument,
-  cosArray as cosArray3,
-  cosDict as cosDict3,
+  cosArray as cosArray4,
+  cosDict as cosDict4,
   cosHexString,
-  cosName,
-  cosNumber as cosNumber3,
+  cosName as cosName2,
+  cosNumber as cosNumber4,
   cosStream,
-  cosString as cosString3,
-  decodePdfString as decodePdfString4,
+  cosString as cosString4,
+  decodePdfString as decodePdfString5,
   dictDelete as dictDelete2,
-  dictGet as dictGet5,
-  dictSet as dictSet2,
+  dictGet as dictGet6,
+  dictSet as dictSet3,
   flattenDocumentFormFields,
   getDocumentFormFields,
   parseFormDataBytes,
@@ -1286,27 +1642,6 @@ function encodePdftkText(str, utf8) {
   }
   return out;
 }
-function decodePdftkEntities(str) {
-  let out = "";
-  let i = 0;
-  while (i < str.length) {
-    if (str[i] === "&" && str[i + 1] === "#") {
-      const semi = str.indexOf(";", i + 2);
-      if (semi !== -1) {
-        const body = str.slice(i + 2, semi);
-        const cp = body.startsWith("x") || body.startsWith("X") ? Number.parseInt(body.slice(1), 16) : Number.parseInt(body, 10);
-        if (Number.isFinite(cp) && cp >= 0) {
-          out += String.fromCodePoint(cp);
-          i = semi + 1;
-          continue;
-        }
-      }
-    }
-    out += str[i];
-    i++;
-  }
-  return out;
-}
 function escapeFdfString(str) {
   return str.replaceAll("\\", "\\\\").replaceAll("(", "\\(").replaceAll(")", "\\)").replaceAll("\r", "\\r").replaceAll("\n", "\\n");
 }
@@ -1327,102 +1662,102 @@ function formatDumpDataFields(doc, utf8 = true) {
     } else {
       valStr = String(field.value ?? "");
     }
-    const lines = [
+    const lines2 = [
       "---",
       `FieldType: ${fieldType}`,
       `FieldName: ${encodePdftkText(field.name, utf8)}`
     ];
     if (field.altName) {
-      lines.push(`FieldNameAlt: ${encodePdftkText(field.altName, utf8)}`);
+      lines2.push(`FieldNameAlt: ${encodePdftkText(field.altName, utf8)}`);
     }
-    lines.push(`FieldFlags: ${flags}`);
+    lines2.push(`FieldFlags: ${flags}`);
     if (field.selectedValues && field.selectedValues.length > 0) {
       for (const sv of field.selectedValues) {
-        lines.push(`FieldValue: ${encodePdftkText(sv, utf8)}`);
+        lines2.push(`FieldValue: ${encodePdftkText(sv, utf8)}`);
       }
     } else {
-      lines.push(`FieldValue: ${encodePdftkText(valStr, utf8)}`);
+      lines2.push(`FieldValue: ${encodePdftkText(valStr, utf8)}`);
     }
     if (field.defaultValue !== void 0 && field.defaultValue !== "") {
-      lines.push(`FieldValueDefault: ${encodePdftkText(field.defaultValue, utf8)}`);
+      lines2.push(`FieldValueDefault: ${encodePdftkText(field.defaultValue, utf8)}`);
     }
-    lines.push(`FieldJustification: ${field.justification ?? "Left"}`);
+    lines2.push(`FieldJustification: ${field.justification ?? "Left"}`);
     for (const opt of options) {
-      lines.push(`FieldStateOption: ${encodePdftkText(opt, utf8)}`);
+      lines2.push(`FieldStateOption: ${encodePdftkText(opt, utf8)}`);
     }
     if (field.maxLength !== void 0) {
-      lines.push(`FieldMaxLength: ${field.maxLength}`);
+      lines2.push(`FieldMaxLength: ${field.maxLength}`);
     }
-    stanzas.push(lines.join("\n"));
+    stanzas.push(lines2.join("\n"));
   }
   return stanzas.join("\n") + "\n";
 }
 function formatDumpDataAnnots(doc, utf8 = false) {
-  const lines = [];
+  const lines2 = [];
   const id0Node = doc.cos.idArray?.items[0] ? doc.cos.resolve(doc.cos.idArray.items[0]) : void 0;
   const id1Node = doc.cos.idArray?.items[1] ? doc.cos.resolve(doc.cos.idArray.items[1]) : void 0;
   const id0Hex = id0Node?.kind === "string" ? bytesToHexLower(id0Node.bytes) : "00000000000000000000000000000000";
   const id1Hex = id1Node?.kind === "string" ? bytesToHexLower(id1Node.bytes) : "00000000000000000000000000000000";
-  lines.push(`PdfID0: ${id0Hex}`);
-  lines.push(`PdfID1: ${id1Hex}`);
-  lines.push(`NumberOfPages: ${doc.pageCount}`);
+  lines2.push(`PdfID0: ${id0Hex}`);
+  lines2.push(`PdfID1: ${id1Hex}`);
+  lines2.push(`NumberOfPages: ${doc.pageCount}`);
   for (let p = 0; p < doc.pageCount; p++) {
     const pageDict = doc.getPage(p).pageDict;
-    const annotsArr = doc.cos.resolveArray(dictGet5(pageDict, "Annots"));
+    const annotsArr = doc.cos.resolveArray(dictGet6(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(dictGet5(annotDict, "Subtype"));
+      const subNode = doc.cos.resolve(dictGet6(annotDict, "Subtype"));
       const subtype = subNode?.kind === "name" ? subNode.decoded : "Annot";
-      const rectArr = doc.cos.resolveArray(dictGet5(annotDict, "Rect"));
+      const rectArr = doc.cos.resolveArray(dictGet6(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(dictGet5(annotDict, "F"));
+      const flagsNode = doc.cos.resolve(dictGet6(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(dictGet5(annotDict, "NM"));
+      lines2.push("---");
+      lines2.push(`AnnotSubtype: ${subtype}`);
+      lines2.push(`AnnotRect: ${rectNums.slice(0, 4).join(" ")}`);
+      const nmNode = doc.cos.resolve(dictGet6(annotDict, "NM"));
       if (nmNode?.kind === "string") {
-        lines.push(`AnnotName: ${encodePdftkText(decodePdfString4(nmNode), utf8)}`);
+        lines2.push(`AnnotName: ${encodePdftkText(decodePdfString5(nmNode), utf8)}`);
       }
-      const tNode = doc.cos.resolve(dictGet5(annotDict, "T"));
+      const tNode = doc.cos.resolve(dictGet6(annotDict, "T"));
       if (tNode?.kind === "string") {
-        lines.push(`AnnotTitle: ${encodePdftkText(decodePdfString4(tNode), utf8)}`);
+        lines2.push(`AnnotTitle: ${encodePdftkText(decodePdfString5(tNode), utf8)}`);
       }
-      const subjNode = doc.cos.resolve(dictGet5(annotDict, "Subj"));
+      const subjNode = doc.cos.resolve(dictGet6(annotDict, "Subj"));
       if (subjNode?.kind === "string") {
-        lines.push(`AnnotSubj: ${encodePdftkText(decodePdfString4(subjNode), utf8)}`);
+        lines2.push(`AnnotSubj: ${encodePdftkText(decodePdfString5(subjNode), utf8)}`);
       }
-      const cNode = doc.cos.resolve(dictGet5(annotDict, "Contents"));
+      const cNode = doc.cos.resolve(dictGet6(annotDict, "Contents"));
       if (cNode?.kind === "string") {
-        lines.push(`AnnotContents: ${encodePdftkText(decodePdfString4(cNode), utf8)}`);
+        lines2.push(`AnnotContents: ${encodePdftkText(decodePdfString5(cNode), utf8)}`);
       }
-      const colArr = doc.cos.resolveArray(dictGet5(annotDict, "C"));
+      const colArr = doc.cos.resolveArray(dictGet6(annotDict, "C"));
       if (colArr && colArr.items.length >= 3) {
         const colNums = colArr.items.slice(0, 3).map((it) => {
           const r = doc.cos.resolve(it);
           return r?.kind === "number" ? r.value : 0;
         });
-        lines.push(`AnnotColor: ${colNums.join(" ")}`);
+        lines2.push(`AnnotColor: ${colNums.join(" ")}`);
       }
-      const openNode = doc.cos.resolve(dictGet5(annotDict, "Open"));
+      const openNode = doc.cos.resolve(dictGet6(annotDict, "Open"));
       if (openNode?.kind === "boolean") {
-        lines.push(`AnnotOpen: ${openNode.value}`);
+        lines2.push(`AnnotOpen: ${openNode.value}`);
       }
-      const mNode = doc.cos.resolve(dictGet5(annotDict, "M"));
+      const mNode = doc.cos.resolve(dictGet6(annotDict, "M"));
       if (mNode?.kind === "string") {
-        lines.push(`AnnotModificationDate: ${encodePdftkText(decodePdfString4(mNode), utf8)}`);
+        lines2.push(`AnnotModificationDate: ${encodePdftkText(decodePdfString5(mNode), utf8)}`);
       }
-      lines.push(`AnnotFlags: ${flags}`);
-      lines.push(`AnnotPageNumber: ${p + 1}`);
+      lines2.push(`AnnotFlags: ${flags}`);
+      lines2.push(`AnnotPageNumber: ${p + 1}`);
       const formatDestTarget = (dRaw) => {
         if (!dRaw) return void 0;
         const resolved = doc.cos.resolve(dRaw);
-        if (resolved?.kind === "string") return decodePdfString4(resolved);
+        if (resolved?.kind === "string") return decodePdfString5(resolved);
         if (resolved?.kind === "name") return resolved.decoded;
         if (resolved?.kind === "array" && resolved.items.length > 0) {
           const first = resolved.items[0];
@@ -1455,53 +1790,53 @@ function formatDumpDataAnnots(doc, utf8 = false) {
         }
         const actionDict = doc.cos.resolveDict(aNode);
         if (!actionDict) return;
-        const sNode = doc.cos.resolve(dictGet5(actionDict, "S"));
+        const sNode = doc.cos.resolve(dictGet6(actionDict, "S"));
         const sType = sNode?.kind === "name" ? sNode.decoded : "";
         if (sType) {
-          lines.push(`AnnotActionType: ${sType}`);
+          lines2.push(`AnnotActionType: ${sType}`);
         }
-        const uriNode = doc.cos.resolve(dictGet5(actionDict, "URI"));
+        const uriNode = doc.cos.resolve(dictGet6(actionDict, "URI"));
         if (uriNode?.kind === "string") {
-          lines.push(`AnnotActionURI: ${encodePdftkText(decodePdfString4(uriNode), utf8)}`);
+          lines2.push(`AnnotActionURI: ${encodePdftkText(decodePdfString5(uriNode), utf8)}`);
         }
-        const dNode = dictGet5(actionDict, "D");
+        const dNode = dictGet6(actionDict, "D");
         const destTarget = formatDestTarget(dNode);
         if (destTarget) {
-          lines.push(`AnnotActionDest: ${encodePdftkText(destTarget, utf8)}`);
+          lines2.push(`AnnotActionDest: ${encodePdftkText(destTarget, utf8)}`);
         }
         const resolvedIdx = resolveDestinationPageIndex(doc, dNode ?? actionDict);
         if (resolvedIdx !== void 0) {
-          lines.push(`AnnotActionPageNumber: ${resolvedIdx + 1}`);
+          lines2.push(`AnnotActionPageNumber: ${resolvedIdx + 1}`);
         }
-        const fRaw = doc.cos.resolve(dictGet5(actionDict, "F"));
+        const fRaw = doc.cos.resolve(dictGet6(actionDict, "F"));
         if (fRaw?.kind === "string") {
-          lines.push(`AnnotActionFile: ${encodePdftkText(decodePdfString4(fRaw), utf8)}`);
+          lines2.push(`AnnotActionFile: ${encodePdftkText(decodePdfString5(fRaw), utf8)}`);
         } else if (fRaw?.kind === "dict") {
-          const ufNode = doc.cos.resolve(dictGet5(fRaw, "UF") ?? dictGet5(fRaw, "F"));
+          const ufNode = doc.cos.resolve(dictGet6(fRaw, "UF") ?? dictGet6(fRaw, "F"));
           if (ufNode?.kind === "string") {
-            lines.push(`AnnotActionFile: ${encodePdftkText(decodePdfString4(ufNode), utf8)}`);
+            lines2.push(`AnnotActionFile: ${encodePdftkText(decodePdfString5(ufNode), utf8)}`);
           }
         }
-        emitActionChain(dictGet5(actionDict, "Next"), visited);
+        emitActionChain(dictGet6(actionDict, "Next"), visited);
       };
-      const rawA = dictGet5(annotDict, "A");
+      const rawA = dictGet6(annotDict, "A");
       if (rawA) {
         emitActionChain(rawA);
-      } else if (dictGet5(annotDict, "Dest")) {
-        lines.push("AnnotActionType: GoTo");
-        const dNode = dictGet5(annotDict, "Dest");
+      } else if (dictGet6(annotDict, "Dest")) {
+        lines2.push("AnnotActionType: GoTo");
+        const dNode = dictGet6(annotDict, "Dest");
         const destTarget = formatDestTarget(dNode);
         if (destTarget) {
-          lines.push(`AnnotActionDest: ${encodePdftkText(destTarget, utf8)}`);
+          lines2.push(`AnnotActionDest: ${encodePdftkText(destTarget, utf8)}`);
         }
         const resolvedIdx = resolveDestinationPageIndex(doc, dNode);
         if (resolvedIdx !== void 0) {
-          lines.push(`AnnotActionPageNumber: ${resolvedIdx + 1}`);
+          lines2.push(`AnnotActionPageNumber: ${resolvedIdx + 1}`);
         }
       }
     }
   }
-  return lines.join("\n") + "\n";
+  return lines2.join("\n") + "\n";
 }
 function copyPrimaryMetadata(srcDoc, dstDoc) {
   const meta = srcDoc.getMetadata();
@@ -1535,18 +1870,18 @@ function collectOutlineBookmarks(doc, firstNode, level, out, visited = /* @__PUR
     }
     const dict = doc.cos.resolveDict(curr);
     if (!dict) break;
-    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 titleNode = doc.cos.resolve(dictGet6(dict, "Title"));
+    const title = titleNode?.kind === "string" ? decodePdfString5(titleNode) : titleNode?.kind === "name" ? titleNode.decoded : "";
+    const resolvedIdx = resolveDestinationPageIndex(doc, dictGet6(dict, "Dest") ?? dictGet6(dict, "A"));
     const pageNumber = resolvedIdx !== void 0 ? resolvedIdx + 1 : 1;
     if (title) {
       out.push({ title, level, pageNumber });
     }
-    const childFirst = dictGet5(dict, "First");
+    const childFirst = dictGet6(dict, "First");
     if (childFirst) {
       collectOutlineBookmarks(doc, childFirst, level + 1, out, visited);
     }
-    curr = dictGet5(dict, "Next");
+    curr = dictGet6(dict, "Next");
   }
 }
 function collectNameTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ new Set()) {
@@ -1557,16 +1892,16 @@ function collectNameTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ new
   }
   const dict = doc.cos.resolveDict(nodeOrRef);
   if (!dict) return;
-  const namesArr = doc.cos.resolveArray(dictGet5(dict, "Names"));
+  const namesArr = doc.cos.resolveArray(dictGet6(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" ? decodePdfString4(k) : "attachment.bin";
+      const name = k?.kind === "string" ? decodePdfString5(k) : "attachment.bin";
       out.push({ name, value: v });
     }
   }
-  const kidsArr = doc.cos.resolveArray(dictGet5(dict, "Kids"));
+  const kidsArr = doc.cos.resolveArray(dictGet6(dict, "Kids"));
   if (kidsArr) {
     for (const kid of kidsArr.items) {
       collectNameTreePairs(doc, kid, out, visited);
@@ -1581,7 +1916,7 @@ function collectNumberTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ n
   }
   const dict = doc.cos.resolveDict(nodeOrRef);
   if (!dict) return;
-  const numsArr = doc.cos.resolveArray(dictGet5(dict, "Nums"));
+  const numsArr = doc.cos.resolveArray(dictGet6(dict, "Nums"));
   if (numsArr) {
     for (let i = 0; i + 1 < numsArr.items.length; i += 2) {
       const k = doc.cos.resolve(numsArr.items[i]);
@@ -1591,7 +1926,7 @@ function collectNumberTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ n
       }
     }
   }
-  const kidsArr = doc.cos.resolveArray(dictGet5(dict, "Kids"));
+  const kidsArr = doc.cos.resolveArray(dictGet6(dict, "Kids"));
   if (kidsArr) {
     for (const kid of kidsArr.items) {
       collectNumberTreePairs(doc, kid, out, visited);
@@ -1605,19 +1940,9 @@ function bytesToHexLower(bytes) {
   }
   return hex;
 }
-function hexToBytes(hex) {
-  const clean = hex.trim();
-  const len = Math.floor(clean.length / 2);
-  const out = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    const byteVal = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
-    out[i] = Number.isNaN(byteVal) ? 0 : byteVal;
-  }
-  return out;
-}
 function formatDumpData(doc, utf8 = true) {
   const meta = doc.getMetadata();
-  const lines = [];
+  const lines2 = [];
   const emittedKeys = /* @__PURE__ */ new Set();
   const infoEntries = [
     ["Title", meta.title],
@@ -1630,7 +1955,7 @@ function formatDumpData(doc, utf8 = true) {
   for (const [key, val] of infoEntries) {
     if (val !== void 0 && val !== "") {
       emittedKeys.add(key);
-      lines.push(
+      lines2.push(
         "InfoBegin",
         `InfoKey: ${encodePdftkText(key, utf8)}`,
         `InfoValue: ${encodePdftkText(val, utf8)}`
@@ -1645,10 +1970,10 @@ function formatDumpData(doc, utf8 = true) {
         if (emittedKeys.has(k)) continue;
         const r = doc.cos.resolve(entry.value);
         if (r?.kind === "string") {
-          const val = decodePdfString4(r);
+          const val = decodePdfString5(r);
           if (val) {
             emittedKeys.add(k);
-            lines.push(
+            lines2.push(
               "InfoBegin",
               `InfoKey: ${encodePdftkText(k, utf8)}`,
               `InfoValue: ${encodePdftkText(val, utf8)}`
@@ -1662,16 +1987,16 @@ function formatDumpData(doc, utf8 = true) {
   const id1Node = doc.cos.idArray?.items[1] ? doc.cos.resolve(doc.cos.idArray.items[1]) : void 0;
   const id0Hex = id0Node?.kind === "string" ? bytesToHexLower(id0Node.bytes) : "00000000000000000000000000000000";
   const id1Hex = id1Node?.kind === "string" ? bytesToHexLower(id1Node.bytes) : "00000000000000000000000000000000";
-  lines.push(`PdfID0: ${id0Hex}`);
-  lines.push(`PdfID1: ${id1Hex}`);
-  lines.push(`NumberOfPages: ${doc.pageCount}`);
+  lines2.push(`PdfID0: ${id0Hex}`);
+  lines2.push(`PdfID1: ${id1Hex}`);
+  lines2.push(`NumberOfPages: ${doc.pageCount}`);
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
-  const outlinesDict = catalog ? doc.cos.resolveDict(dictGet5(catalog, "Outlines")) : void 0;
+  const outlinesDict = catalog ? doc.cos.resolveDict(dictGet6(catalog, "Outlines")) : void 0;
   if (outlinesDict) {
     const bookmarks = [];
-    collectOutlineBookmarks(doc, dictGet5(outlinesDict, "First"), 1, bookmarks);
+    collectOutlineBookmarks(doc, dictGet6(outlinesDict, "First"), 1, bookmarks);
     for (const bm of bookmarks) {
-      lines.push(
+      lines2.push(
         "BookmarkBegin",
         `BookmarkTitle: ${encodePdftkText(bm.title, utf8)}`,
         `BookmarkLevel: ${bm.level}`,
@@ -1683,7 +2008,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(dictGet5(page.pageDict, "MediaBox"));
+    const mbArr = doc.cos.resolveArray(dictGet6(page.pageDict, "MediaBox"));
     let mbRectStr = `0 0 ${width} ${height}`;
     if (mbArr && mbArr.items.length >= 4) {
       const mbNums = mbArr.items.slice(0, 4).map((item) => {
@@ -1692,50 +2017,50 @@ function formatDumpData(doc, utf8 = true) {
       });
       mbRectStr = `${mbNums[0]} ${mbNums[1]} ${mbNums[2]} ${mbNums[3]}`;
     }
-    lines.push(
+    lines2.push(
       "PageMediaBegin",
       `PageMediaNumber: ${i + 1}`,
       `PageMediaRotation: ${rot}`,
       `PageMediaRect: ${mbRectStr}`,
       `PageMediaDimensions: ${width} ${height}`
     );
-    const cbArr = doc.cos.resolveArray(dictGet5(page.pageDict, "CropBox"));
+    const cbArr = doc.cos.resolveArray(dictGet6(page.pageDict, "CropBox"));
     if (cbArr && cbArr.items.length >= 4) {
       const nums = cbArr.items.slice(0, 4).map((item) => {
         const r = doc.cos.resolve(item);
         return r?.kind === "number" ? r.value : 0;
       });
-      lines.push(`PageMediaCropBox: ${nums[0]} ${nums[1]} ${nums[2]} ${nums[3]}`);
-      lines.push(`PageMediaCropRect: ${nums[0]} ${nums[1]} ${nums[2]} ${nums[3]}`);
+      lines2.push(`PageMediaCropBox: ${nums[0]} ${nums[1]} ${nums[2]} ${nums[3]}`);
+      lines2.push(`PageMediaCropRect: ${nums[0]} ${nums[1]} ${nums[2]} ${nums[3]}`);
     }
   }
   const pageLabelsPairs = [];
   if (catalog) {
-    collectNumberTreePairs(doc, dictGet5(catalog, "PageLabels"), pageLabelsPairs);
+    collectNumberTreePairs(doc, dictGet6(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(dictGet5(lblDict, "St"));
+      const stNode = doc.cos.resolve(dictGet6(lblDict, "St"));
       const startNum = stNode?.kind === "number" ? stNode.value : 1;
-      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 pNode = doc.cos.resolve(dictGet6(lblDict, "P"));
+      const prefix = pNode?.kind === "string" ? decodePdfString5(pNode) : void 0;
+      const sNode = doc.cos.resolve(dictGet6(lblDict, "S"));
       const styleCode = sNode?.kind === "name" ? sNode.decoded : "";
       const numStyle = PDF_TO_PAGE_LABEL_STYLE[styleCode] ?? "NoNumber";
-      lines.push(
+      lines2.push(
         "PageLabelBegin",
         `PageLabelNewIndex: ${newIndex}`,
         `PageLabelStart: ${startNum}`
       );
       if (prefix !== void 0 && prefix !== "") {
-        lines.push(`PageLabelPrefix: ${encodePdftkText(prefix, utf8)}`);
+        lines2.push(`PageLabelPrefix: ${encodePdftkText(prefix, utf8)}`);
       }
-      lines.push(`PageLabelNumStyle: ${numStyle}`);
+      lines2.push(`PageLabelNumStyle: ${numStyle}`);
     }
   }
-  return lines.join("\n") + "\n";
+  return lines2.join("\n") + "\n";
 }
 function formatGenerateFdf(doc) {
   const fields = getDocumentFormFields(doc.cos);
@@ -1752,23 +2077,23 @@ function formatGenerateFdf(doc) {
       }
       return `(${escapeFdfString(String(f.value ?? ""))})`;
     }
-    const vNode = doc.cos.resolve(dictGet5(dict, "V"));
+    const vNode = doc.cos.resolve(dictGet6(dict, "V"));
     if (vNode?.kind === "name") return `/${vNode.decoded}`;
-    if (vNode?.kind === "string") return `(${escapeFdfString(decodePdfString4(vNode))})`;
+    if (vNode?.kind === "string") return `(${escapeFdfString(decodePdfString5(vNode))})`;
     return "()";
   };
   const serializeCosFieldNode = (nodeOrRef, prefix) => {
     const dict = doc.cos.resolveDict(nodeOrRef);
     if (!dict) return void 0;
-    const tNode = doc.cos.resolve(dictGet5(dict, "T"));
-    const partialName = tNode?.kind === "string" ? decodePdfString4(tNode) : "";
+    const tNode = doc.cos.resolve(dictGet6(dict, "T"));
+    const partialName = tNode?.kind === "string" ? decodePdfString5(tNode) : "";
     const fullName = prefix && partialName ? `${prefix}.${partialName}` : partialName || prefix;
-    const kidsArr = doc.cos.resolveArray(dictGet5(dict, "Kids"));
+    const kidsArr = doc.cos.resolveArray(dictGet6(dict, "Kids"));
     const namedKids = [];
     if (kidsArr) {
       for (const k of kidsArr.items) {
         const kDict = doc.cos.resolveDict(k);
-        if (kDict && dictGet5(kDict, "T")) {
+        if (kDict && dictGet6(kDict, "T")) {
           const serializedKid = serializeCosFieldNode(k, fullName);
           if (serializedKid) namedKids.push(serializedKid);
         }
@@ -1782,8 +2107,8 @@ function formatGenerateFdf(doc) {
   };
   const entries = [];
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
-  const acroForm = catalog ? doc.cos.resolveDict(dictGet5(catalog, "AcroForm")) : void 0;
-  const fieldsArr = acroForm ? doc.cos.resolveArray(dictGet5(acroForm, "Fields")) : void 0;
+  const acroForm = catalog ? doc.cos.resolveDict(dictGet6(catalog, "AcroForm")) : void 0;
+  const fieldsArr = acroForm ? doc.cos.resolveArray(dictGet6(acroForm, "Fields")) : void 0;
   if (fieldsArr && fieldsArr.items.length > 0) {
     for (const item of fieldsArr.items) {
       const s = serializeCosFieldNode(item, "");
@@ -1791,7 +2116,7 @@ function formatGenerateFdf(doc) {
     }
   } else {
     for (const f of fields) {
-      entries.push(`<< /T (${escapeFdfString(f.name)}) /V ${formatFieldVal(f.name, cosDict3({}))} >>`);
+      entries.push(`<< /T (${escapeFdfString(f.name)}) /V ${formatFieldVal(f.name, cosDict4({}))} >>`);
     }
   }
   return `%FDF-1.2
@@ -1809,9 +2134,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 = cosDict3({ Type: cosName("Outlines") });
+  const outlinesDict = cosDict4({ Type: cosName2("Outlines") });
   const outlinesRef = doc.cos.allocateObject(outlinesDict);
-  dictSet2(catalog, "Outlines", outlinesRef);
+  dictSet3(catalog, "Outlines", outlinesRef);
   const stack = [{ ref: outlinesRef, dict: outlinesDict, children: [] }];
   for (const bm of bookmarks) {
     const targetLevel = Math.max(1, bm.level);
@@ -1830,26 +2155,26 @@ 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 = cosDict3({
-      Title: cosString3(bm.title),
+    const itemDict = cosDict4({
+      Title: cosString4(bm.title),
       Parent: parentState.ref,
-      Dest: cosArray3([pageRef, cosName("XYZ"), { kind: "null" }, { kind: "null" }, { kind: "null" }])
+      Dest: cosArray4([pageRef, cosName2("XYZ"), { kind: "null" }, { kind: "null" }, { kind: "null" }])
     });
     const itemRef = doc.cos.allocateObject(itemDict);
     const prevSibling = parentState.children[parentState.children.length - 1];
     if (prevSibling) {
-      dictSet2(prevSibling.dict, "Next", itemRef);
-      dictSet2(itemDict, "Prev", prevSibling.ref);
+      dictSet3(prevSibling.dict, "Next", itemRef);
+      dictSet3(itemDict, "Prev", prevSibling.ref);
     } else {
-      dictSet2(parentState.dict, "First", itemRef);
+      dictSet3(parentState.dict, "First", itemRef);
     }
-    dictSet2(parentState.dict, "Last", itemRef);
+    dictSet3(parentState.dict, "Last", itemRef);
     parentState.children.push({ ref: itemRef, dict: itemDict });
-    dictSet2(parentState.dict, "Count", cosNumber3(parentState.children.length));
+    dictSet3(parentState.dict, "Count", cosNumber4(parentState.children.length));
   }
 }
 function applyUpdateInfoText(doc, text) {
-  const lines = text.replaceAll("\r\n", "\n").split("\n");
+  const lines2 = text.replaceAll("\r\n", "\n").split("\n");
   let mode = "none";
   let curKey = "";
   let bmTitle = "";
@@ -1901,7 +2226,7 @@ function applyUpdateInfoText(doc, text) {
     pmDimensions = void 0;
     pmCropBox = void 0;
   };
-  for (const raw of lines) {
+  for (const raw of lines2) {
     const line = raw.trim();
     if (line === "InfoBegin") {
       flushStanza();
@@ -1936,7 +2261,7 @@ function applyUpdateInfoText(doc, text) {
         }
         const infoDict = doc.cos.infoRef ? doc.cos.resolveDict(doc.cos.infoRef) : void 0;
         if (infoDict) {
-          dictSet2(infoDict, curKey, cosString3(val));
+          dictSet3(infoDict, curKey, cosString4(val));
         }
       }
       mode = "none";
@@ -1983,7 +2308,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 = cosArray3([cosHexString(b0), cosHexString(b1)]);
+    doc.cos.idArray = cosArray4([cosHexString(b0), cosHexString(b1)]);
   }
   for (const [pageNum, rot] of pageRotations.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
@@ -1992,28 +2317,28 @@ function applyUpdateInfoText(doc, text) {
   }
   for (const [pageNum, [w, h]] of pageDimensions.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
-      dictSet2(
+      dictSet3(
         doc.getPage(pageNum - 1).pageDict,
         "MediaBox",
-        cosArray3([cosNumber3(0), cosNumber3(0), cosNumber3(w), cosNumber3(h)])
+        cosArray4([cosNumber4(0), cosNumber4(0), cosNumber4(w), cosNumber4(h)])
       );
     }
   }
   for (const [pageNum, [x0, y0, x1, y1]] of pageMediaRects.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
-      dictSet2(
+      dictSet3(
         doc.getPage(pageNum - 1).pageDict,
         "MediaBox",
-        cosArray3([cosNumber3(x0), cosNumber3(y0), cosNumber3(x1), cosNumber3(y1)])
+        cosArray4([cosNumber4(x0), cosNumber4(y0), cosNumber4(x1), cosNumber4(y1)])
       );
     }
   }
   for (const [pageNum, [x0, y0, x1, y1]] of pageCropBoxes.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
-      dictSet2(
+      dictSet3(
         doc.getPage(pageNum - 1).pageDict,
         "CropBox",
-        cosArray3([cosNumber3(x0), cosNumber3(y0), cosNumber3(x1), cosNumber3(y1)])
+        cosArray4([cosNumber4(x0), cosNumber4(y0), cosNumber4(x1), cosNumber4(y1)])
       );
     }
   }
@@ -2022,21 +2347,21 @@ function applyUpdateInfoText(doc, text) {
     if (catalog) {
       const numsItems = [];
       for (const pl of pageLabels) {
-        numsItems.push(cosNumber3(Math.max(0, pl.newIndex - 1)));
+        numsItems.push(cosNumber4(Math.max(0, pl.newIndex - 1)));
         const lblEntries = {
-          St: cosNumber3(pl.start)
+          St: cosNumber4(pl.start)
         };
         if (pl.prefix) {
-          lblEntries.P = cosString3(pl.prefix);
+          lblEntries.P = cosString4(pl.prefix);
         }
         const pdfStyle = PAGE_LABEL_STYLE_TO_PDF[pl.style];
         if (pdfStyle) {
-          lblEntries.S = cosName(pdfStyle);
+          lblEntries.S = cosName2(pdfStyle);
         }
-        numsItems.push(cosDict3(lblEntries));
+        numsItems.push(cosDict4(lblEntries));
       }
-      const plDict = cosDict3({ Nums: cosArray3(numsItems) });
-      dictSet2(catalog, "PageLabels", doc.cos.allocateObject(plDict));
+      const plDict = cosDict4({ Nums: cosArray4(numsItems) });
+      dictSet3(catalog, "PageLabels", doc.cos.allocateObject(plDict));
     }
   }
   setDocumentBookmarks(doc, bookmarks);
@@ -2044,20 +2369,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(dictGet5(catalog, "Names"));
+  let namesDict = doc.cos.resolveDict(dictGet6(catalog, "Names"));
   if (!namesDict) {
-    namesDict = cosDict3({});
-    dictSet2(catalog, "Names", doc.cos.allocateObject(namesDict));
+    namesDict = cosDict4({});
+    dictSet3(catalog, "Names", doc.cos.allocateObject(namesDict));
   }
-  let efTree = doc.cos.resolveDict(dictGet5(namesDict, "EmbeddedFiles"));
+  let efTree = doc.cos.resolveDict(dictGet6(namesDict, "EmbeddedFiles"));
   if (!efTree) {
-    efTree = cosDict3({ Names: cosArray3([]) });
-    dictSet2(namesDict, "EmbeddedFiles", doc.cos.allocateObject(efTree));
+    efTree = cosDict4({ Names: cosArray4([]) });
+    dictSet3(namesDict, "EmbeddedFiles", doc.cos.allocateObject(efTree));
   }
-  let namesArr = doc.cos.resolveArray(dictGet5(efTree, "Names"));
+  let namesArr = doc.cos.resolveArray(dictGet6(efTree, "Names"));
   if (!namesArr) {
-    namesArr = cosArray3([]);
-    dictSet2(efTree, "Names", namesArr);
+    namesArr = cosArray4([]);
+    dictSet3(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) {
@@ -2066,34 +2391,34 @@ function attachFilesToDocument(doc, filePaths, files, toPageSpec) {
     const baseName = fp.slice(fp.lastIndexOf("/") + 1);
     const efStreamRef = doc.cos.allocateObject(
       cosStream(bytes, {
-        dict: cosDict3({ Type: cosName("EmbeddedFile") }),
+        dict: cosDict4({ Type: cosName2("EmbeddedFile") }),
         compress: true
       })
     );
     const filespecRef = doc.cos.allocateObject(
-      cosDict3({
-        Type: cosName("Filespec"),
-        F: cosString3(baseName),
-        UF: cosString3(baseName),
-        EF: cosDict3({ F: efStreamRef })
+      cosDict4({
+        Type: cosName2("Filespec"),
+        F: cosString4(baseName),
+        UF: cosString4(baseName),
+        EF: cosDict4({ F: efStreamRef })
       })
     );
-    namesArr.items.push(cosString3(baseName), filespecRef);
+    namesArr.items.push(cosString4(baseName), filespecRef);
     if (targetPageIdx !== void 0) {
       const pageDict = doc.getPage(targetPageIdx).pageDict;
-      let annotsArr = doc.cos.resolveArray(dictGet5(pageDict, "Annots"));
+      let annotsArr = doc.cos.resolveArray(dictGet6(pageDict, "Annots"));
       if (!annotsArr) {
-        annotsArr = cosArray3([]);
-        dictSet2(pageDict, "Annots", annotsArr);
+        annotsArr = cosArray4([]);
+        dictSet3(pageDict, "Annots", annotsArr);
       }
       const annotRef = doc.cos.allocateObject(
-        cosDict3({
-          Type: cosName("Annot"),
-          Subtype: cosName("FileAttachment"),
-          Name: cosName("PushPin"),
-          Contents: cosString3(baseName),
+        cosDict4({
+          Type: cosName2("Annot"),
+          Subtype: cosName2("FileAttachment"),
+          Name: cosName2("PushPin"),
+          Contents: cosString4(baseName),
           FS: filespecRef,
-          Rect: cosArray3([cosNumber3(20), cosNumber3(20), cosNumber3(40), cosNumber3(40)])
+          Rect: cosArray4([cosNumber4(20), cosNumber4(20), cosNumber4(40), cosNumber4(40)])
         })
       );
       annotsArr.items.push(annotRef);
@@ -2110,11 +2435,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(dictGet5(specDict, "UF") ?? dictGet5(specDict, "F"));
-    const fileName = attachmentBasename(ufNode?.kind === "string" ? decodePdfString4(ufNode) : fallbackName);
-    const efDict = doc.cos.resolveDict(dictGet5(specDict, "EF"));
+    const ufNode = doc.cos.resolve(dictGet6(specDict, "UF") ?? dictGet6(specDict, "F"));
+    const fileName = attachmentBasename(ufNode?.kind === "string" ? decodePdfString5(ufNode) : fallbackName);
+    const efDict = doc.cos.resolveDict(dictGet6(specDict, "EF"));
     const fStream = efDict ? doc.cos.resolve(
-      dictGet5(efDict, "UF") ?? dictGet5(efDict, "F") ?? dictGet5(efDict, "DOS") ?? dictGet5(efDict, "Mac") ?? dictGet5(efDict, "Unix")
+      dictGet6(efDict, "UF") ?? dictGet6(efDict, "F") ?? dictGet6(efDict, "DOS") ?? dictGet6(efDict, "Mac") ?? dictGet6(efDict, "Unix")
     ) : void 0;
     if (fStream?.kind === "stream") {
       const decoded = doc.cos.decodeStream(fStream);
@@ -2124,10 +2449,10 @@ function unpackFilesFromDocument(doc, outDir, files) {
   };
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
   if (catalog) {
-    const namesDict = doc.cos.resolveDict(dictGet5(catalog, "Names"));
+    const namesDict = doc.cos.resolveDict(dictGet6(catalog, "Names"));
     const efPairs = [];
     if (namesDict) {
-      collectNameTreePairs(doc, dictGet5(namesDict, "EmbeddedFiles"), efPairs);
+      collectNameTreePairs(doc, dictGet6(namesDict, "EmbeddedFiles"), efPairs);
     }
     for (const pair of efPairs) {
       const specDict = doc.cos.resolveDict(pair.value);
@@ -2135,7 +2460,7 @@ function unpackFilesFromDocument(doc, outDir, files) {
         writeSpecDict(specDict, pair.name);
       }
     }
-    const rootAfArr = doc.cos.resolveArray(dictGet5(catalog, "AF"));
+    const rootAfArr = doc.cos.resolveArray(dictGet6(catalog, "AF"));
     if (rootAfArr) {
       for (const item of rootAfArr.items) {
         const specDict = doc.cos.resolveDict(item);
@@ -2144,21 +2469,21 @@ function unpackFilesFromDocument(doc, outDir, files) {
     }
   }
   for (let p = 0; p < doc.pageCount; p++) {
-    const pageAfArr = doc.cos.resolveArray(dictGet5(doc.getPage(p).pageDict, "AF"));
+    const pageAfArr = doc.cos.resolveArray(dictGet6(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(dictGet5(doc.getPage(p).pageDict, "Annots"));
+    const annotsArr = doc.cos.resolveArray(dictGet6(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(dictGet5(annotDict, "Subtype"));
+      const subNode = doc.cos.resolve(dictGet6(annotDict, "Subtype"));
       if (subNode?.kind === "name" && subNode.decoded === "FileAttachment") {
-        const specDict = doc.cos.resolveDict(dictGet5(annotDict, "FS"));
+        const specDict = doc.cos.resolveDict(dictGet6(annotDict, "FS"));
         if (specDict) writeSpecDict(specDict);
       }
     }
@@ -2169,7 +2494,7 @@ function cloneCosSubgraphInto(srcDoc, dstDoc, node, memo = /* @__PURE__ */ new M
   if (node.kind === "ref") {
     const cached = memo.get(node.objectNumber);
     if (cached) return cached;
-    const placeholder = dstDoc.cos.allocateObject(cosDict3({}));
+    const placeholder = dstDoc.cos.allocateObject(cosDict4({}));
     memo.set(node.objectNumber, placeholder);
     const resolved = srcDoc.cos.resolve(node);
     const cloned = cloneCosSubgraphInto(srcDoc, dstDoc, resolved, memo);
@@ -2183,14 +2508,14 @@ function cloneCosSubgraphInto(srcDoc, dstDoc, node, memo = /* @__PURE__ */ new M
     return placeholder;
   }
   if (node.kind === "array") {
-    return cosArray3(node.items.map((it) => cloneCosSubgraphInto(srcDoc, dstDoc, it, memo)).filter(Boolean));
+    return cosArray4(node.items.map((it) => cloneCosSubgraphInto(srcDoc, dstDoc, it, memo)).filter(Boolean));
   }
   if (node.kind === "dict") {
-    const next = cosDict3({});
+    const next = cosDict4({});
     for (const entry of node.entries) {
       if (entry.key.decoded === "Parent") continue;
       const clonedVal = cloneCosSubgraphInto(srcDoc, dstDoc, entry.value, memo);
-      if (clonedVal) dictSet2(next, entry.key.decoded, clonedVal);
+      if (clonedVal) dictSet3(next, entry.key.decoded, clonedVal);
     }
     return next;
   }
@@ -2255,31 +2580,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(dictGet5(srcRes, subKey));
+      const srcSub = overlayDoc.cos.resolveDict(dictGet6(srcRes, subKey));
       if (!srcSub) continue;
-      let dstSub = targetDoc.cos.resolveDict(dictGet5(dstRes, subKey));
+      let dstSub = targetDoc.cos.resolveDict(dictGet6(dstRes, subKey));
       if (!dstSub) {
-        dstSub = cosDict3({});
-        dictSet2(dstRes, subKey, dstSub);
+        dstSub = cosDict4({});
+        dictSet3(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 (!dictGet5(dstSub, origKey)) {
-          dictSet2(dstSub, origKey, cloned);
+        if (!dictGet6(dstSub, origKey)) {
+          dictSet3(dstSub, origKey, cloned);
         } else {
           let newKey = `Ov_${i}_${origKey}`;
           let suffix = 1;
-          while (dictGet5(dstSub, newKey)) {
+          while (dictGet6(dstSub, newKey)) {
             newKey = `Ov_${i}_${suffix++}_${origKey}`;
           }
-          dictSet2(dstSub, newKey, cloned);
+          dictSet3(dstSub, newKey, cloned);
           renamedResources.set(origKey, newKey);
         }
       }
     }
-    const srcContents = dictGet5(srcPage.pageDict, "Contents");
+    const srcContents = dictGet6(srcPage.pageDict, "Contents");
     if (!srcContents) continue;
     const rawSrcNodes = [];
     const resolvedSrcContents = overlayDoc.cos.resolve(srcContents);
@@ -2305,7 +2630,7 @@ function applyOverlayToDocument(targetDoc, overlayDoc, mode, multi) {
       }
     }
     if (srcList.length === 0) continue;
-    const dstContents = dictGet5(dstPage.pageDict, "Contents");
+    const dstContents = dictGet6(dstPage.pageDict, "Contents");
     const toStreamList = (c) => {
       if (!c) return [];
       const r = targetDoc.cos.resolve(c);
@@ -2354,7 +2679,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];
-    dictSet2(dstPage.pageDict, "Contents", cosArray3(combined));
+    dictSet3(dstPage.pageDict, "Contents", cosArray4(combined));
   }
 }
 function normalizeQuarterTurn(degrees) {
@@ -2538,9 +2863,9 @@ function* runPdftkCliSteps(argv, files, signal) {
       if (!cached) {
         cached = [];
         const cat = d.cos.resolveDict(d.cos.rootRef);
-        const outDict = cat ? d.cos.resolveDict(dictGet5(cat, "Outlines")) : void 0;
+        const outDict = cat ? d.cos.resolveDict(dictGet6(cat, "Outlines")) : void 0;
         if (outDict) {
-          collectOutlineBookmarks(d, dictGet5(outDict, "First"), 1, cached);
+          collectOutlineBookmarks(d, dictGet6(outDict, "First"), 1, cached);
         }
         bookmarksByDoc.set(d, cached);
       }
@@ -2630,7 +2955,7 @@ function* runPdftkCliSteps(argv, files, signal) {
   }
   if (dropXfa) {
     const root = resultDoc.cos.resolveDict(resultDoc.cos.rootRef);
-    const acroForm = root ? resultDoc.cos.resolveDict(dictGet5(root, "AcroForm")) : void 0;
+    const acroForm = root ? resultDoc.cos.resolveDict(dictGet6(root, "AcroForm")) : void 0;
     if (acroForm)
       dictDelete2(acroForm, "XFA");
   }
@@ -2645,28 +2970,28 @@ function* runPdftkCliSteps(argv, files, signal) {
       if (++cooperativeWork % 64 === 0)
         yield;
       if (obj.value.kind === "dict") {
-        const stNode = dictGet5(obj.value, "Subtype");
-        const bfNode = dictGet5(obj.value, "BaseFont");
+        const stNode = dictGet6(obj.value, "Subtype");
+        const bfNode = dictGet6(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") {
-          dictSet2(obj.value, "BaseFont", cosName(cleanFontName));
+          dictSet3(obj.value, "BaseFont", cosName2(cleanFontName));
         }
       }
     }
   }
   if (operation === "fill_form" && !shouldFlatten) {
     const root = resultDoc.cos.resolveDict(resultDoc.cos.rootRef);
-    const acroForm = root ? resultDoc.cos.resolveDict(dictGet5(root, "AcroForm")) : void 0;
+    const acroForm = root ? resultDoc.cos.resolveDict(dictGet6(root, "AcroForm")) : void 0;
     if (acroForm) {
-      dictSet2(acroForm, "NeedAppearances", { kind: "boolean", value: needAppearances });
+      dictSet3(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(dictGet5(root, "AcroForm"));
+      const acroForm = resultDoc.cos.resolveDict(dictGet6(root, "AcroForm"));
       if (acroForm) {
-        dictSet2(acroForm, "NeedAppearances", { kind: "boolean", value: true });
+        dictSet3(acroForm, "NeedAppearances", { kind: "boolean", value: true });
       }
     }
   }
@@ -2674,12 +2999,12 @@ function* runPdftkCliSteps(argv, files, signal) {
   if (keepFinalId) {
     const lastInput = handleDocs[handleDocs.length - 1];
     if (lastInput?.cos.idArray) {
-      resultDoc.cos.idArray = cosArray3([...lastInput.cos.idArray.items]);
+      resultDoc.cos.idArray = cosArray4([...lastInput.cos.idArray.items]);
     }
   } else if (keepFirstId || !resultDoc.cos.idArray) {
     const firstInput = handleDocs[0];
     if (firstInput?.cos.idArray) {
-      resultDoc.cos.idArray = cosArray3([...firstInput.cos.idArray.items]);
+      resultDoc.cos.idArray = cosArray4([...firstInput.cos.idArray.items]);
     }
   }
   if (uncompressStreams || compressStreams) {
@@ -2746,7 +3071,7 @@ async function executePdftk(context, retainedContext = context) {
     const carrier = getCommandArguments(context);
     const argv = [...carrier.args];
     const parsed = await drainSteps(parsePdftkArgumentsSteps(argv), invocation.signal);
-    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))) {
+    if (parsed.options && (["output", "rotate", "attach_files", "stamp", "multistamp", "background", "multibackground", "burst", "update_info", "update_info_utf8", "cat", "shuffle", "fill_form"].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();