@nkzw/palette-swap 3.1.0 → 4.0.0

package/.gitignore

@@ -0,0 +1,2 @@
+lib
+node_modules

package/.npmignore

@@ -0,0 +1,6 @@
+example
+lib/tsconfig.tsbuildinfo
+pnpm-lock.yaml
+src
+tsconfig.json
+tsdown.config.ts

package/README.md

@@ -9,7 +9,15 @@ Image palette swapping and color replacement tool based on canvas for Node.js an
 ## Installation
 
 ```
-npm install @nkzw/palette-swap canvas
+npm install @nkzw/palette-swap
+```
+
+The package selects the browser or Node.js entry point automatically. Browser bundles use native `HTMLCanvasElement` and `ImageData` and do not include the Node backend. Node.js uses `@napi-rs/canvas`, whose platform binaries are installed as optional dependencies; keep optional dependencies enabled.
+
+For Node.js applications that also load images or create canvases, add the backend as a direct dependency:
+
+```sh
+npm install @napi-rs/canvas
 ```
 
 ## Usage
@@ -19,9 +27,9 @@ npm install @nkzw/palette-swap canvas
 Here is an example of how to use `paletteSwap()` to create two variants from a base image:
 
 ```js
-import { loadImage } from 'canvas';
+import { loadImage } from '@napi-rs/canvas';
 import { writeFileSync } from 'node:fs';
-import paletteSwap from 'paletteSwap';
+import paletteSwap from '@nkzw/palette-swap';
 
 const results = paletteSwap(
   await loadImage('./Yoshi.png'),
@@ -36,23 +44,37 @@ const results = paletteSwap(
     ],
     [3, 220],
   ]),
-  new Set([
-    '#000000',
-    '#903020',
-    '#f84020',
-    '#f89000',
-    '#ff0000',
-    '#f8c0a8',
-    '#f8e0d0',
-    '#f8f8f8',
-  ]),
+  new Set(['#000000', '#903020', '#f84020', '#f89000', '#ff0000', '#f8c0a8', '#f8e0d0', '#f8f8f8']),
 );
 
 for (const [variant, canvas] of results) {
-  writeFileSync(`./Yoshi-${variant}.png`, canvas.toBuffer());
+  writeFileSync(`./Yoshi-${variant}.png`, canvas.toBuffer('image/png'));
+}
+```
+
+### Browser
+
+Use the same import and palette definitions with a loaded browser image:
+
+```js
+import paletteSwap from '@nkzw/palette-swap';
+
+const image = new Image();
+image.src = './Yoshi.png';
+await image.decode();
+
+const variants = new Map([[2, new Map([['#006000', '#570061']])]]);
+for (const canvas of paletteSwap(image, variants).values()) {
+  document.body.append(canvas);
 }
 ```
 
+Modern bundlers select the `browser` export automatically. The browser fallback also supports bundlers using the `browser` field. Each entry point has matching TypeScript declarations. With TypeScript's `bundler` module resolution, set `customConditions: ["browser"]` to select the browser declarations explicitly.
+
+### Migrating from node-canvas
+
+Browser callers keep the same API. Node.js callers should create and load images using `@napi-rs/canvas` instead of `canvas`, and use `canvas.toBuffer('image/png')` to encode results. Returned Node canvases are `@napi-rs/canvas` objects; native objects from the old `canvas` package are not interchangeable.
+
 ## Parameters
 
 ### `image: Image`
@@ -105,3 +127,13 @@ const results = paletteSwap(
 ### `options?: { imageName?: string; ignoreMissing?: boolean; }`
 
 By default `paletteSwap` will throw an error for any missing color mapping. Options can be specified to ignore missing color mappings or to provide an image name used for the error message when a color mapping is missing.
+
+## Development
+
+```sh
+pnpm install
+pnpm exec playwright install chromium
+pnpm test
+```
+
+Tests build the published entry points, verify JavaScript and TypeScript export resolution, reject native dependencies in browser bundles, and compare browser and Node pixels, including transparent edges. The existing example pixel hashes remain regression checks.

package/lib/browser.d.ts

@@ -0,0 +1,9 @@
+import { n as HSL, r as VariantName, t as HEX } from "./palette-swap-BQyCssvL.js";
+//#region src/browser.d.ts
+export type Image = HTMLImageElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas;
+declare const _default: (image: Image, inputVariants: ReadonlyMap<VariantName, ReadonlyMap<HEX, HEX> | number>, staticColors?: Set<HEX> | null, images?: ReadonlyMap<VariantName, Image> | null | undefined, options?: {
+  imageName?: string;
+  ignoreMissing?: boolean;
+} | undefined) => ReadonlyMap<VariantName, HTMLCanvasElement>;
+//#endregion
+export { type HEX, type HSL, type VariantName, _default as default };

package/lib/browser.js

@@ -0,0 +1,24 @@
+import { t as createPaletteSwap } from "./palette-swap-D-ZznABu.js";
+//#region src/browser.ts
+var browser_default = createPaletteSwap({
+	readImage(image, width = image.width, height = image.height) {
+		const canvas = document.createElement("canvas");
+		canvas.width = image.width;
+		canvas.height = image.height;
+		const context = canvas.getContext("2d");
+		if (!context) throw new Error("paletteSwap: Could not create a canvas context.");
+		context.drawImage(image, 0, 0);
+		return context.getImageData(0, 0, width, height);
+	},
+	writeImage({ data, height, width }) {
+		const canvas = document.createElement("canvas");
+		canvas.width = width;
+		canvas.height = height;
+		const context = canvas.getContext("2d");
+		if (!context) throw new Error("paletteSwap: Could not create a canvas context.");
+		context.putImageData(new ImageData(data, width, height), 0, 0);
+		return canvas;
+	}
+});
+//#endregion
+export { browser_default as default };

package/lib/node.d.ts

@@ -0,0 +1,10 @@
+import { n as HSL, r as VariantName, t as HEX } from "./palette-swap-BQyCssvL.js";
+import { Canvas, Image as Image$1 } from "@napi-rs/canvas";
+//#region src/node.d.ts
+export type Image = Image$1 | Canvas;
+declare const _default: (image: Image, inputVariants: ReadonlyMap<VariantName, ReadonlyMap<HEX, HEX> | number>, staticColors?: Set<HEX> | null, images?: ReadonlyMap<VariantName, Image> | null | undefined, options?: {
+  imageName?: string;
+  ignoreMissing?: boolean;
+} | undefined) => ReadonlyMap<VariantName, Canvas>;
+//#endregion
+export { type HEX, type HSL, type VariantName, _default as default };

package/lib/node.js

@@ -0,0 +1,17 @@
+import { t as createPaletteSwap } from "./palette-swap-D-ZznABu.js";
+import { ImageData, createCanvas } from "@napi-rs/canvas";
+//#region src/node.ts
+var node_default = createPaletteSwap({
+	readImage(image, width = image.width, height = image.height) {
+		const context = createCanvas(image.width, image.height).getContext("2d");
+		context.drawImage(image, 0, 0);
+		return context.getImageData(0, 0, width, height);
+	},
+	writeImage({ data, height, width }) {
+		const canvas = createCanvas(width, height);
+		canvas.getContext("2d").putImageData(new ImageData(data, width, height), 0, 0);
+		return canvas;
+	}
+});
+//#endregion
+export { node_default as default };

package/lib/palette-swap-BQyCssvL.d.ts

@@ -0,0 +1,6 @@
+//#region src/palette-swap.d.ts
+type HEX = `#${string}`;
+type HSL = [hue: number, saturation: number, lightness: number];
+type VariantName = number | string;
+//#endregion
+export { HSL as n, VariantName as r, HEX as t };

package/lib/palette-swap-D-ZznABu.js

@@ -0,0 +1,199 @@
+//#region src/palette-swap.ts
+const hexToUint32LE = (hex) => {
+	const n = Number.parseInt(hex.slice(1), 16) & 16777215;
+	const [r, g, b] = int32ToRgb(n);
+	return b << 16 | g << 8 | r;
+};
+const int32ToRgb = (color) => {
+	return [
+		color >> 16 & 255,
+		color >> 8 & 255,
+		color & 255
+	];
+};
+const hex = (value) => Math.round(value).toString(16).padStart(2, "0");
+const rgbToHex = ([r, g, b]) => `#${hex(r)}${hex(g)}${hex(b)}`;
+const int32ToHex = (color) => {
+	const [r, g, b] = int32ToRgb(color);
+	return rgbToHex([
+		b,
+		g,
+		r
+	]);
+};
+const applyHue = (color, hue) => {
+	const h = hue / 360;
+	const r = (color & 255) / 255;
+	const g = (color >> 8 & 255) / 255;
+	const b = (color >> 16 & 255) / 255;
+	const min = Math.min(r, g, b);
+	const max = Math.max(r, g, b);
+	const delta = max - min;
+	let s;
+	const l = (min + max) / 2;
+	if (max === min) s = 0;
+	else if (l <= .5) s = delta / (max + min);
+	else s = delta / (2 - max - min);
+	let t2;
+	let t3;
+	let val;
+	if (s === 0) {
+		val = l * 255;
+		return val << 16 | val << 8 | val;
+	}
+	if (l < .5) t2 = l * (1 + s);
+	else t2 = l + s - l * s;
+	const t1 = 2 * l - t2;
+	let result0 = 0;
+	let result1 = 0;
+	let result2 = 0;
+	for (let i = 0; i < 3; i++) {
+		t3 = h + 1 / 3 * -(i - 1);
+		if (t3 < 0) t3++;
+		if (t3 > 1) t3--;
+		if (6 * t3 < 1) val = t1 + (t2 - t1) * 6 * t3;
+		else if (2 * t3 < 1) val = t2;
+		else if (3 * t3 < 2) val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+		else val = t1;
+		if (i === 0) result0 = val * 255;
+		else if (i === 1) result1 = val * 255;
+		else result2 = val * 255;
+	}
+	return result2 << 16 | result1 << 8 | result0;
+};
+const equals = (a, b) => {
+	if (a.width !== b.width || a.height !== b.height) return false;
+	for (let i = 0; i < a.data.length; i++) if (a.data[i] !== b.data[i]) return false;
+	return true;
+};
+const colorCacheSlot = (keys, key, mask) => {
+	let slot = Math.imul(key, 2654435761) & mask;
+	let cachedKey = keys[slot];
+	while (cachedKey !== 0 && cachedKey !== key) {
+		slot = slot + 1 & mask;
+		cachedKey = keys[slot];
+	}
+	return slot;
+};
+const maxCachedColors = 4096;
+function createPaletteSwap({ readImage, writeImage }) {
+	return function paletteSwap(image, inputVariants, staticColors, images, options) {
+		const pixels = readImage(image);
+		const { height, width } = pixels;
+		const size = width * height;
+		const imageData = new Uint32Array(pixels.data.buffer, pixels.data.byteOffset, size);
+		const results = /* @__PURE__ */ new Map();
+		const variantNames = [];
+		const variantImageData = [];
+		const variantBuffers = [];
+		const variantHues = [];
+		let i = 0;
+		const palettes = /* @__PURE__ */ new Map();
+		for (const [variant, palette] of inputVariants) {
+			const newImageData = {
+				data: new Uint8ClampedArray(size * 4),
+				height,
+				width
+			};
+			if (typeof palette !== "number") for (const [key, value] of palette) {
+				const k = hexToUint32LE(key);
+				const v = palettes.get(k) || [];
+				v[i] = hexToUint32LE(value);
+				palettes.set(k, v);
+			}
+			variantNames.push(variant);
+			variantImageData.push(newImageData);
+			variantBuffers.push(new Uint32Array(newImageData.data.buffer));
+			variantHues.push(typeof palette === "number" ? palette : null);
+			i++;
+		}
+		const variantCount = variantNames.length;
+		const staticColorNumbers = staticColors ? new Set([...staticColors].map(hexToUint32LE)) : null;
+		const trackMissing = !options?.ignoreMissing;
+		const missing = /* @__PURE__ */ new Set();
+		const colorCacheKeys = new Uint32Array(maxCachedColors * 2);
+		const colorCacheValues = new Uint32Array(colorCacheKeys.length * variantCount);
+		const colorCacheMask = colorCacheKeys.length - 1;
+		let colorCacheSize = 0;
+		const uncachedColors = new Uint32Array(variantCount);
+		const buffer0 = variantBuffers[0];
+		const buffer1 = variantBuffers[1];
+		const buffer2 = variantBuffers[2];
+		const buffer3 = variantBuffers[3];
+		const buffer4 = variantBuffers[4];
+		const buffer5 = variantBuffers[5];
+		const buffer6 = variantBuffers[6];
+		const buffer7 = variantBuffers[7];
+		for (let index = 0; index < size; index++) {
+			const originalColor = imageData[index];
+			const a = originalColor >> 24 & 255;
+			if (a === 0) continue;
+			const key = originalColor >>> 0;
+			const slot = colorCacheSlot(colorCacheKeys, key, colorCacheMask);
+			const cachedKey = colorCacheKeys[slot];
+			const canCache = cachedKey === key || colorCacheSize < maxCachedColors;
+			const colors = canCache ? colorCacheValues : uncachedColors;
+			const colorOffset = canCache ? slot * variantCount : 0;
+			if (cachedKey !== key) {
+				if (canCache) {
+					colorCacheKeys[slot] = key;
+					colorCacheSize++;
+				}
+				const color = originalColor & 16777215;
+				const isStatic = staticColorNumbers?.has(color);
+				const paletteColors = !isStatic ? palettes.get(color) : null;
+				for (let i = 0; i < variantCount; i++) {
+					if (isStatic) {
+						colors[colorOffset + i] = originalColor;
+						continue;
+					}
+					const hue = variantHues[i];
+					if (hue) colors[colorOffset + i] = a << 24 | applyHue(color, hue);
+					else if (paletteColors?.[i]) colors[colorOffset + i] = a << 24 | paletteColors[i];
+					else if (!staticColorNumbers) colors[colorOffset + i] = originalColor;
+					else {
+						colors[colorOffset + i] = 0;
+						if (trackMissing) missing.add([variantNames[i], color]);
+					}
+				}
+			}
+			if (variantCount === 8) {
+				const color0 = colors[colorOffset];
+				const color1 = colors[colorOffset + 1];
+				const color2 = colors[colorOffset + 2];
+				const color3 = colors[colorOffset + 3];
+				const color4 = colors[colorOffset + 4];
+				const color5 = colors[colorOffset + 5];
+				const color6 = colors[colorOffset + 6];
+				const color7 = colors[colorOffset + 7];
+				if (color0) buffer0[index] = color0;
+				if (color1) buffer1[index] = color1;
+				if (color2) buffer2[index] = color2;
+				if (color3) buffer3[index] = color3;
+				if (color4) buffer4[index] = color4;
+				if (color5) buffer5[index] = color5;
+				if (color6) buffer6[index] = color6;
+				if (color7) buffer7[index] = color7;
+			} else if (variantCount === 2) {
+				const color0 = colors[colorOffset];
+				const color1 = colors[colorOffset + 1];
+				if (color0) buffer0[index] = color0;
+				if (color1) buffer1[index] = color1;
+			} else for (let i = 0; i < variantCount; i++) {
+				const color = colors[colorOffset + i];
+				if (color) variantBuffers[i][index] = color;
+			}
+		}
+		if (trackMissing && missing.size) throw new Error(`${options?.imageName ? `${options.imageName}` : "Palette Swap"}: Missing ${Array.from(new Set([...missing].map(([variant, color]) => `'${int32ToHex(color)}' in '${variant}'`))).join(", ")}.`);
+		for (let i = 0; i < variantCount; i++) {
+			const name = variantNames[i];
+			const existingImage = images?.get(name);
+			const existingImageData = existingImage ? readImage(existingImage, width, height) : null;
+			const newImageData = variantImageData[i];
+			if (!existingImageData || !equals(newImageData, existingImageData)) results.set(name, writeImage(newImageData));
+		}
+		return results;
+	};
+}
+//#endregion
+export { createPaletteSwap as t };

package/package.json

@@ -1,33 +1,51 @@
 {
   "name": "@nkzw/palette-swap",
-  "version": "3.1.0",
-  "author": "Christoph Nakazawa <christoph.pojer@gmail.com>",
+  "version": "4.0.0",
   "description": "Image palette swapping and color replacement tool based on canvas for Node.js and browsers.",
+  "keywords": [
+    "canvas",
+    "color",
+    "palette"
+  ],
+  "license": "MIT",
+  "author": "Christoph Nakazawa <christoph.pojer@gmail.com>",
   "repository": {
     "type": "git",
     "url": "https://github.com/cpojer/palette-swap.git"
   },
-  "license": "MIT",
-  "main": "lib/palette-swap.js",
   "type": "module",
-  "keywords": [
-    "color",
-    "palette",
-    "canvas"
-  ],
-  "engines": {
-    "node": ">=22.0.0"
+  "main": "lib/node.js",
+  "browser": "./lib/browser.js",
+  "types": "lib/node.d.ts",
+  "exports": {
+    ".": {
+      "browser": {
+        "types": "./lib/browser.d.ts",
+        "default": "./lib/browser.js"
+      },
+      "node": {
+        "types": "./lib/node.d.ts",
+        "default": "./lib/node.js"
+      },
+      "default": "./lib/browser.js"
+    }
   },
   "dependencies": {
-    "canvas": "^3.1.0"
+    "@napi-rs/canvas": "^1.0.9"
   },
   "devDependencies": {
-    "@types/node": "^22.15.21",
-    "esbuild": "^0.25.4",
-    "typescript": "^5.8.3"
+    "@types/node": "^25.9.7",
+    "playwright": "^1.63.0",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.1"
+  },
+  "engines": {
+    "node": ">=22.0.0"
   },
   "scripts": {
-    "build": "mkdir -p lib && rm lib/*; tsc --declaration --emitDeclarationOnly --noEmit false && esbuild --target=node22 --format=esm --platform=node --outfile=lib/palette-swap.js --external:canvas --bundle ./src/palette-swap.js",
-    "test": "tsc"
+    "benchmark": "vitest bench --run",
+    "build": "tsdown",
+    "test": "pnpm build && tsc && vitest run"
   }
 }

package/lib/palette-swap.d.ts

@@ -1,11 +0,0 @@
-import { Canvas, Image as CanvasImage } from 'canvas';
-type Hue = number;
-export type HEX = `#${string}`;
-export type HSL = [hue: number, saturation: number, lightness: number];
-export type VariantName = number | string;
-export type Image = CanvasImage | HTMLImageElement;
-export default function paletteSwap(image: Image, inputVariants: ReadonlyMap<VariantName, ReadonlyMap<HEX, HEX> | Hue>, staticColors?: Set<HEX> | null, images?: ReadonlyMap<VariantName, Image> | null, options?: {
-    imageName?: string;
-    ignoreMissing?: boolean;
-}): ReadonlyMap<VariantName, Canvas>;
-export {};

package/lib/palette-swap.js

@@ -1,182 +0,0 @@
-// src/palette-swap.ts
-import {
-  createCanvas,
-  createImageData
-} from "canvas";
-var hexToUint32LE = (hex2) => {
-  const n = Number.parseInt(hex2.slice(1), 16) & 16777215;
-  const [r, g, b] = int32ToRgb(n);
-  return b << 16 | g << 8 | r;
-};
-var int32ToRgb = (color) => {
-  const r = color >> 16 & 255;
-  const g = color >> 8 & 255;
-  const b = color & 255;
-  return [r, g, b];
-};
-var hex = (value) => Math.round(value).toString(16).padStart(2, "0");
-var rgbToHex = ([r, g, b]) => `#${hex(r)}${hex(g)}${hex(b)}`;
-var int32ToHex = (color) => {
-  const [r, g, b] = int32ToRgb(color);
-  return rgbToHex([b, g, r]);
-};
-var applyHue = (rgb, hue) => {
-  const h = hue / 360;
-  const r = rgb[2] / 255;
-  const g = rgb[1] / 255;
-  const b = rgb[0] / 255;
-  const min = Math.min(r, g, b);
-  const max = Math.max(r, g, b);
-  const delta = max - min;
-  let s;
-  const l = (min + max) / 2;
-  if (max === min) {
-    s = 0;
-  } else if (l <= 0.5) {
-    s = delta / (max + min);
-  } else {
-    s = delta / (2 - max - min);
-  }
-  let t2;
-  let t3;
-  let val;
-  if (s === 0) {
-    val = l * 255;
-    return val << 16 | val << 8 | val;
-  }
-  if (l < 0.5) {
-    t2 = l * (1 + s);
-  } else {
-    t2 = l + s - l * s;
-  }
-  const t1 = 2 * l - t2;
-  const result = [0, 0, 0];
-  for (let i = 0; i < 3; i++) {
-    t3 = h + 1 / 3 * -(i - 1);
-    if (t3 < 0) {
-      t3++;
-    }
-    if (t3 > 1) {
-      t3--;
-    }
-    if (6 * t3 < 1) {
-      val = t1 + (t2 - t1) * 6 * t3;
-    } else if (2 * t3 < 1) {
-      val = t2;
-    } else if (3 * t3 < 2) {
-      val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
-    } else {
-      val = t1;
-    }
-    result[i] = val * 255;
-  }
-  return result[2] << 16 | result[1] << 8 | result[0];
-};
-var createCanvasFromImage = (image) => {
-  const canvas = createCanvas(image.width, image.height);
-  const context = canvas.getContext("2d");
-  context.drawImage(image, 0, 0);
-  return canvas;
-};
-var equals = (a, b) => {
-  if (a.width !== b.width || a.height !== b.height) {
-    return false;
-  }
-  for (let i = 0; i < a.data.length; i++) {
-    if (a.data[i] !== b.data[i]) {
-      return false;
-    }
-  }
-  return true;
-};
-function paletteSwap(image, inputVariants, staticColors, images, options) {
-  const canvas = createCanvasFromImage(image);
-  const context = canvas.getContext("2d");
-  const { height, width } = canvas;
-  const imageData = new Uint32Array(
-    context.getImageData(0, 0, width, height).data.buffer
-  );
-  const results = /* @__PURE__ */ new Map();
-  const variants = [];
-  let i = 0;
-  const palettes = /* @__PURE__ */ new Map();
-  for (const [variant, palette] of inputVariants) {
-    const newImageData = createImageData(
-      new Uint8ClampedArray(width * height * 4),
-      width
-    );
-    if (typeof palette !== "number") {
-      for (const [key, value] of palette) {
-        const k = hexToUint32LE(key);
-        const v = palettes.get(k) || [];
-        v[i] = hexToUint32LE(value);
-        palettes.set(k, v);
-      }
-    }
-    variants.push([
-      variant,
-      newImageData,
-      new Uint32Array(newImageData.data.buffer),
-      typeof palette === "number" ? palette : null
-    ]);
-    i++;
-  }
-  const staticColorNumbers = staticColors ? new Set([...staticColors].map(hexToUint32LE)) : null;
-  const missing = /* @__PURE__ */ new Set();
-  for (var y = 0; y < height; ++y) {
-    for (var x = 0; x < width; ++x) {
-      const index = y * width + x;
-      const originalColor = imageData[index];
-      const a = originalColor >> 24 & 255;
-      if (a === 0) {
-        continue;
-      }
-      const color = originalColor & 16777215;
-      const isStatic = staticColorNumbers?.has(color);
-      const colors = !isStatic ? palettes.get(color) : null;
-      for (let i2 = 0; i2 < variants.length; i2++) {
-        const newImageData = variants[i2][2];
-        if (isStatic) {
-          newImageData[index] = originalColor;
-          continue;
-        }
-        const hue = variants[i2][3];
-        if (hue) {
-          newImageData[index] = a << 24 | applyHue(int32ToRgb(color), hue);
-        } else if (colors?.[i2]) {
-          newImageData[index] = a << 24 | colors[i2];
-        } else if (!staticColorNumbers) {
-          newImageData[index] = originalColor;
-        } else {
-          missing.add([variants[i2][0], color]);
-        }
-      }
-    }
-  }
-  if (!options?.ignoreMissing && missing.size) {
-    throw new Error(
-      `${options?.imageName ? `${options.imageName}` : "Palette Swap"}: Missing ${Array.from(
-        new Set(
-          [...missing].map(
-            ([variant, color]) => `'${int32ToHex(color)}' in '${variant}'`
-          )
-        )
-      ).join(", ")}.`
-    );
-  }
-  for (let i2 = 0; i2 < variants.length; i2++) {
-    const name = variants[i2][0];
-    const existingImage = images?.get(name);
-    const existingImageData = existingImage ? createCanvasFromImage(existingImage).getContext("2d").getImageData(0, 0, width, height) : null;
-    const newImageData = variants[i2][1];
-    if (!existingImageData || !equals(newImageData, existingImageData)) {
-      const newCanvas = createCanvasFromImage(image);
-      newCanvas.getContext("2d").putImageData(newImageData, 0, 0);
-      results.set(name, newCanvas);
-    }
-  }
-  return results;
-}
-export {
-  paletteSwap as default
-};

package/pnpm-workspace.yaml

@@ -1,4 +0,0 @@
-ignoredBuiltDependencies:
-  - esbuild
-onlyBuiltDependencies:
-  - canvas