@u1f992/pdfdiff 0.2.2 → 0.3.1

package/src/index.ts

@@ -1,29 +1,13 @@
-/*
- * 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/>.
- */
-
 import * as jimp from "jimp";
-import * as mupdf from "mupdf";
 import Worker from "web-worker";
 
 import { type Pallet } from "./diff.ts";
 import { isValidAlignStrategy, type AlignStrategy } from "./image.ts";
 import { withIndex } from "./iterable.ts";
+import { countPages, renderPageRangePng } from "./pdf.ts";
 import { perf } from "./perf.ts";
 import { parseHex, formatHex } from "./rgba-color.ts";
+import { sliceBackingBuffer } from "./transferable.ts";
 import { VERSION } from "./version.ts";
 import type { JimpInstance } from "./jimp.ts";
 import type {
@@ -55,6 +39,15 @@ type Result = {
   modification: [number, number][];
 };
 
+// Default parallelism scales with the machine: rendering and diffing run across
+// several workers, so the out-of-the-box run uses the CPU rather than a single
+// core. Capped at 4 to keep the default memory footprint and oversubscription
+// modest; raise --workers explicitly for large jobs on big machines.
+export const defaultWorkers = Math.max(
+  1,
+  Math.min(globalThis.navigator?.hardwareConcurrency ?? 1, 4),
+);
+
 export const defaultOptions: Options = {
   dpi: 150,
   alpha: true,
@@ -65,25 +58,9 @@ export const defaultOptions: Options = {
     deletion: [0xff, 0x57, 0x24, 0xff],
     modification: [0xff, 0xc1, 0x05, 0xff],
   },
-  workers: 1,
+  workers: defaultWorkers,
 };
 
-function asSharedBytes(bytes: Uint8Array): Uint8Array {
-  const isNode =
-    typeof globalThis.process !== "undefined" &&
-    !!globalThis.process.versions?.node;
-  const coiOk =
-    (globalThis as { crossOriginIsolated?: boolean }).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);
-}
-
 type WorkerResponse =
   | LoadedMessage
   | ReadyMessage
@@ -136,12 +113,29 @@ class WorkerHandle {
     });
   }
 
-  processPage(index: number): Promise<PageResultMessage> {
+  processDiff(
+    index: number,
+    a: Uint8Array<ArrayBuffer> | null,
+    b: Uint8Array<ArrayBuffer> | null,
+    mask: Uint8Array<ArrayBuffer> | null,
+  ): Promise<PageResultMessage> {
     return new Promise<PageResultMessage>((resolve, reject) => {
       this.pendingResolve = resolve as (data: WorkerResponse) => void;
       this.pendingReject = reject;
-      const msg: PageMessage = { type: "page", index };
-      this.worker.postMessage(msg);
+      const aBuf = a !== null ? sliceBackingBuffer(a) : null;
+      const bBuf = b !== null ? sliceBackingBuffer(b) : null;
+      const maskBuf = mask !== null ? sliceBackingBuffer(mask) : null;
+      const msg: PageMessage = {
+        type: "page",
+        index,
+        a: aBuf,
+        b: bBuf,
+        mask: maskBuf,
+      };
+      const transfer = [aBuf, bBuf, maskBuf].filter(
+        (buf): buf is ArrayBuffer => buf !== null,
+      );
+      this.worker.postMessage(msg, transfer);
     });
   }
 
@@ -155,6 +149,15 @@ function workerUrl(): URL {
   return new URL(`${file}?v=${encodeURIComponent(VERSION)}`, import.meta.url);
 }
 
+function unpackCoords(buf: ArrayBuffer): [number, number][] {
+  const arr = new Int32Array(buf);
+  const out: [number, number][] = new Array(arr.length >>> 1);
+  for (let i = 0, j = 0; j < out.length; i += 2, j++) {
+    out[j] = [arr[i]!, arr[i + 1]!];
+  }
+  return out;
+}
+
 function pageResultToResult(msg: PageResultMessage): Result {
   const sP = perf.span("main.pageResultToResult_ms");
   const r = {
@@ -173,9 +176,9 @@ function pageResultToResult(msg: PageResultMessage): Result {
       height: msg.diff.height,
       data: new Uint8Array(msg.diff.data),
     }) as JimpInstance,
-    addition: msg.addition,
-    deletion: msg.deletion,
-    modification: msg.modification,
+    addition: unpackCoords(msg.addition),
+    deletion: unpackCoords(msg.deletion),
+    modification: unpackCoords(msg.modification),
   };
   sP.stop();
   perf.incr("main.resultsReceived");
@@ -202,62 +205,151 @@ export async function* visualizeDifferences(
     workers: options?.workers ?? defaultOptions.workers,
   };
 
-  const probe = mupdf.PDFDocument.openDocument(a, "application/pdf");
-  const probeB = mupdf.PDFDocument.openDocument(b, "application/pdf");
-  const probeMask =
+  const [aPages, bPages, maskPages] = await Promise.all([
+    countPages(a),
+    countPages(b),
     typeof merged.mask !== "undefined"
-      ? mupdf.PDFDocument.openDocument(merged.mask, "application/pdf")
-      : new mupdf.PDFDocument();
-  const maxPages = Math.max(
-    probe.countPages(),
-    probeB.countPages(),
-    probeMask.countPages(),
-  );
-  probe.destroy();
-  probeB.destroy();
-  probeMask.destroy();
+      ? countPages(merged.mask)
+      : Promise.resolve(0),
+  ]);
+  const maxPages = Math.max(aPages, bPages, maskPages);
 
   if (maxPages === 0) return;
 
-  const aBytes = asSharedBytes(a);
-  const bBytes = asSharedBytes(b);
-  const maskBytes =
-    typeof merged.mask !== "undefined" ? asSharedBytes(merged.mask) : null;
+  const mask = merged.mask;
+  const hasMask = typeof mask !== "undefined" && maskPages > 0;
+  const numDocs = hasMask ? 3 : 2;
 
   const initMsg: InitMessage = {
     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<number, Result>();
-  let nextToAssign = 0;
-
-  const workers: WorkerHandle[] = [worker0];
-  for (let i = 1; i < N; i++) {
+  const workers: WorkerHandle[] = [];
+  for (let i = 0; i < N; i++) {
     const w = new WorkerHandle(url);
     await w.init(initMsg);
     workers.push(w);
   }
 
+  let aborted: unknown = null;
+
+  // One PNG slot per page per document, fulfilled as render chunks complete.
+  // Pages past a document's page count resolve to null (an empty/transparent
+  // page). The defensive catch keeps a chunk failure from surfacing as an
+  // unhandled rejection before a diff lane awaits the slot.
+  type Slot = {
+    p: Promise<Uint8Array<ArrayBuffer> | null>;
+    resolve: (v: Uint8Array<ArrayBuffer> | null) => void;
+    reject: (e: unknown) => void;
+  };
+  const makeSlots = (count: number): Slot[] =>
+    Array.from({ length: maxPages }, (_, i) => {
+      if (i >= count) {
+        return {
+          p: Promise.resolve(null),
+          resolve: () => {},
+          reject: () => {},
+        };
+      }
+      let resolve!: (v: Uint8Array<ArrayBuffer> | null) => void;
+      let reject!: (e: unknown) => void;
+      const p = new Promise<Uint8Array<ArrayBuffer> | null>((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      p.catch(() => {});
+      return { p, resolve, reject };
+    });
+  const slots = {
+    a: makeSlots(aPages),
+    b: makeSlots(bPages),
+    mask: makeSlots(hasMask ? maskPages : 0),
+  };
+
+  // Render chunk tasks: batch several pages per gs() call to amortize startup,
+  // interleaving A/B/mask by page range so the early pages of every document
+  // become available together (which keeps the diff stage fed).
+  // Render concurrency. Aim for ~2x as many chunks as render slots so pages
+  // arrive in waves and the diff/decode stage overlaps later renders instead of
+  // waiting for one big batch. A floor keeps each chunk large enough to amortize
+  // Ghostscript's per-call startup: when there are many slots relative to pages,
+  // the slots are already saturated, so batching beats finer streaming.
+  const MIN_CHUNK = 4;
+  const R = Math.max(merged.workers, numDocs);
+  const totalRenderPages = aPages + bPages + (hasMask ? maskPages : 0);
+  const chunkSize = Math.max(
+    1,
+    Math.min(
+      maxPages,
+      Math.max(MIN_CHUNK, Math.ceil(totalRenderPages / (2 * R))),
+    ),
+  );
+  type Task = { bytes: Uint8Array; start: number; end: number; slots: Slot[] };
+  const tasks: Task[] = [];
+  const pushChunk = (
+    bytes: Uint8Array | undefined,
+    count: number,
+    target: Slot[],
+    start: number,
+  ) => {
+    if (bytes === undefined || start >= count) return;
+    tasks.push({
+      bytes,
+      start,
+      end: Math.min(start + chunkSize, count) - 1,
+      slots: target,
+    });
+  };
+  for (let start = 0; start < maxPages; start += chunkSize) {
+    pushChunk(a, aPages, slots.a, start);
+    pushChunk(b, bPages, slots.b, start);
+    if (hasMask) pushChunk(mask, maskPages, slots.mask, start);
+  }
+
+  let taskIdx = 0;
+  const renderLoops = Array.from(
+    { length: Math.min(R, tasks.length) },
+    async () => {
+      while (taskIdx < tasks.length && aborted === null) {
+        const t = tasks[taskIdx++]!;
+        try {
+          const pngs = await renderPageRangePng(
+            t.bytes,
+            t.start,
+            t.end,
+            merged.dpi,
+            merged.alpha,
+          );
+          for (let i = t.start; i <= t.end; i++) {
+            t.slots[i]!.resolve(pngs.get(i) ?? null);
+          }
+        } catch (e) {
+          aborted = e;
+          for (let i = t.start; i <= t.end; i++) t.slots[i]!.reject(e);
+        }
+      }
+    },
+  );
+
+  const buffered = new Map<number, Result>();
+  let nextToAssign = 0;
   const resolvers = new Map<number, (r: Result) => void>();
   let workerError: unknown = null;
 
-  const loops = workers.map(async (w) => {
+  const diffLoops = workers.map(async (w) => {
     while (nextToAssign < maxPages && workerError === null) {
       const idx = nextToAssign++;
       try {
-        const msg = await w.processPage(idx);
+        const [aPng, bPng, maskPng] = await Promise.all([
+          slots.a[idx]!.p,
+          slots.b[idx]!.p,
+          slots.mask[idx]!.p,
+        ]);
+        const msg = await w.processDiff(idx, aPng, bPng, maskPng);
         const result = pageResultToResult(msg);
         const resolve = resolvers.get(idx);
         if (resolve) {
@@ -269,6 +361,7 @@ export async function* visualizeDifferences(
         }
       } catch (e) {
         workerError = e;
+        aborted = e;
         for (const [, resolve] of resolvers) resolve(null as never);
         resolvers.clear();
         return;
@@ -294,8 +387,11 @@ export async function* visualizeDifferences(
       yield r;
       sYield.stop();
     }
-    await Promise.all(loops);
+    await Promise.all(diffLoops);
+    await Promise.all(renderLoops);
   } finally {
+    aborted = aborted ?? new Error("aborted");
+    await Promise.allSettled(renderLoops);
     for (const w of workers) w.terminate();
   }
 }

package/src/iterable.test.ts

@@ -1,20 +1,3 @@
-/*
- * 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/>.
- */
-
 import assert from "assert";
 import test from "node:test";
 

package/src/iterable.ts

@@ -1,20 +1,3 @@
-/*
- * 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/>.
- */
-
 export async function* withIndex<T>(iter: AsyncIterable<T>, start = 0) {
   let index = start;
   for await (const item of iter) {

package/src/jimp.ts

@@ -1,15 +1,33 @@
 import * as jimp from "jimp";
 
+/**
+ * Narrowed view of `jimp.JimpInstance` used throughout the project.
+ *
+ * Two constraints are tightened relative to the upstream type:
+ *
+ * 1. `bitmap.data` is asserted to be `Uint8Array<ArrayBuffer>` (never
+ *    SAB-backed). jimp allocates pixels via `Buffer`, which is always
+ *    backed by a real ArrayBuffer in practice. Pinning the generic
+ *    parameter here lets `sliceBackingBuffer` (and `postMessage` transfer
+ *    lists) infer ArrayBuffer instead of ArrayBufferLike.
+ *
+ * 2. `resize` and `composite` return `JimpInstance` (this narrowed type)
+ *    rather than upstream `jimp.JimpInstance`, so chaining preserves the
+ *    bitmap-backing constraint above.
+ */
 export type JimpInstance = Pick<
   jimp.JimpInstance,
-  | "width"
-  | "height"
-  | "bitmap"
-  | "getPixelColor"
-  | "setPixelColor"
-  | "resize"
-  | "composite"
+  "width" | "height" | "getPixelColor" | "setPixelColor"
 > & {
+  bitmap: {
+    data: Uint8Array<ArrayBuffer>;
+    width: number;
+    height: number;
+  };
+  resize: (options: Parameters<jimp.JimpInstance["resize"]>[0]) => JimpInstance;
+  composite: (
+    ...args: Parameters<jimp.JimpInstance["composite"]>
+  ) => JimpInstance;
   getBuffer: (mime: "image/png") => ReturnType<jimp.JimpInstance["getBuffer"]>;
   getBase64: (mime: "image/png") => ReturnType<jimp.JimpInstance["getBase64"]>;
 };

package/src/pdf.ts

@@ -1,82 +1,113 @@
+import { gs } from "@u1f992/gs-wasm";
+
+import { perf } from "./perf.ts";
+
 /*
- * 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.
+ * Pages are rendered with Ghostscript (gs-wasm). Each gs() invocation spins up
+ * its own worker and Ghostscript instance, so we render one page per call and
+ * let the caller drive concurrency (e.g. by rendering A/B/mask together and by
+ * running multiple page workers).
  *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ * Ghostscript (via the `web-worker` package) must be invoked from a context
+ * that can itself spawn a worker. In Node's `web-worker` this is only the main
+ * thread, so rendering happens on the main thread and the resulting PNG bytes
+ * are handed off to the diff workers for decoding. The PDF is placed in
+ * Ghostscript's in-memory FS as `input.pdf` and the page is read back as a PNG.
  */
+const INPUT_VM_PATH = "input.pdf";
 
-import * as jimp from "jimp";
-import * as mupdf from "mupdf";
-
-import type { JimpInstance } from "./jimp.ts";
-import { perf } from "./perf.ts";
-
-export function* loadPages(pdf: mupdf.Document) {
-  for (let i = 0; i < pdf.countPages(); i++) {
-    yield pdf.loadPage(i);
+/**
+ * Count the pages of a PDF using Ghostscript's `pdfpagecount`. Runs with
+ * `-dNODISPLAY` (no rendering) so it is cheap relative to a page render.
+ */
+export async function countPages(pdf: Uint8Array): Promise<number> {
+  const span = perf.span("pdf.countPages_ms");
+  const out: number[] = [];
+  const { exitCode } = await gs({
+    args: [
+      "-q",
+      "-dNODISPLAY",
+      "-dNOSAFER",
+      "-c",
+      `(${INPUT_VM_PATH}) (r) file runpdfbegin pdfpagecount = quit`,
+    ],
+    inputFiles: { [INPUT_VM_PATH]: pdf },
+    onStdout: (charCode) => {
+      if (charCode !== null) out.push(charCode);
+    },
+  });
+  span.stop();
+  if (exitCode !== 0) {
+    throw new Error(`gs countPages failed (exit ${exitCode})`);
+  }
+  const text = String.fromCharCode(...out).trim();
+  const n = Number.parseInt(text, 10);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new Error(`gs countPages: unexpected output ${JSON.stringify(text)}`);
   }
+  return n;
 }
 
-function pixmapToRGBA(pixmap: mupdf.Pixmap): Uint8Array {
-  const width = pixmap.getWidth();
-  const height = pixmap.getHeight();
-  const stride = pixmap.getStride();
-  const hasAlpha = pixmap.getAlpha() !== 0;
-  const samples = pixmap.getPixels();
+/**
+ * Render an inclusive range of (0-based) pages of a PDF to PNG bytes in a single
+ * Ghostscript invocation, returning a map keyed by 0-based page index. Batching
+ * several pages per call amortizes Ghostscript's startup and PDF parsing, which
+ * dominate a single-page render. `alpha` selects the device: `pngalpha` keeps
+ * the page background transparent (so the diff can tell "no content" from
+ * "content" via the alpha channel), while `png16m` renders opaque. Decoding to
+ * RGBA is left to the caller (the diff workers) so it can run off this thread.
+ */
+export async function renderPageRangePng(
+  pdf: Uint8Array,
+  firstIndex: number,
+  lastIndex: number,
+  dpi: number,
+  alpha: boolean,
+): Promise<Map<number, Uint8Array<ArrayBuffer>>> {
+  const device = alpha ? "pngalpha" : "png16m";
+  const first = firstIndex + 1; // Ghostscript page numbers are 1-based.
+  const last = lastIndex + 1;
 
-  if (hasAlpha && stride === width * 4) {
-    return new Uint8Array(samples);
-  }
+  // `%d` in the output pattern is the 1-based index of the page *within this
+  // run* (it restarts at 1 regardless of -dFirstPage), so the k-th output maps
+  // back to absolute page (first + k - 1).
+  const pageCount = last - first + 1;
+  const names: string[] = [];
+  for (let k = 1; k <= pageCount; k++) names.push(`out-${k}.png`);
 
-  const out = new Uint8Array(width * height * 4);
-  const srcBpp = pixmap.getNumberOfComponents() + (hasAlpha ? 1 : 0);
-  for (let y = 0; y < height; y++) {
-    const srcRow = y * stride;
-    const dstRow = y * width * 4;
-    for (let x = 0; x < width; x++) {
-      const s = srcRow + x * srcBpp;
-      const d = dstRow + x * 4;
-      out[d] = samples[s]!;
-      out[d + 1] = samples[s + 1]!;
-      out[d + 2] = samples[s + 2]!;
-      out[d + 3] = hasAlpha ? samples[s + 3]! : 255;
+  const sRender = perf.span("pdf.gsRender_ms");
+  const { exitCode, outputFiles } = await gs({
+    args: [
+      "-dNOPAUSE",
+      "-dBATCH",
+      "-dQUIET",
+      `-dFirstPage=${first}`,
+      `-dLastPage=${last}`,
+      `-sDEVICE=${device}`,
+      `-r${dpi}`,
+      "-dTextAlphaBits=4",
+      "-dGraphicsAlphaBits=4",
+      "-sOutputFile=out-%d.png",
+      INPUT_VM_PATH,
+    ],
+    inputFiles: { [INPUT_VM_PATH]: pdf },
+    outputFilePaths: names,
+  });
+  sRender.stop();
+  if (exitCode !== 0) {
+    throw new Error(
+      `gs render failed (pages ${first}-${last}, exit ${exitCode})`,
+    );
+  }
+  const result = new Map<number, Uint8Array<ArrayBuffer>>();
+  for (let k = 1; k <= pageCount; k++) {
+    const png = outputFiles[`out-${k}.png`];
+    if (!png) {
+      throw new Error(`gs render produced no output (page ${first + k - 1})`);
     }
+    result.set(firstIndex + (k - 1), png);
   }
-  return out;
-}
-
-export async function pageToImage(
-  page: mupdf.Page,
-  dpi: number,
-  alpha: boolean,
-) {
-  const zoom = dpi / 72;
-  const sToPixmap = perf.span("pdf.toPixmap_ms");
-  const pixmap = page.toPixmap(
-    [zoom, 0, 0, zoom, 0, 0],
-    mupdf.ColorSpace.DeviceRGB,
-    alpha,
-  );
-  const width = pixmap.getWidth();
-  const height = pixmap.getHeight();
-  sToPixmap.stop();
-  const sRgba = perf.span("pdf.pixmapToRGBA_ms");
-  const data = pixmapToRGBA(pixmap);
-  pixmap.destroy();
-  page.destroy();
-  sRgba.stop();
-  const sFromBitmap = perf.span("pdf.fromBitmap_ms");
-  const result = jimp.Jimp.fromBitmap({ width, height, data }) as JimpInstance;
-  sFromBitmap.stop();
+  perf.incr("pdf.gsCalls");
+  perf.incr("pdf.pagesRendered", pageCount);
   return result;
 }

package/src/perf.ts

@@ -1,20 +1,3 @@
-/*
- * 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/>.
- */
-
 const _enabled = (() => {
   try {
     if (

package/src/rgba-color.test.ts

@@ -1,20 +1,3 @@
-/*
- * 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/>.
- */
-
 import assert from "assert";
 import test from "node:test";
 

package/src/rgba-color.ts

@@ -1,20 +1,3 @@
-/*
- * 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/>.
- */
-
 export type RGBAColor = [number, number, number, number];
 
 export const parseHex = (hex: string) => {