@poe-platform/safe-bash 0.1.813 → 0.1.815

package/dist/pdf-ast/index.js

@@ -28310,7 +28310,7 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
         continue;
       }
       if (tok.kind === "dict-start") {
-        const backed = options.dictionaryStorage && (parent?.kind === "dict" && options.storedDictionaryKeys?.includes(parent.key.decoded) || !parent && options.storeRootDictionary);
+        const backed = options.dictionaryStorage && (parent?.kind === "dict" && !parent.storedEntries && options.storedDictionaryKeys?.includes(parent.key.decoded) || !parent && options.storeRootDictionary);
         yield* push({
           kind: "dict",
           path: ancestorPath(parent),
@@ -43006,6 +43006,13 @@ function* resolveEvaluationDict(node, arrayPathPrefix) {
   const resolved = yield* resolveEvaluationNode(node, false, arrayPathPrefix);
   return resolved?.kind === "dict" ? resolved : resolved?.kind === "stream" ? resolved.dict : void 0;
 }
+function* lookupEvaluationDictionary(dict, key) {
+  if (!dict) return void 0;
+  if (!dict.storedEntries) return dictGet(dict, key);
+  const result = yield { kind: "dictionary-value", dict, key };
+  if (!result || !("kind" in result) || result.kind !== "resolved") throw new TypeError("Expected a PDF dictionary value");
+  return result.node;
+}
 function* resolveEvaluationArray(node, storeRootArray = false, arrayPathPrefix) {
   const resolved = yield* resolveEvaluationNode(node, storeRootArray, arrayPathPrefix);
   return resolved?.kind === "array" ? resolved : void 0;
@@ -43853,8 +43860,8 @@ function* evaluateContentSteps(params) {
     let resolvedMcid = node.mcid;
     let resolvedActualText = node.actualText ?? node.storedActualText;
     if (typeof node.properties === "string" && activeResources) {
-      const propsMap = yield* resolveEvaluationDict(dictGet(activeResources, "Properties"));
-      const propRefOrNode = propsMap ? dictGet(propsMap, node.properties) : void 0;
+      const propsMap = yield* resolveEvaluationDict(dictGet(activeResources, "Properties"), ["Properties"]);
+      const propRefOrNode = yield* lookupEvaluationDictionary(propsMap, node.properties);
       if (propRefOrNode) {
         const propDict = yield* resolveEvaluationDict(propRefOrNode);
         const propType = propDict ? yield* resolveEvaluationNode(dictGet(propDict, "Type")) : void 0;
@@ -44037,8 +44044,8 @@ function* evaluateContentSteps(params) {
           case "xobject": {
             const st = curState();
             if (activeResources) {
-              const xobjDict = yield* resolveEvaluationDict(dictGet(activeResources, "XObject"));
-              const xobjNode = xobjDict ? yield* resolveEvaluationNode(dictGet(xobjDict, node.name)) : void 0;
+              const xobjDict = yield* resolveEvaluationDict(dictGet(activeResources, "XObject"), ["XObject"]);
+              const xobjNode = xobjDict ? yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(xobjDict, node.name)) : void 0;
               if (xobjNode?.kind === "stream") {
                 if (!(yield* optionalContentVisibilitySteps(dictGet(xobjNode.dict, "OC")))) {
                   break;
@@ -44439,7 +44446,7 @@ function* evaluateContentStreamSteps(params) {
           else exhausted = true;
         }
         step = work.next(next.done ? void 0 : next.value);
-      } else if (step.value.kind === "dash-array" || step.value.kind === "array-reference" || step.value.kind === "array-item" || step.value.kind === "string-bytes" || step.value.kind === "font-width" || step.value.kind === "font-unicode" || step.value.kind === "cmap-lookup" || step.value.kind === "cmap-character" || step.value.kind === "truetype-number" || step.value.kind === "truetype-path" || step.value.kind === "cid-gid" || step.value.kind === "frame-push" || step.value.kind === "frame-pop" || step.value.kind === "capture-append" || step.value.kind === "transform-path" || step.value.kind === "append-clip" || step.value.kind === "path-append" || step.value.kind === "path-finish") {
+      } else if (step.value.kind === "dictionary-value" || step.value.kind === "dash-array" || step.value.kind === "array-reference" || step.value.kind === "array-item" || step.value.kind === "string-bytes" || step.value.kind === "font-width" || step.value.kind === "font-unicode" || step.value.kind === "cmap-lookup" || step.value.kind === "cmap-character" || step.value.kind === "truetype-number" || step.value.kind === "truetype-path" || step.value.kind === "cid-gid" || step.value.kind === "frame-push" || step.value.kind === "frame-pop" || step.value.kind === "capture-append" || step.value.kind === "transform-path" || step.value.kind === "append-clip" || step.value.kind === "path-append" || step.value.kind === "path-finish") {
         throw new PdfError("E_CAPABILITY", "Stored PDF paths require an asynchronous source driver");
       } else if (step.value.kind === "shading") {
         if (!params.cosDoc) throw new PdfError("E_CAPABILITY", "PDF shading requires a source driver");
@@ -44631,7 +44638,8 @@ function* preparePageAppearanceSteps(pageDict, pageRes, evalResourcesDict, hideA
     const sub = yield* resolveDict3(entry.value, [entry.key.decoded]);
     if (sub) {
       onAllocation?.(64 + sub.entries.length * 64);
-      const clonedSub = sub.storedEntries ? yield { kind: "dictionary-merge", destination: sub } : cosDict({});
+      const shareBacking = entry.key.decoded === "XObject" || entry.key.decoded === "Properties";
+      const clonedSub = sub.storedEntries ? shareBacking ? { ...sub, entries: [] } : yield { kind: "dictionary-merge", destination: sub } : cosDict({});
       if (!sub.storedEntries) for (const se of sub.entries) dictSet(clonedSub, se.key.decoded, se.value);
       dictSet(evalResourcesDict, entry.key.decoded, clonedSub);
     } else {
@@ -49283,54 +49291,6 @@ async function openPdfCrossReference(source, storage, options = {}) {
   }
 }
 
-// packages/pdf-ast/src/cos/filter-dictionary.ts
-async function resolvePdfStreamDictionary(dict, lookup, active, options) {
-  let remaining = options.maxNodes ?? 65536;
-  const resolve2 = async (node, depth) => {
-    if (--remaining < 0 || depth >= (options.maxRecursionDepth ?? 100)) throw new PdfError("E_LIMIT", "PDF filter resolution limit exceeded");
-    if (node.kind === "ref") {
-      if (active.has(node.objectNumber)) throw new PdfError("E_PARSE", "PDF filter reference cycle");
-      const object = await lookup(node);
-      if (!object) throw new PdfError("E_PARSE", "Missing PDF filter reference");
-      active.add(node.objectNumber);
-      try {
-        return await resolve2(object.value, depth + 1);
-      } finally {
-        active.delete(node.objectNumber);
-      }
-    }
-    if (node.kind === "array") {
-      const items = [];
-      const { storedItems, ...ordinary } = node;
-      if (storedItems) {
-        const reader = readStoredItems(storedItems, options.signal);
-        try {
-          for (; ; ) {
-            const item = await reader.next().catch((error) => {
-              options.onBackingError?.(error);
-              throw error;
-            });
-            if (item.done) break;
-            items.push(await resolve2(item.value, depth + 1));
-          }
-        } finally {
-          await reader.return();
-        }
-      } else for (const item of node.items) items.push(await resolve2(item, depth + 1));
-      return { ...ordinary, items };
-    }
-    if (node.kind === "dict") {
-      const entries2 = [];
-      for (const entry of node.entries) entries2.push({ ...entry, value: await resolve2(entry.value, depth + 1) });
-      return { ...node, entries: entries2 };
-    }
-    return node;
-  };
-  const entries = [];
-  for (const entry of dict.entries) entries.push(["Filter", "F", "DecodeParms", "DP", "Type"].includes(entry.key.decoded) ? { ...entry, value: await resolve2(entry.value, 0) } : entry);
-  return { ...dict, entries };
-}
-
 // packages/pdf-ast/src/cos/reference-set.ts
 var PdfReferenceSet = class {
   constructor(storage, maximum10 = Infinity, signal) {
@@ -49345,12 +49305,16 @@ var PdfReferenceSet = class {
   tail = /* @__PURE__ */ new Set();
   levels = [];
   closed = false;
-  async add(number) {
+  async has(number) {
     if (this.closed) throw new PdfError("E_CAPABILITY", "PDF reference set is closed");
     this.signal?.throwIfAborted();
     if (!Number.isSafeInteger(number) || number < 0) throw new RangeError("Invalid PDF reference number");
-    if (this.tail.has(number)) return false;
-    for (const level2 of this.levels) if (await level2?.get(number, this.signal)) return false;
+    if (this.tail.has(number)) return true;
+    for (const level of this.levels) if (await level?.get(number, this.signal)) return true;
+    return false;
+  }
+  async add(number) {
+    if (await this.has(number)) return false;
     this.tail.add(number);
     if (this.tail.size < 64) return true;
     let level = 0;
@@ -49398,6 +49362,82 @@ var PdfReferenceSet = class {
   }
 };
 
+// packages/pdf-ast/src/cos/filter-dictionary.ts
+async function resolvePdfStreamDictionary(dict, lookup, active, options) {
+  let remaining = options.maxNodes ?? 65536;
+  const resolve2 = async (node, depth, parent = options.referencePath) => {
+    let path = parent, owned, failed = false;
+    try {
+      for (; ; ) {
+        options.signal?.throwIfAborted();
+        if (--remaining < 0 || depth >= (options.maxRecursionDepth ?? 100)) throw new PdfError("E_LIMIT", "PDF filter resolution limit exceeded");
+        if (node.kind !== "ref") break;
+        if (active.has(node.objectNumber)) throw new PdfError("E_PARSE", "PDF filter reference cycle");
+        for (let ancestor = path; ancestor; ancestor = ancestor.parent) {
+          const seen = await ancestor.seen.has(node.objectNumber).catch((error) => {
+            options.onBackingError?.(error);
+            throw error;
+          });
+          if (seen) throw new PdfError("E_PARSE", "PDF filter reference cycle");
+        }
+        owned ??= { seen: new PdfReferenceSet(options.referenceStorage, options.maxTraversalStagingBytes, options.signal), parent, depth: 0 };
+        path = owned;
+        const object = await lookup(node, path);
+        if (!object) throw new PdfError("E_PARSE", "Missing PDF filter reference");
+        await path.seen.add(node.objectNumber).catch((error) => {
+          options.onBackingError?.(error);
+          throw error;
+        });
+        path.depth++;
+        depth++;
+        node = object.value;
+        if (path.depth % 256 === 0) await new Promise((resolve3) => setTimeout(resolve3, 0));
+      }
+      if (node.kind === "array") {
+        const items = [];
+        const { storedItems, ...ordinary } = node;
+        if (storedItems) {
+          const reader = readStoredItems(storedItems, options.signal);
+          try {
+            for (; ; ) {
+              const item = await reader.next().catch((error) => {
+                options.onBackingError?.(error);
+                throw error;
+              });
+              if (item.done) break;
+              items.push(await resolve2(item.value, depth + 1, path));
+            }
+          } finally {
+            await reader.return();
+          }
+        } else for (const item of node.items) items.push(await resolve2(item, depth + 1, path));
+        return { ...ordinary, items };
+      }
+      if (node.kind === "dict") {
+        const entries2 = [];
+        for (const entry of node.entries) entries2.push({ ...entry, value: await resolve2(entry.value, depth + 1, path) });
+        return { ...node, entries: entries2 };
+      }
+      return node;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      try {
+        await owned?.seen.close();
+      } catch (error) {
+        if (!failed) {
+          options.onBackingError?.(error);
+          await Promise.reject(error);
+        }
+      }
+    }
+  };
+  const entries = [];
+  for (const entry of dict.entries) entries.push(["Filter", "F", "DecodeParms", "DP", "Type"].includes(entry.key.decoded) ? { ...entry, value: await resolve2(entry.value, 0) } : entry);
+  return { ...dict, entries };
+}
+
 // packages/pdf-ast/src/cos/recovered-reference.ts
 async function* recoveredBodies(source, index2, storage, options) {
   const visited = new PdfReferenceSet(storage, options.index?.maxStagingBytes, options.signal);
@@ -49527,6 +49567,7 @@ var PdfObjectReader = class {
     this.capacity = integer2(options.objectStreamCacheEntries ?? 2, "objectStreamCacheEntries", 1);
     this.stagingLimit = maximum2(options.maxStagingBytes, "maxStagingBytes");
     maximum2(options.maxObjectStreamMembers, "maxObjectStreamMembers");
+    maximum2(options.maxTraversalStagingBytes, "maxTraversalStagingBytes");
     this.options = {
       maxNodes: 65536,
       maxTokenBytes: 1048576,
@@ -49543,6 +49584,7 @@ var PdfObjectReader = class {
   // Recursive length/object-stream lookups share one failure identity so an
   // outer recovery pass cannot mistake a caller-storage error for PDF syntax.
   backingFailures = /* @__PURE__ */ new WeakMap();
+  referencePaths = /* @__PURE__ */ new WeakMap();
   repairedOffsets = /* @__PURE__ */ new Map();
   options;
   capacity;
@@ -49572,10 +49614,7 @@ var PdfObjectReader = class {
       const object2 = await this.load(objectNumber, generationNumber, /* @__PURE__ */ new Set());
       if (object2?.value.kind !== "dict" || !object2.stream) throw new PdfError("E_PARSE", "Expected an indexed PDF stream");
       const active = /* @__PURE__ */ new Set([objectNumber]);
-      return { object: object2, dict: await resolvePdfStreamDictionary(object2.value, (ref) => this.load(ref.objectNumber, ref.generationNumber, active), active, { ...this.options, onBackingError: (error) => {
-        this.backingFailures.set(active, { error });
-        this.options.onBackingError?.(error);
-      } }) };
+      return { object: object2, dict: await this.resolveStreamDictionary(object2.value, active) };
     });
     const span = object.stream;
     const input = () => this.source.stream(span.start, span.end - span.start, this.options.signal);
@@ -49583,10 +49622,96 @@ var PdfObjectReader = class {
     const decodeOptions = { ...this.options, stopBeforeImageCodec: options.stopBeforeImageCodec ?? false, raw: options.raw ?? false };
     yield* security ? decodePdfEncryptedStreamChunks(security, objectNumber, generationNumber, dict, input, decodeOptions) : decodePdfStreamChunks(dict, input, decodeOptions);
   }
-  async load(objectNumber, generationNumber, active, arrays = this.options.valueArrays ?? {}) {
+  resolveStreamDictionary(dict, active) {
+    return resolvePdfStreamDictionary(dict, async (ref, path) => {
+      const parent = this.referencePaths.get(active);
+      this.referencePaths.set(active, path);
+      try {
+        return await this.load(ref.objectNumber, ref.generationNumber, active);
+      } finally {
+        if (parent) this.referencePaths.set(active, parent);
+        else this.referencePaths.delete(active);
+      }
+    }, active, {
+      ...this.options,
+      referenceStorage: this.storage,
+      referencePath: this.referencePaths.get(active),
+      onBackingError: (error) => {
+        this.backingFailures.set(active, { error });
+        this.options.onBackingError?.(error);
+      }
+    });
+  }
+  /** A stream-valued /Length is invalid as a length, but its references still
+   * need cycle, admission and backing-error validation. Walk those discarded
+   * values in source order instead of retaining one parser and AST per link. */
+  async resolveLength(reference, active) {
+    const path = {
+      seen: new PdfReferenceSet(this.storage, this.options.maxTraversalStagingBytes, this.options.signal),
+      parent: this.referencePaths.get(active),
+      depth: 0
+    };
+    this.referencePaths.set(active, path);
+    let next = reference, result, failed = false;
+    try {
+      while (next) {
+        const current = next;
+        next = void 0;
+        const object = await this.load(
+          current.objectNumber,
+          current.generationNumber,
+          active,
+          this.options.valueArrays ?? {},
+          async (child) => {
+            next = child;
+            return void 0;
+          }
+        );
+        if (path.depth === 0 && object?.value.kind === "number") result = object.value.value;
+        try {
+          await path.seen.add(current.objectNumber);
+        } catch (error) {
+          this.backingFailures.set(active, { error });
+          this.options.onBackingError?.(error);
+          throw error;
+        }
+        path.depth++;
+      }
+      return result;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      if (path.parent) this.referencePaths.set(active, path.parent);
+      else this.referencePaths.delete(active);
+      try {
+        await path.seen.close();
+      } catch (error) {
+        if (!failed) {
+          this.backingFailures.set(active, { error });
+          this.options.onBackingError?.(error);
+          await Promise.reject(error);
+        }
+      }
+    }
+  }
+  async load(objectNumber, generationNumber, active, arrays = this.options.valueArrays ?? {}, resolveLength) {
     this.options.signal?.throwIfAborted();
     if (active.has(objectNumber)) throw new PdfError("E_PARSE", "PDF indirect object cycle");
-    if (active.size >= this.options.maxRecursionDepth) throw new PdfError("E_LIMIT", "PDF object resolution depth limit exceeded");
+    let depth = active.size;
+    for (let path = this.referencePaths.get(active); path; path = path.parent) {
+      let seen;
+      try {
+        seen = await path.seen.has(objectNumber);
+      } catch (error) {
+        this.backingFailures.set(active, { error });
+        this.options.onBackingError?.(error);
+        throw error;
+      }
+      if (seen) throw new PdfError("E_PARSE", "PDF indirect object cycle");
+      depth += path.depth;
+    }
+    if (depth >= this.options.maxRecursionDepth) throw new PdfError("E_LIMIT", "PDF object resolution depth limit exceeded");
     const entry = await this.index.get(objectNumber, this.options.signal);
     if (!entry || entry.type === "free" || generationNumber !== (entry.generationNumber ?? 0)) return void 0;
     active.add(objectNumber);
@@ -49611,18 +49736,18 @@ var PdfObjectReader = class {
         return { objectNumber, generationNumber, value: parsed.value, span: { start, end: parsed.offset } };
       }
       let object;
+      let pendingLength;
       try {
         object = await parseCosRangeObject(this.source, this.repairedOffsets.get(objectNumber) ?? entry.offset, {
           ...this.options,
           ...arrays,
           onBackingError,
-          resolveLength: async (reference) => {
-            const resolved = await this.load(reference.objectNumber, reference.generationNumber, active);
-            return resolved?.value.kind === "number" ? resolved.value.value : void 0;
-          }
+          resolveLength: (reference) => pendingLength = resolveLength ? resolveLength(reference) : this.resolveLength(reference, active)
         });
         if (object.objectNumber !== objectNumber || object.generationNumber !== generationNumber) throw new PdfError("E_PARSE", "Indirect object identity does not match xref");
       } catch (error) {
+        await pendingLength?.catch(() => {
+        });
         this.options.signal?.throwIfAborted();
         const backingFailure = this.backingFailures.get(active);
         if (backingFailure && Object.is(backingFailure.error, error)) throw error;
@@ -49694,10 +49819,7 @@ var PdfObjectReader = class {
     active.add(number);
     let dict;
     try {
-      dict = await resolvePdfStreamDictionary(object.value, (ref) => this.load(ref.objectNumber, ref.generationNumber, active), active, { ...this.options, onBackingError: (error) => {
-        this.backingFailures.set(active, { error });
-        this.options.onBackingError?.(error);
-      } });
+      dict = await this.resolveStreamDictionary(object.value, active);
     } finally {
       active.delete(number);
     }
@@ -54950,7 +55072,7 @@ async function resolveRetainedFont(document2, storage, resources, name, options
       }
       let value;
       if (step.value.kind === "resolve") {
-        const retained = await document2.lookup(step.value.node, options.resourceStorage ? { dictionaryStorage: options.resourceStorage, storedDictionaryKeys: ["Font"], storeRootDictionary: step.value.storeRootDictionary ?? false, arrayStorage: options.resourceStorage, storedArrayKeys: ["Widths", "W", "Differences"], storeRootArray: step.value.storeRootArray ?? false } : {});
+        const retained = await document2.lookup(step.value.node, options.resourceStorage ? { dictionaryStorage: options.resourceStorage, storedDictionaryKeys: ["Font", "XObject", "Properties"], storeRootDictionary: step.value.storeRootDictionary ?? false, arrayStorage: options.resourceStorage, storedArrayKeys: ["Widths", "W", "Differences"], storeRootArray: step.value.storeRootArray ?? false } : {});
         value = retained?.value;
         if (retained?.stream) {
           if (retained.value.kind !== "dict" || !retained.reference) throw new PdfError("E_PARSE", "Font stream has no retained identity");
@@ -55290,6 +55412,9 @@ async function* evaluateRetainedContentSteps(document2, content, params, storage
           reply = { kind: "dash-array", value: await storeDashArray(request.array, request.storage, request.resolveReferences ? resolve2 : async (node) => node, signal) };
           break;
         }
+        case "dictionary-value":
+          reply = { kind: "resolved", node: await readPdfDictionaryValue(request.dict, request.key, signal) };
+          break;
         case "array-reference":
           reply = { kind: "resolved", node: cosBool(await memberships.has(request.items, request.objectNumber)) };
           break;
@@ -56106,7 +56231,7 @@ function* generateDocumentFormAppearancesSteps(doc) {
 function generateDocumentFormAppearances(doc) {
   return drainWork(generateDocumentFormAppearancesSteps(doc));
 }
-function decodeXmlEntities(text) {
+function decodeFormDataEntities(text) {
   let out = "";
   let i = 0;
   while (i < text.length) {
@@ -56170,7 +56295,7 @@ function extractAttributeValue(tagBody, attrName) {
   if (quote !== '"' && quote !== "'") return void 0;
   const end = tagBody.indexOf(quote, after + 1);
   if (end === -1) return void 0;
-  return decodeXmlEntities(tagBody.slice(after + 1, end));
+  return decodeFormDataEntities(tagBody.slice(after + 1, end));
 }
 function parseXfdfString(text, out) {
   const fieldStack = [];
@@ -56202,7 +56327,7 @@ function parseXfdfString(text, out) {
     } else if (tagName === "value" && !selfClosing && fieldStack.length > 0) {
       const closeVal = text.indexOf("</value>", pos);
       if (closeVal !== -1) {
-        const rawVal = decodeXmlEntities(text.slice(pos, closeVal));
+        const rawVal = decodeFormDataEntities(text.slice(pos, closeVal));
         const fullFieldName = fieldStack.filter(Boolean).join(".");
         if (fullFieldName) {
           if (rawVal === "Off") out.set(fullFieldName, false);
@@ -56410,9 +56535,9 @@ function parseFormDataBytes(bytes) {
       if (line.startsWith("FieldType:")) {
         curType = line.slice("FieldType:".length).trim();
       } else if (line.startsWith("FieldName:")) {
-        curName = decodeXmlEntities(line.slice("FieldName:".length).trim());
+        curName = decodeFormDataEntities(line.slice("FieldName:".length).trim());
       } else if (line.startsWith("FieldValue:") && curName) {
-        const val = decodeXmlEntities(line.slice("FieldValue:".length).trim());
+        const val = decodeFormDataEntities(line.slice("FieldValue:".length).trim());
         if (val === "Yes" || val === "On") {
           out.set(curName, true);
         } else if (val === "Off" || val === "false" || curType === "Button" && val === "") {
@@ -58358,7 +58483,7 @@ var PdfMergeOutlines = class {
         if (node.kind === "ref" && !await seen.add(node.objectNumber)) continue;
         const dict = (await document2.lookup(node))?.value;
         if (dict?.kind !== "dict") continue;
-        yield dict;
+        yield { dict, level: depth + 1 };
         if (outlines) {
           await push(dictGet(dict, "Next"), depth);
           await push(dictGet(dict, "First"), depth + 1);
@@ -58380,7 +58505,7 @@ var PdfMergeOutlines = class {
       }
     }
   }
-  async append(document2, pageOffset, includeUntitled = false) {
+  async append(document2, pageOffset, includeUntitled = false, includeNameTitles = false) {
     const resolve2 = async (node) => (await document2.lookup(node))?.value;
     const catalog = await resolve2(document2.crossReference.rootRef);
     if (catalog?.kind !== "dict") return;
@@ -58391,7 +58516,7 @@ var PdfMergeOutlines = class {
       const legacy = await resolve2(dictGet(catalog, "Dests")), direct = legacy?.kind === "dict" ? dictGet(legacy, name) : void 0;
       if (direct) return direct;
       const names = await resolve2(dictGet(catalog, "Names"));
-      if (names?.kind === "dict") for await (const tree of this.walk(document2, dictGet(names, "Dests"), false)) {
+      if (names?.kind === "dict") for await (const { dict: tree } of this.walk(document2, dictGet(names, "Dests"), false)) {
         const pairs = await resolve2(dictGet(tree, "Names"));
         if (pairs?.kind === "array") for (let i = 0; i + 1 < pairs.items.length; i += 2) {
           await this.checkpoint();
@@ -58424,10 +58549,10 @@ var PdfMergeOutlines = class {
       return number?.kind === "number" && number.value >= 0 && number.value < pageCount ? Math.round(number.value) : 0;
     };
     try {
-      for await (const outline of this.walk(document2, dictGet(outlines, "First"), true)) {
-        const title = await resolve2(dictGet(outline, "Title")), text = title?.kind === "string" ? decodePdfString(title) : "";
+      for await (const { dict: outline, level } of this.walk(document2, dictGet(outlines, "First"), true)) {
+        const title = await resolve2(dictGet(outline, "Title")), text = title?.kind === "string" ? decodePdfString(title) : includeNameTitles && title?.kind === "name" ? title.decoded : "";
         const index2 = await destination(dictGet(outline, "Dest") ?? dictGet(outline, "A"));
-        if (text || includeUntitled) await this.objects.set({ objectNumber: ++this.count, generationNumber: 0, value: cosDict({ Title: cosString(text), Page: cosNumber(pageOffset + index2) }) });
+        if (text || includeUntitled) await this.objects.set({ objectNumber: ++this.count, generationNumber: 0, value: cosDict({ Title: cosString(text), Page: cosNumber(pageOffset + index2), Level: cosNumber(level) }) });
       }
     } catch (error) {
       failed = true;
@@ -58439,11 +58564,14 @@ var PdfMergeOutlines = class {
     }
   }
   async *entries() {
+    for await (const { title, pageIndex } of this.details()) yield { title, pageIndex };
+  }
+  async *details() {
     for await (const object of this.objects.objects()) {
       await this.checkpoint();
-      const row = object.value, title = dictGet(row, "Title"), index2 = dictGet(row, "Page");
+      const row = object.value, title = dictGet(row, "Title"), index2 = dictGet(row, "Page"), level = dictGet(row, "Level");
       if (title?.kind !== "string" || index2?.kind !== "number") throw new PdfError("E_PARSE", "Invalid staged outline summary");
-      yield { title: decodePdfString(title), pageIndex: index2.value };
+      yield { title: decodePdfString(title), pageIndex: index2.value, level: level?.kind === "number" ? level.value : 1 };
     }
   }
   async finish(target, catalog, pageCount, page2) {
@@ -58569,7 +58697,7 @@ async function openStoredPdfObjectReader(store, storage, options) {
       validateIdentity(number, generation);
       const object = number === 0 ? void 0 : await store.get(number);
       if (object?.generationNumber !== generation || !object.stream || object.value.kind !== "dict") throw new PdfError("E_PARSE", "Expected an indexed PDF stream");
-      const dict = await resolvePdfStreamDictionary(object.value, (ref) => reader.get(ref.objectNumber, ref.generationNumber), /* @__PURE__ */ new Set([number]), options);
+      const dict = await resolvePdfStreamDictionary(object.value, (ref) => reader.get(ref.objectNumber, ref.generationNumber), /* @__PURE__ */ new Set([number]), { ...options, referenceStorage: storage });
       const snapshot = object.stream;
       async function* input() {
         for await (const bytes of snapshot.chunks) {
@@ -59539,7 +59667,7 @@ async function markedText(document2, page2, mcid, storage, options) {
     var boundary = boundary2, scan = scan2;
     source = await PdfFileSource.fromStream(storage.fs, storage.directory, input(), { chunkBytes, cacheBytes: chunkBytes, maxInputBytes: maximum10, ...signal ? { signal } : {} });
     const resources = (await document2.lookup(dictGet(page2, "Resources")))?.value;
-    const properties = resources?.kind === "dict" ? (await document2.lookup(dictGet(resources, "Properties")))?.value : void 0;
+    const properties = resources?.kind === "dict" ? (await document2.lookup(dictGet(resources, "Properties"), void 0, ["Properties"]))?.value : void 0;
     const operators2 = parseContentRangeOperators(source, storage, { chunkBytes, maxStagingBytes: maximum10 - source.size, ...signal ? { signal } : {} });
     let pending, matching = false, inText = false, part = 0, recorded = false;
     async function* fragments(command) {
@@ -59568,7 +59696,7 @@ async function markedText(document2, page2, mcid, storage, options) {
               await marks.push({ kind: "boolean", value: matching });
               if (operator !== "q") {
                 const property = operands[1];
-                const dict = property?.kind === "name" && properties?.kind === "dict" ? (await document2.lookup(dictGet(properties, property.decoded)))?.value : property;
+                const dict = property?.kind === "name" && properties?.kind === "dict" ? (await document2.lookup(await readPdfDictionaryValue(properties, property.decoded, signal)))?.value : property;
                 const number = dict?.kind === "dict" ? (await document2.lookup(dictGet(dict, "MCID")))?.value : void 0;
                 if (number?.kind === "number") matching = number.value === mcid;
               }
@@ -59967,8 +60095,8 @@ async function* walkRetainedImages(document2, storage, options) {
   const decodeOptions = { chunkBytes, ...options.maxDecodedBytes === void 0 ? {} : { maxDecodedBytes: options.maxDecodedBytes }, ...options.signal ? { signal: options.signal } : {} };
   let imageIndex = 0;
   let stagedBytes = 0;
-  async function dictionary(node) {
-    const value = await document2.lookup(node);
+  async function dictionary(node, resourceKey) {
+    const value = await document2.lookup(node, void 0, resourceKey ? [resourceKey] : void 0);
     return value?.value.kind === "dict" && !value.stream ? value.value : void 0;
   }
   async function number(node, fallback) {
@@ -60067,8 +60195,8 @@ async function* walkRetainedImages(document2, storage, options) {
           } else if (op.operator === "Do") {
             const name = op.operands[0];
             if (name?.kind !== "name") continue;
-            const objects = await dictionary(dictGet(activeResources, "XObject"));
-            const target = await document2.lookup(objects ? dictGet(objects, name.decoded) : void 0);
+            const objects = await dictionary(dictGet(activeResources, "XObject"), "XObject");
+            const target = await document2.lookup(objects ? await readPdfDictionaryValue(objects, name.decoded, options.signal) : void 0);
             if (target?.value.kind !== "dict" || !target.stream || !target.reference) continue;
             const subtype = (await document2.lookup(dictGet(target.value, "Subtype")))?.value;
             if (subtype?.kind !== "name") continue;
@@ -60129,8 +60257,8 @@ async function* walkRetainedImages(document2, storage, options) {
       yield* content(page2.streamContents(), resources, identity, /* @__PURE__ */ new Set(), 0);
       const patterns = await dictionary(dictGet(resources, "Pattern"));
       if (patterns) for (const entry of patterns.entries) yield* auxiliary(entry.value, resources);
-      const fonts = await dictionary(dictGet(resources, "Font"));
-      if (fonts) for (const entry of fonts.entries) {
+      const fonts = await dictionary(dictGet(resources, "Font"), "Font");
+      if (fonts) for await (const entry of readPdfDictionaryEntries(fonts, options.signal)) {
         const font = await dictionary(entry.value);
         if (!font) continue;
         const subtype = (await document2.lookup(dictGet(font, "Subtype")))?.value;
@@ -60145,8 +60273,8 @@ async function* walkRetainedImages(document2, storage, options) {
         const appearance = annotation ? await dictionary(dictGet(annotation, "AP")) : void 0;
         if (appearance) yield* auxiliary(dictGet(appearance, "N"), resources);
       }
-      const objects = await dictionary(dictGet(resources, "XObject"));
-      if (objects) for (const entry of objects.entries) {
+      const objects = await dictionary(dictGet(resources, "XObject"), "XObject");
+      if (objects) for await (const entry of readPdfDictionaryEntries(objects, options.signal)) {
         const ref = entry.value;
         if (ref.kind === "ref" && !(await seen.intern(`${ref.objectNumber}:${ref.generationNumber}`)).added) continue;
         const target = await document2.lookup(ref);
@@ -60183,8 +60311,8 @@ async function* walkRetainedFonts(document2, storage, options) {
   const last = options.lastPage ?? Infinity;
   if (!Number.isSafeInteger(first) || first < 1 || last !== Infinity && (!Number.isSafeInteger(last) || last < first)) throw new RangeError("Invalid PDF font page range");
   let failed = false;
-  async function dictionary(node) {
-    const resolved = await document2.lookup(node);
+  async function dictionary(node, resourceKey) {
+    const resolved = await document2.lookup(node, void 0, resourceKey ? [resourceKey] : void 0);
     return resolved?.value.kind === "dict" && !resolved.stream ? resolved.value : void 0;
   }
   async function* font(node, key, depth) {
@@ -60220,8 +60348,8 @@ async function* walkRetainedFonts(document2, storage, options) {
     options.signal?.throwIfAborted();
     if (!value) return;
     if (depth > options.maxDepth) throw new PdfError("E_LIMIT", "PDF font resource depth limit exceeded");
-    const fonts = await dictionary(dictGet(value, "Font"));
-    if (fonts) for (const entry of fonts.entries) yield* font(entry.value, entry.key.decoded, depth);
+    const fonts = await dictionary(dictGet(value, "Font"), "Font");
+    if (fonts) for await (const entry of readPdfDictionaryEntries(fonts, options.signal)) yield* font(entry.value, entry.key.decoded, depth);
     const states = await dictionary(dictGet(value, "ExtGState"));
     if (states) for (const entry of states.entries) {
       const state = await dictionary(entry.value);
@@ -60229,9 +60357,9 @@ async function* walkRetainedFonts(document2, storage, options) {
       if (gsFont?.kind === "array" && gsFont.items[0]) yield* font(gsFont.items[0], `ExtGS_${entry.key.decoded}`, depth);
     }
     for (const key of ["XObject", "Pattern"]) {
-      const objects = await dictionary(dictGet(value, key));
+      const objects = await dictionary(dictGet(value, key), key);
       if (!objects) continue;
-      for (const entry of objects.entries) {
+      for await (const entry of readPdfDictionaryEntries(objects, options.signal)) {
         if (entry.value.kind === "ref" && !(await names.intern(`form:${entry.value.objectNumber}`)).added) continue;
         const resolved = await document2.lookup(entry.value);
         if (!resolved?.stream || resolved.value.kind !== "dict") continue;
@@ -60815,6 +60943,29 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
     const work = visit(this);
     return work;
   }
+  outlineDetails() {
+    async function* visit(doc) {
+      doc.assertOpen();
+      doc.walks.add(work);
+      const storage = new PdfStagingStorage(doc.storage, doc.options.maxTraversalStagingBytes);
+      const outlines = new PdfMergeOutlines(storage, doc.options.signal, Infinity);
+      let failed = false;
+      try {
+        await outlines.append(doc, 0, false, true);
+        yield* outlines.details();
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        doc.walks.delete(work);
+        await outlines.close().catch((error) => {
+          if (!failed) throw error;
+        });
+      }
+    }
+    const work = visit(this);
+    return work;
+  }
   pageLabels() {
     async function* visit(doc) {
       doc.assertOpen();
@@ -62280,6 +62431,9 @@ async function* saveRetainedDocumentChunks(document2, storage, options = {}) {
   }
 }
 
+// packages/pdf-ast/src/edit/retained-info-updates.ts
+import { PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
+
 // packages/pdf-ast/src/edit/retained-bookmarks.ts
 import { PagedStorage as PagedStorage13 } from "@poe-platform/safe-fs/storage";
 async function setRetainedBookmarks(store, storage, root, pageCount, pageReference, bookmarks, signal, maxDepth = Infinity) {
@@ -62357,6 +62511,126 @@ async function setRetainedBookmarks(store, storage, root, pageCount, pageReferen
   }
 }
 
+// packages/pdf-ast/src/edit/retained-info-updates.ts
+async function applyRetainedInfoUpdates(document2, store, storage, count, getPage, updates, signal, maxDepth) {
+  const pages = new PagedStorage14({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const base = pages.allocate(count * 4 * 48), heads = [-1, -1, -1, -1], tails = [-1, -1, -1, -1];
+  const labels = new PdfMutableObjectStore(storage, { signal }), bookmarks = new PdfMutableObjectStore(storage, { signal });
+  let infoRef = document2.crossReference.infoRef, idArray = document2.crossReference.idArray, labelCount = 0, work = 0, failed = false;
+  const rootRef = document2.crossReference.rootRef;
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+    signal.throwIfAborted();
+  }
+  const position = (group, index2) => base + (group * count + index2) * 48;
+  try {
+    for await (const update of updates) {
+      await checkpoint();
+      if (update.kind === "info") {
+        const standard = ["Title", "Author", "Subject", "Keywords", "Creator", "Producer"].includes(update.key);
+        let info3 = infoRef ? await store.get(infoRef.objectNumber) : void 0;
+        if (infoRef && info3?.value.kind !== "dict") {
+          const resolved = await document2.lookup(infoRef);
+          if (resolved?.value.kind === "dict" && resolved.reference) info3 = await store.get(resolved.reference.objectNumber);
+        }
+        if (!infoRef || standard && info3?.value.kind !== "dict") {
+          infoRef = await store.allocate(cosDict(!standard ? { Title: cosString("") } : {}));
+          info3 = await store.get(infoRef.objectNumber);
+        }
+        if (info3?.value.kind === "dict") {
+          dictSet(info3.value, update.key, cosString(update.value));
+          await store.set(info3);
+        }
+      } else if (update.kind === "id") {
+        if (idArray === document2.crossReference.idArray) {
+          const first = await document2.lookup(idArray?.items[0]), second = await document2.lookup(idArray?.items[1]);
+          const a = first?.value.kind === "string" ? first.value.bytes : new Uint8Array(16), b = second?.value.kind === "string" ? second.value.bytes : a;
+          idArray = cosArray([cosHexString(a), cosHexString(b)]);
+        }
+        idArray.items[update.index] = cosHexString(new Uint8Array(update.bytes));
+      } else if (update.kind === "page") {
+        const index2 = update.pageNumber - 1;
+        if (!Number.isSafeInteger(index2) || index2 < 0 || index2 >= count) continue;
+        const group = ["rotation", "dimensions", "media", "crop"].indexOf(update.property), size = group === 0 ? 1 : group === 1 ? 2 : 4;
+        if (update.values.length !== size || !update.values.every(Number.isFinite)) throw new RangeError("Invalid page property values");
+        const offset = position(group, index2), bytes = await pages.read(offset, 48), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+        if (!view.getFloat64(0)) {
+          view.setFloat64(0, 1);
+          view.setFloat64(8, -1);
+          if (tails[group] >= 0) {
+            const link2 = new Uint8Array(8);
+            new DataView(link2.buffer).setFloat64(0, index2);
+            await pages.write(position(group, tails[group]) + 8, link2);
+          } else heads[group] = index2;
+          tails[group] = index2;
+        }
+        for (let i = 0; i < size; i++) view.setFloat64(16 + i * 8, update.values[i]);
+        await pages.write(offset, bytes);
+      } else if (update.kind === "label") {
+        const value = cosDict({ St: cosNumber(update.start) });
+        if (update.prefix) dictSet(value, "P", cosString(update.prefix));
+        if (update.style) dictSet(value, "S", cosName(update.style));
+        await labels.allocate(cosArray([cosNumber(update.index), value]));
+        labelCount++;
+      } else await bookmarks.allocate(cosArray([cosString(update.title), cosNumber(update.level), cosNumber(update.pageNumber)]));
+    }
+    for (let group = 0; group < 4; group++) for (let index2 = heads[group]; index2 >= 0; ) {
+      await checkpoint();
+      const bytes = await pages.read(position(group, index2), 48), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length), page2 = await getPage(index2);
+      if (group === 0) dictSet(page2.dict, "Rotate", cosNumber((Math.round(view.getFloat64(16) / 90) * 90 % 360 + 360) % 360));
+      else {
+        const values = group === 1 ? [0, 0, view.getFloat64(16), view.getFloat64(24)] : [16, 24, 32, 40].map((offset) => view.getFloat64(offset));
+        dictSet(page2.dict, group === 3 ? "CropBox" : "MediaBox", cosArray(values.map((value) => cosNumber(value))));
+      }
+      await store.set({ objectNumber: page2.reference.objectNumber, generationNumber: page2.reference.generationNumber, value: page2.dict });
+      index2 = view.getFloat64(8);
+    }
+    if (labelCount) {
+      const root = await store.get(rootRef.objectNumber);
+      if (root?.value.kind === "dict") {
+        const ref = await store.allocate(cosDict({}));
+        dictSet(root.value, "PageLabels", ref);
+        await store.set(root);
+        async function* chunks() {
+          const encoder = new TextEncoder();
+          yield encoder.encode("<<\n/Nums [ ");
+          for await (const object of labels.objects()) {
+            await checkpoint();
+            if (object.value.kind !== "array") throw new Error("Invalid label record");
+            for (const node of object.value.items) {
+              yield* serializeCosNodeChunks(node, { signal });
+              yield encoder.encode(" ");
+            }
+          }
+          yield encoder.encode("]\n>>");
+        }
+        let length = 0;
+        for await (const bytes of chunks()) length += bytes.length;
+        await store.setSerializedValue({ objectNumber: ref.objectNumber, generationNumber: 0, body: { length, chunks: chunks() } });
+      }
+    }
+    async function* outlineUpdates() {
+      for await (const object of bookmarks.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 bookmark record");
+        yield { title: decodePdfString(value.items[0]), level: value.items[1].value, pageNumber: value.items[2].value };
+      }
+    }
+    await setRetainedBookmarks(store, storage, rootRef, count, async (index2) => (await getPage(index2)).reference, outlineUpdates(), signal, maxDepth);
+    return { infoRef, idArray };
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([pages.close(), labels.close(), bookmarks.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
 // packages/pdf-ast/src/edit/retained-append-attachments.ts
 async function appendRetainedAttachments(document2, target, storage, attachments, options = {}) {
   const signal = options.signal ?? new AbortController().signal, appended = new PdfMutableObjectStore(storage, { signal });
@@ -62481,7 +62755,7 @@ async function appendRetainedAttachments(document2, target, storage, attachments
 }
 
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
-import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage15 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/form-appearance-chunks.ts
 function* serializeFormAppearanceChunks(text, options) {
@@ -62567,10 +62841,11 @@ function* operators(text, options) {
 }
 
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
-async function generateRetainedFormAppearances(document2, store, storage, signal) {
+async function generateRetainedFormAppearances(document2, store, storage, signal, update) {
   if (!document2.crossReference.rootRef) return;
-  const backing = new PagedStorage14({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable8(backing);
+  const backing = new PagedStorage15({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable8(backing);
   let head = -1, failed = false, work = 0;
+  let matched = false;
   let defaultAppearance;
   async function checkpoint(depth = 0) {
     signal.throwIfAborted();
@@ -62615,6 +62890,7 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
     const source = await PdfFileSource.fromStream(storage.fs, storage.directory, chunks, { signal });
     let failed2 = false;
     try {
+      if (update && dict.kind === "dict") dictSet(dict, "Length", cosNumber(source.size));
       const ref = await store.allocate();
       await store.set({ objectNumber: ref.objectNumber, generationNumber: 0, value: dict, stream: { length: source.size, chunks: source.stream(0, source.size, signal), decoded: true } });
       return ref;
@@ -62672,14 +62948,30 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
     return "Yes";
   }
   try {
-    const form = await locate(formLocation);
+    let form = await locate(formLocation);
+    if (update && form?.value.kind !== "dict") {
+      const catalog = await locate(root);
+      if (catalog?.value.kind !== "dict") return;
+      dictSet(catalog.value, "AcroForm", await store.allocate(cosDict({ Fields: cosArray([]), NeedAppearances: cosBool(true) })));
+      await store.set(catalog.owner);
+      form = await locate(formLocation);
+    }
     if (form?.value.kind !== "dict") return;
+    if (update) {
+      dictSet(form.value, "NeedAppearances", cosBool(true));
+      await store.set(form.owner);
+      const fields3 = await locate(child(form.location, "Fields"));
+      if (fields3?.value.kind !== "array") {
+        dictSet(form.value, "Fields", cosArray([]));
+        await store.set(form.owner);
+      }
+    }
     defaultAppearance = dictGet(form.value, "DA");
     const need = await resolve2(dictGet(form.value, "NeedAppearances")), force = need?.kind === "boolean" && need.value;
     const fields2 = await locate(child(form.location, "Fields"));
     if (fields2?.value.kind === "array") for (let i = fields2.value.items.length - 1; i >= 0; i--) {
       await checkpoint();
-      await push({ location: itemLocation(fields2.location, i, fields2.value.items[i]), named: false, ft: "", ff: 0, q: 0, depth: 0 });
+      await push({ location: itemLocation(fields2.location, i, fields2.value.items[i]), named: "", ft: "", ff: 0, q: 0, depth: 0 });
     }
     while (head !== -1) {
       const record = await readStoredRecord(backing, head, signal);
@@ -62699,7 +62991,8 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
         await push({ exit: id });
       }
       const name = await resolve2(dictGet(field2.value, "T")), ft = await resolve2(dictGet(field2.value, "FT"));
-      const named = frame.named || (name?.kind === "name" ? !!name.decoded : name?.kind === "string" ? !!decodePdfString(name) : false);
+      const partial = name?.kind === "name" ? name.decoded : name?.kind === "string" ? decodePdfString(name) : "";
+      const named = update ? frame.named && partial ? `${frame.named}.${partial}` : partial || frame.named : frame.named || partial ? "1" : "";
       const inherited = { ...frame, named, ft: ft?.kind === "name" ? ft.decoded : frame.ft, ff: await number(dictGet(field2.value, "Ff"), frame.ff), q: await number(dictGet(field2.value, "Q"), frame.q) };
       const maxLen = await resolve2(dictGet(field2.value, "MaxLen"));
       if (maxLen?.kind === "number") inherited.maxLen = maxLen.value;
@@ -62723,6 +63016,70 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
         }
       }
       if (!named) continue;
+      if (update) {
+        if (named !== update.name) continue;
+        matched = true;
+        const value2 = update.value;
+        if (typeof value2 === "boolean" || inherited.ft === "Btn") {
+          const on = await onValue(field2.location);
+          const checked = typeof value2 === "boolean" ? value2 : value2 !== "Off" && value2 !== "false" && value2 !== "0" && value2 !== "";
+          const chosen = typeof value2 === "string" && value2 !== "true" && value2 !== "false" && value2 !== "Off" ? value2 : on;
+          const state = cosName(checked ? chosen : "Off");
+          dictSet(field2.value, "FT", cosName("Btn"));
+          dictSet(field2.value, "V", state);
+          dictSet(field2.value, "AS", state);
+          await store.set(field2.owner);
+          if (kids?.value.kind === "array") for (let i = 0; i < kids.value.items.length; i++) {
+            await checkpoint();
+            const kid = await locate(itemLocation(kids.location, i, kids.value.items[i]));
+            if (kid?.value.kind !== "dict") continue;
+            const normal = await locate(child(child(kid.location, "AP"), "N"));
+            const selected2 = normal?.value.kind === "dict" && normal.value.entries.length ? cosName(checked && dictGet(normal.value, chosen) !== void 0 ? chosen : "Off") : state;
+            dictSet(kid.value, "AS", selected2);
+            await store.set(kid.owner);
+          }
+          continue;
+        }
+        if (!inherited.ft) dictSet(field2.value, "FT", cosName("Tx"));
+        let text2 = String(value2);
+        const multi = inherited.ft === "Ch" && !!(inherited.ff & 1 << 21) && text2.includes(",");
+        const selected = multi ? text2.split(",").map((value3) => value3.trim()).filter(Boolean) : [text2];
+        dictSet(field2.value, "V", multi ? cosArray(selected.map((value3) => cosString(value3))) : cosString(text2));
+        if (inherited.ft === "Ch") {
+          const choices = await resolve2(dictGet(field2.value, "Opt")), indices = [];
+          if (choices?.kind === "array") for (let i = 0; i < choices.items.length; i++) {
+            await checkpoint();
+            const option = await resolve2(choices.items[i]);
+            let exported = "", label = "", valid = false;
+            if (option?.kind === "string") {
+              exported = decodePdfString(option);
+              label = exported;
+              valid = true;
+            } else if (option?.kind === "array" && option.items.length >= 2) {
+              const first = await resolve2(option.items[0]), second = await resolve2(option.items[1]);
+              exported = first?.kind === "string" ? decodePdfString(first) : "";
+              label = second?.kind === "string" ? decodePdfString(second) : "";
+              valid = true;
+            }
+            if (valid && (selected.includes(exported) || selected.includes(label))) {
+              indices.push(i);
+              if (!multi) {
+                if (label) text2 = label;
+                break;
+              }
+            }
+          }
+          if (indices.length) dictSet(field2.value, "I", cosArray(indices.map((value3) => cosNumber(value3))));
+        }
+        await store.set(field2.owner);
+        await synthesize(field2.location, text2, inherited);
+        if (kids?.value.kind === "array") for (let i = 0; i < kids.value.items.length; i++) {
+          await checkpoint();
+          const kid = await locate(itemLocation(kids.location, i, kids.value.items[i]));
+          if (kid?.value.kind === "dict" && !dictGet(kid.value, "T")) await synthesize(kid.location, text2, inherited);
+        }
+        continue;
+      }
       const value = await resolve2(dictGet(field2.value, "V"));
       if (!value) continue;
       const appearance = await resolve2(dictGet(field2.value, "AP")), hasNormal = appearance?.kind === "dict" && dictGet(appearance, "N") !== void 0;
@@ -62760,9 +63117,18 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
         if (kid?.value.kind === "dict" && !dictGet(kid.value, "T")) await synthesize(kid.location, text, inherited);
       }
     }
+    if (update && !matched) {
+      const fields3 = await locate(child(formLocation, "Fields"));
+      if (fields3?.value.kind === "array") {
+        const value = update.value;
+        const field2 = typeof value === "boolean" ? cosDict({ FT: cosName("Btn"), T: cosString(update.name), V: cosName(value ? "Yes" : "Off"), AS: cosName(value ? "Yes" : "Off") }) : cosDict({ FT: cosName("Tx"), T: cosString(update.name), V: cosString(value) });
+        fields3.value.items.push(await store.allocate(field2));
+        await store.set(fields3.owner);
+      }
+    }
     const latest = await locate(formLocation);
     if (latest?.value.kind === "dict") {
-      dictSet(latest.value, "NeedAppearances", cosBool(false));
+      dictSet(latest.value, "NeedAppearances", cosBool(!!update));
       await store.set(latest.owner);
     }
   } catch (error) {
@@ -62776,16 +63142,16 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
 }
 
 // packages/pdf-ast/src/edit/retained-flatten-annotations.ts
-import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage19 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/retained-content-edit.ts
-import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage15 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage16 } from "@poe-platform/safe-fs/storage";
 var RetainedContentEditor = class _RetainedContentEditor {
   constructor(store, storage, signal) {
     this.store = store;
     this.storage = storage;
     this.signal = signal;
-    this.backing = new PagedStorage15({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+    this.backing = new PagedStorage16({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
     this.counts = new IntegerTable9(this.backing);
     this.identities = new PdfNameIndex(storage, Infinity, signal);
   }
@@ -62857,14 +63223,14 @@ var RetainedContentEditor = class _RetainedContentEditor {
 };
 
 // packages/pdf-ast/src/edit/retained-name-replacement.ts
-import { PagedStorage as PagedStorage16 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage17 } from "@poe-platform/safe-fs/storage";
 async function* replaceRetainedPdfName(input, oldName, newName, storage, options = {}) {
   const chunkBytes = options.chunkBytes ?? 16384, maximum10 = options.maxOutputBytes ?? Infinity;
   if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid name replacement chunk size");
   if (maximum10 !== Infinity && (!Number.isSafeInteger(maximum10) || maximum10 < 0)) throw new RangeError("Invalid name replacement output limit");
   const signal = options.signal ?? new AbortController().signal;
   signal.throwIfAborted();
-  const table = new PagedStorage16({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), length = oldName.length + 1;
+  const table = new PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), length = oldName.length + 1;
   const base = table.allocate(length * 8), record = new Uint8Array(8), view = new DataView(record.buffer);
   const pattern = (at) => at ? oldName.charCodeAt(at - 1) : 47;
   let buffer = new Uint8Array(chunkBytes), used = 0, total = 0, work = 0, failed = false;
@@ -62942,10 +63308,10 @@ async function* replaceRetainedPdfName(input, oldName, newName, storage, options
 }
 
 // packages/pdf-ast/src/edit/retained-draw-text.ts
-import { PagedStorage as PagedStorage17 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
 async function drawRetainedAnnotationText(page2, editor, storage, text, x, y, isolated, font, signal) {
   const source = await PdfFileSource.fromStream(storage.fs, storage.directory, page2.streamContents(), { signal });
-  const backing = new PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const backing = new PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   let failed = false;
   try {
     const name = await font(), position = backing.allocate(text.length);
@@ -63021,7 +63387,7 @@ async function flattenRetainedAnnotations(document2, store, storage, mode, signa
     for await (const page2 of document2.pages()) {
       const annotations = await array(dictGet(page2.dict, "Annots"));
       if (!annotations) continue;
-      const survivorStorage = new PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+      const survivorStorage = new PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
       const survivorBase = survivorStorage.allocate(0);
       let pageFailed = false;
       try {
@@ -63107,7 +63473,7 @@ async function flattenRetainedAnnotations(document2, store, storage, mode, signa
           }
           if (normal?.stream && normal.reference && normal.value.kind === "dict") {
             let content = await PdfFileSource.fromStream(storage.fs, storage.directory, document2.objects.decodeStream(normal.reference.objectNumber, normal.reference.generationNumber), { signal });
-            const backing = new PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), renames = new IntegerTable10(backing), names = new PdfNameIndex(storage, Infinity, signal);
+            const backing = new PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), renames = new IntegerTable10(backing), names = new PdfNameIndex(storage, Infinity, signal);
             let appearanceFailed = false, count = 0;
             try {
               if (content.size) {
@@ -63226,11 +63592,11 @@ q ${scaleX} 0 0 ${scaleY} ${tx} ${ty} cm${matSuffix}
 }
 
 // packages/pdf-ast/src/edit/retained-name-map.ts
-import { PagedStorage as PagedStorage19 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
 async function* replaceRetainedPdfNames(input, names, storage, options = {}) {
   const signal = options.signal ?? new AbortController().signal, size = options.chunkBytes ?? 16384;
   if (!Number.isSafeInteger(size) || size < 1) throw new RangeError("Invalid name replacement chunk size");
-  const trie = new PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pending = new PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const trie = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pending = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const root = trie.allocate(40), prefixBase = pending.allocate(0);
   let output = new Uint8Array(size), used = 0, failed = false, work = 0;
   const body = (byte3) => byte3 >= 48 && byte3 <= 57 || byte3 >= 65 && byte3 <= 90 || byte3 >= 97 && byte3 <= 122 || [95, 46, 43, 45].includes(byte3);
@@ -63512,7 +63878,7 @@ async function preserveRetainedStamp(document2, source, page2, other, store, edi
 }
 
 // packages/pdf-ast/src/edit/retained-stamps.ts
-import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage21 } from "@poe-platform/safe-fs/storage";
 async function stampRetainedPages(document2, store, storage, getPage, stamps, signal) {
   const editor = await RetainedContentEditor.open(store, storage, signal);
   let counter = 1, failed = false, work = 0;
@@ -63523,7 +63889,7 @@ async function stampRetainedPages(document2, store, storage, getPage, stamps, si
   try {
     for await (const stamp of stamps) {
       const source = await editRetainedDocument(stamp.source, storage, { signal });
-      const backing = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable11(backing);
+      const backing = new PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable11(backing);
       let stampFailed = false;
       async function clone(node, depth = 0) {
         await checkpoint();
@@ -63709,12 +64075,12 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
 }
 
 // packages/pdf-ast/src/edit/retained-inline-images.ts
-import { PagedStorage as PagedStorage21 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage22 } from "@poe-platform/safe-fs/storage";
 async function externalizeRetainedInlineImages(document2, store, storage, options, signal) {
   const minimum = options.minBytes ?? 1024;
   if (!Number.isSafeInteger(minimum) || minimum < 0) throw new RangeError("Invalid inline-image minimum size");
   const editor = await RetainedContentEditor.open(store, storage, signal);
-  const paths = new PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const paths = new PagedStorage22({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const keys = { BPC: "BitsPerComponent", CS: "ColorSpace", D: "Decode", DP: "DecodeParms", F: "Filter", H: "Height", IM: "ImageMask", I: "Interpolate", W: "Width" };
   const colors = { G: "DeviceGray", RGB: "DeviceRGB", CMYK: "DeviceCMYK", I: "Indexed" };
   const filters = { AHx: "ASCIIHexDecode", A85: "ASCII85Decode", LZW: "LZWDecode", Fl: "FlateDecode", RL: "RunLengthDecode", CCF: "CCITTFaxDecode", DCT: "DCTDecode" };
@@ -63806,7 +64172,7 @@ async function externalizeRetainedInlineImages(document2, store, storage, option
 }
 
 // packages/pdf-ast/src/edit/retained-resource-pruning.ts
-import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage22 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage23 } from "@poe-platform/safe-fs/storage";
 async function collectNames(input, names, found, signal) {
   const iterator = input[Symbol.asyncIterator](), pending = [];
   let chunk = new Uint8Array(), at = 0, ended = false, changed = false, work = 0, failed = false;
@@ -63888,7 +64254,7 @@ async function pruneRetainedResources(document2, store, storage, signal) {
       return { ...found2, value: same(page2.reference) ? page2.dict : same(resources?.reference) ? resources.value : found2.value };
     }
     const names = new PdfNameIndex(storage, Infinity, signal), visitedNames = new PdfNameIndex(storage, Infinity, signal);
-    const backing = new PagedStorage22({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), found = new IntegerTable12(backing);
+    const backing = new PagedStorage23({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), found = new IntegerTable12(backing);
     let failed = false;
     try {
       const referenced = async (name) => await found.get(BigInt((await names.intern(name)).index)) !== void 0;
@@ -64018,7 +64384,7 @@ async function flattenRetainedRotations(document2, store, storage, signal) {
 }
 
 // packages/pdf-ast/src/edit/retained-attachment-edits.ts
-import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage23 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage24 } from "@poe-platform/safe-fs/storage";
 var PdfDuplicateAttachment = class extends PdfError {
   constructor(key) {
     super("E_CAPABILITY", `Duplicate attachment key: ${key}`);
@@ -64029,7 +64395,7 @@ var PdfDuplicateAttachment = class extends PdfError {
 async function editRetainedAttachments(document2, target, storage, remove, additions, signal, preserveTree = false) {
   const pairs = new PdfMutableObjectStore(storage, { signal });
   const names = new PdfNameIndex(storage, Infinity, signal), removed = new PdfNameIndex(storage, Infinity, signal);
-  const backing = new PagedStorage23({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), first = new IntegerTable13(backing), removals = new IntegerTable13(backing);
+  const backing = new PagedStorage24({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), first = new IntegerTable13(backing), removals = new IntegerTable13(backing);
   let failed = false, count = 0, work = 0;
   async function checkpoint() {
     signal.throwIfAborted();
@@ -64231,13 +64597,13 @@ async function* retainedAttachmentNameTokens(document2, storage, root, signal, r
 }
 
 // packages/pdf-ast/src/edit/retained-graph.ts
-import { PagedStorage as PagedStorage24 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
 async function editRetainedDocument(source, storage, options = {}) {
   if (options.maxPages !== void 0 && options.maxPages !== Infinity && (!Number.isSafeInteger(options.maxPages) || options.maxPages < 0)) throw new RangeError("Invalid page limit");
   if (options.maxRecursionDepth !== void 0 && options.maxRecursionDepth !== Infinity && (!Number.isSafeInteger(options.maxRecursionDepth) || options.maxRecursionDepth < 1)) throw new RangeError("Invalid edit depth");
   const signal = options.signal ?? new AbortController().signal;
   const store = new PdfMutableObjectStore(storage, { ...options, signal });
-  const pages = new PagedStorage24({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const pages = new PagedStorage25({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const base = pages.allocate(0);
   let count = 0, document2;
   let closing;
@@ -64286,6 +64652,14 @@ async function editRetainedDocument(source, storage, options = {}) {
       ...options.maxRecursionDepth === void 0 ? {} : { maxRecursionDepth: options.maxRecursionDepth }
     };
     document2 = await PdfRetainedDocument.openStore(store, storage, { ...configured, ...infoRef ? { infoRef } : {} });
+    if (options.infoUpdates) {
+      const updated = await applyRetainedInfoUpdates(document2, store, storage, count, getPage, options.infoUpdates, signal, options.maxRecursionDepth);
+      infoRef = updated.infoRef;
+      if (updated.idArray) configured.idArray = updated.idArray;
+      await document2.close();
+      document2 = await PdfRetainedDocument.openStore(store, storage, { ...configured, ...infoRef ? { infoRef } : {} });
+      addedObjects = true;
+    }
     for await (const edit of options.rotations ?? []) {
       signal.throwIfAborted();
       if (!Number.isSafeInteger(edit.pageIndex) || edit.pageIndex < 0 || edit.pageIndex >= count) throw new RangeError("Page index out of bounds");
@@ -64348,13 +64722,17 @@ async function editRetainedDocument(source, storage, options = {}) {
       await setRetainedBookmarks(store, storage, source.crossReference.rootRef, count, reference, options.bookmarks, signal, options.maxRecursionDepth);
       addedObjects = true;
     }
+    for await (const update of options.formUpdates ?? []) {
+      await generateRetainedFormAppearances(document2, store, storage, signal, update);
+      addedObjects = true;
+    }
     if (options.generateAppearances && !options.removeAcroform) {
       await generateRetainedFormAppearances(document2, store, storage, signal);
       addedObjects = true;
     }
     if (options.removeInfo) {
       await removeRoot(["Metadata"]);
-      const found = await document2.lookup(source.crossReference.infoRef);
+      const found = await document2.lookup(infoRef);
       if (found?.value.kind === "dict" && !found.stream && found.reference) {
         const date = dictGet(found.value, "ModDate");
         found.value.entries.length = 0;
@@ -64459,9 +64837,9 @@ async function* copyRetainedAttachments(document2, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/retained-object-order.ts
-import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage26 } from "@poe-platform/safe-fs/storage";
 async function* retainedObjectOrder(document2, source, storage, signal) {
-  const backing = new PagedStorage25({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const backing = new PagedStorage26({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const seen = new IntegerTable14(backing), streams = new IntegerTable14(backing);
   let failed = false, work = 0;
   async function candidate(number) {
@@ -64598,12 +64976,12 @@ async function* encryptRetainedPdfChunks(source, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/qpdf-json-values.ts
-import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage26 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage27 } from "@poe-platform/safe-fs/storage";
 var QpdfJsonValues = class _QpdfJsonValues {
   constructor(tree, storage, signal) {
     this.tree = tree;
     this.signal = signal;
-    this.scratch = new PagedStorage26({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+    this.scratch = new PagedStorage27({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
     this.first = new IntegerTable15(this.scratch, 64);
     this.next = new IntegerTable15(this.scratch, 64);
   }
@@ -64996,13 +65374,13 @@ var QpdfJsonValues = class _QpdfJsonValues {
 };
 
 // packages/pdf-ast/src/cos/qpdf-json-document.ts
-import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage27 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage28 } from "@poe-platform/safe-fs/storage";
 var QpdfJsonDocument = class _QpdfJsonDocument {
   constructor(storage, options = {}) {
     this.storage = storage;
     this.signal = options.signal ? AbortSignal.any([options.signal, this.controller.signal]) : this.controller.signal;
     this.store = new PdfMutableObjectStore(storage, { signal: this.signal });
-    this.backing = new PagedStorage27(
+    this.backing = new PagedStorage28(
       { fs: storage.fs, cwd: storage.directory, env: {}, signal: this.signal },
       4
     );
@@ -65071,7 +65449,7 @@ var QpdfJsonDocument = class _QpdfJsonDocument {
       env: {},
       signal: this.signal
     };
-    const tape = new PagedStorage27(context, 4), scratch = new PagedStorage27(context, 4);
+    const tape = new PagedStorage28(context, 4), scratch = new PagedStorage28(context, 4);
     let values, failed = false, work = 0;
     const cooperate = async (units = 1) => {
       this.signal.throwIfAborted();
@@ -65292,6 +65670,382 @@ var QpdfJsonDocument = class _QpdfJsonDocument {
     })();
   }
 };
+
+// packages/pdf-ast/src/edit/retained-form-data.ts
+import { IntegerTable as IntegerTable18, PagedStorage as PagedStorage30 } from "@poe-platform/safe-fs/storage";
+
+// packages/pdf-ast/src/edit/retained-form-data-fdf.ts
+import { IntegerTable as IntegerTable17, PagedStorage as PagedStorage29 } from "@poe-platform/safe-fs/storage";
+async function parseRetainedFdf(source, storage, set, signal) {
+  const backing = new PagedStorage29({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), tokens = new IntegerTable17(backing), starts = new IntegerTable17(backing), children = new IntegerTable17(backing), visited = new IntegerTable17(backing), names = new PdfNameIndex(storage, Infinity, signal);
+  let count = 0, cursor = 0, head = -1, work = 0, failed = false;
+  const cache = /* @__PURE__ */ new Map();
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 128 === 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      signal.throwIfAborted();
+    }
+  }
+  async function token2(index2) {
+    if (index2 < 0 || index2 >= count) return;
+    const cached = cache.get(index2);
+    if (cached) return cached;
+    const at = Number(await tokens.get(BigInt(index2))) - 1, result = (await readStoredRecord(backing, at, signal)).value;
+    if (cache.size >= 8) cache.delete(cache.keys().next().value);
+    cache.set(index2, result);
+    return result;
+  }
+  async function objectKey(object) {
+    return BigInt((await names.intern(String(object))).index);
+  }
+  async function push(frame) {
+    head = await appendStoredRecord(backing, { frame, previous: head }, -1, signal);
+  }
+  function dict(prefix) {
+    return { kind: "dict", prefix, partial: "", value: "", hasValue: false, children: -1 };
+  }
+  function text(token3) {
+    return token3.kind === "name" ? token3.decoded : token3.kind === "string" || token3.kind === "hex-string" ? decodePdfString({ kind: "string", bytes: token3.bytes, encoding: token3.kind === "string" ? "literal" : "hex" }) : "";
+  }
+  async function reference(index2) {
+    const a = await token2(index2), b = await token2(index2 + 1), c = await token2(index2 + 2);
+    return a?.kind === "number" && b?.kind === "number" && c?.kind === "keyword" && c.value === "R" ? a.value : void 0;
+  }
+  try {
+    const lexer = new CosRangeLexer(source, { signal, compactNumbers: true });
+    for (let next = await lexer.nextToken(); next; next = await lexer.nextToken()) {
+      await checkpoint();
+      const at = await appendStoredRecord(backing, next, -1, signal);
+      await tokens.set(BigInt(count++), BigInt(at + 1));
+    }
+    for (let i = 0; i < count; i++) {
+      await checkpoint();
+      const a = await token2(i), b = await token2(i + 1), c = await token2(i + 2), d = await token2(i + 3);
+      if (a?.kind === "number" && b?.kind === "number" && c?.kind === "keyword" && c.value === "obj" && d?.kind === "dict-start") await starts.set(await objectKey(a.value), BigInt(i + 5));
+      if (a?.kind === "name" && a.decoded === "Kids" && b?.kind === "array-start") {
+        let depth = 1;
+        for (let k = i + 2; k < count && depth > 0; k++) {
+          await checkpoint();
+          const next = await token2(k);
+          if (next?.kind === "array-start") depth++;
+          else if (next?.kind === "array-end") depth--;
+          else if (depth === 1) {
+            const ref = await reference(k);
+            if (ref !== void 0) {
+              await children.set(await objectKey(ref), 1n);
+              k += 2;
+            }
+          }
+        }
+      }
+    }
+    await push({ kind: "scan" });
+    while (head !== -1) {
+      await checkpoint();
+      const record = await readStoredRecord(backing, head, signal);
+      head = record.value.previous;
+      const frame = record.value.frame;
+      if (frame.kind === "restore") {
+        cursor = frame.cursor;
+        continue;
+      }
+      if (frame.kind === "ref") {
+        const key = await objectKey(frame.object), start = await starts.get(key);
+        if (start && !await visited.get(key)) {
+          await visited.set(key, 1n);
+          cursor = Number(start) - 1;
+          await push(dict(frame.prefix));
+        }
+        continue;
+      }
+      if (frame.kind === "children") {
+        let ref = frame.refs;
+        while (ref !== -1) {
+          const row = await readStoredRecord(backing, ref, signal);
+          await push({ kind: "ref", object: row.value.object, prefix: frame.prefix });
+          ref = row.value.previous;
+        }
+        cursor = frame.start;
+        await push({ kind: "range", end: frame.end, prefix: frame.prefix });
+        continue;
+      }
+      if (frame.kind === "scan" || frame.kind === "range") {
+        const end = frame.kind === "range" ? frame.end : count;
+        while (cursor < end) {
+          await checkpoint();
+          const a = await token2(cursor);
+          if (frame.kind === "scan" && a?.kind === "number") {
+            const b = await token2(cursor + 1), c = await token2(cursor + 2);
+            if (b?.kind === "number" && c?.kind === "keyword" && c.value === "obj") {
+              const key = await objectKey(a.value);
+              if (await children.get(key) || await visited.get(key)) {
+                cursor += 3;
+                while (cursor < count) {
+                  await checkpoint();
+                  const t = await token2(cursor++);
+                  if (t?.kind === "keyword" && t.value === "endobj") break;
+                }
+                continue;
+              }
+            }
+          }
+          cursor++;
+          if (a?.kind === "dict-start") {
+            await push(frame);
+            await push(dict(frame.kind === "range" ? frame.prefix : ""));
+            break;
+          }
+        }
+        continue;
+      }
+      let nested = false;
+      while (cursor < count) {
+        await checkpoint();
+        const next = await token2(cursor++);
+        if (next?.kind === "dict-end") break;
+        if (next?.kind === "dict-start") {
+          await push(frame);
+          await push(dict(frame.prefix && frame.partial ? `${frame.prefix}.${frame.partial}` : frame.partial || frame.prefix));
+          nested = true;
+          break;
+        }
+        if (next?.kind !== "name") continue;
+        const value = await token2(cursor);
+        if (next.decoded === "T" && (value?.kind === "string" || value?.kind === "hex-string" || value?.kind === "name")) {
+          frame.partial = text(value);
+          cursor++;
+        } else if (next.decoded === "V" && value) {
+          if (value.kind === "string" || value.kind === "hex-string" || value.kind === "name") {
+            const decoded = text(value);
+            frame.value = value.kind === "name" ? decoded === "Off" ? false : decoded === "Yes" || decoded === "On" ? true : decoded : decoded;
+            frame.hasValue = true;
+            cursor++;
+          } else if (value.kind === "number" || value.kind === "boolean") {
+            frame.value = value.kind === "number" ? String(value.value) : value.value;
+            frame.hasValue = true;
+            cursor++;
+          } else if (value.kind === "array-start") {
+            cursor++;
+            let depth = 1, joined = "", items = 0;
+            while (cursor < count && depth > 0) {
+              await checkpoint();
+              const t = await token2(cursor++);
+              if (t?.kind === "array-start") depth++;
+              else if (t?.kind === "array-end") depth--;
+              else if (depth === 1 && t && (t.kind === "string" || t.kind === "hex-string" || t.kind === "name")) {
+                joined += (items++ ? "," : "") + text(t);
+              }
+            }
+            frame.value = joined;
+            frame.hasValue = true;
+          }
+        } else if ((next.decoded === "Kids" || next.decoded === "Fields") && value?.kind === "array-start") {
+          cursor++;
+          const start = cursor;
+          let depth = 1, refs = -1;
+          while (cursor < count && depth > 0) {
+            await checkpoint();
+            const t = await token2(cursor++);
+            if (t?.kind === "array-start") depth++;
+            else if (t?.kind === "array-end") depth--;
+            else if (depth === 1) {
+              const ref = await reference(cursor - 1);
+              if (ref !== void 0) {
+                refs = await appendStoredRecord(backing, { object: ref, previous: refs }, -1, signal);
+                cursor += 2;
+              }
+            }
+          }
+          frame.children = await appendStoredRecord(backing, { start, end: cursor - 1, refs, previous: frame.children }, -1, signal);
+        }
+      }
+      if (nested) continue;
+      const name = frame.prefix && frame.partial ? `${frame.prefix}.${frame.partial}` : frame.partial || frame.prefix;
+      if (name && frame.hasValue) await set(name, frame.value);
+      if (frame.children !== -1) {
+        await push({ kind: "restore", cursor });
+        let child = frame.children;
+        while (child !== -1) {
+          const row = (await readStoredRecord(backing, child, signal)).value;
+          await push({ kind: "children", start: row.start, end: row.end, refs: row.refs, prefix: name });
+          child = row.previous;
+        }
+      }
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([backing.close(), names.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
+// packages/pdf-ast/src/edit/retained-form-data.ts
+var FormText = class {
+  constructor(backing, signal) {
+    this.backing = backing;
+    this.signal = signal;
+    this.base = backing.allocate(0);
+  }
+  backing;
+  signal;
+  length = 0;
+  base;
+  async load(source) {
+    const decoder = new TextDecoder();
+    const append = async (text) => {
+      for (let start = 0; start < text.length; start += 4096) {
+        this.signal.throwIfAborted();
+        const length = Math.min(4096, text.length - start), bytes = new Uint8Array(length * 2), view = new DataView(bytes.buffer);
+        for (let i = 0; i < length; i++) view.setUint16(i * 2, text.charCodeAt(start + i), true);
+        await this.backing.write(this.backing.allocate(bytes.length), bytes);
+        this.length += length;
+      }
+    };
+    for await (const chunk of source.stream(0, source.size, this.signal)) await append(decoder.decode(chunk, { stream: true }));
+    await append(decoder.decode());
+  }
+  async read(start, end) {
+    let result = "";
+    for (let at = start; at < end; at += 4096) {
+      this.signal.throwIfAborted();
+      const length = Math.min(4096, end - at), bytes = await this.backing.read(this.base + at * 2, length * 2), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+      const units = [];
+      for (let i = 0; i < length; i++) units.push(view.getUint16(i * 2, true));
+      result += String.fromCharCode(...units);
+    }
+    return result;
+  }
+  async indexOf(needle, start = 0) {
+    for (let at = start; at < this.length; at += 4096) {
+      const part = await this.read(at, Math.min(this.length, at + 4096 + needle.length - 1)), index2 = part.indexOf(needle);
+      if (index2 >= 0) return at + index2;
+    }
+    return -1;
+  }
+  async prefix() {
+    for (let at = 0; at < this.length; at += 4096) {
+      const part = await this.read(at, Math.min(this.length, at + 4096)), trimmed = part.trimStart();
+      if (trimmed) return this.read(at + part.length - trimmed.length, Math.min(this.length, at + part.length - trimmed.length + 5));
+    }
+    return "";
+  }
+};
+async function* parseRetainedFormData(source, storage, options = {}) {
+  const signal = options.signal ?? new AbortController().signal, context = { fs: storage.fs, cwd: storage.directory, env: {}, signal };
+  const textBacking = new PagedStorage30(context, 2), state = new PagedStorage30(context, 4), names = new PdfNameIndex(storage, Infinity, signal), values = new IntegerTable18(state);
+  const text = new FormText(textBacking, signal);
+  let count = 0, failed = false, work = 0;
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 64 === 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      signal.throwIfAborted();
+    }
+  }
+  async function set(name, value, append = false) {
+    await checkpoint();
+    const key = await names.intern(name), at = await values.get(BigInt(key.index));
+    if (key.added) count++;
+    if (append && typeof value === "string" && at) {
+      const previous = (await readStoredRecord(state, Number(at) - 1, signal)).value.value;
+      if (typeof previous === "string" && previous.length) value = `${previous},${value}`;
+    }
+    const offset = await appendStoredRecord(state, { name, value }, -1, signal);
+    await values.set(BigInt(key.index), BigInt(offset + 1));
+  }
+  try {
+    await text.load(source);
+    const prefix = await text.prefix();
+    if (prefix === "%FDF-" || await text.indexOf("/FDF") >= 0 && await text.indexOf("/Fields") >= 0) await parseRetainedFdf(source, storage, set, signal);
+    else if (prefix === "<?xml" || prefix === "<xfdf" || await text.indexOf("<fields") >= 0) {
+      let position = 0, head = -1, field2 = "";
+      while (position < text.length) {
+        await checkpoint();
+        const lt = await text.indexOf("<", position);
+        if (lt < 0) break;
+        const gt = await text.indexOf(">", lt + 1);
+        if (gt < 0) break;
+        const raw = (await text.read(lt + 1, gt)).trim();
+        position = gt + 1;
+        if (raw.startsWith("?") || raw.startsWith("!")) continue;
+        if (raw.startsWith("/")) {
+          if (raw.slice(1).trim().toLowerCase() === "field" && head !== -1) {
+            const row = (await readStoredRecord(state, head, signal)).value;
+            field2 = row.field;
+            head = row.previous;
+          }
+          continue;
+        }
+        const selfClosing = raw.endsWith("/"), tag = selfClosing ? raw.slice(0, -1).trim() : raw, space = tag.indexOf(" "), name = (space < 0 ? tag : tag.slice(0, space)).toLowerCase();
+        if (name === "field") {
+          let part = "";
+          const at = tag.indexOf("name=");
+          if (at >= 0) {
+            const quote = tag[at + 5];
+            if (quote === '"' || quote === "'") {
+              const end = tag.indexOf(quote, at + 6);
+              if (end >= 0) part = decodeFormDataEntities(tag.slice(at + 6, end));
+            }
+          }
+          if (!selfClosing) {
+            head = await appendStoredRecord(state, { field: field2, previous: head }, -1, signal);
+            field2 = field2 && part ? `${field2}.${part}` : field2 || part;
+          }
+        } else if (name === "value" && !selfClosing && head !== -1) {
+          const close = await text.indexOf("</value>", position);
+          if (close >= 0) {
+            const value = decodeFormDataEntities(await text.read(position, close));
+            if (field2) await set(field2, value === "Off" ? false : value === "Yes" || value === "On" ? true : value, true);
+            position = close + 8;
+          }
+        }
+      }
+    } else {
+      const report = await text.indexOf("FieldName:") >= 0;
+      let position = 0, name = "", type = "";
+      while (position < text.length) {
+        await checkpoint();
+        const newline = await text.indexOf("\n", position), end = newline < 0 ? text.length : newline, line = (await text.read(position, end)).trim();
+        position = end + 1;
+        if (report) {
+          if (line === "---") {
+            name = "";
+            type = "";
+          } else if (line.startsWith("FieldType:")) type = line.slice(10).trim();
+          else if (line.startsWith("FieldName:")) name = decodeFormDataEntities(line.slice(10).trim());
+          else if (line.startsWith("FieldValue:") && name) {
+            const value = decodeFormDataEntities(line.slice(11).trim());
+            await set(name, value === "Yes" || value === "On" ? true : value === "Off" || value === "false" || type === "Button" && value === "" ? false : value, true);
+          }
+        } else {
+          if (!line || line.startsWith("#")) continue;
+          const equals = line.indexOf("="), colon = line.indexOf(":"), separator = equals >= 0 ? equals : colon;
+          if (separator > 0) {
+            const name2 = line.slice(0, separator).trim(), value = line.slice(separator + 1).trim();
+            await set(name2, value === "true" || value === "Yes" || value === "On" ? true : value === "false" || value === "Off" ? false : value);
+          }
+        }
+      }
+    }
+    for (let index2 = 0; index2 < count; index2++) {
+      await checkpoint();
+      yield (await readStoredRecord(state, Number(await values.get(BigInt(index2))) - 1, signal)).value;
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([textBacking.close(), state.close(), names.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
 export {
   CosByteLexer,
   CosRangeLexer,
@@ -65357,6 +66111,7 @@ export {
   decodeCcittFax,
   decodeCcittFaxChunks,
   decodeFlate,
+  decodeFormDataEntities,
   decodeInlineImageNodeToRgba,
   decodeInlineImageNodeToRgbaSteps,
   decodeJbig2ToRgba,
@@ -65480,6 +66235,7 @@ export {
   parseCosRangeObject,
   parseCosRangeValue,
   parseFormDataBytes,
+  parseRetainedFormData,
   parseToUnicodeCMap,
   parseToUnicodeCMapSteps,
   parseTrueTypeFont,