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

package/dist/{cli-7z29z4wz.js → cli-hn9pk0hp.js}

@@ -4,7 +4,7 @@ import {
 // package.json
 var package_default = {
   name: "gutterpress",
-  version: "0.11.20-alpha.2",
+  version: "0.11.20-alpha.3",
   description: "Markdown-to-PDF converter for professional print layout using a native Chromium print engine and Ghostscript.",
   author: "itlackey",
   license: "MPL-2.0",

package/dist/cli-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 };

package/dist/{cli-j802s31j.js → cli-x4p99w8d.js}

@@ -1116,7 +1116,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-c9x8912a.json";
 
 // src/assets/preview/scripts/preview-interface.js
 var preview_interface_default = "./preview-interface-nnmrxyqm.js";
@@ -1131,7 +1131,7 @@ 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-1yse8cx3.js";
 
 // src/assets/engine/gutterpress-agent.js
 var gutterpress_agent_default = "./gutterpress-agent-cazqstr1.js";

package/dist/{cli-gh0ym80r.js → cli-y9bcya7r.js}

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "./cli-7z29z4wz.js";
+} from "./cli-hn9pk0hp.js";
 import {
   enhancedPath,
   execCapture,
@@ -132,8 +132,8 @@ async function resolveGhostscript(targetPlatform = process.platform, env = proce
   }
   return targetPlatform === "win32" ? findWindowsGhostscriptInstall(env) : undefined;
 }
-async function hasLiveTransparency(pdfBytes) {
-  const { PDFDocument, PDFDict, PDFName, PDFNumber, PDFRawStream, PDFRef } = await import("pdf-lib");
+async function transparentPages(pdfBytes) {
+  const { PDFDocument, PDFDict, PDFName, PDFNumber, PDFRawStream, PDFArray, PDFRef } = await import("pdf-lib");
   let doc;
   try {
     doc = await PDFDocument.load(pdfBytes, {
@@ -141,36 +141,64 @@ async function hasLiveTransparency(pdfBytes) {
       throwOnInvalidObject: false
     });
   } catch {
-    return false;
+    return [];
   }
   const ctx = doc.context;
-  const NONE = "/None";
-  for (const [, obj] of ctx.enumerateIndirectObjects()) {
-    const dict = obj instanceof PDFRawStream ? obj.dict : obj instanceof PDFDict ? obj : undefined;
-    if (!dict)
-      continue;
+  const SKIP = new Set(["Parent", "Font", "Annots"]);
+  const isSet = (v) => v !== undefined && String(v) !== "/None";
+  const dictHasTransparency = (dict) => {
     const smask = dict.get(PDFName.of("SMask"));
     const subtype = String(dict.get(PDFName.of("Subtype")) ?? "");
     const type = String(dict.get(PDFName.of("Type")) ?? "");
-    if (subtype === "/Image" && smask && String(smask) !== NONE)
+    if (subtype === "/Image" && isSet(smask))
       return true;
-    if (type === "/ExtGState") {
-      if (smask && String(smask) !== NONE)
+    if (type === "/ExtGState" || dict.has(PDFName.of("ca")) || dict.has(PDFName.of("BM"))) {
+      if (isSet(smask))
         return true;
       for (const key of ["ca", "CA"]) {
-        const alpha = dict.get(PDFName.of(key));
+        const alpha = ctx.lookup(dict.get(PDFName.of(key)));
         if (alpha instanceof PDFNumber && alpha.asNumber() < 1)
           return true;
       }
+      const bm = ctx.lookup(dict.get(PDFName.of("BM")));
+      const mode = bm instanceof PDFArray ? bm.get(0) : bm;
+      if (mode && !["/Normal", "/Compatible"].includes(String(mode)))
+        return true;
     }
-    const group = dict.get(PDFName.of("Group"));
-    if (group) {
-      const resolved = group instanceof PDFRef ? ctx.lookup(group) : group;
-      if (resolved instanceof PDFDict && String(resolved.get(PDFName.of("S"))) === "/Transparency")
+    const group = ctx.lookup(dict.get(PDFName.of("Group")));
+    return group instanceof PDFDict && String(group.get(PDFName.of("S"))) === "/Transparency";
+  };
+  const reaches = (root) => {
+    const seen = new Set;
+    const stack = [root];
+    while (stack.length) {
+      const node = stack.pop();
+      const obj = node instanceof PDFRef ? ctx.lookup(node) : node;
+      if (!obj || seen.has(obj))
+        continue;
+      seen.add(obj);
+      if (obj instanceof PDFArray) {
+        stack.push(...obj.asArray());
+        continue;
+      }
+      const dict = obj instanceof PDFRawStream ? obj.dict : obj instanceof PDFDict ? obj : undefined;
+      if (!dict)
+        continue;
+      if (dictHasTransparency(dict))
         return true;
+      for (const [key, value] of dict.entries()) {
+        if (!SKIP.has(key.asString().slice(1)))
+          stack.push(value);
+      }
     }
-  }
-  return false;
+    return false;
+  };
+  const pages = [];
+  doc.getPages().forEach((page, i) => {
+    if (reaches(page.node))
+      pages.push(i + 1);
+  });
+  return pages;
 }
 async function findPostScriptShadingPages(pdfBytes) {
   const { PDFDocument, PDFDict, PDFName, PDFNumber, PDFRawStream, PDFRef } = await import("pdf-lib");
@@ -241,6 +269,75 @@ async function stripAnnotations(pdfPath, stagingDir) {
   const out = await doc.save();
   await writeFile(pdfPath, out);
 }
+function planTransparentPages(transparent, reasons, flattenPages, gradientPages) {
+  const split = [];
+  const artOnly = [];
+  const kept = new Map;
+  for (const n of transparent) {
+    const reason = reasons.get(n);
+    if (reason === "no-text")
+      artOnly.push(n);
+    else if (flattenPages.includes(n))
+      kept.set(n, "listed");
+    else if (reason)
+      kept.set(n, reason);
+    else if (gradientPages.includes(n))
+      kept.set(n, "gradient");
+    else
+      split.push(n);
+  }
+  return { split, artOnly, kept };
+}
+async function flattenTransparentPages(pdfPath, pageNumbers, stagingDir, dpi = 300) {
+  const pages = [...new Set(pageNumbers)].sort((a, b) => a - b);
+  if (pages.length === 0)
+    return;
+  const ghostscript = await resolveGhostscript();
+  if (!ghostscript) {
+    throw new Error("Ghostscript executable not found. Install Ghostscript or set GHOSTSCRIPT_PATH to its command-line executable.");
+  }
+  const art = join(stagingDir, "flatten-art.pdf");
+  const text = join(stagingDir, "flatten-text.pdf");
+  const pageList = `-sPageList=${pages.join(",")}`;
+  const gs = (...args) => run(ghostscript, [
+    "-q",
+    "-dBATCH",
+    "-dNOPAUSE",
+    "-dSAFER",
+    "-dPreserveAnnots=false",
+    "-dNO_PDFMARK_OUTLINES",
+    ...args
+  ]);
+  try {
+    await gs(pageList, "-sDEVICE=pdfimage24", "-dFILTERTEXT", `-r${dpi}`, `-sOutputFile=${art}`, pdfPath);
+    await gs(pageList, "-sDEVICE=pdfwrite", "-dNOTRANSPARENCY", "-dFILTERIMAGE", "-dFILTERVECTOR", "-dCompatibilityLevel=1.3", `-sOutputFile=${text}`, pdfPath);
+    const { PDFDocument, PDFName } = await import("pdf-lib");
+    const doc = await PDFDocument.load(await readFile(pdfPath), { updateMetadata: false });
+    const artDoc = await PDFDocument.load(await readFile(art));
+    const textDoc = await PDFDocument.load(await readFile(text));
+    if (artDoc.getPageCount() !== pages.length || textDoc.getPageCount() !== pages.length) {
+      throw new Error(`Ghostscript returned ${artDoc.getPageCount()} artwork and ${textDoc.getPageCount()} text pages for ${pages.length} transparent pages.`);
+    }
+    const artPages = await doc.embedPages(artDoc.getPages());
+    const withText = textDoc.getPages().filter((p) => p.node.Contents());
+    const embeddedText = await doc.embedPages(withText);
+    const textPages = textDoc.getPages().map((p) => embeddedText[withText.indexOf(p)]);
+    pages.forEach((pageNumber, i) => {
+      const page = doc.getPage(pageNumber - 1);
+      const { x, y, width, height } = page.getMediaBox();
+      page.node.set(PDFName.of("Contents"), doc.context.obj([]));
+      page.node.set(PDFName.of("Resources"), doc.context.obj({}));
+      page.node.delete(PDFName.of("Group"));
+      page.drawPage(artPages[i], { x, y, width, height });
+      const textPage = textPages[i];
+      if (textPage)
+        page.drawPage(textPage, { x, y, width, height });
+    });
+    await writeFile(pdfPath, await doc.save());
+  } finally {
+    await Promise.all([art, text].map((f) => unlink(f).catch(() => {})));
+  }
+}
 function makePdfxDefPs(params) {
   const pdfxVersion = params.pdfx === "x3" ? "PDF/X-3:2002" : "PDF/X-1:2001";
   const pdfxConformance = params.pdfx === "x1a" ? "PDF/X-1a:2001" : null;
@@ -332,6 +429,10 @@ async function convertToPdfxCmyk(inputPdf, outPdf, config) {
     "-dDownsampleColorImages=false",
     "-dDownsampleGrayImages=false",
     "-dDownsampleMonoImages=false",
+    "-dAutoFilterColorImages=false",
+    "-dColorImageFilter=/FlateEncode",
+    "-dAutoFilterGrayImages=false",
+    "-dGrayImageFilter=/FlateEncode",
     ...config.rasterDpi ? [`-r${config.rasterDpi}`] : [],
     "-sProcessColorModel=DeviceCMYK",
     "-sColorConversionStrategy=CMYK",
@@ -584,4 +685,4 @@ async function getSystemDiagnostics() {
   };
 }
 
-export { setLogLevel, debug, info, warn, error, log, resolveGhostscript, hasLiveTransparency, findPostScriptShadingPages, stripAnnotations, stampCreator, convertToPdfxCmyk, PACKAGE_META, PACKAGE_VERSION, defaultConfigDir, FileTokenStore, getSystemDiagnostics };
+export { setLogLevel, debug, info, warn, error, log, resolveGhostscript, transparentPages, findPostScriptShadingPages, stripAnnotations, planTransparentPages, flattenTransparentPages, stampCreator, convertToPdfxCmyk, PACKAGE_META, PACKAGE_VERSION, defaultConfigDir, FileTokenStore, getSystemDiagnostics };

package/dist/cli.js

@@ -6,7 +6,7 @@ import {
   UsageError,
   package_default,
   rejectUnknownFlags
-} from "./cli-7z29z4wz.js";
+} from "./cli-hn9pk0hp.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";
@@ -18,14 +18,14 @@ import {
 import { defineCommand, parseArgs, runMain } from "citty";
 import { statSync } from "node:fs";
 var SUBCOMMANDS = {
-  new: () => import("./new-ftd4fec4.js").then((m) => m.default),
-  preview: () => import("./preview-q76xn95h.js").then((m) => m.default),
-  build: () => import("./build-qmjg9r2d.js").then((m) => m.default),
-  publish: () => import("./publish-7gdy6gbf.js").then((m) => m.default),
-  validate: () => import("./validate-e3ryegce.js").then((m) => m.default),
-  preflight: () => import("./preflight-8sqarcsr.js").then((m) => m.default),
-  doctor: () => import("./doctor-fe7tcs4v.js").then((m) => m.default),
-  ext: () => import("./ext-ahwxt6gv.js").then((m) => m.default)
+  new: () => import("./new-8yah8z91.js").then((m) => m.default),
+  preview: () => import("./preview-w7v9w36q.js").then((m) => m.default),
+  build: () => import("./build-a8ycsg80.js").then((m) => m.default),
+  publish: () => import("./publish-g5nh5myh.js").then((m) => m.default),
+  validate: () => import("./validate-1yh59x0x.js").then((m) => m.default),
+  preflight: () => import("./preflight-8ccx4kdc.js").then((m) => m.default),
+  doctor: () => import("./doctor-wbjkrcpc.js").then((m) => m.default),
+  ext: () => import("./ext-pesyrs68.js").then((m) => m.default)
 };
 var VERSION = package_default.version;
 var main = defineCommand({
@@ -50,7 +50,7 @@ async function preflightRequiredInvocations(rawArgs) {
   const [command, ...commandArgs] = rawArgs;
   try {
     if (command === "new") {
-      const { newArgs } = await import("./new-ftd4fec4.js");
+      const { newArgs } = await import("./new-8yah8z91.js");
       rejectUnknownFlags(commandArgs, newArgs, "new");
       const parsed = parseArgs(commandArgs, {
         ...newArgs,
@@ -62,7 +62,7 @@ async function preflightRequiredInvocations(rawArgs) {
       return;
     }
     if (command === "preflight") {
-      const { preflightArgs } = await import("./preflight-8sqarcsr.js");
+      const { preflightArgs } = await import("./preflight-8ccx4kdc.js");
       rejectUnknownFlags(commandArgs, preflightArgs, "preflight");
       const parsed = parseArgs(commandArgs, {
         ...preflightArgs,
@@ -82,7 +82,7 @@ async function preflightRequiredInvocations(rawArgs) {
       }
       if (subcommand.startsWith("-"))
         return;
-      const { EXT_SUBCOMMANDS, extAddArgs, extRemoveArgs, extEnableArgs, extDisableArgs } = await import("./ext-ahwxt6gv.js");
+      const { EXT_SUBCOMMANDS, extAddArgs, extRemoveArgs, extEnableArgs, extDisableArgs } = await import("./ext-pesyrs68.js");
       if (!EXT_SUBCOMMANDS.includes(subcommand)) {
         throw new UsageError(`gutterpress ext: unknown command "${subcommand}"`);
       }