gutterpress 0.11.20-alpha.2 → 0.11.20-alpha.4

package/dist/{index-6xwtb7cw.js → index-ad95fws8.js}

@@ -19,7 +19,7 @@ import {
   stringValueAt,
   toFolioPage,
   wantsRecto
-} from "./index-3nr5rzzp.js";
+} from "./index-gm5xbx5w.js";
 import {
   launchChromium
 } from "./index-bt0qws5c.js";
@@ -29,14 +29,15 @@ import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
-// src/engine/shared/flush.ts
-var FLUSH_EDGES = ["top", "right", "bottom", "left"];
-function flushKey(edges) {
-  return FLUSH_EDGES.filter((e) => edges.includes(e)).map((e) => e[0]).join("");
+// src/engine/shared/pin-edges.ts
+var PIN_EDGES = ["top", "right", "bottom", "left"];
+var EDGE_PIN_SELECTOR = PIN_EDGES.map((edge) => `.gp-pin.gp-${edge}`).join(", ");
+function pinKey(edges) {
+  return PIN_EDGES.filter((e) => edges.includes(e)).map((e) => e[0]).join("");
 }
-function flushPageName(authorPage, edges) {
+function pinPageName(authorPage, edges) {
   const safe = authorPage ? authorPage.replace(/[^A-Za-z0-9_-]/g, "_") : "";
-  return `gp--flush${safe ? `-${safe}` : ""}-${flushKey(edges)}`;
+  return `gp--pin${safe ? `-${safe}` : ""}-${pinKey(edges)}`;
 }
 function flushMargins(margin, edges) {
   return {
@@ -46,6 +47,23 @@ function flushMargins(margin, edges) {
     left: edges.includes("left") ? 0 : margin.left
   };
 }
+function pinInsets(area, side, edges) {
+  const binding = side === "recto" ? "left" : "right";
+  const inset = (edge) => !area || !edges.includes(edge) ? 0 : edge === binding ? area.safe : area.bleed + area.artSafe;
+  return { top: inset("top"), right: inset("right"), bottom: inset("bottom"), left: inset("left") };
+}
+var NO_PADDING = { top: 0, right: 0, bottom: 0, left: 0 };
+function pinRootStyle(margin, area, side, edges, padding = NO_PADDING) {
+  const px = (pt) => pt * 96 / 72;
+  const inset = pinInsets(area, side, edges);
+  const style = { "box-decoration-break": "clone" };
+  for (const edge of PIN_EDGES)
+    if (edges.includes(edge))
+      style[`padding-${edge}`] = `${px(margin[edge]) + padding[edge]}px`;
+  for (const edge of PIN_EDGES)
+    style[`--gp-pin-${edge}`] = `${px(inset[edge])}px`;
+  return style;
+}
 function marginBoxesOnEdges(edges) {
   const owners = {
     "top-left-corner": ["top", "left"],
@@ -723,7 +741,7 @@ var BUILD_DIAGNOSTIC_CODES = [
   "engine.multicol.dead-column",
   "engine.content.overheight",
   "engine.image.low-dpi",
-  "engine.flush.margin-box",
+  "engine.pin.margin-box",
   "engine.page-background.unreferenced",
   "engine.hyphenation.unsupported"
 ];
@@ -756,25 +774,31 @@ async function build(opts) {
     await page.send("Emulation.setDeviceMetricsOverride", sheetViewport);
     await page.send("Emulation.setEmulatedMedia", { media: "print" });
     log(`print media emulated for audits and measurement`);
-    const flushRoots = await page.evaluate(`window.__gp.flushRoots()`);
-    const flushGroups = new Map;
-    for (const root of flushRoots) {
-      if (flushGroups.has(root.key))
+    const pinRoots = await page.evaluate(`window.__gp.pinRoots()`);
+    const pinGroups = new Map;
+    for (const root of pinRoots) {
+      if (pinGroups.has(root.key))
         continue;
       const authorPage = root.page === "auto" ? undefined : root.page;
-      flushGroups.set(root.key, {
+      pinGroups.set(root.key, {
         authorPage,
         edges: root.edges,
-        genName: flushPageName(authorPage, root.edges),
+        padding: root.padding,
+        genName: pinPageName(authorPage, root.edges),
         key: root.key
       });
     }
-    if (flushGroups.size) {
+    const printArea = pinRoots.length ? await page.evaluate(`window.__gp.printArea()`) : null;
+    const pinStyle = (group, pseudos) => pinRootStyle(resolvePage(model, { name: group.authorPage, pseudos }).geometry.margin, printArea, pseudos.includes("left") ? "verso" : "recto", group.edges, group.padding);
+    if (pinGroups.size) {
       const lines = [];
-      for (const group of flushGroups.values()) {
+      const aliased = new Set;
+      for (const group of pinGroups.values()) {
+        const alias = !aliased.has(group.genName);
+        aliased.add(group.genName);
         const relocated = new Set(marginBoxesOnEdges(group.edges));
         const pseudoSets = [[]];
-        if (group.authorPage) {
+        if (alias && group.authorPage) {
           for (const rule of model.pageRules) {
             if (rule.name !== group.authorPage)
               continue;
@@ -798,7 +822,7 @@ ${body.join(`
 }`);
           }
         }
-        for (const pseudos of pseudoSets) {
+        for (const pseudos of alias ? pseudoSets : []) {
           const pseudo = pseudos.length ? `:${pseudos.join(":")}` : "";
           const body = [];
           for (const edge of group.edges)
@@ -810,14 +834,15 @@ ${body.join(`
 `)}
 }`);
         }
-        lines.push(`:where(.page, .spread)[data-gp-flush="${group.key}"][data-gp-flush][data-gp-flush][data-gp-flush] { page: ${group.genName}; }`);
+        const recto = Object.entries(pinStyle(group, ["right"])).map(([prop, value]) => ` ${prop}: ${value};`).join("");
+        lines.push(`:where(.page, .spread)[data-gp-pin="${group.key}"][data-gp-pin][data-gp-pin][data-gp-pin] { page: ${group.genName};${recto} }`);
       }
-      const flushCss = lines.join(`
+      const pinCss = lines.join(`
 `);
-      await page.evaluate(`window.__gp.addCss("gp-flush-css", ${JSON.stringify(flushCss)})`);
+      await page.evaluate(`window.__gp.addCss("gp-pin-css", ${JSON.stringify(pinCss)})`);
       model = extract(`${cssText}
-${flushCss}`);
-      log(`.gp-flush: ${flushRoots.length} pinned root(s) -> ${flushGroups.size} generated page context(s)`);
+${pinCss}`);
+      log(`pinned art: ${pinRoots.length} page root(s) -> ${pinGroups.size} generated page context(s)`);
     }
     const { tier3Reasons } = classify(model);
     const pseudoContexts = pagePseudoContexts(model);
@@ -842,11 +867,16 @@ ${flushCss}`);
         return !!c && c !== "none" && c !== "normal";
       });
     };
-    const furnitureRoots = flushRoots.filter((root) => {
-      const group = flushGroups.get(root.key);
+    const furnitureRoots = pinRoots.filter((root) => {
+      const group = pinGroups.get(root.key);
       return pseudoContexts.some((pseudos) => relocationBoxes(group, pseudos).length > 0);
     });
-    const flushDiagnosed = new Set;
+    const relocationDiagnosed = new Set;
+    const sideRoots = pinRoots.filter((root) => {
+      const group = pinGroups.get(root.key);
+      const recto = JSON.stringify(pinStyle(group, ["right"]));
+      return [["left"], ["right", "first"]].some((pseudos) => JSON.stringify(pinStyle(group, pseudos)) !== recto);
+    });
     const tier2 = synthesize({
       model,
       marks: opts.marks,
@@ -890,7 +920,7 @@ ${describe(widthOffenders.intrinsics)}`;
       log(`WARNING: ${msg}`);
     }
     const rectoDecls = model.breaks.filter(isRectoVersoBreak);
-    const needsMeasure = tier3Reasons.length > 0 || consumedStrings(model).size > 0 || rectoDecls.length > 0 || model.counterResets.length > 0 || furnitureRoots.length > 0;
+    const needsMeasure = tier3Reasons.length > 0 || consumedStrings(model).size > 0 || rectoDecls.length > 0 || model.counterResets.length > 0 || furnitureRoots.length > 0 || sideRoots.length > 0;
     let tier = tier2.geometry.bleed > 0 || tier2.geometry.slug > 0 ? 2 : 1;
     let passes = 1;
     let pageMap = {};
@@ -918,7 +948,7 @@ ${describe(widthOffenders.intrinsics)}`;
         targets.add(s.id);
       for (const s of resetSites)
         targets.add(s.id);
-      for (const r of furnitureRoots)
+      for (const r of [...furnitureRoots, ...sideRoots])
         targets.add(r.id);
       await page.evaluate(`window.__gp.instrument(${JSON.stringify([...targets])})`);
       const targetText = await page.evaluate(`window.__gp.targetTexts(${JSON.stringify([...targets])})`);
@@ -1004,8 +1034,12 @@ ${describe(widthOffenders.intrinsics)}`;
 /* Tier 3 */
 ${mapCss}`;
         }
+        const pageAt = (id) => map[id] ?? predictedForResult?.pageMap[id];
+        const pseudosAt = (physical) => [
+          physical % 2 === 1 ? "right" : "left",
+          ...physical === 1 ? ["first"] : []
+        ];
         if (furnitureRoots.length) {
-          const pageAt = (id) => map[id] ?? predictedForResult?.pageMap[id];
           const byName = new Map;
           for (const s of sources) {
             const p = pageAt(s.id);
@@ -1023,10 +1057,8 @@ ${mapCss}`;
             const physical = pageAt(root.id);
             if (!physical)
               continue;
-            const group = flushGroups.get(root.key);
-            const pseudos = [physical % 2 === 1 ? "right" : "left"];
-            if (physical === 1)
-              pseudos.push("first");
+            const group = pinGroups.get(root.key);
+            const pseudos = pseudosAt(physical);
             const ctx = resolvePage(model, { name: group.authorPage, pseudos });
             const g = ctx.geometry;
             const eff = flushMargins(g.margin, group.edges);
@@ -1042,9 +1074,9 @@ ${mapCss}`;
                 }
               });
               if (!text) {
-                if (!flushDiagnosed.has(name)) {
-                  flushDiagnosed.add(name);
-                  diagnose("engine.flush.margin-box", `@${name} sits on an edge a .gp-flush pin frees, and its content could not be ` + `re-homed into the page (unsupported content value: ${decls.content}). It will ` + `not print on that page — simplify the box's content, or drop .gp-flush there.`);
+                if (!relocationDiagnosed.has(name)) {
+                  relocationDiagnosed.add(name);
+                  diagnose("engine.pin.margin-box", `@${name} sits on an edge a pinned image frees, and its content could not be ` + `re-homed into the page (unsupported content value: ${decls.content}). It will ` + `not print on that page — simplify the box's content, or pin the image to another edge.`);
                 }
                 continue;
               }
@@ -1069,7 +1101,17 @@ ${mapCss}`;
             items.push({ id: root.id, boxes });
           }
           if (items.length)
-            await page.evaluate(`window.__gp.setFlushFurniture(${JSON.stringify(items)})`);
+            await page.evaluate(`window.__gp.setPinFurniture(${JSON.stringify(items)})`);
+        }
+        if (sideRoots.length) {
+          const items = sideRoots.flatMap((root) => {
+            const physical = pageAt(root.id);
+            if (!physical)
+              return [];
+            return [{ id: root.id, style: pinStyle(pinGroups.get(root.key), pseudosAt(physical)) }];
+          });
+          if (items.length)
+            await page.evaluate(`window.__gp.setPinGeometry(${JSON.stringify(items)})`);
         }
       };
       const predicted = await predictPageMap(browser, url, AGENT, VIEWER, {
@@ -1432,12 +1474,12 @@ function shrinkScale(boxes, limitPx) {
 async function findWidthOffenders(page, model, bleedSlugExtensionPt, restoreViewport) {
   const contexts = [
     resolvePage(model),
-    ...model.pageNames.filter((n) => !n.startsWith("gp-") || n.startsWith("gp--flush-")).map((n) => resolvePage(model, { name: n }))
+    ...model.pageNames.filter((n) => !n.startsWith("gp-") || n.startsWith("gp--pin-")).map((n) => resolvePage(model, { name: n }))
   ];
   const contentPxOf = (c) => (c.geometry.width - c.geometry.margin.left - c.geometry.margin.right + bleedSlugExtensionPt) * 96 / 72;
   const defaultLimitPx = contentPxOf(contexts[0]);
   const namedLimits = {};
-  model.pageNames.filter((n) => !n.startsWith("gp-") || n.startsWith("gp--flush-")).forEach((n) => {
+  model.pageNames.filter((n) => !n.startsWith("gp-") || n.startsWith("gp--pin-")).forEach((n) => {
     namedLimits[n] = contentPxOf(resolvePage(model, { name: n }));
   });
   const widths = [...new Set([defaultLimitPx, ...Object.values(namedLimits)])].sort((a, b) => a - b);
@@ -1624,7 +1666,7 @@ async function predictPageMap(browser, url, agentScript, viewerScript, args, she
     await page.waitForReady();
     await page.evaluate(`window.__GP_MANUAL__ = true;`);
     await page.evaluate(viewerScript);
-    await page.evaluate(`window.__gp.flushRoots()`);
+    await page.evaluate(`window.__gp.pinRoots()`);
     await page.evaluate(`window.__gp.stringSources(${JSON.stringify(args.stringSets)})`);
     if (args.rectoDecls.length)
       await page.evaluate(`window.__gp.forcedBreakSites(${JSON.stringify(args.rectoDecls)})`);

package/dist/{index-3nr5rzzp.js → index-gm5xbx5w.js}

@@ -148,7 +148,7 @@ import { fileURLToPath } from "node:url";
 var favicon_default = "./favicon-272ga6y0.ico";
 
 // src/assets/manifest.schema.json
-var manifest_schema_default = "./manifest.schema-74s1ykyv.json";
+var manifest_schema_default = "./manifest.schema-13dfax80.json";
 
 // src/assets/preview/scripts/preview-interface.js
 var preview_interface_default = "./preview-interface-nnmrxyqm.js";
@@ -163,10 +163,10 @@ var preview_shell_default = "./preview-shell-wk9k3gcd.js";
 var CGATS21_CRPC1_default = "./CGATS21_CRPC1-g0e3k7kr.icc";
 
 // src/assets/engine/gutterpress-viewer.js
-var gutterpress_viewer_default = "./gutterpress-viewer-retj6ym2.js";
+var gutterpress_viewer_default = "./gutterpress-viewer-jr30yw8t.js";
 
 // src/assets/engine/gutterpress-agent.js
-var gutterpress_agent_default = "./gutterpress-agent-cazqstr1.js";
+var gutterpress_agent_default = "./gutterpress-agent-mrdnwktc.js";
 
 // src/assets/templates/book/manifest.yaml
 var manifest_default = "./manifest-n1gh3qw5.yaml";

package/dist/index-sth219v1.js

@@ -0,0 +1,418 @@
+// src/lib/pdf-inspect.ts
+import { stat, readFile } from "node:fs/promises";
+import { getDocumentProxy } from "unpdf";
+import * as pdfjs from "unpdf/pdfjs";
+function getOps(mod) {
+  if ("OPS" in mod && mod.OPS && typeof mod.OPS === "object") {
+    return mod.OPS;
+  }
+  throw new Error("unpdf/pdfjs missing OPS export");
+}
+var OPS = getOps(pdfjs);
+var docCache = new Map;
+var DOC_CACHE_MAX = 8;
+function destroyEntry(entry) {
+  entry.doc.then((d) => d.destroy()).catch(() => {});
+}
+var EVICT_DESTROY_GRACE_MS = 60000;
+var gracePending = new Map;
+function destroyEntryAfterGrace(entry) {
+  const t = setTimeout(() => {
+    gracePending.delete(t);
+    destroyEntry(entry);
+  }, EVICT_DESTROY_GRACE_MS);
+  t.unref?.();
+  gracePending.set(t, entry);
+}
+function evictLru() {
+  while (docCache.size > DOC_CACHE_MAX) {
+    const oldestKey = docCache.keys().next().value;
+    if (oldestKey === undefined)
+      break;
+    const evicted = docCache.get(oldestKey);
+    docCache.delete(oldestKey);
+    if (evicted)
+      destroyEntryAfterGrace(evicted);
+  }
+}
+async function loadPdf(path) {
+  let st;
+  try {
+    st = await stat(path);
+  } catch {
+    return null;
+  }
+  const hit = docCache.get(path);
+  if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
+    docCache.delete(path);
+    docCache.set(path, hit);
+    try {
+      return await hit.doc;
+    } catch {
+      return null;
+    }
+  }
+  if (hit)
+    destroyEntry(hit);
+  const docPromise = readFile(path).then((buf) => getDocumentProxy(new Uint8Array(buf)));
+  docCache.delete(path);
+  docCache.set(path, { mtimeMs: st.mtimeMs, size: st.size, doc: docPromise });
+  evictLru();
+  try {
+    return await docPromise;
+  } catch {
+    if (docCache.get(path)?.doc === docPromise)
+      docCache.delete(path);
+    return null;
+  }
+}
+var activeRetains = 0;
+function retainPdfCache() {
+  activeRetains++;
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    activeRetains--;
+    if (activeRetains === 0)
+      clearPdfCache();
+  };
+}
+function clearPdfCache() {
+  for (const [t, entry] of gracePending) {
+    clearTimeout(t);
+    destroyEntry(entry);
+  }
+  gracePending.clear();
+  for (const entry of docCache.values())
+    destroyEntry(entry);
+  docCache.clear();
+}
+function pendingGraceDestroyCount() {
+  return gracePending.size;
+}
+function getPageSize(page) {
+  const vp = page.getViewport({ scale: 1 });
+  return { w: vp.width, h: vp.height };
+}
+async function getOutlineCount(doc) {
+  try {
+    const outline = await doc.getOutline();
+    return outline ? outline.length : 0;
+  } catch {
+    return 0;
+  }
+}
+async function getPageLabels(doc) {
+  try {
+    return await doc.getPageLabels();
+  } catch {
+    return null;
+  }
+}
+async function countLinkAnnotations(doc, stopAtFirst = false) {
+  let count = 0;
+  for (let i = 1;i <= doc.numPages; i++) {
+    try {
+      const page = await doc.getPage(i);
+      const annots = await page.getAnnotations();
+      for (const a of annots) {
+        if (a.subtype === "Link") {
+          count++;
+          if (stopAtFirst)
+            return count;
+        }
+      }
+    } catch {}
+  }
+  return count;
+}
+var textCache = new WeakMap;
+function getTextPass(doc) {
+  let p = textCache.get(doc);
+  if (!p) {
+    p = (async () => {
+      const textByPage = [];
+      const positions = [];
+      const runsByPage = [];
+      for (let i = 1;i <= doc.numPages; i++) {
+        try {
+          const page = await doc.getPage(i);
+          const tc = await page.getTextContent();
+          let pageText = "";
+          const runs = [];
+          for (const item of tc.items) {
+            const it = item;
+            if (typeof it.str !== "string")
+              continue;
+            pageText += it.str;
+            if (it.transform && it.str.trim().length > 0) {
+              const x = it.transform[4];
+              const y = it.transform[5];
+              positions.push({ x, y });
+              runs.push({ s: it.str, x, y, w: it.width ?? 0, h: it.height ?? 0 });
+            }
+          }
+          textByPage.push(pageText);
+          runsByPage.push(runs);
+        } catch {
+          textByPage.push("");
+          runsByPage.push([]);
+        }
+      }
+      return { textByPage, positions, runsByPage };
+    })();
+    textCache.set(doc, p);
+  }
+  return p;
+}
+var opCache = new WeakMap;
+function multiply(m1, m2) {
+  return [
+    m1[0] * m2[0] + m1[2] * m2[1],
+    m1[1] * m2[0] + m1[3] * m2[1],
+    m1[0] * m2[2] + m1[2] * m2[3],
+    m1[1] * m2[2] + m1[3] * m2[3],
+    m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
+    m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
+  ];
+}
+function fontIsEmbedded(f) {
+  if (f.isType3Font)
+    return true;
+  if (f.missingFile === true)
+    return false;
+  if (f.isStandardFont === true)
+    return false;
+  return true;
+}
+function getOpPass(doc) {
+  let p = opCache.get(doc);
+  if (!p) {
+    p = (async () => {
+      const imagesByPage = new Map;
+      const fonts = [];
+      const seenFonts = new Set;
+      for (let i = 1;i <= doc.numPages; i++) {
+        let page;
+        try {
+          page = await doc.getPage(i);
+        } catch {
+          continue;
+        }
+        let ops;
+        try {
+          ops = await page.getOperatorList();
+        } catch {
+          continue;
+        }
+        let ctm = [1, 0, 0, 1, 0, 0];
+        const stack = [];
+        const pageImages = [];
+        for (let j = 0;j < ops.fnArray.length; j++) {
+          const fn = ops.fnArray[j];
+          const args = ops.argsArray[j];
+          if (fn === OPS.save) {
+            stack.push(ctm.slice());
+          } else if (fn === OPS.restore) {
+            ctm = stack.pop() ?? ctm;
+          } else if (fn === OPS.transform) {
+            ctm = multiply(ctm, args);
+          } else if (fn === OPS.paintImageXObject || fn === OPS.paintImageXObjectRepeat || fn === OPS.paintInlineImageXObject) {
+            const name = typeof args[0] === "string" ? args[0] : "(inline)";
+            pageImages.push({
+              name,
+              placedW: Math.hypot(ctm[0], ctm[1]),
+              placedH: Math.hypot(ctm[2], ctm[3]),
+              x: ctm[4],
+              y: ctm[5],
+              page: i
+            });
+          } else if (fn === OPS.setFont) {
+            const ref = args[0];
+            if (typeof ref === "string" && !seenFonts.has(ref)) {
+              seenFonts.add(ref);
+              try {
+                if (page.commonObjs.has(ref)) {
+                  const f = page.commonObjs.get(ref);
+                  fonts.push({
+                    name: f?.name ?? ref,
+                    embedded: fontIsEmbedded(f ?? {})
+                  });
+                }
+              } catch {}
+            }
+          }
+        }
+        if (pageImages.length > 0)
+          imagesByPage.set(i, pageImages);
+      }
+      return { imagesByPage, fonts };
+    })();
+    opCache.set(doc, p);
+  }
+  return p;
+}
+var opSet = (names) => new Set(names.map((name) => OPS[name]).filter((op) => op !== undefined));
+var FILL_COLOR_OPS = opSet(["setFillGray", "setFillRGBColor", "setFillCMYKColor", "setFillColor"]);
+var STROKE_COLOR_OPS = opSet(["setStrokeGray", "setStrokeRGBColor", "setStrokeCMYKColor", "setStrokeColor"]);
+var SHOW_TEXT_OPS = opSet(["showText", "showSpacedText", "nextLineShowText", "nextLineSetSpacingShowText"]);
+async function unsplittableTextReasons(pdfBytes, pages) {
+  const GSTATE_BIT = { ca: 1, CA: 2, BM: 4, SMask: 8 };
+  const COMPOSITING = 15;
+  const FILL_PATTERN = 16;
+  const STROKE_PATTERN = 32;
+  const CLIP_TEXT = 64;
+  const doc = await getDocumentProxy(new Uint8Array(pdfBytes));
+  const reasons = new Map;
+  try {
+    const scan = pages ?? Array.from({ length: doc.numPages }, (_, i) => i + 1);
+    for (const i of scan) {
+      const page = await doc.getPage(i);
+      const ops = await page.getOperatorList();
+      let state = 0;
+      const groups = [];
+      const stack = [];
+      let showsText = false;
+      for (let j = 0;j < ops.fnArray.length; j++) {
+        const fn = ops.fnArray[j];
+        if (fn === OPS.save || fn === OPS.paintFormXObjectBegin)
+          stack.push(state);
+        else if (fn === OPS.restore || fn === OPS.paintFormXObjectEnd)
+          state = stack.pop() ?? 0;
+        else if (fn === OPS.beginGroup) {
+          const group = ops.argsArray[j][0];
+          groups.push((state & COMPOSITING) !== 0 || !!(group.smask || group.knockout));
+        } else if (fn === OPS.endGroup)
+          groups.pop();
+        else if (fn === OPS.setFont) {
+          const ref = ops.argsArray[j][0];
+          const font = typeof ref === "string" && page.commonObjs.has(ref) ? page.commonObjs.get(ref) : undefined;
+          if (font?.isType3Font) {
+            reasons.set(i, "type3-font");
+            break;
+          }
+        } else if (fn === OPS.setFillColorN || fn === OPS.setStrokeColorN) {
+          const bit = fn === OPS.setFillColorN ? FILL_PATTERN : STROKE_PATTERN;
+          const kind = ops.argsArray[j][0];
+          state = kind === "TilingPattern" || kind === "Shading" ? state | bit : state & ~bit;
+        } else if (FILL_COLOR_OPS.has(fn))
+          state &= ~FILL_PATTERN;
+        else if (STROKE_COLOR_OPS.has(fn))
+          state &= ~STROKE_PATTERN;
+        else if (fn === OPS.setTextRenderingMode) {
+          state = ops.argsArray[j][0] >= 4 ? state | CLIP_TEXT : state & ~CLIP_TEXT;
+        } else if (fn === OPS.setGState) {
+          for (const [key, value] of ops.argsArray[j][0]) {
+            const bit = GSTATE_BIT[key];
+            if (!bit)
+              continue;
+            const on = key === "BM" ? value !== "source-over" : key === "SMask" ? !!value : value < 1;
+            state = on ? state | bit : state & ~bit;
+          }
+        } else if (SHOW_TEXT_OPS.has(fn)) {
+          showsText = true;
+          if (state || groups.includes(true)) {
+            const paint = state & (FILL_PATTERN | STROKE_PATTERN | CLIP_TEXT);
+            reasons.set(i, paint ? "text-pattern-or-clip" : "text-transparency");
+            break;
+          }
+        }
+      }
+      if (!showsText && !reasons.has(i))
+        reasons.set(i, "no-text");
+    }
+  } finally {
+    await doc.destroy();
+  }
+  return reasons;
+}
+function getImagePixelSize(page, name, timeoutMs = 2000) {
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (v) => {
+      if (!done) {
+        done = true;
+        resolve(v);
+      }
+    };
+    const t = setTimeout(() => finish(null), timeoutMs);
+    try {
+      page.objs.get(name, (obj) => {
+        clearTimeout(t);
+        finish(obj && obj.width && obj.height ? { width: obj.width, height: obj.height } : null);
+      });
+    } catch {
+      clearTimeout(t);
+      finish(null);
+    }
+  });
+}
+var PAINT_OPS = new Set([
+  "stroke",
+  "closeStroke",
+  "fill",
+  "eoFill",
+  "fillStroke",
+  "eoFillStroke",
+  "closeFillStroke",
+  "closeEOFillStroke",
+  "shadingFill",
+  "paintImageXObject",
+  "paintInlineImageXObject",
+  "paintImageXObjectRepeat",
+  "paintImageMaskXObject",
+  "paintImageMaskXObjectGroup",
+  "paintImageMaskXObjectRepeat",
+  "paintSolidColorImageMask",
+  "showText",
+  "showSpacedText",
+  "nextLineShowText",
+  "nextLineSetSpacingShowText"
+].map((name) => OPS[name]).filter((op) => op !== undefined));
+async function pageHasMarks(doc, pageNum) {
+  const ops = await (await doc.getPage(pageNum)).getOperatorList();
+  return ops.fnArray.some((fn, i) => fn === OPS.constructPath ? PAINT_OPS.has(ops.argsArray[i][0]) : PAINT_OPS.has(fn));
+}
+async function getImageResolutions(doc) {
+  const { imagesByPage } = await getOpPass(doc);
+  const out = [];
+  for (const [pageNum, imgs] of imagesByPage) {
+    let page;
+    try {
+      page = await doc.getPage(pageNum);
+    } catch {
+      continue;
+    }
+    for (const img of imgs) {
+      if (img.name === "(inline)")
+        continue;
+      const px = await getImagePixelSize(page, img.name);
+      if (!px)
+        continue;
+      const placedWin = img.placedW / 72;
+      const placedHin = img.placedH / 72;
+      if (placedWin <= 0 || placedHin <= 0)
+        continue;
+      out.push({
+        page: pageNum,
+        xDpi: px.width / placedWin,
+        yDpi: px.height / placedHin
+      });
+    }
+  }
+  return out;
+}
+async function isLoadable(doc) {
+  try {
+    for (let i = 1;i <= doc.numPages; i++) {
+      await doc.getPage(i);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { DOC_CACHE_MAX, loadPdf, retainPdfCache, clearPdfCache, pendingGraceDestroyCount, getPageSize, getOutlineCount, getPageLabels, countLinkAnnotations, getTextPass, getOpPass, unsplittableTextReasons, pageHasMarks, getImageResolutions, isLoadable };