@poe-platform/safe-bash 0.1.815 → 0.1.817

package/dist/pdf-ast/index.js

@@ -336,6 +336,157 @@ var PdfStagingStorage = class {
   }
 };
 
+// packages/pdf-ast/src/content/stored-path.ts
+var BLOCK_BYTES = 4096;
+var RECORD_BYTES = 56;
+var RECORDS = Math.floor((BLOCK_BYTES - 8) / RECORD_BYTES);
+var kinds = ["close", "move", "line", "cubic", "rect"];
+var StoredPathWriter = class {
+  constructor(storage, signal) {
+    this.storage = storage;
+    this.signal = signal;
+  }
+  storage;
+  signal;
+  bytes = new Uint8Array(BLOCK_BYTES);
+  view = new DataView(this.bytes.buffer);
+  first = -1;
+  position = -1;
+  used = 0;
+  count = 0;
+  finished = false;
+  bounds = [Infinity, Infinity, -Infinity, -Infinity];
+  allocate() {
+    const at = this.storage.allocate(BLOCK_BYTES);
+    if (!Number.isSafeInteger(at) || at < 0 || !Number.isSafeInteger(at + BLOCK_BYTES)) throw new RangeError("Invalid PDF path allocation");
+    return at;
+  }
+  async append(segment) {
+    this.signal?.throwIfAborted();
+    if (this.finished) throw new Error("PDF path is already finished");
+    if (this.position === -1) this.first = this.position = this.allocate();
+    if (this.used === RECORDS) {
+      const next = this.allocate();
+      this.view.setFloat64(0, next, true);
+      await this.storage.write(this.position, this.bytes, this.signal ? { signal: this.signal } : void 0);
+      this.position = next;
+      this.used = 0;
+    }
+    const at = 8 + this.used++ * RECORD_BYTES;
+    this.view.setFloat64(at, kinds.indexOf(segment.kind), true);
+    const values = segment.kind === "close" ? [] : segment.kind === "cubic" ? [segment.x, segment.y, segment.x1, segment.y1, segment.x2, segment.y2] : segment.kind === "rect" ? [segment.x, segment.y, segment.width, segment.height] : [segment.x, segment.y];
+    for (let i = 0; i < values.length; i++) this.view.setFloat64(at + 8 + i * 8, values[i], true);
+    const include = (x, y) => {
+      this.bounds[0] = Math.min(this.bounds[0], x);
+      this.bounds[1] = Math.min(this.bounds[1], y);
+      this.bounds[2] = Math.max(this.bounds[2], x);
+      this.bounds[3] = Math.max(this.bounds[3], y);
+    };
+    if (segment.kind !== "close") include(segment.x, segment.y);
+    if (segment.kind === "cubic") {
+      include(segment.x1, segment.y1);
+      include(segment.x2, segment.y2);
+    }
+    if (segment.kind === "rect") include(segment.x + segment.width, segment.y + segment.height);
+    this.count++;
+  }
+  async finish() {
+    this.signal?.throwIfAborted();
+    if (this.finished) throw new Error("PDF path is already finished");
+    this.finished = true;
+    if (this.position !== -1) {
+      this.view.setFloat64(0, -1, true);
+      await this.storage.write(this.position, this.bytes.subarray(0, 8 + this.used * RECORD_BYTES), this.signal ? { signal: this.signal } : void 0);
+    }
+    return { kind: "stored-path", storage: this.storage, position: this.first, count: this.count, bounds: this.bounds };
+  }
+};
+async function* readStoredPath(path, signal) {
+  let position = path.position, remaining = path.count;
+  while (remaining > 0) {
+    signal?.throwIfAborted();
+    if (!Number.isSafeInteger(position) || position < 0) throw new Error("Invalid PDF path block");
+    const count = Math.min(RECORDS, remaining), length = 8 + count * RECORD_BYTES;
+    const bytes = (await path.storage.read(position, length, signal ? { signal } : void 0)).slice();
+    if (bytes.length !== length) throw new Error("Incomplete PDF path block");
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    position = view.getFloat64(0, true);
+    for (let i = 0; i < count; i++) {
+      signal?.throwIfAborted();
+      const at = 8 + i * RECORD_BYTES, kind = kinds[view.getFloat64(at, true)];
+      const value = (n) => view.getFloat64(at + 8 + n * 8, true);
+      if (kind === "close") yield { kind };
+      else if (kind === "move" || kind === "line") yield { kind, x: value(0), y: value(1) };
+      else if (kind === "rect") yield { kind, x: value(0), y: value(1), width: value(2), height: value(3) };
+      else if (kind === "cubic") yield { kind, x: value(0), y: value(1), x1: value(2), y1: value(3), x2: value(4), y2: value(5) };
+      else throw new Error("Invalid PDF path record");
+    }
+    remaining -= count;
+  }
+}
+
+// packages/pdf-ast/src/render/svg-path-stream.ts
+function svgPathSegment(segment, height, matrix2) {
+  const point = (x, y) => matrix2 ? `${matrix2[0] * x + matrix2[2] * y + matrix2[4]} ${height - matrix2[1] * x - matrix2[3] * y - matrix2[5]}` : `${x} ${height - y}`;
+  switch (segment.kind) {
+    case "move":
+      return `M ${point(segment.x, segment.y)}`;
+    case "line":
+      return `L ${point(segment.x, segment.y)}`;
+    case "cubic":
+      return `C ${point(segment.x1, segment.y1)} ${point(segment.x2, segment.y2)} ${point(segment.x, segment.y)}`;
+    case "rect":
+      return matrix2 ? `M ${point(segment.x, segment.y)} L ${point(segment.x + segment.width, segment.y)} L ${point(segment.x + segment.width, segment.y + segment.height)} L ${point(segment.x, segment.y + segment.height)} Z` : `M ${segment.x} ${height - segment.y} h ${segment.width} v ${-segment.height} h ${-segment.width} Z`;
+    case "close":
+      return "Z";
+  }
+}
+function limit(value) {
+  if (value === void 0 || value === Infinity) return Infinity;
+  if (!Number.isSafeInteger(value) || value < 0) throw new RangeError("Invalid SVG path limit");
+  return value;
+}
+async function* encodeSvgPathDataChunks(input, height, options = {}) {
+  const { signal } = options;
+  signal?.throwIfAborted();
+  const chunkBytes = options.chunkBytes ?? 16384, maxSegments = limit(options.maxSegments), maximum10 = limit(options.maxOutputBytes);
+  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid SVG path chunk size");
+  const stored = "kind" in input && input.kind === "stored-path" ? input : void 0;
+  if (stored && (!Number.isSafeInteger(stored.count) || stored.count < 0)) throw new RangeError("Invalid stored SVG path count");
+  if (stored && stored.count > maxSegments) throw new PdfError("E_LIMIT", "SVG path segment limit exceeded");
+  const source = stored ? readStoredPath(stored, signal) : input;
+  const buffer = new Uint8Array(Math.min(16384, chunkBytes)), encoder = new TextEncoder();
+  let used = 0, count = 0, total = 0, first = true;
+  for await (const segment of source) {
+    signal?.throwIfAborted();
+    if (count >= maxSegments) throw new PdfError("E_LIMIT", "SVG path segment limit exceeded");
+    if (++count % 64 === 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      signal?.throwIfAborted();
+    }
+    const part = svgPathSegment(segment, height, options.matrix);
+    if (part === void 0) continue;
+    const text = (first ? "" : " ") + part;
+    first = false;
+    if (text.length > maximum10 - total || !Number.isSafeInteger(total + text.length)) throw new PdfError("E_LIMIT", "SVG path output byte limit exceeded");
+    total += text.length;
+    const bytes = encoder.encode(text);
+    for (let at = 0; at < bytes.length; ) {
+      signal?.throwIfAborted();
+      const take = Math.min(buffer.length - used, bytes.length - at);
+      buffer.set(bytes.subarray(at, at + take), used);
+      used += take;
+      at += take;
+      if (used === buffer.length) {
+        yield buffer.slice();
+        used = 0;
+      }
+    }
+  }
+  signal?.throwIfAborted();
+  if (used) yield buffer.slice(0, used);
+}
+
 // packages/pdf-ast/src/content/stored-record.ts
 function* encodeParts(value, storage, key, ancestors) {
   if (key === "storage") {
@@ -522,6 +673,87 @@ var RecordReader = class {
     }
     return result;
   }
+  async size(tag) {
+    const bytes = await this.take(8);
+    const size = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getFloat64(0, true);
+    if (!Number.isSafeInteger(size) || size < 0 || size > this.remaining || tag === 4 /* String */ && size * 2 > this.remaining) throw new Error("Invalid capture field length");
+    return size;
+  }
+  async discard(length) {
+    while (length) {
+      const count = Math.min(length, 4096);
+      await this.take(count);
+      length -= count;
+    }
+  }
+  async stringEquals(expected) {
+    const length = await this.size(4 /* String */);
+    let equal2 = length === expected.length;
+    for (let at = 0; at < length; at += 2048) {
+      const bytes = await this.take(Math.min(2048, length - at) * 2);
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      if (equal2) for (let i = 0; i < bytes.length / 2; i++) {
+        if (view.getUint16(i * 2, true) !== expected.charCodeAt(at + i)) {
+          equal2 = false;
+          break;
+        }
+      }
+    }
+    return equal2;
+  }
+  /** Skip without constructing arrays, strings or byte payloads. Only 32
+   * container counters stay resident; deeper counters use caller backing. */
+  async skip(tag) {
+    const frames = [];
+    const spilled = new StoredMetadataStack(this.storage, this.signal);
+    let remaining = 1;
+    for (; ; ) {
+      if (remaining === 0) {
+        const parent = frames.pop() ?? await spilled.pop();
+        if (parent === void 0) return;
+        remaining = parent;
+        continue;
+      }
+      if (remaining === -1) {
+        const field3 = (await this.take(1))[0];
+        if (field3 === 9 /* End */) {
+          remaining = 0;
+          continue;
+        }
+        if (field3 !== 4 /* String */) throw new Error("Invalid capture key");
+        await this.discard(await this.size(4 /* String */) * 2);
+      } else remaining--;
+      const current = tag ?? (await this.take(1))[0];
+      tag = void 0;
+      if (current === 8 /* Object */ || current === 7 /* Array */) {
+        const children = current === 8 /* Object */ ? -1 : await this.size(7 /* Array */);
+        if (frames.length === 32) await spilled.push(frames.shift());
+        frames.push(remaining);
+        remaining = children;
+      } else if (current === 4 /* String */ || current === 5 /* Bytes */) {
+        await this.discard(await this.size(current) * (current === 4 /* String */ ? 2 : 1));
+      } else if (current === 3 /* Number */) await this.take(8);
+      else if (current !== 0 /* Null */ && current !== 1 /* False */ && current !== 2 /* True */ && current !== 6 /* Storage */) {
+        throw new Error("Invalid capture tag");
+      }
+    }
+  }
+  async matches(path, expected, depth = 0) {
+    const tag = (await this.take(1))[0];
+    if (depth === path.length && tag === 4 /* String */) return this.stringEquals(expected);
+    if (depth === path.length || tag !== 8 /* Object */) {
+      await this.skip(tag);
+      return false;
+    }
+    let matched = false;
+    for (; ; ) {
+      const field3 = (await this.take(1))[0];
+      if (field3 === 9 /* End */) return matched;
+      if (field3 !== 4 /* String */) throw new Error("Invalid capture key");
+      if (await this.stringEquals(path[depth])) matched = await this.matches(path, expected, depth + 1);
+      else await this.skip();
+    }
+  }
   async value(tag) {
     tag ??= (await this.take(1))[0];
     if (tag === 0 /* Null */) return null;
@@ -531,10 +763,10 @@ var RecordReader = class {
     if (tag === 8 /* Object */) {
       const value2 = {};
       for (; ; ) {
-        const field2 = (await this.take(1))[0];
-        if (field2 === 9 /* End */) return value2;
-        if (field2 !== 4 /* String */) throw new Error("Invalid capture key");
-        const key = await this.value(field2);
+        const field3 = (await this.take(1))[0];
+        if (field3 === 9 /* End */) return value2;
+        if (field3 !== 4 /* String */) throw new Error("Invalid capture key");
+        const key = await this.value(field3);
         Object.defineProperty(value2, key, {
           value: await this.value(),
           enumerable: true,
@@ -571,7 +803,7 @@ var RecordReader = class {
     return value;
   }
 };
-async function readStoredRecord(storage, position, signal) {
+async function openStoredRecord(storage, position, signal) {
   signal?.throwIfAborted();
   if (!Number.isSafeInteger(position) || position < 0)
     throw new RangeError("Invalid capture position");
@@ -581,11 +813,22 @@ async function readStoredRecord(storage, position, signal) {
   const view = new DataView(header2.buffer, header2.byteOffset, header2.byteLength), next = view.getFloat64(0, true), length = view.getFloat64(8, true);
   if (!Number.isSafeInteger(length) || length < 1 || !Number.isSafeInteger(position + 16 + length))
     throw new RangeError("Invalid capture length");
-  const reader = new RecordReader(storage, position + 16, length, signal), value = await reader.value();
+  return { reader: new RecordReader(storage, position + 16, length, signal), next };
+}
+async function readStoredRecord(storage, position, signal) {
+  const { reader, next } = await openStoredRecord(storage, position, signal);
+  const value = await reader.value();
   if (reader.remaining) throw new Error("Trailing capture bytes");
   signal?.throwIfAborted();
   return { value, next };
 }
+async function storedRecordMatches(storage, position, path, expected, signal) {
+  const { reader, next } = await openStoredRecord(storage, position, signal);
+  const matched = await reader.matches(path, expected);
+  if (reader.remaining) throw new Error("Trailing capture bytes");
+  signal?.throwIfAborted();
+  return { matched, next };
+}
 var StoredMetadataStack = class {
   constructor(storage, signal) {
     this.storage = storage;
@@ -699,95 +942,6 @@ async function* readStoredOperations(source, signal) {
   }
 }
 
-// packages/pdf-ast/src/content/stored-path.ts
-var BLOCK_BYTES = 4096;
-var RECORD_BYTES = 56;
-var RECORDS = Math.floor((BLOCK_BYTES - 8) / RECORD_BYTES);
-var kinds = ["close", "move", "line", "cubic", "rect"];
-var StoredPathWriter = class {
-  constructor(storage, signal) {
-    this.storage = storage;
-    this.signal = signal;
-  }
-  storage;
-  signal;
-  bytes = new Uint8Array(BLOCK_BYTES);
-  view = new DataView(this.bytes.buffer);
-  first = -1;
-  position = -1;
-  used = 0;
-  count = 0;
-  finished = false;
-  bounds = [Infinity, Infinity, -Infinity, -Infinity];
-  allocate() {
-    const at = this.storage.allocate(BLOCK_BYTES);
-    if (!Number.isSafeInteger(at) || at < 0 || !Number.isSafeInteger(at + BLOCK_BYTES)) throw new RangeError("Invalid PDF path allocation");
-    return at;
-  }
-  async append(segment) {
-    this.signal?.throwIfAborted();
-    if (this.finished) throw new Error("PDF path is already finished");
-    if (this.position === -1) this.first = this.position = this.allocate();
-    if (this.used === RECORDS) {
-      const next = this.allocate();
-      this.view.setFloat64(0, next, true);
-      await this.storage.write(this.position, this.bytes, this.signal ? { signal: this.signal } : void 0);
-      this.position = next;
-      this.used = 0;
-    }
-    const at = 8 + this.used++ * RECORD_BYTES;
-    this.view.setFloat64(at, kinds.indexOf(segment.kind), true);
-    const values = segment.kind === "close" ? [] : segment.kind === "cubic" ? [segment.x, segment.y, segment.x1, segment.y1, segment.x2, segment.y2] : segment.kind === "rect" ? [segment.x, segment.y, segment.width, segment.height] : [segment.x, segment.y];
-    for (let i = 0; i < values.length; i++) this.view.setFloat64(at + 8 + i * 8, values[i], true);
-    const include = (x, y) => {
-      this.bounds[0] = Math.min(this.bounds[0], x);
-      this.bounds[1] = Math.min(this.bounds[1], y);
-      this.bounds[2] = Math.max(this.bounds[2], x);
-      this.bounds[3] = Math.max(this.bounds[3], y);
-    };
-    if (segment.kind !== "close") include(segment.x, segment.y);
-    if (segment.kind === "cubic") {
-      include(segment.x1, segment.y1);
-      include(segment.x2, segment.y2);
-    }
-    if (segment.kind === "rect") include(segment.x + segment.width, segment.y + segment.height);
-    this.count++;
-  }
-  async finish() {
-    this.signal?.throwIfAborted();
-    if (this.finished) throw new Error("PDF path is already finished");
-    this.finished = true;
-    if (this.position !== -1) {
-      this.view.setFloat64(0, -1, true);
-      await this.storage.write(this.position, this.bytes.subarray(0, 8 + this.used * RECORD_BYTES), this.signal ? { signal: this.signal } : void 0);
-    }
-    return { kind: "stored-path", storage: this.storage, position: this.first, count: this.count, bounds: this.bounds };
-  }
-};
-async function* readStoredPath(path, signal) {
-  let position = path.position, remaining = path.count;
-  while (remaining > 0) {
-    signal?.throwIfAborted();
-    if (!Number.isSafeInteger(position) || position < 0) throw new Error("Invalid PDF path block");
-    const count = Math.min(RECORDS, remaining), length = 8 + count * RECORD_BYTES;
-    const bytes = (await path.storage.read(position, length, signal ? { signal } : void 0)).slice();
-    if (bytes.length !== length) throw new Error("Incomplete PDF path block");
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    position = view.getFloat64(0, true);
-    for (let i = 0; i < count; i++) {
-      signal?.throwIfAborted();
-      const at = 8 + i * RECORD_BYTES, kind = kinds[view.getFloat64(at, true)];
-      const value = (n) => view.getFloat64(at + 8 + n * 8, true);
-      if (kind === "close") yield { kind };
-      else if (kind === "move" || kind === "line") yield { kind, x: value(0), y: value(1) };
-      else if (kind === "rect") yield { kind, x: value(0), y: value(1), width: value(2), height: value(3) };
-      else if (kind === "cubic") yield { kind, x: value(0), y: value(1), x1: value(2), y1: value(3), x2: value(4), y2: value(5) };
-      else throw new Error("Invalid PDF path record");
-    }
-    remaining -= count;
-  }
-}
-
 // packages/pdf-ast/src/content/stored-clips.ts
 var PAGE_BYTES = 4096;
 var RECORD_BYTES2 = 64;
@@ -14851,17 +15005,17 @@ var Type1Font = class {
       "StdHW",
       "StdVW"
     ];
-    for (const field2 of fields2) {
-      if (!properties.privateData.has(field2)) {
+    for (const field3 of fields2) {
+      if (!properties.privateData.has(field3)) {
         continue;
       }
-      const value = properties.privateData.get(field2);
+      const value = properties.privateData.get(field3);
       if (Array.isArray(value)) {
         for (let j = value.length - 1; j > 0; j--) {
           value[j] -= value[j - 1];
         }
       }
-      privateDict.setByName(field2, value);
+      privateDict.setByName(field3, value);
     }
     cff.topDict.privateDict = privateDict;
     const subrIndex = new CFFIndex();
@@ -18715,14 +18869,14 @@ var FlateStream = class extends DecodeStream {
       throw new FormatError("Unknown block type in flate stream");
     }
     buffer = this.buffer;
-    let limit10 = buffer ? buffer.length : 0;
+    let limit11 = buffer ? buffer.length : 0;
     let pos = this.bufferLength;
     while (true) {
       let code1 = this.getCode(litCodeTable);
       if (code1 < 256) {
-        if (pos + 1 >= limit10) {
+        if (pos + 1 >= limit11) {
           buffer = this.ensureBuffer(pos + 1);
-          limit10 = buffer.length;
+          limit11 = buffer.length;
         }
         buffer[pos++] = code1;
         continue;
@@ -18745,9 +18899,9 @@ var FlateStream = class extends DecodeStream {
         code2 = this.getBits(code2);
       }
       const dist = (code1 & 65535) + code2;
-      if (pos + len >= limit10) {
+      if (pos + len >= limit11) {
         buffer = this.ensureBuffer(pos + len);
-        limit10 = buffer.length;
+        limit11 = buffer.length;
       }
       for (let k = 0; k < len; ++k, ++pos) {
         buffer[pos] = buffer[pos - dist];
@@ -28224,6 +28378,8 @@ function* repairCandidateSteps(size) {
 // packages/pdf-ast/src/cos/value-parser.ts
 function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity, options = {}) {
   yield;
+  if (options.deferArrayValues && !options.deferDictionaryValues) throw new TypeError("Deferred array values require deferred dictionary values");
+  if (options.deferDictionaryValues && (!options.dictionaryStorage || options.arrayStorage !== options.dictionaryStorage || options.stringStorage !== options.dictionaryStorage || options.containerStorage !== options.dictionaryStorage)) throw new TypeError("Deferred resource values require shared caller backing");
   let work = 0;
   let nodes = 0;
   const charge = () => {
@@ -28233,14 +28389,15 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
   const residentDepth = 32;
   const stack = [];
   let current, depth = 0;
-  const pathLength = (options.storedArrayPaths ?? []).reduce((length, path) => Math.max(length, path.length - 1), 0);
-  function matchesStoredPath(parent) {
-    return options.storedArrayPaths?.some((path) => {
-      const length = parent.path.length + 1;
+  const pathLength = [...options.storedArrayPaths ?? [], ...options.storedDictionaryPaths ?? []].reduce((length, path) => Math.max(length, path.length - 1), 0);
+  function matchesStoredPath(parent, paths) {
+    const currentPath = parent ? [...parent.path, parent.kind === "dict" ? parent.key?.decoded : null] : options.arrayPathPrefix ?? [];
+    return paths?.some((path) => {
+      const length = currentPath.length;
       if (!path.length || path.length > length) return false;
       for (let i = 0; i < path.length; i++) {
         const at = length - path.length + i;
-        const key = at === parent.path.length ? parent.kind === "dict" ? parent.key?.decoded : void 0 : parent.path[at];
+        const key = currentPath[at];
         if (key == null || path[i] !== "*" && path[i] !== key) return false;
       }
       return true;
@@ -28265,7 +28422,9 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
   while (true) {
     if (++work % 16 === 0) yield;
     const parent = current;
-    lexer.setStringStorage?.(options.stringStorage && (parent?.kind === "dict" && parent.key && options.storedStringKeys?.includes(parent.key.decoded) || !parent && options.storeRootString) ? options.stringStorage : void 0);
+    const deferred = options.deferDictionaryValues && (parent?.deferred || parent?.kind === "dict" && parent.storedEntries || options.deferArrayValues && parent?.kind === "array" && parent.storedItems);
+    const selectedString = parent?.kind === "dict" && parent.key && options.storedStringKeys?.includes(parent.key.decoded) || !parent && options.storeRootString;
+    lexer.setStringStorage?.(options.stringStorage && (selectedString || deferred) ? options.stringStorage : void 0);
     const tok = yield "token";
     if (!tok) {
       if (!parent) return void 0;
@@ -28278,11 +28437,11 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
     let node;
     if (parent?.kind === "array" && tok.kind === "array-end") {
       yield* pop();
-      node = { kind: "array", items: parent.items, ...parent.storedItems ? { storedItems: parent.storedItems } : {}, span: { start: parent.start, end: tok.span.end } };
+      node = { kind: "array", items: parent.items, ...parent.deferred ? { deferred: true } : {}, ...parent.storedItems ? { storedItems: parent.storedItems } : {}, span: { start: parent.start, end: tok.span.end } };
     } else if (parent?.kind === "dict" && !parent.key) {
       if (tok.kind === "dict-end") {
         yield* pop();
-        node = yield { kind: "dict", entries: parent.entries, ...parent.storedEntries ? { storedEntries: parent.storedEntries } : {}, span: { start: parent.start, end: tok.span.end } };
+        node = yield { kind: "dict", entries: parent.entries, ...parent.deferred ? { deferred: true } : {}, ...parent.storedEntries ? { storedEntries: parent.storedEntries } : {}, span: { start: parent.start, end: tok.span.end } };
       } else if (tok.kind === "name") {
         charge();
         parent.key = { kind: "name", rawBytes: tok.rawBytes, decoded: tok.decoded, span: tok.span };
@@ -28298,30 +28457,33 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
       charge();
       if (depth > maxDepth) throw new PdfError("E_LIMIT", "PDF syntax nesting limit exceeded");
       if (tok.kind === "array-start") {
-        const backed = options.arrayStorage && (parent?.kind === "array" && parent.storedItems || parent?.kind === "dict" && (options.storedArrayKeys?.includes(parent.key.decoded) || matchesStoredPath(parent)) || !parent && options.storeRootArray);
+        const backed = options.arrayStorage && (parent?.kind === "array" && parent.storedItems && !parent.deferred || parent?.kind === "dict" && (options.storedArrayKeys?.includes(parent.key.decoded) || matchesStoredPath(parent, options.storedArrayPaths)) || !parent && options.storeRootArray);
         yield* push({
           kind: "array",
           path: ancestorPath(parent),
           start: tok.span.start,
           items: [],
           tail: -1,
-          ...backed ? { storedItems: { storage: options.arrayStorage, position: -1, length: 0 } } : {}
+          ...deferred && !backed ? { deferred: true } : {},
+          ...backed || deferred ? { storedItems: { storage: options.arrayStorage, position: -1, length: 0 } } : {}
         });
         continue;
       }
       if (tok.kind === "dict-start") {
-        const backed = options.dictionaryStorage && (parent?.kind === "dict" && !parent.storedEntries && options.storedDictionaryKeys?.includes(parent.key.decoded) || !parent && options.storeRootDictionary);
+        const backed = options.dictionaryStorage && (parent?.kind === "dict" && (!parent.storedEntries || parent.deferred) && (options.storedDictionaryKeys?.includes(parent.key.decoded) || matchesStoredPath(parent, options.storedDictionaryPaths)) || !parent && (options.storeRootDictionary || matchesStoredPath(void 0, options.storedDictionaryPaths)));
         yield* push({
           kind: "dict",
           path: ancestorPath(parent),
           start: tok.span.start,
           entries: [],
           tail: -1,
-          ...backed ? { storedEntries: { storage: options.dictionaryStorage, position: -1, length: 0 } } : {}
+          ...deferred && !backed ? { deferred: true } : {},
+          ...backed || deferred ? { storedEntries: { storage: options.dictionaryStorage, position: -1, length: 0 } } : {}
         });
         continue;
       }
       node = yield* parseLeafFromToken(tok, lexer);
+      if (deferred && !selectedString && node.kind === "string") node = { ...node, deferred: true };
     }
     const container = current;
     if (!container) return node;
@@ -28680,8 +28842,8 @@ var PdfNameIndex = class {
     this.storage = storage;
     this.maximum = maximum10;
     this.signal = signal;
-    const limit10 = typeof maximum10 === "function" ? maximum10() : maximum10;
-    if (limit10 !== Infinity && (!Number.isSafeInteger(limit10) || limit10 < 0)) throw new RangeError("Invalid name staging limit");
+    const limit11 = typeof maximum10 === "function" ? maximum10() : maximum10;
+    if (limit11 !== Infinity && (!Number.isSafeInteger(limit11) || limit11 < 0)) throw new RangeError("Invalid name staging limit");
   }
   storage;
   maximum;
@@ -28720,8 +28882,8 @@ var PdfNameIndex = class {
       for (const [objectNumber, offset] of tail) yield { objectNumber, offset, type: "uncompressed" };
       for (const index2 of inputs) yield* index2.entries(signal);
     }
-    const limit10 = typeof this.maximum === "function" ? this.maximum() : this.maximum;
-    const remaining = Math.min(limit10, Number.MAX_SAFE_INTEGER) - this.stagedBytes;
+    const limit11 = typeof this.maximum === "function" ? this.maximum() : this.maximum;
+    const remaining = Math.min(limit11, Number.MAX_SAFE_INTEGER) - this.stagedBytes;
     if (remaining < 0) throw new PdfError("E_LIMIT", "PDF name staging byte limit exceeded");
     const combined = await PdfObjectIndex.build(rows(), this.storage, {
       runEntries: 64,
@@ -28791,7 +28953,7 @@ var PdfNameIndex = class {
 };
 
 // packages/pdf-ast/src/content/stored-dictionary.ts
-async function* readPdfDictionaryEntries(dict, signal) {
+async function* readRawPdfDictionaryEntries(dict, signal) {
   signal?.throwIfAborted();
   if (dict.storedEntries) yield* readStoredItems(dict.storedEntries, signal);
   else for (const entry of dict.entries) {
@@ -28799,10 +28961,59 @@ async function* readPdfDictionaryEntries(dict, signal) {
     yield entry;
   }
 }
-async function readPdfDictionaryValue(dict, key, signal) {
+async function materializeResourceValue(node, signal) {
+  signal?.throwIfAborted();
+  if (node.kind === "dict" && node.deferred && node.storedEntries) {
+    const { deferred: ignoredDeferred, storedEntries: ignoredEntries, ...ordinary } = node;
+    const entries = [];
+    for await (const entry of readRawPdfDictionaryEntries(node, signal)) entries.push({ ...entry, value: await materializeResourceValue(entry.value, signal) });
+    return { ...ordinary, entries };
+  }
+  if (node.kind === "array" && node.deferred && node.storedItems) {
+    const { deferred: ignoredDeferred, storedItems: ignoredItems, ...ordinary } = node;
+    const items = [];
+    for await (const item of readStoredItems(node.storedItems, signal)) items.push(await materializeResourceValue(item, signal));
+    return { ...ordinary, items };
+  }
+  if (node.kind === "string" && node.deferred && node.storedBytes) {
+    const { deferred: ignoredDeferred, storedBytes, ...ordinary } = node;
+    if (!Number.isSafeInteger(storedBytes.byteLength) || storedBytes.byteLength < 0) throw new RangeError("Invalid deferred resource string length");
+    const bytes = new Uint8Array(storedBytes.byteLength);
+    for (let at = 0; at < bytes.length; at += 4096) {
+      if (at && at % 65536 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+      const length = Math.min(4096, bytes.length - at);
+      const chunk = await storedBytes.storage.read(storedBytes.position + at, length, signal ? { signal } : void 0);
+      signal?.throwIfAborted();
+      if (chunk.length !== length) throw new Error("Incomplete deferred resource string");
+      bytes.set(chunk, at);
+    }
+    return { ...ordinary, bytes };
+  }
+  return node;
+}
+async function* readPdfDictionaryEntries(dict, signal) {
+  for await (const entry of readRawPdfDictionaryEntries(dict, signal)) yield { ...entry, value: await materializeResourceValue(entry.value, signal) };
+}
+async function readPdfDictionaryValue(dict, key, signal, options = {}) {
+  if (dict.storedEntries) {
+    const { storage, length } = dict.storedEntries;
+    if (!Number.isSafeInteger(length) || length < 0) throw new RangeError("Invalid stored array length");
+    let position = dict.storedEntries.position, selected = -1;
+    for (let i = 0; i < length; i++) {
+      if (i && i % 256 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+      const record = await storedRecordMatches(storage, position, ["key", "decoded"], key, signal);
+      if (record.matched) selected = position;
+      position = record.next;
+    }
+    if (position !== -1) throw new Error("Invalid stored array terminator");
+    signal?.throwIfAborted();
+    if (selected === -1) return void 0;
+    const value2 = (await readStoredRecord(storage, selected, signal)).value.value;
+    return options.preserveDeferred ? value2 : materializeResourceValue(value2, signal);
+  }
   let value;
-  for await (const entry of readPdfDictionaryEntries(dict, signal)) if (entry.key.decoded === key) value = entry.value;
-  return value;
+  for await (const entry of readRawPdfDictionaryEntries(dict, signal)) if (entry.key.decoded === key) value = entry.value;
+  return value && !options.preserveDeferred ? materializeResourceValue(value, signal) : value;
 }
 async function mergePdfResourceDictionaries(destination, source, indexStorage, signal) {
   const storage = destination.storedEntries?.storage ?? source?.storedEntries?.storage;
@@ -28812,7 +29023,7 @@ async function mergePdfResourceDictionaries(destination, source, indexStorage, s
   async function* rows() {
     for (const [dict, replace] of [[destination, true], [source, false]]) {
       if (!dict) continue;
-      for await (const entry of readPdfDictionaryEntries(dict, signal)) {
+      for await (const entry of readRawPdfDictionaryEntries(dict, signal)) {
         const name = await names.intern(entry.key.decoded);
         if (!replace && !name.added) continue;
         const position = await writeStoredRecord(storage, entry, -1, signal);
@@ -30901,13 +31112,13 @@ async function decryptPdfObjectStrings(state, objectNumber, generationNumber, va
       let signatureDict = node;
       if (node.storedEntries) {
         signatureDict = { kind: "dict", entries: [] };
-        for await (const entry of readPdfDictionaryEntries(node, options.signal)) {
+        for await (const entry of readRawPdfDictionaryEntries(node, options.signal)) {
           if (["Type", "FT", "ByteRange", "Filter"].includes(entry.key.decoded)) dictSet(signatureDict, entry.key.decoded, entry.value);
         }
       }
       const signature = isSignatureDictionary(signatureDict);
       let position = -1, tail = -1;
-      for await (const entry of readPdfDictionaryEntries(node, options.signal)) {
+      for await (const entry of readRawPdfDictionaryEntries(node, options.signal)) {
         const transformed = { key: entry.key, value: signature && entry.key.decoded === "Contents" ? entry.value : await transform(entry.value) };
         if (node.storedEntries) {
           tail = await appendStoredRecord(node.storedEntries.storage, transformed, tail, options.signal);
@@ -31635,27 +31846,27 @@ function* parseXrefRevisionAtSteps(bytes, xrefOffset, maxDecompressedBytes, maxR
       const objNum = startObj + i;
       const field0 = w0 > 0 ? readInt(w0) : 1;
       const field1 = readInt(w1);
-      const field2 = w2 > 0 ? readInt(w2) : 0;
+      const field22 = w2 > 0 ? readInt(w2) : 0;
       if (field0 === 0) {
         entries.set(objNum, {
           type: "free",
           objectNumber: objNum,
           nextFreeObjectNumber: field1,
-          generationNumber: field2
+          generationNumber: field22
         });
       } else if (field0 === 1) {
         entries.set(objNum, {
           type: "uncompressed",
           objectNumber: objNum,
           offset: field1,
-          generationNumber: field2
+          generationNumber: field22
         });
       } else if (field0 === 2) {
         entries.set(objNum, {
           type: "compressed",
           objectNumber: objNum,
           objectStreamNumber: field1,
-          indexInStream: field2
+          indexInStream: field22
         });
       } else {
         throw new PdfError("E_PARSE", `Invalid XRef entry type: ${field0}`);
@@ -33259,13 +33470,19 @@ function embedTrueTypeFontInCos(doc, font, usedGlyphs) {
 }
 
 // packages/pdf-ast/src/fonts/resolve.ts
-function* resolve(node, storeRootArray = false, storeRootDictionary = false) {
-  const value = yield { kind: "resolve", node, storeRootArray, storeRootDictionary };
+function* field(dict, key) {
+  if (!dict.storedEntries) return dictGet(dict, key);
+  const value = yield { kind: "dictionary-value", dict, key };
+  if (value && !("kind" in value)) throw new TypeError("Expected a font dictionary value");
+  return value;
+}
+function* resolve(node, storeRootArray = false, storeRootDictionary = false, arrayPathPrefix) {
+  const value = yield { kind: "resolve", node, storeRootArray, storeRootDictionary, ...arrayPathPrefix ? { arrayPathPrefix } : {} };
   if (value && !("kind" in value)) throw new TypeError("Font lookup returned stream bytes instead of a COS value");
   return value;
 }
-function* resolveDict2(node, backed = false) {
-  const value = yield* resolve(node, false, backed);
+function* resolveDict2(node, backed = false, path) {
+  const value = yield* resolve(node, false, backed, path);
   return value?.kind === "dict" ? value : value?.kind === "stream" ? value.dict : void 0;
 }
 function* resolveArray2(node, backed = false) {
@@ -33296,10 +33513,10 @@ function* resolvePageFontsSteps(rootRef, resourcesDict, selectedName, options =
   const allocationOptions = { onAllocation: (bytes) => allocation.admit(bytes) };
   const fonts = /* @__PURE__ */ new Map();
   const catalog = yield* resolveDict2(rootRef);
-  const acroForm = catalog ? yield* resolveDict2(dictGet(catalog, "AcroForm")) : void 0;
-  const drDict = acroForm ? yield* resolveDict2(dictGet(acroForm, "DR")) : void 0;
-  const drFontDict = drDict ? yield* resolveDict2(dictGet(drDict, "Font"), true) : void 0;
-  const pageFontDict = resourcesDict ? yield* resolveDict2(dictGet(resourcesDict, "Font"), true) : void 0;
+  const acroForm = catalog ? yield* resolveDict2(yield* field(catalog, "AcroForm")) : void 0;
+  const drDict = acroForm ? yield* resolveDict2(yield* field(acroForm, "DR")) : void 0;
+  const drFontDict = drDict ? yield* resolveDict2(yield* field(drDict, "Font"), true) : void 0;
+  const pageFontDict = resourcesDict ? yield* resolveDict2(yield* field(resourcesDict, "Font"), true) : void 0;
   for (const dictionary of [drFontDict, pageFontDict]) {
     if (!dictionary) continue;
     const cursor = new PdfDictionaryCursor(dictionary);
@@ -33310,17 +33527,17 @@ function* resolvePageFontsSteps(rootRef, resourcesDict, selectedName, options =
       const fName = entry.key.decoded;
       if (selectedName !== void 0 && fName !== selectedName)
         continue;
-      const fObj = yield* resolveDict2(entry.value);
+      const fObj = yield* resolveDict2(entry.value, true);
       if (!fObj)
         continue;
       allocation.admit(1024);
-      const subtypeNode = yield* resolve(dictGet(fObj, "Subtype"));
+      const subtypeNode = yield* resolve(yield* field(fObj, "Subtype"));
       const subtype = subtypeNode?.kind === "name" ? subtypeNode.decoded : "Type1";
-      const baseFontNode = yield* resolve(dictGet(fObj, "BaseFont"));
+      const baseFontNode = yield* resolve(yield* field(fObj, "BaseFont"));
       const baseFont = baseFontNode?.kind === "name" ? baseFontNode.decoded : "Helvetica";
       let cmap;
       let storedCMap;
-      const toUniNode = yield* resolve(dictGet(fObj, "ToUnicode"));
+      const toUniNode = yield* resolve(yield* field(fObj, "ToUnicode"));
       if (toUniNode?.kind === "stream") {
         try {
           const value = yield { kind: "decode", stream: toUniNode, purpose: "unicode-cmap" };
@@ -33334,17 +33551,14 @@ function* resolvePageFontsSteps(rootRef, resourcesDict, selectedName, options =
             throw error;
         }
       }
-      const encNode = yield* resolve(dictGet(fObj, "Encoding"));
+      let encNode = yield* resolve(yield* field(fObj, "Encoding"), false, true);
+      let differenceArray;
       if (encNode?.kind === "dict") {
-        const diffRef = dictGet(encNode, "Differences");
-        if (diffRef?.kind === "ref") {
-          const resolvedDiff = yield* resolve(diffRef, true);
-          if (resolvedDiff?.kind === "array") {
-            dictSet(encNode, "Differences", resolvedDiff);
-          }
-        }
+        differenceArray = yield* field(encNode, "Differences");
+        if (differenceArray?.kind === "ref") differenceArray = yield* resolve(differenceArray, true);
+        const baseEncoding = yield* field(encNode, "BaseEncoding");
+        encNode = cosDict({ ...baseEncoding ? { BaseEncoding: baseEncoding } : {}, ...differenceArray ? { Differences: differenceArray } : {} });
       }
-      const differenceArray = encNode?.kind === "dict" ? dictGet(encNode, "Differences") : void 0;
       let storedEncoding;
       if (options.resourceStorage && differenceArray?.kind === "array") {
         const value = yield { kind: "font-encoding", array: differenceArray };
@@ -33370,28 +33584,29 @@ function* resolvePageFontsSteps(rootRef, resourcesDict, selectedName, options =
       let charProcs;
       let fontResources;
       if (subtype === "Type3") {
-        const fmArr = yield* resolveArray2(dictGet(fObj, "FontMatrix"));
-        if (fmArr && fmArr.items.length >= 6) {
-          const mn = function* (idx, fb = 0) {
-            const r = yield* resolve(fmArr.items[idx]);
-            return r?.kind === "number" ? r.value : fb;
-          };
-          fontMatrix = [yield* mn(0, 1e-3), yield* mn(1, 0), yield* mn(2, 0), yield* mn(3, 1e-3), yield* mn(4, 0), yield* mn(5, 0)];
+        const fmArr = yield* resolveArray2(yield* field(fObj, "FontMatrix"), true);
+        if (fmArr && (fmArr.storedItems?.length ?? fmArr.items.length) >= 6) {
+          const cursor2 = arrayCursor(fmArr);
+          fontMatrix = [1e-3, 0, 0, 1e-3, 0, 0];
+          for (let i = 0; i < 6; i++) {
+            const value = yield* resolve(yield* cursor2.next());
+            if (value?.kind === "number") fontMatrix[i] = value.value;
+          }
         } else {
           fontMatrix = [1e-3, 0, 0, 1e-3, 0, 0];
         }
-        charProcs = yield* resolveDict2(dictGet(fObj, "CharProcs"));
-        fontResources = yield* resolveDict2(dictGet(fObj, "Resources"));
+        charProcs = yield* resolveDict2(yield* field(fObj, "CharProcs"), true);
+        fontResources = yield* resolveDict2(yield* field(fObj, "Resources"), false, ["Resources"]);
       }
       const type3Scale1000 = subtype === "Type3" && fontMatrix ? Math.hypot(fontMatrix[0], fontMatrix[1]) * 1e3 : 1;
+      const descendants = subtype === "Type0" ? yield* resolveArray2(yield* field(fObj, "DescendantFonts"), true) : void 0;
+      const cidDict = descendants ? yield* resolveDict2(yield* arrayCursor(descendants).next(), true) : void 0;
       if (subtype === "Type0") {
-        const descArr = yield* resolveArray2(dictGet(fObj, "DescendantFonts"));
-        const cidDict = descArr && descArr.items[0] ? yield* resolveDict2(descArr.items[0]) : void 0;
         if (cidDict) {
-          const dwNode = yield* resolve(dictGet(cidDict, "DW"));
+          const dwNode = yield* resolve(yield* field(cidDict, "DW"));
           if (dwNode?.kind === "number")
             defaultWidth = dwNode.value;
-          const wArr = yield* resolveArray2(dictGet(cidDict, "W"), true);
+          const wArr = yield* resolveArray2(yield* field(cidDict, "W"), true);
           if (wArr) {
             const cursor2 = arrayCursor(wArr);
             while (cursor2.remaining) {
@@ -33417,11 +33632,11 @@ function* resolvePageFontsSteps(rootRef, resourcesDict, selectedName, options =
           }
         }
       } else {
-        const firstCharNode = yield* resolve(dictGet(fObj, "FirstChar"));
-        const widthsArr = yield* resolveArray2(dictGet(fObj, "Widths"), true);
+        const firstCharNode = yield* resolve(yield* field(fObj, "FirstChar"));
+        const widthsArr = yield* resolveArray2(yield* field(fObj, "Widths"), true);
         if (widthsArr) {
-          const descriptor = yield* resolveDict2(dictGet(fObj, "FontDescriptor"));
-          const missingWidth = descriptor ? yield* resolve(dictGet(descriptor, "MissingWidth")) : void 0;
+          const descriptor = yield* resolveDict2(yield* field(fObj, "FontDescriptor"), true);
+          const missingWidth = descriptor ? yield* resolve(yield* field(descriptor, "MissingWidth")) : void 0;
           defaultWidth = (missingWidth?.kind === "number" ? missingWidth.value : 0) * type3Scale1000;
           const firstChar = firstCharNode?.kind === "number" ? firstCharNode.value : 0;
           const cursor2 = arrayCursor(widthsArr);
@@ -33444,13 +33659,11 @@ function* resolvePageFontsSteps(rootRef, resourcesDict, selectedName, options =
       let storedTrueType;
       let embeddedTrueType;
       let simpleToGid;
-      const fDescDirect = yield* resolveDict2(dictGet(fObj, "FontDescriptor"));
-      const descArrForTt = subtype === "Type0" ? yield* resolveArray2(dictGet(fObj, "DescendantFonts")) : void 0;
-      const cidDictForTt = descArrForTt && descArrForTt.items[0] ? yield* resolveDict2(descArrForTt.items[0]) : void 0;
-      const fDesc = fDescDirect ?? (cidDictForTt ? yield* resolveDict2(dictGet(cidDictForTt, "FontDescriptor")) : void 0);
+      const fDescDirect = yield* resolveDict2(yield* field(fObj, "FontDescriptor"), true);
+      const fDesc = fDescDirect ?? (cidDict ? yield* resolveDict2(yield* field(cidDict, "FontDescriptor"), true) : void 0);
       let cidToGid;
       let storedCidToGid;
-      const cidMap = cidDictForTt ? yield* resolve(dictGet(cidDictForTt, "CIDToGIDMap")) : void 0;
+      const cidMap = cidDict ? yield* resolve(yield* field(cidDict, "CIDToGIDMap")) : void 0;
       if (cidMap?.kind === "stream") {
         const bytes = yield { kind: "decode", stream: cidMap, purpose: "cid-map" };
         if (bytes && "byteLength" in bytes && "storage" in bytes) storedCidToGid = bytes;
@@ -33462,15 +33675,15 @@ function* resolvePageFontsSteps(rootRef, resourcesDict, selectedName, options =
         } else throw new TypeError("Font decoder did not return CID map bytes");
       }
       if (fDesc) {
-        const type1Program = yield* resolve(dictGet(fDesc, "FontFile"));
-        const program = (yield* resolve(dictGet(fDesc, "FontFile2"))) ?? (yield* resolve(dictGet(fDesc, "FontFile3"))) ?? type1Program;
+        const type1Program = yield* resolve(yield* field(fDesc, "FontFile"));
+        const program = (yield* resolve(yield* field(fDesc, "FontFile2"))) ?? (yield* resolve(yield* field(fDesc, "FontFile3"))) ?? type1Program;
         if (program?.kind === "stream") {
-          const programType = yield* resolve(dictGet(program.dict, "Subtype"));
-          const baseEncoding = encNode?.kind === "dict" ? yield* resolve(dictGet(encNode, "BaseEncoding")) : encNode;
+          const programType = yield* resolve(yield* field(program.dict, "Subtype"));
+          const baseEncoding = encNode?.kind === "dict" ? yield* resolve(yield* field(encNode, "BaseEncoding")) : encNode;
           if (program === type1Program) {
-            const length1 = yield* resolve(dictGet(program.dict, "Length1"));
-            const length2 = yield* resolve(dictGet(program.dict, "Length2"));
-            const flags = yield* resolve(dictGet(fDesc, "Flags"));
+            const length1 = yield* resolve(yield* field(program.dict, "Length1"));
+            const length2 = yield* resolve(yield* field(program.dict, "Length2"));
+            const flags = yield* resolve(yield* field(fDesc, "Flags"));
             const type1Properties = {
               length1: length1?.kind === "number" ? length1.value : 0,
               length2: length2?.kind === "number" ? length2.value : 0,
@@ -33590,7 +33803,7 @@ function resolvePageFonts(doc, resourcesDict, selectedName) {
   while (!step.done) {
     let value;
     try {
-      if (step.value.kind === "dictionary-entry" || step.value.kind === "font-encoding" || step.value.kind === "font-label" || step.value.kind === "array-item" || step.value.kind === "truetype-map" || step.value.kind === "font-width-set") throw new TypeError("Stored font requires asynchronous evaluation");
+      if (step.value.kind === "dictionary-value" || step.value.kind === "dictionary-entry" || step.value.kind === "font-encoding" || step.value.kind === "font-label" || step.value.kind === "array-item" || step.value.kind === "truetype-map" || step.value.kind === "font-width-set") throw new TypeError("Stored font requires asynchronous evaluation");
       value = step.value.kind === "resolve" ? doc.resolve(step.value.node) : doc.decodeStream(step.value.stream);
     } catch (error) {
       step = steps.throw(error);
@@ -34479,8 +34692,8 @@ var CCITTFaxDecoder = class {
     }
     this.codingPos = codingPos;
   }
-  *_findTableCode(start, end, table, limit10) {
-    const limitValue = limit10 || 0;
+  *_findTableCode(start, end, table, limit11) {
+    const limitValue = limit11 || 0;
     for (let i = start; i <= end; ++i) {
       let code = yield* this._lookBits(i);
       if (code === ccittEOF) {
@@ -35204,7 +35417,7 @@ var StoredJbigIndex = class {
   *set(key, value) {
     const record = yield* StoredJbigList.create(9);
     const fields2 = value instanceof StoredJbigHuffman ? [2, value.nodes.length, value.nodes.capacity, value.nodes.buffer.position, value.nodes.buffer.length] : value instanceof StoredJbigList ? [0, value.length, value.capacity, value.buffer.position, value.buffer.length] : [1, value.width, value.height, value.length, value.bitmap.position, value.bitmap.length, value.bitmap.rowSize, value.bitmap.width, value.bitmap.height];
-    for (const field2 of fields2) yield* record.push(field2);
+    for (const field3 of fields2) yield* record.push(field3);
     const slot = yield* this.find(key, true);
     yield { kind: "number-write", ...slot, value: record.buffer.position + 1 };
   }
@@ -38151,7 +38364,7 @@ var JpxImage = class {
       } };
       const tile = yield* this.parseCodestreamTileSteps(data, start, end, selected);
       const values = [tile.left, tile.top, tile.width, tile.height, tile.items.position, tile.items.length];
-      for (let field2 = 0; field2 < 6; field2++) yield* jpxVectorWrite(records2, number * 6 + field2, values[field2]);
+      for (let field3 = 0; field3 < 6; field3++) yield* jpxVectorWrite(records2, number * 6 + field3, values[field3]);
     }
     this.storedTiles = { length: count, records: records2 };
   }
@@ -38633,8 +38846,8 @@ function* buildCodeblocks(context, subband, dimensions) {
       if (context.storedPlanes) {
         codeblock.record = codeblocks.records;
         codeblock.recordIndex = codeblocks.length++;
-        for (let field2 = 0; field2 < jpxCodeblockGeometry.length; field2++) {
-          yield* jpxVectorWrite(codeblock.record, codeblock.recordIndex * 18 + field2, codeblock[jpxCodeblockGeometry[field2]]);
+        for (let field3 = 0; field3 < jpxCodeblockGeometry.length; field3++) {
+          yield* jpxVectorWrite(codeblock.record, codeblock.recordIndex * 18 + field3, codeblock[jpxCodeblockGeometry[field3]]);
         }
         yield* writeJpxCodeblock(codeblock);
       } else codeblocks.push(codeblock);
@@ -38688,8 +38901,8 @@ function* writeJpxPrecinct(precinct) {
     precinct.zeroBitPlanesTree ? precinct.zeroBitPlanesTree.root.position + 1 : 0,
     precinct.zeroBitPlanesTree ? precinct.zeroBitPlanesTree.presence.position + 1 : 0
   ];
-  for (let field2 = 0; field2 < values.length; field2++) {
-    yield* jpxVectorWrite(collection.records, precinct.number * 8 + field2, values[field2]);
+  for (let field3 = 0; field3 < values.length; field3++) {
+    yield* jpxVectorWrite(collection.records, precinct.number * 8 + field3, values[field3]);
   }
   collection.cached = precinct;
 }
@@ -38698,7 +38911,7 @@ function* readJpxPrecinct(collection, number) {
   if (collection.cached?.number === number) return collection.cached;
   if (!(yield* jpxVectorRead(collection.records, number * 8))) return void 0;
   const values = [];
-  for (let field2 = 1; field2 < 8; field2++) values.push(yield* jpxVectorRead(collection.records, number * 8 + field2));
+  for (let field3 = 1; field3 < 8; field3++) values.push(yield* jpxVectorRead(collection.records, number * 8 + field3));
   const precinct = { collection, number, cbxMin: values[0], cbyMin: values[1], cbxMax: values[2], cbyMax: values[3] };
   if (values[4]) {
     const width = precinct.cbxMax - precinct.cbxMin + 1, height = precinct.cbyMax - precinct.cbyMin + 1;
@@ -38727,8 +38940,8 @@ function* writeJpxCodeblock(block) {
     data?.totalLength ?? 0,
     data?.codingpasses ?? 0
   ];
-  for (let field2 = 0; field2 < values.length; field2++) {
-    yield* jpxVectorWrite(block.record, block.recordIndex * 18 + 7 + field2, values[field2]);
+  for (let field3 = 0; field3 < values.length; field3++) {
+    yield* jpxVectorWrite(block.record, block.recordIndex * 18 + 7 + field3, values[field3]);
   }
 }
 function* readJpxCodeblock(subband, index2, withPrecinct = true) {
@@ -38736,8 +38949,8 @@ function* readJpxCodeblock(subband, index2, withPrecinct = true) {
   if (!blocks.records) return blocks[index2];
   const block = { record: blocks.records, recordIndex: index2, subbandType: subband.type };
   const values = [];
-  for (let field2 = 0; field2 < 18; field2++) values.push(yield* jpxVectorRead(blocks.records, index2 * 18 + field2));
-  for (let field2 = 0; field2 < jpxCodeblockGeometry.length; field2++) block[jpxCodeblockGeometry[field2]] = values[field2];
+  for (let field3 = 0; field3 < 18; field3++) values.push(yield* jpxVectorRead(blocks.records, index2 * 18 + field3));
+  for (let field3 = 0; field3 < jpxCodeblockGeometry.length; field3++) block[jpxCodeblockGeometry[field3]] = values[field3];
   if (withPrecinct) block.precinct = yield* readJpxPrecinct(subband.precincts, block.precinctNumber);
   block.Lblock = values[7];
   if (values[8]) block.included = true;
@@ -39051,12 +39264,12 @@ var jpxSubbandFields = ["tbx0", "tby0", "tbx1", "tby1"];
 var jpxBlockFields = ["codeblockWidth", "codeblockHeight", "numcodeblockwide", "numcodeblockhigh"];
 var jpxSubbandTypes = ["LL", "HL", "LH", "HH"];
 function* writeJpxResolution(collection, resolution) {
-  const values = jpxResolutionFields.map((field2) => resolution[field2]);
-  values.push(...jpxPrecinctFields.map((field2) => resolution.precinctParameters[field2]), resolution.subbands.length);
+  const values = jpxResolutionFields.map((field3) => resolution[field3]);
+  values.push(...jpxPrecinctFields.map((field3) => resolution.precinctParameters[field3]), resolution.subbands.length);
   for (const band of resolution.subbands) values.push(
     jpxSubbandTypes.indexOf(band.type),
-    ...jpxSubbandFields.map((field2) => band[field2]),
-    ...jpxBlockFields.map((field2) => band.codeblockParameters[field2]),
+    ...jpxSubbandFields.map((field3) => band[field3]),
+    ...jpxBlockFields.map((field3) => band.codeblockParameters[field3]),
     band.codeblocks.length,
     band.codeblocks.records.position,
     band.codeblocks.records.length,
@@ -39081,13 +39294,13 @@ function* readJpxResolution(collection, index2) {
     return yield* jpxVectorRead(collection.records, offset++);
   };
   const resolution = { onAllocation: context.onAllocation, packetAdmission: 128, precinctParameters: {}, subbands: [] };
-  for (const field2 of jpxResolutionFields) resolution[field2] = yield* read();
-  for (const field2 of jpxPrecinctFields) resolution.precinctParameters[field2] = yield* read();
+  for (const field3 of jpxResolutionFields) resolution[field3] = yield* read();
+  for (const field3 of jpxPrecinctFields) resolution.precinctParameters[field3] = yield* read();
   const count = yield* read();
   for (let i = 0; i < count; i++) {
     const band = { type: jpxSubbandTypes[yield* read()], resolution, codeblockParameters: {} };
-    for (const field2 of jpxSubbandFields) band[field2] = yield* read();
-    for (const field2 of jpxBlockFields) band.codeblockParameters[field2] = yield* read();
+    for (const field3 of jpxSubbandFields) band[field3] = yield* read();
+    for (const field3 of jpxBlockFields) band.codeblockParameters[field3] = yield* read();
     band.codeblocks = { length: yield* read(), records: { position: yield* read(), length: yield* read(), bytesPerElement: 8, integer: false } };
     band.precincts = { records: { position: yield* read(), length: yield* read(), bytesPerElement: 8, integer: false }, admission: entry.trees[i] };
     resolution.subbands.push(band);
@@ -40622,8 +40835,8 @@ function* looksLikePostEiContentStream(size, posAfterEi) {
   let p = posAfterEi;
   while (p < size && isPdfWhitespace(yield* byte2(p))) p++;
   if (p >= size) return true;
-  const limit10 = Math.min(size, p + 16);
-  for (let i = p; i < limit10; i++) {
+  const limit11 = Math.min(size, p + 16);
+  for (let i = p; i < limit11; i++) {
     const b = yield* byte2(i);
     if (b === 40 || b === 60 || b === 37) break;
     if (!isPdfWhitespace(b) && (b < 32 || b > 126)) {
@@ -41188,6 +41401,11 @@ function* resolveColorSpaceInfoSteps(doc, node, resources) {
         case "resolve":
           result = doc.resolve(request.node);
           break;
+        case "resource": {
+          const map = doc.resolveDict(dictGet(request.resources, request.category));
+          result = map ? dictGet(map, request.name) : void 0;
+          break;
+        }
         case "palette":
           result = request.node.kind === "stream" ? doc.decodeStream(request.node) : request.node.bytes;
           break;
@@ -41228,9 +41446,7 @@ function* imageColorSpaceProgram(csNode, resourcesDict, maxDepth = Infinity, dep
     if (name === "DeviceRGB" || name === "RGB" || name === "CalRGB") {
       return { colorSpace: "rgb", colorSpaceLabel: name === "CalRGB" ? "cal-rgb" : "rgb", components: 3 };
     }
-    const csResources = resourcesDict ? yield { kind: "resolve", node: dictGet(resourcesDict, "ColorSpace") } : void 0;
-    const csResDict = csResources?.kind === "dict" ? csResources : void 0;
-    const mapped = csResDict ? dictGet(csResDict, name) : void 0;
+    const mapped = resourcesDict ? yield { kind: "resource", resources: resourcesDict, category: "ColorSpace", name } : void 0;
     if (mapped) {
       return yield* imageColorSpaceProgram(mapped, resourcesDict, maxDepth, depth + 1);
     }
@@ -42555,8 +42771,12 @@ function* runColorProgramSteps(doc, work, sources) {
     let step = work.next();
     while (!step.done) {
       const request = step.value;
-      if (request.kind === "resolve") step = work.next(doc?.resolve(request.node));
-      else {
+      if (request.kind === "dictionary-value") step = work.next(dictGet(request.dict, request.key));
+      else if (request.kind === "resolve") step = work.next(doc?.resolve(request.node));
+      else if (request.kind === "resource") {
+        const map = doc?.resolveDict(dictGet(request.resources, request.category));
+        step = work.next(map ? dictGet(map, request.name) : void 0);
+      } else {
         if (!doc) throw new PdfError("E_CAPABILITY", "PDF resource color requires a source driver");
         if (request.kind === "decode") {
           const bytes = doc.decodeStream(request.stream);
@@ -42581,8 +42801,7 @@ function* colorComponentCountSteps(hasDocument, csNode, activeResources, depth =
     if (name === "DeviceCMYK" || name === "CMYK") return 4;
     if (name === "DeviceRGB" || name === "RGB" || name === "CalRGB" || name === "Lab") return 3;
     if (hasDocument && activeResources) {
-      const csDict = yield* resolveColorNode(dictGet(activeResources, "ColorSpace"), "dict");
-      const mapped = csDict ? dictGet(csDict, name) : void 0;
+      const mapped = yield { kind: "resource", resources: activeResources, category: "ColorSpace", name };
       if (mapped) return yield* colorComponentCountSteps(hasDocument, mapped, activeResources, depth + 1);
     }
     return 3;
@@ -42613,8 +42832,7 @@ function* convertContentColorSteps(hasDocument, csNode, csNameFallback, comps, a
   if ((!resolved || resolved.kind === "name") && hasDocument && activeResources) {
     const lookupName = resolved?.kind === "name" ? resolved.decoded : csNameFallback;
     if (lookupName && lookupName !== "DeviceRGB" && lookupName !== "RGB" && lookupName !== "DeviceGray" && lookupName !== "G" && lookupName !== "DeviceCMYK" && lookupName !== "CMYK") {
-      const csDict = yield* resolveColorNode(dictGet(activeResources, "ColorSpace"), "dict");
-      const mapped = csDict ? dictGet(csDict, lookupName) : void 0;
+      const mapped = yield { kind: "resource", resources: activeResources, category: "ColorSpace", name: lookupName };
       if (mapped) {
         resolved = yield* resolveColorNode(mapped);
       }
@@ -42996,20 +43214,20 @@ function isOptionalContentVisible(doc, ocNode) {
   }
   return step.value;
 }
-function* resolveEvaluationNode(node, storeRootArray = false, arrayPathPrefix) {
+function* resolveEvaluationNode(node, storeRootArray = false, arrayPathPrefix, storeRootDictionary = false) {
   if (!node) return void 0;
-  const result = yield { kind: "resolve", node, ...storeRootArray ? { storeRootArray } : {}, ...arrayPathPrefix ? { arrayPathPrefix } : {} };
+  const result = yield { kind: "resolve", node, ...storeRootDictionary ? { storeRootDictionary } : {}, ...storeRootArray ? { storeRootArray } : {}, ...arrayPathPrefix ? { arrayPathPrefix } : {} };
   if (!result || !("kind" in result) || result.kind !== "resolved") throw new TypeError("Expected a resolved PDF object");
   return result.node;
 }
-function* resolveEvaluationDict(node, arrayPathPrefix) {
-  const resolved = yield* resolveEvaluationNode(node, false, arrayPathPrefix);
+function* resolveEvaluationDict(node, arrayPathPrefix, storeRootDictionary = false) {
+  const resolved = yield* resolveEvaluationNode(node, false, arrayPathPrefix, storeRootDictionary);
   return resolved?.kind === "dict" ? resolved : resolved?.kind === "stream" ? resolved.dict : void 0;
 }
-function* lookupEvaluationDictionary(dict, key) {
+function* lookupEvaluationDictionary(dict, key, preserveDeferred = false) {
   if (!dict) return void 0;
   if (!dict.storedEntries) return dictGet(dict, key);
-  const result = yield { kind: "dictionary-value", dict, key };
+  const result = yield { kind: "dictionary-value", dict, key, ...preserveDeferred ? { preserveDeferred } : {} };
   if (!result || !("kind" in result) || result.kind !== "resolved") throw new TypeError("Expected a PDF dictionary value");
   return result.node;
 }
@@ -43017,6 +43235,23 @@ function* resolveEvaluationArray(node, storeRootArray = false, arrayPathPrefix)
   const resolved = yield* resolveEvaluationNode(node, storeRootArray, arrayPathPrefix);
   return resolved?.kind === "array" ? resolved : void 0;
 }
+function* evaluationArrayPrefix(array, count) {
+  if (!array.storedItems) return array.items.slice(0, count);
+  const items = array.storedItems;
+  if (!Number.isSafeInteger(items.length) || items.length < 0) throw new RangeError("Invalid stored array length");
+  const prefix = [];
+  let position = items.position;
+  for (let i = 0; i < Math.min(count, items.length); i++) {
+    const reply = yield { kind: "array-item", items, position };
+    if (!reply || !("kind" in reply) || reply.kind !== "resolved" || reply.node?.kind !== "array") throw new TypeError("Expected stored array item");
+    const [next, value] = reply.node.items;
+    if (next?.kind !== "number" || !value) throw new TypeError("Expected stored array record");
+    position = next.value;
+    prefix.push(value);
+  }
+  if (items.length <= count && position !== -1) throw new PdfError("E_PARSE", "Invalid stored array terminator");
+  return prefix;
+}
 function* visitEvaluationArray(array, visit) {
   if (!array.storedItems) {
     for (const item of array.items) yield* visit(item);
@@ -43115,7 +43350,7 @@ function* evaluateMaskTransferSteps(doc, transfer, sources) {
 function* resolveMaskParameterSteps(mask, form, activeResources) {
   const group = yield* resolveColorNode(dictGet(form.dict, "Group"), "dict");
   const colorSpace = group ? dictGet(group, "CS") : void 0;
-  const bc = yield* resolveColorNode(dictGet(mask, "BC"), "array");
+  const bc = yield* resolveColorNode(yield { kind: "dictionary-value", dict: mask, key: "BC" }, "array");
   let components;
   if (bc) {
     components = [];
@@ -43125,7 +43360,7 @@ function* resolveMaskParameterSteps(mask, form, activeResources) {
     }
   }
   const [r, g, b] = components ? yield* convertContentColorSteps(true, colorSpace, "DeviceRGB", components, activeResources) : [0, 0, 0];
-  const transfer = yield* resolveColorNode(dictGet(mask, "TR"));
+  const transfer = yield* resolveColorNode(yield { kind: "dictionary-value", dict: mask, key: "TR" });
   const transferMap = transfer?.kind === "dict" || transfer?.kind === "stream" ? yield { kind: "transfer", node: transfer } : void 0;
   return { backdrop: { r, g, b }, transferMap };
 }
@@ -43461,8 +43696,8 @@ function* evaluateContentSteps(params) {
         st.dashPhase = void 0;
       }
     } else if (operator === "sh" && activeResources && ops[0]?.kind === "name") {
-      const shMap = yield* resolveEvaluationDict(dictGet(activeResources, "Shading"));
-      const shNode = shMap ? yield* resolveEvaluationNode(dictGet(shMap, ops[0].decoded)) : void 0;
+      const shMap = yield* resolveEvaluationDict(dictGet(activeResources, "Shading"), ["Resources", "Shading"]);
+      const shNode = shMap ? yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(shMap, ops[0].decoded)) : void 0;
       const shDict = shNode?.kind === "dict" ? shNode : shNode?.kind === "stream" ? shNode.dict : void 0;
       const shStream = shNode?.kind === "stream" ? shNode : void 0;
       if (shDict) {
@@ -43513,15 +43748,15 @@ function* evaluateContentSteps(params) {
     } else if (operator === "K") {
       st.strokeColor = yield* resolveScColorOperands("DeviceCMYK", ops, activeResources);
     } else if (operator === "gs" && activeResources && ops[0]?.kind === "name") {
-      const extDict = yield* resolveEvaluationDict(dictGet(activeResources, "ExtGState"), ["ExtGState"]);
-      const gsDict = extDict ? yield* resolveEvaluationDict(dictGet(extDict, ops[0].decoded), ["ExtGState", ops[0].decoded]) : void 0;
+      const extDict = yield* resolveEvaluationDict(dictGet(activeResources, "ExtGState"), ["Resources", "ExtGState"]);
+      const gsDict = extDict ? yield* resolveEvaluationDict(yield* lookupEvaluationDictionary(extDict, ops[0].decoded, true), ["Resources", "ExtGState", ops[0].decoded], true) : void 0;
       if (gsDict) {
-        const mask = yield* resolveEvaluationNode(dictGet(gsDict, "SMask"));
+        const mask = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "SMask", true), false, void 0, true);
         if (mask?.kind === "name" && mask.decoded === "None") {
           st.softMask = void 0;
         } else if (mask?.kind === "dict") {
-          const subtype = yield* resolveEvaluationNode(dictGet(mask, "S"));
-          const form = yield* resolveEvaluationNode(dictGet(mask, "G"));
+          const subtype = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(mask, "S"));
+          const form = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(mask, "G"));
           if (form?.kind === "stream" && subtype?.kind === "name" && (subtype.decoded === "Alpha" || subtype.decoded === "Luminosity")) {
             if (depth >= 8) throw new PdfError("E_LIMIT", "Soft-mask nesting exceeds the form depth limit");
             const parentOperations = capturedOperations;
@@ -43549,48 +43784,36 @@ function* evaluateContentSteps(params) {
             st.softMask = { subtype: subtype.decoded, operations: captured instanceof StoredOperationsWriter ? [] : captured, ...captured instanceof StoredOperationsWriter ? { storedOperations: captured.snapshot() } : {}, ...parameters.value };
           }
         }
-        const bmNode = yield* resolveEvaluationNode(dictGet(gsDict, "BM"));
+        const bmNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "BM", true), true);
         if (bmNode?.kind === "name") {
           st.blendMode = bmNode.decoded === "Compatible" ? "Normal" : bmNode.decoded;
-        } else if (bmNode?.kind === "array" && bmNode.items.length > 0) {
-          const firstBm = yield* resolveEvaluationNode(bmNode.items[0]);
+        } else if (bmNode?.kind === "array" && (bmNode.storedItems?.length ?? bmNode.items.length) > 0) {
+          const firstBm = yield* resolveEvaluationNode((yield* evaluationArrayPrefix(bmNode, 1))[0]);
           if (firstBm?.kind === "name") {
             st.blendMode = firstBm.decoded === "Compatible" ? "Normal" : firstBm.decoded;
           }
         }
-        const caNode = yield* resolveEvaluationNode(dictGet(gsDict, "ca"));
+        const caNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "ca", true), true);
         if (caNode?.kind === "number") st.fillAlpha = Math.max(0, Math.min(1, caNode.value));
-        const CANode = yield* resolveEvaluationNode(dictGet(gsDict, "CA"));
+        const CANode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "CA", true), true);
         if (CANode?.kind === "number") st.strokeAlpha = Math.max(0, Math.min(1, CANode.value));
-        const lwNode = yield* resolveEvaluationNode(dictGet(gsDict, "LW"));
+        const lwNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "LW", true), true);
         if (lwNode?.kind === "number") st.strokeWidth = Math.max(0, lwNode.value);
-        const lcNode = yield* resolveEvaluationNode(dictGet(gsDict, "LC"));
+        const lcNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "LC", true), true);
         if (lcNode?.kind === "number" && (lcNode.value === 0 || lcNode.value === 1 || lcNode.value === 2)) {
           st.lineCap = lcNode.value;
         }
-        const ljNode = yield* resolveEvaluationNode(dictGet(gsDict, "LJ"));
+        const ljNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "LJ", true), true);
         if (ljNode?.kind === "number" && (ljNode.value === 0 || ljNode.value === 1 || ljNode.value === 2)) {
           st.lineJoin = ljNode.value;
         }
-        const mlNode = yield* resolveEvaluationNode(dictGet(gsDict, "ML"));
+        const mlNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "ML", true), true);
         if (mlNode?.kind === "number" && mlNode.value > 0) {
           st.miterLimit = mlNode.value;
         }
-        const dArr = yield* resolveEvaluationArray(dictGet(gsDict, "D"), true);
+        const dArr = yield* resolveEvaluationArray(yield* lookupEvaluationDictionary(gsDict, "D", true), true);
         if (dArr && (dArr.storedItems?.length ?? dArr.items.length) >= 2) {
-          let pair = dArr.items;
-          if (dArr.storedItems) {
-            pair = [];
-            let position = dArr.storedItems.position;
-            for (let i = 0; i < 2; i++) {
-              const reply = yield { kind: "array-item", items: dArr.storedItems, position };
-              if (!reply || !("kind" in reply) || reply.kind !== "resolved" || reply.node?.kind !== "array") throw new TypeError("Expected dash state record");
-              const [next, value] = reply.node.items;
-              if (next?.kind !== "number" || !value) throw new TypeError("Expected dash state value");
-              position = next.value;
-              pair.push(value);
-            }
-          }
+          const pair = yield* evaluationArrayPrefix(dArr, 2);
           const patArr = yield* resolveEvaluationArray(pair[0], true);
           const phaseNode = yield* resolveEvaluationNode(pair[1]);
           if (patArr && params.geometryStorage) {
@@ -43611,9 +43834,10 @@ function* evaluateContentSteps(params) {
             st.dashPhase = phaseNode?.kind === "number" ? phaseNode.value : 0;
           }
         }
-        const fontArr = yield* resolveEvaluationArray(dictGet(gsDict, "Font"));
-        if (fontArr && fontArr.items.length >= 2) {
-          const fSizeNode = yield* resolveEvaluationNode(fontArr.items[1]);
+        const fontArr = yield* resolveEvaluationArray(yield* lookupEvaluationDictionary(gsDict, "Font", true), true);
+        if (fontArr && (fontArr.storedItems?.length ?? fontArr.items.length) >= 2) {
+          const pair = yield* evaluationArrayPrefix(fontArr, 2);
+          const fSizeNode = yield* resolveEvaluationNode(pair[1]);
           if (fSizeNode?.kind === "number") st.fontSize = fSizeNode.value;
           const gsFontKey = `__ExtGS_Font_${ops[0].decoded}`;
           const gsFontResources = {
@@ -43626,7 +43850,7 @@ function* evaluateContentSteps(params) {
                   entries: [
                     {
                       key: { kind: "name", decoded: gsFontKey, rawBytes: new Uint8Array(0) },
-                      value: fontArr.items[0]
+                      value: pair[0]
                     }
                   ]
                 }
@@ -43665,8 +43889,8 @@ function* evaluateContentSteps(params) {
     const st = curState();
     if (!st.fillPatternName || !resources) return false;
     if (depth >= 8) throw new PdfError("E_LIMIT", "Pattern nesting exceeds the form depth limit");
-    const patterns = yield* resolveEvaluationDict(dictGet(resources, "Pattern"));
-    const pattern = patterns && (yield* resolveEvaluationNode(dictGet(patterns, st.fillPatternName)));
+    const patterns = yield* resolveEvaluationDict(dictGet(resources, "Pattern"), ["Resources", "Pattern"]);
+    const pattern = patterns && (yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(patterns, st.fillPatternName)));
     const dict = pattern?.kind === "stream" ? pattern.dict : pattern?.kind === "dict" ? pattern : void 0;
     if (!dict) return false;
     const nums = function* (key, fallback) {
@@ -43749,7 +43973,7 @@ function* evaluateContentSteps(params) {
       const iy1 = Math.ceil((Math.max(...corners.map((p) => p[1])) - box[1]) / yStep) - 1;
       if ((ix1 - ix0 + 1) * (iy1 - iy0 + 1) > 2e4) throw new PdfError("E_LIMIT", "Pattern tile count exceeds 20000");
       const nodes = { stream: pattern };
-      const patternResources = (yield* resolveEvaluationDict(dictGet(dict, "Resources"))) ?? resources;
+      const patternResources = (yield* resolveEvaluationDict(dictGet(dict, "Resources"), ["Resources"])) ?? resources;
       const patternFonts = [patternResources, ...activeFonts];
       for (let iy = iy0; iy <= iy1; iy++) {
         for (let ix = ix0; ix <= ix1; ix++) {
@@ -43783,7 +44007,7 @@ function* evaluateContentSteps(params) {
     const isolated = isolation?.kind === "boolean" && isolation.value;
     const compositeGroup = !maskGroup && groupType?.kind === "name" && groupType.decoded === "Transparency" && (isolated || st.fillAlpha !== 1 || !!st.softMask || !!st.blendMode && st.blendMode !== "Normal" && st.blendMode !== "Compatible");
     const formNodes = { stream: form };
-    const formResDict = (yield* resolveEvaluationDict(dictGet(form.dict, "Resources"))) ?? activeResources;
+    const formResDict = (yield* resolveEvaluationDict(dictGet(form.dict, "Resources"), ["Resources"])) ?? activeResources;
     const formFonts = [formResDict, ...activeFonts];
     let nextCtm = [...st.ctm];
     const matArr = yield* resolveEvaluationArray(dictGet(form.dict, "Matrix"));
@@ -43860,7 +44084,7 @@ 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"), ["Properties"]);
+      const propsMap = yield* resolveEvaluationDict(dictGet(activeResources, "Properties"), ["Resources", "Properties"]);
       const propRefOrNode = yield* lookupEvaluationDictionary(propsMap, node.properties);
       if (propRefOrNode) {
         const propDict = yield* resolveEvaluationDict(propRefOrNode);
@@ -44044,7 +44268,7 @@ function* evaluateContentSteps(params) {
           case "xobject": {
             const st = curState();
             if (activeResources) {
-              const xobjDict = yield* resolveEvaluationDict(dictGet(activeResources, "XObject"), ["XObject"]);
+              const xobjDict = yield* resolveEvaluationDict(dictGet(activeResources, "XObject"), ["Resources", "XObject"]);
               const xobjNode = xobjDict ? yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(xobjDict, node.name)) : void 0;
               if (xobjNode?.kind === "stream") {
                 if (!(yield* optionalContentVisibilitySteps(dictGet(xobjNode.dict, "OC")))) {
@@ -44146,7 +44370,7 @@ function* evaluateContentSteps(params) {
                     explicitName = reply.node?.kind === "name" ? reply.node.decoded : void 0;
                   }
                   const gName = explicitName ?? item.unicode;
-                  const procNode = gName ? yield* resolveEvaluationNode(dictGet(font.charProcs, gName)) : void 0;
+                  const procNode = gName ? yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(font.charProcs, gName)) : void 0;
                   if (procNode?.kind === "stream") {
                     const fm = font.fontMatrix ?? [1e-3, 0, 0, 1e-3, 0, 0];
                     const source2 = { stream: procNode };
@@ -44635,10 +44859,10 @@ function* visible(node) {
 function* preparePageAppearanceSteps(pageDict, pageRes, evalResourcesDict, hideAnnotations = false, onAllocation) {
   onAllocation?.(64 * pageRes.entries.length);
   for (const entry of pageRes.entries) {
-    const sub = yield* resolveDict3(entry.value, [entry.key.decoded]);
+    const sub = yield* resolveDict3(entry.value, ["Resources", entry.key.decoded]);
     if (sub) {
       onAllocation?.(64 + sub.entries.length * 64);
-      const shareBacking = entry.key.decoded === "XObject" || entry.key.decoded === "Properties";
+      const shareBacking = entry.key.decoded !== "Font";
       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);
@@ -44682,12 +44906,12 @@ function* preparePageAppearanceSteps(pageDict, pageRes, evalResourcesDict, hideA
         if (hasContent === true) {
           onAllocation?.(2048);
           renderedApStream = true;
-          const apRes = yield* resolveDict3(dictGet(apN.dict, "Resources"));
+          const apRes = yield* resolveDict3(dictGet(apN.dict, "Resources"), ["Resources"]);
           if (apRes) {
             for (const subKey of ["Font", "XObject", "ExtGState", "ColorSpace", "Pattern", "Shading"]) {
-              const srcSub = yield* resolveDict3(dictGet(apRes, subKey), [subKey]);
+              const srcSub = yield* resolveDict3(dictGet(apRes, subKey), ["Resources", subKey]);
               if (!srcSub) continue;
-              let dstSub = yield* resolveDict3(dictGet(evalResourcesDict, subKey), [subKey]);
+              let dstSub = yield* resolveDict3(dictGet(evalResourcesDict, subKey), ["Resources", subKey]);
               if (!dstSub) {
                 onAllocation?.(64);
                 dstSub = cosDict({});
@@ -48314,24 +48538,13 @@ function* svgImageSteps(image, pageHeight) {
 }
 function* svgPathDataSteps(segments, height, matrix2) {
   let work = 0;
-  const dParts = [];
-  const point = (x, y) => matrix2 ? `${matrix2[0] * x + matrix2[2] * y + matrix2[4]} ${height - matrix2[1] * x - matrix2[3] * y - matrix2[5]}` : `${x} ${height - y}`;
-  for (const seg of segments) {
+  const parts = [];
+  for (const segment of segments) {
     if (++work % 16384 === 0) yield;
-    if (seg.kind === "move") {
-      dParts.push(`M ${point(seg.x, seg.y)}`);
-    } else if (seg.kind === "line") {
-      dParts.push(`L ${point(seg.x, seg.y)}`);
-    } else if (seg.kind === "cubic") {
-      dParts.push(`C ${point(seg.x1, seg.y1)} ${point(seg.x2, seg.y2)} ${point(seg.x, seg.y)}`);
-    } else if (seg.kind === "rect") {
-      if (matrix2) dParts.push(`M ${point(seg.x, seg.y)} L ${point(seg.x + seg.width, seg.y)} L ${point(seg.x + seg.width, seg.y + seg.height)} L ${point(seg.x, seg.y + seg.height)} Z`);
-      else dParts.push(`M ${seg.x} ${height - seg.y} h ${seg.width} v ${-seg.height} h ${-seg.width} Z`);
-    } else if (seg.kind === "close") {
-      dParts.push("Z");
-    }
+    const part = svgPathSegment(segment, height, matrix2);
+    if (part !== void 0) parts.push(part);
   }
-  return dParts.join(" ");
+  return parts.join(" ");
 }
 function* renderDisplayListToSvgSteps(displayList, options = {}) {
   const baseScale = options.scale ?? (options.dpi ? options.dpi / 72 : 1);
@@ -48641,6 +48854,139 @@ function renderPdfPageToPng(pdfBytes, pageIndex = 0, options) {
   while (!next.done) next = steps.next();
   return next.value;
 }
+async function* encodeSvgPathPaintChunks(original, pageHeight, options = {}) {
+  const { signal } = options;
+  signal?.throwIfAborted();
+  const chunkBytes = options.chunkBytes ?? 16384, maximum10 = options.maxOutputBytes ?? Infinity, scale = options.scale ?? 1;
+  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid SVG paint chunk size");
+  for (const value of [maximum10, options.maxSegments ?? Infinity, options.maxDashEntries ?? Infinity]) if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) throw new RangeError("Invalid SVG paint limit");
+  if (!Number.isFinite(scale) || scale <= 0) throw new RangeError("Invalid SVG paint scale");
+  if (original.kind === "glyph" && (original.value.renderMode === 3 || !original.value.outline && !original.value.unicode.trim())) return;
+  const p = original.kind === "glyph" ? glyphPaint(original.value) : original.value;
+  const segmentCount = p.storedSegments?.count ?? p.segments.length, dashCount = p.storedDash?.length ?? p.dashArray?.length ?? 0;
+  if (!Number.isSafeInteger(segmentCount) || segmentCount < 0 || !Number.isSafeInteger(dashCount) || dashCount < 0) throw new RangeError("Invalid SVG paint record count");
+  if (segmentCount > (options.maxSegments ?? Infinity) || dashCount > (options.maxDashEntries ?? Infinity)) throw new PdfError("E_LIMIT", "SVG paint record limit exceeded");
+  if (!segmentCount) return;
+  let emitted = 0, work = 0;
+  const encoder = new TextEncoder();
+  function* bytes(bytes2) {
+    if (bytes2.length > maximum10 - emitted || !Number.isSafeInteger(emitted + bytes2.length)) throw new PdfError("E_LIMIT", "SVG paint output byte limit exceeded");
+    emitted += bytes2.length;
+    for (let at = 0; at < bytes2.length; at += chunkBytes) {
+      signal?.throwIfAborted();
+      yield bytes2.slice(at, at + chunkBytes);
+    }
+  }
+  function* text(value) {
+    for (let at = 0; at < value.length; ) {
+      let end = Math.min(at + 2048, value.length);
+      if (end < value.length && value.charCodeAt(end - 1) >= 55296 && value.charCodeAt(end - 1) <= 56319) end--;
+      yield* bytes(encoder.encode(value.slice(at, end)));
+      at = end;
+    }
+  }
+  async function checkpoint() {
+    signal?.throwIfAborted();
+    if (++work % 64 === 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      signal?.throwIfAborted();
+    }
+  }
+  async function* dashes(factor) {
+    if (!p.storedDash) {
+      for (const value of p.dashArray ?? []) {
+        await checkpoint();
+        yield value * factor;
+      }
+      return;
+    }
+    const source = p.storedDash;
+    if (!Number.isSafeInteger(source.position) || source.position < 0 || !Number.isSafeInteger(source.position + dashCount * 8)) throw new RangeError("Invalid SVG dash position");
+    for (let at = 0; at < dashCount; at += 512) {
+      await checkpoint();
+      const length = Math.min(512, dashCount - at) * 8, data = (await source.storage.read(source.position + at * 8, length, signal ? { signal } : void 0)).slice();
+      if (data.length !== length) throw new Error("Incomplete SVG dash pattern");
+      const view = new DataView(data.buffer, data.byteOffset, data.length);
+      for (let i = 0; i < length; i += 8) {
+        await checkpoint();
+        yield view.getFloat64(i, true) * factor;
+      }
+    }
+  }
+  const prepared = p.strokeColor ? prepareStroke(p, scale) : void 0;
+  let outlineStroke = false;
+  if (prepared) for await (const value of dashes(1)) {
+    if (value === 0) {
+      outlineStroke = true;
+      break;
+    }
+  }
+  const matrix2 = prepared && (prepared.matrix[0] !== 1 || prepared.matrix[1] !== 0 || prepared.matrix[2] !== 0 || prepared.matrix[3] !== 1) ? prepared.matrix : void 0, inverse = matrix2 ? inverseStrokeMatrix(matrix2) : void 0;
+  const transform = inverse && matrix2 ? ` transform="matrix(${matrix2[0]} ${-matrix2[1]} ${-matrix2[2]} ${matrix2[3]} ${matrix2[4]} ${pageHeight - matrix2[5]})"` : "";
+  const fill = p.fillColor ? `rgb(${Math.round(p.fillColor.r * 255)},${Math.round(p.fillColor.g * 255)},${Math.round(p.fillColor.b * 255)})` : "none", stroke = p.strokeColor && prepared ? `rgb(${Math.round(p.strokeColor.r * 255)},${Math.round(p.strokeColor.g * 255)},${Math.round(p.strokeColor.b * 255)})` : "none";
+  const label = original.kind === "glyph" ? ` aria-label="${escapeXmlText(original.value.unicode)}"` : "";
+  let painted = false;
+  if (!outlineStroke || p.fillColor) {
+    painted = true;
+    yield* text(`  <path${label}${transform} d="`);
+    for await (const chunk of encodeSvgPathDataChunks(p.storedSegments ?? p.segments, inverse ? 0 : pageHeight, { ...options, ...inverse ? { matrix: inverse } : {} })) yield* bytes(chunk);
+    yield* text(`" fill="${fill}"${p.fillRule === "evenodd" ? ' fill-rule="evenodd"' : ""}${p.fillAlpha !== void 0 && p.fillAlpha < 1 ? ` fill-opacity="${p.fillAlpha}"` : ""} stroke="${outlineStroke ? "none" : stroke}"${p.strokeAlpha !== void 0 && p.strokeAlpha < 1 ? ` stroke-opacity="${p.strokeAlpha}"` : ""}`);
+    yield* text(p.strokeWidth <= 0 && !matrix2 && !dashCount ? ' stroke-width="1" vector-effect="non-scaling-stroke"' : ` stroke-width="${prepared?.width ?? p.strokeWidth}"`);
+    yield* text(`${p.lineCap === 1 ? ' stroke-linecap="round"' : p.lineCap === 2 ? ' stroke-linecap="square"' : ""}${p.lineJoin === 1 ? ' stroke-linejoin="round"' : p.lineJoin === 2 ? ' stroke-linejoin="bevel"' : ""}${p.miterLimit !== void 0 && p.miterLimit !== 10 ? ` stroke-miterlimit="${p.miterLimit}"` : ""}`);
+    if (!outlineStroke && prepared && dashCount) {
+      yield* text(' stroke-dasharray="');
+      let first = true;
+      const factor = p.storedDash ? prepared.storedDashScale : 1;
+      if (p.storedDash) {
+        for await (const value of dashes(factor)) {
+          yield* text(`${first ? "" : " "}${value}`);
+          first = false;
+        }
+      } else for (const value of prepared.dashArray ?? []) {
+        await checkpoint();
+        yield* text(`${first ? "" : " "}${value}`);
+        first = false;
+      }
+      yield* text('"');
+    }
+    if (!outlineStroke && prepared?.dashPhase) yield* text(` stroke-dashoffset="${prepared.dashPhase}"`);
+    yield* text("/>");
+  }
+  if (outlineStroke) {
+    const io = { signal }, iterator = strokeContourPoints(p, pageHeight, scale, 0, 0, 0, 0, io)[Symbol.iterator]();
+    let firstPoint = true, started = false, contours = 0;
+    try {
+      for (; ; ) {
+        await checkpoint();
+        const next = iterator.next();
+        if (next.done) break;
+        if (io.pathRequest) {
+          const request = io.pathRequest;
+          io.pathRequest = void 0;
+          await request();
+        }
+        const point = next.value;
+        if (point === null) continue;
+        if (!started) {
+          yield* text(`${painted ? "\n" : ""}  <path${label} d="`);
+          started = true;
+        }
+        if (firstPoint && contours) yield* text(" ");
+        if (point) {
+          yield* text(`${firstPoint ? "M" : " L"} ${point[0] / scale} ${point[1] / scale}`);
+          firstPoint = false;
+        } else {
+          yield* text(" Z");
+          firstPoint = true;
+          contours++;
+        }
+      }
+    } finally {
+      iterator.return?.();
+    }
+    if (started) yield* text(`" fill="${stroke}" fill-opacity="${p.strokeAlpha ?? 1}"/>`);
+  }
+}
 
 // packages/pdf-ast/src/render/retained-page-pixels.ts
 async function renderRetainedPagePixels(page2, storage, options = {}) {
@@ -48728,7 +49074,7 @@ async function renderRetainedPagePixels(page2, storage, options = {}) {
 
 // packages/pdf-ast/src/cos/range-parser.ts
 import { listenForAbort as listenForAbort2 } from "@poe-platform/safe-fs/contracts";
-function limit(value, name) {
+function limit2(value, name) {
   const result = value ?? Infinity;
   if (result !== Infinity && (!Number.isSafeInteger(result) || result < 0)) throw new RangeError(`Invalid ${name}`);
   return result;
@@ -48832,16 +49178,16 @@ async function readValue(lexer, depth, nodes, options) {
   return value;
 }
 async function parseCosRangeValue(source, offset, options = {}) {
-  const depth = limit(options.maxRecursionDepth, "maxRecursionDepth");
-  const nodes = limit(options.maxNodes, "maxNodes");
-  const maxTokenBytes = limit(options.maxTokenBytes, "maxTokenBytes");
+  const depth = limit2(options.maxRecursionDepth, "maxRecursionDepth");
+  const nodes = limit2(options.maxNodes, "maxNodes");
+  const maxTokenBytes = limit2(options.maxTokenBytes, "maxTokenBytes");
   const lexer = new CosRangeLexer(source, { compactNumbers: options.compactNumbers ?? false, compactKeywords: options.compactKeywords ?? false, ...options.onBackingError ? { onBackingError: options.onBackingError } : {}, start: offset, ...options.end === void 0 ? {} : { end: options.end }, maxTokenBytes, ...options.signal ? { signal: options.signal } : {} });
   return { value: await readValue(lexer, depth, nodes, options), offset: lexer.offset };
 }
 async function parseCosRangeObject(source, offset, options = {}) {
-  const depth = limit(options.maxRecursionDepth, "maxRecursionDepth");
-  const nodes = limit(options.maxNodes, "maxNodes");
-  const tokenBytes = limit(options.maxTokenBytes, "maxTokenBytes");
+  const depth = limit2(options.maxRecursionDepth, "maxRecursionDepth");
+  const nodes = limit2(options.maxNodes, "maxNodes");
+  const tokenBytes = limit2(options.maxTokenBytes, "maxTokenBytes");
   const { signal } = options;
   signal?.throwIfAborted();
   const lexer = new CosRangeLexer(source, { compactNumbers: options.compactNumbers ?? false, compactKeywords: options.compactKeywords ?? false, ...options.onBackingError ? { onBackingError: options.onBackingError } : {}, start: offset, maxTokenBytes: tokenBytes, ...signal ? { signal } : {} });
@@ -48863,7 +49209,13 @@ async function parseCosRangeObject(source, offset, options = {}) {
       const first = await byteAt(source, start, signal);
       if (first === 13) start += await byteAt(source, start + 1, signal) === 10 ? 2 : 1;
       else if (first === 10) start++;
-      const entry = dictGet(value, "Length");
+      let entry;
+      try {
+        entry = value.storedEntries ? await readPdfDictionaryValue(value, "Length", signal, { preserveDeferred: true }) : dictGet(value, "Length");
+      } catch (error) {
+        options.onBackingError?.(error);
+        throw error;
+      }
       const length = await resolveStreamLength(entry, options);
       signal?.throwIfAborted();
       if (length !== void 0 && Number.isSafeInteger(length) && length >= 0 && length <= source.size - start) {
@@ -49110,11 +49462,11 @@ async function* readCosXrefRevision(source, offset, options = {}) {
       for (let i = 0; i < count; i++) {
         const type = w0 ? await reader.integer(w0) : 1;
         const field1 = await reader.integer(w1);
-        const field2 = w2 ? await reader.integer(w2) : 0;
+        const field22 = w2 ? await reader.integer(w2) : 0;
         signal?.throwIfAborted();
-        if (type === 0) yield { type: "free", objectNumber: start + i, nextFreeObjectNumber: field1, generationNumber: field2 };
-        else if (type === 1) yield { type: "uncompressed", objectNumber: start + i, offset: field1, generationNumber: field2 };
-        else if (type === 2) yield { type: "compressed", objectNumber: start + i, objectStreamNumber: field1, indexInStream: field2 };
+        if (type === 0) yield { type: "free", objectNumber: start + i, nextFreeObjectNumber: field1, generationNumber: field22 };
+        else if (type === 1) yield { type: "uncompressed", objectNumber: start + i, offset: field1, generationNumber: field22 };
+        else if (type === 2) yield { type: "compressed", objectNumber: start + i, objectStreamNumber: field1, indexInStream: field22 };
         else throw new PdfError("E_PARSE", `Invalid XRef entry type: ${type}`);
         if (++turns % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
       }
@@ -49552,7 +49904,7 @@ function integer2(value, name, minimum = 0) {
 function maximum2(value, name) {
   return value === void 0 || value === Infinity ? Number.MAX_SAFE_INTEGER : integer2(value, name);
 }
-function field(dict, key) {
+function field2(dict, key) {
   const value = dictGet(dict, key);
   if (value?.kind !== "number" || !Number.isSafeInteger(value.value) || value.value < 0) throw new PdfError("E_PARSE", `Invalid object stream /${key}`);
   return value.value;
@@ -49762,7 +50114,15 @@ var PdfObjectReader = class {
         this.repairedOffsets.set(objectNumber, object.span.start);
       }
       if (this.options.encryption && objectNumber !== this.options.encryptionObjectNumber) {
-        let type = object.stream && object.value.kind === "dict" ? dictGet(object.value, "Type") : void 0;
+        let type;
+        if (object.stream && object.value.kind === "dict") {
+          try {
+            type = object.value.storedEntries ? await readPdfDictionaryValue(object.value, "Type", this.options.signal, { preserveDeferred: true }) : dictGet(object.value, "Type");
+          } catch (error) {
+            onBackingError(error);
+            throw error;
+          }
+        }
         if (type?.kind === "ref") type = (await this.load(type.objectNumber, type.generationNumber, active))?.value;
         const value = await decryptPdfObjectStrings(
           this.options.encryption,
@@ -49813,8 +50173,8 @@ var PdfObjectReader = class {
     }
     const object = await this.load(number, generation, active);
     if (object?.value.kind !== "dict" || !object.stream || dictGet(object.value, "Type")?.kind !== "name" || dictGet(object.value, "Type").decoded !== "ObjStm") throw new PdfError("E_PARSE", "Invalid object stream dictionary");
-    const count = field(object.value, "N");
-    const first = field(object.value, "First");
+    const count = field2(object.value, "N");
+    const first = field2(object.value, "First");
     if (count > maximum2(this.options.maxObjectStreamMembers, "maxObjectStreamMembers") || count > Math.floor(Number.MAX_SAFE_INTEGER / 16)) throw new PdfError("E_LIMIT", "PDF object stream member limit exceeded");
     active.add(number);
     let dict;
@@ -50816,16 +51176,16 @@ async function renderRetainedMesh(context, dict, type, input, settings, storage,
 
 // packages/pdf-ast/src/extract/retained-color.ts
 import { readBytes as readBytes14 } from "@poe-platform/safe-fs/contracts";
-function limit2(value, fallback, name) {
+function limit3(value, fallback, name) {
   const result = value ?? fallback;
   if (result !== Infinity && (!Number.isSafeInteger(result) || result < 0)) throw new RangeError(`Invalid ${name}`);
   return Math.min(result, Number.MAX_SAFE_INTEGER);
 }
 function createRetainedColorAccess(document2, storage, options, storedFunctions = false) {
-  const maximum10 = limit2(options.maxWorkingBytes, Infinity, "maxWorkingBytes");
-  const maxStaging = limit2(options.maxStagingBytes, Infinity, "maxStagingBytes");
-  const maxNodes = limit2(options.maxNodes, 65536, "maxNodes");
-  const maxDepth = limit2(options.maxDepth, document2.depthLimit, "maxDepth");
+  const maximum10 = limit3(options.maxWorkingBytes, Infinity, "maxWorkingBytes");
+  const maxStaging = limit3(options.maxStagingBytes, Infinity, "maxStagingBytes");
+  const maxNodes = limit3(options.maxNodes, 65536, "maxNodes");
+  const maxDepth = limit3(options.maxDepth, document2.depthLimit, "maxDepth");
   const chunkBytes = options.chunkBytes ?? 4096;
   if (!Number.isSafeInteger(chunkBytes) || chunkBytes <= 0) throw new RangeError("Invalid chunkBytes");
   let used = 0;
@@ -50875,11 +51235,11 @@ function createRetainedColorAccess(document2, storage, options, storedFunctions
     options.onAllocation?.(bytes);
     used += bytes;
   }
-  async function resolve2(value) {
+  async function resolve2(value, path) {
     options.signal?.throwIfAborted();
     if (++nodes > maxNodes) throw new PdfError("E_LIMIT", "PDF color node limit exceeded");
     charge(64);
-    const resolved = await document2.lookup(value);
+    const resolved = await document2.lookup(value, void 0, path);
     options.signal?.throwIfAborted();
     if (!resolved) return void 0;
     if (resolved.stream && resolved.reference && resolved.value.kind === "dict") {
@@ -50890,6 +51250,11 @@ function createRetainedColorAccess(document2, storage, options, storedFunctions
     if (resolved.value.kind === "name") charge(resolved.value.decoded.length * 2);
     return resolved.value;
   }
+  async function resource(request) {
+    const map = await resolve2(dictGet(request.resources, request.category), ["Resources", request.category]);
+    const dictionary = map?.kind === "stream" ? map.dict : map;
+    return dictionary?.kind === "dict" ? readPdfDictionaryValue(dictionary, request.name, options.signal) : void 0;
+  }
   function contents(stream) {
     const reference = streams.get(stream);
     return reference ? document2.objects.decodeStream(reference.objectNumber, reference.generationNumber) : decodePdfStreamChunks(stream.dict, async function* () {
@@ -50993,8 +51358,8 @@ function createRetainedColorAccess(document2, storage, options, storedFunctions
       const item = dictGet(dict, key);
       if (!item) continue;
       charge(64);
-      const field2 = key === "Functions" ? await snapshotFunction(item, depth + 1) : await snapshotNumbers(item);
-      selected.entries.push({ key: cosName(key), value: field2 ?? { kind: "null" } });
+      const field3 = key === "Functions" ? await snapshotFunction(item, depth + 1) : await snapshotNumbers(item);
+      selected.entries.push({ key: cosName(key), value: field3 ?? { kind: "null" } });
     }
     if (value?.kind === "stream" && (kind === 0 || kind === 4) && storedFunctions) return storeFunction(value, selected);
     return value?.kind === "stream" && (kind === 0 || kind === 4) ? cosStream(selected, await decode2(value)) : selected;
@@ -51075,7 +51440,7 @@ function createRetainedColorAccess(document2, storage, options, storedFunctions
     maxRecursionDepth: maxDepth
   });
   options.signal?.throwIfAborted();
-  return { resolve: resolve2, decode: decode2, contents, snapshot, snapshotColor, snapshotFunction, charge, context, maxDepth, functionSources, storedFunctions, async close() {
+  return { resolve: resolve2, resource, decode: decode2, contents, snapshot, snapshotColor, snapshotFunction, charge, context, maxDepth, functionSources, storedFunctions, async close() {
     await functionBacking?.close();
   } };
 }
@@ -51094,7 +51459,7 @@ async function openRetainedImageColor(document2, node, resources, storage, optio
   }
 }
 async function resolveImageColor(access, node, resources, options) {
-  const { resolve: resolve2, decode: decode2, snapshot, snapshotFunction, charge, context, maxDepth, functionSources } = access;
+  const { resolve: resolve2, resource, decode: decode2, snapshot, snapshotFunction, charge, context, maxDepth, functionSources } = access;
   const work = imageColorSpaceProgram(node, resources, maxDepth);
   try {
     let step = work.next();
@@ -51106,6 +51471,9 @@ async function resolveImageColor(access, node, resources, options) {
         case "resolve":
           result = await resolve2(request.node);
           break;
+        case "resource":
+          result = await resource(request);
+          break;
         case "palette": {
           if (!Number.isSafeInteger(request.maxBytes) || request.maxBytes < 0) throw new PdfError("E_LIMIT", "PDF palette size limit exceeded");
           if (request.node.kind === "stream") result = await decode2(request.node, request.maxBytes);
@@ -51164,7 +51532,7 @@ async function runFunctionSteps(work, signal) {
   }
 }
 async function runRetainedColorProgram(document2, storage, options, work) {
-  const { resolve: resolve2, decode: decode2, snapshot, snapshotFunction, context, charge, functionSources, close } = createRetainedColorAccess(document2, storage, options, true);
+  const { resolve: resolve2, resource, decode: decode2, snapshot, snapshotFunction, context, charge, functionSources, close } = createRetainedColorAccess(document2, storage, options, true);
   let failed = false;
   try {
     let step = work.next();
@@ -51172,7 +51540,9 @@ async function runRetainedColorProgram(document2, storage, options, work) {
       options.signal?.throwIfAborted();
       const request = step.value;
       let result;
-      if (request.kind === "resolve") result = await resolve2(request.node);
+      if (request.kind === "dictionary-value") result = await readPdfDictionaryValue(request.dict, request.key, options.signal);
+      else if (request.kind === "resolve") result = await resolve2(request.node);
+      else if (request.kind === "resource") result = await resource(request);
       else if (request.kind === "decode") result = await decode2(request.stream, request.length, request.start);
       else if (request.kind === "calibrated") result = createCalibratedColorSpace(context, request.family, await snapshot(request.parameters));
       else if (request.kind === "transfer") {
@@ -51247,7 +51617,7 @@ async function renderRetainedShading(document2, node, settings, storage, options
 import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/extract/retained-jpeg.ts
-function limit3(value, name) {
+function limit4(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51272,8 +51642,8 @@ var PdfRetainedJpeg = class _PdfRetainedJpeg {
   static async open(source, options = {}) {
     const controller = new AbortController();
     options = { ...options, signal: options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal };
-    const maximum10 = limit3(options.maxWorkingBytes, "maxWorkingBytes");
-    const outputMaximum = limit3(options.maxOutputBytes, "maxOutputBytes");
+    const maximum10 = limit4(options.maxWorkingBytes, "maxWorkingBytes");
+    const outputMaximum = limit4(options.maxOutputBytes, "maxOutputBytes");
     let allocated = 0;
     let parsing = true;
     function charge(bytes) {
@@ -51463,7 +51833,7 @@ async function* tileDescriptors(tiles, storage, signal) {
     }
   }
 }
-function limit4(value, name) {
+function limit5(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51497,8 +51867,8 @@ var PdfRetainedJpx = class _PdfRetainedJpx {
       ...options,
       signal: options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal
     };
-    const maximum10 = limit4(options.maxWorkingBytes, "maxWorkingBytes");
-    const outputMaximum = limit4(options.maxOutputBytes, "maxOutputBytes");
+    const maximum10 = limit5(options.maxWorkingBytes, "maxWorkingBytes");
+    const outputMaximum = limit5(options.maxOutputBytes, "maxOutputBytes");
     let allocated = 0;
     let allocationFailure;
     function charge(bytes) {
@@ -51725,7 +52095,7 @@ var PdfRetainedJpx = class _PdfRetainedJpx {
 };
 
 // packages/pdf-ast/src/extract/retained-jbig2.ts
-function limit5(value, name) {
+function limit6(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51752,8 +52122,8 @@ var PdfRetainedJbig2 = class _PdfRetainedJbig2 {
   static async open(source, fallbackWidth, fallbackHeight, options = {}) {
     const controller = new AbortController();
     options = { ...options, signal: options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal };
-    const maximum10 = limit5(options.maxWorkingBytes, "maxWorkingBytes");
-    const outputMaximum = limit5(options.maxOutputBytes, "maxOutputBytes");
+    const maximum10 = limit6(options.maxWorkingBytes, "maxWorkingBytes");
+    const outputMaximum = limit6(options.maxOutputBytes, "maxOutputBytes");
     let allocated = 0;
     function charge(bytes) {
       if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > maximum10 - allocated) throw new PdfError("E_LIMIT", "JBIG2 working byte limit exceeded");
@@ -51922,7 +52292,7 @@ var PdfRetainedJbig2 = class _PdfRetainedJbig2 {
 
 // packages/pdf-ast/src/extract/retained-mask.ts
 import { readBytes as readBytes15 } from "@poe-platform/safe-fs/contracts";
-function limit6(value, name) {
+function limit7(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51932,8 +52302,8 @@ async function* applyRetainedImageMask(rows, width, height, mask, options) {
     if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`Invalid ${name}`);
   }
   if (options.mode !== "soft" && options.mode !== "explicit") throw new RangeError("Invalid mask mode");
-  const workingLimit = limit6(options.maxWorkingBytes, "maxWorkingBytes");
-  const outputLimit = limit6(options.maxOutputBytes, "maxOutputBytes");
+  const workingLimit = limit7(options.maxWorkingBytes, "maxWorkingBytes");
+  const outputLimit = limit7(options.maxOutputBytes, "maxOutputBytes");
   const pixels = width * height;
   const maskPixels = mask.width * mask.height;
   if (!Number.isSafeInteger(pixels) || pixels > Math.floor(outputLimit / 4)) throw new PdfError("E_LIMIT", "PDF masked output byte limit exceeded");
@@ -51975,7 +52345,7 @@ async function* applyRetainedImageMask(rows, width, height, mask, options) {
 }
 
 // packages/pdf-ast/src/extract/retained-samples.ts
-function limit7(value, name) {
+function limit8(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51984,8 +52354,8 @@ async function* decodeRetainedSampleRows(source, width, height, bitsPerComponent
   for (const [name, value] of [["width", width], ["height", height], ["bitsPerComponent", bitsPerComponent], ["components", color.components]]) {
     if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`Invalid ${name}`);
   }
-  const workingLimit = limit7(options.maxWorkingBytes, "maxWorkingBytes");
-  const outputLimit = limit7(options.maxOutputBytes, "maxOutputBytes");
+  const workingLimit = limit8(options.maxWorkingBytes, "maxWorkingBytes");
+  const outputLimit = limit8(options.maxOutputBytes, "maxOutputBytes");
   const pixels = width * height;
   if (!Number.isSafeInteger(pixels) || pixels > Math.floor(outputLimit / 4)) throw new PdfError("E_LIMIT", "PDF sample output byte limit exceeded");
   options.signal?.throwIfAborted();
@@ -53095,8 +53465,8 @@ async function readType1Header(lexer, initialMatrix, storage, signal) {
     if (!await token2.equals("/")) continue;
     switch (await (await lexer.next())?.keyword()) {
       case "FontMatrix": {
-        const field2 = await readType1NumberArray(lexer);
-        matrix2 = field2.count > 6 ? [...field2.values, 0] : field2.values;
+        const field3 = await readType1NumberArray(lexer);
+        matrix2 = field3.count > 6 ? [...field3.values, 0] : field3.values;
         break;
       }
       case "FontBBox":
@@ -53371,8 +53741,8 @@ async function parseStoredType1Cid(source, properties, storage, signal) {
     const key = await keyToken?.keyword();
     switch (key) {
       case "FontMatrix": {
-        const field2 = await readType1NumberArray(lexer);
-        properties.fontMatrix = field2.count > 6 ? [...field2.values, 0] : field2.values;
+        const field3 = await readType1NumberArray(lexer);
+        properties.fontMatrix = field3.count > 6 ? [...field3.values, 0] : field3.values;
         break;
       }
       case "FontBBox":
@@ -54129,8 +54499,8 @@ async function readCffDictionary(source, selected) {
 var TOP_FIELDS = /* @__PURE__ */ new Set([15, 16, 17, 18, 3079, 3102, 3108, 3109]);
 var PRIVATE_FIELDS = /* @__PURE__ */ new Set([19]);
 var DEFAULT_MATRIX = [1e-3, 0, 0, 1e-3, 0, 0];
-function scalar(dict, field2, fallback = 0) {
-  return dict.get(field2)?.values[0] ?? fallback;
+function scalar(dict, field3, fallback = 0) {
+  return dict.get(field3)?.values[0] ?? fallback;
 }
 function matrix(dict) {
   const entry = dict.get(3079);
@@ -55072,8 +55442,8 @@ 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", "XObject", "Properties"], storeRootDictionary: step.value.storeRootDictionary ?? false, arrayStorage: options.resourceStorage, storedArrayKeys: ["Widths", "W", "Differences"], storeRootArray: step.value.storeRootArray ?? false } : {});
-        value = retained?.value;
+        const retained = await document2.lookup(step.value.node, options.resourceStorage ? { dictionaryStorage: options.resourceStorage, deferDictionaryValues: true, deferArrayValues: true, containerStorage: options.resourceStorage, stringStorage: options.resourceStorage, storedDictionaryKeys: ["Font", "XObject", "Properties"], storedDictionaryPaths: [["Resources", "*"]], storeRootDictionary: step.value.storeRootDictionary ?? false, arrayStorage: options.resourceStorage, storedArrayKeys: ["Widths", "W", "Differences"], storeRootArray: step.value.storeRootArray ?? false } : {}, step.value.arrayPathPrefix);
+        value = retained ? options.resourceStorage && (step.value.storeRootDictionary || step.value.storeRootArray) ? retained.value : await materializeResourceValue(retained.value, signal) : void 0;
         if (retained?.stream) {
           if (retained.value.kind !== "dict" || !retained.reference) throw new PdfError("E_PARSE", "Font stream has no retained identity");
           allocation.admit(256);
@@ -55081,6 +55451,8 @@ async function resolveRetainedFont(document2, storage, resources, name, options
           identities.set(stream, retained.reference);
           value = stream;
         }
+      } else if (step.value.kind === "dictionary-value") {
+        value = await readPdfDictionaryValue(step.value.dict, step.value.key, signal, { preserveDeferred: true });
       } else if (step.value.kind === "dictionary-entry") {
         const record = await readStoredRecord(step.value.entries.storage, step.value.position, signal);
         value = cosArray([record.value.key, record.value.value, cosNumber(record.next)]);
@@ -55265,9 +55637,9 @@ async function* evaluateRetainedContentSteps(document2, content, params, storage
     admitted += bytes;
   }
   const identities = /* @__PURE__ */ new WeakMap();
-  async function resolve2(node, storeRootArray = false, arrayPathPrefix) {
+  async function resolve2(node, storeRootArray = false, arrayPathPrefix, storeRootDictionary = false) {
     charge(64);
-    const value = await document2.lookup(node, storeRootArray && options.imageStorage ? { arrayStorage: options.imageStorage, storeRootArray: true } : void 0, arrayPathPrefix);
+    const value = await document2.lookup(node, void 0, arrayPathPrefix, storeRootDictionary, storeRootArray ? options.imageStorage : void 0);
     signal?.throwIfAborted();
     if (value?.stream && value.reference && value.value.kind === "dict") {
       charge(128);
@@ -55406,14 +55778,14 @@ async function* evaluateRetainedContentSteps(document2, content, params, storage
         }
         case "resolve":
         case "catalog":
-          reply = { kind: "resolved", node: await resolve2(request.kind === "catalog" ? document2.crossReference.rootRef : request.node, request.kind === "resolve" && request.storeRootArray, request.kind === "resolve" ? request.arrayPathPrefix : void 0) };
+          reply = { kind: "resolved", node: await resolve2(request.kind === "catalog" ? document2.crossReference.rootRef : request.node, request.kind === "resolve" && request.storeRootArray, request.kind === "resolve" ? request.arrayPathPrefix : void 0, request.kind === "resolve" && request.storeRootDictionary) };
           break;
         case "dash-array": {
           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) };
+          reply = { kind: "resolved", node: await readPdfDictionaryValue(request.dict, request.key, signal, request.preserveDeferred ? { preserveDeferred: true } : {}) };
           break;
         case "array-reference":
           reply = { kind: "resolved", node: cosBool(await memberships.has(request.items, request.objectNumber)) };
@@ -58349,8 +58721,8 @@ async function* walkRetainedFormFieldDetails(document2, storage, options = {}) {
           yield value2;
         }
       }
-      async function* appearances(field2) {
-        const appearance = await resolve2(dictGet(field2, "AP"));
+      async function* appearances(field3) {
+        const appearance = await resolve2(dictGet(field3, "AP"));
         const normal = appearance?.kind === "dict" ? await resolve2(dictGet(appearance, "N")) : void 0;
         if (normal?.kind === "dict") for (const pair of normal.entries) {
           await checkpoint();
@@ -58363,8 +58735,8 @@ async function* walkRetainedFormFieldDetails(document2, storage, options = {}) {
           yield* appearances(dict);
           const kids = await resolve2(dictGet(dict, "Kids"));
           if (kids?.kind === "array") for (const kid of kids.items) {
-            const field2 = await resolve2(kid);
-            if (field2?.kind === "dict") yield* appearances(field2);
+            const field3 = await resolve2(kid);
+            if (field3?.kind === "dict") yield* appearances(field3);
           }
           if (count === 1) yield* unique("Yes");
         }
@@ -59121,10 +59493,10 @@ async function* streamRawTextChunks(glyphs, storage, options = {}) {
     }
   })();
   const encoder = new TextEncoder(), buffer = new Uint8Array(chunkBytes);
-  function* encode3(text, offset = 0, limit10 = text.length) {
-    while (offset < limit10) {
-      let end = Math.min(limit10, offset + Math.floor(chunkBytes / 3));
-      if (end < limit10 && text.charCodeAt(end - 1) >= 55296 && text.charCodeAt(end - 1) <= 56319 && text.charCodeAt(end) >= 56320 && text.charCodeAt(end) <= 57343) end--;
+  function* encode3(text, offset = 0, limit11 = text.length) {
+    while (offset < limit11) {
+      let end = Math.min(limit11, offset + Math.floor(chunkBytes / 3));
+      if (end < limit11 && text.charCodeAt(end - 1) >= 55296 && text.charCodeAt(end - 1) <= 56319 && text.charCodeAt(end) >= 56320 && text.charCodeAt(end) <= 57343) end--;
       const { read, written } = encoder.encodeInto(text.slice(offset, end), buffer);
       offset += read;
       yield buffer.subarray(0, written);
@@ -59513,15 +59885,15 @@ var PdfStagedOutputs = class _PdfStagedOutputs {
   static async create(storage, input, options = {}) {
     const chunkBytes = maximum7(options.chunkBytes, 65536);
     if (chunkBytes < 32 || chunkBytes === Number.MAX_SAFE_INTEGER) throw new RangeError("PDF output chunkBytes must be finite and at least 32");
-    const limit10 = maximum7(options.maxStagingBytes, Infinity);
+    const limit11 = maximum7(options.maxStagingBytes, Infinity);
     const nameLimit = maximum7(options.maxNameChars, 1048576);
     const { signal } = options;
     let written = 0;
-    const names = new PdfNameIndex(storage, () => limit10 - written, signal);
+    const names = new PdfNameIndex(storage, () => limit11 - written, signal);
     let data;
     let index2;
     const charge = (size) => {
-      if (size > limit10 - written - names.stagedBytes) throw new PdfError("E_LIMIT", "PDF output staging byte limit exceeded");
+      if (size > limit11 - written - names.stagedBytes) throw new PdfError("E_LIMIT", "PDF output staging byte limit exceeded");
       written += size;
     };
     async function* records2() {
@@ -59555,7 +59927,7 @@ var PdfStagedOutputs = class _PdfStagedOutputs {
       }
     }
     try {
-      data = await PdfFileSource.fromStream(storage.fs, storage.directory, records2(), { chunkBytes, cacheBytes: chunkBytes, maxInputBytes: limit10, ...signal ? { signal } : {} });
+      data = await PdfFileSource.fromStream(storage.fs, storage.directory, records2(), { chunkBytes, cacheBytes: chunkBytes, maxInputBytes: limit11, ...signal ? { signal } : {} });
       await names.close();
       const source = data;
       async function* rows() {
@@ -59572,7 +59944,7 @@ var PdfStagedOutputs = class _PdfStagedOutputs {
         runEntries: 64,
         chunkBytes: indexChunk,
         cacheBytes: indexChunk,
-        maxStagingBytes: limit10 - data.size,
+        maxStagingBytes: limit11 - data.size,
         ...signal ? { signal } : {}
       });
       return new _PdfStagedOutputs(data, index2, signal, nameLimit);
@@ -59666,7 +60038,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 resources = (await document2.lookup(dictGet(page2, "Resources"), void 0, ["Resources"]))?.value;
     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;
@@ -60048,7 +60420,7 @@ async function* walkRetainedJavaScripts(document2, storage, options) {
     const kids = await resolve2(dictGet(dict, "Kids"));
     if (kids?.kind === "array") for (const kid of kids.items) yield* tree(kid, depth + 1);
   }
-  async function* field2(node, fallback, depth = 0) {
+  async function* field3(node, fallback, depth = 0) {
     if (depth > options.maxDepth) throw new PdfError("E_LIMIT", "PDF JavaScript field depth limit exceeded");
     const dict = await dictionary(node, "field");
     if (!dict) return;
@@ -60057,7 +60429,7 @@ async function* walkRetainedJavaScripts(document2, storage, options) {
     yield* action(dictGet(dict, "A"), `${label} Action`);
     yield* additional(dictGet(dict, "AA"), label);
     const kids = await resolve2(dictGet(dict, "Kids"));
-    if (kids?.kind === "array") for (const kid of kids.items) yield* field2(kid, label, depth + 1);
+    if (kids?.kind === "array") for (const kid of kids.items) yield* field3(kid, label, depth + 1);
   }
   try {
     const root = await dictionary(document2.crossReference.rootRef);
@@ -60070,11 +60442,11 @@ async function* walkRetainedJavaScripts(document2, storage, options) {
       const label = `Page ${page2.index + 1}`;
       yield* additional(dictGet(page2.dict, "AA"), label);
       const annots = await resolve2(dictGet(page2.dict, "Annots"));
-      if (annots?.kind === "array") for (let i = 0; i < annots.items.length; i++) yield* field2(annots.items[i], `${label} Annot ${i + 1}`);
+      if (annots?.kind === "array") for (let i = 0; i < annots.items.length; i++) yield* field3(annots.items[i], `${label} Annot ${i + 1}`);
     }
     const form = await dictionary(dictGet(root, "AcroForm"));
     const fields2 = form ? await resolve2(dictGet(form, "Fields")) : void 0;
-    if (fields2?.kind === "array") for (let i = 0; i < fields2.items.length; i++) yield* field2(fields2.items[i], `Field ${i + 1}`);
+    if (fields2?.kind === "array") for (let i = 0; i < fields2.items.length; i++) yield* field3(fields2.items[i], `Field ${i + 1}`);
   } catch (error) {
     failed = true;
     throw error;
@@ -60096,7 +60468,7 @@ async function* walkRetainedImages(document2, storage, options) {
   let imageIndex = 0;
   let stagedBytes = 0;
   async function dictionary(node, resourceKey) {
-    const value = await document2.lookup(node, void 0, resourceKey ? [resourceKey] : void 0);
+    const value = await document2.lookup(node, void 0, resourceKey ? resourceKey === "Resources" ? [resourceKey] : ["Resources", resourceKey] : void 0);
     return value?.value.kind === "dict" && !value.stream ? value.value : void 0;
   }
   async function number(node, fallback) {
@@ -60216,7 +60588,7 @@ async function* walkRetainedImages(document2, storage, options) {
               try {
                 yield* content(
                   document2.objects.decodeStream(ref.objectNumber, ref.generationNumber),
-                  await dictionary(dictGet(target.value, "Resources")) ?? activeResources,
+                  await dictionary(dictGet(target.value, "Resources"), "Resources") ?? activeResources,
                   transform,
                   active,
                   depth + 1
@@ -60246,7 +60618,7 @@ async function* walkRetainedImages(document2, storage, options) {
       if (value.stream && value.reference) {
         yield* content(
           document2.objects.decodeStream(value.reference.objectNumber, value.reference.generationNumber),
-          await dictionary(dictGet(value.value, "Resources")) ?? inherited,
+          await dictionary(dictGet(value.value, "Resources"), "Resources") ?? inherited,
           identity,
           /* @__PURE__ */ new Set([value.reference.objectNumber]),
           0
@@ -60255,8 +60627,8 @@ async function* walkRetainedImages(document2, storage, options) {
     }
     try {
       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 patterns = await dictionary(dictGet(resources, "Pattern"), "Pattern");
+      if (patterns) for await (const entry of readPdfDictionaryEntries(patterns, options.signal)) yield* auxiliary(entry.value, resources);
       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);
@@ -60264,7 +60636,7 @@ async function* walkRetainedImages(document2, storage, options) {
         const subtype = (await document2.lookup(dictGet(font, "Subtype")))?.value;
         if (subtype?.kind !== "name" || subtype.decoded !== "Type3") continue;
         const procedures = await dictionary(dictGet(font, "CharProcs"));
-        const inherited = await dictionary(dictGet(font, "Resources")) ?? resources;
+        const inherited = await dictionary(dictGet(font, "Resources"), "Resources") ?? resources;
         if (procedures) for (const entry2 of procedures.entries) yield* auxiliary(entry2.value, inherited);
       }
       const annotations = (await document2.lookup(dictGet(page2.dict, "Annots")))?.value;
@@ -60312,7 +60684,7 @@ async function* walkRetainedFonts(document2, storage, options) {
   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, resourceKey) {
-    const resolved = await document2.lookup(node, void 0, resourceKey ? [resourceKey] : void 0);
+    const resolved = await document2.lookup(node, void 0, resourceKey ? resourceKey === "Resources" ? [resourceKey] : ["Resources", resourceKey] : void 0);
     return resolved?.value.kind === "dict" && !resolved.stream ? resolved.value : void 0;
   }
   async function* font(node, key, depth) {
@@ -60342,7 +60714,7 @@ async function* walkRetainedFonts(document2, storage, options) {
     const enc = (await document2.lookup(dictGet(value, "Encoding")))?.value;
     const encoding = enc?.kind === "name" ? enc.decoded === "WinAnsiEncoding" ? "WinAnsi" : enc.decoded === "MacRomanEncoding" ? "MacRoman" : enc.decoded === "StandardEncoding" ? "Standard" : enc.decoded : enc?.kind === "dict" ? "Custom" : "Builtin";
     yield { name, type, encoding, embedded, unicode: Boolean(dictGet(value, "ToUnicode")), ...node.kind === "ref" ? { reference: node } : {} };
-    if (raw === "Type3") yield* resources(await dictionary(dictGet(value, "Resources")), depth + 1);
+    if (raw === "Type3") yield* resources(await dictionary(dictGet(value, "Resources"), "Resources"), depth + 1);
   }
   async function* resources(value, depth) {
     options.signal?.throwIfAborted();
@@ -60350,8 +60722,8 @@ async function* walkRetainedFonts(document2, storage, options) {
     if (depth > options.maxDepth) throw new PdfError("E_LIMIT", "PDF font resource depth limit exceeded");
     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 states = await dictionary(dictGet(value, "ExtGState"), "ExtGState");
+    if (states) for await (const entry of readPdfDictionaryEntries(states, options.signal)) {
       const state = await dictionary(entry.value);
       const gsFont = state ? (await document2.lookup(dictGet(state, "Font")))?.value : void 0;
       if (gsFont?.kind === "array" && gsFont.items[0]) yield* font(gsFont.items[0], `ExtGS_${entry.key.decoded}`, depth);
@@ -60365,7 +60737,7 @@ async function* walkRetainedFonts(document2, storage, options) {
         if (!resolved?.stream || resolved.value.kind !== "dict") continue;
         const subtype = (await document2.lookup(dictGet(resolved.value, "Subtype")))?.value;
         if (key === "XObject" && !(subtype?.kind === "name" && subtype.decoded === "Form")) continue;
-        yield* resources(await dictionary(dictGet(resolved.value, "Resources")), depth + 1);
+        yield* resources(await dictionary(dictGet(resolved.value, "Resources"), "Resources"), depth + 1);
       }
     }
   }
@@ -60383,10 +60755,10 @@ async function* walkRetainedFonts(document2, storage, options) {
         for (const key of ["N", "R", "D"]) {
           const ap = await document2.lookup(dictGet(appearance, key));
           if (ap?.value.kind !== "dict") continue;
-          if (ap.stream) yield* resources(await dictionary(dictGet(ap.value, "Resources")), 0);
+          if (ap.stream) yield* resources(await dictionary(dictGet(ap.value, "Resources"), "Resources"), 0);
           else for (const entry of ap.value.entries) {
             const stream = await document2.lookup(entry.value);
-            if (stream?.stream && stream.value.kind === "dict") yield* resources(await dictionary(dictGet(stream.value, "Resources")), 0);
+            if (stream?.stream && stream.value.kind === "dict") yield* resources(await dictionary(dictGet(stream.value, "Resources"), "Resources"), 0);
           }
         }
       }
@@ -60474,7 +60846,7 @@ async function* walkRetainedAttachments(document2, storage, options) {
 }
 
 // packages/pdf-ast/src/retained-document.ts
-function limit8(value, name, fallback) {
+function limit9(value, name, fallback) {
   const result = value ?? fallback;
   if (result !== Infinity && (!Number.isSafeInteger(result) || result < 0)) throw new RangeError(`Invalid ${name}`);
   return result;
@@ -60503,9 +60875,9 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
   walks = /* @__PURE__ */ new Set();
   closing;
   static async open(source, storage, options = {}) {
-    const maxPages = limit8(options.maxPages, "maxPages", Infinity);
-    const maxPageTreeDepth = limit8(options.maxPageTreeDepth, "maxPageTreeDepth", 100);
-    const maxTraversalStagingBytes = limit8(options.maxTraversalStagingBytes, "maxTraversalStagingBytes", Infinity);
+    const maxPages = limit9(options.maxPages, "maxPages", Infinity);
+    const maxPageTreeDepth = limit9(options.maxPageTreeDepth, "maxPageTreeDepth", 100);
+    const maxTraversalStagingBytes = limit9(options.maxTraversalStagingBytes, "maxTraversalStagingBytes", Infinity);
     const controller = new AbortController();
     const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
     const configured = { ...options, signal, maxPages, maxPageTreeDepth, maxTraversalStagingBytes };
@@ -60515,9 +60887,9 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
   /** Read an editable caller-backed graph without normalizing it through a PDF
    * save. The caller retains ownership of the store and its object identities. */
   static async openStore(store, storage, options) {
-    const maxPages = limit8(options.maxPages, "maxPages", Infinity);
-    const maxPageTreeDepth = limit8(options.maxPageTreeDepth, "maxPageTreeDepth", 100);
-    const maxTraversalStagingBytes = limit8(options.maxTraversalStagingBytes, "maxTraversalStagingBytes", Infinity);
+    const maxPages = limit9(options.maxPages, "maxPages", Infinity);
+    const maxPageTreeDepth = limit9(options.maxPageTreeDepth, "maxPageTreeDepth", 100);
+    const maxTraversalStagingBytes = limit9(options.maxTraversalStagingBytes, "maxTraversalStagingBytes", Infinity);
     const controller = new AbortController();
     const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
     const configured = { ...options, signal, maxPages, maxPageTreeDepth, maxTraversalStagingBytes };
@@ -60529,8 +60901,10 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
     this.options.signal?.throwIfAborted();
   }
   /** Resolve a bounded reference chain, retaining the final stream's identity. */
-  async lookup(node, arrays = this.options.valueArrays ?? {}, arrayPathPrefix) {
+  async lookup(node, arrays = this.options.valueArrays ?? {}, arrayPathPrefix, storeRootDictionary = false, rootArrayStorage) {
     this.assertOpen();
+    if (rootArrayStorage) arrays = { ...arrays, arrayStorage: arrays.arrayStorage ?? rootArrayStorage, storeRootArray: true };
+    if (storeRootDictionary && arrays.dictionaryStorage) arrays = { ...arrays, storeRootDictionary: true };
     if (arrayPathPrefix) arrays = {
       ...arrays,
       arrayPathPrefix,
@@ -61106,7 +61480,7 @@ var PdfRetainedPage = class {
       for (const key of keys) {
         const entry = dictGet(current, key);
         if (values.has(key) || !entry) continue;
-        const value = (await this.document.lookup(entry))?.value;
+        const value = (await this.document.lookup(entry, void 0, key === "Resources" ? ["Resources"] : void 0))?.value;
         if (key.endsWith("Box")) {
           const rectangle = await box(value, this.document);
           if (!rectangle) continue;
@@ -61323,6 +61697,82 @@ async function* encodeRetainedPng(width, height, input, storage, options = {}) {
   }
 }
 
+// packages/pdf-ast/src/render/svg-image-stream.ts
+async function* encodeSvgImageChunks(image, pageHeight, storage, options = {}) {
+  const { signal } = options;
+  signal?.throwIfAborted();
+  if (!image.decodedRgba && !image.storedRgba) return;
+  const { width, height } = image, chunkBytes = options.chunkBytes ?? 65536, maximum10 = options.maxOutputBytes ?? Infinity;
+  if (![width, height].every((value) => Number.isSafeInteger(value) && value > 0 && value <= 4294967295) || !Number.isSafeInteger(width * height * 4)) throw new PdfError("E_LIMIT", "SVG image dimension limit exceeded");
+  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid SVG image chunk size");
+  if (maximum10 !== Infinity && (!Number.isSafeInteger(maximum10) || maximum10 < 0)) throw new RangeError("Invalid SVG output byte limit");
+  const [a, b, c, d, e, f] = image.matrix;
+  const prefix = `<image width="1" height="1" preserveAspectRatio="none" transform="matrix(${a} ${-b} ${-c} ${d} ${e + c} ${pageHeight - f - d})" href="data:image/png;base64,`, suffix = '"/>';
+  const encoder = new TextEncoder(), header2 = encoder.encode(prefix), tail = encoder.encode(suffix), available = maximum10 - header2.length - tail.length;
+  const pngMaximum = maximum10 === Infinity ? Infinity : Math.floor(available / 4) * 3;
+  if (pngMaximum < 57) throw new PdfError("E_LIMIT", "SVG image output byte limit exceeded");
+  let outputBytes = 0;
+  function* emit(bytes) {
+    if (bytes.length > maximum10 - outputBytes) throw new PdfError("E_LIMIT", "SVG image output byte limit exceeded");
+    outputBytes += bytes.length;
+    for (let at = 0; at < bytes.length; at += chunkBytes) {
+      signal?.throwIfAborted();
+      yield bytes.slice(at, at + chunkBytes);
+    }
+  }
+  async function* pixels() {
+    if (image.decodedRgba) {
+      for (let at = 0; at < image.decodedRgba.length; at += chunkBytes) {
+        signal?.throwIfAborted();
+        yield image.decodedRgba.subarray(at, at + chunkBytes);
+      }
+      return;
+    }
+    const source = image.storedRgba;
+    for (let at = 0; at < width * height * 4; ) {
+      signal?.throwIfAborted();
+      const count = Math.min(chunkBytes, width * height * 4 - at), bytes = await source.storage.read(source.position + at, count, signal ? { signal } : void 0);
+      if (bytes.length > count) throw new Error("Oversized SVG pixel read");
+      if (!bytes.length) return;
+      yield bytes;
+      at += bytes.length;
+    }
+  }
+  yield* emit(header2);
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const buffer = new Uint8Array(Math.min(8192, Math.max(4, chunkBytes))), triple = new Uint8Array(3);
+  let used = 0, pending = 0, work = 0;
+  function group(count) {
+    const n = triple[0] << 16 | triple[1] << 8 | triple[2];
+    buffer[used++] = alphabet.charCodeAt(n >>> 18);
+    buffer[used++] = alphabet.charCodeAt(n >>> 12 & 63);
+    buffer[used++] = count > 1 ? alphabet.charCodeAt(n >>> 6 & 63) : 61;
+    buffer[used++] = count > 2 ? alphabet.charCodeAt(n & 63) : 61;
+    triple.fill(0);
+    pending = 0;
+  }
+  const capacity = buffer.length - buffer.length % 4;
+  for await (const bytes of encodeRetainedPng(width, height, pixels(), storage, { ...options, alpha: "rgba", maxOutputBytes: pngMaximum })) {
+    for (const byte3 of bytes) {
+      triple[pending++] = byte3;
+      if (pending === 3) {
+        group(3);
+        if (used === capacity) {
+          yield* emit(buffer.subarray(0, used));
+          used = 0;
+        }
+        if (++work % 4096 === 0) {
+          await new Promise((resolve2) => setTimeout(resolve2, 0));
+          signal?.throwIfAborted();
+        }
+      }
+    }
+  }
+  if (pending) group(pending);
+  if (used) yield* emit(buffer.subarray(0, used));
+  yield* emit(tail);
+}
+
 // packages/pdf-ast/src/render/retained-tiff.ts
 function maximum9(value) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
@@ -61897,6 +62347,12 @@ async function createRetainedPageCopy(input, indicesOrStorage, storageOrOptions,
           const value = await box(key);
           if (value[0] !== 0 || value[1] !== 0 || value[2] !== width || value[3] !== height) dictSet(page2, key, cosArray(value.map((value2) => cosNumber(value2))));
         }
+        dictSet(page2, "Parent", cosRef(2));
+        const boxes = options.pageBoxes?.({ width, height }, selection.index);
+        for (const [key, value] of [["MediaBox", boxes?.mediaBox], ["CropBox", boxes?.cropBox]]) if (value) {
+          if (value.length !== 4 || !value.every(Number.isFinite)) throw new RangeError("Invalid copied page box");
+          dictSet(page2, key, cosArray(value.map((coordinate) => cosNumber(coordinate))));
+        }
         await store.set({ objectNumber: pageRef.objectNumber, generationNumber: 0, value: page2 });
       }
       const sourceCatalog = await sourceValue(document2.crossReference.rootRef), acro = sourceCatalog?.kind === "dict" ? await sourceValue(dictGet(sourceCatalog, "AcroForm")) : void 0;
@@ -61932,14 +62388,14 @@ async function createRetainedPageCopy(input, indicesOrStorage, storageOrOptions,
       if (fields2?.kind === "array" && acro?.kind === "dict") {
         let addedFields = false;
         const rootNumbers = new IntegerTable6(backing, 64);
-        for (const field2 of fields2.items) {
-          if (!await hasCloned(field2)) continue;
-          const cloned = await clone(field2);
+        for (const field3 of fields2.items) {
+          if (!await hasCloned(field3)) continue;
+          const cloned = await clone(field3);
           if (cloned.kind !== "ref") continue;
-          const dict = await targetDict(cloned), source = await sourceValue(field2), sourceKids = source?.kind === "dict" ? await sourceValue(dictGet(source, "Kids")) : void 0;
+          const dict = await targetDict(cloned), source = await sourceValue(field3), sourceKids = source?.kind === "dict" ? await sourceValue(dictGet(source, "Kids")) : void 0;
           let kids = dict && dictGet(dict, "Kids");
           if (kids?.kind === "ref") kids = (await store.get(kids.objectNumber))?.value;
-          if (dict && kids?.kind === "array" && field2.kind === "ref" && sourceKids?.kind === "array" && sourceKids.items.length === kids.items.length) {
+          if (dict && kids?.kind === "array" && field3.kind === "ref" && sourceKids?.kind === "array" && sourceKids.items.length === kids.items.length) {
             const filtered = [];
             for (let i = 0; i < kids.items.length; i++) if (await hasCloned(sourceKids.items[i])) filtered.push(kids.items[i]);
             if (filtered.length) {
@@ -61986,12 +62442,12 @@ async function createRetainedPageCopy(input, indicesOrStorage, storageOrOptions,
     }
   }
   const encoder = new TextEncoder();
-  async function* dictionary(dict, field2, values) {
+  async function* dictionary(dict, field3, values) {
     yield encoder.encode("<<\n");
     for (const entry of dict.entries) {
       yield* serializeCosNodeChunks(entry.key, { chunkBytes: options.chunkBytes ?? 16384, maxRecursionDepth: maximumDepth, signal }, 1);
       yield encoder.encode(" ");
-      if (entry.key.decoded === field2) {
+      if (entry.key.decoded === field3) {
         if (values.count && maximumDepth < 2) throw new PdfError("E_LIMIT", "PDF page copy depth limit exceeded");
         yield encoder.encode("[ ");
         for await (const reference of references(values)) yield encoder.encode(`${reference.objectNumber} 0 R `);
@@ -62019,10 +62475,10 @@ async function createRetainedPageCopy(input, indicesOrStorage, storageOrOptions,
     const pageTree = cosDict({ Type: cosName("Pages"), Count: cosNumber(pageCount), Kids: cosArray([]) });
     if (pageLabels) await store.setSerializedValue(pageLabels);
     if (attachmentNames) await store.setSerializedValue(attachmentNames);
-    async function saveList(number, dict, field2, values) {
+    async function saveList(number, dict, field3, values) {
       let length = 0;
-      for await (const bytes of dictionary(dict, field2, values)) length += bytes.length;
-      await store.setSerializedValue({ objectNumber: number, generationNumber: 0, body: { length, chunks: dictionary(dict, field2, values) } });
+      for await (const bytes of dictionary(dict, field3, values)) length += bytes.length;
+      await store.setSerializedValue({ objectNumber: number, generationNumber: 0, body: { length, chunks: dictionary(dict, field3, values) } });
     }
     await saveList(2, pageTree, "Kids", pages);
     if (formRef) await saveList(formRef.objectNumber, (await store.get(formRef.objectNumber)).value, "Fields", formFields);
@@ -62059,13 +62515,13 @@ async function* copyRetainedPagesChunks(input, indicesOrStorage, storageOrOption
 }
 
 // packages/pdf-ast/src/cos/retained-objects.ts
-function limit9(value) {
+function limit10(value) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError("Invalid retained object limit");
   return value;
 }
 async function* retainedCosObjects(document2, storage, options = {}) {
-  const maxObjects = limit9(options.maxObjects), maxStreamBytes = limit9(options.maxStreamBytes), signal = options.signal;
+  const maxObjects = limit10(options.maxObjects), maxStreamBytes = limit10(options.maxStreamBytes), signal = options.signal;
   let count = 0;
   for await (const entry of document2.crossReference.index.entries(signal)) {
     signal?.throwIfAborted();
@@ -62431,16 +62887,329 @@ async function* saveRetainedDocumentChunks(document2, storage, options = {}) {
   }
 }
 
+// packages/pdf-ast/src/edit/retained-flatten-forms.ts
+import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage13 } from "@poe-platform/safe-fs/storage";
+async function flattenRetainedForms(document2, store, storage, signal) {
+  if (!document2.crossReference.rootRef) return;
+  const backing = new PagedStorage13({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), names = new PdfNameIndex(storage, Infinity, signal), baked = new IntegerTable8(backing), active = new IntegerTable8(backing), fields2 = new IntegerTable8(backing), pagesSeen = new IntegerTable8(backing), walkMarks = new IntegerTable8(backing);
+  let head = -1, fieldCount = 0, work = 0, walk = 0, failed = false;
+  async function checkpoint(depth = 0) {
+    signal.throwIfAborted();
+    if (depth > document2.depthLimit) throw new PdfError("E_LIMIT", "PDF form field depth limit exceeded");
+    if (++work % 64 === 0) {
+      await new Promise((resolve3) => setTimeout(resolve3, 0));
+      signal.throwIfAborted();
+    }
+  }
+  const child = (location, key) => ({ reference: location.reference, path: [...location.path, key] });
+  async function locate(location) {
+    let owner = await store.get(location.reference.objectNumber);
+    if (!owner || owner.generationNumber !== location.reference.generationNumber || owner.stream) return;
+    let value = owner.value, path = [], reference = location.reference, refs = 0;
+    for (let i = 0; i <= location.path.length; i++) {
+      while (value?.kind === "ref") {
+        await checkpoint(++refs);
+        reference = value;
+        owner = await store.get(value.objectNumber);
+        if (!owner || owner.generationNumber !== reference.generationNumber || owner.stream) return;
+        value = owner.value;
+        path = [];
+      }
+      if (!value) return;
+      if (i === location.path.length) return { value, owner, location: { reference, path } };
+      const key = location.path[i];
+      path.push(key);
+      value = typeof key === "number" ? value.kind === "array" ? value.items[key] : void 0 : value.kind === "dict" ? dictGet(value, key) : void 0;
+    }
+  }
+  async function identity(location) {
+    return (await names.intern(`${location.reference.objectNumber}:${location.reference.generationNumber}:${JSON.stringify(location.path)}`)).index;
+  }
+  async function resolve2(node) {
+    const found = await document2.lookup(node);
+    return found?.stream ? void 0 : found?.value;
+  }
+  async function number(node, fallback) {
+    const value = await resolve2(node);
+    return value?.kind === "number" ? value.value : fallback;
+  }
+  async function push(frame) {
+    head = await appendStoredRecord(backing, { frame, previous: head }, -1, signal);
+  }
+  async function set(location, key, value) {
+    const found = await locate(location);
+    if (found?.value.kind === "dict") {
+      dictSet(found.value, key, value);
+      await store.set(found.owner);
+    }
+  }
+  async function stream(dict, chunks) {
+    const source = await PdfFileSource.fromStream(storage.fs, storage.directory, chunks, { signal });
+    let failed2 = false;
+    try {
+      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;
+    } catch (error) {
+      failed2 = true;
+      throw error;
+    } finally {
+      await source.close().catch((error) => {
+        if (!failed2) throw error;
+      });
+    }
+  }
+  async function append(page2, ref) {
+    const found = await locate(page2);
+    if (found?.value.kind !== "dict") return;
+    const existing = dictGet(found.value, "Contents");
+    if (!existing) {
+      dictSet(found.value, "Contents", ref);
+      await store.set(found.owner);
+      return;
+    }
+    const contents = await locate(child(page2, "Contents"));
+    if (contents?.value.kind === "array") {
+      contents.value.items.push(ref);
+      await store.set(contents.owner);
+    } else {
+      dictSet(found.value, "Contents", cosArray([existing, ref]));
+      await store.set(found.owner);
+    }
+  }
+  async function inheritedResources(page2) {
+    const mark = BigInt(++walk);
+    let location = page2;
+    while (location) {
+      await checkpoint();
+      const found = await locate(location);
+      if (found?.value.kind !== "dict") return;
+      const key = BigInt(await identity(found.location));
+      if (await walkMarks.get(key) === mark) return;
+      await walkMarks.set(key, mark);
+      const node = dictGet(found.value, "Resources");
+      if (node !== void 0) {
+        const value = await resolve2(node);
+        return value?.kind === "dict" ? value : void 0;
+      }
+      location = child(found.location, "Parent");
+    }
+  }
+  const encoder = new TextEncoder();
+  function* textChunks(text, x, y, font) {
+    yield encoder.encode(`
+q BT /${font} 11 Tf `);
+    const normalized = text.replaceAll("\r\n", "\n");
+    let offset = 0, line = 0;
+    while (offset <= normalized.length) {
+      signal.throwIfAborted();
+      const end = normalized.indexOf("\n", offset), part = normalized.slice(offset, end < 0 ? normalized.length : end);
+      yield encoder.encode(line++ ? " 0 -13 Td (" : `${Math.round(x)} ${Math.round(y)} Td (`);
+      let escaped = "";
+      for (const char of part) {
+        escaped += (char === "(" || char === ")" || char === "\\" ? "\\" : "") + char;
+        if (escaped.length >= 2048) {
+          yield encoder.encode(escaped);
+          escaped = "";
+        }
+      }
+      if (escaped) yield encoder.encode(escaped);
+      yield encoder.encode(") Tj");
+      if (end < 0) break;
+      offset = end + 1;
+    }
+    yield encoder.encode(" ET Q\n");
+  }
+  async function draw(page2, text, x, y) {
+    if (!text) return;
+    let resources = await locate(child(page2, "Resources"));
+    if (resources?.value.kind !== "dict") {
+      await set(page2, "Resources", cosDict({}));
+      resources = await locate(child(page2, "Resources"));
+    }
+    const resourceLocation = resources.location;
+    let fonts = await locate(child(resourceLocation, "Font"));
+    if (fonts?.value.kind !== "dict") {
+      await set(resourceLocation, "Font", cosDict({}));
+      fonts = await locate(child(resourceLocation, "Font"));
+    }
+    const font = fonts.value, key = dictGet(font, "F1") ? "F_AcroFlat" : "F1";
+    if (!dictGet(font, key)) {
+      dictSet(font, key, await store.allocate(cosDict({ Type: cosName("Font"), Subtype: cosName("Type1"), BaseFont: cosName("Helvetica") })));
+      await store.set(fonts.owner);
+    }
+    await append(page2, await stream(cosDict({}), textChunks(text, x, y, key)));
+  }
+  async function textValue(node, arrays) {
+    if (node?.kind === "string") return decodePdfString(node);
+    if (node?.kind === "name" && node.decoded !== "Off") return node.decoded;
+    if (node?.kind === "boolean" && node.value) return "Yes";
+    if (arrays && node?.kind === "array") {
+      let text = "", count = 0;
+      for (const item of node.items) {
+        await checkpoint();
+        const value = await resolve2(item);
+        if (value?.kind === "string" || value?.kind === "name") text += (count++ ? ", " : "") + (value.kind === "string" ? decodePdfString(value) : value.decoded);
+      }
+      return text;
+    }
+    return "";
+  }
+  const root = { reference: document2.crossReference.rootRef, path: [] }, form = child(root, "AcroForm");
+  try {
+    const fieldArray = await locate(child(form, "Fields"));
+    if (fieldArray?.value.kind === "array") for (let i = fieldArray.value.items.length - 1; i >= 0; i--) {
+      await checkpoint();
+      await push({ location: child(fieldArray.location, i), named: false, ft: "", depth: 0 });
+    }
+    while (head !== -1) {
+      const record = (await readStoredRecord(backing, head, signal)).value;
+      head = record.previous;
+      const frame = record.frame;
+      if ("exit" in frame) {
+        await active.set(BigInt(frame.exit), 0n);
+        continue;
+      }
+      await checkpoint(frame.depth);
+      const found = await locate(frame.location);
+      if (found?.value.kind !== "dict") continue;
+      const id = await identity(found.location);
+      if (await active.get(BigInt(id))) continue;
+      await active.set(BigInt(id), 1n);
+      await push({ exit: id });
+      const name = await resolve2(dictGet(found.value, "T")), type = await resolve2(dictGet(found.value, "FT")), named = frame.named || (name?.kind === "string" ? !!decodePdfString(name) : name?.kind === "name" ? !!name.decoded : false), ft = type?.kind === "name" ? type.decoded : frame.ft;
+      const kids = await locate(child(found.location, "Kids"));
+      let descend = false;
+      if (kids?.value.kind === "array" && kids.value.items.length) {
+        let namedKids = false;
+        for (let i = 0; i < kids.value.items.length; i++) {
+          await checkpoint();
+          const kid = await locate(child(kids.location, i));
+          if (kid?.value.kind === "dict" && dictGet(kid.value, "T")) {
+            namedKids = true;
+            break;
+          }
+        }
+        descend = namedKids || !ft || !named;
+        if (descend) for (let i = kids.value.items.length - 1; i >= 0; i--) {
+          await checkpoint();
+          await push({ location: child(kids.location, i), named, ft, depth: frame.depth + 1 });
+        }
+      }
+      if (!descend && named) {
+        const at = await appendStoredRecord(backing, found.location, -1, signal);
+        await fields2.set(BigInt(fieldCount++), BigInt(at));
+      }
+    }
+    let firstPage;
+    for await (const page2 of document2.pages()) {
+      await checkpoint();
+      if (!page2.reference) throw new PdfError("E_PARSE", "Expected retained form page reference");
+      const pageLocation = { reference: page2.reference, path: [] };
+      if (!firstPage) firstPage = pageLocation;
+      if (await pagesSeen.get(BigInt(page2.reference.objectNumber))) continue;
+      await pagesSeen.set(BigInt(page2.reference.objectNumber), 1n);
+      const annotations = await locate(child(pageLocation, "Annots"));
+      if (annotations?.value.kind !== "array") continue;
+      const survivors = [];
+      for (let i = 0; i < annotations.value.items.length; i++) {
+        await checkpoint();
+        const annotation = await locate(child(annotations.location, i));
+        if (annotation?.value.kind !== "dict") {
+          survivors.push(annotations.value.items[i]);
+          continue;
+        }
+        const subtype = await resolve2(dictGet(annotation.value, "Subtype"));
+        if (!(subtype?.kind === "name" && subtype.decoded === "Widget") && !dictGet(annotation.value, "FT") && !dictGet(annotation.value, "T")) {
+          survivors.push(annotations.value.items[i]);
+          continue;
+        }
+        await baked.set(BigInt(await identity(annotation.location)), 1n);
+        const parent = await locate(child(annotation.location, "Parent"));
+        if (parent?.value.kind === "dict") await baked.set(BigInt(await identity(parent.location)), 1n);
+        const rect = await resolve2(dictGet(annotation.value, "Rect")), items = rect?.kind === "array" ? rect.items : [];
+        const x = await number(items[0], 50), y = await number(items[1], 700), ownState = await resolve2(dictGet(annotation.value, "AS"));
+        const value = ownState ?? await resolve2(dictGet(annotation.value, "V") ?? (parent?.value.kind === "dict" ? dictGet(parent.value, "V") ?? dictGet(parent.value, "AS") : void 0));
+        const appearance = await locate(child(annotation.location, "AP"));
+        let normal = appearance?.value.kind === "dict" ? await document2.lookup(dictGet(appearance.value, "N")) : void 0;
+        if (normal?.value.kind === "dict" && !normal.stream && value?.kind === "name" && value.decoded !== "Off") normal = await document2.lookup(dictGet(normal.value, value.decoded));
+        if (normal?.stream && normal.reference && normal.value.kind === "dict") {
+          const inherited = await inheritedResources(pageLocation), resources = { kind: "dict", entries: [...inherited?.entries ?? []] };
+          const old = await resolve2(dictGet(resources, "XObject")), objects = { kind: "dict", entries: [...old?.kind === "dict" ? old.entries : []] };
+          let suffix = 1;
+          while (dictGet(objects, `AcroAppearance${suffix}`)) {
+            await checkpoint();
+            suffix++;
+          }
+          const name = `AcroAppearance${suffix}`, dict = { kind: "dict", entries: [...normal.value.entries] };
+          dictSet(dict, "Type", cosName("XObject"));
+          dictSet(dict, "Subtype", cosName("Form"));
+          const original = await store.get(normal.reference.objectNumber), ref = await store.allocate();
+          if (!original?.stream) throw new PdfError("E_PARSE", "Missing retained appearance stream");
+          await store.set({ ...original, objectNumber: ref.objectNumber, generationNumber: 0, value: dict });
+          dictSet(objects, name, ref);
+          dictSet(resources, "XObject", objects);
+          await set(pageLocation, "Resources", resources);
+          const r2 = await resolve2(items[2]), r3 = await resolve2(items[3]), width = r2?.kind === "number" ? Math.max(1, Math.abs(r2.value - x)) : 20, height = r3?.kind === "number" ? Math.max(1, Math.abs(r3.value - y)) : 20;
+          const bbox = await resolve2(dictGet(dict, "BBox"));
+          let bx0 = 0, by0 = 0, bx1 = width, by1 = height;
+          if (bbox?.kind === "array" && bbox.items.length >= 4) {
+            const b = await Promise.all(bbox.items.slice(0, 4).map(resolve2));
+            if (b.every((v) => v?.kind === "number")) {
+              const n = b;
+              bx0 = Math.min(n[0].value, n[2].value);
+              by0 = Math.min(n[1].value, n[3].value);
+              bx1 = Math.max(n[0].value, n[2].value);
+              by1 = Math.max(n[1].value, n[3].value);
+            }
+          }
+          const matrix2 = await resolve2(dictGet(dict, "Matrix")), values = matrix2?.kind === "array" && matrix2.items.length >= 6 ? await Promise.all(matrix2.items.slice(0, 6).map((v) => number(v, 0))) : [1, 0, 0, 1, 0, 0];
+          const [ma, mb, mc, md, me, mf] = values, corners = [[bx0 * ma + by0 * mc + me, bx0 * mb + by0 * md + mf], [bx1 * ma + by0 * mc + me, bx1 * mb + by0 * md + mf], [bx0 * ma + by1 * mc + me, bx0 * mb + by1 * md + mf], [bx1 * ma + by1 * mc + me, bx1 * mb + by1 * md + mf]];
+          const minX = Math.min(...corners.map((c) => c[0])), minY = Math.min(...corners.map((c) => c[1])), bw = Math.max(1, Math.max(...corners.map((c) => c[0])) - minX), bh = Math.max(1, Math.max(...corners.map((c) => c[1])) - minY);
+          const sx = Number((width / bw).toFixed(6)), sy = Number((height / bh).toFixed(6)), tx = Number((x - minX * sx).toFixed(6)), ty = Number((y - minY * sy).toFixed(6));
+          await append(pageLocation, await stream(cosDict({}), [encoder.encode(`
+q ${sx} 0 0 ${sy} ${tx} ${ty} cm /${name} Do Q
+`)]));
+        } else await draw(pageLocation, await textValue(value, true), x + 2, y + 4);
+      }
+      await set(pageLocation, "Annots", cosArray(survivors));
+    }
+    if (!firstPage) return;
+    for (let i = 0; i < fieldCount; i++) {
+      await checkpoint();
+      const location = (await readStoredRecord(backing, Number(await fields2.get(BigInt(i))), signal)).value, field3 = await locate(location);
+      if (field3?.value.kind !== "dict" || await baked.get(BigInt(await identity(field3.location)))) continue;
+      const rect = await resolve2(dictGet(field3.value, "Rect")), items = rect?.kind === "array" ? rect.items : [], x = await number(items[0], 50), y = await number(items[1], 700), value = await resolve2(dictGet(field3.value, "V") ?? dictGet(field3.value, "AS"));
+      await draw(firstPage, await textValue(value, false), x + 2, y + 4);
+    }
+    const latest = await locate(form);
+    if (latest?.value.kind === "dict") {
+      dictSet(latest.value, "Fields", cosArray([]));
+      dictSet(latest.value, "NeedAppearances", cosBool(false));
+      await store.set(latest.owner);
+    }
+  } 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-info-updates.ts
-import { PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage15 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/retained-bookmarks.ts
-import { PagedStorage as PagedStorage13 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
 async function setRetainedBookmarks(store, storage, root, pageCount, pageReference, bookmarks, signal, maxDepth = Infinity) {
   if (!pageCount) return;
   const catalog = await store.get(root.objectNumber);
   if (catalog?.value.kind !== "dict") return;
-  const frames = new PagedStorage13({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const frames = new PagedStorage14({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const base = frames.allocate(0);
   let depth = 0, capacity = 0, failed = false, work = 0;
   async function write(index2, frame) {
@@ -62513,7 +63282,7 @@ 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 pages = new PagedStorage15({ 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;
@@ -62755,7 +63524,7 @@ async function appendRetainedAttachments(document2, target, storage, attachments
 }
 
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
-import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage15 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage16 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/form-appearance-chunks.ts
 function* serializeFormAppearanceChunks(text, options) {
@@ -62843,7 +63612,7 @@ function* operators(text, options) {
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
 async function generateRetainedFormAppearances(document2, store, storage, signal, update) {
   if (!document2.crossReference.rootRef) return;
-  const backing = new PagedStorage15({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable8(backing);
+  const backing = new PagedStorage16({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable9(backing);
   let head = -1, failed = false, work = 0;
   let matched = false;
   let defaultAppearance;
@@ -62982,21 +63751,21 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
         continue;
       }
       await checkpoint(frame.depth);
-      const field2 = await locate(frame.location);
-      if (field2?.value.kind !== "dict") continue;
-      if (!field2.location.path.length) {
-        const id = field2.location.reference.objectNumber;
+      const field3 = await locate(frame.location);
+      if (field3?.value.kind !== "dict") continue;
+      if (!field3.location.path.length) {
+        const id = field3.location.reference.objectNumber;
         if (await active.get(BigInt(id)) === 1n) continue;
         await active.set(BigInt(id), 1n);
         await push({ exit: id });
       }
-      const name = await resolve2(dictGet(field2.value, "T")), ft = await resolve2(dictGet(field2.value, "FT"));
+      const name = await resolve2(dictGet(field3.value, "T")), ft = await resolve2(dictGet(field3.value, "FT"));
       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"));
+      const inherited = { ...frame, named, ft: ft?.kind === "name" ? ft.decoded : frame.ft, ff: await number(dictGet(field3.value, "Ff"), frame.ff), q: await number(dictGet(field3.value, "Q"), frame.q) };
+      const maxLen = await resolve2(dictGet(field3.value, "MaxLen"));
       if (maxLen?.kind === "number") inherited.maxLen = maxLen.value;
-      const kids = await locate(child(field2.location, "Kids"));
+      const kids = await locate(child(field3.location, "Kids"));
       if (kids?.value.kind === "array" && kids.value.items.length) {
         let namedKids = false;
         for (let i = 0; i < kids.value.items.length; i++) {
@@ -63021,14 +63790,14 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
         matched = true;
         const value2 = update.value;
         if (typeof value2 === "boolean" || inherited.ft === "Btn") {
-          const on = await onValue(field2.location);
+          const on = await onValue(field3.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);
+          dictSet(field3.value, "FT", cosName("Btn"));
+          dictSet(field3.value, "V", state);
+          dictSet(field3.value, "AS", state);
+          await store.set(field3.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]));
@@ -63040,13 +63809,13 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
           }
           continue;
         }
-        if (!inherited.ft) dictSet(field2.value, "FT", cosName("Tx"));
+        if (!inherited.ft) dictSet(field3.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));
+        dictSet(field3.value, "V", multi ? cosArray(selected.map((value3) => cosString(value3))) : cosString(text2));
         if (inherited.ft === "Ch") {
-          const choices = await resolve2(dictGet(field2.value, "Opt")), indices = [];
+          const choices = await resolve2(dictGet(field3.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]);
@@ -63069,10 +63838,10 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
               }
             }
           }
-          if (indices.length) dictSet(field2.value, "I", cosArray(indices.map((value3) => cosNumber(value3))));
+          if (indices.length) dictSet(field3.value, "I", cosArray(indices.map((value3) => cosNumber(value3))));
         }
-        await store.set(field2.owner);
-        await synthesize(field2.location, text2, inherited);
+        await store.set(field3.owner);
+        await synthesize(field3.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]));
@@ -63080,24 +63849,24 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
         }
         continue;
       }
-      const value = await resolve2(dictGet(field2.value, "V"));
+      const value = await resolve2(dictGet(field3.value, "V"));
       if (!value) continue;
-      const appearance = await resolve2(dictGet(field2.value, "AP")), hasNormal = appearance?.kind === "dict" && dictGet(appearance, "N") !== void 0;
+      const appearance = await resolve2(dictGet(field3.value, "AP")), hasNormal = appearance?.kind === "dict" && dictGet(appearance, "N") !== void 0;
       if (!force && hasNormal) continue;
       if (inherited.ft === "Btn") {
-        dictSet(field2.value, "AS", cosName(value.kind === "name" ? value.decoded : value.kind === "string" ? decodePdfString(value) : "Off"));
+        dictSet(field3.value, "AS", cosName(value.kind === "name" ? value.decoded : value.kind === "string" ? decodePdfString(value) : "Off"));
         if (!hasNormal) {
-          const name2 = await onValue(field2.location), dict = cosDict({ Type: cosName("XObject"), Subtype: cosName("Form"), BBox: cosArray([0, 0, 12, 12].map((v) => cosNumber(v))) });
+          const name2 = await onValue(field3.location), dict = cosDict({ Type: cosName("XObject"), Subtype: cosName("Form"), BBox: cosArray([0, 0, 12, 12].map((v) => cosNumber(v))) });
           const on = await stream(dict, [new TextEncoder().encode("q 0 0 0 rg 2 2 8 8 re f Q\n")]);
           const off = await stream(dict, [new TextEncoder().encode("q Q\n")]);
-          dictSet(field2.value, "AP", cosDict({ N: cosDict({ [name2]: on, Off: off }) }));
+          dictSet(field3.value, "AP", cosDict({ N: cosDict({ [name2]: on, Off: off }) }));
         }
-        await store.set(field2.owner);
+        await store.set(field3.owner);
         continue;
       }
       let text = value.kind === "string" ? decodePdfString(value) : value.kind === "name" ? value.decoded : "";
       if (inherited.ft === "Ch") {
-        const choices = await resolve2(dictGet(field2.value, "Opt"));
+        const choices = await resolve2(dictGet(field3.value, "Opt"));
         if (choices?.kind === "array") for (const choice of choices.items) {
           await checkpoint();
           const pair = await resolve2(choice);
@@ -63110,7 +63879,7 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
           }
         }
       }
-      await synthesize(field2.location, text, inherited);
+      await synthesize(field3.location, text, 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]));
@@ -63121,8 +63890,8 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
       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));
+        const field3 = 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(field3));
         await store.set(fields3.owner);
       }
     }
@@ -63142,17 +63911,17 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
 }
 
 // packages/pdf-ast/src/edit/retained-flatten-annotations.ts
-import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage19 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/retained-content-edit.ts
-import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage16 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage17 } 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 PagedStorage16({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
-    this.counts = new IntegerTable9(this.backing);
+    this.backing = new PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+    this.counts = new IntegerTable10(this.backing);
     this.identities = new PdfNameIndex(storage, Infinity, signal);
   }
   store;
@@ -63223,14 +63992,14 @@ var RetainedContentEditor = class _RetainedContentEditor {
 };
 
 // packages/pdf-ast/src/edit/retained-name-replacement.ts
-import { PagedStorage as PagedStorage17 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage18 } 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 PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), length = oldName.length + 1;
+  const table = new PagedStorage18({ 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;
@@ -63308,10 +64077,10 @@ async function* replaceRetainedPdfName(input, oldName, newName, storage, options
 }
 
 // packages/pdf-ast/src/edit/retained-draw-text.ts
-import { PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage19 } 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 PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const backing = new PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   let failed = false;
   try {
     const name = await font(), position = backing.allocate(text.length);
@@ -63387,7 +64156,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 PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+      const survivorStorage = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
       const survivorBase = survivorStorage.allocate(0);
       let pageFailed = false;
       try {
@@ -63473,7 +64242,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 PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), renames = new IntegerTable10(backing), names = new PdfNameIndex(storage, Infinity, signal);
+            const backing = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), renames = new IntegerTable11(backing), names = new PdfNameIndex(storage, Infinity, signal);
             let appearanceFailed = false, count = 0;
             try {
               if (content.size) {
@@ -63592,11 +64361,11 @@ q ${scaleX} 0 0 ${scaleY} ${tx} ${ty} cm${matSuffix}
 }
 
 // packages/pdf-ast/src/edit/retained-name-map.ts
-import { PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage21 } 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 PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pending = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const trie = new PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pending = new PagedStorage21({ 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);
@@ -63878,7 +64647,7 @@ async function preserveRetainedStamp(document2, source, page2, other, store, edi
 }
 
 // packages/pdf-ast/src/edit/retained-stamps.ts
-import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage21 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage22 } 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;
@@ -63889,7 +64658,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 PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable11(backing);
+      const backing = new PagedStorage22({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable12(backing);
       let stampFailed = false;
       async function clone(node, depth = 0) {
         await checkpoint();
@@ -64075,12 +64844,12 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
 }
 
 // packages/pdf-ast/src/edit/retained-inline-images.ts
-import { PagedStorage as PagedStorage22 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage23 } 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 PagedStorage22({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const paths = new PagedStorage23({ 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" };
@@ -64172,7 +64941,7 @@ async function externalizeRetainedInlineImages(document2, store, storage, option
 }
 
 // packages/pdf-ast/src/edit/retained-resource-pruning.ts
-import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage23 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage24 } 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;
@@ -64254,7 +65023,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 PagedStorage23({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), found = new IntegerTable12(backing);
+    const backing = new PagedStorage24({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), found = new IntegerTable13(backing);
     let failed = false;
     try {
       const referenced = async (name) => await found.get(BigInt((await names.intern(name)).index)) !== void 0;
@@ -64384,7 +65153,7 @@ async function flattenRetainedRotations(document2, store, storage, signal) {
 }
 
 // packages/pdf-ast/src/edit/retained-attachment-edits.ts
-import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage24 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
 var PdfDuplicateAttachment = class extends PdfError {
   constructor(key) {
     super("E_CAPABILITY", `Duplicate attachment key: ${key}`);
@@ -64395,7 +65164,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 PagedStorage24({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), first = new IntegerTable13(backing), removals = new IntegerTable13(backing);
+  const backing = new PagedStorage25({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), first = new IntegerTable14(backing), removals = new IntegerTable14(backing);
   let failed = false, count = 0, work = 0;
   async function checkpoint() {
     signal.throwIfAborted();
@@ -64597,13 +65366,13 @@ async function* retainedAttachmentNameTokens(document2, storage, root, signal, r
 }
 
 // packages/pdf-ast/src/edit/retained-graph.ts
-import { PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage26 } 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 PagedStorage25({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const pages = new PagedStorage26({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const base = pages.allocate(0);
   let count = 0, document2;
   let closing;
@@ -64730,6 +65499,10 @@ async function editRetainedDocument(source, storage, options = {}) {
       await generateRetainedFormAppearances(document2, store, storage, signal);
       addedObjects = true;
     }
+    if (options.flattenForms) {
+      await flattenRetainedForms(document2, store, storage, signal);
+      addedObjects = true;
+    }
     if (options.removeInfo) {
       await removeRoot(["Metadata"]);
       const found = await document2.lookup(infoRef);
@@ -64837,10 +65610,10 @@ async function* copyRetainedAttachments(document2, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/retained-object-order.ts
-import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage26 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage27 } from "@poe-platform/safe-fs/storage";
 async function* retainedObjectOrder(document2, source, storage, signal) {
-  const backing = new PagedStorage26({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
-  const seen = new IntegerTable14(backing), streams = new IntegerTable14(backing);
+  const backing = new PagedStorage27({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const seen = new IntegerTable15(backing), streams = new IntegerTable15(backing);
   let failed = false, work = 0;
   async function candidate(number) {
     signal.throwIfAborted();
@@ -64854,7 +65627,7 @@ async function* retainedObjectOrder(document2, source, storage, signal) {
   try {
     if (document2.crossReference.revisionCount) {
       for (const kind of ["uncompressed", "compressed"]) {
-        const revisions = new IntegerTable14(backing);
+        const revisions = new IntegerTable15(backing);
         let offset = document2.crossReference.xrefOffset;
         while (offset !== void 0 && await revisions.get(BigInt(offset)) === void 0) {
           await revisions.set(BigInt(offset), 1n);
@@ -64976,14 +65749,14 @@ async function* encryptRetainedPdfChunks(source, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/qpdf-json-values.ts
-import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage27 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage28 } from "@poe-platform/safe-fs/storage";
 var QpdfJsonValues = class _QpdfJsonValues {
   constructor(tree, storage, signal) {
     this.tree = tree;
     this.signal = signal;
-    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);
+    this.scratch = new PagedStorage28({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+    this.first = new IntegerTable16(this.scratch, 64);
+    this.next = new IntegerTable16(this.scratch, 64);
   }
   tree;
   signal;
@@ -65081,7 +65854,7 @@ var QpdfJsonValues = class _QpdfJsonValues {
       await this.cooperate();
       const header2 = await this.tree.describe(position);
       if (header2.kind === "object") {
-        const hashes = new IntegerTable15(this.scratch, 64);
+        const hashes = new IntegerTable16(this.scratch, 64);
         let head = 0, tail = 0;
         for await (const { key } of order.entries(position)) {
           let hash2 = 0;
@@ -65374,19 +66147,19 @@ var QpdfJsonValues = class _QpdfJsonValues {
 };
 
 // packages/pdf-ast/src/cos/qpdf-json-document.ts
-import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage28 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable17, PagedStorage as PagedStorage29 } 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 PagedStorage28(
+    this.backing = new PagedStorage29(
       { fs: storage.fs, cwd: storage.directory, env: {}, signal: this.signal },
       4
     );
-    this.positions = new IntegerTable16(this.backing, 64);
-    this.order = new IntegerTable16(this.backing, 64);
-    this.catalogs = new IntegerTable16(this.backing, 64);
+    this.positions = new IntegerTable17(this.backing, 64);
+    this.order = new IntegerTable17(this.backing, 64);
+    this.catalogs = new IntegerTable17(this.backing, 64);
   }
   storage;
   rootRef;
@@ -65449,7 +66222,7 @@ var QpdfJsonDocument = class _QpdfJsonDocument {
       env: {},
       signal: this.signal
     };
-    const tape = new PagedStorage28(context, 4), scratch = new PagedStorage28(context, 4);
+    const tape = new PagedStorage29(context, 4), scratch = new PagedStorage29(context, 4);
     let values, failed = false, work = 0;
     const cooperate = async (units = 1) => {
       this.signal.throwIfAborted();
@@ -65672,12 +66445,12 @@ 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";
+import { IntegerTable as IntegerTable19, PagedStorage as PagedStorage31 } 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";
+import { IntegerTable as IntegerTable18, PagedStorage as PagedStorage30 } 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);
+  const backing = new PagedStorage30({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), tokens = new IntegerTable18(backing), starts = new IntegerTable18(backing), children = new IntegerTable18(backing), visited = new IntegerTable18(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() {
@@ -65937,7 +66710,7 @@ var FormText = class {
 };
 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 textBacking = new PagedStorage31(context, 2), state = new PagedStorage31(context, 4), names = new PdfNameIndex(storage, Infinity, signal), values = new IntegerTable19(state);
   const text = new FormText(textBacking, signal);
   let count = 0, failed = false, work = 0;
   async function checkpoint() {
@@ -65963,7 +66736,7 @@ async function* parseRetainedFormData(source, storage, options = {}) {
     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 = "";
+      let position = 0, head = -1, field3 = "";
       while (position < text.length) {
         await checkpoint();
         const lt = await text.indexOf("<", position);
@@ -65976,7 +66749,7 @@ async function* parseRetainedFormData(source, storage, options = {}) {
         if (raw.startsWith("/")) {
           if (raw.slice(1).trim().toLowerCase() === "field" && head !== -1) {
             const row = (await readStoredRecord(state, head, signal)).value;
-            field2 = row.field;
+            field3 = row.field;
             head = row.previous;
           }
           continue;
@@ -65993,14 +66766,14 @@ async function* parseRetainedFormData(source, storage, options = {}) {
             }
           }
           if (!selfClosing) {
-            head = await appendStoredRecord(state, { field: field2, previous: head }, -1, signal);
-            field2 = field2 && part ? `${field2}.${part}` : field2 || part;
+            head = await appendStoredRecord(state, { field: field3, previous: head }, -1, signal);
+            field3 = field3 && part ? `${field3}.${part}` : field3 || 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);
+            if (field3) await set(field3, value === "Off" ? false : value === "Yes" || value === "On" ? true : value, true);
             position = close + 8;
           }
         }
@@ -66173,6 +66946,9 @@ export {
   encodeRgbaToPng,
   encodeRgbaToPngSteps,
   encodeRunLength,
+  encodeSvgImageChunks,
+  encodeSvgPathDataChunks,
+  encodeSvgPathPaintChunks,
   encodeTiff,
   encodeTiffSteps,
   encodeWinAnsiBytes,