gutterpress 0.11.20-alpha.2 → 0.11.20-alpha.3

package/dist/{doctor-fe7tcs4v.js → doctor-wbjkrcpc.js}

@@ -1,12 +1,12 @@
 import {
   getSystemDiagnostics,
   log
-} from "./cli-gh0ym80r.js";
+} from "./cli-y9bcya7r.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-7z29z4wz.js";
+} from "./cli-hn9pk0hp.js";
 import"./cli-46ycxe6r.js";
 import"./cli-asap4t1z.js";
 import"./cli-37x76zdn.js";

package/dist/{engine-yax79k9m.js → engine-fdtv01a2.js}

@@ -1,9 +1,9 @@
 import {
   build
-} from "./index-6xwtb7cw.js";
+} from "./index-r87y7wzw.js";
 import {
   BuildError
-} from "./index-3nr5rzzp.js";
+} from "./index-zagagnwq.js";
 import"./index-bt0qws5c.js";
 import"./index-37x76zdn.js";
 

package/dist/{engine-9xb1ky8d.js → engine-yxnnp3hx.js}

@@ -1,6 +1,6 @@
 import {
   build
-} from "./cli-j802s31j.js";
+} from "./cli-x4p99w8d.js";
 import {
   BuildError
 } from "./cli-46ycxe6r.js";

package/dist/{ext-ahwxt6gv.js → ext-pesyrs68.js}

@@ -12,20 +12,21 @@ import {
   searchNpmExtensions,
   setExtensionEnabled,
   updateExtensions
-} from "./cli-zacevwcy.js";
-import"./cli-gh0ym80r.js";
+} from "./cli-9k2tb493.js";
+import"./cli-y9bcya7r.js";
 import {
   UsageError,
   exitForUsage,
   rejectExtraPositionals,
   rejectUnknownFlags,
   resolveProjectDir
-} from "./cli-7z29z4wz.js";
+} from "./cli-hn9pk0hp.js";
 import"./cli-ht1bcqdd.js";
-import"./cli-j802s31j.js";
+import"./cli-x4p99w8d.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";
+import"./cli-sth219v1.js";
 import"./cli-eyyggect.js";
 import"./cli-asap4t1z.js";
 import"./cli-5qr3z0qa.js";

package/dist/{gutterpress-viewer-retj6ym2.js → gutterpress-viewer-1yse8cx3.js}

@@ -1455,12 +1455,20 @@
     return head;
   }
   var pushTargets = new WeakMap;
+  function repeatingHead(table) {
+    const head = table.tHead;
+    return head && getComputedStyle(head).display === "table-header-group" ? head : null;
+  }
+  function repeatingFoot(table) {
+    const foot = table.tFoot;
+    return foot && getComputedStyle(foot).display === "table-footer-group" ? foot : null;
+  }
   function compensateRepeatedHeaders(strips, maxPasses = 24) {
     const warnings = [];
     let passes = 0;
     let touched = 0;
     for (const strip of strips) {
-      const tables = Array.from(strip.el.querySelectorAll("table")).filter((t) => t.tHead || t.tFoot);
+      const tables = Array.from(strip.el.querySelectorAll("table")).filter((t) => repeatingHead(t) || repeatingFoot(t));
       if (!tables.length)
         continue;
       for (const table of tables) {
@@ -1485,9 +1493,9 @@
         const colBottom = strip.el.clientHeight;
         const plans = [];
         for (const table of tables) {
-          const head = table.tHead;
+          const head = repeatingHead(table);
           const headRect = head?.getClientRects()[0];
-          const footHeight = (table.tFoot?.getBoundingClientRect().height ?? 0) / zoom;
+          const footHeight = (repeatingFoot(table)?.getBoundingClientRect().height ?? 0) / zoom;
           const rows = Array.from(table.querySelectorAll("tbody > tr")).filter((r) => !r.classList.contains("gp-thead-shim") && !r.classList.contains("gp-tfoot-shim"));
           if (!rows.length)
             continue;
@@ -1567,7 +1575,7 @@
         td.colSpan = cell.colSpan;
         td.innerHTML = cell.innerHTML;
         const cs = getComputedStyle(cell);
-        td.style.cssText = `font:${cs.font};text-align:${cs.textAlign};padding:${cs.padding};border:${cs.border};background:${cs.backgroundColor};`;
+        td.style.cssText = `font:${cs.font};color:${cs.color};letter-spacing:${cs.letterSpacing};text-transform:${cs.textTransform};vertical-align:${cs.verticalAlign};text-align:${cs.textAlign};padding:${cs.padding};border:${cs.border};background:${cs.backgroundColor};`;
         shim.appendChild(td);
       }
     } else {

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

@@ -19,7 +19,7 @@ import {
   stringValueAt,
   toFolioPage,
   wantsRecto
-} from "./index-3nr5rzzp.js";
+} from "./index-zagagnwq.js";
 import {
   launchChromium
 } from "./index-bt0qws5c.js";

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 };