@poe-platform/safe-bash 0.1.788 → 0.1.790

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

@@ -4,7 +4,7 @@ import {
 
 // packages/safe-bash-command-wkhtmltopdf/dist/index.js
 init_buffer();
-import { yieldTurn } from "../safe-bash-contracts/yield.js";
+import { drainCooperativeSteps } from "../safe-bash-contracts/yield.js";
 import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/command.js";
 import { readBytes, writeBytes } from "../safe-bash-contracts/io.js";
 import { shellValueByteLength } from "../safe-bash-contracts/value.js";
@@ -3646,6 +3646,11 @@ function tokenizeCos(bytes, start = 0, end = bytes.length) {
   }
   return tokens;
 }
+function drainWork(work) {
+  let step = work.next();
+  while (!step.done) step = work.next();
+  return step.value;
+}
 function bytesToString3(bytes) {
   if (typeof bytes !== "object" || bytes?.length === void 0) {
     throw new Error("Invalid argument for bytesToString");
@@ -4067,7 +4072,9 @@ function concatByteArrays(chunks) {
   }
   return out;
 }
-function serializeCosDocument(options) {
+function* serializeCosDocumentSteps(options) {
+  yield;
+  let work = 0;
   const maxOutputBytes = options.maxOutputBytes ?? Infinity;
   const maxObjects = options.maxObjects ?? Infinity;
   const sorted = [...options.objects].sort((a, b) => a.objectNumber - b.objectNumber);
@@ -4090,6 +4097,7 @@ function serializeCosDocument(options) {
     const packable = [];
     const direct = [];
     for (const obj of sorted) {
+      if (++work % 16 === 0) yield;
       const isLinearized = obj.value.kind === "dict" && dictGet(obj.value, "Linearized") !== void 0;
       if (obj.value.kind !== "stream" && obj.generationNumber === 0 && !isLinearized) {
         packable.push(obj);
@@ -4104,6 +4112,7 @@ function serializeCosDocument(options) {
       const headerPairs = [];
       let relOffset = 0;
       for (const pObj of packable) {
+        if (++work % 16 === 0) yield;
         headerPairs.push(`${pObj.objectNumber} ${relOffset}`);
         const bBytes = serializeCosNodeBytes(pObj.value);
         const nl = textEncoder2.encode("\n");
@@ -4129,6 +4138,7 @@ function serializeCosDocument(options) {
       ];
       const directOffsets = /* @__PURE__ */ new Map();
       for (const dObj of allDirect) {
+        if (++work % 16 === 0) yield;
         directOffsets.set(dObj.objectNumber, { offset, generation: dObj.generationNumber });
         const prefix = textEncoder2.encode(`${dObj.objectNumber} ${dObj.generationNumber} obj
 `);
@@ -4139,6 +4149,7 @@ function serializeCosDocument(options) {
       }
       const compressedMap = /* @__PURE__ */ new Map();
       for (let idx = 0; idx < packable.length; idx++) {
+        if (++work % 16 === 0) yield;
         compressedMap.set(packable[idx].objectNumber, idx);
       }
       const xrefOffset2 = offset;
@@ -4156,6 +4167,7 @@ function serializeCosDocument(options) {
       };
       writeEntry7(0, 0, 0, 65535);
       for (let i = 1; i < size2; i++) {
+        if (++work % 16 === 0) yield;
         if (i === xrefStmNum) {
           writeEntry7(i, 1, xrefOffset2, 0);
         } else if (compressedMap.has(i)) {
@@ -4236,6 +4248,7 @@ ${xrefOffset2}
     let pageCount = 0;
     let firstPageObjNum = options.rootRef.objectNumber;
     for (const o of sorted) {
+      if (++work % 16 === 0) yield;
       if (o.value.kind === "dict") {
         const t = dictGet(o.value, "Type");
         if (t?.kind === "name" && t.decoded === "Page") {
@@ -4283,6 +4296,7 @@ ${xrefOffset2}
   }
   const objectOffsets = /* @__PURE__ */ new Map();
   for (const obj of sorted) {
+    if (++work % 16 === 0) yield;
     objectOffsets.set(obj.objectNumber, { offset, generation: obj.generationNumber });
     let value = obj.value;
     if (options.normalizeContent && value.kind === "stream" && value.decodedBytes) {
@@ -4314,6 +4328,7 @@ ${xrefOffset2}
 0000000000 65535 f 
 `;
   for (let i = 1; i < size; i++) {
+    if (++work % 16 === 0) yield;
     const entry = objectOffsets.get(i);
     if (entry) {
       xrefText += `${String(entry.offset).padStart(10, "0")} ${String(entry.generation).padStart(5, "0")} n 
@@ -4360,6 +4375,7 @@ ${xrefOffset}
     let endFirstPage = xrefOffset;
     const sortedOffsets = [...objectOffsets.entries()].sort((a, b) => a[1].offset - b[1].offset);
     for (let i = 0; i < sortedOffsets.length; i++) {
+      if (++work % 16 === 0) yield;
       const [objNum, info3] = sortedOffsets[i];
       const nextOff = sortedOffsets[i + 1]?.[1].offset ?? xrefOffset;
       if (objNum === hintObjAfter.objectNumber) {
@@ -4393,6 +4409,9 @@ ${xrefOffset}
   }
   return fullBytes;
 }
+function serializeCosDocument(options) {
+  return drainWork(serializeCosDocumentSteps(options));
+}
 function appendIncrementalRevision(originalBytes, doc, updatedObjects) {
   const chunks = [originalBytes, textEncoder2.encode("\n")];
   let offset = originalBytes.length + 1;
@@ -4631,48 +4650,30 @@ function encryptPdfBuffer(state, objectNumber, generationNumber, plaintext) {
   const objKey = md5Bytes([state.fileKey, suffix]).subarray(0, Math.min(16, state.fileKey.length + 5));
   return rc4Transform(objKey, plaintext);
 }
-function transformNodeStringsAndStreams(node, transform, transformStream) {
+function* transformNodeStringsAndStreamsSteps(node, transform, transformStream) {
+  yield;
   switch (node.kind) {
     case "string":
-      return {
-        kind: "string",
-        format: "hex",
-        bytes: transform(node.bytes)
-      };
-    case "array":
-      return {
-        kind: "array",
-        items: node.items.map((item) => transformNodeStringsAndStreams(item, transform, transformStream))
-      };
+      return { kind: "string", format: "hex", bytes: transform(node.bytes) };
+    case "array": {
+      const items = [];
+      for (const item of node.items) items.push(yield* transformNodeStringsAndStreamsSteps(item, transform, transformStream));
+      return { kind: "array", items };
+    }
     case "dict": {
-      const type = dictGet(node, "Type");
-      const fieldType = dictGet(node, "FT");
-      const byteRange = dictGet(node, "ByteRange");
+      const type = dictGet(node, "Type"), fieldType = dictGet(node, "FT"), byteRange = dictGet(node, "ByteRange");
       const signature = type?.kind === "name" && type.decoded === "Sig" || fieldType?.kind === "name" && fieldType.decoded === "Sig" || byteRange?.kind === "array" && dictGet(node, "Filter")?.kind === "name";
-      return {
-        kind: "dict",
-        entries: node.entries.map((e) => ({
-          key: e.key,
-          value: signature && e.key.decoded === "Contents" ? e.value : transformNodeStringsAndStreams(e.value, transform, transformStream)
-        }))
-      };
+      const entries = [];
+      for (const e of node.entries) entries.push({ key: e.key, value: signature && e.key.decoded === "Contents" ? e.value : yield* transformNodeStringsAndStreamsSteps(e.value, transform, transformStream) });
+      return { kind: "dict", entries };
     }
     case "stream": {
       const type = dictGet(node.dict, "Type");
       if (type?.kind === "name" && type.decoded === "XRef") return node;
       const stream = transformStream ? transformStream(node) : { ...node, rawBytes: transform(node.rawBytes) };
-      const updatedDict = {
-        kind: "dict",
-        entries: stream.dict.entries.map((e) => ({
-          key: e.key,
-          value: e.key.decoded === "Length" ? cosNumber(stream.rawBytes.length) : transformNodeStringsAndStreams(e.value, transform, transformStream)
-        }))
-      };
-      return {
-        kind: "stream",
-        dict: updatedDict,
-        rawBytes: stream.rawBytes
-      };
+      const entries = [];
+      for (const e of stream.dict.entries) entries.push({ key: e.key, value: e.key.decoded === "Length" ? cosNumber(stream.rawBytes.length) : yield* transformNodeStringsAndStreamsSteps(e.value, transform, transformStream) });
+      return { kind: "stream", dict: { kind: "dict", entries }, rawBytes: stream.rawBytes };
     }
     default:
       return node;
@@ -4741,7 +4742,8 @@ function createR6Encryption(userPassword, ownerPassword, pMask) {
     StrF: cosName("StdCF")
   }) };
 }
-function encryptCosDocument(doc, options = {}) {
+function* encryptCosDocumentSteps(doc, options = {}) {
+  yield;
   const userPassword = options.userPassword ?? "";
   const ownerPassword = options.ownerPassword ?? userPassword;
   const revision = options.revision ?? 6;
@@ -4763,14 +4765,15 @@ function encryptCosDocument(doc, options = {}) {
   const encryptObjNum = maxObjNum + 1;
   const encryptedObjects = [];
   for (const obj of doc.objects.values()) {
-    const transformed = transformNodeStringsAndStreams(
+    yield;
+    const transformed = yield* transformNodeStringsAndStreamsSteps(
       obj.value,
       (plain) => encryptPdfBuffer(state, obj.objectNumber, obj.generationNumber, plain)
     );
     encryptedObjects.push({ objectNumber: obj.objectNumber, generationNumber: obj.generationNumber, value: transformed });
   }
   encryptedObjects.push({ objectNumber: encryptObjNum, generationNumber: 0, value: encryptDict });
-  return serializeCosDocument({
+  return yield* serializeCosDocumentSteps({
     objects: encryptedObjects,
     rootRef: doc.rootRef,
     infoRef: doc.infoRef,
@@ -4820,17 +4823,19 @@ function decryptStream(doc, stream, transform) {
   }
   return { kind: "stream", dict, rawBytes: bytes };
 }
-function decryptCosDocument(doc, state) {
+function* decryptCosDocumentSteps(doc, state) {
+  yield;
   const encryptObjNum = doc.encryptRef?.objectNumber;
   const handler = securityHandlers.get(state);
   for (const [num, obj] of doc.objects.entries()) {
+    yield;
     if (num === encryptObjNum || handler?.plaintextObjects.has(num)) continue;
     if (obj.value.kind === "stream") {
       const type = doc.resolve(dictGet(obj.value.dict, "Type"));
       if (type?.kind === "name" && (type.decoded === "XRef" || type.decoded === "Metadata" && !state.encryptMetadata)) continue;
     }
     const transform = handler?.factory.createCipherTransform(obj.objectNumber, obj.generationNumber);
-    const decrypted = transformNodeStringsAndStreams(
+    const decrypted = yield* transformNodeStringsAndStreamsSteps(
       obj.value,
       (cipher) => decryptPdfBuffer(state, obj.objectNumber, obj.generationNumber, cipher),
       transform ? (stream) => decryptStream(doc, stream, transform) : void 0
@@ -4838,9 +4843,12 @@ function decryptCosDocument(doc, state) {
     doc.objects.set(num, { objectNumber: obj.objectNumber, generationNumber: obj.generationNumber, value: decrypted, span: obj.span });
   }
 }
-function parseNodeFromLexer(lexer, bytes, maxDepth, repair = false) {
+function* parseNodeFromLexerSteps(lexer, bytes, maxDepth, repair = false) {
+  yield;
+  let work = 0;
   const stack = [];
   while (true) {
+    if (++work % 16 === 0) yield;
     const tok = lexer.nextToken();
     const parent = stack.at(-1);
     if (!tok) {
@@ -5034,7 +5042,8 @@ function parseHeaderVersion(bytes) {
   }
   return head.slice(idx + 5, idx + 8);
 }
-function parseObjectAtOffset(bytes, offset, maxRecursionDepth, repair = false) {
+function* parseObjectAtOffsetSteps(bytes, offset, maxRecursionDepth, repair = false) {
+  yield;
   const lexer = new CosByteLexer(bytes, offset);
   const objNumTok = lexer.nextToken();
   const genNumTok = lexer.nextToken();
@@ -5042,7 +5051,7 @@ function parseObjectAtOffset(bytes, offset, maxRecursionDepth, repair = false) {
   if (objNumTok?.kind !== "number" || genNumTok?.kind !== "number" || objKwTok?.kind !== "keyword" || objKwTok.value !== "obj") {
     throw new PdfError("E_PARSE", `Malformed indirect object header at byte offset ${offset}`);
   }
-  const value = parseNodeFromLexer(lexer, bytes, maxRecursionDepth, repair);
+  const value = yield* parseNodeFromLexerSteps(lexer, bytes, maxRecursionDepth, repair);
   if (!value) {
     throw new PdfError("E_PARSE", `Empty indirect object ${objNumTok.value} at offset ${offset}`);
   }
@@ -5053,7 +5062,9 @@ function parseObjectAtOffset(bytes, offset, maxRecursionDepth, repair = false) {
     span: { start: objNumTok.span.start, end: lexer.offset }
   };
 }
-function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursionDepth, maxObjects) {
+function* parseXrefRevisionAtSteps(bytes, xrefOffset, maxDecompressedBytes, maxRecursionDepth, maxObjects) {
+  yield;
+  let work = 0;
   if (xrefOffset < 0 || xrefOffset >= bytes.length) {
     throw new PdfError("E_PARSE", `Invalid xref offset: ${xrefOffset}`);
   }
@@ -5065,6 +5076,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
   if (firstTok.kind === "keyword" && firstTok.value === "xref") {
     const entries2 = /* @__PURE__ */ new Map();
     while (true) {
+      if (++work % 16 === 0) yield;
       const saved = lexer.offset;
       const tok = lexer.nextToken();
       if (!tok) {
@@ -5088,6 +5100,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
       }
       if (count > maxObjects + 1) throw new PdfError("E_LIMIT", "PDF object count limit exceeded while reading xref entries");
       for (let i = 0; i < count; i++) {
+        if (++work % 16 === 0) yield;
         const offTok = lexer.nextToken();
         const genTok = lexer.nextToken();
         const flagTok = lexer.nextToken();
@@ -5113,7 +5126,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
         if (entries2.size > maxObjects + 1) throw new PdfError("E_LIMIT", "PDF object count limit exceeded while reading xref entries");
       }
     }
-    const trailerNode = parseNodeFromLexer(lexer, bytes, maxRecursionDepth);
+    const trailerNode = yield* parseNodeFromLexerSteps(lexer, bytes, maxRecursionDepth);
     if (!trailerNode || trailerNode.kind !== "dict") {
       throw new PdfError("E_PARSE", "Missing trailer dictionary after xref table");
     }
@@ -5125,7 +5138,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
       previousXrefOffset: prevNode2?.kind === "number" ? prevNode2.value : void 0
     };
   }
-  const xrefObj = parseObjectAtOffset(bytes, xrefOffset, maxRecursionDepth);
+  const xrefObj = yield* parseObjectAtOffsetSteps(bytes, xrefOffset, maxRecursionDepth);
   if (xrefObj.value.kind !== "stream") {
     throw new PdfError("E_PARSE", `Expected xref table or XRef stream at offset ${xrefOffset}`);
   }
@@ -5146,6 +5159,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
   if (indexArray) {
     if (indexArray.kind !== "array" || indexArray.items.length % 2 !== 0) throw new PdfError("E_PARSE", "Invalid XRef range fields");
     for (let i = 0; i < indexArray.items.length; i += 2) {
+      if (++work % 16 === 0) yield;
       const first = indexArray.items[i];
       const count = indexArray.items[i + 1];
       if (first?.kind !== "number" || count?.kind !== "number" || !Number.isSafeInteger(first.value) || first.value < 0 || !Number.isSafeInteger(count.value) || count.value < 0 || !Number.isSafeInteger(first.value + count.value)) {
@@ -5168,9 +5182,11 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
     return v;
   };
   for (const [startObj, count] of subsections) {
+    if (++work % 16 === 0) yield;
     if (count > (decoded.length - pos) / stride) throw new PdfError("E_PARSE", "Truncated XRef stream");
     if (count > maxObjects + 1) throw new PdfError("E_LIMIT", "PDF object count limit exceeded while reading xref entries");
     for (let i = 0; i < count; i++) {
+      if (++work % 16 === 0) yield;
       const objNum = startObj + i;
       const field0 = w0 > 0 ? readInt(w0) : 1;
       const field1 = readInt(w1);
@@ -5216,12 +5232,16 @@ function isAsciiWhitespace(ch3) {
 function isAsciiDigit(ch3) {
   return ch3 >= 48 && ch3 <= 57;
 }
-function repairScanCosDocument(bytes, maxObjects, maxRecursionDepth) {
+function* repairScanCosDocumentSteps(bytes, maxObjects, maxRecursionDepth) {
+  yield;
+  let work = 0;
   const objects = /* @__PURE__ */ new Map();
   const trailers = [];
   let pos = 0;
   while (pos < bytes.length) {
+    if (++work % 16 === 0) yield;
     while (pos < bytes.length && !isAsciiDigit(bytes[pos])) {
+      if (++work % 16 === 0) yield;
       if (bytes[pos] === 37) {
         while (pos < bytes.length && bytes[pos] !== 10 && bytes[pos] !== 13) pos++;
         continue;
@@ -5231,7 +5251,7 @@ function repairScanCosDocument(bytes, maxObjects, maxRecursionDepth) {
         try {
           const token = lexer.nextToken();
           if (token?.kind === "keyword" && token.value === "trailer") {
-            const trailer = parseNodeFromLexer(lexer, bytes, maxRecursionDepth, true);
+            const trailer = yield* parseNodeFromLexerSteps(lexer, bytes, maxRecursionDepth, true);
             if (trailer?.kind === "dict") trailers.push(trailer);
             pos = lexer.offset;
             continue;
@@ -5264,7 +5284,7 @@ function repairScanCosDocument(bytes, maxObjects, maxRecursionDepth) {
     bytes[pos + 3] === 40)) {
       pos += 3;
       try {
-        const parsed = parseObjectAtOffset(bytes, headerStart, maxRecursionDepth, true);
+        const parsed = yield* parseObjectAtOffsetSteps(bytes, headerStart, maxRecursionDepth, true);
         objects.set(parsed.objectNumber, parsed);
         if (parsed.value.kind === "stream") {
           const type = dictGet(parsed.value.dict, "Type");
@@ -5281,13 +5301,17 @@ function repairScanCosDocument(bytes, maxObjects, maxRecursionDepth) {
   }
   return { objects, trailers };
 }
-function unpackRecoveredObjects(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth) {
+function* unpackRecoveredObjectsSteps(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth) {
+  yield;
+  let work = 0;
   for (const obj of [...objects.values()]) {
+    if (++work % 16 === 0) yield;
     if (obj.value.kind === "stream") {
       const t = dictGet(obj.value.dict, "Type");
       if (t?.kind === "name" && t.decoded === "ObjStm") {
         try {
-          for (const [unpackedNum, unpackedVal] of unpackObjectStream(obj.value, maxDecompressedBytes, maxRecursionDepth, true).entries()) {
+          for (const [unpackedNum, unpackedVal] of (yield* unpackObjectStreamSteps(obj.value, maxDecompressedBytes, maxRecursionDepth, true)).entries()) {
+            if (++work % 16 === 0) yield;
             if (!objects.has(unpackedNum)) {
               objects.set(unpackedNum, {
                 objectNumber: unpackedNum,
@@ -5323,7 +5347,9 @@ function recoveredReferences(objects) {
   }
   return { ...rootRef ? { rootRef } : {}, ...infoRef ? { infoRef } : {} };
 }
-function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth, repair = false) {
+function* unpackObjectStreamSteps(streamObj, maxDecompressedBytes, maxRecursionDepth, repair = false) {
+  yield;
+  let work = 0;
   const nNode = dictGet(streamObj.dict, "N");
   const firstNode = dictGet(streamObj.dict, "First");
   if (nNode?.kind !== "number" || firstNode?.kind !== "number") {
@@ -5333,6 +5359,7 @@ function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth,
   const headerLexer = new CosByteLexer(decoded, 0);
   const pairs = [];
   for (let i = 0; i < nNode.value; i++) {
+    if (++work % 16 === 0) yield;
     const numTok = headerLexer.nextToken();
     const offTok = headerLexer.nextToken();
     if (numTok?.kind === "number" && offTok?.kind === "number") {
@@ -5341,9 +5368,10 @@ function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth,
   }
   const result = /* @__PURE__ */ new Map();
   for (const pair of pairs) {
+    if (++work % 16 === 0) yield;
     try {
       const valLexer = new CosByteLexer(decoded, firstNode.value + pair.relativeOffset);
-      const node = parseNodeFromLexer(valLexer, decoded, maxRecursionDepth, repair);
+      const node = yield* parseNodeFromLexerSteps(valLexer, decoded, maxRecursionDepth, repair);
       if (node) {
         result.set(pair.objectNumber, node);
       }
@@ -5353,7 +5381,9 @@ function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth,
   }
   return result;
 }
-function parseCosDocument(bytes, options = {}) {
+function* parseCosDocumentSteps(bytes, options = {}) {
+  yield;
+  let work = 0;
   const version = parseHeaderVersion(bytes);
   const recovery = options.recovery ?? "strict";
   const maxObjects = options.maxObjects ?? Infinity;
@@ -5388,10 +5418,12 @@ function parseCosDocument(bytes, options = {}) {
         let currentXrefOffset = offsetTok.value;
         const visitedOffsets = /* @__PURE__ */ new Set();
         while (currentXrefOffset !== void 0 && !visitedOffsets.has(currentXrefOffset)) {
+          if (++work % 16 === 0) yield;
           visitedOffsets.add(currentXrefOffset);
-          const rev = parseXrefRevisionAt(bytes, currentXrefOffset, maxDecompressedBytes, maxRecursionDepth, maxObjects);
+          const rev = yield* parseXrefRevisionAtSteps(bytes, currentXrefOffset, maxDecompressedBytes, maxRecursionDepth, maxObjects);
           revisions.push(rev);
           for (const [num, entry] of rev.entries.entries()) {
+            if (++work % 16 === 0) yield;
             if (!mergedXref.has(num)) {
               mergedXref.set(num, entry);
               if (mergedXref.size > maxObjects + 1) throw new PdfError("E_LIMIT", "PDF object count limit exceeded while reading xref entries");
@@ -5424,8 +5456,9 @@ function parseCosDocument(bytes, options = {}) {
   if (!useRepair && rootRef) {
     try {
       for (const [objNum, entry] of mergedXref.entries()) {
+        if (++work % 16 === 0) yield;
         if (entry.type !== "uncompressed") continue;
-        const parsed = parseObjectAtOffset(bytes, entry.offset ?? 0, maxRecursionDepth, recovery === "repair");
+        const parsed = yield* parseObjectAtOffsetSteps(bytes, entry.offset ?? 0, maxRecursionDepth, recovery === "repair");
         if (parsed.objectNumber !== objNum || parsed.generationNumber !== (entry.generationNumber ?? 0)) {
           throw new PdfError("E_PARSE", `Bad uncompressed XRef entry for object ${objNum}`);
         }
@@ -5443,7 +5476,7 @@ function parseCosDocument(bytes, options = {}) {
       throw new PdfError("E_PARSE", "PDF trailer missing /Root reference");
     }
     useRepair = true;
-    const scanned = repairScanCosDocument(bytes, maxObjects, maxRecursionDepth);
+    const scanned = yield* repairScanCosDocumentSteps(bytes, maxObjects, maxRecursionDepth);
     objects = scanned.objects;
     revisions.length = 0;
     mergedXref.clear();
@@ -5478,7 +5511,7 @@ function parseCosDocument(bytes, options = {}) {
     encryptNode = encrypt?.kind === "ref" || encrypt?.kind === "dict" ? encrypt : void 0;
     encryptRef = encrypt?.kind === "ref" ? encrypt : void 0;
     idArray = id?.kind === "array" ? id : void 0;
-    if (!rootRef && !encryptNode) unpackRecoveredObjects(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth);
+    if (!rootRef && !encryptNode) yield* unpackRecoveredObjectsSteps(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth);
     const fallback = recoveredReferences(objects);
     rootRef ??= fallback.rootRef;
     infoRef ??= fallback.infoRef;
@@ -5513,20 +5546,21 @@ function parseCosDocument(bytes, options = {}) {
       maxRecursionDepth
     });
     doc.encryption = encState;
-    decryptCosDocument(doc, encState);
+    yield* decryptCosDocumentSteps(doc, encState);
   }
   if (useRepair) {
-    unpackRecoveredObjects(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth);
+    yield* unpackRecoveredObjectsSteps(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth);
     doc.infoRef ??= recoveredReferences(objects).infoRef;
   }
   const objStmCache = /* @__PURE__ */ new Map();
   for (const [objNum, entry] of mergedXref.entries()) {
+    if (++work % 16 === 0) yield;
     if (entry.type === "compressed" && entry.objectStreamNumber !== void 0) {
       let unpacked = objStmCache.get(entry.objectStreamNumber);
       if (!unpacked) {
         const stmObj = objects.get(entry.objectStreamNumber)?.value;
         if (stmObj?.kind === "stream") {
-          unpacked = unpackObjectStream(stmObj, maxDecompressedBytes, maxRecursionDepth, recovery === "repair");
+          unpacked = yield* unpackObjectStreamSteps(stmObj, maxDecompressedBytes, maxRecursionDepth, recovery === "repair");
           objStmCache.set(entry.objectStreamNumber, unpacked);
         }
       }
@@ -5543,6 +5577,9 @@ function parseCosDocument(bytes, options = {}) {
   }
   return doc;
 }
+function parseCosDocument(bytes, options = {}) {
+  return drainWork(parseCosDocumentSteps(bytes, options));
+}
 function isAsciiHexDigit(ch3) {
   return ch3 >= 48 && ch3 <= 57 || ch3 >= 65 && ch3 <= 70 || ch3 >= 97 && ch3 <= 102;
 }
@@ -13345,7 +13382,8 @@ function resolveInheritedFieldEntry(doc, dict, key) {
   }
   return void 0;
 }
-function collectFieldDicts(doc, node, prefix = "", out = [], parentFt = "", parentFf = 0, parentQ = 0, parentMaxLen) {
+function* collectFieldDictsSteps(doc, node, prefix = "", out = [], parentFt = "", parentFf = 0, parentQ = 0, parentMaxLen, yieldState = { work: 0 }) {
+  if (++yieldState.work % 256 === 0) yield;
   const dict = doc.resolveDict(node);
   if (!dict) return out;
   const tNode = doc.resolve(dictGet(dict, "T"));
@@ -13378,7 +13416,8 @@ function collectFieldDicts(doc, node, prefix = "", out = [], parentFt = "", pare
       return out;
     }
     for (const kid of kidsArr.items) {
-      collectFieldDicts(doc, kid, fullName, out, currentFt, currentFf, currentQ, currentMaxLen);
+      if (++yieldState.work % 16 === 0) yield;
+      yield* collectFieldDictsSteps(doc, kid, fullName, out, currentFt, currentFf, currentQ, currentMaxLen, yieldState);
     }
   } else if (fullName) {
     out.push({
@@ -13803,6 +13842,9 @@ function escapePdfLiteralString(str) {
   }
   return out;
 }
+function collectFieldDicts(doc, node, prefix = "", out = [], parentFt = "", parentFf = 0, parentQ = 0, parentMaxLen) {
+  drainWork(collectFieldDictsSteps(doc, node, prefix, out, parentFt, parentFf, parentQ, parentMaxLen));
+}
 function createStandardFontHandle(standardName) {
   return {
     kind: "standard14",
@@ -44917,14 +44959,18 @@ var init_dist = __esm({
         });
         return new _PdfDocument(parseCosDocument(rawBytes));
       }
-      static load(bytes, options) {
+      static *loadSteps(bytes, options) {
+        yield;
         return new _PdfDocument(
-          parseCosDocument(bytes, {
+          yield* parseCosDocumentSteps(bytes, {
             ...options,
             recovery: options?.recovery ?? "repair"
           })
         );
       }
+      static load(bytes, options) {
+        return drainWork(_PdfDocument.loadSteps(bytes, options));
+      }
       rebuildPagesList() {
         const catalog = this.cos.resolveDict(this.cos.rootRef);
         const pagesNode = catalog ? dictGet(catalog, "Pages") : void 0;
@@ -45006,20 +45052,30 @@ var init_dist = __esm({
         this.pages.splice(index, 1);
         this.syncPageTree();
       }
-      copyPagesFrom(sourceDoc, indices) {
+      *copyPagesFromSteps(sourceDoc, indices) {
+        function* cloneItems(items) {
+          const result = [];
+          for (const item of items) result.push(yield* cloneNode(item));
+          return result;
+        }
+        yield;
+        let work = 0;
         const memo = /* @__PURE__ */ new Map();
         const sourcePageObjNums = /* @__PURE__ */ new Set();
         for (let i = 0; i < sourceDoc.getPageCount(); i++) {
+          if (++work % 16 === 0) yield;
           sourcePageObjNums.add(sourceDoc.getPage(i).ref.objectNumber);
         }
         const targetPageRefs = [];
         for (const idx of indices) {
+          if (++work % 16 === 0) yield;
           const srcPage = sourceDoc.getPage(idx);
           const pageRef = this.cos.allocateObject({ kind: "null" });
           targetPageRefs.push(pageRef);
           memo.set(srcPage.ref.objectNumber, pageRef);
         }
-        const cloneNode = (node) => {
+        const cloneNode = function* (node) {
+          if (++work % 16 === 0) yield;
           if (node.kind === "ref") {
             const existing = memo.get(node.objectNumber);
             if (existing) return existing;
@@ -45030,12 +45086,12 @@ var init_dist = __esm({
             if (!target) return cosRef(0);
             const placeholderRef = this.cos.allocateObject({ kind: "null" });
             memo.set(node.objectNumber, placeholderRef);
-            const clonedTarget = cloneNode(target);
+            const clonedTarget = yield* cloneNode(target);
             this.cos.setObject(placeholderRef.objectNumber, clonedTarget, 0);
             return placeholderRef;
           }
           if (node.kind === "array") {
-            return cosArray(node.items.map(cloneNode));
+            return cosArray(yield* cloneItems(node.items));
           }
           if (node.kind === "dict") {
             const typeEntry = dictGet(node, "Type");
@@ -45045,13 +45101,13 @@ var init_dist = __esm({
               if (isPageTreeNode && entry.key.decoded === "Parent") continue;
               newEntries.push({
                 key: { ...entry.key },
-                value: cloneNode(entry.value)
+                value: yield* cloneNode(entry.value)
               });
             }
             return { kind: "dict", entries: newEntries };
           }
           if (node.kind === "stream") {
-            const clonedDict = cloneNode(node.dict);
+            const clonedDict = yield* cloneNode(node.dict);
             return {
               kind: "stream",
               dict: clonedDict,
@@ -45060,11 +45116,12 @@ var init_dist = __esm({
             };
           }
           return node;
-        };
+        }.bind(this);
         const copiedPages = [];
         for (const [position, idx] of indices.entries()) {
+          if (++work % 16 === 0) yield;
           const srcPage = sourceDoc.getPage(idx);
-          const clonedPageDict = cloneNode(srcPage.pageDict);
+          const clonedPageDict = yield* cloneNode(srcPage.pageDict);
           const size = srcPage.getSize();
           if (!dictGet(clonedPageDict, "MediaBox")) {
             dictSet(
@@ -45074,13 +45131,14 @@ var init_dist = __esm({
             );
           }
           if (!dictGet(clonedPageDict, "Resources")) {
-            dictSet(clonedPageDict, "Resources", cloneNode(srcPage.getResourcesDict()));
+            dictSet(clonedPageDict, "Resources", yield* cloneNode(srcPage.getResourcesDict()));
           }
           if (!dictGet(clonedPageDict, "Rotate") && srcPage.getRotation() !== 0) {
             dictSet(clonedPageDict, "Rotate", cosNumber(srcPage.getRotation()));
           }
           const inheritedBoxKeys = ["CropBox", "BleedBox", "TrimBox", "ArtBox"];
           for (const boxKey of inheritedBoxKeys) {
+            if (++work % 16 === 0) yield;
             if (!dictGet(clonedPageDict, boxKey)) {
               const boxVal = boxKey === "CropBox" ? srcPage.getCropBox() : boxKey === "BleedBox" ? srcPage.getBleedBox() : boxKey === "TrimBox" ? srcPage.getTrimBox() : srcPage.getArtBox();
               if (boxVal[0] !== 0 || boxVal[1] !== 0 || boxVal[2] !== size.width || boxVal[3] !== size.height) {
@@ -45122,8 +45180,9 @@ var init_dist = __esm({
           };
           const clonedRootFieldRefs = [];
           for (const item of srcFieldsArr.items) {
+            if (++work % 16 === 0) yield;
             if (!hasClonedDescendant(item)) continue;
-            const cloned = cloneNode(item);
+            const cloned = yield* cloneNode(item);
             if (cloned.kind === "ref") {
               const clonedDict = this.cos.resolveDict(cloned);
               const kidsArr = clonedDict ? this.cos.resolveArray(dictGet(clonedDict, "Kids")) : void 0;
@@ -45157,6 +45216,7 @@ var init_dist = __esm({
                 dstFields.items.filter((x) => x.kind === "ref").map((x) => x.objectNumber)
               );
               for (const fRef of clonedRootFieldRefs) {
+                if (++work % 16 === 0) yield;
                 if (!existingNums.has(fRef.objectNumber)) {
                   dstFields.items.push(fRef);
                   existingNums.add(fRef.objectNumber);
@@ -45164,11 +45224,11 @@ var init_dist = __esm({
               }
               const srcDr = dictGet(srcAcroForm, "DR");
               if (srcDr && !dictGet(dstAcroForm, "DR")) {
-                dictSet(dstAcroForm, "DR", cloneNode(srcDr));
+                dictSet(dstAcroForm, "DR", yield* cloneNode(srcDr));
               }
               const srcDa = dictGet(srcAcroForm, "DA");
               if (srcDa && !dictGet(dstAcroForm, "DA")) {
-                dictSet(dstAcroForm, "DA", cloneNode(srcDa));
+                dictSet(dstAcroForm, "DA", yield* cloneNode(srcDa));
               }
             }
           }
@@ -45177,12 +45237,15 @@ var init_dist = __esm({
         if (srcOcProps) {
           const dstCatalog = this.cos.resolveDict(this.cos.rootRef);
           if (dstCatalog && !dictGet(dstCatalog, "OCProperties")) {
-            dictSet(dstCatalog, "OCProperties", cloneNode(srcOcProps));
+            dictSet(dstCatalog, "OCProperties", yield* cloneNode(srcOcProps));
           }
         }
         this.syncPageTree();
         return copiedPages;
       }
+      copyPagesFrom(sourceDoc, indices) {
+        return drainWork(this.copyPagesFromSteps(sourceDoc, indices));
+      }
       embedStandardFont(fontName) {
         return createStandardFontHandle(fontName);
       }
@@ -45382,14 +45445,15 @@ var init_dist = __esm({
         });
         return buildSemanticAstFromPages(extractedPages, tablesByPage, displayLists);
       }
-      save(options = {}) {
+      *saveSteps(options = {}) {
+        yield;
         this.syncPageTree();
         if (this.cos.requiresFullRewrite) {
           pruneUnusedXObjects(this.cos, this.pages);
           discardUnreachableObjects(this.cos);
         }
         if (options.encrypt) {
-          return encryptCosDocument(this.cos, options.encrypt);
+          return yield* encryptCosDocumentSteps(this.cos, options.encrypt);
         }
         const allObjects = [...this.cos.objects.values()].sort(
           (a, b) => a.objectNumber - b.objectNumber
@@ -45397,7 +45461,7 @@ var init_dist = __esm({
         if (options.incremental && !this.cos.requiresFullRewrite && this.cos.bytes.length > 0) {
           return appendIncrementalRevision(this.cos.bytes, this.cos, allObjects);
         }
-        return serializeCosDocument({
+        return yield* serializeCosDocumentSteps({
           objects: allObjects,
           rootRef: this.cos.rootRef,
           infoRef: this.cos.infoRef,
@@ -45408,6 +45472,9 @@ var init_dist = __esm({
           linearize: options.linearize
         });
       }
+      save(options = {}) {
+        return drainWork(this.saveSteps(options));
+      }
     };
   }
 });
@@ -45520,10 +45587,14 @@ function extractLinks(html) {
   }
   return links;
 }
-function parseHtmlDocumentSync(rawHtml, replacements, signal) {
+function* parseHtmlDocumentSteps(rawHtml, replacements, signal) {
+  let cooperativeWork = 0;
   let html = rawHtml;
   for (const [key, value] of replacements) {
-    if (key) html = html.split(key).join(value);
+    if (++cooperativeWork % 64 === 0)
+      yield;
+    if (key)
+      html = html.split(key).join(value);
   }
   const titleMatch = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
   const title = titleMatch ? stripTags(titleMatch[1] ?? "") : "";
@@ -45534,8 +45605,11 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
   let match;
   let work = 0;
   while ((match = tokenRegex.exec(bodyHtml)) !== null) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     signal.throwIfAborted();
-    if (++work % 64 === 0) signal.throwIfAborted();
+    if (++work % 64 === 0)
+      signal.throwIfAborted();
     const leadingText = stripTags(bodyHtml.slice(lastIndex, match.index));
     if (leadingText) {
       blocks.push({ kind: "paragraph", text: leadingText, links: extractLinks(bodyHtml.slice(lastIndex, match.index)) });
@@ -45584,8 +45658,11 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       const liRegex = /<li\b[^>]*>([\s\S]*?)<\/li>/gi;
       let liMatch;
       while ((liMatch = liRegex.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const itemText = stripTags(liMatch[1] ?? "");
-        if (itemText) items.push(itemText);
+        if (itemText)
+          items.push(itemText);
       }
       if (items.length > 0) {
         blocks.push({ kind: "list", ordered: tag === "ol", items });
@@ -45596,6 +45673,8 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       let m;
       let currentTerm = "";
       while ((m = dtDdRegex.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const t = m[1].toLowerCase();
         const txt = stripTags(m[2] ?? "");
         if (t === "dt") {
@@ -45617,6 +45696,8 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       const rectRe = /<rect\b([^>]*)\/?>/gi;
       let rm;
       while ((rm = rectRe.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const ra = rm[1] ?? "";
         const rx = Number(/\bx=["']?([\d.]+)/i.exec(ra)?.[1] ?? 0);
         const ry = Number(/\by=["']?([\d.]+)/i.exec(ra)?.[1] ?? 0);
@@ -45627,11 +45708,14 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       const textRe = /<text\b([^>]*)>([\s\S]*?)<\/text>/gi;
       let tm;
       while ((tm = textRe.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const ta = tm[1] ?? "";
         const tx = Number(/\bx=["']?([\d.]+)/i.exec(ta)?.[1] ?? 8);
         const ty = Number(/\by=["']?([\d.]+)/i.exec(ta)?.[1] ?? 16);
         const txt = stripTags(tm[2] ?? "");
-        if (txt) svgPrimitives.push({ kind: "text", x: tx, y: ty, text: txt });
+        if (txt)
+          svgPrimitives.push({ kind: "text", x: tx, y: ty, text: txt });
       }
       blocks.push({ kind: "svg", displayWidth, displayHeight, svgPrimitives });
     } else if (tag === "blockquote") {
@@ -45644,13 +45728,18 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       const trRegex = /<tr\b[^>]*>([\s\S]*?)<\/tr>/gi;
       let trMatch;
       while ((trMatch = trRegex.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const rowHtml = trMatch[1] ?? "";
         const cells = [];
         let header = false;
         const cellRegex = /<(th|td)\b([^>]*)>([\s\S]*?)<\/\1>/gi;
         let cellMatch;
         while ((cellMatch = cellRegex.exec(rowHtml)) !== null) {
-          if (cellMatch[1]?.toLowerCase() === "th") header = true;
+          if (++cooperativeWork % 64 === 0)
+            yield;
+          if (cellMatch[1]?.toLowerCase() === "th")
+            header = true;
           const cellAttrs = cellMatch[2] ?? "";
           const colspanMatch = /colspan=["']?(\d+)/i.exec(cellAttrs);
           const colspan = Math.max(1, colspanMatch ? Number(colspanMatch[1]) : 1);
@@ -45665,7 +45754,7 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       }
     } else {
       if (/<(h[1-6]|p|pre|ul|ol|dl|table|svg|hr|img|blockquote|div|section|article)\b/i.test(inner)) {
-        const nested = parseHtmlDocumentSync(inner, [], signal);
+        const nested = yield* parseHtmlDocumentSteps(inner, [], signal);
         blocks.push(...nested.blocks);
       } else {
         const text = stripTags(inner);
@@ -45712,7 +45801,8 @@ function rgbColor(r, g, b, grayscale) {
   const lum = Math.round((0.299 * r + 0.587 * g + 0.114 * b) * 1e3) / 1e3;
   return { r: lum, g: lum, b: lum };
 }
-function layoutObjectPagesSync(blocks, box, settings, signal) {
+function* layoutObjectPagesSteps(blocks, box, settings, signal) {
+  let cooperativeWork = 0;
   const pages = [];
   let currentActions = [];
   const headerReserve = settings.header.left || settings.header.center || settings.header.right ? 24 : 0;
@@ -45733,8 +45823,11 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
   };
   let work = 0;
   for (const block of blocks) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     signal.throwIfAborted();
-    if (++work % 64 === 0) signal.throwIfAborted();
+    if (++work % 64 === 0)
+      signal.throwIfAborted();
     if (block.kind === "pagebreak") {
       flushPage();
       continue;
@@ -45749,6 +45842,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
       cursorY -= 4;
       const blockTopY = cursorY;
       for (const line of lines) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const drawY = cursorY - fontSize;
         const x = box.marginLeft;
         currentActions.push((page, _doc, grayscale) => {
@@ -45766,6 +45861,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
         const rectBottom = cursorY;
         const rectTop = blockTopY;
         for (const link of block.links) {
+          if (++cooperativeWork % 64 === 0)
+            yield;
           currentActions.push((page) => {
             page.addLinkAnnotation({
               rect: [box.marginLeft, rectBottom, box.marginLeft + Math.min(contentWidth, 220), rectTop],
@@ -45785,6 +45882,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
       ensureHeight(lines.length * lineHeight + 6);
       const blockTopY = cursorY;
       for (const line of lines) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const drawY = cursorY - fontSize;
         const x = box.marginLeft;
         const hasLink = (block.links?.length ?? 0) > 0;
@@ -45803,6 +45902,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
         const rectBottom = cursorY;
         const rectTop = blockTopY;
         for (const link of block.links) {
+          if (++cooperativeWork % 64 === 0)
+            yield;
           currentActions.push((page) => {
             page.addLinkAnnotation({
               rect: [box.marginLeft, rectBottom, box.marginLeft + Math.min(contentWidth, 220), rectTop],
@@ -45835,6 +45936,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
       });
       cursorY -= 6;
       for (const rawLine of rawLines) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const drawY = cursorY - fontSize;
         const x = box.marginLeft + 6;
         currentActions.push((page, _doc, grayscale) => {
@@ -45856,10 +45959,14 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
       const lineHeight = 15;
       const items = block.items ?? [];
       for (let idx = 0; idx < items.length; idx++) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const prefix = block.ordered ? `${idx + 1}. ` : "\u2022 ";
         const lines = wrapTextLines(prefix + items[idx], Math.max(20, Math.floor((contentWidth - 14) / 5.8)));
         ensureHeight(lines.length * lineHeight + 2);
         for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+          if (++cooperativeWork % 64 === 0)
+            yield;
           const drawY = cursorY - fontSize;
           const x = box.marginLeft + (lineIdx === 0 ? 10 : 22);
           const lineText = lines[lineIdx];
@@ -45898,6 +46005,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
         });
       });
       for (const line of lines) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const drawY = cursorY - fontSize;
         const x = box.marginLeft + 14;
         currentActions.push((page, _doc, grayscale) => {
@@ -45949,19 +46058,21 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
     }
     if (block.kind === "table") {
       const rows = block.rows ?? [];
-      const colCount = Math.max(
-        1,
-        ...rows.map((r) => r.cells.reduce((sum, c) => sum + c.colspan, 0))
-      );
+      const colCount = Math.max(1, ...rows.map((r) => r.cells.reduce((sum, c) => sum + c.colspan, 0)));
       const colWidth = contentWidth / colCount;
       const rowHeight = 20;
       ensureHeight(rows.length * rowHeight + 8);
       for (const row of rows) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         ensureHeight(rowHeight);
         const rowBottom = cursorY - rowHeight;
         let colCursor = 0;
         for (const cell of row.cells) {
-          if (colCursor >= colCount) break;
+          if (++cooperativeWork % 64 === 0)
+            yield;
+          if (colCursor >= colCount)
+            break;
           const span = Math.min(cell.colspan, colCount - colCursor);
           const cellX = box.marginLeft + colCursor * colWidth;
           const cellW = span * colWidth;
@@ -46035,7 +46146,8 @@ function substituteFurnitureTokens(template, tokens) {
   const isoDate = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   return template.replace(/\[page\]/g, String(tokens.page)).replace(/\[topage\]/g, String(tokens.topage)).replace(/\[webpage\]/g, tokens.webpage).replace(/\[title\]/g, tokens.title).replace(/\[section\]/g, tokens.section ?? tokens.title).replace(/\[subsection\]/g, tokens.subsection ?? "").replace(/\[isodate\]/g, isoDate).replace(/\[date\]/g, isoDate);
 }
-function renderPdfAstSync(request) {
+function* renderPdfAstSteps(request) {
+  let cooperativeWork = 0;
   request.signal.throwIfAborted();
   const { job, inputs, signal, limits } = request;
   const decoder2 = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
@@ -46045,15 +46157,17 @@ function renderPdfAstSync(request) {
   const objectMeta = [];
   let inferredDocumentTitle = job.global.documentTitle;
   for (let i = 0; i < job.objects.length; i++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     signal.throwIfAborted();
     const obj = job.objects[i];
     const htmlBytes = inputs[i] ?? new Uint8Array(0);
     const htmlText = decoder2.decode(htmlBytes);
-    const parsed = parseHtmlDocumentSync(htmlText, obj.settings.replacements, signal);
+    const parsed = yield* parseHtmlDocumentSteps(htmlText, obj.settings.replacements, signal);
     if (!inferredDocumentTitle && parsed.title) {
       inferredDocumentTitle = parsed.title;
     }
-    const pages = layoutObjectPagesSync(parsed.blocks, box, obj.settings, signal);
+    const pages = yield* layoutObjectPagesSteps(parsed.blocks, box, obj.settings, signal);
     laidOutPerObject.push(pages);
     objectMeta.push({
       title: parsed.title || inferredDocumentTitle || "Document",
@@ -46061,23 +46175,20 @@ function renderPdfAstSync(request) {
       settings: obj.settings
     });
   }
-  const sequence = planPageSequence(
-    laidOutPerObject.map((pages, idx) => ({
-      physicalPages: pages.length,
-      pagesCount: job.objects[idx].settings.pagesCount
-    })),
-    {
-      copies: job.global.copies,
-      collate: job.global.collate,
-      pageOffset: job.global.pageOffset,
-      limits: {
-        maxObjects: limits.parse.maxObjects,
-        maxPhysicalPages: Infinity,
-        maxWork: limits.resources.maxWork
-      },
-      signal
-    }
-  );
+  const sequence = planPageSequence(laidOutPerObject.map((pages, idx) => ({
+    physicalPages: pages.length,
+    pagesCount: job.objects[idx].settings.pagesCount
+  })), {
+    copies: job.global.copies,
+    collate: job.global.collate,
+    pageOffset: job.global.pageOffset,
+    limits: {
+      maxObjects: limits.parse.maxObjects,
+      maxPhysicalPages: Infinity,
+      maxWork: limits.resources.maxWork
+    },
+    signal
+  });
   const doc = PdfDocument.create();
   doc.setMetadata({
     title: inferredDocumentTitle || "Document",
@@ -46085,11 +46196,16 @@ function renderPdfAstSync(request) {
     producer: "@poe-code/pdf-ast"
   });
   for (const outPage of sequence.pages) {
+    yield;
     signal.throwIfAborted();
     const spec = laidOutPerObject[outPage.objectIndex][outPage.pageIndex];
     const meta = objectMeta[outPage.objectIndex];
     const page = doc.addPage({ width: box.width, height: box.height });
-    for (const action of spec.actions) action(page, doc, grayscale);
+    for (const action of spec.actions) {
+      if (++cooperativeWork % 64 === 0)
+        yield;
+      action(page, doc, grayscale);
+    }
     const tokens = {
       page: outPage.logicalPage,
       topage: sequence.logicalTotal + job.global.pageOffset,
@@ -46185,8 +46301,7 @@ function createPdfAstRenderer() {
   return Object.freeze({
     profile: pdfAstRendererProfile,
     async open(request) {
-      await yieldTurn(request.signal);
-      const pdfBytes = renderPdfAstSync(request);
+      const pdfBytes = await drainCooperativeSteps(renderPdfAstSteps(request), request.signal);
       return {
         success: true,
         errorCode: 0,
@@ -46211,6 +46326,12 @@ function pdfAstWkhtmltopdfCommands(options = {}) {
     ...options.replace === void 0 ? {} : { replace: options.replace }
   });
 }
+function renderPdfAstSync(request) {
+  const steps = renderPdfAstSteps(request);
+  let next = steps.next();
+  while (!next.done) next = steps.next();
+  return next.value;
+}
 var pdfAstRendererProfile;
 var PAGE_SIZES_PT;
 var pdfAstRenderer;