pixel-data-js 0.15.1 → 0.17.0

package/dist/index.dev.cjs

@@ -20,22 +20,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  BlendMode: () => BlendMode,
-  FAST_BLENDER_REGISTRY: () => FAST_BLENDER_REGISTRY,
-  FAST_BLEND_MODES: () => FAST_BLEND_MODES,
-  FAST_BLEND_MODE_BY_NAME: () => FAST_BLEND_MODE_BY_NAME,
-  FAST_BLEND_TO_INDEX: () => FAST_BLEND_TO_INDEX,
-  INDEX_TO_FAST_BLEND: () => INDEX_TO_FAST_BLEND,
-  INDEX_TO_PERFECT_BLEND: () => INDEX_TO_PERFECT_BLEND,
+  BASE_FAST_BLEND_MODE_FUNCTIONS: () => BASE_FAST_BLEND_MODE_FUNCTIONS,
+  BASE_PERFECT_BLEND_MODE_FUNCTIONS: () => BASE_PERFECT_BLEND_MODE_FUNCTIONS,
+  BaseBlendMode: () => BaseBlendMode,
+  HistoryManager: () => HistoryManager,
   IndexedImage: () => IndexedImage,
   MaskType: () => MaskType,
-  PERFECT_BLENDER_REGISTRY: () => PERFECT_BLENDER_REGISTRY,
-  PERFECT_BLEND_MODES: () => PERFECT_BLEND_MODES,
-  PERFECT_BLEND_MODE_BY_NAME: () => PERFECT_BLEND_MODE_BY_NAME,
-  PERFECT_BLEND_TO_INDEX: () => PERFECT_BLEND_TO_INDEX,
+  PixelAccumulator: () => PixelAccumulator,
   PixelData: () => PixelData,
+  PixelEngineConfig: () => PixelEngineConfig,
+  PixelTile: () => PixelTile,
+  PixelWriter: () => PixelWriter,
   UnsupportedFormatError: () => UnsupportedFormatError,
+  applyCircleBrushToPixelData: () => applyCircleBrushToPixelData,
   applyMaskToPixelData: () => applyMaskToPixelData,
+  applyPatchTiles: () => applyPatchTiles,
+  applyRectBrushToPixelData: () => applyRectBrushToPixelData,
   base64DecodeArrayBuffer: () => base64DecodeArrayBuffer,
   base64EncodeArrayBuffer: () => base64EncodeArrayBuffer,
   blendColorPixelData: () => blendColorPixelData,
@@ -74,6 +74,7 @@ __export(src_exports, {
   floodFillSelection: () => floodFillSelection,
   getImageDataFromClipboard: () => getImageDataFromClipboard,
   getIndexedImageColorCounts: () => getIndexedImageColorCounts,
+  getRectBrushBounds: () => getRectBrushBounds,
   getSupportedPixelFormats: () => getSupportedPixelFormats,
   hardLightFast: () => hardLightFast,
   hardLightPerfect: () => hardLightPerfect,
@@ -102,14 +103,25 @@ __export(src_exports, {
   linearDodgePerfect: () => linearDodgePerfect,
   linearLightFast: () => linearLightFast,
   linearLightPerfect: () => linearLightPerfect,
+  makeBlendModeRegistry: () => makeBlendModeRegistry,
+  makeFastBlendModeRegistry: () => makeFastBlendModeRegistry,
+  makeFullPixelMutator: () => makeFullPixelMutator,
+  makePerfectBlendModeRegistry: () => makePerfectBlendModeRegistry,
   makePixelCanvas: () => makePixelCanvas,
   makeReusableCanvas: () => makeReusableCanvas,
   makeReusableImageData: () => makeReusableImageData,
   mergeMasks: () => mergeMasks,
   multiplyFast: () => multiplyFast,
   multiplyPerfect: () => multiplyPerfect,
+  mutatorApplyMask: () => mutatorApplyMask,
+  mutatorBlendColor: () => mutatorBlendColor,
+  mutatorBlendPixel: () => mutatorBlendPixel,
+  mutatorBlendPixelData: () => mutatorBlendPixelData,
+  mutatorFill: () => mutatorFill,
+  mutatorInvert: () => mutatorInvert,
   overlayFast: () => overlayFast,
   overlayPerfect: () => overlayPerfect,
+  overwriteBase: () => overwriteBase,
   overwriteFast: () => overwriteFast,
   overwritePerfect: () => overwritePerfect,
   packColor: () => packColor,
@@ -144,42 +156,80 @@ __export(src_exports, {
   vividLightFast: () => vividLightFast,
   vividLightPerfect: () => vividLightPerfect,
   writeImageData: () => writeImageData,
-  writeImageDataPixels: () => writeImageDataPixels,
+  writeImageDataBuffer: () => writeImageDataBuffer,
   writeImageDataToClipboard: () => writeImageDataToClipboard,
-  writeImgBlobToClipboard: () => writeImgBlobToClipboard
+  writeImgBlobToClipboard: () => writeImgBlobToClipboard,
+  writePixelDataBuffer: () => writePixelDataBuffer
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/BlendModes/blend-modes.ts
-var BlendMode = /* @__PURE__ */ ((BlendMode2) => {
-  BlendMode2[BlendMode2["overwrite"] = 0] = "overwrite";
-  BlendMode2[BlendMode2["sourceOver"] = 1] = "sourceOver";
-  BlendMode2[BlendMode2["darken"] = 2] = "darken";
-  BlendMode2[BlendMode2["multiply"] = 3] = "multiply";
-  BlendMode2[BlendMode2["colorBurn"] = 4] = "colorBurn";
-  BlendMode2[BlendMode2["linearBurn"] = 5] = "linearBurn";
-  BlendMode2[BlendMode2["darkerColor"] = 6] = "darkerColor";
-  BlendMode2[BlendMode2["lighten"] = 7] = "lighten";
-  BlendMode2[BlendMode2["screen"] = 8] = "screen";
-  BlendMode2[BlendMode2["colorDodge"] = 9] = "colorDodge";
-  BlendMode2[BlendMode2["linearDodge"] = 10] = "linearDodge";
-  BlendMode2[BlendMode2["lighterColor"] = 11] = "lighterColor";
-  BlendMode2[BlendMode2["overlay"] = 12] = "overlay";
-  BlendMode2[BlendMode2["softLight"] = 13] = "softLight";
-  BlendMode2[BlendMode2["hardLight"] = 14] = "hardLight";
-  BlendMode2[BlendMode2["vividLight"] = 15] = "vividLight";
-  BlendMode2[BlendMode2["linearLight"] = 16] = "linearLight";
-  BlendMode2[BlendMode2["pinLight"] = 17] = "pinLight";
-  BlendMode2[BlendMode2["hardMix"] = 18] = "hardMix";
-  BlendMode2[BlendMode2["difference"] = 19] = "difference";
-  BlendMode2[BlendMode2["exclusion"] = 20] = "exclusion";
-  BlendMode2[BlendMode2["subtract"] = 21] = "subtract";
-  BlendMode2[BlendMode2["divide"] = 22] = "divide";
-  return BlendMode2;
-})(BlendMode || {});
+var BaseBlendMode = {
+  overwrite: 0,
+  sourceOver: 1,
+  darken: 2,
+  multiply: 3,
+  colorBurn: 4,
+  linearBurn: 5,
+  darkerColor: 6,
+  lighten: 7,
+  screen: 8,
+  colorDodge: 9,
+  linearDodge: 10,
+  lighterColor: 11,
+  overlay: 12,
+  softLight: 13,
+  hardLight: 14,
+  vividLight: 15,
+  linearLight: 16,
+  pinLight: 17,
+  hardMix: 18,
+  difference: 19,
+  exclusion: 20,
+  subtract: 21,
+  divide: 22
+};
 var overwriteBase = (src, _dst) => src;
 overwriteBase.isOverwrite = true;
 
+// src/BlendModes/BlendModeRegistry.ts
+function makeBlendModeRegistry(blendModes, initialEntries) {
+  const blendToName = /* @__PURE__ */ new Map();
+  const blendToIndex = /* @__PURE__ */ new Map();
+  const indexToName = [];
+  const indexToBlend = [];
+  const nameToBlend = {};
+  const nameToIndex = {};
+  const add = (name, index, blendFn) => {
+    if (!Number.isFinite(index)) {
+      throw new Error(`Index "${index}" is not a number. Attempting to add name: "${name}", index: "${index}"`);
+    }
+    if (indexToBlend[index]) {
+      throw new Error(`Blend Mode index: ${index} is already used. Attempting to add name: "${name}", index: "${index}"`);
+    }
+    indexToName[index] = name;
+    indexToBlend[index] = blendFn;
+    blendToIndex.set(blendFn, index);
+    blendToName.set(blendFn, name);
+    nameToBlend[name] = blendFn;
+    nameToIndex[name] = index;
+  };
+  for (const [name, index] of Object.entries(blendModes)) {
+    const blend = initialEntries[index];
+    add(name, index, blend);
+  }
+  return {
+    nameToBlend,
+    nameToIndex,
+    blendToIndex,
+    blendToName,
+    indexToBlend,
+    indexToName,
+    indexType: null,
+    nameType: null
+  };
+}
+
 // src/BlendModes/blend-modes-fast.ts
 var overwriteFast = overwriteBase;
 var sourceOverFast = (src, dst) => {
@@ -565,76 +615,34 @@ var divideFast = (src, dst) => {
   const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var FAST_BLENDER_REGISTRY = [
-  [0 /* overwrite */, overwriteFast],
-  [1 /* sourceOver */, sourceOverFast],
-  [2 /* darken */, darkenFast],
-  [3 /* multiply */, multiplyFast],
-  [4 /* colorBurn */, colorBurnFast],
-  [5 /* linearBurn */, linearBurnFast],
-  [6 /* darkerColor */, darkerFast],
-  [7 /* lighten */, lightenFast],
-  [8 /* screen */, screenFast],
-  [9 /* colorDodge */, colorDodgeFast],
-  [10 /* linearDodge */, linearDodgeFast],
-  [11 /* lighterColor */, lighterFast],
-  [12 /* overlay */, overlayFast],
-  [13 /* softLight */, softLightFast],
-  [14 /* hardLight */, hardLightFast],
-  [15 /* vividLight */, vividLightFast],
-  [16 /* linearLight */, linearLightFast],
-  [17 /* pinLight */, pinLightFast],
-  [18 /* hardMix */, hardMixFast],
-  [19 /* difference */, differenceFast],
-  [20 /* exclusion */, exclusionFast],
-  [21 /* subtract */, subtractFast],
-  [22 /* divide */, divideFast]
-];
-var FAST_BLEND_MODES = [];
-for (const [index, blend] of FAST_BLENDER_REGISTRY) {
-  FAST_BLEND_MODES[index] = blend;
-}
-var FAST_BLEND_TO_INDEX = new Map(
-  FAST_BLENDER_REGISTRY.map((entry, index) => {
-    return [
-      entry[1],
-      index
-    ];
-  })
-);
-var INDEX_TO_FAST_BLEND = new Map(
-  FAST_BLENDER_REGISTRY.map((entry, index) => {
-    return [
-      index,
-      entry[1]
-    ];
-  })
-);
-var FAST_BLEND_MODE_BY_NAME = {
-  overwrite: overwriteFast,
-  sourceOver: sourceOverFast,
-  darken: darkenFast,
-  multiply: multiplyFast,
-  colorBurn: colorBurnFast,
-  linearBurn: linearBurnFast,
-  darkerColor: darkerFast,
-  lighten: lightenFast,
-  screen: screenFast,
-  colorDodge: colorDodgeFast,
-  linearDodge: linearDodgeFast,
-  lighterColor: lighterFast,
-  overlay: overlayFast,
-  softLight: softLightFast,
-  hardLight: hardLightFast,
-  vividLight: vividLightFast,
-  linearLight: linearLightFast,
-  pinLight: pinLightFast,
-  hardMix: hardMixFast,
-  difference: differenceFast,
-  exclusion: exclusionFast,
-  subtract: subtractFast,
-  divide: divideFast
+var BASE_FAST_BLEND_MODE_FUNCTIONS = {
+  [BaseBlendMode.overwrite]: overwriteFast,
+  [BaseBlendMode.sourceOver]: sourceOverFast,
+  [BaseBlendMode.darken]: darkenFast,
+  [BaseBlendMode.multiply]: multiplyFast,
+  [BaseBlendMode.colorBurn]: colorBurnFast,
+  [BaseBlendMode.linearBurn]: linearBurnFast,
+  [BaseBlendMode.darkerColor]: darkerFast,
+  [BaseBlendMode.lighten]: lightenFast,
+  [BaseBlendMode.screen]: screenFast,
+  [BaseBlendMode.colorDodge]: colorDodgeFast,
+  [BaseBlendMode.linearDodge]: linearDodgeFast,
+  [BaseBlendMode.lighterColor]: lighterFast,
+  [BaseBlendMode.overlay]: overlayFast,
+  [BaseBlendMode.softLight]: softLightFast,
+  [BaseBlendMode.hardLight]: hardLightFast,
+  [BaseBlendMode.vividLight]: vividLightFast,
+  [BaseBlendMode.linearLight]: linearLightFast,
+  [BaseBlendMode.pinLight]: pinLightFast,
+  [BaseBlendMode.hardMix]: hardMixFast,
+  [BaseBlendMode.difference]: differenceFast,
+  [BaseBlendMode.exclusion]: exclusionFast,
+  [BaseBlendMode.subtract]: subtractFast,
+  [BaseBlendMode.divide]: divideFast
 };
+function makeFastBlendModeRegistry() {
+  return makeBlendModeRegistry(BaseBlendMode, BASE_FAST_BLEND_MODE_FUNCTIONS);
+}
 
 // src/_types.ts
 var MaskType = /* @__PURE__ */ ((MaskType2) => {
@@ -1001,14 +1009,18 @@ var sourceOverPerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 255) return src;
   if (sa === 0) return dst;
+  const invA = 255 - sa;
   const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
   const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
   const da = dst >>> 24 & 255;
-  const invA = 255 - sa;
-  const r = (sr * sa + dr * invA) / 255 | 0;
-  const g = (sg * sa + dg * invA) / 255 | 0;
-  const b = (sb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + da * invA) / 255 | 0;
+  const tR = sr * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = sg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = sb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var darkenPerfect = (src, dst) => {
@@ -1021,44 +1033,71 @@ var darkenPerfect = (src, dst) => {
   const bb = sb < db ? sb : db;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var multiplyPerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const br = sr * dr / 255 | 0;
-  const bg = sg * dg / 255 | 0;
-  const bb = sb * db / 255 | 0;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const da = dst >>> 24 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const mR = sr * dr;
+  const br = mR + 1 + (mR >> 8) >> 8;
+  const mG = sg * dg;
+  const bg = mG + 1 + (mG >> 8) >> 8;
+  const mB = sb * db;
+  const bb = mB + 1 + (mB >> 8) >> 8;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const da = dst >>> 24 & 255;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + da * invA) / 255 | 0;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var colorBurnPerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const br = dr === 255 ? 255 : sr === 0 ? 0 : Math.max(0, 255 - ((255 - dr) * 255 / sr | 0));
-  const bg = dg === 255 ? 255 : sg === 0 ? 0 : Math.max(0, 255 - ((255 - dg) * 255 / sg | 0));
-  const bb = db === 255 ? 255 : sb === 0 ? 0 : Math.max(0, 255 - ((255 - db) * 255 / sb | 0));
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const resR = dr === 255 ? 255 : sr === 0 ? 0 : 255 - ((255 - dr) * 255 / sr | 0);
+  const br = resR < 0 ? 0 : resR;
+  const resG = dg === 255 ? 255 : sg === 0 ? 0 : 255 - ((255 - dg) * 255 / sg | 0);
+  const bg = resG < 0 ? 0 : resG;
+  const resB = db === 255 ? 255 : sb === 0 ? 0 : 255 - ((255 - db) * 255 / sb | 0);
+  const bb = resB < 0 ? 0 : resB;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
   const da = dst >>> 24 & 255;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + da * invA) / 255 | 0;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var linearBurnPerfect = (src, dst) => {
@@ -1074,10 +1113,15 @@ var linearBurnPerfect = (src, dst) => {
   const bb = bbU < 0 ? 0 : bbU;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var darkerPerfect = (src, dst) => {
@@ -1099,10 +1143,15 @@ var darkerPerfect = (src, dst) => {
   }
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var lightenPerfect = (src, dst) => {
@@ -1114,10 +1163,15 @@ var lightenPerfect = (src, dst) => {
   const bb = (src >>> 16 & 255) > db ? src >>> 16 & 255 : db;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var screenPerfect = (src, dst) => {
@@ -1129,26 +1183,43 @@ var screenPerfect = (src, dst) => {
   const bb = 255 - ((255 - (src >>> 16 & 255)) * (255 - db) / 255 | 0);
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var colorDodgePerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = sr === 255 ? 255 : Math.min(255, dr * 255 / (255 - sr) | 0);
-  const bg = sg === 255 ? 255 : Math.min(255, dg * 255 / (255 - sg) | 0);
-  const bb = sb === 255 ? 255 : Math.min(255, db * 255 / (255 - sb) | 0);
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const resR = sr === 255 ? 255 : dr * 255 / (255 - sr) | 0;
+  const br = resR > 255 ? 255 : resR;
+  const resG = sg === 255 ? 255 : dg * 255 / (255 - sg) | 0;
+  const bg = resG > 255 ? 255 : resG;
+  const resB = sb === 255 ? 255 : db * 255 / (255 - sb) | 0;
+  const bb = resB > 255 ? 255 : resB;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var linearDodgePerfect = (src, dst) => {
@@ -1163,10 +1234,15 @@ var linearDodgePerfect = (src, dst) => {
   const bb = bbU > 255 ? 255 : bbU;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var lighterPerfect = (src, dst) => {
@@ -1188,10 +1264,15 @@ var lighterPerfect = (src, dst) => {
   }
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var overlayPerfect = (src, dst) => {
@@ -1204,10 +1285,15 @@ var overlayPerfect = (src, dst) => {
   const bb = db < 128 ? 2 * sb * db / 255 | 0 : 255 - (2 * (255 - sb) * (255 - db) / 255 | 0);
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var softLightPerfect = (src, dst) => {
@@ -1215,15 +1301,26 @@ var softLightPerfect = (src, dst) => {
   if (sa === 0) return dst;
   const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
   const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = ((255 - dr) * (sr * dr / 255 | 0) + dr * (255 - ((255 - sr) * (255 - dr) / 255 | 0))) / 255 | 0;
-  const bg = ((255 - dg) * (sg * dg / 255 | 0) + dg * (255 - ((255 - sg) * (255 - dg) / 255 | 0))) / 255 | 0;
-  const bb = ((255 - db) * (sb * db / 255 | 0) + db * (255 - ((255 - sb) * (255 - db) / 255 | 0))) / 255 | 0;
+  const mR = sr * dr;
+  const scR = (255 - sr) * (255 - dr);
+  const br = (255 - dr) * (mR + 1 + (mR >> 8) >> 8) + dr * (255 - (scR + 1 + (scR >> 8) >> 8)) + 1 + ((255 - dr) * (mR + 1 + (mR >> 8) >> 8) + dr * (255 - (scR + 1 + (scR >> 8) >> 8)) >> 8) >> 8;
+  const mG = sg * dg;
+  const scG = (255 - sg) * (255 - dg);
+  const bg = (255 - dg) * (mG + 1 + (mG >> 8) >> 8) + dg * (255 - (scG + 1 + (scG >> 8) >> 8)) + 1 + ((255 - dg) * (mG + 1 + (mG >> 8) >> 8) + dg * (255 - (scG + 1 + (scG >> 8) >> 8)) >> 8) >> 8;
+  const mB = sb * db;
+  const scB = (255 - sb) * (255 - db);
+  const bb = (255 - db) * (mB + 1 + (mB >> 8) >> 8) + db * (255 - (scB + 1 + (scB >> 8) >> 8)) + 1 + ((255 - db) * (mB + 1 + (mB >> 8) >> 8) + db * (255 - (scB + 1 + (scB >> 8) >> 8)) >> 8) >> 8;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var hardLightPerfect = (src, dst) => {
@@ -1236,10 +1333,15 @@ var hardLightPerfect = (src, dst) => {
   const bb = sb < 128 ? 2 * sb * db / 255 | 0 : 255 - (2 * (255 - sb) * (255 - db) / 255 | 0);
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var vividLightPerfect = (src, dst) => {
@@ -1252,10 +1354,15 @@ var vividLightPerfect = (src, dst) => {
   const bb = sb < 128 ? sb === 0 ? 0 : Math.max(0, 255 - ((255 - db) * 255 / (2 * sb) | 0)) : sb === 255 ? 255 : Math.min(255, db * 255 / (2 * (255 - sb)) | 0);
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var linearLightPerfect = (src, dst) => {
@@ -1271,10 +1378,15 @@ var linearLightPerfect = (src, dst) => {
   const bb = bbU < 0 ? 0 : bbU > 255 ? 255 : bbU;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var pinLightPerfect = (src, dst) => {
@@ -1292,10 +1404,14 @@ var pinLightPerfect = (src, dst) => {
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
   const da = dst >>> 24 & 255;
-  const r = (br * sa + dr * invA + 128) / 255 | 0;
-  const g = (bg * sa + dg * invA + 128) / 255 | 0;
-  const b = (bb * sa + db * invA + 128) / 255 | 0;
-  const a = (255 * sa + da * invA + 128) / 255 | 0;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var hardMixPerfect = (src, dst) => {
@@ -1308,33 +1424,36 @@ var hardMixPerfect = (src, dst) => {
   const bb = (sb < 128 ? sb === 0 ? 0 : Math.max(0, 255 - ((255 - db) * 255 / (2 * sb) | 0)) : sb === 255 ? 255 : Math.min(255, db * 255 / (2 * (255 - sb)) | 0)) < 128 ? 0 : 255;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var differencePerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
-  const dr = dst & 255;
-  const dg = dst >>> 8 & 255;
-  const db = dst >>> 16 & 255;
-  const sr = src & 255;
-  const sg = src >>> 8 & 255;
-  const sb = src >>> 16 & 255;
-  const br = Math.abs(dr - sr);
-  const bg = Math.abs(dg - sg);
-  const bb = Math.abs(db - sb);
-  if (sa === 255) {
-    return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  }
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const br = dr > sr ? dr - sr : sr - dr;
+  const bg = dg > sg ? dg - sg : sg - dg;
+  const bb = db > sb ? db - sb : sb - db;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
   const da = dst >>> 24 & 255;
-  const r = (br * sa + dr * invA + 128) / 255 | 0;
-  const g = (bg * sa + dg * invA + 128) / 255 | 0;
-  const b = (bb * sa + db * invA + 128) / 255 | 0;
-  const a = (255 * sa + da * invA + 128) / 255 | 0;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var exclusionPerfect = (src, dst) => {
@@ -1346,18 +1465,23 @@ var exclusionPerfect = (src, dst) => {
   const sr = src & 255;
   const sg = src >>> 8 & 255;
   const sb = src >>> 16 & 255;
-  const br = dr + sr - (dr * sr >> 7);
-  const bg = dg + sg - (dg * sg >> 7);
-  const bb = db + sb - (db * sb >> 7);
-  if (sa === 255) {
-    return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  }
+  const r2 = dr * sr;
+  const br = dr + sr - (r2 + r2 + 1 + (r2 + r2 >> 8) >> 8);
+  const g2 = dg * sg;
+  const bg = dg + sg - (g2 + g2 + 1 + (g2 + g2 >> 8) >> 8);
+  const b2 = db * sb;
+  const bb = db + sb - (b2 + b2 + 1 + (b2 + b2 >> 8) >> 8);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
   const da = dst >>> 24 & 255;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + da * invA) / 255 | 0;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var subtractPerfect = (src, dst) => {
@@ -1373,10 +1497,15 @@ var subtractPerfect = (src, dst) => {
   const bb = bbU < 0 ? 0 : bbU;
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
 var dividePerfect = (src, dst) => {
@@ -1389,82 +1518,45 @@ var dividePerfect = (src, dst) => {
   const bb = sb === 0 ? 255 : Math.min(255, db * 255 / sb | 0);
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
-  const r = (br * sa + dr * invA) / 255 | 0;
-  const g = (bg * sa + dg * invA) / 255 | 0;
-  const b = (bb * sa + db * invA) / 255 | 0;
-  const a = (255 * sa + (dst >>> 24 & 255) * invA) / 255 | 0;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var PERFECT_BLENDER_REGISTRY = [
-  [0 /* overwrite */, overwritePerfect],
-  [1 /* sourceOver */, sourceOverPerfect],
-  [2 /* darken */, darkenPerfect],
-  [3 /* multiply */, multiplyPerfect],
-  [4 /* colorBurn */, colorBurnPerfect],
-  [5 /* linearBurn */, linearBurnPerfect],
-  [6 /* darkerColor */, darkerPerfect],
-  [7 /* lighten */, lightenPerfect],
-  [8 /* screen */, screenPerfect],
-  [9 /* colorDodge */, colorDodgePerfect],
-  [10 /* linearDodge */, linearDodgePerfect],
-  [11 /* lighterColor */, lighterPerfect],
-  [12 /* overlay */, overlayPerfect],
-  [13 /* softLight */, softLightPerfect],
-  [14 /* hardLight */, hardLightPerfect],
-  [15 /* vividLight */, vividLightPerfect],
-  [16 /* linearLight */, linearLightPerfect],
-  [17 /* pinLight */, pinLightPerfect],
-  [18 /* hardMix */, hardMixPerfect],
-  [19 /* difference */, differencePerfect],
-  [20 /* exclusion */, exclusionPerfect],
-  [21 /* subtract */, subtractPerfect],
-  [22 /* divide */, dividePerfect]
-];
-var PERFECT_BLEND_MODES = [];
-for (const [index, blend] of PERFECT_BLENDER_REGISTRY) {
-  PERFECT_BLEND_MODES[index] = blend;
-}
-var PERFECT_BLEND_TO_INDEX = new Map(
-  PERFECT_BLENDER_REGISTRY.map((entry, index) => {
-    return [
-      entry[1],
-      index
-    ];
-  })
-);
-var INDEX_TO_PERFECT_BLEND = new Map(
-  PERFECT_BLENDER_REGISTRY.map((entry, index) => {
-    return [
-      index,
-      entry[1]
-    ];
-  })
-);
-var PERFECT_BLEND_MODE_BY_NAME = {
-  overwrite: overwritePerfect,
-  sourceOver: sourceOverPerfect,
-  darken: darkenPerfect,
-  multiply: multiplyPerfect,
-  colorBurn: colorBurnPerfect,
-  linearBurn: linearBurnPerfect,
-  darkerColor: darkerPerfect,
-  lighten: lightenPerfect,
-  screen: screenPerfect,
-  colorDodge: colorDodgePerfect,
-  linearDodge: linearDodgePerfect,
-  lighterColor: lighterPerfect,
-  overlay: overlayPerfect,
-  softLight: softLightPerfect,
-  hardLight: hardLightPerfect,
-  vividLight: vividLightPerfect,
-  linearLight: linearLightPerfect,
-  pinLight: pinLightPerfect,
-  hardMix: hardMixPerfect,
-  difference: differencePerfect,
-  exclusion: exclusionPerfect,
-  subtract: subtractPerfect,
-  divide: dividePerfect
+var BASE_PERFECT_BLEND_MODE_FUNCTIONS = {
+  [BaseBlendMode.overwrite]: overwritePerfect,
+  [BaseBlendMode.sourceOver]: sourceOverPerfect,
+  [BaseBlendMode.darken]: darkenPerfect,
+  [BaseBlendMode.multiply]: multiplyPerfect,
+  [BaseBlendMode.colorBurn]: colorBurnPerfect,
+  [BaseBlendMode.linearBurn]: linearBurnPerfect,
+  [BaseBlendMode.darkerColor]: darkerPerfect,
+  [BaseBlendMode.lighten]: lightenPerfect,
+  [BaseBlendMode.screen]: screenPerfect,
+  [BaseBlendMode.colorDodge]: colorDodgePerfect,
+  [BaseBlendMode.linearDodge]: linearDodgePerfect,
+  [BaseBlendMode.lighterColor]: lighterPerfect,
+  [BaseBlendMode.overlay]: overlayPerfect,
+  [BaseBlendMode.softLight]: softLightPerfect,
+  [BaseBlendMode.hardLight]: hardLightPerfect,
+  [BaseBlendMode.vividLight]: vividLightPerfect,
+  [BaseBlendMode.linearLight]: linearLightPerfect,
+  [BaseBlendMode.pinLight]: pinLightPerfect,
+  [BaseBlendMode.hardMix]: hardMixPerfect,
+  [BaseBlendMode.difference]: differencePerfect,
+  [BaseBlendMode.exclusion]: exclusionPerfect,
+  [BaseBlendMode.subtract]: subtractPerfect,
+  [BaseBlendMode.divide]: dividePerfect
 };
+function makePerfectBlendModeRegistry() {
+  return makeBlendModeRegistry(BaseBlendMode, BASE_PERFECT_BLEND_MODE_FUNCTIONS);
+}
 
 // src/Canvas/_constants.ts
 var OFFSCREEN_CANVAS_CTX_FAILED = "Failed to create OffscreenCanvas context";
@@ -1579,763 +1671,776 @@ async function writeImageDataToClipboard(imageData) {
   return writeImgBlobToClipboard(blob);
 }
 
-// src/ImageData/ReusableImageData.ts
-function makeReusableImageData() {
-  let imageData = null;
-  let buffer = null;
-  return function getReusableImageData(width, height) {
-    const hasInstance = !!imageData;
-    const widthMatches = hasInstance && imageData.width === width;
-    const heightMatches = hasInstance && imageData.height === height;
-    if (!widthMatches || !heightMatches) {
-      const buffer2 = new Uint8ClampedArray(width * height * 4);
-      imageData = new ImageData(buffer2, width, height);
+// src/History/PixelPatchTiles.ts
+var PixelTile = class {
+  constructor(id, tx, ty, tileArea) {
+    this.id = id;
+    this.tx = tx;
+    this.ty = ty;
+    this.data32 = new Uint32Array(tileArea);
+  }
+  data32;
+};
+function applyPatchTiles(target, tiles, tileSize = 256) {
+  for (let i = 0; i < tiles.length; i++) {
+    const tile = tiles[i];
+    if (!tile) continue;
+    const dst = target.data32;
+    const src = tile.data32;
+    const dstWidth = target.width;
+    const dstHeight = target.height;
+    const startX = tile.tx * tileSize;
+    const startY = tile.ty * tileSize;
+    const copyWidth = Math.max(0, Math.min(tileSize, dstWidth - startX));
+    if (copyWidth <= 0) return;
+    for (let ly = 0; ly < tileSize; ly++) {
+      const globalY = startY + ly;
+      if (globalY >= dstHeight) break;
+      const dstIndex = globalY * dstWidth + startX;
+      const srcIndex = ly * tileSize;
+      const rowData = src.subarray(srcIndex, srcIndex + copyWidth);
+      dst.set(rowData, dstIndex);
     }
-    return imageData;
-  };
-}
-
-// src/ImageData/copyImageData.ts
-function copyImageData({ data, width, height }) {
-  return new ImageData(data.slice(), width, height);
-}
-function copyImageDataLike({ data, width, height }) {
-  return {
-    data: data.slice(),
-    width,
-    height
-  };
-}
-
-// src/PixelData/pixelDataToAlphaMask.ts
-function pixelDataToAlphaMask(pixelData) {
-  const {
-    data32,
-    width,
-    height
-  } = pixelData;
-  const len = data32.length;
-  const mask = new Uint8Array(width * height);
-  for (let i = 0; i < len; i++) {
-    const val = data32[i];
-    mask[i] = val >>> 24 & 255;
   }
-  return mask;
 }
 
-// src/ImageData/imageDataToAlphaMask.ts
-function imageDataToAlphaMask(imageData) {
-  const {
-    width,
-    height,
-    data
-  } = imageData;
-  const data32 = new Uint32Array(
-    data.buffer,
-    data.byteOffset,
-    data.byteLength >> 2
-  );
-  const len = data32.length;
-  const mask = new Uint8Array(width * height);
-  for (let i = 0; i < len; i++) {
-    const val = data32[i];
-    mask[i] = val >>> 24 & 255;
+// src/History/PixelAccumulator.ts
+var PixelAccumulator = class {
+  constructor(target, config) {
+    this.target = target;
+    this.config = config;
+    this.lookup = [];
+    this.beforeTiles = [];
+    this.pool = [];
+  }
+  lookup;
+  beforeTiles;
+  pool;
+  getTile(id, tx, ty) {
+    let tile = this.pool.pop();
+    if (tile) {
+      tile.id = id;
+      tile.tx = tx;
+      tile.ty = ty;
+      return tile;
+    }
+    return new PixelTile(
+      id,
+      tx,
+      ty,
+      this.config.tileArea
+    );
   }
-  return mask;
-}
-
-// src/ImageData/imageDataToDataUrl.ts
-var get = makeReusableCanvas();
-function imageDataToDataUrl(imageData) {
-  const { canvas, ctx } = get(imageData.width, imageData.height);
-  ctx.putImageData(imageData, 0, 0);
-  return canvas.toDataURL();
-}
-imageDataToDataUrl.reset = get.reset;
-
-// src/ImageData/imageDataToUInt32Array.ts
-function imageDataToUInt32Array(imageData) {
-  return new Uint32Array(
-    imageData.data.buffer,
-    imageData.data.byteOffset,
-    // Shift right by 2 is a fast bitwise division by 4.
-    imageData.data.byteLength >> 2
-  );
-}
-
-// src/ImageData/invertImageData.ts
-function invertImageData(imageData) {
-  const data = imageData.data;
-  let length = data.length;
-  for (let i = 0; i < length; i += 4) {
-    data[i] = 255 - data[i];
-    data[i + 1] = 255 - data[i + 1];
-    data[i + 2] = 255 - data[i + 2];
+  recyclePatch(patch) {
+    const before = patch.beforeTiles;
+    for (let i = 0; i < before.length; i++) {
+      let tile = before[i];
+      if (tile) {
+        this.pool.push(tile);
+      }
+    }
+    const after = patch.afterTiles;
+    for (let i = 0; i < after.length; i++) {
+      let tile = after[i];
+      if (tile) {
+        this.pool.push(tile);
+      }
+    }
+  }
+  /**
+   * @param x pixel x coordinate
+   * @param y pixel y coordinate
+   */
+  storeTileBeforeState(x, y) {
+    let target = this.target;
+    let shift = this.config.tileShift;
+    let columns = target.width + this.config.tileMask >> shift;
+    let tx = x >> shift;
+    let ty = y >> shift;
+    let id = ty * columns + tx;
+    let tile = this.lookup[id];
+    if (!tile) {
+      tile = this.getTile(
+        id,
+        tx,
+        ty
+      );
+      this.extractState(tile);
+      this.lookup[id] = tile;
+      this.beforeTiles.push(tile);
+    }
+  }
+  /**
+   *
+   * @param x pixel x coordinate
+   * @param y pixel y coordinate
+   * @param w pixel width
+   * @param h pixel height
+   */
+  storeRegionBeforeState(x, y, w, h) {
+    let target = this.target;
+    let shift = this.config.tileShift;
+    let columns = target.width + this.config.tileMask >> shift;
+    let startX = x >> shift;
+    let startY = y >> shift;
+    let endX = x + w - 1 >> shift;
+    let endY = y + h - 1 >> shift;
+    for (let ty = startY; ty <= endY; ty++) {
+      for (let tx = startX; tx <= endX; tx++) {
+        let id = ty * columns + tx;
+        let tile = this.lookup[id];
+        if (!tile) {
+          tile = this.getTile(
+            id,
+            tx,
+            ty
+          );
+          this.extractState(tile);
+          this.lookup[id] = tile;
+          this.beforeTiles.push(tile);
+        }
+      }
+    }
+  }
+  extractState(tile) {
+    let target = this.target;
+    let TILE_SIZE = this.config.tileSize;
+    let dst = tile.data32;
+    let src = target.data32;
+    let startX = tile.tx * TILE_SIZE;
+    let startY = tile.ty * TILE_SIZE;
+    let targetWidth = target.width;
+    let targetHeight = target.height;
+    let copyWidth = Math.max(0, Math.min(TILE_SIZE, targetWidth - startX));
+    for (let ly = 0; ly < TILE_SIZE; ly++) {
+      let globalY = startY + ly;
+      let dstIndex = ly * TILE_SIZE;
+      if (globalY < 0 || globalY >= targetHeight || copyWidth === 0) {
+        dst.fill(0, dstIndex, dstIndex + TILE_SIZE);
+        continue;
+      }
+      let srcIndex = globalY * targetWidth + startX;
+      let rowData = src.subarray(srcIndex, srcIndex + copyWidth);
+      dst.set(rowData, dstIndex);
+      if (copyWidth < TILE_SIZE) {
+        dst.fill(0, dstIndex + copyWidth, dstIndex + TILE_SIZE);
+      }
+    }
+  }
+  extractAfterTiles() {
+    let afterTiles = [];
+    let length = this.beforeTiles.length;
+    for (let i = 0; i < length; i++) {
+      let beforeTile = this.beforeTiles[i];
+      if (beforeTile) {
+        let afterTile = this.getTile(
+          beforeTile.id,
+          beforeTile.tx,
+          beforeTile.ty
+        );
+        this.extractState(afterTile);
+        afterTiles.push(afterTile);
+      }
+    }
+    return afterTiles;
+  }
+  reset() {
+    this.lookup = [];
+    this.beforeTiles = [];
   }
-  return imageData;
-}
-
-// src/Internal/resample32.ts
-var resample32Scratch = {
-  data: null,
-  width: 0,
-  height: 0
 };
-function resample32(srcData32, srcW, srcH, factor) {
-  const dstW = Math.max(1, srcW * factor | 0);
-  const dstH = Math.max(1, srcH * factor | 0);
-  const dstData = new Int32Array(dstW * dstH);
-  const scaleX = srcW / dstW;
-  const scaleY = srcH / dstH;
-  for (let y = 0; y < dstH; y++) {
-    const srcY = Math.min(srcH - 1, y * scaleY | 0);
-    const srcRowOffset = srcY * srcW;
-    const dstRowOffset = y * dstW;
-    for (let x = 0; x < dstW; x++) {
-      const srcX = Math.min(srcW - 1, x * scaleX | 0);
-      dstData[dstRowOffset + x] = srcData32[srcRowOffset + srcX];
+
+// src/History/HistoryManager.ts
+var HistoryManager = class {
+  constructor(maxSteps = 50) {
+    this.maxSteps = maxSteps;
+    this.undoStack = [];
+    this.redoStack = [];
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  undoStack;
+  redoStack;
+  listeners;
+  get canUndo() {
+    return this.undoStack.length > 0;
+  }
+  get canRedo() {
+    return this.redoStack.length > 0;
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  notify() {
+    this.listeners.forEach((fn) => fn());
+  }
+  commit(action) {
+    this.undoStack.push(action);
+    this.clearRedoStack();
+    if (this.undoStack.length > this.maxSteps) {
+      this.undoStack.shift()?.dispose?.();
+    }
+    this.notify();
+  }
+  undo() {
+    let action = this.undoStack.pop();
+    if (!action) return;
+    this.redoStack.push(action);
+    action.undo();
+    this.notify();
+  }
+  redo() {
+    let action = this.redoStack.pop();
+    if (!action) return;
+    this.undoStack.push(action);
+    action.redo();
+    this.notify();
+  }
+  clearRedoStack() {
+    let length = this.redoStack.length;
+    for (let i = 0; i < length; i++) {
+      let action = this.redoStack[i];
+      if (action) {
+        action.dispose?.();
+      }
     }
+    this.redoStack.length = 0;
   }
-  resample32Scratch.data = dstData;
-  resample32Scratch.width = dstW;
-  resample32Scratch.height = dstH;
-  return resample32Scratch;
-}
+};
 
-// src/ImageData/resampleImageData.ts
-function resampleImageData(source, factor) {
-  const src32 = new Uint32Array(source.data.buffer);
-  const { data, width, height } = resample32(src32, source.width, source.height, factor);
-  const uint8ClampedArray = new Uint8ClampedArray(data.buffer);
-  return new ImageData(uint8ClampedArray, width, height);
-}
+// src/History/PixelEngineConfig.ts
+var PixelEngineConfig = class {
+  tileSize;
+  tileShift;
+  tileMask;
+  tileArea;
+  constructor(tileSize = 256) {
+    if ((tileSize & tileSize - 1) !== 0) {
+      throw new Error("tileSize must be a power of 2");
+    }
+    this.tileSize = tileSize;
+    this.tileShift = Math.log2(tileSize);
+    this.tileMask = tileSize - 1;
+    this.tileArea = tileSize * tileSize;
+  }
+};
 
-// src/ImageData/resizeImageData.ts
-function resizeImageData(current, newWidth, newHeight, offsetX = 0, offsetY = 0) {
-  const result = new ImageData(newWidth, newHeight);
+// src/PixelData/applyMaskToPixelData.ts
+function applyMaskToPixelData(dst, mask, opts = {}) {
   const {
-    width: oldW,
-    height: oldH,
-    data: oldData
-  } = current;
-  const newData = result.data;
-  const x0 = Math.max(0, offsetX);
-  const y0 = Math.max(0, offsetY);
-  const x1 = Math.min(newWidth, offsetX + oldW);
-  const y1 = Math.min(newHeight, offsetY + oldH);
-  if (x1 <= x0 || y1 <= y0) {
-    return result;
-  }
-  const rowCount = y1 - y0;
-  const rowLen = (x1 - x0) * 4;
-  for (let row = 0; row < rowCount; row++) {
-    const dstY = y0 + row;
-    const srcY = dstY - offsetY;
-    const srcX = x0 - offsetX;
-    const dstStart = (dstY * newWidth + x0) * 4;
-    const srcStart = (srcY * oldW + srcX) * 4;
-    newData.set(
-      oldData.subarray(srcStart, srcStart + rowLen),
-      dstStart
-    );
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
   }
-  return result;
-}
-
-// src/ImageData/serialization.ts
-function base64EncodeArrayBuffer(buffer) {
-  const uint8 = new Uint8Array(buffer);
-  const decoder = new TextDecoder("latin1");
-  const binary = decoder.decode(uint8);
-  return btoa(binary);
-}
-function base64DecodeArrayBuffer(encoded) {
-  const binary = atob(encoded);
-  const bytes = new Uint8ClampedArray(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
+  if (y < 0) {
+    h += y;
+    y = 0;
   }
-  return bytes;
-}
-function serializeImageData(imageData) {
-  return {
-    width: imageData.width,
-    height: imageData.height,
-    data: base64EncodeArrayBuffer(imageData.data.buffer)
-  };
-}
-function serializeNullableImageData(imageData) {
-  if (!imageData) return null;
-  return serializeImageData(imageData);
-}
-function deserializeRawImageData(serialized) {
-  return {
-    width: serialized.width,
-    height: serialized.height,
-    data: base64DecodeArrayBuffer(serialized.data)
-  };
-}
-function deserializeImageData(serialized) {
-  const data = base64DecodeArrayBuffer(serialized.data);
-  return new ImageData(data, serialized.width, serialized.height);
-}
-function deserializeNullableImageData(serialized) {
-  if (!serialized) return null;
-  return deserializeImageData(serialized);
-}
-
-// src/ImageData/writeImageData.ts
-function writeImageData(target, source, x, y, sx = 0, sy = 0, sw = source.width, sh = source.height, mask = null, maskType = 1 /* BINARY */) {
-  const dstW = target.width;
-  const dstH = target.height;
-  const dstData = target.data;
-  const srcW = source.width;
-  const srcData = source.data;
-  const x0 = Math.max(0, x);
-  const y0 = Math.max(0, y);
-  const x1 = Math.min(dstW, x + sw);
-  const y1 = Math.min(dstH, y + sh);
-  if (x1 <= x0 || y1 <= y0) {
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0 || globalAlpha === 0) {
     return;
   }
-  const useMask = !!mask;
-  const rowCount = y1 - y0;
-  const rowLenPixels = x1 - x0;
-  for (let row = 0; row < rowCount; row++) {
-    const dstY = y0 + row;
-    const srcY = sy + (dstY - y);
-    const srcXBase = sx + (x0 - x);
-    const dstStart = (dstY * dstW + x0) * 4;
-    const srcStart = (srcY * srcW + srcXBase) * 4;
-    if (useMask && mask) {
-      for (let ix = 0; ix < rowLenPixels; ix++) {
-        const mi = srcY * srcW + (srcXBase + ix);
-        const alpha = mask[mi];
-        if (alpha === 0) {
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const mPitch = mw ?? width;
+  const isAlpha = maskType === 0 /* ALPHA */;
+  const dx = x - targetX;
+  const dy = y - targetY;
+  let dIdx = y * dw + x;
+  let mIdx = (my + dy) * mPitch + (mx + dx);
+  const dStride = dw - actualW;
+  const mStride = mPitch - actualW;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      const mVal = mask[mIdx];
+      let weight = globalAlpha;
+      if (isAlpha) {
+        const effectiveM = invertMask ? 255 - mVal : mVal;
+        if (effectiveM === 0) {
+          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+          dIdx++;
+          mIdx++;
           continue;
         }
-        const di = dstStart + ix * 4;
-        const si = srcStart + ix * 4;
-        if (maskType === 1 /* BINARY */ || alpha === 255) {
-          dstData[di] = srcData[si];
-          dstData[di + 1] = srcData[si + 1];
-          dstData[di + 2] = srcData[si + 2];
-          dstData[di + 3] = srcData[si + 3];
+        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
+      } else {
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (!isHit) {
+          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        weight = globalAlpha;
+      }
+      if (weight === 0) {
+        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+      } else {
+        const d = dst32[dIdx];
+        const da = d >>> 24;
+        let finalAlpha = da;
+        if (da === 0) {
+        } else if (weight === 255) {
+        } else if (da === 255) {
+          finalAlpha = weight;
         } else {
-          const a = alpha / 255;
-          const invA = 1 - a;
-          dstData[di] = srcData[si] * a + dstData[di] * invA;
-          dstData[di + 1] = srcData[si + 1] * a + dstData[di + 1] * invA;
-          dstData[di + 2] = srcData[si + 2] * a + dstData[di + 2] * invA;
-          dstData[di + 3] = srcData[si + 3] * a + dstData[di + 3] * invA;
+          finalAlpha = da * weight + 128 >> 8;
         }
+        dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
       }
-    } else {
-      const byteLen = rowLenPixels * 4;
-      const sub = srcData.subarray(srcStart, srcStart + byteLen);
-      dstData.set(sub, dstStart);
+      dIdx++;
+      mIdx++;
     }
+    dIdx += dStride;
+    mIdx += mStride;
   }
 }
 
-// src/ImageData/writeImageDataPixels.ts
-function writeImageDataPixels(imageData, data, _x, _y, _w, _h) {
-  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
-  const { width: dstW, height: dstH, data: dst } = imageData;
-  const x0 = Math.max(0, x);
-  const y0 = Math.max(0, y);
-  const x1 = Math.min(dstW, x + w);
-  const y1 = Math.min(dstH, y + h);
-  if (x1 <= x0 || y1 <= y0) return;
-  const rowLen = (x1 - x0) * 4;
-  const srcCol = x0 - x;
-  const srcYOffset = y0 - y;
-  const actualH = y1 - y0;
-  for (let row = 0; row < actualH; row++) {
-    const dstStart = ((y0 + row) * dstW + x0) * 4;
-    const srcRow = srcYOffset + row;
-    const o = (srcRow * w + srcCol) * 4;
-    dst.set(data.subarray(o, o + rowLen), dstStart);
+// src/History/PixelWriter.ts
+var PixelWriter = class {
+  target;
+  historyManager;
+  accumulator;
+  config;
+  mutator;
+  constructor(target, mutatorFactory, {
+    tileSize = 256,
+    maxHistorySteps = 50,
+    historyManager = new HistoryManager(maxHistorySteps)
+  } = {}) {
+    this.target = target;
+    this.config = new PixelEngineConfig(tileSize);
+    this.historyManager = historyManager;
+    this.accumulator = new PixelAccumulator(target, this.config);
+    this.mutator = mutatorFactory(this);
+  }
+  withHistory(cb) {
+    cb(this.mutator);
+    const beforeTiles = this.accumulator.beforeTiles;
+    if (beforeTiles.length === 0) return;
+    const afterTiles = this.accumulator.extractAfterTiles();
+    const patch = {
+      beforeTiles,
+      afterTiles
+    };
+    const target = this.target;
+    const tileSize = this.config.tileSize;
+    const accumulator = this.accumulator;
+    const action = {
+      undo: () => applyPatchTiles(target, patch.beforeTiles, tileSize),
+      redo: () => applyPatchTiles(target, patch.afterTiles, tileSize),
+      dispose: () => accumulator.recyclePatch(patch)
+    };
+    this.historyManager.commit(action);
+    this.accumulator.reset();
   }
+};
+
+// src/History/PixelMutator/mutatorApplyMask.ts
+function mutatorApplyMask(writer) {
+  return {
+    applyMask: (mask, opts = {}) => {
+      let target = writer.target;
+      const {
+        x = 0,
+        y = 0,
+        w = writer.target.width,
+        h = writer.target.height
+      } = opts;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      applyMaskToPixelData(target, mask, opts);
+    }
+  };
 }
 
-// src/IndexedImage/IndexedImage.ts
-var IndexedImage = class _IndexedImage {
-  /** The width of the image in pixels. */
-  width;
-  /** The height of the image in pixels. */
-  height;
-  /** Flat array of palette indices. Index = x + (y * width). */
-  data;
-  /** The palette of unique 32-bit colors (ABGR/RGBA packed) found in the image. */
-  palette;
-  /** The specific index in the palette reserved for fully transparent pixels. */
-  transparentPalletIndex;
-  /**
-   * @param width - Image width.
-   * @param height - Image height.
-   * @param data - The indexed pixel data.
-   * @param palette - The array of packed colors.
-   * @param transparentPalletIndex - The index representing alpha 0.
-   */
-  constructor(width, height, data, palette, transparentPalletIndex) {
-    this.width = width;
-    this.height = height;
-    this.data = data;
-    this.palette = palette;
-    this.transparentPalletIndex = transparentPalletIndex;
+// src/PixelData/blendColorPixelData.ts
+function blendColorPixelData(dst, color, opts = {}) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
+    blendFn = sourceOverFast,
+    mask,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (globalAlpha === 0) return;
+  const baseSrcAlpha = color >>> 24;
+  const isOverwrite = blendFn.isOverwrite;
+  if (baseSrcAlpha === 0 && !isOverwrite) return;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
   }
-  /**
-   * Creates an IndexedImage from standard browser ImageData.
-   * @param imageData - The source ImageData to convert.
-   * @returns A new IndexedImage instance.
-   */
-  static fromImageData(imageData) {
-    return _IndexedImage.fromRaw(imageData.data, imageData.width, imageData.height);
+  if (y < 0) {
+    h += y;
+    y = 0;
   }
-  /**
-   * Creates an IndexedImage from a raw byte buffer and dimensions.
-   * Any pixel with an alpha channel of 0 is normalized to the transparent palette index.
-   * @param data - Raw RGBA byte data.
-   * @param width - Image width.
-   * @param height - Image height.
-   * @returns A new IndexedImage instance.
-   */
-  static fromRaw(data, width, height) {
-    const buffer = data.buffer;
-    const rawData = new Uint32Array(buffer);
-    const indexedData = new Int32Array(rawData.length);
-    const colorMap = /* @__PURE__ */ new Map();
-    const transparentColor = 0;
-    const transparentPalletIndex = 0;
-    colorMap.set(transparentColor, transparentPalletIndex);
-    for (let i = 0; i < rawData.length; i++) {
-      const pixel = rawData[i];
-      const alpha = pixel >>> 24 & 255;
-      const isTransparent = alpha === 0;
-      const colorKey = isTransparent ? transparentColor : pixel >>> 0;
-      let id = colorMap.get(colorKey);
-      if (id === void 0) {
-        id = colorMap.size;
-        colorMap.set(colorKey, id);
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) return;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const mPitch = mw ?? width;
+  const isAlphaMask = maskType === 0 /* ALPHA */;
+  const dx = x - targetX;
+  const dy = y - targetY;
+  let dIdx = y * dw + x;
+  let mIdx = (my + dy) * mPitch + (mx + dx);
+  const dStride = dw - actualW;
+  const mStride = mPitch - actualW;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      let weight = globalAlpha;
+      if (mask) {
+        const mVal = mask[mIdx];
+        if (isAlphaMask) {
+          const effectiveM = invertMask ? 255 - mVal : mVal;
+          if (effectiveM === 0) {
+            dIdx++;
+            mIdx++;
+            continue;
+          }
+          if (globalAlpha === 255) {
+            weight = effectiveM;
+          } else if (effectiveM === 255) {
+            weight = globalAlpha;
+          } else {
+            weight = effectiveM * globalAlpha + 128 >> 8;
+          }
+        } else {
+          const isHit = invertMask ? mVal === 0 : mVal === 1;
+          if (!isHit) {
+            dIdx++;
+            mIdx++;
+            continue;
+          }
+          weight = globalAlpha;
+        }
+        if (weight === 0) {
+          dIdx++;
+          mIdx++;
+          continue;
+        }
       }
-      indexedData[i] = id;
+      let currentSrcColor = color;
+      if (weight < 255) {
+        let currentSrcAlpha = baseSrcAlpha;
+        if (baseSrcAlpha === 255) {
+          currentSrcAlpha = weight;
+        } else {
+          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
+        }
+        if (!isOverwrite && currentSrcAlpha === 0) {
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        currentSrcColor = (color & 16777215 | currentSrcAlpha << 24) >>> 0;
+      }
+      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
+      dIdx++;
+      mIdx++;
     }
-    const palette = Uint32Array.from(colorMap.keys());
-    return new _IndexedImage(
-      width,
-      height,
-      indexedData,
-      palette,
-      transparentPalletIndex
-    );
-  }
-  /**
-   * Retrieves the 32-bit packed color value at the given coordinates.
-   * @param x - X coordinate.
-   * @param y - Y coordinate.
-   * @returns The packed color from the palette.
-   */
-  getColorAt(x, y) {
-    const index = x + y * this.width;
-    const paletteIndex = this.data[index];
-    return this.palette[paletteIndex];
-  }
-};
-
-// src/IndexedImage/getIndexedImageColorCounts.ts
-function getIndexedImageColorCounts(indexedImage) {
-  const data = indexedImage.data;
-  const palette = indexedImage.palette;
-  const frequencies = new Int32Array(palette.length);
-  for (let i = 0; i < data.length; i++) {
-    const colorIndex = data[i];
-    frequencies[colorIndex]++;
+    dIdx += dStride;
+    mIdx += mStride;
   }
-  return frequencies;
 }
 
-// src/IndexedImage/indexedImageToAverageColor.ts
-function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
-  const { data, palette, transparentPalletIndex } = indexedImage;
-  const counts = new Uint32Array(palette.length);
-  for (let i = 0; i < data.length; i++) {
-    const id = data[i];
-    counts[id]++;
-  }
-  let rSum = 0;
-  let gSum = 0;
-  let bSum = 0;
-  let aSum = 0;
-  let totalWeight = 0;
-  for (let id = 0; id < counts.length; id++) {
-    const weight = counts[id];
-    if (weight === 0) {
-      continue;
-    }
-    if (!includeTransparent && id === transparentPalletIndex) {
-      continue;
+// src/History/PixelMutator/mutatorBlendColor.ts
+function mutatorBlendColor(writer) {
+  return {
+    blendColor(color, opts = {}) {
+      const {
+        x = 0,
+        y = 0,
+        w = writer.target.width,
+        h = writer.target.height
+      } = opts;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      blendColorPixelData(writer.target, color, opts);
     }
-    const color = palette[id] >>> 0;
-    const r2 = color & 255;
-    const g2 = color >> 8 & 255;
-    const b2 = color >> 16 & 255;
-    const a2 = color >> 24 & 255;
-    rSum += r2 * weight;
-    gSum += g2 * weight;
-    bSum += b2 * weight;
-    aSum += a2 * weight;
-    totalWeight += weight;
-  }
-  if (totalWeight === 0) {
-    return packColor(0, 0, 0, 0);
-  }
-  const r = rSum / totalWeight | 0;
-  const g = gSum / totalWeight | 0;
-  const b = bSum / totalWeight | 0;
-  const a = aSum / totalWeight | 0;
-  return packColor(r, g, b, a);
+  };
 }
 
-// src/IndexedImage/resampleIndexedImage.ts
-function resampleIndexedImage(source, factor) {
-  const { data, width, height } = resample32(
-    source.data,
-    source.width,
-    source.height,
-    factor
-  );
-  return new IndexedImage(
-    width,
-    height,
-    data,
-    source.palette,
-    source.transparentPalletIndex
-  );
+// src/History/PixelMutator/mutatorBlendPixel.ts
+function mutatorBlendPixel(writer) {
+  return {
+    blendPixel(x, y, color, alpha = 255, blendFn = overwriteFast) {
+      let target = writer.target;
+      let width = target.width;
+      let height = target.height;
+      if (x < 0 || x >= width || y < 0 || y >= height) return;
+      writer.accumulator.storeTileBeforeState(x, y);
+      let index = y * width + x;
+      let bg = target.data32[index];
+      let finalColor = color;
+      if (alpha < 255) {
+        let baseSrcAlpha = color >>> 24;
+        let finalAlpha = baseSrcAlpha * alpha + 128 >> 8;
+        finalColor = (color & 16777215 | finalAlpha << 24) >>> 0;
+      }
+      target.data32[index] = blendFn(finalColor, bg);
+    }
+  };
 }
 
-// src/IndexedImage/indexedImageToImageData.ts
-function indexedImageToImageData(indexedImage) {
-  const { width, height, data, palette } = indexedImage;
-  const result = new ImageData(width, height);
-  const data32 = new Uint32Array(result.data.buffer);
-  for (let i = 0; i < data.length; i++) {
-    const paletteIndex = data[i];
-    const color = palette[paletteIndex];
-    data32[i] = color;
+// src/PixelData/blendPixelData.ts
+function blendPixelData(dst, src, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    sx: sourceX = 0,
+    sy: sourceY = 0,
+    w: width = src.width,
+    h: height = src.height,
+    alpha: globalAlpha = 255,
+    blendFn = sourceOverFast,
+    mask,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (globalAlpha === 0) return;
+  let x = targetX;
+  let y = targetY;
+  let sx = sourceX;
+  let sy = sourceY;
+  let w = width;
+  let h = height;
+  if (sx < 0) {
+    x -= sx;
+    w += sx;
+    sx = 0;
   }
-  return result;
-}
-
-// src/Input/fileInputChangeToImageData.ts
-async function fileInputChangeToImageData(event) {
-  const target = event.target;
-  const file = target.files?.[0];
-  if (!file) return null;
-  return await fileToImageData(file);
-}
-
-// src/Input/fileToImageData.ts
-var UnsupportedFormatError = class extends Error {
-  constructor(mimeType) {
-    super(`File type ${mimeType} is not a supported image format.`);
-    this.name = "UnsupportedFormatError";
+  if (sy < 0) {
+    y -= sy;
+    h += sy;
+    sy = 0;
   }
-};
-async function fileToImageData(file) {
-  if (!file) return null;
-  if (!file.type.startsWith("image/")) {
-    throw new UnsupportedFormatError(file.type);
-  }
-  let bitmap = null;
-  try {
-    bitmap = await createImageBitmap(file);
-    const canvas = new OffscreenCanvas(
-      bitmap.width,
-      bitmap.height
-    );
-    const ctx = canvas.getContext("2d");
-    if (!ctx) throw new Error(OFFSCREEN_CANVAS_CTX_FAILED);
-    ctx.drawImage(
-      bitmap,
-      0,
-      0
-    );
-    return ctx.getImageData(
-      0,
-      0,
-      bitmap.width,
-      bitmap.height
-    );
-  } finally {
-    bitmap?.close();
-  }
-}
-
-// src/Input/getSupportedRasterFormats.ts
-var formatsPromise = null;
-var defaultRasterMimes = [
-  "image/png",
-  "image/jpeg",
-  "image/webp",
-  "image/avif",
-  "image/gif",
-  "image/bmp"
-];
-async function getSupportedPixelFormats(rasterMimes = defaultRasterMimes) {
-  if (formatsPromise) {
-    return formatsPromise;
-  }
-  const probeCanvas = async () => {
-    const canvas = new OffscreenCanvas(1, 1);
-    const results = await Promise.all(
-      rasterMimes.map(async (mime) => {
-        try {
-          const blob = await canvas.convertToBlob({
-            type: mime
-          });
-          return blob.type === mime ? mime : null;
-        } catch {
-          return null;
-        }
-      })
-    );
-    return results.filter((type) => {
-      return type !== null;
-    });
-  };
-  formatsPromise = probeCanvas().catch((error) => {
-    formatsPromise = null;
-    throw error;
-  });
-  return formatsPromise;
-}
-
-// src/Mask/copyMask.ts
-function copyMask(src) {
-  return src.slice();
-}
-
-// src/Mask/invertMask.ts
-function invertBinaryMask(dst) {
-  const len = dst.length;
-  for (let i = 0; i < len; i++) {
-    dst[i] = dst[i] === 0 ? 1 : 0;
-  }
-}
-function invertAlphaMask(dst) {
-  const len = dst.length;
-  for (let i = 0; i < len; i++) {
-    dst[i] = 255 - dst[i];
-  }
-}
-
-// src/Mask/mergeMasks.ts
-function mergeMasks(dst, dstWidth, src, opts) {
-  const {
-    x: targetX = 0,
-    y: targetY = 0,
-    w: width = 0,
-    h: height = 0,
-    alpha: globalAlpha = 255,
-    maskType = 0 /* ALPHA */,
-    mw,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
-  if (width <= 0 || height <= 0 || globalAlpha === 0) {
-    return;
-  }
-  const sPitch = mw ?? width;
-  const isAlpha = maskType === 0 /* ALPHA */;
-  for (let iy = 0; iy < height; iy++) {
-    const dy = targetY + iy;
-    const sy = my + iy;
-    if (dy < 0 || sy < 0) {
-      continue;
-    }
-    for (let ix = 0; ix < width; ix++) {
-      const dx = targetX + ix;
-      const sx = mx + ix;
-      if (dx < 0 || dx >= dstWidth || sx < 0 || sx >= sPitch) {
-        continue;
-      }
-      const dIdx = dy * dstWidth + dx;
-      const sIdx = sy * sPitch + sx;
-      const mVal = src[sIdx];
-      let weight = globalAlpha;
-      if (isAlpha) {
-        const effectiveM = invertMask ? 255 - mVal : mVal;
-        if (effectiveM === 0) {
-          dst[dIdx] = 0;
-          continue;
-        }
-        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
-      } else {
-        const isHit = invertMask ? mVal === 0 : mVal === 1;
-        if (!isHit) {
-          dst[dIdx] = 0;
-          continue;
-        }
-        weight = globalAlpha;
-      }
-      if (weight === 0) {
-        dst[dIdx] = 0;
-        continue;
-      }
-      const da = dst[dIdx];
-      if (da === 0) {
-      } else if (weight === 255) {
-      } else if (da === 255) {
-        dst[dIdx] = weight;
-      } else {
-        dst[dIdx] = da * weight + 128 >> 8;
-      }
-    }
-  }
-}
-
-// src/PixelData/PixelData.ts
-var PixelData = class _PixelData {
-  data32;
-  imageData;
-  get width() {
-    return this.imageData.width;
-  }
-  get height() {
-    return this.imageData.height;
-  }
-  constructor(imageData) {
-    this.data32 = imageDataToUInt32Array(imageData);
-    this.imageData = imageData;
-  }
-  set(imageData) {
-    this.imageData = imageData;
-    this.data32 = imageDataToUInt32Array(imageData);
-  }
-  /**
-   * Creates a deep copy of the PixelData using the environment's ImageData constructor.
-   */
-  copy() {
-    const buffer = new Uint8ClampedArray(this.imageData.data);
-    const ImageConstructor = typeof ImageData !== "undefined" ? ImageData : this.imageData.constructor;
-    const newImageData = new ImageConstructor(
-      buffer,
-      this.width,
-      this.height
-    );
-    return new _PixelData(newImageData);
-  }
-};
-
-// src/PixelData/applyMaskToPixelData.ts
-function applyMaskToPixelData(dst, mask, opts) {
-  const {
-    x: targetX = 0,
-    y: targetY = 0,
-    w: width = dst.width,
-    h: height = dst.height,
-    alpha: globalAlpha = 255,
-    maskType = 0 /* ALPHA */,
-    mw,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
-  let x = targetX;
-  let y = targetY;
-  let w = width;
-  let h = height;
-  if (x < 0) {
-    w += x;
-    x = 0;
+  w = Math.min(w, src.width - sx);
+  h = Math.min(h, src.height - sy);
+  if (x < 0) {
+    sx -= x;
+    w += x;
+    x = 0;
   }
   if (y < 0) {
+    sy -= y;
     h += y;
     y = 0;
   }
   const actualW = Math.min(w, dst.width - x);
   const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0 || globalAlpha === 0) {
-    return;
-  }
+  if (actualW <= 0 || actualH <= 0) return;
   const dst32 = dst.data32;
+  const src32 = src.data32;
   const dw = dst.width;
+  const sw = src.width;
   const mPitch = mw ?? width;
-  const isAlpha = maskType === 0 /* ALPHA */;
+  const isAlphaMask = maskType === 0 /* ALPHA */;
   const dx = x - targetX;
   const dy = y - targetY;
   let dIdx = y * dw + x;
+  let sIdx = sy * sw + sx;
   let mIdx = (my + dy) * mPitch + (mx + dx);
   const dStride = dw - actualW;
+  const sStride = sw - actualW;
   const mStride = mPitch - actualW;
+  const isOverwrite = blendFn.isOverwrite;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
-      const mVal = mask[mIdx];
+      const baseSrcColor = src32[sIdx];
+      const baseSrcAlpha = baseSrcColor >>> 24;
+      if (baseSrcAlpha === 0 && !isOverwrite) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
+      }
       let weight = globalAlpha;
-      if (isAlpha) {
-        const effectiveM = invertMask ? 255 - mVal : mVal;
-        if (effectiveM === 0) {
-          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+      if (mask) {
+        const mVal = mask[mIdx];
+        if (isAlphaMask) {
+          const effectiveM = invertMask ? 255 - mVal : mVal;
+          if (effectiveM === 0) {
+            dIdx++;
+            sIdx++;
+            mIdx++;
+            continue;
+          }
+          if (globalAlpha === 255) {
+            weight = effectiveM;
+          } else if (effectiveM === 255) {
+            weight = globalAlpha;
+          } else {
+            weight = effectiveM * globalAlpha + 128 >> 8;
+          }
+        } else {
+          const isHit = invertMask ? mVal === 0 : mVal === 1;
+          if (!isHit) {
+            dIdx++;
+            sIdx++;
+            mIdx++;
+            continue;
+          }
+          weight = globalAlpha;
+        }
+        if (weight === 0) {
           dIdx++;
+          sIdx++;
           mIdx++;
           continue;
         }
-        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
-      } else {
-        const isHit = invertMask ? mVal === 0 : mVal === 1;
-        if (!isHit) {
-          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+      }
+      let currentSrcColor = baseSrcColor;
+      if (weight < 255) {
+        let currentSrcAlpha = baseSrcAlpha;
+        if (baseSrcAlpha === 255) {
+          currentSrcAlpha = weight;
+        } else {
+          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
+        }
+        if (!isOverwrite && currentSrcAlpha === 0) {
           dIdx++;
+          sIdx++;
           mIdx++;
           continue;
         }
-        weight = globalAlpha;
-      }
-      if (weight === 0) {
-        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
-      } else {
-        const d = dst32[dIdx];
-        const da = d >>> 24;
-        let finalAlpha = da;
-        if (da === 0) {
-        } else if (weight === 255) {
-        } else if (da === 255) {
-          finalAlpha = weight;
-        } else {
-          finalAlpha = da * weight + 128 >> 8;
-        }
-        dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+        currentSrcColor = (baseSrcColor & 16777215 | currentSrcAlpha << 24) >>> 0;
       }
+      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
       dIdx++;
+      sIdx++;
       mIdx++;
     }
     dIdx += dStride;
+    sIdx += sStride;
     mIdx += mStride;
   }
 }
 
-// src/PixelData/blendColorPixelData.ts
-function blendColorPixelData(dst, color, opts = {}) {
+// src/History/PixelMutator/mutatorBlendPixelData.ts
+function mutatorBlendPixelData(writer) {
+  return {
+    blendPixelData(src, opts) {
+      const {
+        x = 0,
+        y = 0,
+        w = src.width,
+        h = src.height
+      } = opts;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      blendPixelData(writer.target, src, opts);
+    }
+  };
+}
+
+// src/PixelData/fillPixelData.ts
+function fillPixelData(dst, color, _x, _y, _w, _h) {
+  let x;
+  let y;
+  let w;
+  let h;
+  if (typeof _x === "object") {
+    x = _x.x ?? 0;
+    y = _x.y ?? 0;
+    w = _x.w ?? dst.width;
+    h = _x.h ?? dst.height;
+  } else if (typeof _x === "number") {
+    x = _x;
+    y = _y;
+    w = _w;
+    h = _h;
+  } else {
+    x = 0;
+    y = 0;
+    w = dst.width;
+    h = dst.height;
+  }
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) {
+    return;
+  }
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  if (actualW === dw && actualH === dst.height && x === 0 && y === 0) {
+    dst32.fill(color);
+    return;
+  }
+  for (let iy = 0; iy < actualH; iy++) {
+    const start = (y + iy) * dw + x;
+    const end = start + actualW;
+    dst32.fill(color, start, end);
+  }
+}
+
+// src/History/PixelMutator/mutatorFillPixelData.ts
+function mutatorFill(writer) {
+  return {
+    fill(color, rect = {}) {
+      const {
+        x = 0,
+        y = 0,
+        w = writer.target.width,
+        h = writer.target.height
+      } = rect;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      fillPixelData(writer.target, color, x, y, w, h);
+    }
+  };
+}
+
+// src/PixelData/invertPixelData.ts
+function invertPixelData(pixelData, opts = {}) {
+  const dst = pixelData;
   const {
     x: targetX = 0,
     y: targetY = 0,
-    w: width = dst.width,
-    h: height = dst.height,
-    alpha: globalAlpha = 255,
-    blendFn = sourceOverFast,
+    w: width = pixelData.width,
+    h: height = pixelData.height,
     mask,
-    maskType = 0 /* ALPHA */,
     mw,
     mx = 0,
     my = 0,
     invertMask = false
   } = opts;
-  if (globalAlpha === 0) return;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite;
-  if (baseSrcAlpha === 0 && !isOverwrite) return;
   let x = targetX;
   let y = targetY;
   let w = width;
@@ -2354,255 +2459,798 @@ function blendColorPixelData(dst, color, opts = {}) {
   const dst32 = dst.data32;
   const dw = dst.width;
   const mPitch = mw ?? width;
-  const isAlphaMask = maskType === 0 /* ALPHA */;
   const dx = x - targetX;
   const dy = y - targetY;
   let dIdx = y * dw + x;
   let mIdx = (my + dy) * mPitch + (mx + dx);
   const dStride = dw - actualW;
   const mStride = mPitch - actualW;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      let weight = globalAlpha;
-      if (mask) {
+  if (mask) {
+    for (let iy = 0; iy < actualH; iy++) {
+      for (let ix = 0; ix < actualW; ix++) {
         const mVal = mask[mIdx];
-        if (isAlphaMask) {
-          const effectiveM = invertMask ? 255 - mVal : mVal;
-          if (effectiveM === 0) {
-            dIdx++;
-            mIdx++;
-            continue;
-          }
-          if (globalAlpha === 255) {
-            weight = effectiveM;
-          } else if (effectiveM === 255) {
-            weight = globalAlpha;
-          } else {
-            weight = effectiveM * globalAlpha + 128 >> 8;
-          }
-        } else {
-          const isHit = invertMask ? mVal === 0 : mVal === 1;
-          if (!isHit) {
-            dIdx++;
-            mIdx++;
-            continue;
-          }
-          weight = globalAlpha;
-        }
-        if (weight === 0) {
-          dIdx++;
-          mIdx++;
-          continue;
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (isHit) {
+          dst32[dIdx] = dst32[dIdx] ^ 16777215;
         }
+        dIdx++;
+        mIdx++;
       }
-      let currentSrcColor = color;
-      if (weight < 255) {
-        let currentSrcAlpha = baseSrcAlpha;
-        if (baseSrcAlpha === 255) {
-          currentSrcAlpha = weight;
-        } else {
-          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
-        }
-        if (!isOverwrite && currentSrcAlpha === 0) {
-          dIdx++;
-          mIdx++;
-          continue;
-        }
-        currentSrcColor = (color & 16777215 | currentSrcAlpha << 24) >>> 0;
+      dIdx += dStride;
+      mIdx += mStride;
+    }
+  } else {
+    for (let iy = 0; iy < actualH; iy++) {
+      for (let ix = 0; ix < actualW; ix++) {
+        dst32[dIdx] = dst32[dIdx] ^ 16777215;
+        dIdx++;
       }
-      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
-      dIdx++;
-      mIdx++;
+      dIdx += dStride;
     }
-    dIdx += dStride;
-    mIdx += mStride;
   }
 }
 
-// src/PixelData/blendPixelData.ts
-function blendPixelData(dst, src, opts) {
+// src/History/PixelMutator/mutatorInvert.ts
+function mutatorInvert(writer) {
+  return {
+    invert(opts = {}) {
+      const {
+        x = 0,
+        y = 0,
+        w = writer.target.width,
+        h = writer.target.height
+      } = opts;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      invertPixelData(writer.target, opts);
+    }
+  };
+}
+
+// src/History/PixelMutator.ts
+function makeFullPixelMutator(writer) {
+  return {
+    ...mutatorApplyMask(writer),
+    ...mutatorBlendPixelData(writer),
+    ...mutatorBlendColor(writer),
+    ...mutatorBlendPixel(writer),
+    ...mutatorFill(writer),
+    ...mutatorInvert(writer)
+  };
+}
+
+// src/ImageData/ReusableImageData.ts
+function makeReusableImageData() {
+  let imageData = null;
+  let buffer = null;
+  return function getReusableImageData(width, height) {
+    const hasInstance = !!imageData;
+    const widthMatches = hasInstance && imageData.width === width;
+    const heightMatches = hasInstance && imageData.height === height;
+    if (!widthMatches || !heightMatches) {
+      const buffer2 = new Uint8ClampedArray(width * height * 4);
+      imageData = new ImageData(buffer2, width, height);
+    }
+    return imageData;
+  };
+}
+
+// src/ImageData/copyImageData.ts
+function copyImageData({ data, width, height }) {
+  return new ImageData(data.slice(), width, height);
+}
+function copyImageDataLike({ data, width, height }) {
+  return {
+    data: data.slice(),
+    width,
+    height
+  };
+}
+
+// src/PixelData/pixelDataToAlphaMask.ts
+function pixelDataToAlphaMask(pixelData) {
   const {
-    x: targetX = 0,
-    y: targetY = 0,
-    sx: sourceX = 0,
-    sy: sourceY = 0,
-    w: width = src.width,
-    h: height = src.height,
+    data32,
+    width,
+    height
+  } = pixelData;
+  const len = data32.length;
+  const mask = new Uint8Array(width * height);
+  for (let i = 0; i < len; i++) {
+    const val = data32[i];
+    mask[i] = val >>> 24 & 255;
+  }
+  return mask;
+}
+
+// src/ImageData/imageDataToAlphaMask.ts
+function imageDataToAlphaMask(imageData) {
+  const {
+    width,
+    height,
+    data
+  } = imageData;
+  const data32 = new Uint32Array(
+    data.buffer,
+    data.byteOffset,
+    data.byteLength >> 2
+  );
+  const len = data32.length;
+  const mask = new Uint8Array(width * height);
+  for (let i = 0; i < len; i++) {
+    const val = data32[i];
+    mask[i] = val >>> 24 & 255;
+  }
+  return mask;
+}
+
+// src/ImageData/imageDataToDataUrl.ts
+var get = makeReusableCanvas();
+function imageDataToDataUrl(imageData) {
+  const { canvas, ctx } = get(imageData.width, imageData.height);
+  ctx.putImageData(imageData, 0, 0);
+  return canvas.toDataURL();
+}
+imageDataToDataUrl.reset = get.reset;
+
+// src/ImageData/imageDataToUInt32Array.ts
+function imageDataToUInt32Array(imageData) {
+  return new Uint32Array(
+    imageData.data.buffer,
+    imageData.data.byteOffset,
+    // Shift right by 2 is a fast bitwise division by 4.
+    imageData.data.byteLength >> 2
+  );
+}
+
+// src/ImageData/invertImageData.ts
+function invertImageData(imageData) {
+  const data = imageData.data;
+  let length = data.length;
+  for (let i = 0; i < length; i += 4) {
+    data[i] = 255 - data[i];
+    data[i + 1] = 255 - data[i + 1];
+    data[i + 2] = 255 - data[i + 2];
+  }
+  return imageData;
+}
+
+// src/Internal/resample32.ts
+var resample32Scratch = {
+  data: null,
+  width: 0,
+  height: 0
+};
+function resample32(srcData32, srcW, srcH, factor) {
+  const dstW = Math.max(1, srcW * factor | 0);
+  const dstH = Math.max(1, srcH * factor | 0);
+  const dstData = new Int32Array(dstW * dstH);
+  const scaleX = srcW / dstW;
+  const scaleY = srcH / dstH;
+  for (let y = 0; y < dstH; y++) {
+    const srcY = Math.min(srcH - 1, y * scaleY | 0);
+    const srcRowOffset = srcY * srcW;
+    const dstRowOffset = y * dstW;
+    for (let x = 0; x < dstW; x++) {
+      const srcX = Math.min(srcW - 1, x * scaleX | 0);
+      dstData[dstRowOffset + x] = srcData32[srcRowOffset + srcX];
+    }
+  }
+  resample32Scratch.data = dstData;
+  resample32Scratch.width = dstW;
+  resample32Scratch.height = dstH;
+  return resample32Scratch;
+}
+
+// src/ImageData/resampleImageData.ts
+function resampleImageData(source, factor) {
+  const src32 = new Uint32Array(source.data.buffer);
+  const { data, width, height } = resample32(src32, source.width, source.height, factor);
+  const uint8ClampedArray = new Uint8ClampedArray(data.buffer);
+  return new ImageData(uint8ClampedArray, width, height);
+}
+
+// src/ImageData/resizeImageData.ts
+function resizeImageData(current, newWidth, newHeight, offsetX = 0, offsetY = 0) {
+  const result = new ImageData(newWidth, newHeight);
+  const {
+    width: oldW,
+    height: oldH,
+    data: oldData
+  } = current;
+  const newData = result.data;
+  const x0 = Math.max(0, offsetX);
+  const y0 = Math.max(0, offsetY);
+  const x1 = Math.min(newWidth, offsetX + oldW);
+  const y1 = Math.min(newHeight, offsetY + oldH);
+  if (x1 <= x0 || y1 <= y0) {
+    return result;
+  }
+  const rowCount = y1 - y0;
+  const rowLen = (x1 - x0) * 4;
+  for (let row = 0; row < rowCount; row++) {
+    const dstY = y0 + row;
+    const srcY = dstY - offsetY;
+    const srcX = x0 - offsetX;
+    const dstStart = (dstY * newWidth + x0) * 4;
+    const srcStart = (srcY * oldW + srcX) * 4;
+    newData.set(
+      oldData.subarray(srcStart, srcStart + rowLen),
+      dstStart
+    );
+  }
+  return result;
+}
+
+// src/ImageData/serialization.ts
+function base64EncodeArrayBuffer(buffer) {
+  const uint8 = new Uint8Array(buffer);
+  const decoder = new TextDecoder("latin1");
+  const binary = decoder.decode(uint8);
+  return btoa(binary);
+}
+function base64DecodeArrayBuffer(encoded) {
+  const binary = atob(encoded);
+  const bytes = new Uint8ClampedArray(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function serializeImageData(imageData) {
+  return {
+    width: imageData.width,
+    height: imageData.height,
+    data: base64EncodeArrayBuffer(imageData.data.buffer)
+  };
+}
+function serializeNullableImageData(imageData) {
+  if (!imageData) return null;
+  return serializeImageData(imageData);
+}
+function deserializeRawImageData(serialized) {
+  return {
+    width: serialized.width,
+    height: serialized.height,
+    data: base64DecodeArrayBuffer(serialized.data)
+  };
+}
+function deserializeImageData(serialized) {
+  const data = base64DecodeArrayBuffer(serialized.data);
+  return new ImageData(data, serialized.width, serialized.height);
+}
+function deserializeNullableImageData(serialized) {
+  if (!serialized) return null;
+  return deserializeImageData(serialized);
+}
+
+// src/ImageData/writeImageData.ts
+function writeImageData(target, source, x, y, sx = 0, sy = 0, sw = source.width, sh = source.height, mask = null, maskType = 1 /* BINARY */) {
+  const dstW = target.width;
+  const dstH = target.height;
+  const dstData = target.data;
+  const srcW = source.width;
+  const srcData = source.data;
+  const x0 = Math.max(0, x);
+  const y0 = Math.max(0, y);
+  const x1 = Math.min(dstW, x + sw);
+  const y1 = Math.min(dstH, y + sh);
+  if (x1 <= x0 || y1 <= y0) {
+    return;
+  }
+  const useMask = !!mask;
+  const rowCount = y1 - y0;
+  const rowLenPixels = x1 - x0;
+  for (let row = 0; row < rowCount; row++) {
+    const dstY = y0 + row;
+    const srcY = sy + (dstY - y);
+    const srcXBase = sx + (x0 - x);
+    const dstStart = (dstY * dstW + x0) * 4;
+    const srcStart = (srcY * srcW + srcXBase) * 4;
+    if (useMask && mask) {
+      for (let ix = 0; ix < rowLenPixels; ix++) {
+        const mi = srcY * srcW + (srcXBase + ix);
+        const alpha = mask[mi];
+        if (alpha === 0) {
+          continue;
+        }
+        const di = dstStart + ix * 4;
+        const si = srcStart + ix * 4;
+        if (maskType === 1 /* BINARY */ || alpha === 255) {
+          dstData[di] = srcData[si];
+          dstData[di + 1] = srcData[si + 1];
+          dstData[di + 2] = srcData[si + 2];
+          dstData[di + 3] = srcData[si + 3];
+        } else {
+          const a = alpha / 255;
+          const invA = 1 - a;
+          dstData[di] = srcData[si] * a + dstData[di] * invA;
+          dstData[di + 1] = srcData[si + 1] * a + dstData[di + 1] * invA;
+          dstData[di + 2] = srcData[si + 2] * a + dstData[di + 2] * invA;
+          dstData[di + 3] = srcData[si + 3] * a + dstData[di + 3] * invA;
+        }
+      }
+    } else {
+      const byteLen = rowLenPixels * 4;
+      const sub = srcData.subarray(srcStart, srcStart + byteLen);
+      dstData.set(sub, dstStart);
+    }
+  }
+}
+
+// src/ImageData/writeImageDataBuffer.ts
+function writeImageDataBuffer(imageData, data, _x, _y, _w, _h) {
+  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
+  const { width: dstW, height: dstH, data: dst } = imageData;
+  const x0 = Math.max(0, x);
+  const y0 = Math.max(0, y);
+  const x1 = Math.min(dstW, x + w);
+  const y1 = Math.min(dstH, y + h);
+  if (x1 <= x0 || y1 <= y0) return;
+  const rowLen = (x1 - x0) * 4;
+  const srcCol = x0 - x;
+  const srcYOffset = y0 - y;
+  const actualH = y1 - y0;
+  for (let row = 0; row < actualH; row++) {
+    const dstStart = ((y0 + row) * dstW + x0) * 4;
+    const srcRow = srcYOffset + row;
+    const o = (srcRow * w + srcCol) * 4;
+    dst.set(data.subarray(o, o + rowLen), dstStart);
+  }
+}
+
+// src/IndexedImage/IndexedImage.ts
+var IndexedImage = class _IndexedImage {
+  /** The width of the image in pixels. */
+  width;
+  /** The height of the image in pixels. */
+  height;
+  /** Flat array of palette indices. Index = x + (y * width). */
+  data;
+  /** The palette of unique 32-bit colors (ABGR/RGBA packed) found in the image. */
+  palette;
+  /** The specific index in the palette reserved for fully transparent pixels. */
+  transparentPalletIndex;
+  /**
+   * @param width - Image width.
+   * @param height - Image height.
+   * @param data - The indexed pixel data.
+   * @param palette - The array of packed colors.
+   * @param transparentPalletIndex - The index representing alpha 0.
+   */
+  constructor(width, height, data, palette, transparentPalletIndex) {
+    this.width = width;
+    this.height = height;
+    this.data = data;
+    this.palette = palette;
+    this.transparentPalletIndex = transparentPalletIndex;
+  }
+  /**
+   * Creates an IndexedImage from standard browser ImageData.
+   * @param imageData - The source ImageData to convert.
+   * @returns A new IndexedImage instance.
+   */
+  static fromImageData(imageData) {
+    return _IndexedImage.fromRaw(imageData.data, imageData.width, imageData.height);
+  }
+  /**
+   * Creates an IndexedImage from a raw byte buffer and dimensions.
+   * Any pixel with an alpha channel of 0 is normalized to the transparent palette index.
+   * @param data - Raw RGBA byte data.
+   * @param width - Image width.
+   * @param height - Image height.
+   * @returns A new IndexedImage instance.
+   */
+  static fromRaw(data, width, height) {
+    const buffer = data.buffer;
+    const rawData = new Uint32Array(buffer);
+    const indexedData = new Int32Array(rawData.length);
+    const colorMap = /* @__PURE__ */ new Map();
+    const transparentColor = 0;
+    const transparentPalletIndex = 0;
+    colorMap.set(transparentColor, transparentPalletIndex);
+    for (let i = 0; i < rawData.length; i++) {
+      const pixel = rawData[i];
+      const alpha = pixel >>> 24 & 255;
+      const isTransparent = alpha === 0;
+      const colorKey = isTransparent ? transparentColor : pixel >>> 0;
+      let id = colorMap.get(colorKey);
+      if (id === void 0) {
+        id = colorMap.size;
+        colorMap.set(colorKey, id);
+      }
+      indexedData[i] = id;
+    }
+    const palette = Uint32Array.from(colorMap.keys());
+    return new _IndexedImage(
+      width,
+      height,
+      indexedData,
+      palette,
+      transparentPalletIndex
+    );
+  }
+  /**
+   * Retrieves the 32-bit packed color value at the given coordinates.
+   * @param x - X coordinate.
+   * @param y - Y coordinate.
+   * @returns The packed color from the palette.
+   */
+  getColorAt(x, y) {
+    const index = x + y * this.width;
+    const paletteIndex = this.data[index];
+    return this.palette[paletteIndex];
+  }
+};
+
+// src/IndexedImage/getIndexedImageColorCounts.ts
+function getIndexedImageColorCounts(indexedImage) {
+  const data = indexedImage.data;
+  const palette = indexedImage.palette;
+  const frequencies = new Int32Array(palette.length);
+  for (let i = 0; i < data.length; i++) {
+    const colorIndex = data[i];
+    frequencies[colorIndex]++;
+  }
+  return frequencies;
+}
+
+// src/IndexedImage/indexedImageToAverageColor.ts
+function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
+  const { data, palette, transparentPalletIndex } = indexedImage;
+  const counts = new Uint32Array(palette.length);
+  for (let i = 0; i < data.length; i++) {
+    const id = data[i];
+    counts[id]++;
+  }
+  let rSum = 0;
+  let gSum = 0;
+  let bSum = 0;
+  let aSum = 0;
+  let totalWeight = 0;
+  for (let id = 0; id < counts.length; id++) {
+    const weight = counts[id];
+    if (weight === 0) {
+      continue;
+    }
+    if (!includeTransparent && id === transparentPalletIndex) {
+      continue;
+    }
+    const color = palette[id] >>> 0;
+    const r2 = color & 255;
+    const g2 = color >> 8 & 255;
+    const b2 = color >> 16 & 255;
+    const a2 = color >> 24 & 255;
+    rSum += r2 * weight;
+    gSum += g2 * weight;
+    bSum += b2 * weight;
+    aSum += a2 * weight;
+    totalWeight += weight;
+  }
+  if (totalWeight === 0) {
+    return packColor(0, 0, 0, 0);
+  }
+  const r = rSum / totalWeight | 0;
+  const g = gSum / totalWeight | 0;
+  const b = bSum / totalWeight | 0;
+  const a = aSum / totalWeight | 0;
+  return packColor(r, g, b, a);
+}
+
+// src/IndexedImage/resampleIndexedImage.ts
+function resampleIndexedImage(source, factor) {
+  const { data, width, height } = resample32(
+    source.data,
+    source.width,
+    source.height,
+    factor
+  );
+  return new IndexedImage(
+    width,
+    height,
+    data,
+    source.palette,
+    source.transparentPalletIndex
+  );
+}
+
+// src/IndexedImage/indexedImageToImageData.ts
+function indexedImageToImageData(indexedImage) {
+  const { width, height, data, palette } = indexedImage;
+  const result = new ImageData(width, height);
+  const data32 = new Uint32Array(result.data.buffer);
+  for (let i = 0; i < data.length; i++) {
+    const paletteIndex = data[i];
+    const color = palette[paletteIndex];
+    data32[i] = color;
+  }
+  return result;
+}
+
+// src/Input/fileInputChangeToImageData.ts
+async function fileInputChangeToImageData(event) {
+  const target = event.target;
+  const file = target.files?.[0];
+  if (!file) return null;
+  return await fileToImageData(file);
+}
+
+// src/Input/fileToImageData.ts
+var UnsupportedFormatError = class extends Error {
+  constructor(mimeType) {
+    super(`File type ${mimeType} is not a supported image format.`);
+    this.name = "UnsupportedFormatError";
+  }
+};
+async function fileToImageData(file) {
+  if (!file) return null;
+  if (!file.type.startsWith("image/")) {
+    throw new UnsupportedFormatError(file.type);
+  }
+  let bitmap = null;
+  try {
+    bitmap = await createImageBitmap(file);
+    const canvas = new OffscreenCanvas(
+      bitmap.width,
+      bitmap.height
+    );
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error(OFFSCREEN_CANVAS_CTX_FAILED);
+    ctx.drawImage(
+      bitmap,
+      0,
+      0
+    );
+    return ctx.getImageData(
+      0,
+      0,
+      bitmap.width,
+      bitmap.height
+    );
+  } finally {
+    bitmap?.close();
+  }
+}
+
+// src/Input/getSupportedRasterFormats.ts
+var formatsPromise = null;
+var defaultRasterMimes = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/avif",
+  "image/gif",
+  "image/bmp"
+];
+async function getSupportedPixelFormats(rasterMimes = defaultRasterMimes) {
+  if (formatsPromise) {
+    return formatsPromise;
+  }
+  const probeCanvas = async () => {
+    const canvas = new OffscreenCanvas(1, 1);
+    const results = await Promise.all(
+      rasterMimes.map(async (mime) => {
+        try {
+          const blob = await canvas.convertToBlob({
+            type: mime
+          });
+          return blob.type === mime ? mime : null;
+        } catch {
+          return null;
+        }
+      })
+    );
+    return results.filter((type) => {
+      return type !== null;
+    });
+  };
+  formatsPromise = probeCanvas().catch((error) => {
+    formatsPromise = null;
+    throw error;
+  });
+  return formatsPromise;
+}
+
+// src/Mask/copyMask.ts
+function copyMask(src) {
+  return src.slice();
+}
+
+// src/Mask/invertMask.ts
+function invertBinaryMask(dst) {
+  const len = dst.length;
+  for (let i = 0; i < len; i++) {
+    dst[i] = dst[i] === 0 ? 1 : 0;
+  }
+}
+function invertAlphaMask(dst) {
+  const len = dst.length;
+  for (let i = 0; i < len; i++) {
+    dst[i] = 255 - dst[i];
+  }
+}
+
+// src/Mask/mergeMasks.ts
+function mergeMasks(dst, dstWidth, src, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = 0,
+    h: height = 0,
     alpha: globalAlpha = 255,
-    blendFn = FAST_BLEND_MODES[1 /* sourceOver */],
-    mask,
     maskType = 0 /* ALPHA */,
     mw,
     mx = 0,
     my = 0,
     invertMask = false
   } = opts;
-  if (globalAlpha === 0) return;
-  let x = targetX;
-  let y = targetY;
-  let sx = sourceX;
-  let sy = sourceY;
-  let w = width;
-  let h = height;
-  if (sx < 0) {
-    x -= sx;
-    w += sx;
-    sx = 0;
-  }
-  if (sy < 0) {
-    y -= sy;
-    h += sy;
-    sy = 0;
-  }
-  w = Math.min(w, src.width - sx);
-  h = Math.min(h, src.height - sy);
-  if (x < 0) {
-    sx -= x;
-    w += x;
-    x = 0;
-  }
-  if (y < 0) {
-    sy -= y;
-    h += y;
-    y = 0;
+  if (width <= 0 || height <= 0 || globalAlpha === 0) {
+    return;
   }
-  const actualW = Math.min(w, dst.width - x);
-  const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return;
-  const dst32 = dst.data32;
-  const src32 = src.data32;
-  const dw = dst.width;
-  const sw = src.width;
-  const mPitch = mw ?? width;
-  const isAlphaMask = maskType === 0 /* ALPHA */;
-  const dx = x - targetX;
-  const dy = y - targetY;
-  let dIdx = y * dw + x;
-  let sIdx = sy * sw + sx;
-  let mIdx = (my + dy) * mPitch + (mx + dx);
-  const dStride = dw - actualW;
-  const sStride = sw - actualW;
-  const mStride = mPitch - actualW;
-  const isOverwrite = blendFn.isOverwrite;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      const baseSrcColor = src32[sIdx];
-      const baseSrcAlpha = baseSrcColor >>> 24;
-      if (baseSrcAlpha === 0 && !isOverwrite) {
-        dIdx++;
-        sIdx++;
-        mIdx++;
+  const sPitch = mw ?? width;
+  const isAlpha = maskType === 0 /* ALPHA */;
+  for (let iy = 0; iy < height; iy++) {
+    const dy = targetY + iy;
+    const sy = my + iy;
+    if (dy < 0 || sy < 0) {
+      continue;
+    }
+    for (let ix = 0; ix < width; ix++) {
+      const dx = targetX + ix;
+      const sx = mx + ix;
+      if (dx < 0 || dx >= dstWidth || sx < 0 || sx >= sPitch) {
         continue;
       }
+      const dIdx = dy * dstWidth + dx;
+      const sIdx = sy * sPitch + sx;
+      const mVal = src[sIdx];
       let weight = globalAlpha;
-      if (mask) {
-        const mVal = mask[mIdx];
-        if (isAlphaMask) {
-          const effectiveM = invertMask ? 255 - mVal : mVal;
-          if (effectiveM === 0) {
-            dIdx++;
-            sIdx++;
-            mIdx++;
-            continue;
-          }
-          if (globalAlpha === 255) {
-            weight = effectiveM;
-          } else if (effectiveM === 255) {
-            weight = globalAlpha;
-          } else {
-            weight = effectiveM * globalAlpha + 128 >> 8;
-          }
-        } else {
-          const isHit = invertMask ? mVal === 0 : mVal === 1;
-          if (!isHit) {
-            dIdx++;
-            sIdx++;
-            mIdx++;
-            continue;
-          }
-          weight = globalAlpha;
-        }
-        if (weight === 0) {
-          dIdx++;
-          sIdx++;
-          mIdx++;
+      if (isAlpha) {
+        const effectiveM = invertMask ? 255 - mVal : mVal;
+        if (effectiveM === 0) {
+          dst[dIdx] = 0;
           continue;
         }
-      }
-      let currentSrcColor = baseSrcColor;
-      if (weight < 255) {
-        let currentSrcAlpha = baseSrcAlpha;
-        if (baseSrcAlpha === 255) {
-          currentSrcAlpha = weight;
-        } else {
-          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
-        }
-        if (!isOverwrite && currentSrcAlpha === 0) {
-          dIdx++;
-          sIdx++;
-          mIdx++;
+        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
+      } else {
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (!isHit) {
+          dst[dIdx] = 0;
           continue;
         }
-        currentSrcColor = (baseSrcColor & 16777215 | currentSrcAlpha << 24) >>> 0;
+        weight = globalAlpha;
+      }
+      if (weight === 0) {
+        dst[dIdx] = 0;
+        continue;
+      }
+      const da = dst[dIdx];
+      if (da === 0) {
+      } else if (weight === 255) {
+      } else if (da === 255) {
+        dst[dIdx] = weight;
+      } else {
+        dst[dIdx] = da * weight + 128 >> 8;
       }
-      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
-      dIdx++;
-      sIdx++;
-      mIdx++;
     }
-    dIdx += dStride;
-    sIdx += sStride;
-    mIdx += mStride;
   }
 }
 
-// src/PixelData/fillPixelData.ts
-function fillPixelData(dst, color, _x, _y, _w, _h) {
-  let x;
-  let y;
-  let w;
-  let h;
-  if (typeof _x === "object") {
-    x = _x.x ?? 0;
-    y = _x.y ?? 0;
-    w = _x.w ?? dst.width;
-    h = _x.h ?? dst.height;
-  } else if (typeof _x === "number") {
-    x = _x;
-    y = _y;
-    w = _w;
-    h = _h;
-  } else {
-    x = 0;
-    y = 0;
-    w = dst.width;
-    h = dst.height;
+// src/PixelData/PixelData.ts
+var PixelData = class _PixelData {
+  data32;
+  imageData;
+  get width() {
+    return this.imageData.width;
   }
-  if (x < 0) {
-    w += x;
-    x = 0;
+  get height() {
+    return this.imageData.height;
   }
-  if (y < 0) {
-    h += y;
-    y = 0;
+  constructor(imageData) {
+    this.data32 = imageDataToUInt32Array(imageData);
+    this.imageData = imageData;
   }
-  const actualW = Math.min(w, dst.width - x);
-  const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) {
-    return;
+  set(imageData) {
+    this.imageData = imageData;
+    this.data32 = imageDataToUInt32Array(imageData);
   }
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  if (actualW === dw && actualH === dst.height && x === 0 && y === 0) {
-    dst32.fill(color);
-    return;
+  /**
+   * Creates a deep copy of the PixelData using the environment's ImageData constructor.
+   */
+  copy() {
+    const buffer = new Uint8ClampedArray(this.imageData.data);
+    const ImageConstructor = typeof ImageData !== "undefined" ? ImageData : this.imageData.constructor;
+    const newImageData = new ImageConstructor(
+      buffer,
+      this.width,
+      this.height
+    );
+    return new _PixelData(newImageData);
   }
-  for (let iy = 0; iy < actualH; iy++) {
-    const start = (y + iy) * dw + x;
-    const end = start + actualW;
-    dst32.fill(color, start, end);
+};
+
+// src/PixelData/applyCircleBrushToPixelData.ts
+function applyCircleBrushToPixelData(target, color, centerX, centerY, brushSize, alpha = 255, fallOff, blendFn = sourceOverPerfect) {
+  const r = brushSize / 2;
+  const rSqr = r * r;
+  const centerOffset = brushSize % 2 === 0 ? 0.5 : 0;
+  const xStart = Math.max(0, Math.ceil(centerX - r));
+  const xEnd = Math.min(target.width - 1, Math.floor(centerX + r));
+  const yStart = Math.max(0, Math.ceil(centerY - r));
+  const yEnd = Math.min(target.height - 1, Math.floor(centerY + r));
+  const data32 = target.data32;
+  const targetWidth = target.width;
+  const baseColor = color & 16777215;
+  const invR = 1 / r;
+  const constantSrc = (alpha << 24 | baseColor) >>> 0;
+  for (let cy = yStart; cy <= yEnd; cy++) {
+    const dy = cy - centerY + centerOffset;
+    const dySqr = dy * dy;
+    const rowOffset = cy * targetWidth;
+    for (let cx = xStart; cx <= xEnd; cx++) {
+      const dx = cx - centerX + centerOffset;
+      const dSqr = dx * dx + dySqr;
+      if (dSqr <= rSqr) {
+        const idx = rowOffset + cx;
+        if (fallOff) {
+          const strength = fallOff(Math.sqrt(dSqr) * invR);
+          const fAlpha = alpha * strength & 255;
+          const src = (fAlpha << 24 | baseColor) >>> 0;
+          data32[idx] = blendFn(src, data32[idx]);
+        } else {
+          data32[idx] = blendFn(constantSrc, data32[idx]);
+        }
+      }
+    }
+  }
+}
+
+// src/PixelData/applyRectBrushToPixelData.ts
+function applyRectBrushToPixelData(target, color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn = sourceOverPerfect) {
+  const targetWidth = target.width;
+  const targetHeight = target.height;
+  const data32 = target.data32;
+  const rawStartX = Math.floor(centerX - brushWidth / 2);
+  const rawStartY = Math.floor(centerY - brushHeight / 2);
+  const endX = Math.min(targetWidth, rawStartX + brushWidth);
+  const endY = Math.min(targetHeight, rawStartY + brushHeight);
+  const startX = Math.max(0, rawStartX);
+  const startY = Math.max(0, rawStartY);
+  const baseColor = color & 16777215;
+  const constantSrc = (alpha << 24 | baseColor) >>> 0;
+  const invHalfW = 1 / (brushWidth / 2);
+  const invHalfH = 1 / (brushHeight / 2);
+  for (let py = startY; py < endY; py++) {
+    const rowOffset = py * targetWidth;
+    const dy = Math.abs(py + 0.5 - centerY) * invHalfH;
+    for (let px = startX; px < endX; px++) {
+      if (fallOff) {
+        const dx = Math.abs(px + 0.5 - centerX) * invHalfW;
+        const dist = dx > dy ? dx : dy;
+        const fAlpha = alpha * fallOff(dist) | 0;
+        const src = (fAlpha << 24 | baseColor) >>> 0;
+        data32[rowOffset + px] = blendFn(src, data32[rowOffset + px]);
+      } else {
+        data32[rowOffset + px] = blendFn(constantSrc, data32[rowOffset + px]);
+      }
+    }
   }
 }
+function getRectBrushBounds(centerX, centerY, brushWidth, brushHeight, targetWidth, targetHeight) {
+  const rawStartX = Math.floor(centerX - brushWidth / 2);
+  const rawStartY = Math.floor(centerY - brushHeight / 2);
+  const rawEndX = rawStartX + brushWidth;
+  const rawEndY = rawStartY + brushHeight;
+  const startX = targetWidth !== void 0 ? Math.max(0, rawStartX) : rawStartX;
+  const startY = targetHeight !== void 0 ? Math.max(0, rawStartY) : rawStartY;
+  const endX = targetWidth !== void 0 ? Math.min(targetWidth, rawEndX) : rawEndX;
+  const endY = targetHeight !== void 0 ? Math.min(targetHeight, rawEndY) : rawEndY;
+  return {
+    x: startX,
+    y: startY,
+    w: endX - startX,
+    h: endY - startY
+  };
+}
 
 // src/PixelData/clearPixelData.ts
 function clearPixelData(dst, rect) {
@@ -2650,16 +3298,6 @@ function extractPixelData(source, _x, _y, _w, _h) {
   return result;
 }
 
-// src/PixelData/invertPixelData.ts
-function invertPixelData(pixelData) {
-  const data32 = pixelData.data32;
-  const len = data32.length;
-  for (let i = 0; i < len; i++) {
-    data32[i] = data32[i] ^ 16777215;
-  }
-  return pixelData;
-}
-
 // src/PixelData/reflectPixelData.ts
 function reflectPixelDataHorizontal(pixelData) {
   const width = pixelData.width;
@@ -2750,24 +3388,54 @@ function rotateSquareInPlace(pixelData) {
     }
   }
 }
+
+// src/PixelData/writePixelDataBuffer.ts
+function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
+  const { x, y, w, h } = typeof _x === "object" ? _x : {
+    x: _x,
+    y: _y,
+    w: _w,
+    h: _h
+  };
+  const dstW = target.width;
+  const dstH = target.height;
+  const dstData = target.data32;
+  const x0 = Math.max(0, x);
+  const y0 = Math.max(0, y);
+  const x1 = Math.min(dstW, x + w);
+  const y1 = Math.min(dstH, y + h);
+  if (x1 <= x0 || y1 <= y0) {
+    return;
+  }
+  const rowLen = x1 - x0;
+  const srcCol = x0 - x;
+  const srcYOffset = y0 - y;
+  const actualH = y1 - y0;
+  for (let row = 0; row < actualH; row++) {
+    const dstStart = (y0 + row) * dstW + x0;
+    const srcRow = srcYOffset + row;
+    const srcStart = srcRow * w + srcCol;
+    dstData.set(data.subarray(srcStart, srcStart + rowLen), dstStart);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BlendMode,
-  FAST_BLENDER_REGISTRY,
-  FAST_BLEND_MODES,
-  FAST_BLEND_MODE_BY_NAME,
-  FAST_BLEND_TO_INDEX,
-  INDEX_TO_FAST_BLEND,
-  INDEX_TO_PERFECT_BLEND,
+  BASE_FAST_BLEND_MODE_FUNCTIONS,
+  BASE_PERFECT_BLEND_MODE_FUNCTIONS,
+  BaseBlendMode,
+  HistoryManager,
   IndexedImage,
   MaskType,
-  PERFECT_BLENDER_REGISTRY,
-  PERFECT_BLEND_MODES,
-  PERFECT_BLEND_MODE_BY_NAME,
-  PERFECT_BLEND_TO_INDEX,
+  PixelAccumulator,
   PixelData,
+  PixelEngineConfig,
+  PixelTile,
+  PixelWriter,
   UnsupportedFormatError,
+  applyCircleBrushToPixelData,
   applyMaskToPixelData,
+  applyPatchTiles,
+  applyRectBrushToPixelData,
   base64DecodeArrayBuffer,
   base64EncodeArrayBuffer,
   blendColorPixelData,
@@ -2806,6 +3474,7 @@ function rotateSquareInPlace(pixelData) {
   floodFillSelection,
   getImageDataFromClipboard,
   getIndexedImageColorCounts,
+  getRectBrushBounds,
   getSupportedPixelFormats,
   hardLightFast,
   hardLightPerfect,
@@ -2834,14 +3503,25 @@ function rotateSquareInPlace(pixelData) {
   linearDodgePerfect,
   linearLightFast,
   linearLightPerfect,
+  makeBlendModeRegistry,
+  makeFastBlendModeRegistry,
+  makeFullPixelMutator,
+  makePerfectBlendModeRegistry,
   makePixelCanvas,
   makeReusableCanvas,
   makeReusableImageData,
   mergeMasks,
   multiplyFast,
   multiplyPerfect,
+  mutatorApplyMask,
+  mutatorBlendColor,
+  mutatorBlendPixel,
+  mutatorBlendPixelData,
+  mutatorFill,
+  mutatorInvert,
   overlayFast,
   overlayPerfect,
+  overwriteBase,
   overwriteFast,
   overwritePerfect,
   packColor,
@@ -2876,8 +3556,9 @@ function rotateSquareInPlace(pixelData) {
   vividLightFast,
   vividLightPerfect,
   writeImageData,
-  writeImageDataPixels,
+  writeImageDataBuffer,
   writeImageDataToClipboard,
-  writeImgBlobToClipboard
+  writeImgBlobToClipboard,
+  writePixelDataBuffer
 });
 //# sourceMappingURL=index.dev.cjs.map