@u1f992/pdfdiff 0.1.0 → 0.2.1

package/dist/cli.js

@@ -18,7 +18,6 @@ var HeaderTypes;
     HeaderTypes[HeaderTypes["BITMAP_V4_HEADER"] = 108] = "BITMAP_V4_HEADER";
     HeaderTypes[HeaderTypes["BITMAP_V5_HEADER"] = 124] = "BITMAP_V5_HEADER";
 })(HeaderTypes || (HeaderTypes = {}));
-var HeaderTypes$1 = HeaderTypes;
 
 // We have these:
 //
@@ -148,7 +147,7 @@ class BmpDecoder {
         this.offset = this.readUInt32LE();
         // End of BITMAP_FILE_HEADER
         this.headerSize = this.readUInt32LE();
-        if (!(this.headerSize in HeaderTypes$1)) {
+        if (!(this.headerSize in HeaderTypes)) {
             throw new Error(`Unsupported BMP header size ${this.headerSize}`);
         }
         this.width = this.readUInt32LE();
@@ -180,7 +179,7 @@ class BmpDecoder {
             this.maskBlue = 0x001f;
         }
         // End of BITMAP_INFO_HEADER
-        if (this.headerSize > HeaderTypes$1.BITMAP_INFO_HEADER ||
+        if (this.headerSize > HeaderTypes.BITMAP_INFO_HEADER ||
             this.compression === BmpCompression.BI_BIT_FIELDS ||
             this.compression === BmpCompression.BI_ALPHA_BIT_FIELDS) {
             this.maskRed = this.readUInt32LE();
@@ -188,18 +187,18 @@ class BmpDecoder {
             this.maskBlue = this.readUInt32LE();
         }
         // End of BITMAP_V2_INFO_HEADER
-        if (this.headerSize > HeaderTypes$1.BITMAP_V2_INFO_HEADER ||
+        if (this.headerSize > HeaderTypes.BITMAP_V2_INFO_HEADER ||
             this.compression === BmpCompression.BI_ALPHA_BIT_FIELDS) {
             this.maskAlpha = this.readUInt32LE();
         }
         // End of BITMAP_V3_INFO_HEADER
-        if (this.headerSize > HeaderTypes$1.BITMAP_V3_INFO_HEADER) {
+        if (this.headerSize > HeaderTypes.BITMAP_V3_INFO_HEADER) {
             this.pos +=
-                HeaderTypes$1.BITMAP_V4_HEADER - HeaderTypes$1.BITMAP_V3_INFO_HEADER;
+                HeaderTypes.BITMAP_V4_HEADER - HeaderTypes.BITMAP_V3_INFO_HEADER;
         }
         // End of BITMAP_V4_HEADER
-        if (this.headerSize > HeaderTypes$1.BITMAP_V4_HEADER) {
-            this.pos += HeaderTypes$1.BITMAP_V5_HEADER - HeaderTypes$1.BITMAP_V4_HEADER;
+        if (this.headerSize > HeaderTypes.BITMAP_V4_HEADER) {
+            this.pos += HeaderTypes.BITMAP_V5_HEADER - HeaderTypes.BITMAP_V4_HEADER;
         }
         // End of BITMAP_V5_HEADER
         if (this.bitPP <= 8 || this.colors > 0) {
@@ -515,7 +514,7 @@ class BmpEncoder {
         this.buffer = imgData.data;
         this.width = imgData.width;
         this.height = imgData.height;
-        this.headerSize = HeaderTypes$1.BITMAP_INFO_HEADER;
+        this.headerSize = HeaderTypes.BITMAP_INFO_HEADER;
         // Header
         this.flag = 'BM';
         this.bitPP = imgData.bitPP || 24;
@@ -2032,31 +2031,6 @@ function intToRGBA$1(i) {
         Math.pow(256, 0));
     return rgba;
 }
-/**
- * A static helper method that converts RGBA values to a single integer value
- * @param r the red value (0-255)
- * @param g the green value (0-255)
- * @param b the blue value (0-255)
- * @param a the alpha value (0-255)
- * @example
- * ```ts
- * import { rgbaToInt } from "@jimp/utils";
- *
- * rgbaToInt(255, 0, 0, 255); // 0xFF0000FF
- * ```
- */
-function rgbaToInt(r, g, b, a) {
-    let i = r & 0xff;
-    i <<= 8;
-    i |= g & 0xff;
-    i <<= 8;
-    i |= b & 0xff;
-    i <<= 8;
-    i |= a & 0xff;
-    // Ensure sign is correct
-    i >>>= 0;
-    return i;
-}
 /**
  * Compute color difference
  * 0 means no difference, 1 means maximum difference.
@@ -36374,13 +36348,13 @@ const defaultPlugins = [
 ];
 const defaultFormats = [bmp, msBmp, gif, jpeg$1, png, tiff];
 /** Convenience object for getting the MIME types of the default formats */
-const JimpMime = {
+({
     bmp: bmp().mime,
     gif: gif().mime,
     jpeg: jpeg$1().mime,
     png: png().mime,
     tiff: tiff().mime,
-};
+});
 // TODO: This doesn't document the constructor of the class
 /**
  * @class
@@ -39449,13 +39423,6 @@ globalThis.$libmupdf_device = {
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-function createEmptyImage(width, height) {
-    return new Jimp({
-        width,
-        height,
-        color: rgbaToInt(0, 0, 0, 0),
-    });
-}
 const alignStrategyValues = new Set([
     "resize",
     "top-left",
@@ -39470,55 +39437,6 @@ const alignStrategyValues = new Set([
 ]);
 const isValidAlignStrategy = (str) => alignStrategyValues.has(str);
 
-/*
- * Copyright (C) 2025  Koutaro Mukai
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-async function* withIndex(iter, start = 0) {
-    let index = start;
-    for await (const item of iter) {
-        yield [index, item];
-        index++;
-    }
-}
-
-/*
- * Copyright (C) 2025  Koutaro Mukai
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-async function pageToImage(page, dpi, alpha) {
-    const zoom = dpi / 72;
-    const pixmap = page.toPixmap([zoom, 0, 0, zoom, 0, 0], ColorSpace.DeviceRGB, alpha);
-    const ret = await Jimp.fromBuffer(new Uint8Array(pixmap.asPNG()).buffer);
-    pixmap.destroy();
-    page.destroy();
-    return ret;
-}
-
 /*
  * Copyright (C) 2025  Koutaro Mukai
  *
@@ -39578,6 +39496,32 @@ const formatHex = ([r, g, b, a]) => "#" +
     })
         .join("");
 
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+async function* withIndex(iter, start = 0) {
+    let index = start;
+    for await (const item of iter) {
+        yield [index, item];
+        index++;
+    }
+}
+
+const VERSION = "0.2.1";
+
 /*
  * Copyright (C) 2025  Koutaro Mukai
  *
@@ -39604,9 +39548,105 @@ const defaultOptions = {
         deletion: [0xff, 0x57, 0x24, 0xff],
         modification: [0xff, 0xc1, 0x05, 0xff],
     },
+    workers: 1,
 };
+function asSharedBytes(bytes) {
+    const isNode = typeof globalThis.process !== "undefined" &&
+        !!globalThis.process.versions?.node;
+    const coiOk = globalThis.crossOriginIsolated ===
+        true;
+    if (typeof SharedArrayBuffer !== "undefined" && (isNode || coiOk)) {
+        const sab = new SharedArrayBuffer(bytes.byteLength);
+        const view = new Uint8Array(sab);
+        view.set(bytes);
+        return view;
+    }
+    return new Uint8Array(bytes);
+}
+class WorkerHandle {
+    worker;
+    loaded;
+    pendingResolve = null;
+    pendingReject = null;
+    constructor(url) {
+        this.worker = new Worker(url, { type: "module" });
+        this.loaded = new Promise((resolveLoaded, rejectLoaded) => {
+            const onMessage = (e) => {
+                const data = e.data;
+                if (data.type === "loaded") {
+                    resolveLoaded();
+                    return;
+                }
+                const resolve = this.pendingResolve;
+                const reject = this.pendingReject;
+                this.pendingResolve = null;
+                this.pendingReject = null;
+                if (data.type === "error") {
+                    reject?.(new Error(`worker: ${data.message}`));
+                }
+                else {
+                    resolve?.(data);
+                }
+            };
+            this.worker.addEventListener("message", onMessage);
+            this.worker.addEventListener("error", (e) => {
+                const err = e.error ?? new Error(e.message);
+                rejectLoaded(err);
+                const reject = this.pendingReject;
+                this.pendingResolve = null;
+                this.pendingReject = null;
+                reject?.(err);
+            });
+        });
+    }
+    async init(msg) {
+        await this.loaded;
+        return new Promise((resolve, reject) => {
+            this.pendingResolve = resolve;
+            this.pendingReject = reject;
+            this.worker.postMessage(msg);
+        });
+    }
+    processPage(index) {
+        return new Promise((resolve, reject) => {
+            this.pendingResolve = resolve;
+            this.pendingReject = reject;
+            const msg = { type: "page", index };
+            this.worker.postMessage(msg);
+        });
+    }
+    terminate() {
+        this.worker.terminate();
+    }
+}
+function workerUrl() {
+    const file = import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js";
+    return new URL(`${file}?v=${encodeURIComponent(VERSION)}`, import.meta.url);
+}
+function pageResultToResult(msg) {
+    return {
+        a: Jimp.fromBitmap({
+            width: msg.a.width,
+            height: msg.a.height,
+            data: new Uint8Array(msg.a.data),
+        }),
+        b: Jimp.fromBitmap({
+            width: msg.b.width,
+            height: msg.b.height,
+            data: new Uint8Array(msg.b.data),
+        }),
+        diff: Jimp.fromBitmap({
+            width: msg.diff.width,
+            height: msg.diff.height,
+            data: new Uint8Array(msg.diff.data),
+        }),
+        addition: msg.addition,
+        deletion: msg.deletion,
+        modification: msg.modification,
+    };
+}
 async function* visualizeDifferences(a, b, options) {
-    const mergedOptions = {
+    const merged = {
         dpi: options?.dpi ?? defaultOptions.dpi,
         alpha: options?.alpha ?? defaultOptions.alpha,
         mask: options?.mask ?? defaultOptions.mask,
@@ -39616,76 +39656,92 @@ async function* visualizeDifferences(a, b, options) {
             deletion: options?.pallet?.deletion ?? defaultOptions.pallet.deletion,
             modification: options?.pallet?.modification ?? defaultOptions.pallet.modification,
         },
+        workers: options?.workers ?? defaultOptions.workers,
     };
-    const pdfA = PDFDocument.openDocument(a, "application/pdf");
-    const pdfB = PDFDocument.openDocument(b, "application/pdf");
-    const pdfMask = typeof mergedOptions.mask !== "undefined"
-        ? PDFDocument.openDocument(mergedOptions.mask, "application/pdf")
+    const probe = PDFDocument.openDocument(a, "application/pdf");
+    const probeB = PDFDocument.openDocument(b, "application/pdf");
+    const probeMask = typeof merged.mask !== "undefined"
+        ? PDFDocument.openDocument(merged.mask, "application/pdf")
         : new PDFDocument();
-    const maxPages = Math.max(pdfA.countPages(), pdfB.countPages(), pdfMask.countPages());
-    async function processPage(pageIndex) {
-        const [pageA, pageB, pageMask] = await Promise.all([
-            pageIndex < pdfA.countPages()
-                ? pageToImage(pdfA.loadPage(pageIndex), mergedOptions.dpi, mergedOptions.alpha)
-                : createEmptyImage(1, 1),
-            pageIndex < pdfB.countPages()
-                ? pageToImage(pdfB.loadPage(pageIndex), mergedOptions.dpi, mergedOptions.alpha)
-                : createEmptyImage(1, 1),
-            pageIndex < pdfMask.countPages()
-                ? pageToImage(pdfMask.loadPage(pageIndex), mergedOptions.dpi, mergedOptions.alpha)
-                : createEmptyImage(1, 1),
-        ]);
-        // NOTE: getBufferはcopyなので、Workerに移譲した後もa, bを使用して問題ない
-        // https://github.com/jimp-dev/jimp/blob/b6b0e418a5f1259211a133b20cddb4f4e5c25679/packages/core/src/index.ts#L444
-        const [bufA, bufB, bufMask] = await Promise.all([
-            pageA
-                .getBuffer(JimpMime.png)
-                .then((buf) => new Uint8Array(buf).buffer),
-            pageB
-                .getBuffer(JimpMime.png)
-                .then((buf) => new Uint8Array(buf).buffer),
-            pageMask
-                .getBuffer(JimpMime.png)
-                .then((buf) => new Uint8Array(buf).buffer),
-        ]);
-        const { bufDiff, addition, deletion, modification } = (await new Promise((resolve, reject) => {
-            const url = new URL("./worker.js", import.meta.url);
-            const worker = new Worker(url, { type: "module" });
-            worker.addEventListener("message", (e) => {
-                resolve(e.data);
-                worker.terminate();
-            });
-            worker.addEventListener("error", (e) => {
-                reject(e);
-                worker.terminate();
-            });
-            worker.postMessage({
-                bufA,
-                bufB,
-                bufMask,
-                pallet: mergedOptions.pallet,
-                align: mergedOptions.align,
-            }, [bufA, bufB, bufMask]);
-        }));
-        const diff = await Jimp.fromBuffer(bufDiff);
-        return { a: pageA, b: pageB, diff, addition, deletion, modification };
-    }
-    // ページ処理を並列発行し、順序を保証して出力
-    const concurrency = navigator.hardwareConcurrency;
-    const pending = /** @type {Promise<VisualizeDifferencesResult>[]} */ [];
-    let nextPageToProcess = 0;
-    let nextPageToYield = 0;
-    while (nextPageToYield < maxPages) {
-        // プールに空きがあれば新しいページ処理を追加
-        while (nextPageToProcess < maxPages && pending.length < concurrency) {
-            pending.push(processPage(nextPageToProcess));
-            nextPageToProcess++;
+    const maxPages = Math.max(probe.countPages(), probeB.countPages(), probeMask.countPages());
+    probe.destroy();
+    probeB.destroy();
+    probeMask.destroy();
+    if (maxPages === 0)
+        return;
+    const aBytes = asSharedBytes(a);
+    const bBytes = asSharedBytes(b);
+    const maskBytes = typeof merged.mask !== "undefined" ? asSharedBytes(merged.mask) : null;
+    const initMsg = {
+        type: "init",
+        aBytes,
+        bBytes,
+        maskBytes,
+        dpi: merged.dpi,
+        alpha: merged.alpha,
+        pallet: merged.pallet,
+        align: merged.align,
+    };
+    const N = Math.max(1, Math.min(merged.workers, maxPages));
+    const url = workerUrl();
+    const worker0 = new WorkerHandle(url);
+    await worker0.init(initMsg);
+    const buffered = new Map();
+    let nextToAssign = 0;
+    const workers = [worker0];
+    for (let i = 1; i < N; i++) {
+        const w = new WorkerHandle(url);
+        await w.init(initMsg);
+        workers.push(w);
+    }
+    const resolvers = new Map();
+    let workerError = null;
+    const loops = workers.map(async (w) => {
+        while (nextToAssign < maxPages && workerError === null) {
+            const idx = nextToAssign++;
+            try {
+                const msg = await w.processPage(idx);
+                const result = pageResultToResult(msg);
+                const resolve = resolvers.get(idx);
+                if (resolve) {
+                    resolvers.delete(idx);
+                    resolve(result);
+                }
+                else {
+                    buffered.set(idx, result);
+                }
+            }
+            catch (e) {
+                workerError = e;
+                for (const [, resolve] of resolvers)
+                    resolve(null);
+                resolvers.clear();
+                return;
+            }
+        }
+    });
+    try {
+        for (let i = 0; i < maxPages; i++) {
+            if (workerError !== null)
+                throw workerError;
+            let r;
+            const buf = buffered.get(i);
+            if (buf !== undefined) {
+                buffered.delete(i);
+                r = buf;
+            }
+            else {
+                r = await new Promise((resolve) => resolvers.set(i, resolve));
+                if (workerError !== null)
+                    throw workerError;
+            }
+            yield r;
         }
-        // 次に出力すべきページのPromiseを待つ
-        const result = await pending[0];
-        pending.shift();
-        yield result;
-        nextPageToYield++;
+        await Promise.all(loops);
+    }
+    finally {
+        for (const w of workers)
+            w.terminate();
     }
 }
 
@@ -39705,7 +39761,7 @@ async function* visualizeDifferences(a, b, options) {
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-const { positionals, values: { dpi: dpi_, alpha: alpha_, mask: mask_, align: align_, "addition-color": additionColorHex, "deletion-color": deletionColorHex, "modification-color": modificationColorHex, version, help, }, } = util$2.parseArgs({
+const { positionals, values: { dpi: dpi_, alpha: alpha_, mask: mask_, align: align_, "addition-color": additionColorHex, "deletion-color": deletionColorHex, "modification-color": modificationColorHex, workers: workers_, version, help, }, } = util$2.parseArgs({
     allowPositionals: true,
     options: {
         dpi: { type: "string" },
@@ -39715,6 +39771,7 @@ const { positionals, values: { dpi: dpi_, alpha: alpha_, mask: mask_, align: ali
         "addition-color": { type: "string" },
         "deletion-color": { type: "string" },
         "modification-color": { type: "string" },
+        workers: { type: "string" },
         version: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" },
     },
@@ -39733,21 +39790,22 @@ OPTIONS:
     --addition-color <#HEX>        default: ${formatHex(defaultOptions.pallet.addition)}
     --deletion-color <#HEX>        default: ${formatHex(defaultOptions.pallet.deletion)}
     --modification-color <#HEX>    default: ${formatHex(defaultOptions.pallet.modification)}
+    --workers <N>                  default: ${defaultOptions.workers}
     -v, --version
     -h, --help
+
+NOTES:
+    Approximate per-worker memory:
+        a_size_MB + b_size_MB [+ mask_size_MB]    (PDF buffers in wasm)
+        + 300 MB                                  (mupdf + V8 base)
+        + (dpi / 150)^2 * 50 MB                   (pixmap working set)
+    The main process adds ~500 MB - 1 GB (varies with --workers).
+    Choose --workers so the total stays under ~80% of available memory.
 `);
     process.exit(0);
 }
 if (version) {
-    try {
-        const versionStr = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), {
-            encoding: "utf-8",
-        })).version;
-        console.log(versionStr);
-    }
-    catch {
-        console.log("unknown");
-    }
+    console.log(VERSION);
     process.exit(0);
 }
 if (positionals.length !== 3) {
@@ -39782,6 +39840,12 @@ if (additionColor === null ||
     modificationColor === null) {
     throw new Error("Invalid color format");
 }
+const workers = typeof workers_ !== "undefined"
+    ? parseInt(workers_, 10)
+    : defaultOptions.workers;
+if (Number.isNaN(workers) || workers < 1) {
+    throw new Error("Invalid workers value");
+}
 fs.mkdirSync(outDir, { recursive: true });
 for await (const [i, { a, b, diff, addition, deletion, modification },] of withIndex(visualizeDifferences(pdfA, pdfB, {
     dpi,
@@ -39793,6 +39857,7 @@ for await (const [i, { a, b, diff, addition, deletion, modification },] of withI
         deletion: deletionColor,
         modification: modificationColor,
     },
+    workers,
 }), 1)) {
     console.log(`Page ${i}, Addition: ${addition.length}, Deletion: ${deletion.length}, Modification: ${modification.length}`);
     const dir = path.join(outDir, i.toString(10));