@nkzw/palette-swap 3.2.0 → 4.0.1

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,39 @@ 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.
+
+The browser build also accepts `ImageData`. Read pixels once with `getImageData()` and reuse them across calls when generating variants in batches.
+
+### 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 +129,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,7 @@
+import { n as HSL, r as VariantName, t as HEX } from "./palette-swap-CpUFcX2w.js";
+export type Image = HTMLImageElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas;
+declare const _default: (image: ImageData | Image, inputVariants: ReadonlyMap<VariantName, ReadonlyMap<HEX, HEX> | number>, staticColors?: Set<HEX> | null, images?: ReadonlyMap<VariantName, ImageData | Image> | null | undefined, options?: {
+  imageName?: string;
+  ignoreMissing?: boolean;
+} | undefined) => ReadonlyMap<VariantName, HTMLCanvasElement>;
+export { type HEX, type HSL, type VariantName, _default as default };

package/lib/browser.js

@@ -0,0 +1,31 @@
+import { t as createPaletteSwap } from "./palette-swap-DnkKCKpC.js";
+// src/browser.ts
+var browser_default = createPaletteSwap({
+	readImage(image, width = image.width, height = image.height) {
+		const isImageData = image instanceof ImageData;
+		if (isImageData && image.width === width && image.height === height && image.colorSpace === "srgb" && image.data.BYTES_PER_ELEMENT === 1) return image;
+		const canvas = document.createElement("canvas");
+		canvas.width = image.width;
+		canvas.height = image.height;
+		try {
+			const context = canvas.getContext("2d");
+			if (!context) throw new Error("paletteSwap: Could not create a canvas context.");
+			if (isImageData) context.putImageData(image, 0, 0);
+			else context.drawImage(image, 0, 0);
+			return context.getImageData(0, 0, width, height);
+		} finally {
+			canvas.width = 0;
+			canvas.height = 0;
+		}
+	},
+	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;
+	}
+});
+export { browser_default as default };

package/lib/node.d.ts

@@ -0,0 +1,8 @@
+import { n as HSL, r as VariantName, t as HEX } from "./palette-swap-CpUFcX2w.js";
+import { Canvas, Image as Image$1 } from "@napi-rs/canvas";
+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>;
+export { type HEX, type HSL, type VariantName, _default as default };

package/lib/node.js

@@ -0,0 +1,16 @@
+import { t as createPaletteSwap } from "./palette-swap-DnkKCKpC.js";
+import { ImageData, createCanvas } from "@napi-rs/canvas";
+// 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;
+	}
+});
+export { node_default as default };

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

@@ -0,0 +1,4 @@
+type HEX = `#${string}`;
+type HSL = [hue: number, saturation: number, lightness: number];
+type VariantName = number | string;
+export { HSL as n, VariantName as r, HEX as t };

package/lib/palette-swap-DnkKCKpC.js

@@ -0,0 +1,198 @@
+// 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;
+	};
+}
+export { createPaletteSwap as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkzw/palette-swap",
-  "version": "3.2.0",
+  "version": "4.0.1",
   "description": "Image palette swapping and color replacement tool based on canvas for Node.js and browsers.",
   "keywords": [
     "canvas",
@@ -14,16 +14,38 @@
     "url": "https://github.com/cpojer/palette-swap.git"
   },
   "type": "module",
-  "main": "lib/palette-swap.js",
-  "types": "lib/palette-swap.d.ts",
+  "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.2.3"
+    "@napi-rs/canvas": "^1.1.0"
   },
   "devDependencies": {
-    "@types/node": "^25.9.1",
-    "tsdown": "^0.22.0",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.7"
+    "@types/node": "^26.6.6",
+    "playwright": "^1.65.0",
+    "tsdown": "^0.23.7",
+    "typescript": "^7.0.2",
+    "vitest": "^5.1.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "12.18.0",
+      "onFail": "download"
+    }
   },
   "engines": {
     "node": ">=22.0.0"
@@ -31,6 +53,6 @@
   "scripts": {
     "benchmark": "vitest bench --run",
     "build": "tsdown",
-    "test": "tsc && vitest run"
+    "test": "pnpm build && tsc && vitest run"
   }
 }

package/lib/palette-swap.d.ts

@@ -1,14 +0,0 @@
-import { Canvas, Image as Image$1 } from "canvas";
-
-//#region src/palette-swap.d.ts
-type Hue = number;
-type HEX = `#${string}`;
-type HSL = [hue: number, saturation: number, lightness: number];
-type VariantName = number | string;
-type Image = Image$1 | HTMLImageElement;
-declare 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>;
-//#endregion
-export { HEX, HSL, Image, VariantName, paletteSwap as default };

package/lib/palette-swap.js

@@ -1,203 +0,0 @@
-import { createCanvas, createImageData } from "canvas";
-//#region src/palette-swap.ts
-const hexToUint32LE = (hex) => {
-	const [r, g, b] = int32ToRgb(Number.parseInt(hex.slice(1), 16) & 16777215);
-	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 createCanvasFromImage = (image) => {
-	const canvas = createCanvas(image.width, image.height);
-	canvas.getContext("2d").drawImage(image, 0, 0);
-	return canvas;
-};
-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 paletteSwap(image, inputVariants, staticColors, images, options) {
-	const canvas = createCanvasFromImage(image);
-	const context = canvas.getContext("2d");
-	const { height, width } = canvas;
-	const size = width * height;
-	const imageData = new Uint32Array(context.getImageData(0, 0, width, height).data.buffer);
-	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 = createImageData(new Uint8ClampedArray(size * 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);
-		}
-		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 ? createCanvasFromImage(existingImage).getContext("2d").getImageData(0, 0, width, height) : null;
-		const newImageData = variantImageData[i];
-		if (!existingImageData || !equals(newImageData, existingImageData)) {
-			const newCanvas = createCanvas(width, height);
-			newCanvas.getContext("2d").putImageData(newImageData, 0, 0);
-			results.set(name, newCanvas);
-		}
-	}
-	return results;
-}
-//#endregion
-export { paletteSwap as default };

package/pnpm-workspace.yaml

@@ -1,4 +0,0 @@
-allowBuilds:
-  canvas: true
-onlyBuiltDependencies:
-  - canvas