@poe-platform/safe-bash 0.1.814 → 0.1.815

package/dist/pdf-ast/index.js

@@ -49365,45 +49365,73 @@ 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) => {
-    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);
+  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));
+      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();
           }
-        } 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);
         }
-      } 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);
@@ -49556,7 +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();
-  lengthPaths = /* @__PURE__ */ new WeakMap();
+  referencePaths = /* @__PURE__ */ new WeakMap();
   repairedOffsets = /* @__PURE__ */ new Map();
   options;
   capacity;
@@ -49586,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);
@@ -49597,16 +49622,36 @@ 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);
   }
+  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.lengthPaths.get(active),
+      parent: this.referencePaths.get(active),
       depth: 0
     };
-    this.lengthPaths.set(active, path);
+    this.referencePaths.set(active, path);
     let next = reference, result, failed = false;
     try {
       while (next) {
@@ -49637,8 +49682,8 @@ var PdfObjectReader = class {
       failed = true;
       throw error;
     } finally {
-      if (path.parent) this.lengthPaths.set(active, path.parent);
-      else this.lengthPaths.delete(active);
+      if (path.parent) this.referencePaths.set(active, path.parent);
+      else this.referencePaths.delete(active);
       try {
         await path.seen.close();
       } catch (error) {
@@ -49654,7 +49699,7 @@ var PdfObjectReader = class {
     this.options.signal?.throwIfAborted();
     if (active.has(objectNumber)) throw new PdfError("E_PARSE", "PDF indirect object cycle");
     let depth = active.size;
-    for (let path = this.lengthPaths.get(active); path; path = path.parent) {
+    for (let path = this.referencePaths.get(active); path; path = path.parent) {
       let seen;
       try {
         seen = await path.seen.has(objectNumber);
@@ -49774,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);
     }
@@ -56189,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) {
@@ -56253,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 = [];
@@ -56285,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);
@@ -56493,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 === "") {
@@ -58655,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) {
@@ -62848,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;
@@ -65627,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,
@@ -65692,6 +66111,7 @@ export {
   decodeCcittFax,
   decodeCcittFaxChunks,
   decodeFlate,
+  decodeFormDataEntities,
   decodeInlineImageNodeToRgba,
   decodeInlineImageNodeToRgbaSteps,
   decodeJbig2ToRgba,
@@ -65815,6 +66235,7 @@ export {
   parseCosRangeObject,
   parseCosRangeValue,
   parseFormDataBytes,
+  parseRetainedFormData,
   parseToUnicodeCMap,
   parseToUnicodeCMapSteps,
   parseTrueTypeFont,