@vivliostyle/cli 10.2.0 → 10.3.0

package/dist/{chunk-5MEUINC4.js → chunk-ALY3QX7K.js}

@@ -1,6 +1,6 @@
 import {
   resolveViteConfig
-} from "./chunk-XMCTTVR7.js";
+} from "./chunk-RBKPG6VU.js";
 import {
   buildWebPublication,
   cleanupWorkspace,
@@ -16,10 +16,10 @@ import {
   prepareThemeDirectory,
   resolveTaskConfig,
   warnDeprecatedConfig
-} from "./chunk-BR2V7MHE.js";
+} from "./chunk-YNX6D2I6.js";
 import {
   importNodeModule
-} from "./chunk-E6QVHS6D.js";
+} from "./chunk-ECEGM36O.js";
 import {
   Logger,
   copyAssets,
@@ -32,7 +32,7 @@ import {
   randomBookSymbol,
   runExitHandlers,
   setupConfigFromFlags
-} from "./chunk-T2VWLU2I.js";
+} from "./chunk-RILZCPJE.js";
 import {
   CONTAINER_LOCAL_HOSTNAME,
   CONTAINER_ROOT_DIR,
@@ -187,7 +187,7 @@ async function buildPDFWithContainer({
 }
 
 // src/output/pdf.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import { URL as URL2 } from "node:url";
 import terminalLink from "terminal-link";
 import upath3 from "upath";
@@ -195,10 +195,442 @@ import { cyan, gray, green, red } from "yoctocolors";
 
 // src/output/pdf-postprocess.ts
 import decamelize from "decamelize";
-import fs from "node:fs";
+import fs2 from "node:fs";
 import os from "node:os";
 import upath2 from "upath";
 import { v1 as uuid } from "uuid";
+
+// src/output/pdf-stream.ts
+var SRGB_MAX = 1e4;
+var CMYK_MAX = 1e4;
+function* tokenize(content) {
+  let i = 0;
+  const len = content.length;
+  while (i < len) {
+    while (i < len && /\s/.test(content[i])) i++;
+    if (i >= len) break;
+    const c = content[i];
+    if (c === "%") {
+      const start = i;
+      while (i < len && content[i] !== "\n" && content[i] !== "\r") i++;
+      yield { type: "other", raw: content.slice(start, i) };
+      continue;
+    }
+    if (c === "(") {
+      let depth = 1;
+      let str = "(";
+      i++;
+      while (i < len && depth > 0) {
+        if (content[i] === "\\" && i + 1 < len) {
+          str += content[i] + content[i + 1];
+          i += 2;
+        } else {
+          if (content[i] === "(") depth++;
+          else if (content[i] === ")") depth--;
+          str += content[i];
+          i++;
+        }
+      }
+      yield { type: "other", raw: str };
+      continue;
+    }
+    if (c === "<" && content[i + 1] !== "<") {
+      let str = "<";
+      i++;
+      while (i < len && content[i] !== ">") {
+        str += content[i];
+        i++;
+      }
+      if (i < len) {
+        str += ">";
+        i++;
+      }
+      yield { type: "other", raw: str };
+      continue;
+    }
+    if (c === "[" || c === "]" || c === "{" || c === "}") {
+      yield { type: "other", raw: c };
+      i++;
+      continue;
+    }
+    if (c === "<" && content[i + 1] === "<") {
+      yield { type: "other", raw: "<<" };
+      i += 2;
+      continue;
+    }
+    if (c === ">" && content[i + 1] === ">") {
+      yield { type: "other", raw: ">>" };
+      i += 2;
+      continue;
+    }
+    if (c === "/") {
+      let name = "/";
+      i++;
+      while (i < len && /[^\s\[\]()<>{}/%]/.test(content[i])) {
+        name += content[i];
+        i++;
+      }
+      yield { type: "other", raw: name };
+      continue;
+    }
+    let token = "";
+    while (i < len && /[^\s\[\]()<>{}/%]/.test(content[i])) {
+      token += content[i];
+      i++;
+    }
+    if (/^[+-]?(\d+\.?\d*|\.\d+)$/.test(token)) {
+      yield { type: "number", value: parseFloat(token), raw: token };
+    } else if (token === "ID") {
+      yield { type: "operator", value: "ID", raw: "ID" };
+      const dataStart = i;
+      while (i < len) {
+        if (/\s/.test(content[i]) && content[i + 1] === "E" && content[i + 2] === "I" && (i + 3 >= len || /\s/.test(content[i + 3]))) {
+          yield { type: "other", raw: content.slice(dataStart, i + 1) };
+          yield { type: "operator", value: "EI", raw: "EI" };
+          i += 3;
+          break;
+        }
+        i++;
+      }
+    } else if (token.length > 0) {
+      yield { type: "operator", value: token, raw: token };
+    }
+  }
+}
+function formatRgbKey(r, g, b) {
+  const ri = Math.round(r * SRGB_MAX);
+  const gi = Math.round(g * SRGB_MAX);
+  const bi = Math.round(b * SRGB_MAX);
+  return JSON.stringify([ri, gi, bi]);
+}
+function formatRgbKeyForWarning(r, g, b) {
+  const ri = Math.round(r * SRGB_MAX);
+  const gi = Math.round(g * SRGB_MAX);
+  const bi = Math.round(b * SRGB_MAX);
+  return JSON.stringify({ r: ri, g: gi, b: bi });
+}
+function convertStreamColors(content, colorMap, warnUnmapped, warnedColors) {
+  const result = [];
+  const pendingNumbers = [];
+  const flushPendingNumbers = () => {
+    for (const num of pendingNumbers) {
+      result.push(num.raw);
+    }
+    pendingNumbers.length = 0;
+  };
+  for (const token of tokenize(content)) {
+    if (token.type === "number") {
+      pendingNumbers.push({ value: token.value, raw: token.raw });
+    } else if (token.type === "operator") {
+      const op = token.value;
+      const cmykOp = op === "rg" ? "k" : op === "RG" ? "K" : null;
+      if (cmykOp && pendingNumbers.length >= 3) {
+        const b = pendingNumbers.pop();
+        const g = pendingNumbers.pop();
+        const r = pendingNumbers.pop();
+        flushPendingNumbers();
+        const key = formatRgbKey(r.value, g.value, b.value);
+        const cmyk = colorMap[key];
+        if (cmyk) {
+          const c = (cmyk.c / CMYK_MAX).toString();
+          const m = (cmyk.m / CMYK_MAX).toString();
+          const y = (cmyk.y / CMYK_MAX).toString();
+          const k = (cmyk.k / CMYK_MAX).toString();
+          result.push(`${c} ${m} ${y} ${k} ${cmykOp}`);
+        } else {
+          result.push(r.raw, g.raw, b.raw, token.raw);
+          if (warnUnmapped) {
+            const warnKey = formatRgbKeyForWarning(r.value, g.value, b.value);
+            if (!warnedColors.has(warnKey)) {
+              warnedColors.add(warnKey);
+              Logger.logWarn(`RGB color not mapped to CMYK: ${warnKey}`);
+            }
+          }
+        }
+      } else {
+        flushPendingNumbers();
+        result.push(token.raw);
+      }
+    } else {
+      flushPendingNumbers();
+      result.push(token.raw);
+    }
+  }
+  flushPendingNumbers();
+  return result.join(" ");
+}
+
+// src/output/cmyk.ts
+function disposable(obj) {
+  return Object.assign(obj, {
+    [Symbol.dispose]() {
+      obj.destroy();
+    }
+  });
+}
+function processStream(stream, colorMap, warnUnmapped, warnedColors, mupdf) {
+  const buffer = stream.readStream();
+  const content = buffer.asString();
+  const converted = convertStreamColors(
+    content,
+    colorMap,
+    warnUnmapped,
+    warnedColors
+  );
+  stream.writeStream(new mupdf.Buffer(converted));
+}
+function processFormXObjects(resources, colorMap, warnUnmapped, warnedColors, mupdf, processed) {
+  const xobjects = resources.get("XObject");
+  if (!xobjects || !xobjects.isDictionary()) {
+    return;
+  }
+  xobjects.forEach((xobj) => {
+    if (!xobj || !xobj.isStream()) {
+      return;
+    }
+    const resolved = xobj.resolve();
+    const objNum = resolved.asIndirect();
+    if (objNum && processed.has(objNum)) {
+      return;
+    }
+    if (objNum) {
+      processed.add(objNum);
+    }
+    const subtype = resolved.get("Subtype");
+    if (!subtype || subtype.toString() !== "/Form") {
+      return;
+    }
+    processStream(resolved, colorMap, warnUnmapped, warnedColors, mupdf);
+    const nestedResources = resolved.get("Resources");
+    if (nestedResources && nestedResources.isDictionary()) {
+      processFormXObjects(
+        nestedResources,
+        colorMap,
+        warnUnmapped,
+        warnedColors,
+        mupdf,
+        processed
+      );
+    }
+  });
+}
+function processContents(contents, colorMap, warnUnmapped, warnedColors, mupdf) {
+  if (contents.isArray()) {
+    for (let i = 0; i < contents.length; i++) {
+      const streamObj = contents.get(i);
+      if (streamObj && streamObj.isStream()) {
+        processStream(
+          streamObj.resolve(),
+          colorMap,
+          warnUnmapped,
+          warnedColors,
+          mupdf
+        );
+      }
+    }
+  } else if (contents.isStream()) {
+    processStream(contents, colorMap, warnUnmapped, warnedColors, mupdf);
+  }
+}
+async function convertCmykColors({
+  pdf,
+  colorMap,
+  warnUnmapped
+}) {
+  var _stack = [];
+  try {
+    const mupdf = await importNodeModule("mupdf");
+    const warnedColors = /* @__PURE__ */ new Set();
+    const processedXObjects = /* @__PURE__ */ new Set();
+    const doc = __using(_stack, disposable(
+      mupdf.PDFDocument.openDocument(
+        pdf,
+        "application/pdf"
+      )
+    ));
+    const pageCount = doc.countPages();
+    for (let i = 0; i < pageCount; i++) {
+      const page = doc.loadPage(i);
+      const pageObj = page.getObject().resolve();
+      const contents = pageObj.get("Contents");
+      if (contents) {
+        processContents(contents, colorMap, warnUnmapped, warnedColors, mupdf);
+      }
+      const resources = pageObj.get("Resources");
+      if (resources && resources.isDictionary()) {
+        processFormXObjects(
+          resources,
+          colorMap,
+          warnUnmapped,
+          warnedColors,
+          mupdf,
+          processedXObjects
+        );
+      }
+      const annots = pageObj.get("Annots");
+      if (!annots?.isArray()) {
+        continue;
+      }
+      for (let j = 0; j < annots.length; j++) {
+        const annot = annots.get(j);
+        if (!annot) {
+          continue;
+        }
+        const ap = annot.resolve().get("AP");
+        if (!ap?.isDictionary()) {
+          continue;
+        }
+        const n = ap.get("N");
+        if (!n) {
+          continue;
+        }
+        if (n.isStream()) {
+          processStream(n, colorMap, warnUnmapped, warnedColors, mupdf);
+        } else if (n.isDictionary()) {
+          n.forEach((val) => {
+            if (val?.isStream()) {
+              processStream(val, colorMap, warnUnmapped, warnedColors, mupdf);
+            }
+          });
+        }
+      }
+    }
+    const outputBuffer = __using(_stack, disposable(doc.saveToBuffer("compress")));
+    return new Uint8Array(outputBuffer.asUint8Array());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+
+// src/output/image.ts
+import fs from "node:fs";
+function disposable2(obj) {
+  return Object.assign(obj, {
+    [Symbol.dispose]() {
+      obj.destroy();
+    }
+  });
+}
+function imagesEqual(a, b) {
+  if (a.getWidth() !== b.getWidth() || a.getHeight() !== b.getHeight()) {
+    return false;
+  }
+  const pixmapA = a.toPixmap();
+  const pixmapB = b.toPixmap();
+  const typeA = pixmapA.getColorSpace();
+  const typeB = pixmapB.getColorSpace();
+  if (typeA === null || typeB === null || !(typeA.isRGB() && typeB.isRGB() || typeA.isCMYK() && typeB.isCMYK() || typeA.isGray() && typeB.isGray())) {
+    return false;
+  }
+  const pixelsA = pixmapA.getPixels();
+  const pixelsB = pixmapB.getPixels();
+  return pixelsA.length === pixelsB.length && Buffer.compare(Buffer.from(pixelsA), Buffer.from(pixelsB)) === 0;
+}
+function replaceImagesInDocument(doc, imagePairs) {
+  let replaced = 0;
+  let total = 0;
+  const pageCount = doc.countPages();
+  for (let i = 0; i < pageCount; i++) {
+    const page = doc.loadPage(i);
+    const pageObj = page.getObject().resolve();
+    const res = pageObj.get("Resources");
+    if (!res || !res.isDictionary()) continue;
+    const xobjects = res.get("XObject");
+    if (!xobjects || !xobjects.isDictionary()) continue;
+    const entries = [];
+    xobjects.forEach((value, key) => {
+      entries.push({ key, value });
+    });
+    for (const { key, value } of entries) {
+      const resolved = value.resolve();
+      const subtype = resolved.get("Subtype");
+      if (subtype && subtype.toString() === "/Image") {
+        total++;
+        const pdfImage = doc.loadImage(value);
+        for (const pair of imagePairs) {
+          if (imagesEqual(pdfImage, pair.srcImage)) {
+            const newImageRef = doc.addImage(pair.destImage);
+            xobjects.put(key, newImageRef);
+            replaced++;
+            Logger.debug(
+              `  Page ${i + 1}, ref "${key}": ${pair.sourcePath} -> ${pair.replacementPath}`
+            );
+            break;
+          }
+        }
+      }
+    }
+    res.put("XObject", xobjects);
+    pageObj.put("Resources", res);
+  }
+  return { replaced, total };
+}
+async function replaceImages({
+  pdf,
+  replaceImageConfig
+}) {
+  var _stack = [];
+  try {
+    if (replaceImageConfig.length === 0) {
+      return pdf;
+    }
+    const mupdf = await importNodeModule("mupdf");
+    const imagePairs = [];
+    for (const { source, replacement } of replaceImageConfig) {
+      let srcImage;
+      let destImage;
+      try {
+        const srcBuffer = fs.readFileSync(source);
+        srcImage = new mupdf.Image(srcBuffer);
+        Logger.debug(
+          `Loaded source image: ${source} (${srcImage.getWidth()}x${srcImage.getHeight()})`
+        );
+      } catch (error) {
+        Logger.logWarn(`Failed to load source image: ${source}: ${error}`);
+        continue;
+      }
+      try {
+        const destBuffer = fs.readFileSync(replacement);
+        destImage = new mupdf.Image(destBuffer);
+        Logger.debug(
+          `Loaded replacement image: ${replacement} (${destImage.getWidth()}x${destImage.getHeight()})`
+        );
+      } catch (error) {
+        Logger.logWarn(
+          `Failed to load replacement image: ${replacement}: ${error}`
+        );
+        continue;
+      }
+      imagePairs.push({
+        srcImage,
+        destImage,
+        sourcePath: source,
+        replacementPath: replacement
+      });
+    }
+    if (imagePairs.length === 0) {
+      return pdf;
+    }
+    const doc = __using(_stack, disposable2(
+      mupdf.PDFDocument.openDocument(
+        pdf,
+        "application/pdf"
+      )
+    ));
+    const stats = replaceImagesInDocument(doc, imagePairs);
+    Logger.debug(`Replaced ${stats.replaced} of ${stats.total} images`);
+    const outputBuffer = __using(_stack, disposable2(doc.saveToBuffer("compress")));
+    return new Uint8Array(outputBuffer.asUint8Array());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+
+// src/output/pdf-postprocess.ts
 var prefixes = {
   dcterms: "http://purl.org/dc/terms/",
   meta: "http://idpf.org/epub/vocab/package/meta/#"
@@ -247,49 +679,89 @@ var PostProcess = class _PostProcess {
   constructor(document2) {
     this.document = document2;
   }
-  async save(output, { preflight, preflightOption, image }) {
-    const input = preflight ? upath2.join(os.tmpdir(), `vivliostyle-cli-${uuid()}.pdf`) : output;
-    const pdf = await this.document.save();
-    await fs.promises.writeFile(input, pdf);
-    if (preflight === "press-ready-local" || preflight === "press-ready" && isInContainer()) {
-      var _stack = [];
-      try {
-        const _3 = __using(_stack, Logger.suspendLogging("Running press-ready"));
-        const { build: build2 } = await importNodeModule("press-ready");
-        await build2({
-          ...preflightOption.reduce((acc, opt) => {
-            const optName = decamelize(opt, { separator: "-" });
-            return optName.startsWith("no-") ? {
-              ...acc,
-              [optName.slice(3)]: false
-            } : {
-              ...acc,
-              [optName]: true
-            };
-          }, {}),
-          input,
-          output
-        });
-      } catch (_) {
-        var _error = _, _hasError = true;
-      } finally {
-        __callDispose(_stack, _error, _hasError);
+  async save(output, {
+    preflight,
+    preflightOption,
+    image,
+    cmyk,
+    cmykMap,
+    replaceImage
+  }) {
+    let pdf = await this.document.save();
+    if (cmyk) {
+      const mergedMap = { ...cmykMap };
+      for (const [rgb, cmykValue] of cmyk.overrideMap) {
+        const key = JSON.stringify([rgb.r, rgb.g, rgb.b]);
+        mergedMap[key] = cmykValue;
       }
-    } else if (preflight === "press-ready") {
-      var _stack2 = [];
-      try {
-        const _3 = __using(_stack2, Logger.suspendLogging("Running press-ready"));
-        await pressReadyWithContainer({
-          input,
-          output,
-          preflightOption,
-          image
-        });
-      } catch (_2) {
-        var _error2 = _2, _hasError2 = true;
-      } finally {
-        __callDispose(_stack2, _error2, _hasError2);
+      Logger.logInfo("Converting CMYK colors");
+      pdf = await convertCmykColors({
+        pdf,
+        colorMap: mergedMap,
+        warnUnmapped: cmyk.warnUnmapped
+      });
+      if (cmyk.mapOutput) {
+        const mapOutputDir = upath2.dirname(cmyk.mapOutput);
+        fs2.mkdirSync(mapOutputDir, { recursive: true });
+        await fs2.promises.writeFile(
+          cmyk.mapOutput,
+          JSON.stringify(mergedMap, null, 2)
+        );
+        Logger.logInfo(`CMYK color map saved to ${cmyk.mapOutput}`);
+      }
+    }
+    if (replaceImage.length > 0) {
+      Logger.logInfo("Replacing images");
+      pdf = await replaceImages({
+        pdf,
+        replaceImageConfig: replaceImage
+      });
+    }
+    if (preflight) {
+      const input = upath2.join(os.tmpdir(), `vivliostyle-cli-${uuid()}.pdf`);
+      await fs2.promises.writeFile(input, pdf);
+      if (preflight === "press-ready-local" || preflight === "press-ready" && isInContainer()) {
+        var _stack = [];
+        try {
+          const _3 = __using(_stack, Logger.suspendLogging("Running press-ready"));
+          const { build: build2 } = await importNodeModule("press-ready");
+          await build2({
+            ...preflightOption.reduce((acc, opt) => {
+              const optName = decamelize(opt, { separator: "-" });
+              return optName.startsWith("no-") ? {
+                ...acc,
+                [optName.slice(3)]: false
+              } : {
+                ...acc,
+                [optName]: true
+              };
+            }, {}),
+            input,
+            output
+          });
+        } catch (_) {
+          var _error = _, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
+      } else if (preflight === "press-ready") {
+        var _stack2 = [];
+        try {
+          const _3 = __using(_stack2, Logger.suspendLogging("Running press-ready"));
+          await pressReadyWithContainer({
+            input,
+            output,
+            preflightOption,
+            image
+          });
+        } catch (_2) {
+          var _error2 = _2, _hasError2 = true;
+        } finally {
+          __callDispose(_stack2, _error2, _hasError2);
+        }
       }
+    } else {
+      await fs2.promises.writeFile(output, pdf);
     }
   }
   async metadata(tree, {
@@ -506,7 +978,7 @@ async function buildPDF({
           response.url()
         );
         handleEntry(response);
-        if (300 > response.status() && 200 <= response.status()) return;
+        if (400 > response.status() && 200 <= response.status()) return;
         if (response.url().startsWith("file://") && response.ok()) return;
         Logger.logError(red(`${response.status()}`), response.url());
       });
@@ -546,6 +1018,7 @@ async function buildPDF({
   const metadata = await loadMetadata(page);
   const toc = await loadTOC(page);
   const pageSizeData = await loadPageSizeData(page);
+  const cmykMap = target.cmyk ? await loadCmykMap(page) : {};
   remainTime -= Date.now() - startTime;
   if (remainTime <= 0) {
     throw new Error("Typesetting process timed out");
@@ -572,7 +1045,7 @@ async function buildPDF({
   });
   await browser.close();
   Logger.logUpdate("Processing PDF");
-  fs2.mkdirSync(upath3.dirname(target.path), { recursive: true });
+  fs3.mkdirSync(upath3.dirname(target.path), { recursive: true });
   const post = await PostProcess.load(pdf);
   await post.metadata(metadata, {
     pageProgression,
@@ -587,7 +1060,10 @@ async function buildPDF({
   await post.save(target.path, {
     preflight: target.preflight,
     preflightOption: target.preflightOption,
-    image: config.image
+    image: config.image,
+    cmyk: target.cmyk,
+    cmykMap,
+    replaceImage: target.replaceImage
   });
   return target.path;
 }
@@ -630,6 +1106,9 @@ async function loadPageSizeData(page) {
     return sizeData;
   });
 }
+async function loadCmykMap(page) {
+  return page.evaluate(() => window.coreViewer.getCmykMap?.() ?? {});
+}
 
 // src/core/build.ts
 async function build(inlineConfig, { containerForkMode = false } = {}) {
@@ -754,4 +1233,4 @@ async function build(inlineConfig, { containerForkMode = false } = {}) {
 export {
   build
 };
-//# sourceMappingURL=chunk-5MEUINC4.js.map
+//# sourceMappingURL=chunk-ALY3QX7K.js.map