pixel-data-js 0.25.0 → 0.26.0

package/dist/index.prod.js

@@ -297,37 +297,22 @@ function trimMaskRectBounds(target, bounds) {
 }
 
 // src/Algorithm/floodFillSelection.ts
-function floodFillSelection(img, startX, startY, {
-  contiguous = true,
-  tolerance = 0,
-  bounds
-} = {}) {
-  let imageData;
-  let data32;
-  if ("data32" in img) {
-    data32 = img.data32;
-    imageData = img.imageData;
-  } else {
-    data32 = new Uint32Array(img.data.buffer, img.data.byteOffset, img.data.byteLength >> 2);
-    imageData = img;
-  }
-  const {
-    width,
-    height
-  } = img;
-  const limit = bounds || {
-    x: 0,
-    y: 0,
-    w: width,
-    h: height
-  };
-  const xMin = Math.max(0, limit.x);
-  const xMax = Math.min(width - 1, limit.x + limit.w - 1);
-  const yMin = Math.max(0, limit.y);
-  const yMax = Math.min(height - 1, limit.y + limit.h - 1);
+function floodFillSelection(target, startX, startY, contiguous = true, tolerance = 0, bounds, out) {
+  const data32 = target.data32;
+  const width = target.width;
+  const height = target.height;
+  const lx = bounds?.x ?? 0;
+  const ly = bounds?.y ?? 0;
+  const lw = bounds?.w ?? width;
+  const lh = bounds?.h ?? height;
+  const xMin = Math.max(0, lx);
+  const xMax = Math.min(width - 1, lx + lw - 1);
+  const yMin = Math.max(0, ly);
+  const yMax = Math.min(height - 1, ly + lh - 1);
   if (startX < xMin || startX > xMax || startY < yMin || startY > yMax) {
     return null;
   }
+  out = out ?? {};
   const baseColor = data32[startY * width + startX];
   let matchCount = 0;
   const matchX = new Uint16Array(width * height);
@@ -398,42 +383,33 @@ function floodFillSelection(img, startX, startY, {
       }
     }
   }
-  if (matchCount === 0) {
-    return null;
-  }
+  if (matchCount === 0) return null;
   const w = maxX - minX + 1;
   const h = maxY - minY + 1;
-  const selectionRect = {
-    x: minX,
-    y: minY,
-    w,
-    h,
-    data: new Uint8Array(w * h),
-    type: 1 /* BINARY */
-  };
-  const sw = selectionRect.w;
-  const sh = selectionRect.h;
-  const finalMask = selectionRect.data;
+  out.startX = startX;
+  out.startY = startY;
+  out.x = minX;
+  out.y = minY;
+  out.w = w;
+  out.h = h;
+  out.data = new Uint8Array(w * h);
+  out.type = 1 /* BINARY */;
+  const finalMask = out.data;
   for (let i = 0; i < matchCount; i++) {
-    const mx = matchX[i] - selectionRect.x;
-    const my = matchY[i] - selectionRect.y;
-    if (mx >= 0 && mx < sw && my >= 0 && my < sh) {
-      finalMask[my * sw + mx] = 1;
+    const mx = matchX[i] - minX;
+    const my = matchY[i] - minY;
+    if (mx >= 0 && mx < w && my >= 0 && my < h) {
+      finalMask[my * w + mx] = 1;
     }
   }
-  trimMaskRectBounds(selectionRect, {
+  trimMaskRectBounds(out, {
     x: 0,
     y: 0,
     w: width,
     h: height
   });
-  const extracted = extractImageDataBuffer(imageData, selectionRect.x, selectionRect.y, selectionRect.w, selectionRect.h);
-  return {
-    startX,
-    startY,
-    selectionRect,
-    pixels: extracted
-  };
+  out.pixels = extractImageDataBuffer(target.imageData, out.x, out.y, out.w, out.h);
+  return out;
 }
 
 // src/Algorithm/forEachLinePoint.ts
@@ -456,35 +432,6 @@ function forEachLinePoint(x0, y0, x1, y1, callback) {
   }
 }
 
-// src/BlendModes/blend-modes.ts
-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, registryName = "anonymous") {
   const blendToName = /* @__PURE__ */ new Map();
@@ -524,6 +471,35 @@ function makeBlendModeRegistry(blendModes, initialEntries, registryName = "anony
   };
 }
 
+// src/BlendModes/blend-modes.ts
+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/blend-modes-fast.ts
 var overwriteFast = overwriteBase;
 var sourceOverFast = (src, dst) => {
@@ -1529,7 +1505,7 @@ var getKeyByValue = (obj, value) => {
   }
 };
 
-// src/Canvas/_constants.ts
+// support/error-strings.ts
 var OFFSCREEN_CANVAS_CTX_FAILED = "Failed to create OffscreenCanvas context";
 var CANVAS_CTX_FAILED = "Failed to create Canvas context";
 
@@ -1631,6 +1607,24 @@ function makePixelCanvas(canvas) {
   };
 }
 
+// src/Canvas/canvas-blend-modes.ts
+var CANVAS_COMPOSITE_MAP = {
+  [BaseBlendMode.overwrite]: "copy",
+  [BaseBlendMode.sourceOver]: "source-over",
+  [BaseBlendMode.darken]: "darken",
+  [BaseBlendMode.multiply]: "multiply",
+  [BaseBlendMode.colorBurn]: "color-burn",
+  [BaseBlendMode.lighten]: "lighten",
+  [BaseBlendMode.screen]: "screen",
+  [BaseBlendMode.colorDodge]: "color-dodge",
+  [BaseBlendMode.linearDodge]: "lighter",
+  [BaseBlendMode.overlay]: "overlay",
+  [BaseBlendMode.softLight]: "soft-light",
+  [BaseBlendMode.hardLight]: "hard-light",
+  [BaseBlendMode.difference]: "difference",
+  [BaseBlendMode.exclusion]: "exclusion"
+};
+
 // src/ImageData/imgBlobToImageData.ts
 async function imgBlobToImageData(blob) {
   let bitmap = null;
@@ -1715,10 +1709,9 @@ function applyPatchTiles(target, tiles, tileSize) {
 }
 
 // src/History/HistoryAction.ts
-function makeHistoryAction(writer, patch, after, afterUndo, afterRedo, applyPatchTilesFn = applyPatchTiles) {
-  const target = writer.config.target;
-  const tileSize = writer.config.tileSize;
-  const accumulator = writer.accumulator;
+function makeHistoryAction(config, accumulator, patch, after, afterUndo, afterRedo, applyPatchTilesFn = applyPatchTiles) {
+  const target = config.target;
+  const tileSize = config.tileSize;
   return {
     undo: () => {
       applyPatchTilesFn(target, patch.beforeTiles, tileSize);
@@ -1988,20 +1981,17 @@ var PixelEngineConfig = class {
   }
 };
 
-// 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 = sourceOverPerfect
-  } = opts;
+// src/PixelData/applyAlphaMaskToPixelData.ts
+function applyAlphaMaskToPixelData(target, mask, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const width = opts?.w ?? target.width;
+  const height = opts?.h ?? target.height;
+  const globalAlpha = opts?.alpha ?? 255;
+  const mx = opts?.mx ?? 0;
+  const my = opts?.my ?? 0;
+  const invertMask = opts?.invertMask ?? false;
   if (globalAlpha === 0) return false;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) return false;
   let x = targetX;
   let y = targetY;
   let w = width;
@@ -2014,114 +2004,320 @@ function blendColorPixelData(dst, color, opts = {}) {
     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 false;
-  let finalSrcColor = color;
-  if (globalAlpha < 255) {
-    const a = baseSrcAlpha * globalAlpha + 128 >> 8;
-    if (a === 0 && !isOverwrite) return false;
-    finalSrcColor = (color & 16777215 | a << 24) >>> 0;
-  }
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  let dIdx = y * dw + x | 0;
-  const dStride = dw - actualW | 0;
+  w = Math.min(w, target.width - x);
+  h = Math.min(h, target.height - y);
+  if (w <= 0) return false;
+  if (h <= 0) return false;
+  const mPitch = mask.w;
+  if (mPitch <= 0) return false;
+  const startX = mx + (x - targetX);
+  const startY = my + (y - targetY);
+  const sX0 = Math.max(0, startX);
+  const sY0 = Math.max(0, startY);
+  const sX1 = Math.min(mPitch, startX + w);
+  const sY1 = Math.min(mask.h, startY + h);
+  const finalW = sX1 - sX0;
+  const finalH = sY1 - sY0;
+  if (finalW <= 0) return false;
+  if (finalH <= 0) return false;
+  const xShift = sX0 - startX;
+  const yShift = sY0 - startY;
+  const dst32 = target.data32;
+  const dw = target.width;
+  const dStride = dw - finalW;
+  const mStride = mPitch - finalW;
+  const maskData = mask.data;
+  let dIdx = (y + yShift) * dw + (x + xShift);
+  let mIdx = sY0 * mPitch + sX0;
   let didChange = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      const current = dst32[dIdx];
-      const next = blendFn(finalSrcColor, current);
-      if (current !== next) {
-        dst32[dIdx] = next;
+  for (let iy = 0; iy < h; iy++) {
+    for (let ix = 0; ix < w; ix++) {
+      const mVal = maskData[mIdx];
+      const effectiveM = invertMask ? 255 - mVal : mVal;
+      let weight = 0;
+      if (effectiveM === 0) {
+        weight = 0;
+      } else if (effectiveM === 255) {
+        weight = globalAlpha;
+      } else if (globalAlpha === 255) {
+        weight = effectiveM;
+      } else {
+        weight = effectiveM * globalAlpha + 128 >> 8;
+      }
+      if (weight === 0) {
+        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
         didChange = true;
+      } else if (weight !== 255) {
+        const d = dst32[dIdx];
+        const da = d >>> 24;
+        if (da !== 0) {
+          const finalAlpha = da === 255 ? weight : da * weight + 128 >> 8;
+          const current = dst32[dIdx];
+          const next = (d & 16777215 | finalAlpha << 24) >>> 0;
+          if (current !== next) {
+            dst32[dIdx] = next;
+            didChange = true;
+          }
+        }
       }
       dIdx++;
+      mIdx++;
     }
     dIdx += dStride;
+    mIdx += mStride;
   }
   return didChange;
 }
 
-// src/History/PixelMutator/mutatorBlendColor.ts
-var defaults2 = {
-  blendColorPixelData
-};
-var mutatorBlendColor = ((writer, deps = defaults2) => {
+// src/ImageData/resizeImageData.ts
+function resizeImageData(target, newWidth, newHeight, offsetX = 0, offsetY = 0) {
+  const result = new ImageData(newWidth, newHeight);
   const {
-    blendColorPixelData: blendColorPixelData2 = defaults2.blendColorPixelData
-  } = deps;
-  return {
-    blendColor(color, opts = {}) {
-      const target = writer.config.target;
-      const {
-        x = 0,
-        y = 0,
-        w = target.width,
-        h = target.height
-      } = opts;
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(blendColorPixelData2(target, color, opts));
-    }
-  };
-});
-
-// src/PixelData/blendPixel.ts
-function blendPixel(target, x, y, color, alpha = 255, blendFn = sourceOverPerfect) {
-  if (alpha === 0) return false;
-  let width = target.width;
-  let height = target.height;
-  if (x < 0 || x >= width || y < 0 || y >= height) return false;
-  let srcAlpha = color >>> 24;
-  let isOverwrite = blendFn.isOverwrite;
-  if (srcAlpha === 0 && !isOverwrite) return false;
-  let dst32 = target.data32;
-  let index = y * width + x;
-  let finalColor = color;
-  if (alpha !== 255) {
-    let finalAlpha = srcAlpha * alpha + 128 >> 8;
-    if (finalAlpha === 0 && !isOverwrite) return false;
-    finalColor = (color & 16777215 | finalAlpha << 24) >>> 0;
+    width: oldW,
+    height: oldH,
+    data: oldData
+  } = target;
+  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;
   }
-  let current = dst32[index];
-  let next = blendFn(finalColor, current);
-  if (current !== next) {
-    dst32[index] = next;
-    return true;
+  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 false;
+  return result;
 }
 
-// src/History/PixelMutator/mutatorBlendPixel.ts
-var defaults3 = {
-  blendPixel
-};
-var mutatorBlendPixel = ((writer, deps = defaults3) => {
-  const {
-    blendPixel: blendPixel2 = defaults3.blendPixel
-  } = deps;
-  return {
-    blendPixel(x, y, color, alpha, blendFn) {
-      const didChange = writer.accumulator.storePixelBeforeState(x, y);
-      return didChange(blendPixel2(writer.config.target, x, y, color, alpha, blendFn));
-    }
+// src/Rect/trimRectBounds.ts
+function trimRectBounds(x, y, w, h, targetWidth, targetHeight, out) {
+  const res = out ?? {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
   };
-});
+  const left = Math.max(0, x);
+  const top = Math.max(0, y);
+  const right = Math.min(targetWidth, x + w);
+  const bottom = Math.min(targetHeight, y + h);
+  res.x = left;
+  res.y = top;
+  res.w = Math.max(0, right - left);
+  res.h = Math.max(0, bottom - top);
+  return res;
+}
 
-// 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 = sourceOverPerfect
-  } = opts;
-  if (globalAlpha === 0) return false;
-  let x = targetX;
+// src/Paint/PaintBuffer.ts
+var PaintBuffer = class {
+  constructor(config, tilePool) {
+    this.config = config;
+    this.tilePool = tilePool;
+    this.lookup = [];
+  }
+  lookup;
+  scratchBounds = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  eachTileInBounds(bounds, callback) {
+    const {
+      tileShift,
+      targetColumns,
+      targetRows,
+      tileSize
+    } = this.config;
+    const x1 = Math.max(0, bounds.x >> tileShift);
+    const y1 = Math.max(0, bounds.y >> tileShift);
+    const x2 = Math.min(targetColumns - 1, bounds.x + bounds.w - 1 >> tileShift);
+    const y2 = Math.min(targetRows - 1, bounds.y + bounds.h - 1 >> tileShift);
+    if (x1 > x2 || y1 > y2) return;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    for (let ty = y1; ty <= y2; ty++) {
+      const rowOffset = ty * targetColumns;
+      const tileTop = ty << tileShift;
+      for (let tx = x1; tx <= x2; tx++) {
+        const id = rowOffset + tx;
+        const tile = lookup[id] ?? (lookup[id] = tilePool.getTile(id, tx, ty));
+        const tileLeft = tx << tileShift;
+        const startX = bounds.x > tileLeft ? bounds.x : tileLeft;
+        const startY = bounds.y > tileTop ? bounds.y : tileTop;
+        const maskEndX = bounds.x + bounds.w;
+        const tileEndX = tileLeft + tileSize;
+        const endX = maskEndX < tileEndX ? maskEndX : tileEndX;
+        const maskEndY = bounds.y + bounds.h;
+        const tileEndY = tileTop + tileSize;
+        const endY = maskEndY < tileEndY ? maskEndY : tileEndY;
+        callback(tile, startX, startY, endX - startX, endY - startY);
+      }
+    }
+  }
+  writePaintAlphaMaskStroke(color, brush, x0, y0, x1, y1) {
+    const cA = color >>> 24;
+    if (cA === 0) return false;
+    const {
+      tileShift,
+      tileMask,
+      target
+    } = this.config;
+    const {
+      w: bW,
+      h: bH,
+      data: bD,
+      centerOffsetX,
+      centerOffsetY
+    } = brush;
+    const cRGB = color & 16777215;
+    const scratch = this.scratchBounds;
+    let changed = false;
+    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBounds(topLeftX, topLeftY, bW, bH, target.width, target.height, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      this.eachTileInBounds(scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const d32 = tile.data32;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const bOff = (canvasY - topLeftY) * bW;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const canvasX = bX + j;
+            const brushA = bD[bOff + (canvasX - topLeftX)];
+            if (brushA === 0) continue;
+            const t = cA * brushA + 128;
+            const blendedA = t + (t >> 8) >> 8;
+            const idx = dS + j;
+            const cur = d32[idx];
+            if (brushA > cur >>> 24) {
+              const next = (cRGB | blendedA << 24) >>> 0;
+              if (cur !== next) {
+                d32[idx] = next;
+                tileChanged = true;
+              }
+            }
+          }
+        }
+        if (tileChanged) changed = true;
+      });
+    });
+    return changed;
+  }
+  writePaintBinaryMaskStroke(color, brush, x0, y0, x1, y1) {
+    const alphaIsZero = color >>> 24 === 0;
+    if (alphaIsZero) return false;
+    const {
+      tileShift,
+      tileMask,
+      target
+    } = this.config;
+    const {
+      w: bW,
+      h: bH,
+      data: bD,
+      centerOffsetX,
+      centerOffsetY
+    } = brush;
+    const scratch = this.scratchBounds;
+    let changed = false;
+    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBounds(topLeftX, topLeftY, bW, bH, target.width, target.height, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      this.eachTileInBounds(scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const d32 = tile.data32;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const bOff = (canvasY - topLeftY) * bW;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const canvasX = bX + j;
+            if (bD[bOff + (canvasX - topLeftX)]) {
+              const idx = dS + j;
+              if (d32[idx] !== color) {
+                d32[idx] = color;
+                tileChanged = true;
+              }
+            }
+          }
+        }
+        if (tileChanged) changed = true;
+      });
+    });
+    return changed;
+  }
+  writeRectStroke(color, brushWidth, brushHeight, x0, y0, x1, y1) {
+    const alphaIsZero = color >>> 24 === 0;
+    if (alphaIsZero) return false;
+    const config = this.config;
+    const tileShift = config.tileShift;
+    const tileMask = config.tileMask;
+    const target = config.target;
+    const scratch = this.scratchBounds;
+    const centerOffsetX = -(brushWidth - 1 >> 1);
+    const centerOffsetY = -(brushHeight - 1 >> 1);
+    let changed = false;
+    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBounds(topLeftX, topLeftY, brushWidth, brushHeight, target.width, target.height, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      this.eachTileInBounds(scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const d32 = tile.data32;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const idx = dS + j;
+            if (d32[idx] !== color) {
+              d32[idx] = color;
+              tileChanged = true;
+            }
+          }
+        }
+        if (tileChanged) {
+          changed = true;
+        }
+      });
+    });
+    return changed;
+  }
+  clear() {
+    this.tilePool.releaseTiles(this.lookup);
+  }
+};
+
+// src/PixelData/blendPixelData.ts
+function blendPixelData(target, src, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const sourceX = opts?.sx ?? 0;
+  const sourceY = opts?.sy ?? 0;
+  const width = opts?.w ?? src.width;
+  const height = opts?.h ?? src.height;
+  const globalAlpha = opts?.alpha ?? 255;
+  const blendFn = opts?.blendFn ?? sourceOverPerfect;
+  if (globalAlpha === 0) return false;
+  let x = targetX;
   let y = targetY;
   let sx = sourceX;
   let sy = sourceY;
@@ -2149,12 +2345,12 @@ function blendPixelData(dst, src, opts = {}) {
     h += y;
     y = 0;
   }
-  const actualW = Math.min(w, dst.width - x);
-  const actualH = Math.min(h, dst.height - y);
+  const actualW = Math.min(w, target.width - x);
+  const actualH = Math.min(h, target.height - y);
   if (actualW <= 0 || actualH <= 0) return false;
-  const dst32 = dst.data32;
+  const dst32 = target.data32;
   const src32 = src.data32;
-  const dw = dst.width;
+  const dw = target.width;
   const sw = src.width;
   let dIdx = y * dw + x | 0;
   let sIdx = sy * sw + sx | 0;
@@ -2197,240 +2393,528 @@ function blendPixelData(dst, src, opts = {}) {
   return didChange;
 }
 
-// src/History/PixelMutator/mutatorBlendPixelData.ts
-var defaults4 = {
-  blendPixelData
+// src/PixelTile/PixelTile.ts
+var PixelTile = class {
+  constructor(id, tx, ty, tileSize, tileArea) {
+    this.id = id;
+    this.tx = tx;
+    this.ty = ty;
+    this.width = this.height = tileSize;
+    this.data32 = new Uint32Array(tileArea);
+    const data8 = new Uint8ClampedArray(this.data32.buffer);
+    this.imageData = new ImageData(data8, tileSize, tileSize);
+  }
+  data32;
+  width;
+  height;
+  imageData;
 };
-var mutatorBlendPixelData = ((writer, deps = defaults4) => {
-  const {
-    blendPixelData: blendPixelData2 = defaults4.blendPixelData
-  } = deps;
-  return {
-    blendPixelData(src, opts = {}) {
-      const {
-        x = 0,
-        y = 0,
-        w = src.width,
-        h = src.height
-      } = opts;
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(blendPixelData2(writer.config.target, src, opts));
-    }
-  };
-});
 
-// src/PixelData/blendPixelDataAlphaMask.ts
-function blendPixelDataAlphaMask(dst, src, alphaMask, 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 = sourceOverPerfect,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
-  if (globalAlpha === 0) return false;
-  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;
+// src/PixelTile/PixelTilePool.ts
+var PixelTilePool = class {
+  pool;
+  tileSize;
+  tileArea;
+  constructor(config) {
+    this.pool = [];
+    this.tileSize = config.tileSize;
+    this.tileArea = config.tileArea;
   }
-  w = Math.min(w, src.width - sx);
-  h = Math.min(h, src.height - sy);
-  if (x < 0) {
-    sx -= x;
-    w += x;
-    x = 0;
+  getTile(id, tx, ty) {
+    let tile = this.pool.pop();
+    if (tile) {
+      tile.id = id;
+      tile.tx = tx;
+      tile.ty = ty;
+      tile.data32.fill(0);
+      return tile;
+    }
+    return new PixelTile(id, tx, ty, this.tileSize, this.tileArea);
   }
-  if (y < 0) {
-    sy -= y;
-    h += y;
-    y = 0;
+  releaseTile(tile) {
+    this.pool.push(tile);
   }
-  const actualW = Math.min(w, dst.width - x);
-  const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return false;
-  const dw = dst.width;
-  const sw = src.width;
-  const mPitch = alphaMask.w;
-  const maskData = alphaMask.data;
-  const dx = x - targetX | 0;
-  const dy = y - targetY | 0;
-  const dst32 = dst.data32;
-  const src32 = src.data32;
-  let dIdx = y * dw + x | 0;
-  let sIdx = sy * sw + sx | 0;
-  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
-  const dStride = dw - actualW | 0;
-  const sStride = sw - actualW | 0;
-  const mStride = mPitch - actualW | 0;
-  const isOpaque = globalAlpha === 255;
-  const isOverwrite = blendFn.isOverwrite || false;
-  let didChange = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      const mVal = maskData[mIdx];
-      const effM = invertMask ? 255 - mVal : mVal;
-      if (effM === 0) {
-        dIdx++;
-        sIdx++;
-        mIdx++;
-        continue;
-      }
-      const srcCol = src32[sIdx];
-      const srcAlpha = srcCol >>> 24;
-      if (srcAlpha === 0 && !isOverwrite) {
-        dIdx++;
-        sIdx++;
-        mIdx++;
-        continue;
-      }
-      let weight = globalAlpha;
-      if (isOpaque) {
-        weight = effM;
-      } else if (effM !== 255) {
-        weight = effM * globalAlpha + 128 >> 8;
-      }
-      if (weight === 0) {
-        dIdx++;
-        sIdx++;
-        mIdx++;
-        continue;
+  releaseTiles(tiles) {
+    let length = tiles.length;
+    for (let i = 0; i < length; i++) {
+      let tile = tiles[i];
+      if (tile) {
+        this.pool.push(tile);
       }
-      let finalCol = srcCol;
-      if (weight < 255) {
-        const a = srcAlpha * weight + 128 >> 8;
-        if (a === 0 && !isOverwrite) {
-          dIdx++;
-          sIdx++;
-          mIdx++;
-          continue;
-        }
-        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
+    }
+    tiles.length = 0;
+  }
+};
+
+// src/History/PixelWriter.ts
+var PixelWriter = class {
+  historyManager;
+  accumulator;
+  historyActionFactory;
+  config;
+  pixelTilePool;
+  paintBuffer;
+  mutator;
+  blendPixelDataOpts = {
+    alpha: 255,
+    blendFn: sourceOverPerfect,
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  _inProgress = false;
+  constructor(target, mutatorFactory, options) {
+    const tileSize = options?.tileSize ?? 256;
+    const maxHistorySteps = options?.maxHistorySteps ?? 50;
+    this.config = new PixelEngineConfig(tileSize, target);
+    this.historyManager = options?.historyManager ?? new HistoryManager(maxHistorySteps);
+    this.historyActionFactory = options?.historyActionFactory ?? makeHistoryAction;
+    this.pixelTilePool = options?.pixelTilePool ?? new PixelTilePool(this.config);
+    this.accumulator = options?.accumulator ?? new PixelAccumulator(this.config, this.pixelTilePool);
+    this.mutator = mutatorFactory(this);
+    this.paintBuffer = new PaintBuffer(this.config, this.pixelTilePool);
+  }
+  /**
+   * Executes `transaction` and commits the resulting pixel changes as a single
+   * undoable history action.
+   *
+   * - If `transaction` throws, all accumulated changes are rolled back and the error
+   *   is re-thrown. No action is committed.
+   * - If `transaction` completes without modifying any pixels, no action is committed.
+   * - `withHistory` is not re-entrant. Calling it again from inside `transaction` will
+   *   throw immediately to prevent silent data loss from a nested extractPatch.
+   *
+   * @param transaction Callback to be executed inside the transaction.
+   * @param after    Called after both undo and redo — use for generic change notifications.
+   * @param afterUndo Called after undo only — use for dimension or state changes specific to undo.
+   * @param afterRedo Called after redo only.
+   */
+  withHistory(transaction, after, afterUndo, afterRedo) {
+    if (this._inProgress) {
+      throw new Error("withHistory is not re-entrant \u2014 commit or rollback the current operation first");
+    }
+    this._inProgress = true;
+    try {
+      transaction(this.mutator);
+    } catch (e) {
+      this.accumulator.rollbackAfterError();
+      throw e;
+    } finally {
+      this._inProgress = false;
+    }
+    if (this.accumulator.beforeTiles.length === 0) return;
+    const patch = this.accumulator.extractPatch();
+    const action = this.historyActionFactory(this.config, this.accumulator, patch, after, afterUndo, afterRedo);
+    this.historyManager.commit(action);
+  }
+  resize(newWidth, newHeight, offsetX = 0, offsetY = 0, after, afterUndo, afterRedo, resizeImageDataFn = resizeImageData) {
+    if (this._inProgress) {
+      throw new Error("Cannot resize inside a withHistory callback");
+    }
+    if (this.accumulator.beforeTiles.length > 0) {
+      throw new Error("Cannot resize with an open accumulator \u2014 commit or rollback first");
+    }
+    const config = this.config;
+    const target = config.target;
+    const beforeImageData = target.imageData;
+    const afterImageData = resizeImageDataFn(beforeImageData, newWidth, newHeight, offsetX, offsetY);
+    target.set(afterImageData);
+    this.historyManager.commit({
+      undo: () => {
+        target.set(beforeImageData);
+        afterUndo?.(beforeImageData);
+        after?.(beforeImageData);
+      },
+      redo: () => {
+        target.set(afterImageData);
+        afterRedo?.(afterImageData);
+        after?.(afterImageData);
       }
-      const current = dst32[dIdx];
-      const next = blendFn(finalCol, dst32[dIdx]);
-      if (current !== next) {
-        dst32[dIdx] = next;
-        didChange = true;
+    });
+  }
+  commitPaintBuffer(alpha = 255, blendFn = sourceOverPerfect, blendPixelDataFn = blendPixelData) {
+    const paintBuffer = this.paintBuffer;
+    const tileShift = paintBuffer.config.tileShift;
+    const lookup = paintBuffer.lookup;
+    const opts = this.blendPixelDataOpts;
+    opts.alpha = alpha;
+    opts.blendFn = blendFn;
+    for (let i = 0; i < lookup.length; i++) {
+      const tile = lookup[i];
+      if (tile) {
+        const didChange = this.accumulator.storeTileBeforeState(tile.id, tile.tx, tile.ty);
+        const dx = tile.tx << tileShift;
+        const dy = tile.ty << tileShift;
+        opts.x = dx;
+        opts.y = dy;
+        opts.w = tile.width;
+        opts.h = tile.height;
+        didChange(blendPixelDataFn(this.config.target, tile, opts));
       }
-      dIdx++;
-      sIdx++;
-      mIdx++;
     }
-    dIdx += dStride;
-    sIdx += sStride;
-    mIdx += mStride;
+    paintBuffer.clear();
   }
-  return didChange;
-}
+};
 
-// src/History/PixelMutator/mutatorBlendPixelDataAlphaMask.ts
-var defaults5 = {
-  blendPixelDataAlphaMask
+// src/History/PixelMutator/mutatorApplyAlphaMask.ts
+var defaults2 = {
+  applyAlphaMaskToPixelData
 };
-var mutatorBlendPixelDataAlphaMask = ((writer, deps = defaults5) => {
+var mutatorApplyAlphaMask = ((writer, deps = defaults2) => {
   const {
-    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults5.blendPixelDataAlphaMask
+    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults2.applyAlphaMaskToPixelData
   } = deps;
   return {
-    blendPixelDataAlphaMask(src, mask, opts = {}) {
-      const x = opts.x ?? 0;
-      const y = opts.y ?? 0;
-      const w = opts.w ?? src.width;
-      const h = opts.h ?? src.height;
+    applyAlphaMask(mask, opts) {
+      const target = writer.config.target;
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? target.width;
+      const h = opts?.h ?? target.height;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(blendPixelDataAlphaMask2(writer.config.target, src, mask, opts));
+      return didChange(applyAlphaMaskToPixelData2(target, mask, opts));
     }
   };
 });
 
-// src/PixelData/blendPixelDataBinaryMask.ts
-function blendPixelDataBinaryMask(dst, src, binaryMask, 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 = sourceOverPerfect,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
+// src/PixelData/applyBinaryMaskToPixelData.ts
+function applyBinaryMaskToPixelData(target, mask, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const width = opts?.w ?? target.width;
+  const height = opts?.h ?? target.height;
+  const globalAlpha = opts?.alpha ?? 255;
+  const mx = opts?.mx ?? 0;
+  const my = opts?.my ?? 0;
+  const invertMask = opts?.invertMask ?? false;
   if (globalAlpha === 0) return false;
   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;
   }
-  const actualW = Math.min(w, dst.width - x);
-  const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return false;
-  const dx = x - targetX | 0;
-  const dy = y - targetY | 0;
-  const dst32 = dst.data32;
-  const src32 = src.data32;
-  const dw = dst.width;
-  const sw = src.width;
-  const mPitch = binaryMask.w;
-  const maskData = binaryMask.data;
-  let dIdx = y * dw + x | 0;
-  let sIdx = sy * sw + sx | 0;
-  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
-  const dStride = dw - actualW | 0;
-  const sStride = sw - actualW | 0;
-  const mStride = mPitch - actualW | 0;
-  const skipVal = invertMask ? 1 : 0;
-  const isOpaque = globalAlpha === 255;
-  const isOverwrite = blendFn.isOverwrite || false;
-  let didChange = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      if (maskData[mIdx] === skipVal) {
-        dIdx++;
-        sIdx++;
+  w = Math.min(w, target.width - x);
+  h = Math.min(h, target.height - y);
+  if (w <= 0 || h <= 0) return false;
+  const mPitch = mask.w;
+  if (mPitch <= 0) return false;
+  const startX = mx + (x - targetX);
+  const startY = my + (y - targetY);
+  const sX0 = Math.max(0, startX);
+  const sY0 = Math.max(0, startY);
+  const sX1 = Math.min(mPitch, startX + w);
+  const sY1 = Math.min(mask.h, startY + h);
+  const finalW = sX1 - sX0;
+  const finalH = sY1 - sY0;
+  if (finalW <= 0 || finalH <= 0) {
+    return false;
+  }
+  const xShift = sX0 - startX;
+  const yShift = sY0 - startY;
+  const dst32 = target.data32;
+  const dw = target.width;
+  const dStride = dw - finalW;
+  const mStride = mPitch - finalW;
+  const maskData = mask.data;
+  let dIdx = (y + yShift) * dw + (x + xShift);
+  let mIdx = sY0 * mPitch + sX0;
+  let didChange = false;
+  for (let iy = 0; iy < finalH; iy++) {
+    for (let ix = 0; ix < finalW; ix++) {
+      const mVal = maskData[mIdx];
+      const isMaskedOut = invertMask ? mVal !== 0 : mVal === 0;
+      if (isMaskedOut) {
+        const current = dst32[dIdx];
+        const next = (current & 16777215) >>> 0;
+        if (current !== next) {
+          dst32[dIdx] = next;
+          didChange = true;
+        }
+      } else if (globalAlpha !== 255) {
+        const d = dst32[dIdx];
+        const da = d >>> 24;
+        if (da !== 0) {
+          const finalAlpha = da === 255 ? globalAlpha : da * globalAlpha + 128 >> 8;
+          const next = (d & 16777215 | finalAlpha << 24) >>> 0;
+          if (d !== next) {
+            dst32[dIdx] = next;
+            didChange = true;
+          }
+        }
+      }
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+  return didChange;
+}
+
+// src/History/PixelMutator/mutatorApplyBinaryMask.ts
+var defaults3 = {
+  applyBinaryMaskToPixelData
+};
+var mutatorApplyBinaryMask = ((writer, deps = defaults3) => {
+  const {
+    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults3.applyBinaryMaskToPixelData
+  } = deps;
+  return {
+    applyBinaryMask(mask, opts) {
+      const target = writer.config.target;
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? target.width;
+      const h = opts?.h ?? target.height;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(applyBinaryMaskToPixelData2(target, mask, opts));
+    }
+  };
+});
+
+// src/History/PixelMutator/mutatorApplyMask.ts
+var defaults4 = {
+  applyBinaryMaskToPixelData,
+  applyAlphaMaskToPixelData
+};
+var mutatorApplyMask = ((writer, deps = defaults4) => {
+  const {
+    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults4.applyBinaryMaskToPixelData,
+    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults4.applyAlphaMaskToPixelData
+  } = deps;
+  return {
+    applyMask(mask, opts) {
+      const target = writer.config.target;
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? target.width;
+      const h = opts?.h ?? target.height;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      if (mask.type === 1 /* BINARY */) {
+        return didChange(applyBinaryMaskToPixelData2(target, mask, opts));
+      } else {
+        return didChange(applyAlphaMaskToPixelData2(target, mask, opts));
+      }
+    }
+  };
+});
+
+// src/PixelData/blendPixelDataAlphaMask.ts
+function blendPixelDataAlphaMask(target, src, alphaMask, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const sourceX = opts?.sx ?? 0;
+  const sourceY = opts?.sy ?? 0;
+  const width = opts?.w ?? src.width;
+  const height = opts?.h ?? src.height;
+  const globalAlpha = opts?.alpha ?? 255;
+  const blendFn = opts?.blendFn ?? sourceOverPerfect;
+  const mx = opts?.mx ?? 0;
+  const my = opts?.my ?? 0;
+  const invertMask = opts?.invertMask ?? false;
+  if (globalAlpha === 0) return false;
+  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;
+  }
+  const actualW = Math.min(w, target.width - x);
+  const actualH = Math.min(h, target.height - y);
+  if (actualW <= 0 || actualH <= 0) return false;
+  const dw = target.width;
+  const sw = src.width;
+  const mPitch = alphaMask.w;
+  const maskData = alphaMask.data;
+  const dx = x - targetX | 0;
+  const dy = y - targetY | 0;
+  const dst32 = target.data32;
+  const src32 = src.data32;
+  let dIdx = y * dw + x | 0;
+  let sIdx = sy * sw + sx | 0;
+  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
+  const dStride = dw - actualW | 0;
+  const sStride = sw - actualW | 0;
+  const mStride = mPitch - actualW | 0;
+  const isOpaque = globalAlpha === 255;
+  const isOverwrite = blendFn.isOverwrite || false;
+  let didChange = false;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      const mVal = maskData[mIdx];
+      const effM = invertMask ? 255 - mVal : mVal;
+      if (effM === 0) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
+      }
+      const srcCol = src32[sIdx];
+      const srcAlpha = srcCol >>> 24;
+      if (srcAlpha === 0 && !isOverwrite) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
+      }
+      let weight = globalAlpha;
+      if (isOpaque) {
+        weight = effM;
+      } else if (effM !== 255) {
+        weight = effM * globalAlpha + 128 >> 8;
+      }
+      if (weight === 0) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
+      }
+      let finalCol = srcCol;
+      if (weight < 255) {
+        const a = srcAlpha * weight + 128 >> 8;
+        if (a === 0 && !isOverwrite) {
+          dIdx++;
+          sIdx++;
+          mIdx++;
+          continue;
+        }
+        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
+      }
+      const current = dst32[dIdx];
+      const next = blendFn(finalCol, dst32[dIdx]);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
+      }
+      dIdx++;
+      sIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    sIdx += sStride;
+    mIdx += mStride;
+  }
+  return didChange;
+}
+
+// src/History/PixelMutator/mutatorBlendAlphaMask.ts
+var defaults5 = {
+  blendPixelDataAlphaMask
+};
+var mutatorBlendAlphaMask = ((writer, deps = defaults5) => {
+  const {
+    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults5.blendPixelDataAlphaMask
+  } = deps;
+  return {
+    blendAlphaMask(src, mask, opts) {
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? src.width;
+      const h = opts?.h ?? src.height;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendPixelDataAlphaMask2(writer.config.target, src, mask, opts));
+    }
+  };
+});
+
+// src/PixelData/blendPixelDataBinaryMask.ts
+function blendPixelDataBinaryMask(target, src, binaryMask, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const sourceX = opts?.sx ?? 0;
+  const sourceY = opts?.sy ?? 0;
+  const width = opts?.w ?? src.width;
+  const height = opts?.h ?? src.height;
+  const globalAlpha = opts?.alpha ?? 255;
+  const blendFn = opts?.blendFn ?? sourceOverPerfect;
+  const mx = opts?.mx ?? 0;
+  const my = opts?.my ?? 0;
+  const invertMask = opts?.invertMask ?? false;
+  if (globalAlpha === 0) return false;
+  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;
+  }
+  const actualW = Math.min(w, target.width - x);
+  const actualH = Math.min(h, target.height - y);
+  if (actualW <= 0 || actualH <= 0) return false;
+  const dx = x - targetX | 0;
+  const dy = y - targetY | 0;
+  const dst32 = target.data32;
+  const src32 = src.data32;
+  const dw = target.width;
+  const sw = src.width;
+  const mPitch = binaryMask.w;
+  const maskData = binaryMask.data;
+  let dIdx = y * dw + x | 0;
+  let sIdx = sy * sw + sx | 0;
+  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
+  const dStride = dw - actualW | 0;
+  const sStride = sw - actualW | 0;
+  const mStride = mPitch - actualW | 0;
+  const skipVal = invertMask ? 1 : 0;
+  const isOpaque = globalAlpha === 255;
+  const isOverwrite = blendFn.isOverwrite || false;
+  let didChange = false;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      if (maskData[mIdx] === skipVal) {
+        dIdx++;
+        sIdx++;
         mIdx++;
         continue;
       }
@@ -2470,956 +2954,744 @@ function blendPixelDataBinaryMask(dst, src, binaryMask, opts = {}) {
   return didChange;
 }
 
-// src/History/PixelMutator/mutatorBlendPixelDataBinaryMask.ts
+// src/History/PixelMutator/mutatorBlendBinaryMask.ts
 var defaults6 = {
   blendPixelDataBinaryMask
 };
-var mutatorBlendPixelDataBinaryMask = ((writer, deps = defaults6) => {
+var mutatorBlendBinaryMask = ((writer, deps = defaults6) => {
   const {
     blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults6.blendPixelDataBinaryMask
   } = deps;
   return {
-    blendPixelDataBinaryMask(src, mask, opts = {}) {
-      const x = opts.x ?? 0;
-      const y = opts.y ?? 0;
-      const w = opts.w ?? src.width;
-      const h = opts.h ?? src.height;
+    blendBinaryMask(src, mask, opts) {
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? src.width;
+      const h = opts?.h ?? src.height;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(blendPixelDataBinaryMask2(writer.config.target, src, mask, opts));
     }
   };
 });
 
-// src/PixelData/fillPixelDataFast.ts
-var SCRATCH_RECT = makeClippedRect();
-function fillPixelDataFast(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 {
+// src/PixelData/blendColorPixelData.ts
+function blendColorPixelData(target, color, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const width = opts?.w ?? target.width;
+  const height = opts?.h ?? target.height;
+  const globalAlpha = opts?.alpha ?? 255;
+  const blendFn = opts?.blendFn ?? sourceOverPerfect;
+  if (globalAlpha === 0) return false;
+  const baseSrcAlpha = color >>> 24;
+  const isOverwrite = blendFn.isOverwrite || false;
+  if (baseSrcAlpha === 0 && !isOverwrite) return false;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
     x = 0;
+  }
+  if (y < 0) {
+    h += y;
     y = 0;
-    w = dst.width;
-    h = dst.height;
   }
-  const clip = resolveRectClipping(x, y, w, h, dst.width, dst.height, SCRATCH_RECT);
-  if (!clip.inBounds) return;
-  const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH
-  } = clip;
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  if (actualW === dw && actualH === dst.height && finalX === 0 && finalY === 0) {
-    dst32.fill(color);
-    return;
+  const actualW = Math.min(w, target.width - x);
+  const actualH = Math.min(h, target.height - y);
+  if (actualW <= 0 || actualH <= 0) return false;
+  let finalSrcColor = color;
+  if (globalAlpha < 255) {
+    const a = baseSrcAlpha * globalAlpha + 128 >> 8;
+    if (a === 0 && !isOverwrite) return false;
+    finalSrcColor = (color & 16777215 | a << 24) >>> 0;
   }
+  const dst32 = target.data32;
+  const dw = target.width;
+  let dIdx = y * dw + x | 0;
+  const dStride = dw - actualW | 0;
+  let didChange = false;
   for (let iy = 0; iy < actualH; iy++) {
-    const start = (finalY + iy) * dw + finalX;
-    const end = start + actualW;
-    dst32.fill(color, start, end);
+    for (let ix = 0; ix < actualW; ix++) {
+      const current = dst32[dIdx];
+      const next = blendFn(finalSrcColor, current);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
+      }
+      dIdx++;
+    }
+    dIdx += dStride;
   }
+  return didChange;
 }
 
-// src/History/PixelMutator/mutatorClear.ts
+// src/History/PixelMutator/mutatorBlendColor.ts
 var defaults7 = {
-  fillPixelData: fillPixelDataFast
+  blendColorPixelData
 };
-var mutatorClear = ((writer, deps = defaults7) => {
+var mutatorBlendColor = ((writer, deps = defaults7) => {
   const {
-    fillPixelData: fillPixelData2 = defaults7.fillPixelData
+    blendColorPixelData: blendColorPixelData2 = defaults7.blendColorPixelData
   } = deps;
   return {
-    clear(rect = {}) {
+    blendColor(color, opts) {
       const target = writer.config.target;
-      const x = rect.x ?? 0;
-      const y = rect.y ?? 0;
-      const w = rect.w ?? target.width;
-      const h = rect.h ?? target.height;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      fillPixelData2(target, 0, x, y, w, h);
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? target.width;
+      const h = opts?.h ?? target.height;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendColorPixelData2(target, color, opts));
     }
   };
 });
 
-// src/PixelData/fillPixelData.ts
-var SCRATCH_RECT2 = makeClippedRect();
-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 {
+// src/PixelData/blendColorPixelDataAlphaMask.ts
+function blendColorPixelDataAlphaMask(target, color, mask, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const w = opts?.w ?? mask.w;
+  const h = opts?.h ?? mask.h;
+  const globalAlpha = opts?.alpha ?? 255;
+  const blendFn = opts?.blendFn ?? sourceOverPerfect;
+  const mx = opts?.mx ?? 0;
+  const my = opts?.my ?? 0;
+  const invertMask = opts?.invertMask ?? false;
+  if (globalAlpha === 0) return false;
+  const baseSrcAlpha = color >>> 24;
+  const isOverwrite = blendFn.isOverwrite || false;
+  if (baseSrcAlpha === 0 && !isOverwrite) return false;
+  let x = targetX;
+  let y = targetY;
+  let actualW = w;
+  let actualH = h;
+  if (x < 0) {
+    actualW += x;
     x = 0;
+  }
+  if (y < 0) {
+    actualH += y;
     y = 0;
-    w = dst.width;
-    h = dst.height;
   }
-  const clip = resolveRectClipping(x, y, w, h, dst.width, dst.height, SCRATCH_RECT2);
-  if (!clip.inBounds) return false;
-  const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH
-  } = clip;
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  let hasChanged = false;
+  actualW = Math.min(actualW, target.width - x);
+  actualH = Math.min(actualH, target.height - y);
+  if (actualW <= 0 || actualH <= 0) return false;
+  const dx = x - targetX | 0;
+  const dy = y - targetY | 0;
+  const dst32 = target.data32;
+  const dw = target.width;
+  const mPitch = mask.w;
+  const maskData = mask.data;
+  let dIdx = y * dw + x | 0;
+  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
+  const dStride = dw - actualW | 0;
+  const mStride = mPitch - actualW | 0;
+  const isOpaque = globalAlpha === 255;
+  const colorRGB = color & 16777215;
+  let didChange = false;
   for (let iy = 0; iy < actualH; iy++) {
-    const rowOffset = (finalY + iy) * dw;
-    const start = rowOffset + finalX;
-    const end = start + actualW;
-    for (let i = start; i < end; i++) {
-      if (dst32[i] !== color) {
-        dst32[i] = color;
-        hasChanged = true;
+    for (let ix = 0; ix < actualW; ix++) {
+      const mVal = maskData[mIdx];
+      const effM = invertMask ? 255 - mVal : mVal;
+      if (effM === 0) {
+        dIdx++;
+        mIdx++;
+        continue;
+      }
+      let weight = globalAlpha;
+      if (isOpaque) {
+        weight = effM;
+      } else if (effM !== 255) {
+        weight = effM * globalAlpha + 128 >> 8;
+      }
+      if (weight === 0) {
+        dIdx++;
+        mIdx++;
+        continue;
+      }
+      let finalCol = color;
+      if (weight < 255) {
+        const a = baseSrcAlpha * weight + 128 >> 8;
+        if (a === 0 && !isOverwrite) {
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        finalCol = (colorRGB | a << 24) >>> 0;
+      }
+      const current = dst32[dIdx];
+      const next = blendFn(finalCol, current);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
       }
+      dIdx++;
+      mIdx++;
     }
+    dIdx += dStride;
+    mIdx += mStride;
   }
-  return hasChanged;
+  return didChange;
 }
 
-// src/History/PixelMutator/mutatorFill.ts
+// src/History/PixelMutator/mutatorBlendColorPaintAlphaMask.ts
 var defaults8 = {
-  fillPixelData
+  blendColorPixelDataAlphaMask
 };
-var mutatorFill = ((writer, deps = defaults8) => {
+var mutatorBlendColorPaintAlphaMask = ((writer, deps = defaults8) => {
   const {
-    fillPixelData: fillPixelData2 = defaults8.fillPixelData
+    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults8.blendColorPixelDataAlphaMask
   } = deps;
+  const OPTS = {
+    x: 0,
+    y: 0,
+    blendFn: sourceOverPerfect,
+    alpha: 255
+  };
   return {
-    fill(color, x = 0, y = 0, w = writer.config.target.width, h = writer.config.target.height) {
-      const target = writer.config.target;
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(fillPixelData2(target, color, x, y, w, h));
+    blendColorPaintAlphaMask(color, mask, x, y, alpha = 255, blendFn = sourceOverPerfect) {
+      const tx = x + mask.centerOffsetX;
+      const ty = y + mask.centerOffsetY;
+      const didChange = writer.accumulator.storeRegionBeforeState(tx, ty, mask.w, mask.h);
+      OPTS.x = tx;
+      OPTS.y = ty;
+      OPTS.alpha = alpha;
+      OPTS.blendFn = blendFn;
+      return didChange(blendColorPixelDataAlphaMask2(writer.config.target, color, mask, OPTS));
     }
   };
 });
-var mutatorFillRect = ((writer, deps = defaults8) => {
+
+// src/PixelData/blendColorPixelDataBinaryMask.ts
+function blendColorPixelDataBinaryMask(target, color, mask, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  let w = opts?.w ?? mask.w;
+  let h = opts?.h ?? mask.h;
+  const globalAlpha = opts?.alpha ?? 255;
+  const blendFn = opts?.blendFn ?? sourceOverPerfect;
+  const mx = opts?.mx ?? 0;
+  const my = opts?.my ?? 0;
+  const invertMask = opts?.invertMask ?? false;
+  if (globalAlpha === 0) return false;
+  const baseSrcAlpha = color >>> 24;
+  const isOverwrite = blendFn.isOverwrite || false;
+  if (baseSrcAlpha === 0 && !isOverwrite) return false;
+  let x = targetX;
+  let y = targetY;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, target.width - x);
+  const actualH = Math.min(h, target.height - y);
+  if (actualW <= 0 || actualH <= 0) return false;
+  let baseColorWithGlobalAlpha = color;
+  if (globalAlpha < 255) {
+    const a = baseSrcAlpha * globalAlpha + 128 >> 8;
+    if (a === 0 && !isOverwrite) return false;
+    baseColorWithGlobalAlpha = (color & 16777215 | a << 24) >>> 0;
+  }
+  const dx = x - targetX | 0;
+  const dy = y - targetY | 0;
+  const dst32 = target.data32;
+  const dw = target.width;
+  const mPitch = mask.w;
+  const maskData = mask.data;
+  let dIdx = y * dw + x | 0;
+  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
+  const dStride = dw - actualW | 0;
+  const mStride = mPitch - actualW | 0;
+  const skipVal = invertMask ? 1 : 0;
+  let didChange = false;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      if (maskData[mIdx] === skipVal) {
+        dIdx++;
+        mIdx++;
+        continue;
+      }
+      const current = dst32[dIdx];
+      const next = blendFn(baseColorWithGlobalAlpha, current);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
+      }
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+  return didChange;
+}
+
+// src/History/PixelMutator/mutatorBlendColorPaintBinaryMask.ts
+var defaults9 = {
+  blendColorPixelDataBinaryMask
+};
+var mutatorBlendColorPaintBinaryMask = ((writer, deps = defaults9) => {
   const {
-    fillPixelData: fillPixelData2 = defaults8.fillPixelData
+    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults9.blendColorPixelDataBinaryMask
   } = deps;
+  const OPTS = {
+    x: 0,
+    y: 0,
+    blendFn: sourceOverPerfect,
+    alpha: 255
+  };
   return {
-    fillRect(color, rect) {
-      const target = writer.config.target;
-      const didChange = writer.accumulator.storeRegionBeforeState(rect.x, rect.y, rect.w, rect.h);
-      return didChange(fillPixelData2(target, color, rect.x, rect.y, rect.w, rect.h));
+    blendColorPaintBinaryMask(color, mask, x, y, alpha = 255, blendFn = sourceOverPerfect) {
+      const tx = x + mask.centerOffsetX;
+      const ty = y + mask.centerOffsetY;
+      const didChange = writer.accumulator.storeRegionBeforeState(tx, ty, mask.w, mask.h);
+      OPTS.x = tx;
+      OPTS.y = ty;
+      OPTS.alpha = alpha;
+      OPTS.blendFn = blendFn;
+      return didChange(blendColorPixelDataBinaryMask2(writer.config.target, color, mask, OPTS));
     }
   };
 });
 
-// src/PixelData/fillPixelDataBinaryMask.ts
-var SCRATCH_RECT3 = makeClippedRect();
-function fillPixelDataBinaryMask(dst, color, mask, alpha = 255, x = 0, y = 0) {
-  if (alpha === 0) return false;
-  const maskW = mask.w;
-  const maskH = mask.h;
-  const clip = resolveRectClipping(x, y, maskW, maskH, dst.width, dst.height, SCRATCH_RECT3);
-  if (!clip.inBounds) return false;
-  const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH
-  } = clip;
-  const maskData = mask.data;
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  let finalCol = color;
-  if (alpha < 255) {
-    const baseSrcAlpha = color >>> 24;
-    const colorRGB = color & 16777215;
-    const a = baseSrcAlpha * alpha + 128 >> 8;
-    finalCol = (colorRGB | a << 24) >>> 0;
-  }
-  let hasChanged = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    const currentY = finalY + iy;
-    const maskY = currentY - y;
-    const maskOffset = maskY * maskW;
-    const dstRowOffset = currentY * dw;
-    for (let ix = 0; ix < actualW; ix++) {
-      const currentX = finalX + ix;
-      const maskX = currentX - x;
-      const maskIndex = maskOffset + maskX;
-      if (maskData[maskIndex]) {
-        const current = dst32[dstRowOffset + currentX];
-        if (current !== finalCol) {
-          dst32[dstRowOffset + currentX] = finalCol;
-          hasChanged = true;
-        }
-      }
-    }
-  }
-  return hasChanged;
-}
-
-// src/History/PixelMutator/mutatorFillBinaryMask.ts
-var defaults9 = {
-  fillPixelDataBinaryMask
+// src/History/PixelMutator/mutatorBlendColorPaintMask.ts
+var defaults10 = {
+  blendColorPixelDataAlphaMask,
+  blendColorPixelDataBinaryMask
 };
-var mutatorFillBinaryMask = ((writer, deps = defaults9) => {
+var mutatorBlendColorPaintMask = ((writer, deps = defaults10) => {
   const {
-    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults9.fillPixelDataBinaryMask
+    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults10.blendColorPixelDataBinaryMask,
+    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults10.blendColorPixelDataAlphaMask
   } = deps;
+  const OPTS = {
+    x: 0,
+    y: 0,
+    blendFn: sourceOverPerfect,
+    alpha: 255
+  };
   return {
-    fillBinaryMask(color, mask, alpha = 255, x = 0, y = 0) {
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, mask.w, mask.h);
-      return didChange(fillPixelDataBinaryMask2(writer.config.target, color, mask, alpha, x, y));
+    blendColorPaintMask(color, mask, x, y, alpha = 255, blendFn = sourceOverPerfect) {
+      const tx = x + mask.centerOffsetX;
+      const ty = y + mask.centerOffsetY;
+      const didChange = writer.accumulator.storeRegionBeforeState(tx, ty, mask.w, mask.h);
+      OPTS.x = tx;
+      OPTS.y = ty;
+      OPTS.alpha = alpha;
+      OPTS.blendFn = blendFn;
+      if (mask.type === 1 /* BINARY */) {
+        return didChange(blendColorPixelDataBinaryMask2(writer.config.target, color, mask, OPTS));
+      } else {
+        return didChange(blendColorPixelDataAlphaMask2(writer.config.target, color, mask, OPTS));
+      }
     }
   };
 });
 
-// src/PixelData/invertPixelData.ts
-var SCRATCH_RECT4 = makeClippedRect();
-function invertPixelData(pixelData, opts = {}) {
-  const dst = pixelData;
-  const {
-    x: targetX = 0,
-    y: targetY = 0,
-    w: width = pixelData.width,
-    h: height = pixelData.height,
-    mask,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
-  const clip = resolveRectClipping(targetX, targetY, width, height, dst.width, dst.height, SCRATCH_RECT4);
-  if (!clip.inBounds) return false;
+// src/History/PixelMutator/mutatorBlendMask.ts
+var defaults11 = {
+  blendPixelDataAlphaMask,
+  blendPixelDataBinaryMask
+};
+var mutatorBlendMask = ((writer, deps = defaults11) => {
   const {
-    x,
-    y,
-    w: actualW,
-    h: actualH
-  } = clip;
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  const mPitch = mask?.w ?? width;
-  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;
-  if (mask) {
-    const maskData = mask.data;
-    for (let iy = 0; iy < actualH; iy++) {
-      for (let ix = 0; ix < actualW; ix++) {
-        const mVal = maskData[mIdx];
-        const isHit = invertMask ? mVal === 0 : mVal === 1;
-        if (isHit) {
-          dst32[dIdx] = dst32[dIdx] ^ 16777215;
-        }
-        dIdx++;
-        mIdx++;
-      }
-      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++;
+    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults11.blendPixelDataAlphaMask,
+    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults11.blendPixelDataBinaryMask
+  } = deps;
+  return {
+    blendMask(src, mask, opts) {
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? src.width;
+      const h = opts?.h ?? src.height;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      if (mask.type === 1 /* BINARY */) {
+        return didChange(blendPixelDataBinaryMask2(writer.config.target, src, mask, opts));
+      } else {
+        return didChange(blendPixelDataAlphaMask2(writer.config.target, src, mask, opts));
       }
-      dIdx += dStride;
     }
-  }
-  return true;
-}
+  };
+});
 
-// src/History/PixelMutator/mutatorInvert.ts
-var defaults10 = {
-  invertPixelData
+// src/History/PixelMutator/mutatorBlendPaintRect.ts
+var defaults12 = {
+  blendColorPixelData
 };
-var mutatorInvert = ((writer, deps = defaults10) => {
+var mutatorBlendPaintRect = ((writer, deps = defaults12) => {
   const {
-    invertPixelData: invertPixelData2 = defaults10.invertPixelData
+    blendColorPixelData: blendColorPixelData2 = defaults12.blendColorPixelData
   } = deps;
+  const OPTS = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0,
+    blendFn: sourceOverPerfect,
+    alpha: 255
+  };
   return {
-    invert(opts = {}) {
+    blendPaintRect(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, blendFn = sourceOverPerfect) {
       const target = writer.config.target;
-      const {
-        x = 0,
-        y = 0,
-        w = target.width,
-        h = target.height
-      } = opts;
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(invertPixelData2(target, opts));
+      const topLeftX = centerX + -(brushWidth - 1 >> 1);
+      const topLeftY = centerY + -(brushHeight - 1 >> 1);
+      OPTS.x = topLeftX;
+      OPTS.y = topLeftY;
+      OPTS.w = brushWidth;
+      OPTS.h = brushHeight;
+      OPTS.blendFn = blendFn;
+      OPTS.alpha = alpha;
+      const didChange = writer.accumulator.storeRegionBeforeState(topLeftX, topLeftY, brushWidth, brushHeight);
+      return didChange(blendColorPixelData2(target, color, OPTS));
     }
   };
 });
 
-// src/History/PixelMutator.ts
-function makeFullPixelMutator(writer) {
-  return {
-    // @sort
-    ...mutatorBlendColor(writer),
-    ...mutatorBlendPixel(writer),
-    ...mutatorBlendPixelData(writer),
-    ...mutatorBlendPixelDataAlphaMask(writer),
-    ...mutatorBlendPixelDataBinaryMask(writer),
-    ...mutatorClear(writer),
-    ...mutatorFill(writer),
-    ...mutatorFillBinaryMask(writer),
-    ...mutatorFillRect(writer),
-    ...mutatorInvert(writer)
-  };
-}
-
-// src/ImageData/resizeImageData.ts
-function resizeImageData(target, newWidth, newHeight, offsetX = 0, offsetY = 0) {
-  const result = new ImageData(newWidth, newHeight);
-  const {
-    width: oldW,
-    height: oldH,
-    data: oldData
-  } = target;
-  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;
+// src/PixelData/blendPixel.ts
+function blendPixel(target, x, y, color, alpha = 255, blendFn = sourceOverPerfect) {
+  if (alpha === 0) return false;
+  let width = target.width;
+  let height = target.height;
+  if (x < 0 || x >= width || y < 0 || y >= height) return false;
+  let srcAlpha = color >>> 24;
+  let isOverwrite = blendFn.isOverwrite;
+  if (srcAlpha === 0 && !isOverwrite) return false;
+  let dst32 = target.data32;
+  let index = y * width + x;
+  let finalColor = color;
+  if (alpha !== 255) {
+    let finalAlpha = srcAlpha * alpha + 128 >> 8;
+    if (finalAlpha === 0 && !isOverwrite) return false;
+    finalColor = (color & 16777215 | finalAlpha << 24) >>> 0;
   }
-  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);
+  let current = dst32[index];
+  let next = blendFn(finalColor, current);
+  if (current !== next) {
+    dst32[index] = next;
+    return true;
   }
-  return result;
+  return false;
 }
 
-// src/Internal/helpers.ts
-var macro_halfAndFloor = (value) => value >> 1;
+// src/History/PixelMutator/mutatorBlendPixel.ts
+var defaults13 = {
+  blendPixel
+};
+var mutatorBlendPixel = ((writer, deps = defaults13) => {
+  const {
+    blendPixel: blendPixel2 = defaults13.blendPixel
+  } = deps;
+  return {
+    blendPixel(x, y, color, alpha, blendFn) {
+      const didChange = writer.accumulator.storePixelBeforeState(x, y);
+      return didChange(blendPixel2(writer.config.target, x, y, color, alpha, blendFn));
+    }
+  };
+});
 
-// src/Rect/trimRectBounds.ts
-function trimRectBounds(x, y, w, h, targetWidth, targetHeight, out) {
-  const res = out ?? {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
+// src/History/PixelMutator/mutatorBlendPixelData.ts
+var defaults14 = {
+  blendPixelData
+};
+var mutatorBlendPixelData = ((writer, deps = defaults14) => {
+  const {
+    blendPixelData: blendPixelData2 = defaults14.blendPixelData
+  } = deps;
+  return {
+    blendPixelData(src, opts) {
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? src.width;
+      const h = opts?.h ?? src.height;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendPixelData2(writer.config.target, src, opts));
+    }
   };
-  const left = Math.max(0, x);
-  const top = Math.max(0, y);
-  const right = Math.min(targetWidth, x + w);
-  const bottom = Math.min(targetHeight, y + h);
-  res.x = left;
-  res.y = top;
-  res.w = Math.max(0, right - left);
-  res.h = Math.max(0, bottom - top);
-  return res;
-}
+});
 
-// src/Paint/PaintBuffer.ts
-var PaintBuffer = class {
-  constructor(config, tilePool) {
-    this.config = config;
-    this.tilePool = tilePool;
-    this.lookup = [];
+// src/PixelData/fillPixelData.ts
+var SCRATCH_RECT = makeClippedRect();
+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;
   }
-  lookup;
-  scratchBounds = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  eachTileInBounds(bounds, callback) {
-    const {
-      tileShift,
-      targetColumns,
-      targetRows,
-      tileSize
-    } = this.config;
-    const x1 = Math.max(0, bounds.x >> tileShift);
-    const y1 = Math.max(0, bounds.y >> tileShift);
-    const x2 = Math.min(targetColumns - 1, bounds.x + bounds.w - 1 >> tileShift);
-    const y2 = Math.min(targetRows - 1, bounds.y + bounds.h - 1 >> tileShift);
-    if (x1 > x2 || y1 > y2) return;
-    const lookup = this.lookup;
-    const tilePool = this.tilePool;
-    for (let ty = y1; ty <= y2; ty++) {
-      const rowOffset = ty * targetColumns;
-      const tileTop = ty << tileShift;
-      for (let tx = x1; tx <= x2; tx++) {
-        const id = rowOffset + tx;
-        const tile = lookup[id] ?? (lookup[id] = tilePool.getTile(id, tx, ty));
-        const tileLeft = tx << tileShift;
-        const startX = bounds.x > tileLeft ? bounds.x : tileLeft;
-        const startY = bounds.y > tileTop ? bounds.y : tileTop;
-        const maskEndX = bounds.x + bounds.w;
-        const tileEndX = tileLeft + tileSize;
-        const endX = maskEndX < tileEndX ? maskEndX : tileEndX;
-        const maskEndY = bounds.y + bounds.h;
-        const tileEndY = tileTop + tileSize;
-        const endY = maskEndY < tileEndY ? maskEndY : tileEndY;
-        callback(tile, startX, startY, endX - startX, endY - startY);
-      }
-    }
-  }
-  writePaintAlphaMaskStroke(color, brush, x0, y0, x1, y1) {
-    const cA = color >>> 24;
-    if (cA === 0) return false;
-    const {
-      tileShift,
-      tileMask,
-      target
-    } = this.config;
-    const {
-      w: bW,
-      h: bH,
-      data: bD,
-      centerOffsetX,
-      centerOffsetY
-    } = brush;
-    const cRGB = color & 16777215;
-    const scratch = this.scratchBounds;
-    let changed = false;
-    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
-      const topLeftX = Math.floor(px + centerOffsetX);
-      const topLeftY = Math.floor(py + centerOffsetY);
-      trimRectBounds(topLeftX, topLeftY, bW, bH, target.width, target.height, scratch);
-      if (scratch.w <= 0 || scratch.h <= 0) return;
-      this.eachTileInBounds(scratch, (tile, bX, bY, bW_t, bH_t) => {
-        const d32 = tile.data32;
-        let tileChanged = false;
-        for (let i = 0; i < bH_t; i++) {
-          const canvasY = bY + i;
-          const bOff = (canvasY - topLeftY) * bW;
-          const tOff = (canvasY & tileMask) << tileShift;
-          const dS = tOff + (bX & tileMask);
-          for (let j = 0; j < bW_t; j++) {
-            const canvasX = bX + j;
-            const brushA = bD[bOff + (canvasX - topLeftX)];
-            if (brushA === 0) continue;
-            const t = cA * brushA + 128;
-            const blendedA = t + (t >> 8) >> 8;
-            const idx = dS + j;
-            const cur = d32[idx];
-            if (brushA > cur >>> 24) {
-              const next = (cRGB | blendedA << 24) >>> 0;
-              if (cur !== next) {
-                d32[idx] = next;
-                tileChanged = true;
-              }
-            }
-          }
-        }
-        if (tileChanged) changed = true;
-      });
-    });
-    return changed;
-  }
-  writePaintBinaryMaskStroke(color, brush, x0, y0, x1, y1) {
-    const alphaIsZero = color >>> 24 === 0;
-    if (alphaIsZero) return false;
-    const {
-      tileShift,
-      tileMask,
-      target
-    } = this.config;
-    const {
-      w: bW,
-      h: bH,
-      data: bD,
-      centerOffsetX,
-      centerOffsetY
-    } = brush;
-    const scratch = this.scratchBounds;
-    let changed = false;
-    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
-      const topLeftX = Math.floor(px + centerOffsetX);
-      const topLeftY = Math.floor(py + centerOffsetY);
-      trimRectBounds(topLeftX, topLeftY, bW, bH, target.width, target.height, scratch);
-      if (scratch.w <= 0 || scratch.h <= 0) return;
-      this.eachTileInBounds(scratch, (tile, bX, bY, bW_t, bH_t) => {
-        const d32 = tile.data32;
-        let tileChanged = false;
-        for (let i = 0; i < bH_t; i++) {
-          const canvasY = bY + i;
-          const bOff = (canvasY - topLeftY) * bW;
-          const tOff = (canvasY & tileMask) << tileShift;
-          const dS = tOff + (bX & tileMask);
-          for (let j = 0; j < bW_t; j++) {
-            const canvasX = bX + j;
-            if (bD[bOff + (canvasX - topLeftX)]) {
-              const idx = dS + j;
-              if (d32[idx] !== color) {
-                d32[idx] = color;
-                tileChanged = true;
-              }
-            }
-          }
-        }
-        if (tileChanged) changed = true;
-      });
-    });
-    return changed;
-  }
-  writeRectStroke(color, brushWidth, brushHeight, x0, y0, x1, y1) {
-    const alphaIsZero = color >>> 24 === 0;
-    if (alphaIsZero) return false;
-    const config = this.config;
-    const tileShift = config.tileShift;
-    const tileMask = config.tileMask;
-    const target = config.target;
-    const scratch = this.scratchBounds;
-    const centerOffsetX = macro_halfAndFloor(brushWidth - 1);
-    const centerOffsetY = macro_halfAndFloor(brushHeight - 1);
-    let changed = false;
-    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
-      const topLeftX = Math.floor(px + centerOffsetX);
-      const topLeftY = Math.floor(py + centerOffsetY);
-      trimRectBounds(topLeftX, topLeftY, brushWidth, brushHeight, target.width, target.height, scratch);
-      if (scratch.w <= 0 || scratch.h <= 0) return;
-      this.eachTileInBounds(scratch, (tile, bX, bY, bW_t, bH_t) => {
-        const d32 = tile.data32;
-        let tileChanged = false;
-        for (let i = 0; i < bH_t; i++) {
-          const canvasY = bY + i;
-          const tOff = (canvasY & tileMask) << tileShift;
-          const dS = tOff + (bX & tileMask);
-          for (let j = 0; j < bW_t; j++) {
-            const idx = dS + j;
-            if (d32[idx] !== color) {
-              d32[idx] = color;
-              tileChanged = true;
-            }
-          }
-        }
-        if (tileChanged) {
-          changed = true;
-        }
-      });
-    });
-    return changed;
-  }
-  clear() {
-    this.tilePool.releaseTiles(this.lookup);
-  }
-};
-
-// src/PixelTile/PixelTile.ts
-var PixelTile = class {
-  constructor(id, tx, ty, tileSize, tileArea) {
-    this.id = id;
-    this.tx = tx;
-    this.ty = ty;
-    this.width = this.height = tileSize;
-    this.data32 = new Uint32Array(tileArea);
-    const data8 = new Uint8ClampedArray(this.data32.buffer);
-    this.imageData = new ImageData(data8, tileSize, tileSize);
-  }
-  data32;
-  width;
-  height;
-  imageData;
-};
-
-// src/PixelTile/PixelTilePool.ts
-var PixelTilePool = class {
-  pool;
-  tileSize;
-  tileArea;
-  constructor(config) {
-    this.pool = [];
-    this.tileSize = config.tileSize;
-    this.tileArea = config.tileArea;
-  }
-  getTile(id, tx, ty) {
-    let tile = this.pool.pop();
-    if (tile) {
-      tile.id = id;
-      tile.tx = tx;
-      tile.ty = ty;
-      tile.data32.fill(0);
-      return tile;
-    }
-    return new PixelTile(id, tx, ty, this.tileSize, this.tileArea);
-  }
-  releaseTile(tile) {
-    this.pool.push(tile);
-  }
-  releaseTiles(tiles) {
-    let length = tiles.length;
-    for (let i = 0; i < length; i++) {
-      let tile = tiles[i];
-      if (tile) {
-        this.pool.push(tile);
-      }
-    }
-    tiles.length = 0;
-  }
-};
-
-// src/History/PixelWriter.ts
-var PixelWriter = class {
-  historyManager;
-  accumulator;
-  historyActionFactory;
-  config;
-  pixelTilePool;
-  paintBuffer;
-  mutator;
-  blendPixelDataOpts = {
-    alpha: 255,
-    blendFn: sourceOverPerfect,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  _inProgress = false;
-  constructor(target, mutatorFactory, {
-    tileSize = 256,
-    maxHistorySteps = 50,
-    historyManager = new HistoryManager(maxHistorySteps),
-    historyActionFactory = makeHistoryAction,
-    pixelTilePool,
-    accumulator
-  } = {}) {
-    this.config = new PixelEngineConfig(tileSize, target);
-    this.historyManager = historyManager;
-    this.pixelTilePool = pixelTilePool ?? new PixelTilePool(this.config);
-    this.accumulator = accumulator ?? new PixelAccumulator(this.config, this.pixelTilePool);
-    this.historyActionFactory = historyActionFactory;
-    this.mutator = mutatorFactory(this);
-    this.paintBuffer = new PaintBuffer(this.config, this.pixelTilePool);
-  }
-  /**
-   * Executes `transaction` and commits the resulting pixel changes as a single
-   * undoable history action.
-   *
-   * - If `transaction` throws, all accumulated changes are rolled back and the error
-   *   is re-thrown. No action is committed.
-   * - If `transaction` completes without modifying any pixels, no action is committed.
-   * - `withHistory` is not re-entrant. Calling it again from inside `transaction` will
-   *   throw immediately to prevent silent data loss from a nested extractPatch.
-   *
-   * @param transaction Callback to be executed inside the transaction.
-   * @param after    Called after both undo and redo — use for generic change notifications.
-   * @param afterUndo Called after undo only — use for dimension or state changes specific to undo.
-   * @param afterRedo Called after redo only.
-   */
-  withHistory(transaction, after, afterUndo, afterRedo) {
-    if (this._inProgress) {
-      throw new Error("withHistory is not re-entrant \u2014 commit or rollback the current operation first");
-    }
-    this._inProgress = true;
-    try {
-      transaction(this.mutator);
-    } catch (e) {
-      this.accumulator.rollbackAfterError();
-      throw e;
-    } finally {
-      this._inProgress = false;
-    }
-    if (this.accumulator.beforeTiles.length === 0) return;
-    const patch = this.accumulator.extractPatch();
-    const action = this.historyActionFactory(this, patch, after, afterUndo, afterRedo);
-    this.historyManager.commit(action);
-  }
-  resize(newWidth, newHeight, offsetX = 0, offsetY = 0, after, afterUndo, afterRedo, resizeImageDataFn = resizeImageData) {
-    if (this._inProgress) {
-      throw new Error("Cannot resize inside a withHistory callback");
-    }
-    if (this.accumulator.beforeTiles.length > 0) {
-      throw new Error("Cannot resize with an open accumulator \u2014 commit or rollback first");
-    }
-    const config = this.config;
-    const target = config.target;
-    const beforeImageData = target.imageData;
-    const afterImageData = resizeImageDataFn(beforeImageData, newWidth, newHeight, offsetX, offsetY);
-    target.set(afterImageData);
-    this.historyManager.commit({
-      undo: () => {
-        target.set(beforeImageData);
-        afterUndo?.(beforeImageData);
-        after?.(beforeImageData);
-      },
-      redo: () => {
-        target.set(afterImageData);
-        afterRedo?.(afterImageData);
-        after?.(afterImageData);
-      }
-    });
-  }
-  commitPaintBuffer(alpha = 255, blendFn = sourceOverPerfect, blendPixelDataFn = blendPixelData) {
-    const paintBuffer = this.paintBuffer;
-    const tileShift = paintBuffer.config.tileShift;
-    const lookup = paintBuffer.lookup;
-    const opts = this.blendPixelDataOpts;
-    opts.alpha = alpha;
-    opts.blendFn = blendFn;
-    for (let i = 0; i < lookup.length; i++) {
-      const tile = lookup[i];
-      if (tile) {
-        const didChange = this.accumulator.storeTileBeforeState(tile.id, tile.tx, tile.ty);
-        const dx = tile.tx << tileShift;
-        const dy = tile.ty << tileShift;
-        opts.x = dx;
-        opts.y = dy;
-        opts.w = tile.width;
-        opts.h = tile.height;
-        didChange(blendPixelDataFn(this.config.target, tile, opts));
-      }
-    }
-    paintBuffer.clear();
-  }
-};
-
-// src/PixelData/applyAlphaMaskToPixelData.ts
-function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
+  const clip = resolveRectClipping(x, y, w, h, dst.width, dst.height, SCRATCH_RECT);
+  if (!clip.inBounds) return false;
   const {
-    x: targetX = 0,
-    y: targetY = 0,
-    w: width = dst.width,
-    h: height = dst.height,
-    alpha: globalAlpha = 255,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
-  if (globalAlpha === 0) return false;
-  let x = targetX;
-  let y = targetY;
-  let w = width;
-  let h = height;
-  if (x < 0) {
-    w += x;
-    x = 0;
-  }
-  if (y < 0) {
-    h += y;
-    y = 0;
-  }
-  w = Math.min(w, dst.width - x);
-  h = Math.min(h, dst.height - y);
-  if (w <= 0) return false;
-  if (h <= 0) return false;
-  const mPitch = mask.w;
-  if (mPitch <= 0) return false;
-  const startX = mx + (x - targetX);
-  const startY = my + (y - targetY);
-  const sX0 = Math.max(0, startX);
-  const sY0 = Math.max(0, startY);
-  const sX1 = Math.min(mPitch, startX + w);
-  const sY1 = Math.min(mask.h, startY + h);
-  const finalW = sX1 - sX0;
-  const finalH = sY1 - sY0;
-  if (finalW <= 0) return false;
-  if (finalH <= 0) return false;
-  const xShift = sX0 - startX;
-  const yShift = sY0 - startY;
+    x: finalX,
+    y: finalY,
+    w: actualW,
+    h: actualH
+  } = clip;
   const dst32 = dst.data32;
   const dw = dst.width;
-  const dStride = dw - finalW;
-  const mStride = mPitch - finalW;
-  const maskData = mask.data;
-  let dIdx = (y + yShift) * dw + (x + xShift);
-  let mIdx = sY0 * mPitch + sX0;
-  let didChange = false;
-  for (let iy = 0; iy < h; iy++) {
-    for (let ix = 0; ix < w; ix++) {
-      const mVal = maskData[mIdx];
-      const effectiveM = invertMask ? 255 - mVal : mVal;
-      let weight = 0;
-      if (effectiveM === 0) {
-        weight = 0;
-      } else if (effectiveM === 255) {
-        weight = globalAlpha;
-      } else if (globalAlpha === 255) {
-        weight = effectiveM;
-      } else {
-        weight = effectiveM * globalAlpha + 128 >> 8;
-      }
-      if (weight === 0) {
-        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
-        didChange = true;
-      } else if (weight !== 255) {
-        const d = dst32[dIdx];
-        const da = d >>> 24;
-        if (da !== 0) {
-          const finalAlpha = da === 255 ? weight : da * weight + 128 >> 8;
-          const current = dst32[dIdx];
-          const next = (d & 16777215 | finalAlpha << 24) >>> 0;
-          if (current !== next) {
-            dst32[dIdx] = next;
-            didChange = true;
-          }
-        }
+  let hasChanged = false;
+  for (let iy = 0; iy < actualH; iy++) {
+    const rowOffset = (finalY + iy) * dw;
+    const start = rowOffset + finalX;
+    const end = start + actualW;
+    for (let i = start; i < end; i++) {
+      if (dst32[i] !== color) {
+        dst32[i] = color;
+        hasChanged = true;
       }
-      dIdx++;
-      mIdx++;
     }
-    dIdx += dStride;
-    mIdx += mStride;
   }
-  return didChange;
+  return hasChanged;
 }
 
-// src/History/PixelMutator/mutatorApplyAlphaMask.ts
-var defaults11 = {
-  applyAlphaMaskToPixelData
+// src/History/PixelMutator/mutatorClear.ts
+var defaults15 = {
+  fillPixelData
 };
-var mutatorApplyAlphaMask = ((writer, deps = defaults11) => {
+var mutatorClear = ((writer, deps = defaults15) => {
   const {
-    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults11.applyAlphaMaskToPixelData
+    fillPixelData: fillPixelData2 = defaults15.fillPixelData
   } = deps;
   return {
-    applyAlphaMask(mask, opts = {}) {
-      let target = writer.config.target;
-      const {
-        x = 0,
-        y = 0,
-        w = target.width,
-        h = target.height
-      } = opts;
+    clear(rect) {
+      const target = writer.config.target;
+      const x = rect?.x ?? 0;
+      const y = rect?.y ?? 0;
+      const w = rect?.w ?? target.width;
+      const h = rect?.h ?? target.height;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(applyAlphaMaskToPixelData2(target, mask, opts));
+      return didChange(fillPixelData2(target, 0, x, y, w, h));
     }
   };
 });
 
-// src/PixelData/applyBinaryMaskToPixelData.ts
-function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
+// src/History/PixelMutator/mutatorFill.ts
+var defaults16 = {
+  fillPixelData
+};
+var mutatorFill = ((writer, deps = defaults16) => {
   const {
-    x: targetX = 0,
-    y: targetY = 0,
-    w: width = dst.width,
-    h: height = dst.height,
-    alpha: globalAlpha = 255,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
-  if (globalAlpha === 0) return false;
-  let x = targetX;
-  let y = targetY;
-  let w = width;
-  let h = height;
-  if (x < 0) {
-    w += x;
-    x = 0;
-  }
-  if (y < 0) {
-    h += y;
-    y = 0;
-  }
-  w = Math.min(w, dst.width - x);
-  h = Math.min(h, dst.height - y);
-  if (w <= 0 || h <= 0) return false;
-  const mPitch = mask.w;
-  if (mPitch <= 0) return false;
-  const startX = mx + (x - targetX);
-  const startY = my + (y - targetY);
-  const sX0 = Math.max(0, startX);
-  const sY0 = Math.max(0, startY);
-  const sX1 = Math.min(mPitch, startX + w);
-  const sY1 = Math.min(mask.h, startY + h);
-  const finalW = sX1 - sX0;
-  const finalH = sY1 - sY0;
-  if (finalW <= 0 || finalH <= 0) {
-    return false;
-  }
-  const xShift = sX0 - startX;
-  const yShift = sY0 - startY;
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  const dStride = dw - finalW;
-  const mStride = mPitch - finalW;
+    fillPixelData: fillPixelData2 = defaults16.fillPixelData
+  } = deps;
+  return {
+    fill(color, x = 0, y = 0, w = writer.config.target.width, h = writer.config.target.height) {
+      const target = writer.config.target;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(fillPixelData2(target, color, x, y, w, h));
+    }
+  };
+});
+var mutatorFillRect = ((writer, deps = defaults16) => {
+  const {
+    fillPixelData: fillPixelData2 = defaults16.fillPixelData
+  } = deps;
+  return {
+    fillRect(color, rect) {
+      const target = writer.config.target;
+      const didChange = writer.accumulator.storeRegionBeforeState(rect.x, rect.y, rect.w, rect.h);
+      return didChange(fillPixelData2(target, color, rect.x, rect.y, rect.w, rect.h));
+    }
+  };
+});
+
+// src/PixelData/fillPixelDataBinaryMask.ts
+var SCRATCH_RECT2 = makeClippedRect();
+function fillPixelDataBinaryMask(target, color, mask, x = 0, y = 0) {
+  const maskW = mask.w;
+  const maskH = mask.h;
+  const clip = resolveRectClipping(x, y, maskW, maskH, target.width, target.height, SCRATCH_RECT2);
+  if (!clip.inBounds) return false;
+  const {
+    x: finalX,
+    y: finalY,
+    w: actualW,
+    h: actualH
+  } = clip;
   const maskData = mask.data;
-  let dIdx = (y + yShift) * dw + (x + xShift);
-  let mIdx = sY0 * mPitch + sX0;
-  let didChange = false;
-  for (let iy = 0; iy < finalH; iy++) {
-    for (let ix = 0; ix < finalW; ix++) {
-      const mVal = maskData[mIdx];
-      const isMaskedOut = invertMask ? mVal !== 0 : mVal === 0;
-      if (isMaskedOut) {
-        const current = dst32[dIdx];
-        const next = (current & 16777215) >>> 0;
-        if (current !== next) {
-          dst32[dIdx] = next;
-          didChange = true;
+  const dst32 = target.data32;
+  const dw = target.width;
+  let hasChanged = false;
+  for (let iy = 0; iy < actualH; iy++) {
+    const currentY = finalY + iy;
+    const maskY = currentY - y;
+    const maskOffset = maskY * maskW;
+    const dstRowOffset = currentY * dw;
+    for (let ix = 0; ix < actualW; ix++) {
+      const currentX = finalX + ix;
+      const maskX = currentX - x;
+      const maskIndex = maskOffset + maskX;
+      if (maskData[maskIndex]) {
+        const current = dst32[dstRowOffset + currentX];
+        if (current !== color) {
+          dst32[dstRowOffset + currentX] = color;
+          hasChanged = true;
         }
-      } else if (globalAlpha !== 255) {
-        const d = dst32[dIdx];
-        const da = d >>> 24;
-        if (da !== 0) {
-          const finalAlpha = da === 255 ? globalAlpha : da * globalAlpha + 128 >> 8;
-          const next = (d & 16777215 | finalAlpha << 24) >>> 0;
-          if (d !== next) {
-            dst32[dIdx] = next;
-            didChange = true;
-          }
+      }
+    }
+  }
+  return hasChanged;
+}
+
+// src/History/PixelMutator/mutatorFillBinaryMask.ts
+var defaults17 = {
+  fillPixelDataBinaryMask
+};
+var mutatorFillBinaryMask = ((writer, deps = defaults17) => {
+  const {
+    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults17.fillPixelDataBinaryMask
+  } = deps;
+  return {
+    fillBinaryMask(color, mask, x = 0, y = 0) {
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, mask.w, mask.h);
+      return didChange(fillPixelDataBinaryMask2(writer.config.target, color, mask, x, y));
+    }
+  };
+});
+
+// src/PixelData/invertPixelData.ts
+var SCRATCH_RECT3 = makeClippedRect();
+function invertPixelData(target, opts) {
+  const mask = opts?.mask;
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const mx = opts?.mx ?? 0;
+  const my = opts?.my ?? 0;
+  const width = opts?.w ?? target.width;
+  const height = opts?.h ?? target.height;
+  const invertMask = opts?.invertMask ?? false;
+  const clip = resolveRectClipping(targetX, targetY, width, height, target.width, target.height, SCRATCH_RECT3);
+  if (!clip.inBounds) return false;
+  const {
+    x,
+    y,
+    w: actualW,
+    h: actualH
+  } = clip;
+  const dst32 = target.data32;
+  const dw = target.width;
+  const mPitch = mask?.w ?? width;
+  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;
+  if (mask) {
+    const maskData = mask.data;
+    for (let iy = 0; iy < actualH; iy++) {
+      for (let ix = 0; ix < actualW; ix++) {
+        const mVal = maskData[mIdx];
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (isHit) {
+          dst32[dIdx] = dst32[dIdx] ^ 16777215;
         }
+        dIdx++;
+        mIdx++;
       }
-      dIdx++;
-      mIdx++;
+      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++;
+      }
+      dIdx += dStride;
     }
-    dIdx += dStride;
-    mIdx += mStride;
   }
-  return didChange;
+  return true;
 }
 
-// src/History/PixelMutator/mutatorApplyBinaryMask.ts
-var defaults12 = {
-  applyBinaryMaskToPixelData
+// src/History/PixelMutator/mutatorInvert.ts
+var defaults18 = {
+  invertPixelData
 };
-var mutatorApplyBinaryMask = ((writer, deps = defaults12) => {
+var mutatorInvert = ((writer, deps = defaults18) => {
   const {
-    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults12.applyBinaryMaskToPixelData
+    invertPixelData: invertPixelData2 = defaults18.invertPixelData
   } = deps;
   return {
-    applyBinaryMask(mask, opts = {}) {
-      let target = writer.config.target;
-      const {
-        x = 0,
-        y = 0,
-        w = target.width,
-        h = target.height
-      } = opts;
+    invert(opts) {
+      const target = writer.config.target;
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? target.width;
+      const h = opts?.h ?? target.height;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(applyBinaryMaskToPixelData2(target, mask, opts));
+      return didChange(invertPixelData2(target, opts));
     }
   };
 });
 
+// src/History/PixelMutator.ts
+function makeFullPixelMutator(writer) {
+  return {
+    // @sort
+    ...mutatorApplyAlphaMask(writer),
+    ...mutatorApplyBinaryMask(writer),
+    ...mutatorApplyMask(writer),
+    ...mutatorBlendAlphaMask(writer),
+    ...mutatorBlendBinaryMask(writer),
+    ...mutatorBlendColor(writer),
+    ...mutatorBlendColorPaintAlphaMask(writer),
+    ...mutatorBlendColorPaintBinaryMask(writer),
+    ...mutatorBlendColorPaintMask(writer),
+    ...mutatorBlendMask(writer),
+    ...mutatorBlendPaintRect(writer),
+    ...mutatorBlendPixel(writer),
+    ...mutatorBlendPixelData(writer),
+    ...mutatorClear(writer),
+    ...mutatorFill(writer),
+    ...mutatorFillBinaryMask(writer),
+    ...mutatorFillRect(writer),
+    ...mutatorInvert(writer)
+  };
+}
+
+// src/ImageData/ImageDataLike.ts
+function makeImageDataLike(width, height, data) {
+  const size = width * height * 4;
+  const buffer = data ? new Uint8ClampedArray(data.buffer, data.byteOffset, size) : new Uint8ClampedArray(size);
+  return {
+    width,
+    height,
+    data: buffer
+  };
+}
+
+// src/ImageData/ReusableImageData.ts
+function makeReusableImageData() {
+  let imageData = null;
+  return function getReusableImageData(width, height) {
+    if (imageData === null || imageData.width !== width || imageData.height !== height) {
+      imageData = new ImageData(width, height);
+    } else {
+      imageData.data.fill(0);
+    }
+    return imageData;
+  };
+}
+
 // src/ImageData/copyImageData.ts
 function copyImageData({
   data,
@@ -3440,17 +3712,6 @@ function copyImageDataLike({
   };
 }
 
-// src/ImageData/ImageDataLike.ts
-function makeImageDataLike(width, height, data) {
-  const size = width * height * 4;
-  const buffer = data ? new Uint8ClampedArray(data.buffer, data.byteOffset, size) : new Uint8ClampedArray(size);
-  return {
-    width,
-    height,
-    data: buffer
-  };
-}
-
 // src/ImageData/imageDataToAlphaMaskBuffer.ts
 function imageDataToAlphaMaskBuffer(imageData) {
   const {
@@ -3538,20 +3799,7 @@ function resampleImageData(source, factor) {
     height
   } = resample32(src32, source.width, source.height, factor);
   const uint8ClampedArray = new Uint8ClampedArray(data.buffer);
-  return new ImageData(uint8ClampedArray, width, height);
-}
-
-// src/ImageData/ReusableImageData.ts
-function makeReusableImageData() {
-  let imageData = null;
-  return function getReusableImageData(width, height) {
-    if (imageData === null || imageData.width !== width || imageData.height !== height) {
-      imageData = new ImageData(width, height);
-    } else {
-      imageData.data.fill(0);
-    }
-    return imageData;
-  };
+  return new ImageData(uint8ClampedArray, width, height);
 }
 
 // src/ImageData/serialization.ts
@@ -3708,18 +3956,6 @@ function writeImageDataBuffer(target, data, _x, _y, _w, _h) {
   }
 }
 
-// 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/IndexedImage.ts
 var IndexedImage = class _IndexedImage {
   /** The width of the image in pixels. */
@@ -3798,6 +4034,18 @@ var IndexedImage = class _IndexedImage {
   }
 };
 
+// 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 {
@@ -3956,16 +4204,14 @@ function makeBinaryMask(w, h, data) {
 }
 
 // src/Mask/applyBinaryMaskToAlphaMask.ts
-function applyBinaryMaskToAlphaMask(alphaMaskDst, binaryMaskSrc, opts = {}) {
-  const {
-    x: targetX = 0,
-    y: targetY = 0,
-    w: reqWidth = 0,
-    h: reqHeight = 0,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
+function applyBinaryMaskToAlphaMask(alphaMaskDst, binaryMaskSrc, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const reqWidth = opts?.w ?? 0;
+  const reqHeight = opts?.h ?? 0;
+  const mx = opts?.mx ?? 0;
+  const my = opts?.my ?? 0;
+  const invertMask = opts?.invertMask ?? false;
   const dstWidth = alphaMaskDst.w;
   if (dstWidth <= 0) return;
   if (binaryMaskSrc.data.length === 0) return;
@@ -4388,6 +4634,148 @@ function pushPiece(dest, r, x, y, w, h) {
   });
 }
 
+// src/Paint/PaintBufferCanvasRenderer.ts
+function makePaintBufferCanvasRenderer(paintBuffer, offscreenCanvasClass = OffscreenCanvas) {
+  const config = paintBuffer.config;
+  const tileSize = config.tileSize;
+  const tileShift = config.tileShift;
+  const lookup = paintBuffer.lookup;
+  const canvas = new offscreenCanvasClass(tileSize, tileSize);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error(CANVAS_CTX_FAILED);
+  ctx.imageSmoothingEnabled = false;
+  return function drawPaintBuffer(targetCtx, alpha = 255, compOperation = "source-over") {
+    targetCtx.globalAlpha = alpha / 255;
+    targetCtx.globalCompositeOperation = compOperation;
+    for (let i = 0; i < lookup.length; i++) {
+      const tile = lookup[i];
+      if (tile) {
+        const dx = tile.tx << tileShift;
+        const dy = tile.ty << tileShift;
+        ctx.putImageData(tile.imageData, 0, 0);
+        targetCtx.drawImage(canvas, dx, dy);
+      }
+    }
+    targetCtx.globalAlpha = 1;
+    targetCtx.globalCompositeOperation = "source-over";
+  };
+}
+
+// src/Paint/makeCirclePaintAlphaMask.ts
+function makeCirclePaintAlphaMask(size, fallOff = (d) => d) {
+  const area = size * size;
+  const data = new Uint8Array(area);
+  const radius = size / 2;
+  const invR = 1 / radius;
+  const centerOffset = -Math.ceil(radius - 0.5);
+  for (let y = 0; y < size; y++) {
+    const rowOffset = y * size;
+    const dy = y - radius + 0.5;
+    const dy2 = dy * dy;
+    for (let x = 0; x < size; x++) {
+      const dx = x - radius + 0.5;
+      const distSqr = dx * dx + dy2;
+      if (distSqr <= radius * radius) {
+        const dist = Math.sqrt(distSqr) * invR;
+        const strength = fallOff(1 - dist);
+        if (strength > 0) {
+          const intensity = strength * 255 | 0;
+          data[rowOffset + x] = Math.max(0, Math.min(255, intensity));
+        }
+      }
+    }
+  }
+  return {
+    type: 0 /* ALPHA */,
+    data,
+    w: size,
+    h: size,
+    centerOffsetX: centerOffset,
+    centerOffsetY: centerOffset
+  };
+}
+
+// src/Paint/makeCirclePaintBinaryMask.ts
+function makeCirclePaintBinaryMask(size) {
+  const area = size * size;
+  const data = new Uint8Array(area);
+  const radius = size / 2;
+  const centerOffset = -Math.ceil(radius - 0.5);
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const dx = x - radius + 0.5;
+      const dy = y - radius + 0.5;
+      const distSqr = dx * dx + dy * dy;
+      if (distSqr <= radius * radius) {
+        data[y * size + x] = 1;
+      }
+    }
+  }
+  return {
+    type: 1 /* BINARY */,
+    data,
+    w: size,
+    h: size,
+    centerOffsetX: centerOffset,
+    centerOffsetY: centerOffset
+  };
+}
+
+// src/Paint/makePaintMask.ts
+function makePaintBinaryMask(mask) {
+  return {
+    type: 1 /* BINARY */,
+    data: mask.data,
+    w: mask.w,
+    h: mask.h,
+    centerOffsetX: -(mask.w >> 1),
+    centerOffsetY: -(mask.h >> 1)
+  };
+}
+function makePaintAlphaMask(mask) {
+  return {
+    type: 0 /* ALPHA */,
+    data: mask.data,
+    w: mask.w,
+    h: mask.h,
+    centerOffsetX: -(mask.w >> 1),
+    centerOffsetY: -(mask.h >> 1)
+  };
+}
+
+// src/Paint/makeRectFalloffPaintAlphaMask.ts
+function makeRectFalloffPaintAlphaMask(width, height, fallOff = (d) => d) {
+  const fPx = Math.floor(width / 2);
+  const fPy = Math.floor(height / 2);
+  const invHalfW = 2 / width;
+  const invHalfH = 2 / height;
+  const offX = width % 2 === 0 ? 0.5 : 0;
+  const offY = height % 2 === 0 ? 0.5 : 0;
+  const area = width * height;
+  const data = new Uint8Array(area);
+  for (let y = 0; y < height; y++) {
+    const dy = Math.abs(y - fPy + offY) * invHalfH;
+    const rowOffset = y * width;
+    for (let x = 0; x < width; x++) {
+      const dx = Math.abs(x - fPx + offX) * invHalfW;
+      const dist = dx > dy ? dx : dy;
+      const strength = fallOff(1 - dist);
+      if (strength > 0) {
+        const intensity = strength * 255 | 0;
+        data[rowOffset + x] = Math.max(0, Math.min(255, intensity));
+      }
+    }
+  }
+  return {
+    type: 0 /* ALPHA */,
+    data,
+    w: width,
+    h: height,
+    centerOffsetX: -(width >> 1),
+    centerOffsetY: -(height >> 1)
+  };
+}
+
 // src/PixelData/PixelData.ts
 var PixelData = class {
   data32;
@@ -4409,170 +4797,96 @@ var PixelData = class {
   }
 };
 
-// src/PixelData/blendColorPixelDataAlphaMask.ts
-function blendColorPixelDataAlphaMask(dst, color, mask, opts = {}) {
-  const targetX = opts.x ?? 0;
-  const targetY = opts.y ?? 0;
-  const w = opts.w ?? mask.w;
-  const h = opts.h ?? mask.h;
-  const globalAlpha = opts.alpha ?? 255;
-  const blendFn = opts.blendFn ?? sourceOverPerfect;
-  const mx = opts.mx ?? 0;
-  const my = opts.my ?? 0;
-  const invertMask = opts.invertMask ?? false;
-  if (globalAlpha === 0) return false;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) return false;
-  let x = targetX;
-  let y = targetY;
-  let actualW = w;
-  let actualH = h;
-  if (x < 0) {
-    actualW += x;
-    x = 0;
-  }
-  if (y < 0) {
-    actualH += y;
-    y = 0;
+// src/PixelData/applyMaskToPixelData.ts
+function applyMaskToPixelData(dst, mask, opts) {
+  if (mask.type === 1 /* BINARY */) {
+    return applyBinaryMaskToPixelData(dst, mask, opts);
+  } else {
+    return applyAlphaMaskToPixelData(dst, mask, opts);
   }
-  actualW = Math.min(actualW, dst.width - x);
-  actualH = Math.min(actualH, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return false;
-  const dx = x - targetX | 0;
-  const dy = y - targetY | 0;
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  const mPitch = mask.w;
-  const maskData = mask.data;
-  let dIdx = y * dw + x | 0;
-  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
-  const dStride = dw - actualW | 0;
-  const mStride = mPitch - actualW | 0;
-  const isOpaque = globalAlpha === 255;
-  const colorRGB = color & 16777215;
-  let didChange = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      const mVal = maskData[mIdx];
-      const effM = invertMask ? 255 - mVal : mVal;
-      if (effM === 0) {
-        dIdx++;
-        mIdx++;
-        continue;
-      }
-      let weight = globalAlpha;
-      if (isOpaque) {
-        weight = effM;
-      } else if (effM !== 255) {
-        weight = effM * globalAlpha + 128 >> 8;
-      }
-      if (weight === 0) {
-        dIdx++;
-        mIdx++;
-        continue;
-      }
-      let finalCol = color;
-      if (weight < 255) {
-        const a = baseSrcAlpha * weight + 128 >> 8;
-        if (a === 0 && !isOverwrite) {
-          dIdx++;
-          mIdx++;
-          continue;
-        }
-        finalCol = (colorRGB | a << 24) >>> 0;
-      }
-      const current = dst32[dIdx];
-      const next = blendFn(finalCol, current);
-      if (current !== next) {
-        dst32[dIdx] = next;
-        didChange = true;
-      }
-      dIdx++;
-      mIdx++;
-    }
-    dIdx += dStride;
-    mIdx += mStride;
+}
+
+// src/PixelData/blendColorPixelDataMask.ts
+function blendColorPixelDataMask(dst, color, mask, opts) {
+  if (mask.type === 1 /* BINARY */) {
+    return blendColorPixelDataBinaryMask(dst, color, mask, opts);
+  } else {
+    return blendColorPixelDataAlphaMask(dst, color, mask, opts);
   }
-  return didChange;
 }
 
-// src/PixelData/blendColorPixelDataBinaryMask.ts
-function blendColorPixelDataBinaryMask(dst, color, mask, opts = {}) {
-  const targetX = opts.x ?? 0;
-  const targetY = opts.y ?? 0;
-  let w = opts.w ?? mask.w;
-  let h = opts.h ?? mask.h;
-  const globalAlpha = opts.alpha ?? 255;
-  const blendFn = opts.blendFn ?? sourceOverPerfect;
-  const mx = opts.mx ?? 0;
-  const my = opts.my ?? 0;
-  const invertMask = opts.invertMask ?? false;
-  if (globalAlpha === 0) return false;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) return false;
-  let x = targetX;
-  let y = targetY;
-  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 false;
-  let baseColorWithGlobalAlpha = color;
-  if (globalAlpha < 255) {
-    const a = baseSrcAlpha * globalAlpha + 128 >> 8;
-    if (a === 0 && !isOverwrite) return false;
-    baseColorWithGlobalAlpha = (color & 16777215 | a << 24) >>> 0;
+// src/PixelData/blendColorPixelDataPaintAlphaMask.ts
+var SCRATCH_OPTS = {
+  x: 0,
+  y: 0,
+  alpha: 255,
+  blendFn: sourceOverPerfect
+};
+function blendColorPixelDataPaintAlphaMask(dst, color, mask, x, y, alpha = 255, blendFn = sourceOverPerfect) {
+  const tx = x + mask.centerOffsetX;
+  const ty = y + mask.centerOffsetY;
+  SCRATCH_OPTS.x = tx;
+  SCRATCH_OPTS.y = ty;
+  SCRATCH_OPTS.alpha = alpha;
+  SCRATCH_OPTS.blendFn = blendFn;
+  return blendColorPixelDataAlphaMask(dst, color, mask, SCRATCH_OPTS);
+}
+
+// src/PixelData/blendColorPixelDataPaintBinaryMask.ts
+var SCRATCH_OPTS2 = {
+  x: 0,
+  y: 0,
+  alpha: 255,
+  blendFn: sourceOverPerfect
+};
+function blendColorPixelDataPaintBinaryMask(dst, color, mask, x, y, alpha = 255, blendFn = sourceOverPerfect) {
+  const tx = x + mask.centerOffsetX;
+  const ty = y + mask.centerOffsetY;
+  SCRATCH_OPTS2.x = tx;
+  SCRATCH_OPTS2.y = ty;
+  SCRATCH_OPTS2.alpha = alpha;
+  SCRATCH_OPTS2.blendFn = blendFn;
+  return blendColorPixelDataBinaryMask(dst, color, mask, SCRATCH_OPTS2);
+}
+
+// src/PixelData/blendColorPixelDataPaintMask.ts
+var SCRATCH_OPTS3 = {
+  x: 0,
+  y: 0,
+  alpha: 255,
+  blendFn: sourceOverPerfect
+};
+function blendColorPixelDataPaintMask(dst, color, mask, x, y, alpha = 255, blendFn = sourceOverPerfect) {
+  const tx = x + mask.centerOffsetX;
+  const ty = y + mask.centerOffsetY;
+  SCRATCH_OPTS3.x = tx;
+  SCRATCH_OPTS3.y = ty;
+  SCRATCH_OPTS3.alpha = alpha;
+  SCRATCH_OPTS3.blendFn = blendFn;
+  if (mask.type === 1 /* BINARY */) {
+    return blendColorPixelDataBinaryMask(dst, color, mask, SCRATCH_OPTS3);
+  } else {
+    return blendColorPixelDataAlphaMask(dst, color, mask, SCRATCH_OPTS3);
   }
-  const dx = x - targetX | 0;
-  const dy = y - targetY | 0;
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  const mPitch = mask.w;
-  const maskData = mask.data;
-  let dIdx = y * dw + x | 0;
-  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
-  const dStride = dw - actualW | 0;
-  const mStride = mPitch - actualW | 0;
-  const skipVal = invertMask ? 1 : 0;
-  let didChange = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      if (maskData[mIdx] === skipVal) {
-        dIdx++;
-        mIdx++;
-        continue;
-      }
-      const current = dst32[dIdx];
-      const next = blendFn(baseColorWithGlobalAlpha, current);
-      if (current !== next) {
-        dst32[dIdx] = next;
-        didChange = true;
-      }
-      dIdx++;
-      mIdx++;
-    }
-    dIdx += dStride;
-    mIdx += mStride;
+}
+
+// src/PixelData/blendPixelDataMask.ts
+function blendPixelDataMask(target, src, mask, opts) {
+  if (mask.type === 1 /* BINARY */) {
+    return blendPixelDataBinaryMask(target, src, mask, opts);
+  } else {
+    return blendPixelDataAlphaMask(target, src, mask, opts);
   }
-  return didChange;
 }
 
 // src/PixelData/blendPixelDataPaintBuffer.ts
-var SCRATCH_OPTS = {
+var SCRATCH_OPTS4 = {
   x: 0,
   y: 0,
   alpha: 255,
   blendFn: void 0
 };
-function blendPixelDataPaintBuffer(paintBuffer, target, alpha = 255, blendFn, blendPixelDataFn = blendPixelData) {
+function blendPixelDataPaintBuffer(target, paintBuffer, alpha = 255, blendFn, blendPixelDataFn = blendPixelData) {
   const tileShift = paintBuffer.config.tileShift;
   const lookup = paintBuffer.lookup;
   for (let i = 0; i < lookup.length; i++) {
@@ -4580,17 +4894,61 @@ function blendPixelDataPaintBuffer(paintBuffer, target, alpha = 255, blendFn, bl
     if (tile) {
       const x = tile.tx << tileShift;
       const y = tile.ty << tileShift;
-      SCRATCH_OPTS.x = x;
-      SCRATCH_OPTS.y = y;
-      SCRATCH_OPTS.alpha = alpha;
-      SCRATCH_OPTS.blendFn = blendFn;
-      blendPixelDataFn(target, tile, SCRATCH_OPTS);
+      SCRATCH_OPTS4.x = x;
+      SCRATCH_OPTS4.y = y;
+      SCRATCH_OPTS4.alpha = alpha;
+      SCRATCH_OPTS4.blendFn = blendFn;
+      blendPixelDataFn(target, tile, SCRATCH_OPTS4);
     }
   }
 }
 
-// src/PixelData/clearPixelData.ts
-function clearPixelData(dst, rect) {
+// src/PixelData/fillPixelDataFast.ts
+var SCRATCH_RECT4 = makeClippedRect();
+function fillPixelDataFast(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;
+  }
+  const clip = resolveRectClipping(x, y, w, h, dst.width, dst.height, SCRATCH_RECT4);
+  if (!clip.inBounds) return;
+  const {
+    x: finalX,
+    y: finalY,
+    w: actualW,
+    h: actualH
+  } = clip;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  if (actualW === dw && actualH === dst.height && finalX === 0 && finalY === 0) {
+    dst32.fill(color);
+    return;
+  }
+  for (let iy = 0; iy < actualH; iy++) {
+    const start = (finalY + iy) * dw + finalX;
+    const end = start + actualW;
+    dst32.fill(color, start, end);
+  }
+}
+
+// src/PixelData/clearPixelDataFast.ts
+function clearPixelDataFast(dst, rect) {
   fillPixelDataFast(dst, 0, rect);
 }
 
@@ -4653,26 +5011,6 @@ function extractPixelData(source, _x, _y, _w, _h) {
   return result;
 }
 
-// src/PixelData/PixelBuffer32.ts
-var PixelBuffer32 = class _PixelBuffer32 {
-  constructor(width, height, data32) {
-    this.width = width;
-    this.height = height;
-    this.data32 = data32 ?? new Uint32Array(width * height);
-  }
-  data32;
-  set(width, height, data32) {
-    ;
-    this.data32 = data32 ?? new Uint32Array(width * height);
-    this.width = width;
-    this.height = height;
-  }
-  copy() {
-    const newData32 = new Uint32Array(this.data32);
-    return new _PixelBuffer32(this.width, this.height, newData32);
-  }
-};
-
 // src/PixelData/pixelDataToAlphaMask.ts
 function pixelDataToAlphaMask(pixelData) {
   const {
@@ -4824,160 +5162,16 @@ function writePaintBufferToPixelData(target, paintBuffer, writePixelDataBufferFn
     }
   }
 }
-
-// src/Paint/makeCirclePaintAlphaMask.ts
-function makeCirclePaintAlphaMask(size, fallOff = (d) => d) {
-  const area = size * size;
-  const data = new Uint8Array(area);
-  const radius = size / 2;
-  const invR = 1 / radius;
-  const centerOffset = -Math.ceil(radius - 0.5);
-  for (let y = 0; y < size; y++) {
-    const rowOffset = y * size;
-    const dy = y - radius + 0.5;
-    const dy2 = dy * dy;
-    for (let x = 0; x < size; x++) {
-      const dx = x - radius + 0.5;
-      const distSqr = dx * dx + dy2;
-      if (distSqr <= radius * radius) {
-        const dist = Math.sqrt(distSqr) * invR;
-        const strength = fallOff(1 - dist);
-        if (strength > 0) {
-          const intensity = strength * 255 | 0;
-          data[rowOffset + x] = Math.max(0, Math.min(255, intensity));
-        }
-      }
-    }
-  }
-  return {
-    type: 0 /* ALPHA */,
-    data,
-    w: size,
-    h: size,
-    centerOffsetX: centerOffset,
-    centerOffsetY: centerOffset
-  };
-}
-
-// src/Paint/makeCirclePaintBinaryMask.ts
-function makeCirclePaintBinaryMask(size) {
-  const area = size * size;
-  const data = new Uint8Array(area);
-  const radius = size / 2;
-  const centerOffset = -Math.ceil(radius - 0.5);
-  for (let y = 0; y < size; y++) {
-    for (let x = 0; x < size; x++) {
-      const dx = x - radius + 0.5;
-      const dy = y - radius + 0.5;
-      const distSqr = dx * dx + dy * dy;
-      if (distSqr <= radius * radius) {
-        data[y * size + x] = 1;
-      }
-    }
-  }
-  return {
-    type: 1 /* BINARY */,
-    data,
-    w: size,
-    h: size,
-    centerOffsetX: centerOffset,
-    centerOffsetY: centerOffset
-  };
-}
-
-// src/Paint/makePaintMask.ts
-function makePaintBinaryMask(mask) {
-  return {
-    type: 1 /* BINARY */,
-    data: mask.data,
-    w: mask.w,
-    h: mask.h,
-    centerOffsetX: -macro_halfAndFloor(mask.w),
-    centerOffsetY: -macro_halfAndFloor(mask.h)
-  };
-}
-function makePaintAlphaMask(mask) {
-  return {
-    type: 0 /* ALPHA */,
-    data: mask.data,
-    w: mask.w,
-    h: mask.h,
-    centerOffsetX: -macro_halfAndFloor(mask.w),
-    centerOffsetY: -macro_halfAndFloor(mask.h)
-  };
-}
-
-// src/Paint/makeRectFalloffPaintAlphaMask.ts
-function makeRectFalloffPaintAlphaMask(width, height, fallOff = (d) => d) {
-  const fPx = Math.floor(width / 2);
-  const fPy = Math.floor(height / 2);
-  const invHalfW = 2 / width;
-  const invHalfH = 2 / height;
-  const offX = width % 2 === 0 ? 0.5 : 0;
-  const offY = height % 2 === 0 ? 0.5 : 0;
-  const area = width * height;
-  const data = new Uint8Array(area);
-  for (let y = 0; y < height; y++) {
-    const dy = Math.abs(y - fPy + offY) * invHalfH;
-    const rowOffset = y * width;
-    for (let x = 0; x < width; x++) {
-      const dx = Math.abs(x - fPx + offX) * invHalfW;
-      const dist = dx > dy ? dx : dy;
-      const strength = fallOff(1 - dist);
-      if (strength > 0) {
-        const intensity = strength * 255 | 0;
-        data[rowOffset + x] = Math.max(0, Math.min(255, intensity));
-      }
-    }
-  }
-  return {
-    type: 0 /* ALPHA */,
-    data,
-    w: width,
-    h: height,
-    centerOffsetX: -(width >> 1),
-    centerOffsetY: -(height >> 1)
-  };
-}
-
-// src/Paint/PaintBufferCanvasRenderer.ts
-function makePaintBufferCanvasRenderer(paintBuffer, offscreenCanvasClass = OffscreenCanvas) {
-  const config = paintBuffer.config;
-  const tileSize = config.tileSize;
-  const tileShift = config.tileShift;
-  const lookup = paintBuffer.lookup;
-  const canvas = new offscreenCanvasClass(tileSize, tileSize);
-  const ctx = canvas.getContext("2d");
-  if (!ctx) throw new Error(CANVAS_CTX_FAILED);
-  ctx.imageSmoothingEnabled = false;
-  return function drawPaintBuffer(targetCtx, alpha = 255, compOperation = "source-over") {
-    targetCtx.globalAlpha = alpha / 255;
-    targetCtx.globalCompositeOperation = compOperation;
-    for (let i = 0; i < lookup.length; i++) {
-      const tile = lookup[i];
-      if (tile) {
-        const dx = tile.tx << tileShift;
-        const dy = tile.ty << tileShift;
-        ctx.putImageData(tile.imageData, 0, 0);
-        targetCtx.drawImage(canvas, dx, dy);
-      }
-    }
-    targetCtx.globalAlpha = 1;
-    targetCtx.globalCompositeOperation = "source-over";
-  };
-}
 export {
   BASE_FAST_BLEND_MODE_FUNCTIONS,
   BASE_PERFECT_BLEND_MODE_FUNCTIONS,
   BaseBlendMode,
-  CANVAS_CTX_FAILED,
+  CANVAS_COMPOSITE_MAP,
   HistoryManager,
   IndexedImage,
   MaskType,
-  OFFSCREEN_CANVAS_CTX_FAILED,
   PaintBuffer,
   PixelAccumulator,
-  PixelBuffer32,
   PixelData,
   PixelEngineConfig,
   PixelTile,
@@ -4987,18 +5181,24 @@ export {
   applyAlphaMaskToPixelData,
   applyBinaryMaskToAlphaMask,
   applyBinaryMaskToPixelData,
+  applyMaskToPixelData,
   applyPatchTiles,
   base64DecodeArrayBuffer,
   base64EncodeArrayBuffer,
   blendColorPixelData,
   blendColorPixelDataAlphaMask,
   blendColorPixelDataBinaryMask,
+  blendColorPixelDataMask,
+  blendColorPixelDataPaintAlphaMask,
+  blendColorPixelDataPaintBinaryMask,
+  blendColorPixelDataPaintMask,
   blendPixel,
   blendPixelData,
   blendPixelDataAlphaMask,
   blendPixelDataBinaryMask,
+  blendPixelDataMask,
   blendPixelDataPaintBuffer,
-  clearPixelData,
+  clearPixelDataFast,
   color32ToCssRGBA,
   color32ToHex,
   colorBurnFast,
@@ -5071,6 +5271,8 @@ export {
   makeCanvasFrameRenderer,
   makeCirclePaintAlphaMask,
   makeCirclePaintBinaryMask,
+  makeClippedBlit,
+  makeClippedRect,
   makeFastBlendModeRegistry,
   makeFullPixelMutator,
   makeHistoryAction,
@@ -5092,11 +5294,17 @@ export {
   multiplyPerfect,
   mutatorApplyAlphaMask,
   mutatorApplyBinaryMask,
+  mutatorApplyMask,
+  mutatorBlendAlphaMask,
+  mutatorBlendBinaryMask,
   mutatorBlendColor,
+  mutatorBlendColorPaintAlphaMask,
+  mutatorBlendColorPaintBinaryMask,
+  mutatorBlendColorPaintMask,
+  mutatorBlendMask,
+  mutatorBlendPaintRect,
   mutatorBlendPixel,
   mutatorBlendPixelData,
-  mutatorBlendPixelDataAlphaMask,
-  mutatorBlendPixelDataBinaryMask,
   mutatorClear,
   mutatorFill,
   mutatorFillBinaryMask,
@@ -5114,10 +5322,13 @@ export {
   pixelDataToAlphaMask,
   reflectPixelDataHorizontal,
   reflectPixelDataVertical,
+  resample32,
   resampleImageData,
   resampleIndexedImage,
   resamplePixelData,
   resizeImageData,
+  resolveBlitClipping,
+  resolveRectClipping,
   rotatePixelData,
   screenFast,
   screenPerfect,