@poe-platform/safe-bash 0.1.812 → 0.1.814

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

@@ -1,50 +1,493 @@
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
-// packages/safe-bash-command-pdftk/src/retained-fields.ts
-async function* retainedFieldReport(document, utf8, signal) {
-  const encoder = new TextEncoder();
-  let work = 0;
-  async function* line(prefix, value) {
-    let part = prefix;
-    for (const char of String(value)) {
-      const code = char.codePointAt(0);
-      part += !utf8 && code > 127 ? `&#${code};` : char;
-      if (part.length >= 4096) {
-        signal.throwIfAborted();
-        if (++work % 16 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
-        yield encoder.encode(part);
-        part = "";
+// 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 = "";
+  let replaced = false;
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] !== "%") {
+      out += pattern[i];
+      continue;
+    }
+    if (pattern[i + 1] === "%") {
+      out += "%";
+      i++;
+      continue;
+    }
+    if (!replaced) {
+      let j = i + 1;
+      let zeroPad = false;
+      if (pattern[j] === "0") {
+        zeroPad = true;
+        j++;
+      }
+      let widthStr = "";
+      while (j < pattern.length && pattern[j] >= "0" && pattern[j] <= "9") {
+        widthStr += pattern[j];
+        j++;
+      }
+      if (pattern[j] === "d") {
+        const width = widthStr ? Number.parseInt(widthStr, 10) : 1;
+        out += zeroPad ? String(pageNum).padStart(width, "0") : String(pageNum);
+        replaced = true;
+        i = j;
+        continue;
+      }
+    }
+    out += "%";
+  }
+  return out;
+}
+
+// packages/safe-bash-command-pdftk/src/retained-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();
-    yield encoder.encode(part + "\n");
   }
-  for await (const field of document.formFieldDetails()) {
-    yield encoder.encode("---\n");
-    yield* line("FieldType: ", field.type === "checkbox" ? "Button" : field.type === "choice" ? "Choice" : "Text");
-    yield* line("FieldName: ", field.name);
-    if (field.altName) yield* line("FieldNameAlt: ", field.altName);
-    yield* line("FieldFlags: ", field.flags);
-    for await (const value of field.values()) yield* line("FieldValue: ", value);
-    if (field.defaultValue !== void 0 && field.defaultValue !== "") yield* line("FieldValueDefault: ", field.defaultValue);
-    yield* line("FieldJustification: ", field.justification);
-    for await (const option of field.options()) yield* line("FieldStateOption: ", option);
-    if (field.maxLength !== void 0) yield* line("FieldMaxLength: ", field.maxLength);
+  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.ts
-import { PdfError, PdfFileSource, PdfRetainedDocument, retainedCosObjects } from "../pdf-ast/index.js";
-import { FsError } from "../safe-bash-contracts/errors.js";
-import { writeBytes } from "../safe-bash-contracts/io.js";
-import { resolvePath } from "../safe-bash-contracts/path.js";
-import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
+// packages/safe-bash-command-pdftk/src/retained-burst.ts
+import { createRetainedPageCopy as createRetainedPageCopy2, saveRetainedDocumentChunks } from "../pdf-ast/index.js";
 
-// packages/safe-bash-command-pdftk/src/retained-annots.ts
-import { IntegerTable, PagedStorage } from "@poe-platform/safe-fs/storage";
-import { PdfMutableObjectStore, decodePdfString, dictGet } from "../pdf-ast/index.js";
-async function* retainedAnnotationReport(document, storage, utf8, signal) {
-  const backing = new PagedStorage({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pages = new IntegerTable(backing, 64);
+// packages/safe-bash-command-pdftk/src/retained-inspection.ts
+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 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() {
@@ -72,29 +515,37 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
   }
   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) => {
+    const push = async (value, level = 1) => {
       await checkpoint();
-      await stack.set({ objectNumber: ++pending, generationNumber: 0, value });
+      await stack.set({ objectNumber: ++pending, generationNumber: 0, value: cosArray2([value, cosNumber2(level)]) });
     };
     try {
       await push(start);
       while (pending) {
         await checkpoint();
-        const raw = (await stack.get(pending--)).value;
+        const frame = (await stack.get(pending--)).value;
+        if (frame.kind !== "array") continue;
+        const raw = frame.items[0], levelNode = frame.items[1], level = levelNode.kind === "number" ? levelNode.value : 1;
         if (raw.kind === "ref") {
           if (await seen.get(BigInt(raw.objectNumber))) continue;
           await seen.set(BigInt(raw.objectNumber), 1n);
         }
         const value = await resolve(raw);
         if (value?.kind === "array" && key === "Next") {
-          for (let i = value.items.length - 1; i >= 0; i--) await push(value.items[i]);
+          for (let i = value.items.length - 1; i >= 0; i--) await push(value.items[i], level);
           continue;
         }
         if (value?.kind !== "dict") continue;
-        yield value;
-        const child = dictGet(value, key);
+        yield { dict: value, level };
+        if (key === "Outlines") {
+          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 = dictGet3(value, key);
         if (key === "Next") {
           if (child) await push(child);
         } else {
@@ -114,23 +565,23 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
   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 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;
               }
@@ -141,7 +592,7 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
       }
       node = await resolve(target);
       if (node?.kind === "dict") {
-        const inner = dictGet(node, "D");
+        const inner = dictGet3(node, "D");
         if (inner) node = await resolve(inner);
       }
     }
@@ -156,7 +607,7 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
   }
   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];
@@ -172,14 +623,48 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
     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()) {
       pageCount++;
       if (page.reference && !await pages.get(BigInt(page.reference.objectNumber))) await pages.set(BigInt(page.reference.objectNumber), BigInt(page.index + 1));
     }
+    if (kind === "document") {
+      const emitted = new 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(dictGet3(info, key));
+            const value = node?.kind === "string" ? decodePdfString3(node) : node?.kind === "name" ? node.decoded : "";
+            if (value) {
+              await emitted.intern(key);
+              yield* line("", "InfoBegin");
+              yield* line("InfoKey: ", key, true);
+              yield* line("InfoValue: ", value, true);
+            }
+          }
+          for (const entry of info.entries) {
+            const node = await resolve(entry.value), value = node?.kind === "string" ? decodePdfString3(node) : "";
+            if (value && (await emitted.intern(entry.key.decoded)).added) {
+              yield* line("", "InfoBegin");
+              yield* line("InfoKey: ", entry.key.decoded, true);
+              yield* line("InfoValue: ", value, true);
+            }
+          }
+        }
+      } catch (error) {
+        failed2 = true;
+        throw error;
+      } finally {
+        await emitted.close().catch((error) => {
+          if (!failed2) throw error;
+        });
+      }
+    }
     for (let i = 0; i < 2; i++) {
       const id = await resolve(document.crossReference.idArray?.items[i]);
       if (id?.kind !== "string") yield* line(`PdfID${i}: `, "00000000000000000000000000000000");
@@ -195,13 +680,82 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
       }
     }
     yield* line("NumberOfPages: ", pageCount);
+    if (kind === "document") {
+      const catalog = await resolve(document.crossReference.rootRef);
+      const outlines = catalog?.kind === "dict" ? await resolve(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);
+          yield* line("BookmarkLevel: ", level);
+          yield* line("BookmarkPageNumber: ", index === void 0 ? 1 : index + 1);
+        }
+      }
+      async function rectangle(raw, strict) {
+        const node = await resolve(raw);
+        if (node?.kind !== "array" || node.items.length < 4) return;
+        const result = [];
+        for (const item of node.items.slice(0, 4)) {
+          const number = await resolve(item);
+          if (strict && number?.kind !== "number") return;
+          result.push(number?.kind === "number" ? number.value : 0);
+        }
+        return result;
+      }
+      for await (const page of document.pages()) {
+        let media, rotate, hasMedia = false, hasRotate = false;
+        for await (const parent of document.pageAncestors(page.dict)) {
+          if (!hasMedia && dictGet3(parent, "MediaBox")) {
+            hasMedia = true;
+            media = dictGet3(parent, "MediaBox");
+          }
+          if (!hasRotate && dictGet3(parent, "Rotate")) {
+            hasRotate = true;
+            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(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(dictGet3(page.dict, "CropBox"), false);
+        if (crop) {
+          yield* line("PageMediaCropBox: ", crop.join(" "));
+          yield* line("PageMediaCropRect: ", crop.join(" "));
+        }
+      }
+      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(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" && 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);
@@ -212,7 +766,7 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
         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)) {
@@ -221,31 +775,31 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
           }
           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");
-        if (action) for await (const dict of walk(action, "Next")) {
-          const type = await resolve(dictGet(dict, "S"));
+        const action = dictGet3(annotation, "A");
+        if (action) for await (const { dict } of walk(action, "Next")) {
+          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);
@@ -262,10 +816,365 @@ async function* retainedAnnotationReport(document, storage, utf8, signal) {
   }
 }
 
+// packages/safe-bash-command-pdftk/src/retained-burst.ts
+async function* retainedBurst(document, storage, options, pageCount, signal) {
+  const pattern = options.outputTarget ?? "pg_%04d.pdf";
+  const slash = pattern.lastIndexOf("/");
+  const report = slash < 0 ? "doc_data.txt" : `${pattern.slice(0, slash + 1)}doc_data.txt`;
+  const repeated = formatBurstFilename(pattern, 1) === formatBurstFilename(pattern, 2);
+  for (let index = repeated ? Math.max(0, pageCount - 1) : 0; index < pageCount; index++) {
+    signal.throwIfAborted();
+    const path = formatBurstFilename(pattern, index + 1);
+    if (path === "-" || path === report) continue;
+    const copy = await 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();
+      yield { path, chunks };
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      await copy.close().catch((error) => {
+        if (!failed) throw error;
+      });
+    }
+  }
+  yield { path: report, chunks: retainedInspectionReport(document, storage, false, signal, "document") };
+}
+
+// packages/safe-bash-command-pdftk/src/retained-rotate.ts
+import { PagedStorage as PagedStorage4 } from "@poe-platform/safe-fs/storage";
+async function* retainedRotations(args, handles, primaryHandle, pageCount, storage, signal) {
+  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 {
+    for (const arg of args) for (const selection of iteratePdftkRangeToken(arg, handles, primaryHandle)) {
+      signal.throwIfAborted();
+      if (++work % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+      if (!selection.rotation || selection.pageNumber > pageCount) continue;
+      const bytes = new Uint8Array(16), view = new DataView(bytes.buffer);
+      view.setFloat64(0, selection.rotation.kind === "relative" ? 2 : 1);
+      view.setFloat64(8, selection.rotation.degrees);
+      await records.write(base + (selection.pageNumber - 1) * 16, bytes);
+    }
+    for (let pageIndex = 0; pageIndex < pageCount; pageIndex++) {
+      signal.throwIfAborted();
+      if (++work % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+      const bytes = await records.read(base + pageIndex * 16, 16), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length), kind = view.getFloat64(0);
+      if (kind) yield { pageIndex, degrees: view.getFloat64(8), relative: kind === 2 };
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    await records.close().catch((error) => {
+      if (!failed) throw error;
+    });
+  }
+}
+
+// packages/safe-bash-command-pdftk/src/retained-output.ts
+import { editRetainedDocument as editRetainedDocument2, PdfFileSource as PdfFileSource3, PdfMutableObjectStore as PdfMutableObjectStore4, PdfRetainedDocument, cosBool, 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) {
+  const infoUpdates = info?.updates;
+  const store = new PdfMutableObjectStore4(storage, { signal });
+  let edited;
+  let document, plaintext, failed = false;
+  try {
+    if (options.operation === "attach_files" || stamps || infoUpdates) {
+      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 editRetainedDocument2(source, 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 = 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(dictGet4(root.value, "AcroForm"));
+      if (form?.value.kind === "dict" && !form.stream) {
+        if (options.dropXfa) dictDelete(form.value, "XFA");
+        if (options.needAppearances) dictSet2(form.value, "NeedAppearances", cosBool(true));
+        if (form.reference) await store.set({ objectNumber: form.reference.objectNumber, generationNumber: form.reference.generationNumber, value: form.value });
+        else dictSet2(root.value, "AcroForm", form.value);
+      }
+      await store.set({ objectNumber: root.reference.objectNumber, generationNumber: root.reference.generationNumber, value: root.value });
+    }
+    const chunks = saveRetainedDocumentChunks2(document, storage, { signal, ...options.operation === "rotate" ? { rotations: retainedRotations(options.opArgs, handles, options.inputs[0].handle, pageCount, storage, signal) } : {}, removeMetadata: options.dropXmp, streamMode: options.uncompressStreams ? "uncompress" : options.compressStreams ? "compress" : "preserve" });
+    if (!options.userPassword && !options.ownerPassword) {
+      yield* chunks;
+      return;
+    }
+    plaintext = await PdfFileSource3.fromStream(storage.fs, storage.directory, chunks, { signal });
+    const allow = options.allowPermissions, all = allow.has("allfeatures");
+    yield* encryptRetainedPdfChunks(plaintext, storage, {
+      userPassword: options.userPassword ?? "",
+      ownerPassword: options.ownerPassword ?? options.userPassword ?? "owner",
+      revision: 6,
+      signal,
+      ...allow.size ? { permissions: { print: all || allow.has("printing") || allow.has("degradedprinting"), modify: all || allow.has("modifycontents"), copy: all || allow.has("copycontents"), addNotes: all || allow.has("modifyannotations"), fillForms: all || allow.has("fillin") || allow.has("modifyannotations"), extractAccessibility: all || allow.has("screenreaders"), assemble: all || allow.has("assembly") || allow.has("modifycontents"), printHighRes: all || allow.has("printing") } } : {}
+    });
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([document?.close(), plaintext?.close(), store.close(), edited?.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
+// packages/safe-bash-command-pdftk/src/retained-fdf.ts
+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 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() {
+    signal.throwIfAborted();
+    if (++work % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+    signal.throwIfAborted();
+  }
+  async function resolve(node) {
+    await checkpoint();
+    const found = await document.lookup(node);
+    return found?.stream ? void 0 : found?.value;
+  }
+  async function* text(value, escape = false) {
+    let chunk = "";
+    for (const char of value) {
+      chunk += escape ? char === "\\" || char === "(" || char === ")" ? `\\${char}` : char === "\r" ? "\\r" : char === "\n" ? "\\n" : char : char;
+      if (chunk.length >= 4096) {
+        await checkpoint();
+        yield encoder.encode(chunk);
+        chunk = "";
+      }
+    }
+    if (chunk) {
+      signal.throwIfAborted();
+      yield encoder.encode(chunk);
+    }
+  }
+  async function* fieldValue(field) {
+    if (field.checked !== void 0) {
+      yield* text(`/${field.checked ? field.stateValue ?? "Yes" : "Off"}`);
+      return;
+    }
+    let count = 0;
+    for await (const ignored of field.values()) {
+      void ignored;
+      if (++count > 1) break;
+    }
+    if (count > 1) yield* text("[ ");
+    let first = true;
+    for await (const value of field.values()) {
+      if (!first) yield* text(" ");
+      first = false;
+      yield* text("(");
+      yield* text(value, true);
+      yield* text(")");
+    }
+    if (count > 1) yield* text(" ]");
+  }
+  async function record(id) {
+    const node = (await tree.get(id))?.value;
+    if (node?.kind !== "array") throw new PdfError("E_PARSE", "Invalid FDF traversal record");
+    return node.items;
+  }
+  const number = (items, at) => {
+    const node = items[at];
+    if (node?.kind !== "number") throw new PdfError("E_PARSE", "Invalid FDF traversal number");
+    return node.value;
+  };
+  const string = (items, at) => {
+    const node = items[at];
+    if (node?.kind !== "string") throw new PdfError("E_PARSE", "Invalid FDF traversal name");
+    return decodePdfString4(node);
+  };
+  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 PdfFileSource4.fromStream(storage.fs, storage.directory, fieldValue(field), { signal });
+      let valueFailed = false;
+      try {
+        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;
+      } finally {
+        await staged.close().catch((error) => {
+          if (!valueFailed) throw error;
+        });
+      }
+    }
+    const catalog = await resolve(document.crossReference.rootRef);
+    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(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 && !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] = cosNumber3(cursor);
+        await save(top, frame);
+        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;
+      }
+      if (descended) continue;
+      const parent = number(frame, 7);
+      if (parent && (number(frame, 4) || string(frame, 1) || string(frame, 2))) {
+        const owner = await record(parent), last = number(owner, 5);
+        if (last) {
+          const sibling = await record(last);
+          sibling[6] = cosNumber3(top);
+          await save(last, sibling);
+        } else owner[4] = cosNumber3(top);
+        owner[5] = cosNumber3(top);
+        await save(parent, owner);
+      }
+      top = parent;
+    }
+    yield* text("%FDF-1.2\n1 0 obj\n<< /FDF << /Fields [\n");
+    let current = number(await record(1), 4);
+    if (current) yield* text("  ");
+    while (current) {
+      await checkpoint();
+      const frame = await record(current), child = number(frame, 4);
+      yield* text("<< /T (");
+      yield* text(string(frame, 2) || string(frame, 1), true);
+      yield* text(")");
+      if (child) {
+        yield* text(" /Kids [ ");
+        current = child;
+        continue;
+      }
+      yield* text(" /V ");
+      const name = await names.intern(string(frame, 1)), value = name.added ? void 0 : await values.get(name.index + 1);
+      if (value?.stream) yield* value.stream.chunks;
+      else {
+        const dict = await resolve(frame[0]), raw = dict?.kind === "dict" ? await resolve(dictGet5(dict, "V")) : void 0;
+        if (raw?.kind === "name") yield* text(`/${raw.decoded}`);
+        else {
+          yield* text("(");
+          if (raw?.kind === "string") yield* text(decodePdfString4(raw), true);
+          yield* text(")");
+        }
+      }
+      yield* text(" >>");
+      while (current) {
+        const done = await record(current), sibling = number(done, 6), parent = number(done, 7);
+        if (sibling) {
+          yield* text(parent === 1 ? "\n  " : " ");
+          current = sibling;
+          break;
+        }
+        current = parent === 1 ? 0 : parent;
+        if (current) yield* text(" ] >>");
+      }
+    }
+    yield* text("\n] >> >>\nendobj\ntrailer\n<< /Root 1 0 R >>\n%%EOF\n");
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([names.close(), values.close(), tree.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
+// packages/safe-bash-command-pdftk/src/retained-fields.ts
+async function* retainedFieldReport(document, utf8, signal) {
+  const encoder = new TextEncoder();
+  let work = 0;
+  async function* line(prefix, value) {
+    let part = prefix;
+    for (const char of String(value)) {
+      const code = char.codePointAt(0);
+      part += !utf8 && code > 127 ? `&#${code};` : char;
+      if (part.length >= 4096) {
+        signal.throwIfAborted();
+        if (++work % 16 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+        yield encoder.encode(part);
+        part = "";
+      }
+    }
+    signal.throwIfAborted();
+    yield encoder.encode(part + "\n");
+  }
+  for await (const field of document.formFieldDetails()) {
+    yield encoder.encode("---\n");
+    yield* line("FieldType: ", field.type === "checkbox" ? "Button" : field.type === "choice" ? "Choice" : "Text");
+    yield* line("FieldName: ", field.name);
+    if (field.altName) yield* line("FieldNameAlt: ", field.altName);
+    yield* line("FieldFlags: ", field.flags);
+    for await (const value of field.values()) yield* line("FieldValue: ", value);
+    if (field.defaultValue !== void 0 && field.defaultValue !== "") yield* line("FieldValueDefault: ", field.defaultValue);
+    yield* line("FieldJustification: ", field.justification);
+    for await (const option of field.options()) yield* line("FieldStateOption: ", option);
+    if (field.maxLength !== void 0) yield* line("FieldMaxLength: ", field.maxLength);
+  }
+}
+
 // packages/safe-bash-command-pdftk/src/retained.ts
+import { PdfError as PdfError2, PdfFileSource as 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";
+import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 async function executeRetainedPdftk(context, options) {
   const signal = context.signal, storage = { fs: context.fs, directory: resolvePath(context.cwd, context.env.TMPDIR || "/tmp") };
+  const handles = /* @__PURE__ */ new Map();
+  for (const input of options.inputs) {
+    handles.set(input.handle, input);
+    if (!handles.has("")) handles.set("", input);
+  }
+  const primary = options.inputs[0];
+  let idInput = handles.values().next().value;
+  if (options.keepFinalId) for (const input of handles.values()) idInput = input;
+  let selectedId;
+  const counts = /* @__PURE__ */ new Map();
   const inputs = /* @__PURE__ */ new Map();
+  const 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;
+  if (options.operation === "attach_files") for (let i = 0; i < options.opArgs.length; i++) {
+    if (options.opArgs[i].toLowerCase() === "to_page") attachmentPage = options.opArgs[++i];
+    else attachmentPaths.push(options.opArgs[i]);
+  }
+  async function* attachments() {
+    for (const path of attachmentPaths) {
+      const source = inputs.get(path);
+      if (source) yield { filename: path.slice(path.lastIndexOf("/") + 1), chunks: source.stream(0, source.size, signal) };
+    }
+  }
+  let assembled;
+  let overlayDocument;
   let document, output, total = 0, failed = false;
   const diagnostic = async (message) => {
     await writeBytes(context.stderr, new TextEncoder().encode(message), signal);
@@ -274,20 +1183,20 @@ async function executeRetainedPdftk(context, options) {
   try {
     await context.fs.mkdir(storage.directory, { recursive: true, signal });
     const maximum = context.inputBudget?.maxBytes ?? Infinity;
-    if (options.inputs.some((input) => input.file === "-")) {
-      const source = await PdfFileSource.fromStream(context.fs, storage.directory, context.stdin, { signal, maxInputBytes: maximum });
+    if (options.inputs.some((input) => input.file === "-") || attachmentPaths.includes("-") || overlayPath === "-" || infoPath === "-") {
+      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) {
+    for (const input of [...options.inputs, ...attachmentPaths.map((file) => ({ file })), ...overlayPath !== void 0 ? [{ file: overlayPath }] : [], ...infoPath !== void 0 ? [{ file: infoPath }] : []]) {
       if (inputs.has(input.file)) continue;
       let source;
       try {
-        source = await PdfFileSource.open(context.fs, resolvePath(context.cwd, input.file), { signal, maxInputBytes: maximum - total });
+        source = await 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 PdfError && error.message === "PDF source must be a regular file") {
+        if (error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR", "EACCES", "EISDIR"].includes(String(error.code)) || error instanceof PdfError2 && error.message === "PDF source must be a regular file") {
           inputs.set(input.file, void 0);
           continue;
         }
@@ -302,12 +1211,18 @@ async function executeRetainedPdftk(context, options) {
       if (!source) return await diagnostic(`Error: Unable to find file '${input.file}'
 `);
       try {
-        document = await PdfRetainedDocument.open(source, storage, { signal, recovery: "strict", ...input.password ? { password: input.password } : {} });
-        for await (const object of retainedCosObjects(document, storage, { signal })) if (object.stream) for await (const ignored of object.stream.chunks) void ignored;
-        for await (const ignored of document.pages()) void ignored;
+        document = await PdfRetainedDocument2.open(source, storage, { signal, recovery: "strict", ...input.password ? { password: input.password } : {} });
+        if (input === idInput) selectedId = document.crossReference.idArray;
+        for await (const object of retainedCosObjects2(document, storage, { signal })) if (object.stream) for await (const ignored of object.stream.chunks) void ignored;
+        let count = 0;
+        for await (const ignored of document.pages()) {
+          void ignored;
+          count++;
+        }
+        counts.set(input, count);
       } catch (error) {
         signal.throwIfAborted();
-        if (!(error instanceof PdfError) || error.code === "E_LIMIT" || error.code === "E_CANCELLED") throw error;
+        if (!(error instanceof PdfError2) || error.code === "E_LIMIT" || error.code === "E_CANCELLED") throw error;
         return await diagnostic(`Error: Failed to open PDF '${input.file}': ${error.message}
 `);
       }
@@ -315,14 +1230,48 @@ async function executeRetainedPdftk(context, options) {
       document = void 0;
       await source.releaseCache();
     }
-    const primary = options.inputs[0];
-    document = await PdfRetainedDocument.open(inputs.get(primary.file), storage, { signal, recovery: "strict", ...primary.password ? { password: primary.password } : {} });
-    output = await PdfFileSource.fromStream(context.fs, storage.directory, options.operation === "dump_data_fields" || options.operation === "dump_data_fields_utf8" ? retainedFieldReport(document, options.operation.endsWith("_utf8"), signal) : retainedAnnotationReport(document, storage, options.operation.endsWith("_utf8"), signal), { signal });
+    document = await PdfRetainedDocument2.open(inputs.get(primary.file), storage, { signal, recovery: "strict", ...primary.password ? { password: primary.password } : {} });
+    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);
+      if (!source) return await diagnostic(`Error: Unable to open '${overlayPath}'
+`);
+      overlayDocument = await PdfRetainedDocument2.open(source, storage, { signal, recovery: "strict" });
+      for await (const object of retainedCosObjects2(overlayDocument, storage, { signal })) if (object.stream) for await (const ignored of object.stream.chunks) void ignored;
+      for await (const ignored of overlayDocument.pages()) {
+        void ignored;
+        overlayPages++;
+      }
+    }
+    async function* stampPages() {
+      if (overlayPages) for (let targetIndex = 0; targetIndex < counts.get(primary); targetIndex++) yield { targetIndex, sourceIndex: options.operation.startsWith("multi") ? Math.min(targetIndex, overlayPages - 1) : 0 };
+    }
+    if (options.operation === "unpack_files" || options.operation === "burst") {
+      const files = options.operation === "burst" ? retainedBurst(document, storage, options, counts.get(primary), signal) : retainedUnpack(document, storage, options.outputTarget ?? ".", inputs.keys(), signal);
+      for await (const file of files) {
+        try {
+          await publish(context, resolvePath(context.cwd, file.path), file.chunks);
+        } catch (error) {
+          signal.throwIfAborted();
+          if (!(error instanceof Error) || !("code" in error)) throw error;
+          return await diagnostic(`Error: Failed to open output file '${file.path}': ${error.code}.
+`);
+        }
+      }
+      return { exitCode: 0 };
+    }
+    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"].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) : options.operation === "generate_fdf" ? retainedFdf(document, storage, signal) : options.operation === "dump_data_fields" || options.operation === "dump_data_fields_utf8" ? retainedFieldReport(document, options.operation.endsWith("_utf8"), signal) : retainedInspectionReport(document, storage, options.operation.endsWith("_utf8"), signal, options.operation === "dump_data" || options.operation === "dump_data_utf8" ? "document" : "annotations"), { signal });
     const destination = options.outputTarget;
     if (!destination || destination === "-") for await (const bytes of output.stream(0, output.size, signal)) await writeBytes(context.stdout, bytes, signal);
     else {
       try {
-        await publish(context, resolvePath(context.cwd, destination), output);
+        await publish(context, resolvePath(context.cwd, destination), output.stream(0, output.size, signal));
       } catch (error) {
         signal.throwIfAborted();
         if (!(error instanceof Error) || !("code" in error)) throw error;
@@ -335,13 +1284,13 @@ async function executeRetainedPdftk(context, options) {
     failed = true;
     throw error;
   } finally {
-    const results = await Promise.allSettled([document?.close(), output?.close(), ...[...inputs.values()].map((source) => source?.close())]);
+    const results = await Promise.allSettled([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);
     }
   }
 }
-async function publish(context, path, source) {
+async function publish(context, path, chunks) {
   const fs = context.fs, signal = context.signal;
   const capabilities = await fs.capabilitiesFor?.(path, { signal, create: true, stagingAncestry: true }) ?? fs.capabilities;
   if (!capabilities.atomicFileStaging || !capabilities.retainedStagingWrite || !capabilities.retainedStagingCleanup || !capabilities.atomicStagingAncestry || !fs.prepareStagingResolution || !fs.createStagedFile || !fs.publishStagedFile) throw new FsError("ENOTSUP", { path, message: "PDF output requires retained atomic staging" });
@@ -350,7 +1299,7 @@ async function publish(context, path, source) {
   let failed = false;
   try {
     if (!staging.writer || !staging.cleanup) throw new FsError("ENOTSUP", { path, message: "PDF backend omitted retained staging handles" });
-    for await (const bytes of source.stream(0, source.size, signal)) await writeFileOutput(context, bytes, (data) => staging.writer.write(data, { signal }));
+    for await (const bytes of chunks) await writeFileOutput(context, bytes, (data) => staging.writer.write(data, { signal }));
     const stat = await staging.writer.finish({ signal });
     await fs.publishStagedFile({ ...staging, file: { ...staging.file, stat } }, resolution.path, { parent: resolution.parent, destination: resolution.destination, ancestors: resolution.ancestors, commitGuard: resolution.validate, signal });
   } catch (error) {
@@ -548,17 +1497,17 @@ import { readBytes, writeBytes as writeBytes2 } from "../safe-bash-contracts/io.
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
 import {
   PdfDocument,
-  cosArray,
-  cosDict,
+  cosArray as cosArray4,
+  cosDict as cosDict4,
   cosHexString,
   cosName,
-  cosNumber,
+  cosNumber as cosNumber4,
   cosStream,
-  cosString,
-  decodePdfString as decodePdfString2,
-  dictDelete,
-  dictGet as dictGet2,
-  dictSet,
+  cosString as cosString4,
+  decodePdfString as decodePdfString5,
+  dictDelete as dictDelete2,
+  dictGet as dictGet6,
+  dictSet as dictSet3,
   flattenDocumentFormFields,
   getDocumentFormFields,
   parseFormDataBytes,
@@ -616,6 +1565,9 @@ function resolvePageEndpoint(token, totalPages) {
   return Number.isFinite(num) && num >= 1 ? Math.min(totalPages, num) : 1;
 }
 function parsePdftkRangeToken(token, handles, defaultHandle) {
+  return Array.from(iteratePdftkRangeToken(token, handles, defaultHandle));
+}
+function* iteratePdftkRangeToken(token, handles, defaultHandle) {
   let work = token.trim();
   let handle = defaultHandle;
   const sortedHandleKeys = [...handles.keys()].sort((a, b) => b.length - a.length);
@@ -661,22 +1613,11 @@ function parsePdftkRangeToken(token, handles, defaultHandle) {
       endPage = resolvePageEndpoint(work.slice(dashIdx + 1), totalPages);
     }
   }
-  const pages = [];
-  if (startPage <= endPage) {
-    for (let p = startPage; p <= endPage; p++) pages.push(p);
-  } else {
-    for (let p = startPage; p >= endPage; p--) pages.push(p);
+  const step = startPage <= endPage ? 1 : -1;
+  for (let pageNumber = startPage; step > 0 ? pageNumber <= endPage : pageNumber >= endPage; pageNumber += step) {
+    if (qualifier === "even" && pageNumber % 2 !== 0 || qualifier === "odd" && pageNumber % 2 !== 1) continue;
+    yield { handle, pageNumber, rotation };
   }
-  const filtered = pages.filter((p) => {
-    if (qualifier === "even") return p % 2 === 0;
-    if (qualifier === "odd") return p % 2 === 1;
-    return true;
-  });
-  return filtered.map((pageNumber) => ({
-    handle,
-    pageNumber,
-    rotation
-  }));
 }
 function encodePdftkText(str, utf8) {
   if (utf8) return str;
@@ -691,27 +1632,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");
 }
@@ -732,102 +1652,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(dictGet2(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(dictGet2(annotDict, "Subtype"));
+      const subNode = doc.cos.resolve(dictGet6(annotDict, "Subtype"));
       const subtype = subNode?.kind === "name" ? subNode.decoded : "Annot";
-      const rectArr = doc.cos.resolveArray(dictGet2(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(dictGet2(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(dictGet2(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(decodePdfString2(nmNode), utf8)}`);
+        lines2.push(`AnnotName: ${encodePdftkText(decodePdfString5(nmNode), utf8)}`);
       }
-      const tNode = doc.cos.resolve(dictGet2(annotDict, "T"));
+      const tNode = doc.cos.resolve(dictGet6(annotDict, "T"));
       if (tNode?.kind === "string") {
-        lines.push(`AnnotTitle: ${encodePdftkText(decodePdfString2(tNode), utf8)}`);
+        lines2.push(`AnnotTitle: ${encodePdftkText(decodePdfString5(tNode), utf8)}`);
       }
-      const subjNode = doc.cos.resolve(dictGet2(annotDict, "Subj"));
+      const subjNode = doc.cos.resolve(dictGet6(annotDict, "Subj"));
       if (subjNode?.kind === "string") {
-        lines.push(`AnnotSubj: ${encodePdftkText(decodePdfString2(subjNode), utf8)}`);
+        lines2.push(`AnnotSubj: ${encodePdftkText(decodePdfString5(subjNode), utf8)}`);
       }
-      const cNode = doc.cos.resolve(dictGet2(annotDict, "Contents"));
+      const cNode = doc.cos.resolve(dictGet6(annotDict, "Contents"));
       if (cNode?.kind === "string") {
-        lines.push(`AnnotContents: ${encodePdftkText(decodePdfString2(cNode), utf8)}`);
+        lines2.push(`AnnotContents: ${encodePdftkText(decodePdfString5(cNode), utf8)}`);
       }
-      const colArr = doc.cos.resolveArray(dictGet2(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(dictGet2(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(dictGet2(annotDict, "M"));
+      const mNode = doc.cos.resolve(dictGet6(annotDict, "M"));
       if (mNode?.kind === "string") {
-        lines.push(`AnnotModificationDate: ${encodePdftkText(decodePdfString2(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 decodePdfString2(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];
@@ -860,53 +1780,53 @@ function formatDumpDataAnnots(doc, utf8 = false) {
         }
         const actionDict = doc.cos.resolveDict(aNode);
         if (!actionDict) return;
-        const sNode = doc.cos.resolve(dictGet2(actionDict, "S"));
+        const sNode = doc.cos.resolve(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(dictGet2(actionDict, "URI"));
+        const uriNode = doc.cos.resolve(dictGet6(actionDict, "URI"));
         if (uriNode?.kind === "string") {
-          lines.push(`AnnotActionURI: ${encodePdftkText(decodePdfString2(uriNode), utf8)}`);
+          lines2.push(`AnnotActionURI: ${encodePdftkText(decodePdfString5(uriNode), utf8)}`);
         }
-        const dNode = dictGet2(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(dictGet2(actionDict, "F"));
+        const fRaw = doc.cos.resolve(dictGet6(actionDict, "F"));
         if (fRaw?.kind === "string") {
-          lines.push(`AnnotActionFile: ${encodePdftkText(decodePdfString2(fRaw), utf8)}`);
+          lines2.push(`AnnotActionFile: ${encodePdftkText(decodePdfString5(fRaw), utf8)}`);
         } else if (fRaw?.kind === "dict") {
-          const ufNode = doc.cos.resolve(dictGet2(fRaw, "UF") ?? dictGet2(fRaw, "F"));
+          const ufNode = doc.cos.resolve(dictGet6(fRaw, "UF") ?? dictGet6(fRaw, "F"));
           if (ufNode?.kind === "string") {
-            lines.push(`AnnotActionFile: ${encodePdftkText(decodePdfString2(ufNode), utf8)}`);
+            lines2.push(`AnnotActionFile: ${encodePdftkText(decodePdfString5(ufNode), utf8)}`);
           }
         }
-        emitActionChain(dictGet2(actionDict, "Next"), visited);
+        emitActionChain(dictGet6(actionDict, "Next"), visited);
       };
-      const rawA = dictGet2(annotDict, "A");
+      const rawA = dictGet6(annotDict, "A");
       if (rawA) {
         emitActionChain(rawA);
-      } else if (dictGet2(annotDict, "Dest")) {
-        lines.push("AnnotActionType: GoTo");
-        const dNode = dictGet2(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();
@@ -940,18 +1860,18 @@ function collectOutlineBookmarks(doc, firstNode, level, out, visited = /* @__PUR
     }
     const dict = doc.cos.resolveDict(curr);
     if (!dict) break;
-    const titleNode = doc.cos.resolve(dictGet2(dict, "Title"));
-    const title = titleNode?.kind === "string" ? decodePdfString2(titleNode) : titleNode?.kind === "name" ? titleNode.decoded : "";
-    const resolvedIdx = resolveDestinationPageIndex(doc, dictGet2(dict, "Dest") ?? dictGet2(dict, "A"));
+    const titleNode = doc.cos.resolve(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 = dictGet2(dict, "First");
+    const childFirst = dictGet6(dict, "First");
     if (childFirst) {
       collectOutlineBookmarks(doc, childFirst, level + 1, out, visited);
     }
-    curr = dictGet2(dict, "Next");
+    curr = dictGet6(dict, "Next");
   }
 }
 function collectNameTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ new Set()) {
@@ -962,16 +1882,16 @@ function collectNameTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ new
   }
   const dict = doc.cos.resolveDict(nodeOrRef);
   if (!dict) return;
-  const namesArr = doc.cos.resolveArray(dictGet2(dict, "Names"));
+  const namesArr = doc.cos.resolveArray(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" ? decodePdfString2(k) : "attachment.bin";
+      const name = k?.kind === "string" ? decodePdfString5(k) : "attachment.bin";
       out.push({ name, value: v });
     }
   }
-  const kidsArr = doc.cos.resolveArray(dictGet2(dict, "Kids"));
+  const kidsArr = doc.cos.resolveArray(dictGet6(dict, "Kids"));
   if (kidsArr) {
     for (const kid of kidsArr.items) {
       collectNameTreePairs(doc, kid, out, visited);
@@ -986,7 +1906,7 @@ function collectNumberTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ n
   }
   const dict = doc.cos.resolveDict(nodeOrRef);
   if (!dict) return;
-  const numsArr = doc.cos.resolveArray(dictGet2(dict, "Nums"));
+  const numsArr = doc.cos.resolveArray(dictGet6(dict, "Nums"));
   if (numsArr) {
     for (let i = 0; i + 1 < numsArr.items.length; i += 2) {
       const k = doc.cos.resolve(numsArr.items[i]);
@@ -996,7 +1916,7 @@ function collectNumberTreePairs(doc, nodeOrRef, out, visited = /* @__PURE__ */ n
       }
     }
   }
-  const kidsArr = doc.cos.resolveArray(dictGet2(dict, "Kids"));
+  const kidsArr = doc.cos.resolveArray(dictGet6(dict, "Kids"));
   if (kidsArr) {
     for (const kid of kidsArr.items) {
       collectNumberTreePairs(doc, kid, out, visited);
@@ -1010,19 +1930,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],
@@ -1035,7 +1945,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)}`
@@ -1050,10 +1960,10 @@ function formatDumpData(doc, utf8 = true) {
         if (emittedKeys.has(k)) continue;
         const r = doc.cos.resolve(entry.value);
         if (r?.kind === "string") {
-          const val = decodePdfString2(r);
+          const val = decodePdfString5(r);
           if (val) {
             emittedKeys.add(k);
-            lines.push(
+            lines2.push(
               "InfoBegin",
               `InfoKey: ${encodePdftkText(k, utf8)}`,
               `InfoValue: ${encodePdftkText(val, utf8)}`
@@ -1067,16 +1977,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(dictGet2(catalog, "Outlines")) : void 0;
+  const outlinesDict = catalog ? doc.cos.resolveDict(dictGet6(catalog, "Outlines")) : void 0;
   if (outlinesDict) {
     const bookmarks = [];
-    collectOutlineBookmarks(doc, dictGet2(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}`,
@@ -1088,7 +1998,7 @@ function formatDumpData(doc, utf8 = true) {
     const page = doc.getPage(i);
     const { width, height } = page.getSize();
     const rot = page.getRotation();
-    const mbArr = doc.cos.resolveArray(dictGet2(page.pageDict, "MediaBox"));
+    const mbArr = doc.cos.resolveArray(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) => {
@@ -1097,50 +2007,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(dictGet2(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, dictGet2(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(dictGet2(lblDict, "St"));
+      const stNode = doc.cos.resolve(dictGet6(lblDict, "St"));
       const startNum = stNode?.kind === "number" ? stNode.value : 1;
-      const pNode = doc.cos.resolve(dictGet2(lblDict, "P"));
-      const prefix = pNode?.kind === "string" ? decodePdfString2(pNode) : void 0;
-      const sNode = doc.cos.resolve(dictGet2(lblDict, "S"));
+      const pNode = doc.cos.resolve(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);
@@ -1157,23 +2067,23 @@ function formatGenerateFdf(doc) {
       }
       return `(${escapeFdfString(String(f.value ?? ""))})`;
     }
-    const vNode = doc.cos.resolve(dictGet2(dict, "V"));
+    const vNode = doc.cos.resolve(dictGet6(dict, "V"));
     if (vNode?.kind === "name") return `/${vNode.decoded}`;
-    if (vNode?.kind === "string") return `(${escapeFdfString(decodePdfString2(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(dictGet2(dict, "T"));
-    const partialName = tNode?.kind === "string" ? decodePdfString2(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(dictGet2(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 && dictGet2(kDict, "T")) {
+        if (kDict && dictGet6(kDict, "T")) {
           const serializedKid = serializeCosFieldNode(k, fullName);
           if (serializedKid) namedKids.push(serializedKid);
         }
@@ -1187,8 +2097,8 @@ function formatGenerateFdf(doc) {
   };
   const entries = [];
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
-  const acroForm = catalog ? doc.cos.resolveDict(dictGet2(catalog, "AcroForm")) : void 0;
-  const fieldsArr = acroForm ? doc.cos.resolveArray(dictGet2(acroForm, "Fields")) : void 0;
+  const acroForm = catalog ? doc.cos.resolveDict(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, "");
@@ -1196,7 +2106,7 @@ function formatGenerateFdf(doc) {
     }
   } else {
     for (const f of fields) {
-      entries.push(`<< /T (${escapeFdfString(f.name)}) /V ${formatFieldVal(f.name, cosDict({}))} >>`);
+      entries.push(`<< /T (${escapeFdfString(f.name)}) /V ${formatFieldVal(f.name, cosDict4({}))} >>`);
     }
   }
   return `%FDF-1.2
@@ -1214,9 +2124,9 @@ function setDocumentBookmarks(doc, bookmarks) {
   if (bookmarks.length === 0 || doc.pageCount === 0) return;
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
   if (!catalog) return;
-  const outlinesDict = cosDict({ Type: cosName("Outlines") });
+  const outlinesDict = cosDict4({ Type: cosName("Outlines") });
   const outlinesRef = doc.cos.allocateObject(outlinesDict);
-  dictSet(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);
@@ -1235,26 +2145,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 = cosDict({
-      Title: cosString(bm.title),
+    const itemDict = cosDict4({
+      Title: cosString4(bm.title),
       Parent: parentState.ref,
-      Dest: cosArray([pageRef, cosName("XYZ"), { kind: "null" }, { kind: "null" }, { kind: "null" }])
+      Dest: cosArray4([pageRef, cosName("XYZ"), { kind: "null" }, { kind: "null" }, { kind: "null" }])
     });
     const itemRef = doc.cos.allocateObject(itemDict);
     const prevSibling = parentState.children[parentState.children.length - 1];
     if (prevSibling) {
-      dictSet(prevSibling.dict, "Next", itemRef);
-      dictSet(itemDict, "Prev", prevSibling.ref);
+      dictSet3(prevSibling.dict, "Next", itemRef);
+      dictSet3(itemDict, "Prev", prevSibling.ref);
     } else {
-      dictSet(parentState.dict, "First", itemRef);
+      dictSet3(parentState.dict, "First", itemRef);
     }
-    dictSet(parentState.dict, "Last", itemRef);
+    dictSet3(parentState.dict, "Last", itemRef);
     parentState.children.push({ ref: itemRef, dict: itemDict });
-    dictSet(parentState.dict, "Count", cosNumber(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 = "";
@@ -1306,7 +2216,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();
@@ -1341,7 +2251,7 @@ function applyUpdateInfoText(doc, text) {
         }
         const infoDict = doc.cos.infoRef ? doc.cos.resolveDict(doc.cos.infoRef) : void 0;
         if (infoDict) {
-          dictSet(infoDict, curKey, cosString(val));
+          dictSet3(infoDict, curKey, cosString4(val));
         }
       }
       mode = "none";
@@ -1388,7 +2298,7 @@ function applyUpdateInfoText(doc, text) {
     const existing1 = doc.cos.idArray?.items[1] && doc.cos.resolve(doc.cos.idArray.items[1])?.kind === "string" ? doc.cos.resolve(doc.cos.idArray.items[1]).bytes : existing0;
     const b0 = pdfId0Hex !== void 0 ? hexToBytes(pdfId0Hex) : existing0;
     const b1 = pdfId1Hex !== void 0 ? hexToBytes(pdfId1Hex) : existing1;
-    doc.cos.idArray = cosArray([cosHexString(b0), cosHexString(b1)]);
+    doc.cos.idArray = cosArray4([cosHexString(b0), cosHexString(b1)]);
   }
   for (const [pageNum, rot] of pageRotations.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
@@ -1397,28 +2307,28 @@ function applyUpdateInfoText(doc, text) {
   }
   for (const [pageNum, [w, h]] of pageDimensions.entries()) {
     if (pageNum >= 1 && pageNum <= doc.pageCount) {
-      dictSet(
+      dictSet3(
         doc.getPage(pageNum - 1).pageDict,
         "MediaBox",
-        cosArray([cosNumber(0), cosNumber(0), cosNumber(w), cosNumber(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) {
-      dictSet(
+      dictSet3(
         doc.getPage(pageNum - 1).pageDict,
         "MediaBox",
-        cosArray([cosNumber(x0), cosNumber(y0), cosNumber(x1), cosNumber(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) {
-      dictSet(
+      dictSet3(
         doc.getPage(pageNum - 1).pageDict,
         "CropBox",
-        cosArray([cosNumber(x0), cosNumber(y0), cosNumber(x1), cosNumber(y1)])
+        cosArray4([cosNumber4(x0), cosNumber4(y0), cosNumber4(x1), cosNumber4(y1)])
       );
     }
   }
@@ -1427,21 +2337,21 @@ function applyUpdateInfoText(doc, text) {
     if (catalog) {
       const numsItems = [];
       for (const pl of pageLabels) {
-        numsItems.push(cosNumber(Math.max(0, pl.newIndex - 1)));
+        numsItems.push(cosNumber4(Math.max(0, pl.newIndex - 1)));
         const lblEntries = {
-          St: cosNumber(pl.start)
+          St: cosNumber4(pl.start)
         };
         if (pl.prefix) {
-          lblEntries.P = cosString(pl.prefix);
+          lblEntries.P = cosString4(pl.prefix);
         }
         const pdfStyle = PAGE_LABEL_STYLE_TO_PDF[pl.style];
         if (pdfStyle) {
           lblEntries.S = cosName(pdfStyle);
         }
-        numsItems.push(cosDict(lblEntries));
+        numsItems.push(cosDict4(lblEntries));
       }
-      const plDict = cosDict({ Nums: cosArray(numsItems) });
-      dictSet(catalog, "PageLabels", doc.cos.allocateObject(plDict));
+      const plDict = cosDict4({ Nums: cosArray4(numsItems) });
+      dictSet3(catalog, "PageLabels", doc.cos.allocateObject(plDict));
     }
   }
   setDocumentBookmarks(doc, bookmarks);
@@ -1449,20 +2359,20 @@ function applyUpdateInfoText(doc, text) {
 function attachFilesToDocument(doc, filePaths, files, toPageSpec) {
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
   if (!catalog) return;
-  let namesDict = doc.cos.resolveDict(dictGet2(catalog, "Names"));
+  let namesDict = doc.cos.resolveDict(dictGet6(catalog, "Names"));
   if (!namesDict) {
-    namesDict = cosDict({});
-    dictSet(catalog, "Names", doc.cos.allocateObject(namesDict));
+    namesDict = cosDict4({});
+    dictSet3(catalog, "Names", doc.cos.allocateObject(namesDict));
   }
-  let efTree = doc.cos.resolveDict(dictGet2(namesDict, "EmbeddedFiles"));
+  let efTree = doc.cos.resolveDict(dictGet6(namesDict, "EmbeddedFiles"));
   if (!efTree) {
-    efTree = cosDict({ Names: cosArray([]) });
-    dictSet(namesDict, "EmbeddedFiles", doc.cos.allocateObject(efTree));
+    efTree = cosDict4({ Names: cosArray4([]) });
+    dictSet3(namesDict, "EmbeddedFiles", doc.cos.allocateObject(efTree));
   }
-  let namesArr = doc.cos.resolveArray(dictGet2(efTree, "Names"));
+  let namesArr = doc.cos.resolveArray(dictGet6(efTree, "Names"));
   if (!namesArr) {
-    namesArr = cosArray([]);
-    dictSet(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) {
@@ -1471,34 +2381,34 @@ function attachFilesToDocument(doc, filePaths, files, toPageSpec) {
     const baseName = fp.slice(fp.lastIndexOf("/") + 1);
     const efStreamRef = doc.cos.allocateObject(
       cosStream(bytes, {
-        dict: cosDict({ Type: cosName("EmbeddedFile") }),
+        dict: cosDict4({ Type: cosName("EmbeddedFile") }),
         compress: true
       })
     );
     const filespecRef = doc.cos.allocateObject(
-      cosDict({
+      cosDict4({
         Type: cosName("Filespec"),
-        F: cosString(baseName),
-        UF: cosString(baseName),
-        EF: cosDict({ F: efStreamRef })
+        F: cosString4(baseName),
+        UF: cosString4(baseName),
+        EF: cosDict4({ F: efStreamRef })
       })
     );
-    namesArr.items.push(cosString(baseName), filespecRef);
+    namesArr.items.push(cosString4(baseName), filespecRef);
     if (targetPageIdx !== void 0) {
       const pageDict = doc.getPage(targetPageIdx).pageDict;
-      let annotsArr = doc.cos.resolveArray(dictGet2(pageDict, "Annots"));
+      let annotsArr = doc.cos.resolveArray(dictGet6(pageDict, "Annots"));
       if (!annotsArr) {
-        annotsArr = cosArray([]);
-        dictSet(pageDict, "Annots", annotsArr);
+        annotsArr = cosArray4([]);
+        dictSet3(pageDict, "Annots", annotsArr);
       }
       const annotRef = doc.cos.allocateObject(
-        cosDict({
+        cosDict4({
           Type: cosName("Annot"),
           Subtype: cosName("FileAttachment"),
           Name: cosName("PushPin"),
-          Contents: cosString(baseName),
+          Contents: cosString4(baseName),
           FS: filespecRef,
-          Rect: cosArray([cosNumber(20), cosNumber(20), cosNumber(40), cosNumber(40)])
+          Rect: cosArray4([cosNumber4(20), cosNumber4(20), cosNumber4(40), cosNumber4(40)])
         })
       );
       annotsArr.items.push(annotRef);
@@ -1515,11 +2425,11 @@ function attachmentBasename(name) {
 function unpackFilesFromDocument(doc, outDir, files) {
   const cleanDir = outDir.endsWith("/") ? outDir.slice(0, -1) : outDir;
   const writeSpecDict = (specDict, fallbackName = "attachment.bin") => {
-    const ufNode = doc.cos.resolve(dictGet2(specDict, "UF") ?? dictGet2(specDict, "F"));
-    const fileName = attachmentBasename(ufNode?.kind === "string" ? decodePdfString2(ufNode) : fallbackName);
-    const efDict = doc.cos.resolveDict(dictGet2(specDict, "EF"));
+    const ufNode = doc.cos.resolve(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(
-      dictGet2(efDict, "UF") ?? dictGet2(efDict, "F") ?? dictGet2(efDict, "DOS") ?? dictGet2(efDict, "Mac") ?? dictGet2(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);
@@ -1529,10 +2439,10 @@ function unpackFilesFromDocument(doc, outDir, files) {
   };
   const catalog = doc.cos.resolveDict(doc.cos.rootRef);
   if (catalog) {
-    const namesDict = doc.cos.resolveDict(dictGet2(catalog, "Names"));
+    const namesDict = doc.cos.resolveDict(dictGet6(catalog, "Names"));
     const efPairs = [];
     if (namesDict) {
-      collectNameTreePairs(doc, dictGet2(namesDict, "EmbeddedFiles"), efPairs);
+      collectNameTreePairs(doc, dictGet6(namesDict, "EmbeddedFiles"), efPairs);
     }
     for (const pair of efPairs) {
       const specDict = doc.cos.resolveDict(pair.value);
@@ -1540,7 +2450,7 @@ function unpackFilesFromDocument(doc, outDir, files) {
         writeSpecDict(specDict, pair.name);
       }
     }
-    const rootAfArr = doc.cos.resolveArray(dictGet2(catalog, "AF"));
+    const rootAfArr = doc.cos.resolveArray(dictGet6(catalog, "AF"));
     if (rootAfArr) {
       for (const item of rootAfArr.items) {
         const specDict = doc.cos.resolveDict(item);
@@ -1549,69 +2459,32 @@ function unpackFilesFromDocument(doc, outDir, files) {
     }
   }
   for (let p = 0; p < doc.pageCount; p++) {
-    const pageAfArr = doc.cos.resolveArray(dictGet2(doc.getPage(p).pageDict, "AF"));
+    const pageAfArr = doc.cos.resolveArray(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(dictGet2(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(dictGet2(annotDict, "Subtype"));
+      const subNode = doc.cos.resolve(dictGet6(annotDict, "Subtype"));
       if (subNode?.kind === "name" && subNode.decoded === "FileAttachment") {
-        const specDict = doc.cos.resolveDict(dictGet2(annotDict, "FS"));
+        const specDict = doc.cos.resolveDict(dictGet6(annotDict, "FS"));
         if (specDict) writeSpecDict(specDict);
       }
     }
   }
 }
-function formatBurstFilename(pattern, pageNum) {
-  let out = "";
-  let replaced = false;
-  for (let i = 0; i < pattern.length; i++) {
-    if (pattern[i] !== "%") {
-      out += pattern[i];
-      continue;
-    }
-    if (pattern[i + 1] === "%") {
-      out += "%";
-      i++;
-      continue;
-    }
-    if (!replaced) {
-      let j = i + 1;
-      let zeroPad = false;
-      if (pattern[j] === "0") {
-        zeroPad = true;
-        j++;
-      }
-      let widthStr = "";
-      while (j < pattern.length && pattern[j] >= "0" && pattern[j] <= "9") {
-        widthStr += pattern[j];
-        j++;
-      }
-      if (pattern[j] === "d") {
-        const width = widthStr ? Number.parseInt(widthStr, 10) : 1;
-        out += zeroPad ? String(pageNum).padStart(width, "0") : String(pageNum);
-        replaced = true;
-        i = j;
-        continue;
-      }
-    }
-    out += "%";
-  }
-  return out;
-}
 function cloneCosSubgraphInto(srcDoc, dstDoc, node, memo = /* @__PURE__ */ new Map()) {
   if (!node) return void 0;
   if (node.kind === "ref") {
     const cached = memo.get(node.objectNumber);
     if (cached) return cached;
-    const placeholder = dstDoc.cos.allocateObject(cosDict({}));
+    const placeholder = dstDoc.cos.allocateObject(cosDict4({}));
     memo.set(node.objectNumber, placeholder);
     const resolved = srcDoc.cos.resolve(node);
     const cloned = cloneCosSubgraphInto(srcDoc, dstDoc, resolved, memo);
@@ -1625,14 +2498,14 @@ function cloneCosSubgraphInto(srcDoc, dstDoc, node, memo = /* @__PURE__ */ new M
     return placeholder;
   }
   if (node.kind === "array") {
-    return cosArray(node.items.map((it) => cloneCosSubgraphInto(srcDoc, dstDoc, it, memo)).filter(Boolean));
+    return cosArray4(node.items.map((it) => cloneCosSubgraphInto(srcDoc, dstDoc, it, memo)).filter(Boolean));
   }
   if (node.kind === "dict") {
-    const next = cosDict({});
+    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) dictSet(next, entry.key.decoded, clonedVal);
+      if (clonedVal) dictSet3(next, entry.key.decoded, clonedVal);
     }
     return next;
   }
@@ -1697,31 +2570,31 @@ function applyOverlayToDocument(targetDoc, overlayDoc, mode, multi) {
     const srcRes = srcPage.getResourcesDict();
     const renamedResources = /* @__PURE__ */ new Map();
     for (const subKey of ["Font", "XObject", "ExtGState", "ColorSpace", "Pattern", "Shading", "Properties"]) {
-      const srcSub = overlayDoc.cos.resolveDict(dictGet2(srcRes, subKey));
+      const srcSub = overlayDoc.cos.resolveDict(dictGet6(srcRes, subKey));
       if (!srcSub) continue;
-      let dstSub = targetDoc.cos.resolveDict(dictGet2(dstRes, subKey));
+      let dstSub = targetDoc.cos.resolveDict(dictGet6(dstRes, subKey));
       if (!dstSub) {
-        dstSub = cosDict({});
-        dictSet(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 (!dictGet2(dstSub, origKey)) {
-          dictSet(dstSub, origKey, cloned);
+        if (!dictGet6(dstSub, origKey)) {
+          dictSet3(dstSub, origKey, cloned);
         } else {
           let newKey = `Ov_${i}_${origKey}`;
           let suffix = 1;
-          while (dictGet2(dstSub, newKey)) {
+          while (dictGet6(dstSub, newKey)) {
             newKey = `Ov_${i}_${suffix++}_${origKey}`;
           }
-          dictSet(dstSub, newKey, cloned);
+          dictSet3(dstSub, newKey, cloned);
           renamedResources.set(origKey, newKey);
         }
       }
     }
-    const srcContents = dictGet2(srcPage.pageDict, "Contents");
+    const srcContents = dictGet6(srcPage.pageDict, "Contents");
     if (!srcContents) continue;
     const rawSrcNodes = [];
     const resolvedSrcContents = overlayDoc.cos.resolve(srcContents);
@@ -1747,7 +2620,7 @@ function applyOverlayToDocument(targetDoc, overlayDoc, mode, multi) {
       }
     }
     if (srcList.length === 0) continue;
-    const dstContents = dictGet2(dstPage.pageDict, "Contents");
+    const dstContents = dictGet6(dstPage.pageDict, "Contents");
     const toStreamList = (c) => {
       if (!c) return [];
       const r = targetDoc.cos.resolve(c);
@@ -1796,7 +2669,7 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
     const qOpenSrc = targetDoc.cos.allocateObject(cosStream(new TextEncoder().encode(srcOpenCmd), { compress: false }));
     const qClose = targetDoc.cos.allocateObject(cosStream(new TextEncoder().encode("\nQ\n"), { compress: false }));
     const combined = mode === "background" ? [qOpenSrc, ...srcList, qClose, qOpenDst, ...dstList, qClose] : [qOpenDst, ...dstList, qClose, qOpenSrc, ...srcList, qClose];
-    dictSet(dstPage.pageDict, "Contents", cosArray(combined));
+    dictSet3(dstPage.pageDict, "Contents", cosArray4(combined));
   }
 }
 function normalizeQuarterTurn(degrees) {
@@ -1870,8 +2743,8 @@ function* runPdftkCliSteps(argv, files, signal) {
           if (obj.value.kind !== "stream")
             continue;
           const raw = singleDoc.cos.decodeStream(obj.value);
-          dictDelete(obj.value.dict, "Filter");
-          dictDelete(obj.value.dict, "DecodeParms");
+          dictDelete2(obj.value.dict, "Filter");
+          dictDelete2(obj.value.dict, "DecodeParms");
           singleDoc.cos.objects.set(obj.objectNumber, {
             ...obj,
             value: cosStream(raw, {
@@ -1980,9 +2853,9 @@ function* runPdftkCliSteps(argv, files, signal) {
       if (!cached) {
         cached = [];
         const cat = d.cos.resolveDict(d.cos.rootRef);
-        const outDict = cat ? d.cos.resolveDict(dictGet2(cat, "Outlines")) : void 0;
+        const outDict = cat ? d.cos.resolveDict(dictGet6(cat, "Outlines")) : void 0;
         if (outDict) {
-          collectOutlineBookmarks(d, dictGet2(outDict, "First"), 1, cached);
+          collectOutlineBookmarks(d, dictGet6(outDict, "First"), 1, cached);
         }
         bookmarksByDoc.set(d, cached);
       }
@@ -2072,14 +2945,14 @@ function* runPdftkCliSteps(argv, files, signal) {
   }
   if (dropXfa) {
     const root = resultDoc.cos.resolveDict(resultDoc.cos.rootRef);
-    const acroForm = root ? resultDoc.cos.resolveDict(dictGet2(root, "AcroForm")) : void 0;
+    const acroForm = root ? resultDoc.cos.resolveDict(dictGet6(root, "AcroForm")) : void 0;
     if (acroForm)
-      dictDelete(acroForm, "XFA");
+      dictDelete2(acroForm, "XFA");
   }
   if (dropXmp) {
     const root = resultDoc.cos.resolveDict(resultDoc.cos.rootRef);
     if (root)
-      dictDelete(root, "Metadata");
+      dictDelete2(root, "Metadata");
   }
   if (replacementFont && operation === "fill_form") {
     const cleanFontName = replacementFont.startsWith("/") ? replacementFont.slice(1) : replacementFont;
@@ -2087,28 +2960,28 @@ function* runPdftkCliSteps(argv, files, signal) {
       if (++cooperativeWork % 64 === 0)
         yield;
       if (obj.value.kind === "dict") {
-        const stNode = dictGet2(obj.value, "Subtype");
-        const bfNode = dictGet2(obj.value, "BaseFont");
+        const stNode = 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") {
-          dictSet(obj.value, "BaseFont", cosName(cleanFontName));
+          dictSet3(obj.value, "BaseFont", cosName(cleanFontName));
         }
       }
     }
   }
   if (operation === "fill_form" && !shouldFlatten) {
     const root = resultDoc.cos.resolveDict(resultDoc.cos.rootRef);
-    const acroForm = root ? resultDoc.cos.resolveDict(dictGet2(root, "AcroForm")) : void 0;
+    const acroForm = root ? resultDoc.cos.resolveDict(dictGet6(root, "AcroForm")) : void 0;
     if (acroForm) {
-      dictSet(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(dictGet2(root, "AcroForm"));
+      const acroForm = resultDoc.cos.resolveDict(dictGet6(root, "AcroForm"));
       if (acroForm) {
-        dictSet(acroForm, "NeedAppearances", { kind: "boolean", value: true });
+        dictSet3(acroForm, "NeedAppearances", { kind: "boolean", value: true });
       }
     }
   }
@@ -2116,12 +2989,12 @@ function* runPdftkCliSteps(argv, files, signal) {
   if (keepFinalId) {
     const lastInput = handleDocs[handleDocs.length - 1];
     if (lastInput?.cos.idArray) {
-      resultDoc.cos.idArray = cosArray([...lastInput.cos.idArray.items]);
+      resultDoc.cos.idArray = cosArray4([...lastInput.cos.idArray.items]);
     }
   } else if (keepFirstId || !resultDoc.cos.idArray) {
     const firstInput = handleDocs[0];
     if (firstInput?.cos.idArray) {
-      resultDoc.cos.idArray = cosArray([...firstInput.cos.idArray.items]);
+      resultDoc.cos.idArray = cosArray4([...firstInput.cos.idArray.items]);
     }
   }
   if (uncompressStreams || compressStreams) {
@@ -2131,8 +3004,8 @@ function* runPdftkCliSteps(argv, files, signal) {
       if (obj.value.kind !== "stream")
         continue;
       const raw = resultDoc.cos.decodeStream(obj.value);
-      dictDelete(obj.value.dict, "Filter");
-      dictDelete(obj.value.dict, "DecodeParms");
+      dictDelete2(obj.value.dict, "Filter");
+      dictDelete2(obj.value.dict, "DecodeParms");
       resultDoc.cos.objects.set(obj.objectNumber, {
         ...obj,
         value: cosStream(raw, {
@@ -2180,7 +3053,7 @@ function runPdftkCliSync(argv, files, signal) {
   }
   return next.value;
 }
-async function executePdftk(context) {
+async function executePdftk(context, retainedContext = context) {
   let cooperativeWork = 63;
   const invocation = createOutputOperation(context, { write: async () => {
   } });
@@ -2188,8 +3061,8 @@ async function executePdftk(context) {
     const carrier = getCommandArguments(context);
     const argv = [...carrier.args];
     const parsed = await drainSteps(parsePdftkArgumentsSteps(argv), invocation.signal);
-    if (parsed.options && ["dump_data_annots", "dump_data_annots_utf8", "dump_data_fields", "dump_data_fields_utf8"].includes(parsed.options.operation)) {
-      return await executeRetainedPdftk({ ...context, signal: invocation.signal, stdout: invocation.child(context.stdout).output }, parsed.options);
+    if (parsed.options && (["output", "rotate", "attach_files", "stamp", "multistamp", "background", "multibackground", "burst", "update_info", "update_info_utf8", "cat", "shuffle"].includes(parsed.options.operation) && !parsed.options.shouldFlatten || ["dump_data", "dump_data_utf8", "dump_data_annots", "dump_data_annots_utf8", "dump_data_fields", "dump_data_fields_utf8", "generate_fdf", "unpack_files"].includes(parsed.options.operation))) {
+      return await executeRetainedPdftk({ ...retainedContext, signal: invocation.signal, stdout: invocation.child(context.stdout).output }, parsed.options);
     }
     const vfsFiles = /* @__PURE__ */ new Map();
     let accountedBytes = 0;
@@ -2290,7 +3163,7 @@ function createPdftkCommand(options = {}) {
     runtimeIdentity: commandRuntimeIdentity,
     description: "Manipulate PDF documents, fill/flatten AcroForms, and assemble pages via @poe-code/pdf-ast",
     execute(context) {
-      return new InputByteBudget(maxInputBytes).run(context, executePdftk);
+      return new InputByteBudget(maxInputBytes).run(context, (limited) => executePdftk(limited, { ...context, inputBudget: limited.inputBudget }));
     }
   });
 }
@@ -2312,6 +3185,7 @@ function createPdftkCommands(options = {}) {
 export {
   createPdftkCommand,
   createPdftkCommands,
+  iteratePdftkRangeToken,
   parsePdftkRangeToken,
   pdftkCommand,
   pdftkCommands,