pixel-data-js 0.23.1 → 0.25.0

package/dist/index.dev.cjs

@@ -28,27 +28,29 @@ __export(src_exports, {
   IndexedImage: () => IndexedImage,
   MaskType: () => MaskType,
   OFFSCREEN_CANVAS_CTX_FAILED: () => OFFSCREEN_CANVAS_CTX_FAILED,
+  PaintBuffer: () => PaintBuffer,
   PixelAccumulator: () => PixelAccumulator,
   PixelBuffer32: () => PixelBuffer32,
   PixelData: () => PixelData,
   PixelEngineConfig: () => PixelEngineConfig,
   PixelTile: () => PixelTile,
+  PixelTilePool: () => PixelTilePool,
   PixelWriter: () => PixelWriter,
   UnsupportedFormatError: () => UnsupportedFormatError,
   applyAlphaMaskToPixelData: () => applyAlphaMaskToPixelData,
   applyBinaryMaskToAlphaMask: () => applyBinaryMaskToAlphaMask,
   applyBinaryMaskToPixelData: () => applyBinaryMaskToPixelData,
-  applyCircleBrushToPixelData: () => applyCircleBrushToPixelData,
   applyPatchTiles: () => applyPatchTiles,
-  applyRectBrushToPixelData: () => applyRectBrushToPixelData,
   base64DecodeArrayBuffer: () => base64DecodeArrayBuffer,
   base64EncodeArrayBuffer: () => base64EncodeArrayBuffer,
   blendColorPixelData: () => blendColorPixelData,
   blendColorPixelDataAlphaMask: () => blendColorPixelDataAlphaMask,
   blendColorPixelDataBinaryMask: () => blendColorPixelDataBinaryMask,
+  blendPixel: () => blendPixel,
   blendPixelData: () => blendPixelData,
   blendPixelDataAlphaMask: () => blendPixelDataAlphaMask,
   blendPixelDataBinaryMask: () => blendPixelDataBinaryMask,
+  blendPixelDataPaintBuffer: () => blendPixelDataPaintBuffer,
   clearPixelData: () => clearPixelData,
   color32ToCssRGBA: () => color32ToCssRGBA,
   color32ToHex: () => color32ToHex,
@@ -82,14 +84,11 @@ __export(src_exports, {
   fileToImageData: () => fileToImageData,
   fillPixelData: () => fillPixelData,
   fillPixelDataBinaryMask: () => fillPixelDataBinaryMask,
+  fillPixelDataFast: () => fillPixelDataFast,
   floodFillSelection: () => floodFillSelection,
   forEachLinePoint: () => forEachLinePoint,
-  getCircleBrushOrPencilBounds: () => getCircleBrushOrPencilBounds,
-  getCircleBrushOrPencilStrokeBounds: () => getCircleBrushOrPencilStrokeBounds,
   getImageDataFromClipboard: () => getImageDataFromClipboard,
   getIndexedImageColorCounts: () => getIndexedImageColorCounts,
-  getRectBrushOrPencilBounds: () => getRectBrushOrPencilBounds,
-  getRectBrushOrPencilStrokeBounds: () => getRectBrushOrPencilStrokeBounds,
   getRectsBounds: () => getRectsBounds,
   getSupportedPixelFormats: () => getSupportedPixelFormats,
   hardLightFast: () => hardLightFast,
@@ -122,15 +121,22 @@ __export(src_exports, {
   makeAlphaMask: () => makeAlphaMask,
   makeBinaryMask: () => makeBinaryMask,
   makeBlendModeRegistry: () => makeBlendModeRegistry,
-  makeCircleBrushAlphaMask: () => makeCircleBrushAlphaMask,
-  makeCircleBrushBinaryMask: () => makeCircleBrushBinaryMask,
+  makeCanvasFrameRenderer: () => makeCanvasFrameRenderer,
+  makeCirclePaintAlphaMask: () => makeCirclePaintAlphaMask,
+  makeCirclePaintBinaryMask: () => makeCirclePaintBinaryMask,
   makeFastBlendModeRegistry: () => makeFastBlendModeRegistry,
   makeFullPixelMutator: () => makeFullPixelMutator,
+  makeHistoryAction: () => makeHistoryAction,
   makeImageDataLike: () => makeImageDataLike,
+  makePaintAlphaMask: () => makePaintAlphaMask,
+  makePaintBinaryMask: () => makePaintBinaryMask,
+  makePaintBufferCanvasRenderer: () => makePaintBufferCanvasRenderer,
   makePerfectBlendModeRegistry: () => makePerfectBlendModeRegistry,
   makePixelCanvas: () => makePixelCanvas,
+  makeRectFalloffPaintAlphaMask: () => makeRectFalloffPaintAlphaMask,
   makeReusableCanvas: () => makeReusableCanvas,
   makeReusableImageData: () => makeReusableImageData,
+  makeReusableOffscreenCanvas: () => makeReusableOffscreenCanvas,
   merge2BinaryMaskRects: () => merge2BinaryMaskRects,
   mergeAlphaMasks: () => mergeAlphaMasks,
   mergeBinaryMaskRects: () => mergeBinaryMaskRects,
@@ -139,14 +145,6 @@ __export(src_exports, {
   multiplyPerfect: () => multiplyPerfect,
   mutatorApplyAlphaMask: () => mutatorApplyAlphaMask,
   mutatorApplyBinaryMask: () => mutatorApplyBinaryMask,
-  mutatorApplyCircleBrush: () => mutatorApplyCircleBrush,
-  mutatorApplyCircleBrushStroke: () => mutatorApplyCircleBrushStroke,
-  mutatorApplyCirclePencil: () => mutatorApplyCirclePencil,
-  mutatorApplyCirclePencilStroke: () => mutatorApplyCirclePencilStroke,
-  mutatorApplyRectBrush: () => mutatorApplyRectBrush,
-  mutatorApplyRectBrushStroke: () => mutatorApplyRectBrushStroke,
-  mutatorApplyRectPencil: () => mutatorApplyRectPencil,
-  mutatorApplyRectPencilStroke: () => mutatorApplyRectPencilStroke,
   mutatorBlendColor: () => mutatorBlendColor,
   mutatorBlendPixel: () => mutatorBlendPixel,
   mutatorBlendPixelData: () => mutatorBlendPixelData,
@@ -155,6 +153,7 @@ __export(src_exports, {
   mutatorClear: () => mutatorClear,
   mutatorFill: () => mutatorFill,
   mutatorFillBinaryMask: () => mutatorFillBinaryMask,
+  mutatorFillRect: () => mutatorFillRect,
   mutatorInvert: () => mutatorInvert,
   overlayFast: () => overlayFast,
   overlayPerfect: () => overlayPerfect,
@@ -186,6 +185,7 @@ __export(src_exports, {
   subtractFast: () => subtractFast,
   subtractPerfect: () => subtractPerfect,
   toBlendModeIndexAndName: () => toBlendModeIndexAndName,
+  trimMaskRectBounds: () => trimMaskRectBounds,
   trimRectBounds: () => trimRectBounds,
   uInt32ArrayToImageData: () => uInt32ArrayToImageData,
   uInt32ArrayToImageDataLike: () => uInt32ArrayToImageDataLike,
@@ -201,6 +201,7 @@ __export(src_exports, {
   writeImageDataBuffer: () => writeImageDataBuffer,
   writeImageDataToClipboard: () => writeImageDataToClipboard,
   writeImgBlobToClipboard: () => writeImgBlobToClipboard,
+  writePaintBufferToPixelData: () => writePaintBufferToPixelData,
   writePixelDataBuffer: () => writePixelDataBuffer
 });
 module.exports = __toCommonJS(src_exports);
@@ -439,8 +440,8 @@ function extractMaskBuffer(maskBuffer, maskWidth, xOrRect, y, w, h) {
   return out;
 }
 
-// src/Rect/trimRectBounds.ts
-function trimRectBounds(target, bounds) {
+// src/Rect/trimMaskRectBounds.ts
+function trimMaskRectBounds(target, bounds) {
   const originalX = target.x;
   const originalY = target.y;
   const originalW = target.w;
@@ -628,7 +629,7 @@ function floodFillSelection(img, startX, startY, {
       finalMask[my * sw + mx] = 1;
     }
   }
-  trimRectBounds(selectionRect, {
+  trimMaskRectBounds(selectionRect, {
     x: 0,
     y: 0,
     w: width,
@@ -643,6 +644,26 @@ function floodFillSelection(img, startX, startY, {
   };
 }
 
+// src/Algorithm/forEachLinePoint.ts
+function forEachLinePoint(x0, y0, x1, y1, callback) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const steps = Math.max(Math.abs(dx), Math.abs(dy));
+  if (steps === 0) {
+    callback(x0, y0);
+    return;
+  }
+  const xInc = dx / steps;
+  const yInc = dy / steps;
+  let curX = x0;
+  let curY = y0;
+  for (let i = 0; i <= steps; i++) {
+    callback(curX, curY);
+    curX += xInc;
+    curY += yInc;
+  }
+}
+
 // src/BlendModes/blend-modes.ts
 var BaseBlendMode = {
   overwrite: 0,
@@ -1720,51 +1741,104 @@ var getKeyByValue = (obj, value) => {
 var OFFSCREEN_CANVAS_CTX_FAILED = "Failed to create OffscreenCanvas context";
 var CANVAS_CTX_FAILED = "Failed to create Canvas context";
 
-// src/Canvas/PixelCanvas.ts
-function makePixelCanvas(canvas) {
-  const ctx = canvas.getContext("2d");
-  if (!ctx) throw new Error(CANVAS_CTX_FAILED);
-  ctx.imageSmoothingEnabled = false;
-  return {
-    canvas,
-    ctx,
-    resize(w, h) {
-      canvas.width = w;
-      canvas.height = h;
-      ctx.imageSmoothingEnabled = false;
-    }
-  };
-}
-
 // src/Canvas/ReusableCanvas.ts
 function makeReusableCanvas() {
+  return makeReusableCanvasMeta((w, h) => {
+    const canvas = document.createElement("canvas");
+    canvas.width = w;
+    canvas.height = h;
+    return canvas;
+  });
+}
+function makeReusableOffscreenCanvas() {
+  return makeReusableCanvasMeta((w, h) => new OffscreenCanvas(w, h));
+}
+function makeReusableCanvasMeta(factory) {
   let canvas = null;
   let ctx = null;
+  const result = {
+    canvas: null,
+    ctx: null
+  };
   function get2(width, height) {
     if (canvas === null) {
-      canvas = document.createElement("canvas");
+      canvas = factory(width, height);
       ctx = canvas.getContext("2d");
-      if (!ctx) throw new Error(CANVAS_CTX_FAILED);
+      if (!ctx) {
+        throw new Error(CANVAS_CTX_FAILED);
+      }
+      ctx.imageSmoothingEnabled = false;
+      result.canvas = canvas;
+      result.ctx = ctx;
+      return result;
     }
     if (canvas.width !== width || canvas.height !== height) {
       canvas.width = width;
       canvas.height = height;
       ctx.imageSmoothingEnabled = false;
     } else {
+      ctx.setTransform(1, 0, 0, 1, 0, 0);
       ctx.clearRect(0, 0, width, height);
     }
-    return {
-      canvas,
-      ctx
-    };
+    return result;
   }
   get2.reset = () => {
     canvas = null;
     ctx = null;
+    result.canvas = null;
+    result.ctx = null;
   };
   return get2;
 }
 
+// src/Canvas/CanvasFrameRenderer.ts
+var defaults = {
+  makeReusableCanvas
+};
+function makeCanvasFrameRenderer(deps = defaults) {
+  const {
+    makeReusableCanvas: makeReusableCanvas2 = defaults.makeReusableCanvas
+  } = deps;
+  const bufferCanvas = makeReusableCanvas2();
+  return function renderCanvasFrame(pixelCanvas, scale, getImageData, drawPixelLayer, drawScreenLayer) {
+    const {
+      canvas,
+      ctx
+    } = pixelCanvas;
+    const {
+      ctx: pxCtx,
+      canvas: pxCanvas
+    } = bufferCanvas(canvas.width, canvas.height);
+    const img = getImageData();
+    if (img) {
+      pxCtx.putImageData(img, 0, 0);
+    }
+    drawPixelLayer?.(pxCtx);
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    ctx.setTransform(scale, 0, 0, scale, 0, 0);
+    ctx.drawImage(pxCanvas, 0, 0);
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    drawScreenLayer?.(ctx, scale);
+  };
+}
+
+// src/Canvas/PixelCanvas.ts
+function makePixelCanvas(canvas) {
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error(CANVAS_CTX_FAILED);
+  ctx.imageSmoothingEnabled = false;
+  return {
+    canvas,
+    ctx,
+    resize(w, h) {
+      canvas.width = w;
+      canvas.height = h;
+      ctx.imageSmoothingEnabled = false;
+    }
+  };
+}
+
 // src/ImageData/imgBlobToImageData.ts
 async function imgBlobToImageData(blob) {
   let bitmap = null;
@@ -1824,6 +1898,50 @@ async function writeImageDataToClipboard(imageData) {
   return writeImgBlobToClipboard(blob);
 }
 
+// src/History/PixelPatchTiles.ts
+function applyPatchTiles(target, tiles, tileSize) {
+  for (let i = 0; i < tiles.length; i++) {
+    const tile = tiles[i];
+    if (!tile) continue;
+    const dst = target.data32;
+    const src = tile.data32;
+    const dstWidth = target.width;
+    const dstHeight = target.height;
+    const startX = tile.tx * tileSize;
+    const startY = tile.ty * tileSize;
+    const copyWidth = Math.max(0, Math.min(tileSize, dstWidth - startX));
+    if (copyWidth <= 0) continue;
+    for (let ly = 0; ly < tileSize; ly++) {
+      const globalY = startY + ly;
+      if (globalY >= dstHeight) break;
+      const dstIndex = globalY * dstWidth + startX;
+      const srcIndex = ly * tileSize;
+      const rowData = src.subarray(srcIndex, srcIndex + copyWidth);
+      dst.set(rowData, dstIndex);
+    }
+  }
+}
+
+// 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;
+  return {
+    undo: () => {
+      applyPatchTilesFn(target, patch.beforeTiles, tileSize);
+      afterUndo?.();
+      after?.();
+    },
+    redo: () => {
+      applyPatchTilesFn(target, patch.afterTiles, tileSize);
+      afterRedo?.();
+      after?.();
+    },
+    dispose: () => accumulator.recyclePatch(patch)
+  };
+}
+
 // src/History/HistoryManager.ts
 var HistoryManager = class {
   constructor(maxSteps = 50) {
@@ -1882,134 +2000,123 @@ var HistoryManager = class {
   }
 };
 
-// src/History/PixelPatchTiles.ts
-var PixelTile = class {
-  constructor(id, tx, ty, tileArea) {
-    this.id = id;
-    this.tx = tx;
-    this.ty = ty;
-    this.data32 = new Uint32Array(tileArea);
-  }
-  data32;
-};
-function applyPatchTiles(target, tiles, tileSize = 256) {
-  for (let i = 0; i < tiles.length; i++) {
-    const tile = tiles[i];
-    if (!tile) continue;
-    const dst = target.data32;
-    const src = tile.data32;
-    const dstWidth = target.width;
-    const dstHeight = target.height;
-    const startX = tile.tx * tileSize;
-    const startY = tile.ty * tileSize;
-    const copyWidth = Math.max(0, Math.min(tileSize, dstWidth - startX));
-    if (copyWidth <= 0) return;
-    for (let ly = 0; ly < tileSize; ly++) {
-      const globalY = startY + ly;
-      if (globalY >= dstHeight) break;
-      const dstIndex = globalY * dstWidth + startX;
-      const srcIndex = ly * tileSize;
-      const rowData = src.subarray(srcIndex, srcIndex + copyWidth);
-      dst.set(rowData, dstIndex);
-    }
-  }
-}
-
 // src/History/PixelAccumulator.ts
 var PixelAccumulator = class {
-  constructor(target, config) {
-    this.target = target;
+  constructor(config, tilePool) {
     this.config = config;
+    this.tilePool = tilePool;
     this.lookup = [];
     this.beforeTiles = [];
-    this.pool = [];
   }
   lookup;
   beforeTiles;
-  pool;
-  getTile(id, tx, ty) {
-    let tile = this.pool.pop();
-    if (tile) {
-      tile.id = id;
-      tile.tx = tx;
-      tile.ty = ty;
-      return tile;
-    }
-    return new PixelTile(id, tx, ty, this.config.tileArea);
-  }
   recyclePatch(patch) {
-    const before = patch.beforeTiles;
-    for (let i = 0; i < before.length; i++) {
-      let tile = before[i];
-      if (tile) {
-        this.pool.push(tile);
-      }
-    }
-    const after = patch.afterTiles;
-    for (let i = 0; i < after.length; i++) {
-      let tile = after[i];
-      if (tile) {
-        this.pool.push(tile);
-      }
-    }
+    this.tilePool.releaseTiles(patch.beforeTiles);
+    this.tilePool.releaseTiles(patch.afterTiles);
   }
   /**
    * @param x pixel x coordinate
    * @param y pixel y coordinate
    */
-  storeTileBeforeState(x, y) {
-    let target = this.target;
-    let shift = this.config.tileShift;
-    let columns = target.width + this.config.tileMask >> shift;
-    let tx = x >> shift;
-    let ty = y >> shift;
-    let id = ty * columns + tx;
+  storePixelBeforeState(x, y) {
+    const shift = this.config.tileShift;
+    const columns = this.config.targetColumns;
+    const tx = x >> shift;
+    const ty = y >> shift;
+    const id = ty * columns + tx;
     let tile = this.lookup[id];
+    let added = false;
     if (!tile) {
-      tile = this.getTile(id, tx, ty);
+      tile = this.tilePool.getTile(id, tx, ty);
       this.extractState(tile);
       this.lookup[id] = tile;
       this.beforeTiles.push(tile);
+      added = true;
     }
+    return (didChange) => {
+      if (!didChange && added) {
+        this.beforeTiles.pop();
+        this.lookup[id] = void 0;
+        this.tilePool.releaseTile(tile);
+      }
+      return didChange;
+    };
   }
   /**
-   *
    * @param x pixel x coordinate
    * @param y pixel y coordinate
    * @param w pixel width
    * @param h pixel height
    */
   storeRegionBeforeState(x, y, w, h) {
-    let target = this.target;
-    let shift = this.config.tileShift;
-    let columns = target.width + this.config.tileMask >> shift;
-    let startX = x >> shift;
-    let startY = y >> shift;
-    let endX = x + w - 1 >> shift;
-    let endY = y + h - 1 >> shift;
+    const shift = this.config.tileShift;
+    const columns = this.config.targetColumns;
+    const startX = x >> shift;
+    const startY = y >> shift;
+    const endX = x + w - 1 >> shift;
+    const endY = y + h - 1 >> shift;
+    const startIndex = this.beforeTiles.length;
     for (let ty = startY; ty <= endY; ty++) {
       for (let tx = startX; tx <= endX; tx++) {
-        let id = ty * columns + tx;
+        const id = ty * columns + tx;
         let tile = this.lookup[id];
         if (!tile) {
-          tile = this.getTile(id, tx, ty);
+          tile = this.tilePool.getTile(id, tx, ty);
           this.extractState(tile);
           this.lookup[id] = tile;
           this.beforeTiles.push(tile);
         }
       }
     }
+    return (didChange) => {
+      if (!didChange) {
+        const length = this.beforeTiles.length;
+        for (let i = startIndex; i < length; i++) {
+          let t = this.beforeTiles[i];
+          if (t) {
+            this.lookup[t.id] = void 0;
+            this.tilePool.releaseTile(t);
+          }
+        }
+        this.beforeTiles.length = startIndex;
+      }
+      return didChange;
+    };
+  }
+  storeTileBeforeState(id, tx, ty) {
+    let tile = this.lookup[id];
+    let added = false;
+    if (!tile) {
+      tile = this.tilePool.getTile(id, tx, ty);
+      this.extractState(tile);
+      this.lookup[id] = tile;
+      this.beforeTiles.push(tile);
+      added = true;
+    }
+    return (didChange) => {
+      if (!didChange && added) {
+        this.beforeTiles.pop();
+        this.lookup[id] = void 0;
+        this.tilePool.releaseTile(tile);
+      }
+      return didChange;
+    };
   }
   extractState(tile) {
-    let target = this.target;
-    let TILE_SIZE = this.config.tileSize;
-    let dst = tile.data32;
-    let src = target.data32;
-    let startX = tile.tx * TILE_SIZE;
-    let startY = tile.ty * TILE_SIZE;
-    let targetWidth = target.width;
-    let targetHeight = target.height;
-    let copyWidth = Math.max(0, Math.min(TILE_SIZE, targetWidth - startX));
+    const target = this.config.target;
+    const TILE_SIZE = this.config.tileSize;
+    const dst = tile.data32;
+    const src = target.data32;
+    const startX = tile.tx * TILE_SIZE;
+    const startY = tile.ty * TILE_SIZE;
+    const targetWidth = target.width;
+    const targetHeight = target.height;
+    if (startX >= targetWidth || startX + TILE_SIZE <= 0 || startY >= targetHeight || startY + TILE_SIZE <= 0) {
+      dst.fill(0);
+      return;
+    }
+    let srcOffsetX = Math.max(0, -startX);
+    let copyWidth = Math.max(0, Math.min(TILE_SIZE - srcOffsetX, targetWidth - Math.max(0, startX)));
     for (let ly = 0; ly < TILE_SIZE; ly++) {
       let globalY = startY + ly;
       let dstIndex = ly * TILE_SIZE;
@@ -2017,63 +2124,92 @@ var PixelAccumulator = class {
         dst.fill(0, dstIndex, dstIndex + TILE_SIZE);
         continue;
       }
-      let srcIndex = globalY * targetWidth + startX;
+      let srcIndex = globalY * targetWidth + Math.max(0, startX);
       let rowData = src.subarray(srcIndex, srcIndex + copyWidth);
-      dst.set(rowData, dstIndex);
-      if (copyWidth < TILE_SIZE) {
-        dst.fill(0, dstIndex + copyWidth, dstIndex + TILE_SIZE);
+      dst.set(rowData, dstIndex + srcOffsetX);
+      if (srcOffsetX > 0) {
+        dst.fill(0, dstIndex, dstIndex + srcOffsetX);
+      }
+      if (srcOffsetX + copyWidth < TILE_SIZE) {
+        dst.fill(0, dstIndex + srcOffsetX + copyWidth, dstIndex + TILE_SIZE);
       }
     }
   }
-  extractAfterTiles() {
-    let afterTiles = [];
-    let length = this.beforeTiles.length;
+  extractPatch() {
+    const afterTiles = [];
+    const length = this.beforeTiles.length;
     for (let i = 0; i < length; i++) {
       let beforeTile = this.beforeTiles[i];
       if (beforeTile) {
-        let afterTile = this.getTile(beforeTile.id, beforeTile.tx, beforeTile.ty);
+        let afterTile = this.tilePool.getTile(beforeTile.id, beforeTile.tx, beforeTile.ty);
         this.extractState(afterTile);
         afterTiles.push(afterTile);
       }
     }
-    return afterTiles;
-  }
-  reset() {
-    this.lookup = [];
+    const beforeTiles = this.beforeTiles;
     this.beforeTiles = [];
+    this.lookup.length = 0;
+    return {
+      beforeTiles,
+      afterTiles
+    };
+  }
+  rollbackAfterError() {
+    const target = this.config.target;
+    const tileSize = this.config.tileSize;
+    const length = this.beforeTiles.length;
+    applyPatchTiles(target, this.beforeTiles, tileSize);
+    for (let i = 0; i < length; i++) {
+      let tile = this.beforeTiles[i];
+      if (tile) {
+        this.lookup[tile.id] = void 0;
+        this.tilePool.releaseTile(tile);
+      }
+    }
+    this.beforeTiles.length = 0;
+    this.lookup.length = 0;
   }
 };
 
 // src/History/PixelEngineConfig.ts
 var PixelEngineConfig = class {
   tileSize;
+  // pixelX = tileX << tileShift
+  // pixelY = tileY << tileShift
   tileShift;
   tileMask;
   tileArea;
-  constructor(tileSize = 256) {
+  target;
+  targetColumns = 0;
+  targetRows = 0;
+  constructor(tileSize, target) {
     if ((tileSize & tileSize - 1) !== 0) {
       throw new Error("tileSize must be a power of 2");
     }
     this.tileSize = tileSize;
-    this.tileShift = Math.log2(tileSize);
+    this.tileShift = 31 - Math.clz32(tileSize);
     this.tileMask = tileSize - 1;
     this.tileArea = tileSize * tileSize;
+    this.target = target;
+    this.targetColumns = target.width + this.tileMask >> this.tileShift;
+    this.targetRows = target.height + this.tileMask >> this.tileShift;
   }
 };
 
-// src/PixelData/applyAlphaMaskToPixelData.ts
-function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
+// 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,
-    mx = 0,
-    my = 0,
-    invertMask = false
+    blendFn = sourceOverPerfect
   } = opts;
-  if (globalAlpha === 0) return;
+  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;
@@ -2086,257 +2222,290 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
     h += y;
     y = 0;
   }
-  w = Math.min(w, dst.width - x);
-  h = Math.min(h, dst.height - y);
-  if (w <= 0) return;
-  if (h <= 0) return;
-  const mPitch = mask.w;
-  if (mPitch <= 0) return;
-  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;
-  if (finalH <= 0) return;
-  const xShift = sX0 - startX;
-  const yShift = sY0 - startY;
+  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;
-  const dStride = dw - finalW;
-  const mStride = mPitch - finalW;
-  const maskData = mask.data;
-  let dIdx = (y + yShift) * dw + (x + xShift);
-  let mIdx = sY0 * mPitch + sX0;
-  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;
-      } else if (weight !== 255) {
-        const d = dst32[dIdx];
-        const da = d >>> 24;
-        if (da !== 0) {
-          const finalAlpha = da === 255 ? weight : da * weight + 128 >> 8;
-          dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
-        }
+  let dIdx = y * dw + x | 0;
+  const dStride = dw - actualW | 0;
+  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;
+        didChange = true;
       }
       dIdx++;
-      mIdx++;
     }
     dIdx += dStride;
-    mIdx += mStride;
   }
+  return didChange;
 }
 
-// src/History/PixelMutator/mutatorApplyAlphaMask.ts
-var defaults = {
-  applyAlphaMaskToPixelData
-};
-var mutatorApplyAlphaMask = ((writer, deps = defaults) => {
+// src/History/PixelMutator/mutatorBlendColor.ts
+var defaults2 = {
+  blendColorPixelData
+};
+var mutatorBlendColor = ((writer, deps = defaults2) => {
   const {
-    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults.applyAlphaMaskToPixelData
+    blendColorPixelData: blendColorPixelData2 = defaults2.blendColorPixelData
   } = deps;
   return {
-    applyAlphaMask: (mask, opts = {}) => {
-      let target = writer.target;
+    blendColor(color, opts = {}) {
+      const target = writer.config.target;
       const {
         x = 0,
         y = 0,
-        w = writer.target.width,
-        h = writer.target.height
+        w = target.width,
+        h = target.height
       } = opts;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      applyAlphaMaskToPixelData2(target, mask, opts);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendColorPixelData2(target, color, opts));
     }
   };
 });
 
-// src/PixelData/applyBinaryMaskToPixelData.ts
-function applyBinaryMaskToPixelData(dst, mask, 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;
+  }
+  let current = dst32[index];
+  let next = blendFn(finalColor, current);
+  if (current !== next) {
+    dst32[index] = next;
+    return true;
+  }
+  return false;
+}
+
+// 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/PixelData/blendPixelData.ts
+function blendPixelData(dst, src, opts = {}) {
   const {
     x: targetX = 0,
     y: targetY = 0,
-    w: width = dst.width,
-    h: height = dst.height,
+    sx: sourceX = 0,
+    sy: sourceY = 0,
+    w: width = src.width,
+    h: height = src.height,
     alpha: globalAlpha = 255,
-    mx = 0,
-    my = 0,
-    invertMask = false
+    blendFn = sourceOverPerfect
   } = opts;
-  if (globalAlpha === 0) return;
+  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;
   }
-  w = Math.min(w, dst.width - x);
-  h = Math.min(h, dst.height - y);
-  if (w <= 0) return;
-  if (h <= 0) return;
-  const mPitch = mask.w;
-  if (mPitch <= 0) return;
-  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;
-  if (finalH <= 0) return;
-  const xShift = sX0 - startX;
-  const yShift = sY0 - startY;
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) return false;
   const dst32 = dst.data32;
+  const src32 = src.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;
-  for (let iy = 0; iy < h; iy++) {
-    for (let ix = 0; ix < w; ix++) {
-      const mVal = maskData[mIdx];
-      const isMaskedOut = invertMask ? mVal !== 0 : mVal === 0;
-      if (isMaskedOut) {
-        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
-      } else if (globalAlpha !== 255) {
-        const d = dst32[dIdx];
-        const da = d >>> 24;
-        if (da !== 0) {
-          const finalAlpha = da === 255 ? globalAlpha : da * globalAlpha + 128 >> 8;
-          dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+  const sw = src.width;
+  let dIdx = y * dw + x | 0;
+  let sIdx = sy * sw + sx | 0;
+  const dStride = dw - actualW | 0;
+  const sStride = sw - actualW | 0;
+  const isOpaque = globalAlpha === 255;
+  const isOverwrite = blendFn.isOverwrite;
+  let didChange = false;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      const srcCol = src32[sIdx];
+      const srcAlpha = srcCol >>> 24;
+      if (srcAlpha === 0 && !isOverwrite) {
+        dIdx++;
+        sIdx++;
+        continue;
+      }
+      let finalCol = srcCol;
+      if (!isOpaque) {
+        const a = srcAlpha * globalAlpha + 128 >> 8;
+        if (a === 0 && !isOverwrite) {
+          dIdx++;
+          sIdx++;
+          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++;
-      mIdx++;
+      sIdx++;
     }
     dIdx += dStride;
-    mIdx += mStride;
+    sIdx += sStride;
   }
+  return didChange;
 }
 
-// src/History/PixelMutator/mutatorApplyBinaryMask.ts
-var defaults2 = {
-  applyBinaryMaskToPixelData
+// src/History/PixelMutator/mutatorBlendPixelData.ts
+var defaults4 = {
+  blendPixelData
 };
-var mutatorApplyBinaryMask = ((writer, deps = defaults2) => {
+var mutatorBlendPixelData = ((writer, deps = defaults4) => {
   const {
-    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults2.applyBinaryMaskToPixelData
+    blendPixelData: blendPixelData2 = defaults4.blendPixelData
   } = deps;
   return {
-    applyBinaryMask: (mask, opts = {}) => {
-      let target = writer.target;
+    blendPixelData(src, opts = {}) {
       const {
         x = 0,
         y = 0,
-        w = writer.target.width,
-        h = writer.target.height
+        w = src.width,
+        h = src.height
       } = opts;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      applyBinaryMaskToPixelData2(target, mask, opts);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendPixelData2(writer.config.target, src, opts));
     }
   };
 });
 
-// src/Rect/getCircleBrushOrPencilBounds.ts
-function getCircleBrushOrPencilBounds(centerX, centerY, brushSize, targetWidth, targetHeight, out) {
-  const r = brushSize / 2;
-  const minOffset = -Math.ceil(r - 0.5);
-  const maxOffset = Math.floor(r - 0.5);
-  const startX = Math.floor(centerX + minOffset);
-  const startY = Math.floor(centerY + minOffset);
-  const endX = Math.floor(centerX + maxOffset) + 1;
-  const endY = Math.floor(centerY + maxOffset) + 1;
-  const res = out ?? {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const cStartX = Math.max(0, startX);
-  const cStartY = Math.max(0, startY);
-  const cEndX = Math.min(targetWidth, endX);
-  const cEndY = Math.min(targetHeight, endY);
-  const w = cEndX - cStartX;
-  const h = cEndY - cStartY;
-  res.x = cStartX;
-  res.y = cStartY;
-  res.w = w < 0 ? 0 : w;
-  res.h = h < 0 ? 0 : h;
-  return res;
-}
-
-// 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;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) return;
+// 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 actualW = w;
-  let actualH = h;
+  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) {
-    actualW += x;
+    sx -= x;
+    w += x;
     x = 0;
   }
   if (y < 0) {
-    actualH += y;
+    sy -= y;
+    h += y;
     y = 0;
   }
-  actualW = Math.min(actualW, dst.width - x);
-  actualH = Math.min(actualH, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return;
+  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 dw = dst.width;
-  const mPitch = mask.w;
-  const maskData = mask.data;
+  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;
-  let mStride = mPitch - actualW | 0;
+  const sStride = sw - actualW | 0;
+  const mStride = mPitch - actualW | 0;
   const isOpaque = globalAlpha === 255;
-  const colorRGB = color & 16777215;
+  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;
       }
@@ -2348,779 +2517,915 @@ function blendColorPixelDataAlphaMask(dst, color, mask, opts = {}) {
       }
       if (weight === 0) {
         dIdx++;
+        sIdx++;
         mIdx++;
         continue;
       }
-      let finalCol = color;
+      let finalCol = srcCol;
       if (weight < 255) {
-        const a = baseSrcAlpha * weight + 128 >> 8;
+        const a = srcAlpha * weight + 128 >> 8;
         if (a === 0 && !isOverwrite) {
           dIdx++;
+          sIdx++;
           mIdx++;
           continue;
         }
-        finalCol = (colorRGB | a << 24) >>> 0;
+        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
+      }
+      const current = dst32[dIdx];
+      const next = blendFn(finalCol, dst32[dIdx]);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
       }
-      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
       dIdx++;
+      sIdx++;
       mIdx++;
     }
     dIdx += dStride;
+    sIdx += sStride;
     mIdx += mStride;
   }
+  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;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) return;
-  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;
-  let baseColorWithGlobalAlpha = color;
-  if (globalAlpha < 255) {
-    const a = baseSrcAlpha * globalAlpha + 128 >> 8;
-    if (a === 0 && !isOverwrite) return;
-    baseColorWithGlobalAlpha = (color & 16777215 | a << 24) >>> 0;
-  }
-  const dx = x - targetX | 0;
-  const dy = y - targetY | 0;
+// src/History/PixelMutator/mutatorBlendPixelDataAlphaMask.ts
+var defaults5 = {
+  blendPixelDataAlphaMask
+};
+var mutatorBlendPixelDataAlphaMask = ((writer, deps = defaults5) => {
+  const {
+    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults5.blendPixelDataAlphaMask
+  } = 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;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendPixelDataAlphaMask2(writer.config.target, src, 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;
+  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 mPitch = mask.w;
-  const maskData = mask.data;
+  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;
+      }
+      const srcCol = src32[sIdx];
+      const srcAlpha = srcCol >>> 24;
+      if (srcAlpha === 0 && !isOverwrite) {
+        dIdx++;
+        sIdx++;
         mIdx++;
         continue;
       }
-      dst32[dIdx] = blendFn(baseColorWithGlobalAlpha, dst32[dIdx]);
+      let finalCol = srcCol;
+      if (!isOpaque) {
+        const a = srcAlpha * globalAlpha + 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/PixelData/applyCircleBrushToPixelData.ts
-function applyCircleBrushToPixelData(target, color, centerX, centerY, brush, alpha = 255, blendFn = sourceOverPerfect, scratchOptions = {}, bounds) {
-  const b = bounds ?? getCircleBrushOrPencilBounds(centerX, centerY, brush.size, target.width, target.height);
-  if (b.w <= 0 || b.h <= 0) return;
-  const unclippedStartX = Math.floor(centerX + brush.minOffset);
-  const unclippedStartY = Math.floor(centerY + brush.minOffset);
-  const ix = Math.max(unclippedStartX, b.x);
-  const iy = Math.max(unclippedStartY, b.y);
-  const ir = Math.min(unclippedStartX + brush.w, b.x + b.w);
-  const ib = Math.min(unclippedStartY + brush.h, b.y + b.h);
-  const iw = ir - ix;
-  const ih = ib - iy;
-  if (iw <= 0 || ih <= 0) return;
-  scratchOptions.x = ix;
-  scratchOptions.y = iy;
-  scratchOptions.w = iw;
-  scratchOptions.h = ih;
-  scratchOptions.mx = ix - unclippedStartX;
-  scratchOptions.my = iy - unclippedStartY;
-  scratchOptions.alpha = alpha;
-  scratchOptions.blendFn = blendFn;
-  if (brush.type === 0 /* ALPHA */) {
-    blendColorPixelDataAlphaMask(target, color, brush, scratchOptions);
-  }
-  if (brush.type === 1 /* BINARY */) {
-    blendColorPixelDataBinaryMask(target, color, brush, scratchOptions);
-  }
-}
-
-// src/History/PixelMutator/mutatorApplyCircleBrush.ts
-var defaults3 = {
-  applyCircleBrushToPixelData,
-  getCircleBrushOrPencilBounds
+// src/History/PixelMutator/mutatorBlendPixelDataBinaryMask.ts
+var defaults6 = {
+  blendPixelDataBinaryMask
 };
-var mutatorApplyCircleBrush = ((writer, deps = defaults3) => {
+var mutatorBlendPixelDataBinaryMask = ((writer, deps = defaults6) => {
   const {
-    applyCircleBrushToPixelData: applyCircleBrushToPixelData2 = defaults3.applyCircleBrushToPixelData,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults3.getCircleBrushOrPencilBounds
+    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults6.blendPixelDataBinaryMask
   } = deps;
-  const boundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const blendColorPixelOptions = {
-    alpha: 255,
-    blendFn: sourceOverPerfect,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
   return {
-    applyCircleBrush(color, centerX, centerY, brush, alpha = 255, blendFn) {
-      const bounds = getCircleBrushOrPencilBounds2(centerX, centerY, brush.size, writer.target.width, writer.target.height, boundsOut);
-      const {
-        x,
-        y,
-        w,
-        h
-      } = bounds;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      applyCircleBrushToPixelData2(writer.target, color, centerX, centerY, brush, alpha, blendFn, blendColorPixelOptions, bounds);
+    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;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendPixelDataBinaryMask2(writer.config.target, src, mask, opts));
     }
   };
 });
 
-// src/Algorithm/forEachLinePoint.ts
-function forEachLinePoint(x0, y0, x1, y1, callback) {
-  const dx = x1 - x0;
-  const dy = y1 - y0;
-  const steps = Math.max(Math.abs(dx), Math.abs(dy));
-  if (steps === 0) {
-    callback(x0, y0);
+// 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 {
+    x = 0;
+    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 xInc = dx / steps;
-  const yInc = dy / steps;
-  let curX = x0;
-  let curY = y0;
-  for (let i = 0; i <= steps; i++) {
-    callback(curX, curY);
-    curX += xInc;
-    curY += yInc;
+  for (let iy = 0; iy < actualH; iy++) {
+    const start = (finalY + iy) * dw + finalX;
+    const end = start + actualW;
+    dst32.fill(color, start, end);
   }
 }
 
-// src/Rect/getCircleBrushOrPencilStrokeBounds.ts
-function getCircleBrushOrPencilStrokeBounds(x0, y0, x1, y1, brushSize, result) {
-  const r = Math.ceil(brushSize / 2);
-  const minX = Math.min(x0, x1) - r;
-  const minY = Math.min(y0, y1) - r;
-  const maxX = Math.max(x0, x1) + r;
-  const maxY = Math.max(x0, y1) + r;
-  result.x = Math.floor(minX);
-  result.y = Math.floor(minY);
-  result.w = Math.ceil(maxX - minX);
-  result.h = Math.ceil(maxY - minY);
-  return result;
-}
-
-// src/History/PixelMutator/mutatorApplyCircleBrushStroke.ts
-var defaults4 = {
-  forEachLinePoint,
-  blendColorPixelDataAlphaMask,
-  getCircleBrushOrPencilBounds,
-  getCircleBrushOrPencilStrokeBounds
+// src/History/PixelMutator/mutatorClear.ts
+var defaults7 = {
+  fillPixelData: fillPixelDataFast
 };
-var mutatorApplyCircleBrushStroke = ((writer, deps = defaults4) => {
+var mutatorClear = ((writer, deps = defaults7) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults4.forEachLinePoint,
-    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults4.blendColorPixelDataAlphaMask,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults4.getCircleBrushOrPencilBounds,
-    getCircleBrushOrPencilStrokeBounds: getCircleBrushOrPencilStrokeBounds2 = defaults4.getCircleBrushOrPencilStrokeBounds
+    fillPixelData: fillPixelData2 = defaults7.fillPixelData
   } = deps;
-  const strokeBoundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const circleBrushBounds = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const blendColorPixelOptions = {
-    alpha: 255,
-    blendFn: sourceOverPerfect,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const mask = {
-    type: 0 /* ALPHA */,
-    data: null,
-    w: 0,
-    h: 0
-  };
   return {
-    applyCircleBrushStroke(color, x0, y0, x1, y1, brush, alpha = 255, blendFn = sourceOverPerfect) {
-      const brushSize = brush.size;
-      const {
-        x: bx,
-        y: by,
-        w: bw,
-        h: bh
-      } = getCircleBrushOrPencilStrokeBounds2(x0, y0, x1, y1, brushSize, strokeBoundsOut);
-      if (bw <= 0 || bh <= 0) return;
-      mask.data = new Uint8Array(bw * bh);
-      mask.w = bw;
-      mask.h = bh;
-      const maskData = mask.data;
-      const brushData = brush.data;
-      const minOffset = brush.minOffset;
-      const targetWidth = writer.target.width;
-      const targetHeight = writer.target.height;
-      forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
-        const {
-          x: cbx,
-          y: cby,
-          w: cbw,
-          h: cbh
-        } = getCircleBrushOrPencilBounds2(px, py, brushSize, targetWidth, targetHeight, circleBrushBounds);
-        writer.accumulator.storeRegionBeforeState(cbx, cby, cbw, cbh);
-        const startX = Math.max(bx, cbx);
-        const startY = Math.max(by, cby);
-        const endX = Math.min(bx + bw, cbx + cbw);
-        const endY = Math.min(by + bh, cby + cbh);
-        const unclippedStartX = Math.floor(px + minOffset);
-        const unclippedStartY = Math.floor(py + minOffset);
-        for (let my = startY; my < endY; my++) {
-          const strokeMaskY = my - by;
-          const strokeMaskRowOffset = strokeMaskY * bw;
-          const brushY = my - unclippedStartY;
-          const brushRowOffset = brushY * brushSize;
-          for (let mx = startX; mx < endX; mx++) {
-            const brushX = mx - unclippedStartX;
-            const brushVal = brushData[brushRowOffset + brushX];
-            if (brushVal > 0) {
-              const strokeMaskIdx = strokeMaskRowOffset + (mx - bx);
-              if (brushVal > maskData[strokeMaskIdx]) {
-                maskData[strokeMaskIdx] = brushVal;
-              }
-            }
-          }
-        }
-      });
-      blendColorPixelOptions.blendFn = blendFn;
-      blendColorPixelOptions.alpha = alpha;
-      blendColorPixelOptions.x = bx;
-      blendColorPixelOptions.y = by;
-      blendColorPixelOptions.w = bw;
-      blendColorPixelOptions.h = bh;
-      blendColorPixelDataAlphaMask2(writer.target, color, mask, blendColorPixelOptions);
+    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;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      fillPixelData2(target, 0, x, y, w, h);
     }
   };
 });
 
-// src/History/PixelMutator/mutatorApplyCirclePencil.ts
-var defaults5 = {
-  applyCircleBrushToPixelData,
-  getCircleBrushOrPencilBounds
+// 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 {
+    x = 0;
+    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;
+  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;
+      }
+    }
+  }
+  return hasChanged;
+}
+
+// src/History/PixelMutator/mutatorFill.ts
+var defaults8 = {
+  fillPixelData
 };
-var mutatorApplyCirclePencil = ((writer, deps = defaults5) => {
+var mutatorFill = ((writer, deps = defaults8) => {
   const {
-    applyCircleBrushToPixelData: applyCircleBrushToPixelData2 = defaults5.applyCircleBrushToPixelData,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults5.getCircleBrushOrPencilBounds
+    fillPixelData: fillPixelData2 = defaults8.fillPixelData
   } = deps;
-  const boundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
   return {
-    applyCirclePencil(color, centerX, centerY, brush, alpha = 255, blendFn) {
-      const bounds = getCircleBrushOrPencilBounds2(centerX, centerY, brush.size, writer.target.width, writer.target.height, boundsOut);
-      const {
-        x,
-        y,
-        w,
-        h
-      } = bounds;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      applyCircleBrushToPixelData2(writer.target, color, centerX, centerY, brush, alpha, blendFn, bounds);
+    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));
     }
   };
 });
-
-// src/History/PixelMutator/mutatorApplyCirclePencilStroke.ts
-var defaults6 = {
-  forEachLinePoint,
-  blendColorPixelDataBinaryMask,
-  getCircleBrushOrPencilBounds,
-  getCircleBrushOrPencilStrokeBounds
-};
-var mutatorApplyCirclePencilStroke = ((writer, deps = defaults6) => {
+var mutatorFillRect = ((writer, deps = defaults8) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults6.forEachLinePoint,
-    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults6.blendColorPixelDataBinaryMask,
-    getCircleBrushOrPencilStrokeBounds: getCircleBrushOrPencilStrokeBounds2 = defaults6.getCircleBrushOrPencilStrokeBounds,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults6.getCircleBrushOrPencilBounds
+    fillPixelData: fillPixelData2 = defaults8.fillPixelData
   } = deps;
-  const strokeBoundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const circlePencilBounds = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const blendColorPixelOptions = {
-    alpha: 255,
-    blendFn: sourceOverPerfect,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const mask = {
-    type: 1 /* BINARY */,
-    data: null,
-    w: 0,
-    h: 0
-  };
   return {
-    applyCirclePencilStroke(color, x0, y0, x1, y1, brush, alpha = 255, blendFn = sourceOverPerfect) {
-      const {
-        x: bx,
-        y: by,
-        w: bw,
-        h: bh
-      } = getCircleBrushOrPencilStrokeBounds2(x0, y0, x1, y1, brush.size, strokeBoundsOut);
-      if (bw <= 0 || bh <= 0) return;
-      mask.data = new Uint8Array(bw * bh);
-      mask.w = bw;
-      mask.h = bh;
-      const maskData = mask.data;
-      const targetWidth = writer.target.width;
-      const targetHeight = writer.target.height;
-      forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
-        const {
-          x: cbx,
-          y: cby,
-          w: cbw,
-          h: cbh
-        } = getCircleBrushOrPencilBounds2(px, py, brush.size, targetWidth, targetHeight, circlePencilBounds);
-        writer.accumulator.storeRegionBeforeState(cbx, cby, cbw, cbh);
-        const unclippedStartX = Math.floor(px + brush.minOffset);
-        const unclippedStartY = Math.floor(py + brush.minOffset);
-        const startX = Math.max(bx, unclippedStartX);
-        const startY = Math.max(by, unclippedStartY);
-        const endX = Math.min(bx + bw, unclippedStartX + brush.w);
-        const endY = Math.min(by + bh, unclippedStartY + brush.h);
-        for (let my = startY; my < endY; my++) {
-          const brushY = my - unclippedStartY;
-          const maskRowOffset = (my - by) * bw;
-          const brushRowOffset = brushY * brush.w;
-          for (let mx = startX; mx < endX; mx++) {
-            const brushX = mx - unclippedStartX;
-            const brushAlpha = brush.data[brushRowOffset + brushX];
-            if (brushAlpha > 0) {
-              const maskIdx = maskRowOffset + (mx - bx);
-              maskData[maskIdx] = brushAlpha;
-            }
-          }
-        }
-      });
-      blendColorPixelOptions.blendFn = blendFn;
-      blendColorPixelOptions.alpha = alpha;
-      blendColorPixelOptions.x = bx;
-      blendColorPixelOptions.y = by;
-      blendColorPixelOptions.w = bw;
-      blendColorPixelOptions.h = bh;
-      blendColorPixelDataBinaryMask2(writer.target, color, mask, blendColorPixelOptions);
+    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/Rect/getRectBrushOrPencilBounds.ts
-function getRectBrushOrPencilBounds(centerX, centerY, brushWidth, brushHeight, targetWidth, targetHeight, out) {
-  const startX = Math.floor(centerX - brushWidth / 2);
-  const startY = Math.floor(centerY - brushHeight / 2);
-  const endX = startX + brushWidth;
-  const endY = startY + brushHeight;
-  const res = out ?? {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const cStartX = Math.max(0, startX);
-  const cStartY = Math.max(0, startY);
-  const cEndX = Math.min(targetWidth, endX);
-  const cEndY = Math.min(targetHeight, endY);
-  const w = cEndX - cStartX;
-  const h = cEndY - cStartY;
-  res.x = cStartX;
-  res.y = cStartY;
-  res.w = w < 0 ? 0 : w;
-  res.h = h < 0 ? 0 : h;
-  return res;
-}
-
-// src/PixelData/applyRectBrushToPixelData.ts
-function applyRectBrushToPixelData(target, color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn = sourceOverPerfect, bounds) {
-  const targetWidth = target.width;
-  const targetHeight = target.height;
-  const b = bounds ?? getRectBrushOrPencilBounds(centerX, centerY, brushWidth, brushHeight, targetWidth, targetHeight);
-  if (b.w <= 0 || b.h <= 0) return;
-  const data32 = target.data32;
-  const baseColor = color & 16777215;
-  const baseSrcAlpha = color >>> 24;
-  const isOpaque = alpha === 255;
-  const invHalfW = 1 / (brushWidth / 2);
-  const invHalfH = 1 / (brushHeight / 2);
-  const centerOffsetX = brushWidth % 2 === 0 ? 0.5 : 0;
-  const centerOffsetY = brushHeight % 2 === 0 ? 0.5 : 0;
-  const fCenterX = Math.floor(centerX);
-  const fCenterY = Math.floor(centerY);
-  const endX = b.x + b.w;
-  const endY = b.y + b.h;
-  const isOverwrite = blendFn.isOverwrite;
-  for (let py = b.y; py < endY; py++) {
-    const rowOffset = py * targetWidth;
-    const dy = Math.abs(py - fCenterY + centerOffsetY) * invHalfH;
-    for (let px = b.x; px < endX; px++) {
-      const idx = rowOffset + px;
-      const dx = Math.abs(px - fCenterX + centerOffsetX) * invHalfW;
-      const dist = dx > dy ? dx : dy;
-      const strength = fallOff(dist);
-      const maskVal = strength * 255 | 0;
-      if (maskVal <= 0) continue;
-      let weight = alpha;
-      if (isOpaque) {
-        weight = maskVal;
-      } else if (maskVal !== 255) {
-        weight = maskVal * alpha + 128 >> 8;
-      }
-      let finalCol = color;
-      if (weight < 255) {
-        const a = baseSrcAlpha * weight + 128 >> 8;
-        if (a === 0 && !isOverwrite) continue;
-        finalCol = (a << 24 | baseColor) >>> 0;
+// 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;
+        }
       }
-      data32[idx] = blendFn(finalCol, data32[idx]);
     }
   }
+  return hasChanged;
 }
 
-// src/History/PixelMutator/mutatorApplyRectBrush.ts
-var defaults7 = {
-  applyRectBrushToPixelData,
-  getRectBrushOrPencilBounds
+// src/History/PixelMutator/mutatorFillBinaryMask.ts
+var defaults9 = {
+  fillPixelDataBinaryMask
 };
-var mutatorApplyRectBrush = ((writer, deps = defaults7) => {
+var mutatorFillBinaryMask = ((writer, deps = defaults9) => {
   const {
-    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults7.applyRectBrushToPixelData,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults7.getRectBrushOrPencilBounds
+    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults9.fillPixelDataBinaryMask
   } = deps;
-  const boundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
   return {
-    applyRectBrush(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn) {
-      const bounds = getRectBrushOrPencilBounds2(centerX, centerY, brushWidth, brushHeight, writer.target.width, writer.target.height, boundsOut);
-      const {
-        x,
-        y,
-        w,
-        h
-      } = bounds;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      applyRectBrushToPixelData2(writer.target, color, centerX, centerY, brushWidth, brushHeight, alpha, fallOff, blendFn, bounds);
+    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));
     }
   };
 });
 
-// src/Rect/getRectBrushOrPencilStrokeBounds.ts
-function getRectBrushOrPencilStrokeBounds(x0, y0, x1, y1, brushWidth, brushHeight, result) {
-  const halfW = brushWidth / 2;
-  const halfH = brushHeight / 2;
-  const minX = Math.min(x0, x1) - halfW;
-  const minY = Math.min(y0, y1) - halfH;
-  const maxX = Math.max(x0, x1) + halfW;
-  const maxY = Math.max(y0, y1) + halfH;
-  result.x = Math.floor(minX);
-  result.y = Math.floor(minY);
-  result.w = Math.ceil(maxX - minX);
-  result.h = Math.ceil(maxY - minY);
-  return result;
+// 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;
+  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++;
+      }
+      dIdx += dStride;
+    }
+  }
+  return true;
 }
 
-// src/History/PixelMutator/mutatorApplyRectBrushStroke.ts
-var defaults8 = {
-  forEachLinePoint,
-  blendColorPixelDataAlphaMask,
-  getRectBrushOrPencilBounds,
-  getRectBrushOrPencilStrokeBounds
+// src/History/PixelMutator/mutatorInvert.ts
+var defaults10 = {
+  invertPixelData
 };
-var mutatorApplyRectBrushStroke = ((writer, deps = defaults8) => {
+var mutatorInvert = ((writer, deps = defaults10) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults8.forEachLinePoint,
-    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults8.blendColorPixelDataAlphaMask,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults8.getRectBrushOrPencilBounds,
-    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults8.getRectBrushOrPencilStrokeBounds
+    invertPixelData: invertPixelData2 = defaults10.invertPixelData
   } = deps;
-  const strokeBoundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const rectBrushBounds = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const blendColorPixelOptions = {
-    alpha: 255,
-    blendFn: sourceOverPerfect,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const mask = {
-    type: 0 /* ALPHA */,
-    data: null,
-    w: 0,
-    h: 0
-  };
   return {
-    applyRectBrushStroke(color, x0, y0, x1, y1, brushWidth, brushHeight, alpha = 255, fallOff, blendFn = sourceOverPerfect) {
+    invert(opts = {}) {
+      const target = writer.config.target;
       const {
-        x: bx,
-        y: by,
-        w: bw,
-        h: bh
-      } = getRectBrushOrPencilStrokeBounds2(x0, y0, x1, y1, brushWidth, brushHeight, strokeBoundsOut);
-      if (bw <= 0 || bh <= 0) return;
-      mask.data = new Uint8Array(bw * bh);
-      mask.w = bw;
-      mask.h = bh;
-      const maskData = mask.data;
-      const halfW = brushWidth / 2;
-      const halfH = brushHeight / 2;
-      const invHalfW = 1 / halfW;
-      const invHalfH = 1 / halfH;
-      const centerOffsetX = brushWidth % 2 === 0 ? 0.5 : 0;
-      const centerOffsetY = brushHeight % 2 === 0 ? 0.5 : 0;
-      const targetWidth = writer.target.width;
-      const targetHeight = writer.target.height;
-      forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
-        const {
-          x: rbx,
-          y: rby,
-          w: rbw,
-          h: rbh
-        } = getRectBrushOrPencilBounds2(px, py, brushWidth, brushHeight, targetWidth, targetHeight, rectBrushBounds);
-        writer.accumulator.storeRegionBeforeState(rbx, rby, rbw, rbh);
-        const startX = Math.max(bx, rbx);
-        const startY = Math.max(by, rby);
-        const endX = Math.min(bx + bw, rbx + rbw);
-        const endY = Math.min(by + bh, rby + rbh);
-        const fPx = Math.floor(px);
-        const fPy = Math.floor(py);
-        for (let my = startY; my < endY; my++) {
-          const dy = Math.abs(my - fPy + centerOffsetY) * invHalfH;
-          const maskRowOffset = (my - by) * bw;
-          for (let mx = startX; mx < endX; mx++) {
-            const dx = Math.abs(mx - fPx + centerOffsetX) * invHalfW;
-            const maskIdx = maskRowOffset + (mx - bx);
-            const dist = dx > dy ? dx : dy;
-            const strength = fallOff(dist);
-            if (strength > 0) {
-              const intensity = strength * 255 | 0;
-              if (intensity > maskData[maskIdx]) {
-                maskData[maskIdx] = intensity;
-              }
-            }
-          }
-        }
-      });
-      blendColorPixelOptions.blendFn = blendFn;
-      blendColorPixelOptions.alpha = alpha;
-      blendColorPixelOptions.x = bx;
-      blendColorPixelOptions.y = by;
-      blendColorPixelOptions.w = bw;
-      blendColorPixelOptions.h = bh;
-      blendColorPixelDataAlphaMask2(writer.target, color, mask, blendColorPixelOptions);
+        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));
     }
   };
 });
 
-// src/History/PixelMutator/mutatorApplyRectPencil.ts
-var defaults9 = {
-  applyRectBrushToPixelData,
-  getRectBrushOrPencilBounds,
-  fallOff: () => 1
-};
-var mutatorApplyRectPencil = ((writer, deps = defaults9) => {
-  const {
-    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults9.applyRectBrushToPixelData,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults9.getRectBrushOrPencilBounds,
-    fallOff = defaults9.fallOff
-  } = deps;
-  const boundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
+// src/History/PixelMutator.ts
+function makeFullPixelMutator(writer) {
   return {
-    applyRectPencil(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, blendFn) {
-      const bounds = getRectBrushOrPencilBounds2(centerX, centerY, brushWidth, brushHeight, writer.target.width, writer.target.height, boundsOut);
-      const {
-        x,
-        y,
-        w,
-        h
-      } = bounds;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      applyRectBrushToPixelData2(writer.target, color, centerX, centerY, brushWidth, brushHeight, alpha, fallOff, blendFn, bounds);
-    }
+    // @sort
+    ...mutatorBlendColor(writer),
+    ...mutatorBlendPixel(writer),
+    ...mutatorBlendPixelData(writer),
+    ...mutatorBlendPixelDataAlphaMask(writer),
+    ...mutatorBlendPixelDataBinaryMask(writer),
+    ...mutatorClear(writer),
+    ...mutatorFill(writer),
+    ...mutatorFillBinaryMask(writer),
+    ...mutatorFillRect(writer),
+    ...mutatorInvert(writer)
   };
-});
+}
 
-// src/History/PixelMutator/mutatorApplyRectPencilStroke.ts
-var defaults10 = {
-  forEachLinePoint,
-  getRectBrushOrPencilBounds,
-  getRectBrushOrPencilStrokeBounds,
-  blendColorPixelDataBinaryMask
-};
-var mutatorApplyRectPencilStroke = ((writer, deps = defaults10) => {
+// src/ImageData/resizeImageData.ts
+function resizeImageData(target, newWidth, newHeight, offsetX = 0, offsetY = 0) {
+  const result = new ImageData(newWidth, newHeight);
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults10.forEachLinePoint,
-    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults10.blendColorPixelDataBinaryMask,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults10.getRectBrushOrPencilBounds,
-    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults10.getRectBrushOrPencilStrokeBounds
-  } = deps;
-  const strokeBoundsOut = {
+    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;
+  }
+  const rowCount = y1 - y0;
+  const rowLen = (x1 - x0) * 4;
+  for (let row = 0; row < rowCount; row++) {
+    const dstY = y0 + row;
+    const srcY = dstY - offsetY;
+    const srcX = x0 - offsetX;
+    const dstStart = (dstY * newWidth + x0) * 4;
+    const srcStart = (srcY * oldW + srcX) * 4;
+    newData.set(oldData.subarray(srcStart, srcStart + rowLen), dstStart);
+  }
+  return result;
+}
+
+// src/Internal/helpers.ts
+var macro_halfAndFloor = (value) => value >> 1;
+
+// 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 rectPencilBounds = {
+  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 = [];
+  }
+  lookup;
+  scratchBounds = {
     x: 0,
     y: 0,
     w: 0,
     h: 0
   };
-  const blendColorPixelOptions = {
-    alpha: 255,
+  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
   };
-  const mask = {
-    type: 1 /* BINARY */,
-    data: null,
-    w: 0,
-    h: 0
-  };
-  return {
-    applyRectPencilStroke(color, x0, y0, x1, y1, brushWidth, brushHeight, alpha = 255, blendFn = sourceOverPerfect) {
-      const {
-        x: bx,
-        y: by,
-        w: bw,
-        h: bh
-      } = getRectBrushOrPencilStrokeBounds2(x0, y0, x1, y1, brushWidth, brushHeight, strokeBoundsOut);
-      if (bw <= 0 || bh <= 0) return;
-      mask.data = new Uint8Array(bw * bh);
-      mask.w = bw;
-      mask.h = bh;
-      const maskData = mask.data;
-      const halfW = brushWidth / 2;
-      const halfH = brushHeight / 2;
-      const centerOffset = brushWidth % 2 === 0 ? 0.5 : 0;
-      const targetWidth = writer.target.width;
-      const targetHeight = writer.target.height;
-      forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
-        const {
-          x: rbx,
-          y: rby,
-          w: rbw,
-          h: rbh
-        } = getRectBrushOrPencilBounds2(px, py, brushWidth, brushHeight, targetWidth, targetHeight, rectPencilBounds);
-        writer.accumulator.storeRegionBeforeState(rbx, rby, rbw, rbh);
-        const startX = Math.max(bx, rbx);
-        const startY = Math.max(by, rby);
-        const endX = Math.min(bx + bw, rbx + rbw);
-        const endY = Math.min(by + bh, rby + rbh);
-        const fPx = Math.floor(px);
-        const fPy = Math.floor(py);
-        for (let my = startY; my < endY; my++) {
-          const dy = Math.abs(my - fPy + centerOffset);
-          const maskRowOffset = (my - by) * bw;
-          for (let mx = startX; mx < endX; mx++) {
-            const dx = Math.abs(mx - fPx + centerOffset);
-            const maskIdx = maskRowOffset + (mx - bx);
-            if (dx <= halfW && dy <= halfH) {
-              maskData[maskIdx] = 1;
-            }
-          }
-        }
-      });
-      blendColorPixelOptions.blendFn = blendFn;
-      blendColorPixelOptions.alpha = alpha;
-      blendColorPixelOptions.x = bx;
-      blendColorPixelOptions.y = by;
-      blendColorPixelOptions.w = bw;
-      blendColorPixelOptions.h = bh;
-      blendColorPixelDataBinaryMask2(writer.target, color, mask, blendColorPixelOptions);
+  _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/blendColorPixelData.ts
-function blendColorPixelData(dst, color, opts = {}) {
+// src/PixelData/applyAlphaMaskToPixelData.ts
+function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
   const {
     x: targetX = 0,
     y: targetY = 0,
     w: width = dst.width,
     h: height = dst.height,
     alpha: globalAlpha = 255,
-    blendFn = sourceOverPerfect
+    mx = 0,
+    my = 0,
+    invertMask = false
   } = opts;
-  if (globalAlpha === 0) return;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) return;
-  let x = targetX, y = targetY, w = width, h = height;
+  if (globalAlpha === 0) return false;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
   if (x < 0) {
     w += x;
     x = 0;
@@ -3129,723 +3434,200 @@ 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;
-  let finalSrcColor = color;
-  if (globalAlpha < 255) {
-    const a = baseSrcAlpha * globalAlpha + 128 >> 8;
-    if (a === 0 && !isOverwrite) return;
-    finalSrcColor = (color & 16777215 | a << 24) >>> 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;
   const dst32 = dst.data32;
   const dw = dst.width;
-  let dIdx = y * dw + x | 0;
-  const dStride = dw - actualW | 0;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      dst32[dIdx] = blendFn(finalSrcColor, dst32[dIdx]);
+  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;
+          }
+        }
+      }
       dIdx++;
+      mIdx++;
     }
     dIdx += dStride;
+    mIdx += mStride;
   }
+  return didChange;
 }
 
-// src/History/PixelMutator/mutatorBlendColor.ts
+// src/History/PixelMutator/mutatorApplyAlphaMask.ts
 var defaults11 = {
-  blendColorPixelData
+  applyAlphaMaskToPixelData
 };
-var mutatorBlendColor = ((writer, deps = defaults11) => {
+var mutatorApplyAlphaMask = ((writer, deps = defaults11) => {
   const {
-    blendColorPixelData: blendColorPixelData2 = defaults11.blendColorPixelData
+    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults11.applyAlphaMaskToPixelData
   } = deps;
   return {
-    blendColor(color, opts = {}) {
+    applyAlphaMask(mask, opts = {}) {
+      let target = writer.config.target;
       const {
         x = 0,
         y = 0,
-        w = writer.target.width,
-        h = writer.target.height
+        w = target.width,
+        h = target.height
       } = opts;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      blendColorPixelData2(writer.target, color, opts);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(applyAlphaMaskToPixelData2(target, mask, opts));
     }
   };
 });
 
-// src/History/PixelMutator/mutatorBlendPixel.ts
-function mutatorBlendPixel(writer) {
-  return {
-    blendPixel(x, y, color, alpha = 255, blendFn = overwriteFast) {
-      let target = writer.target;
-      let width = target.width;
-      let height = target.height;
-      if (x < 0 || x >= width || y < 0 || y >= height) return;
-      writer.accumulator.storeTileBeforeState(x, y);
-      let index = y * width + x;
-      let bg = target.data32[index];
-      let finalColor = color;
-      if (alpha < 255) {
-        let baseSrcAlpha = color >>> 24;
-        let finalAlpha = baseSrcAlpha * alpha + 128 >> 8;
-        finalColor = (color & 16777215 | finalAlpha << 24) >>> 0;
-      }
-      target.data32[index] = blendFn(finalColor, bg);
-    }
-  };
-}
-
-// src/PixelData/blendPixelData.ts
-function blendPixelData(dst, src, opts = {}) {
+// src/PixelData/applyBinaryMaskToPixelData.ts
+function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
   const {
     x: targetX = 0,
     y: targetY = 0,
-    sx: sourceX = 0,
-    sy: sourceY = 0,
-    w: width = src.width,
-    h: height = src.height,
+    w: width = dst.width,
+    h: height = dst.height,
     alpha: globalAlpha = 255,
-    blendFn = sourceOverPerfect
+    mx = 0,
+    my = 0,
+    invertMask = false
   } = opts;
-  if (globalAlpha === 0) return;
+  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;
-  const dst32 = dst.data32;
-  const src32 = src.data32;
-  const dw = dst.width;
-  const sw = src.width;
-  let dIdx = y * dw + x | 0;
-  let sIdx = sy * sw + sx | 0;
-  const dStride = dw - actualW | 0;
-  const sStride = sw - actualW | 0;
-  const isOpaque = globalAlpha === 255;
-  const isOverwrite = blendFn.isOverwrite;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      const srcCol = src32[sIdx];
-      const srcAlpha = srcCol >>> 24;
-      if (srcAlpha === 0 && !isOverwrite) {
-        dIdx++;
-        sIdx++;
-        continue;
-      }
-      let finalCol = srcCol;
-      if (!isOpaque) {
-        const a = srcAlpha * globalAlpha + 128 >> 8;
-        if (a === 0 && !isOverwrite) {
-          dIdx++;
-          sIdx++;
-          continue;
-        }
-        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
-      }
-      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
-      dIdx++;
-      sIdx++;
-    }
-    dIdx += dStride;
-    sIdx += sStride;
-  }
-}
-
-// src/History/PixelMutator/mutatorBlendPixelData.ts
-var defaults12 = {
-  blendPixelData
-};
-var mutatorBlendPixelData = ((writer, deps = defaults12) => {
-  const {
-    blendPixelData: blendPixelData2 = defaults12.blendPixelData
-  } = deps;
-  return {
-    blendPixelData(src, opts = {}) {
-      const {
-        x = 0,
-        y = 0,
-        w = src.width,
-        h = src.height
-      } = opts;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      blendPixelData2(writer.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;
-  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;
-  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;
-  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;
-      }
-      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
-      dIdx++;
-      sIdx++;
-      mIdx++;
-    }
-    dIdx += dStride;
-    sIdx += sStride;
-    mIdx += mStride;
-  }
-}
-
-// src/History/PixelMutator/mutatorBlendPixelDataAlphaMask.ts
-var defaults13 = {
-  blendPixelDataAlphaMask
-};
-var mutatorBlendPixelDataAlphaMask = ((writer, deps = defaults13) => {
-  const {
-    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults13.blendPixelDataAlphaMask
-  } = 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;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      blendPixelDataAlphaMask2(writer.target, src, 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;
-  if (globalAlpha === 0) return;
-  let x = targetX;
-  let y = targetY;
-  let sx = sourceX;
-  let sy = sourceY;
-  let w = width;
-  let h = height;
-  if (sx < 0) {
-    x -= sx;
-    w += sx;
-    sx = 0;
-  }
-  if (sy < 0) {
-    y -= sy;
-    h += sy;
-    sy = 0;
-  }
-  w = Math.min(w, src.width - sx);
-  h = Math.min(h, src.height - sy);
-  if (x < 0) {
-    sx -= x;
-    w += x;
-    x = 0;
-  }
-  if (y < 0) {
-    sy -= y;
-    h += y;
-    y = 0;
-  }
-  const actualW = Math.min(w, dst.width - x);
-  const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return;
-  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;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      if (maskData[mIdx] === skipVal) {
-        dIdx++;
-        sIdx++;
-        mIdx++;
-        continue;
-      }
-      const srcCol = src32[sIdx];
-      const srcAlpha = srcCol >>> 24;
-      if (srcAlpha === 0 && !isOverwrite) {
-        dIdx++;
-        sIdx++;
-        mIdx++;
-        continue;
-      }
-      let finalCol = srcCol;
-      if (!isOpaque) {
-        const a = srcAlpha * globalAlpha + 128 >> 8;
-        if (a === 0 && !isOverwrite) {
-          dIdx++;
-          sIdx++;
-          mIdx++;
-          continue;
-        }
-        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
-      }
-      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
-      dIdx++;
-      sIdx++;
-      mIdx++;
-    }
-    dIdx += dStride;
-    sIdx += sStride;
-    mIdx += mStride;
-  }
-}
-
-// src/History/PixelMutator/mutatorBlendPixelDataBinaryMask.ts
-var defaults14 = {
-  blendPixelDataBinaryMask
-};
-var mutatorBlendPixelDataBinaryMask = ((writer, deps = defaults14) => {
-  const {
-    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults14.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;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      blendPixelDataBinaryMask2(writer.target, src, mask, opts);
-    }
-  };
-});
-
-// 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;
-  }
-  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;
-  }
-  for (let iy = 0; iy < actualH; iy++) {
-    const start = (finalY + iy) * dw + finalX;
-    const end = start + actualW;
-    dst32.fill(color, start, end);
-  }
-}
-
-// src/History/PixelMutator/mutatorClear.ts
-var defaults15 = {
-  fillPixelData
-};
-var mutatorClear = ((writer, deps = defaults15) => {
-  const {
-    fillPixelData: fillPixelData2 = defaults15.fillPixelData
-  } = deps;
-  return {
-    clear(rect = {}) {
-      const x = rect.x ?? 0;
-      const y = rect.y ?? 0;
-      const w = rect.w ?? writer.target.width;
-      const h = rect.h ?? writer.target.height;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      fillPixelData2(writer.target, 0, x, y, w, h);
-    }
-  };
-});
-
-// src/History/PixelMutator/mutatorFill.ts
-var defaults16 = {
-  fillPixelData
-};
-var mutatorFill = ((writer, deps = defaults16) => {
-  const {
-    fillPixelData: fillPixelData2 = defaults16.fillPixelData
-  } = deps;
-  return {
-    fill(color, rect = {}) {
-      const {
-        x = 0,
-        y = 0,
-        w = writer.target.width,
-        h = writer.target.height
-      } = rect;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      fillPixelData2(writer.target, color, x, y, w, h);
-    }
-  };
-});
-
-// src/PixelData/fillPixelDataBinaryMask.ts
-var SCRATCH_RECT2 = makeClippedRect();
-function fillPixelDataBinaryMask(dst, color, mask, alpha = 255, x = 0, y = 0) {
-  if (alpha === 0) return;
-  const maskW = mask.w;
-  const maskH = mask.h;
-  const clip = resolveRectClipping(x, y, maskW, maskH, dst.width, dst.height, SCRATCH_RECT2);
-  if (!clip.inBounds) return;
-  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;
-  }
-  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]) {
-        dst32[dstRowOffset + currentX] = finalCol;
-      }
-    }
-  }
-}
-
-// src/History/PixelMutator/mutatorFillBinaryMask.ts
-var defaults17 = {
-  fillPixelDataBinaryMask
-};
-var mutatorFillBinaryMask = ((writer, deps = defaults17) => {
-  const {
-    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults17.fillPixelDataBinaryMask
-  } = deps;
-  return {
-    fillBinaryMask(color, mask, alpha = 255, x = 0, y = 0) {
-      writer.accumulator.storeRegionBeforeState(x, y, mask.w, mask.h);
-      fillPixelDataBinaryMask2(writer.target, color, mask, alpha, x, y);
-    }
-  };
-});
-
-// src/PixelData/invertPixelData.ts
-var SCRATCH_RECT3 = 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_RECT3);
-  if (!clip.inBounds) return;
-  const {
-    x,
-    y,
-    w: actualW,
-    h: actualH
-  } = clip;
+  }
+  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 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;
+  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;
-    }
-  } else {
-    for (let iy = 0; iy < actualH; iy++) {
-      for (let ix = 0; ix < actualW; ix++) {
-        dst32[dIdx] = dst32[dIdx] ^ 16777215;
-        dIdx++;
       }
-      dIdx += dStride;
+      dIdx++;
+      mIdx++;
     }
+    dIdx += dStride;
+    mIdx += mStride;
   }
+  return didChange;
 }
 
-// src/History/PixelMutator/mutatorInvert.ts
-var defaults18 = {
-  invertPixelData
+// src/History/PixelMutator/mutatorApplyBinaryMask.ts
+var defaults12 = {
+  applyBinaryMaskToPixelData
 };
-var mutatorInvert = ((writer, deps = defaults18) => {
+var mutatorApplyBinaryMask = ((writer, deps = defaults12) => {
   const {
-    invertPixelData: invertPixelData2 = defaults18.invertPixelData
+    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults12.applyBinaryMaskToPixelData
   } = deps;
   return {
-    invert(opts = {}) {
+    applyBinaryMask(mask, opts = {}) {
+      let target = writer.config.target;
       const {
         x = 0,
         y = 0,
-        w = writer.target.width,
-        h = writer.target.height
+        w = target.width,
+        h = target.height
       } = opts;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      invertPixelData2(writer.target, opts);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(applyBinaryMaskToPixelData2(target, mask, opts));
     }
   };
 });
 
-// src/History/PixelMutator.ts
-function makeFullPixelMutator(writer) {
-  return {
-    // @sort
-    ...mutatorApplyAlphaMask(writer),
-    ...mutatorApplyBinaryMask(writer),
-    ...mutatorApplyCircleBrush(writer),
-    ...mutatorApplyCircleBrushStroke(writer),
-    ...mutatorApplyCirclePencil(writer),
-    ...mutatorApplyCirclePencilStroke(writer),
-    ...mutatorApplyRectBrush(writer),
-    ...mutatorApplyRectBrushStroke(writer),
-    ...mutatorApplyRectPencil(writer),
-    ...mutatorApplyRectPencilStroke(writer),
-    ...mutatorBlendColor(writer),
-    ...mutatorBlendPixel(writer),
-    ...mutatorBlendPixelData(writer),
-    ...mutatorBlendPixelDataAlphaMask(writer),
-    ...mutatorBlendPixelDataBinaryMask(writer),
-    ...mutatorClear(writer),
-    ...mutatorFill(writer),
-    ...mutatorFillBinaryMask(writer),
-    ...mutatorInvert(writer)
-  };
-}
-
-// src/History/PixelWriter.ts
-var PixelWriter = class {
-  target;
-  historyManager;
-  accumulator;
-  config;
-  mutator;
-  constructor(target, mutatorFactory, {
-    tileSize = 256,
-    maxHistorySteps = 50,
-    historyManager = new HistoryManager(maxHistorySteps)
-  } = {}) {
-    this.target = target;
-    this.config = new PixelEngineConfig(tileSize);
-    this.historyManager = historyManager;
-    this.accumulator = new PixelAccumulator(target, this.config);
-    this.mutator = mutatorFactory(this);
-  }
-  withHistory(cb) {
-    cb(this.mutator);
-    this.captureHistory();
-  }
-  captureHistory() {
-    const beforeTiles = this.accumulator.beforeTiles;
-    if (beforeTiles.length === 0) return;
-    const afterTiles = this.accumulator.extractAfterTiles();
-    const patch = {
-      beforeTiles,
-      afterTiles
-    };
-    const target = this.target;
-    const tileSize = this.config.tileSize;
-    const accumulator = this.accumulator;
-    const action = {
-      undo: () => applyPatchTiles(target, patch.beforeTiles, tileSize),
-      redo: () => applyPatchTiles(target, patch.afterTiles, tileSize),
-      dispose: () => accumulator.recyclePatch(patch)
-    };
-    this.historyManager.commit(action);
-    this.accumulator.reset();
-  }
-};
-
 // src/ImageData/copyImageData.ts
 function copyImageData({
   data,
@@ -3967,44 +3749,14 @@ function resampleImageData(source, factor) {
   return new ImageData(uint8ClampedArray, width, height);
 }
 
-// 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;
-  }
-  const rowCount = y1 - y0;
-  const rowLen = (x1 - x0) * 4;
-  for (let row = 0; row < rowCount; row++) {
-    const dstY = y0 + row;
-    const srcY = dstY - offsetY;
-    const srcX = x0 - offsetX;
-    const dstStart = (dstY * newWidth + x0) * 4;
-    const srcStart = (srcY * oldW + srcX) * 4;
-    newData.set(oldData.subarray(srcStart, srcStart + rowLen), dstStart);
-  }
-  return result;
-}
-
 // src/ImageData/ReusableImageData.ts
 function makeReusableImageData() {
   let imageData = null;
   return function getReusableImageData(width, height) {
-    const hasInstance = !!imageData;
-    const widthMatches = hasInstance && imageData.width === width;
-    const heightMatches = hasInstance && imageData.height === height;
-    if (!widthMatches || !heightMatches) {
+    if (imageData === null || imageData.width !== width || imageData.height !== height) {
       imageData = new ImageData(width, height);
+    } else {
+      imageData.data.fill(0);
     }
     return imageData;
   };
@@ -4411,62 +4163,6 @@ function makeBinaryMask(w, h, data) {
   };
 }
 
-// src/Mask/CircleBrushAlphaMask.ts
-function makeCircleBrushAlphaMask(size, fallOff = () => 1) {
-  const area = size * size;
-  const data = new Uint8Array(area);
-  const radius = size / 2;
-  const invR = 1 / radius;
-  const minOffset = -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) {
-        const dist = Math.sqrt(distSqr);
-        data[y * size + x] = fallOff(1 - dist * invR) * 255 | 0;
-      }
-    }
-  }
-  return {
-    type: 0 /* ALPHA */,
-    data,
-    w: size,
-    h: size,
-    radius,
-    size,
-    minOffset
-  };
-}
-
-// src/Mask/CircleBrushBinaryMask.ts
-function makeCircleBrushBinaryMask(size) {
-  const area = size * size;
-  const data = new Uint8Array(area);
-  const radius = size / 2;
-  const minOffset = -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,
-    radius,
-    size,
-    minOffset
-  };
-}
-
 // src/Mask/applyBinaryMaskToAlphaMask.ts
 function applyBinaryMaskToAlphaMask(alphaMaskDst, binaryMaskSrc, opts = {}) {
   const {
@@ -4737,57 +4433,6 @@ function setMaskData(mask, width, height, data) {
   mask.data = data;
 }
 
-// src/MaskRect/subtractBinaryMaskRects.ts
-function subtractBinaryMaskRects(current, subtracting) {
-  let result = [...current];
-  for (const sub of subtracting) {
-    const next = [];
-    for (const r of result) {
-      const ix = Math.max(r.x, sub.x);
-      const iy = Math.max(r.y, sub.y);
-      const ix2 = Math.min(r.x + r.w, sub.x + sub.w);
-      const iy2 = Math.min(r.y + r.h, sub.y + sub.h);
-      if (ix >= ix2 || iy >= iy2) {
-        next.push(r);
-        continue;
-      }
-      if (r.y < iy) pushPiece(next, r, r.x, r.y, r.w, iy - r.y);
-      if (iy2 < r.y + r.h) pushPiece(next, r, r.x, iy2, r.w, r.y + r.h - iy2);
-      if (r.x < ix) pushPiece(next, r, r.x, iy, ix - r.x, iy2 - iy);
-      if (ix2 < r.x + r.w) pushPiece(next, r, ix2, iy, r.x + r.w - ix2, iy2 - iy);
-    }
-    result = next;
-  }
-  return result;
-}
-function pushPiece(dest, r, x, y, w, h) {
-  if (r.data === null || r.data === void 0) {
-    dest.push({
-      x,
-      y,
-      w,
-      h,
-      data: null,
-      type: null
-    });
-    return;
-  }
-  const lx = x - r.x;
-  const ly = y - r.y;
-  const data = new Uint8Array(w * h);
-  for (let row = 0; row < h; row++) {
-    data.set(r.data.subarray((ly + row) * r.w + lx, (ly + row) * r.w + lx + w), row * w);
-  }
-  dest.push({
-    x,
-    y,
-    w,
-    h,
-    data,
-    type: 1 /* BINARY */
-  });
-}
-
 // src/Rect/getRectsBounds.ts
 function getRectsBounds(rects) {
   if (rects.length === 1) return {
@@ -4895,13 +4540,64 @@ function mergeBinaryMaskRects(current, adding) {
       }
       if (!merged) next.push(r);
     }
-    rects.splice(0, rects.length, ...next);
+    rects.splice(0, rects.length, ...next);
+  }
+  return rects;
+}
+
+// src/MaskRect/subtractBinaryMaskRects.ts
+function subtractBinaryMaskRects(current, subtracting) {
+  let result = [...current];
+  for (const sub of subtracting) {
+    const next = [];
+    for (const r of result) {
+      const ix = Math.max(r.x, sub.x);
+      const iy = Math.max(r.y, sub.y);
+      const ix2 = Math.min(r.x + r.w, sub.x + sub.w);
+      const iy2 = Math.min(r.y + r.h, sub.y + sub.h);
+      if (ix >= ix2 || iy >= iy2) {
+        next.push(r);
+        continue;
+      }
+      if (r.y < iy) pushPiece(next, r, r.x, r.y, r.w, iy - r.y);
+      if (iy2 < r.y + r.h) pushPiece(next, r, r.x, iy2, r.w, r.y + r.h - iy2);
+      if (r.x < ix) pushPiece(next, r, r.x, iy, ix - r.x, iy2 - iy);
+      if (ix2 < r.x + r.w) pushPiece(next, r, ix2, iy, r.x + r.w - ix2, iy2 - iy);
+    }
+    result = next;
   }
-  return rects;
+  return result;
+}
+function pushPiece(dest, r, x, y, w, h) {
+  if (r.data === null || r.data === void 0) {
+    dest.push({
+      x,
+      y,
+      w,
+      h,
+      data: null,
+      type: null
+    });
+    return;
+  }
+  const lx = x - r.x;
+  const ly = y - r.y;
+  const data = new Uint8Array(w * h);
+  for (let row = 0; row < h; row++) {
+    data.set(r.data.subarray((ly + row) * r.w + lx, (ly + row) * r.w + lx + w), row * w);
+  }
+  dest.push({
+    x,
+    y,
+    w,
+    h,
+    data,
+    type: 1 /* BINARY */
+  });
 }
 
 // src/PixelData/PixelData.ts
-var PixelData = class _PixelData {
+var PixelData = class {
   data32;
   imageData;
   width;
@@ -4919,30 +4615,191 @@ var PixelData = class _PixelData {
     this.width = imageData.width;
     this.height = imageData.height;
   }
-  // should only be used for debug and testing
-  copy() {
-    const data = this.imageData.data;
-    const buffer = new Uint8ClampedArray(data);
-    const Ctor = this.imageData.constructor;
-    const isCtorValid = typeof Ctor === "function";
-    let newImageData;
-    if (isCtorValid && Ctor !== Object) {
-      const ImageConstructor = Ctor;
-      newImageData = new ImageConstructor(buffer, this.width, this.height);
-    } else {
-      newImageData = {
-        width: this.width,
-        height: this.height,
-        data: buffer
-      };
+};
+
+// 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;
+  }
+  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;
+  }
+  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;
+  }
+  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++;
     }
-    return new _PixelData(newImageData);
+    dIdx += dStride;
+    mIdx += mStride;
   }
+  return didChange;
+}
+
+// src/PixelData/blendPixelDataPaintBuffer.ts
+var SCRATCH_OPTS = {
+  x: 0,
+  y: 0,
+  alpha: 255,
+  blendFn: void 0
 };
+function blendPixelDataPaintBuffer(paintBuffer, target, alpha = 255, blendFn, blendPixelDataFn = blendPixelData) {
+  const tileShift = paintBuffer.config.tileShift;
+  const lookup = paintBuffer.lookup;
+  for (let i = 0; i < lookup.length; i++) {
+    const tile = lookup[i];
+    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);
+    }
+  }
+}
 
 // src/PixelData/clearPixelData.ts
 function clearPixelData(dst, rect) {
-  fillPixelData(dst, 0, rect);
+  fillPixelDataFast(dst, 0, rect);
 }
 
 // src/PixelData/extractPixelDataBuffer.ts
@@ -5161,6 +5018,162 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
     dstData.set(data.subarray(srcStart, srcStart + copyW), dstStart);
   }
 }
+
+// src/PixelData/writePaintBufferToPixelData.ts
+function writePaintBufferToPixelData(target, paintBuffer, writePixelDataBufferFn = writePixelDataBuffer) {
+  const tileShift = paintBuffer.config.tileShift;
+  const lookup = paintBuffer.lookup;
+  for (let i = 0; i < lookup.length; i++) {
+    const tile = lookup[i];
+    if (tile) {
+      const dx = tile.tx << tileShift;
+      const dy = tile.ty << tileShift;
+      writePixelDataBufferFn(target, tile.data32, dx, dy, tile.width, tile.height);
+    }
+  }
+}
+
+// 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: -macro_halfAndFloor(width),
+    centerOffsetY: -macro_halfAndFloor(height)
+  };
+}
+
+// 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";
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BASE_FAST_BLEND_MODE_FUNCTIONS,
@@ -5171,27 +5184,29 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   IndexedImage,
   MaskType,
   OFFSCREEN_CANVAS_CTX_FAILED,
+  PaintBuffer,
   PixelAccumulator,
   PixelBuffer32,
   PixelData,
   PixelEngineConfig,
   PixelTile,
+  PixelTilePool,
   PixelWriter,
   UnsupportedFormatError,
   applyAlphaMaskToPixelData,
   applyBinaryMaskToAlphaMask,
   applyBinaryMaskToPixelData,
-  applyCircleBrushToPixelData,
   applyPatchTiles,
-  applyRectBrushToPixelData,
   base64DecodeArrayBuffer,
   base64EncodeArrayBuffer,
   blendColorPixelData,
   blendColorPixelDataAlphaMask,
   blendColorPixelDataBinaryMask,
+  blendPixel,
   blendPixelData,
   blendPixelDataAlphaMask,
   blendPixelDataBinaryMask,
+  blendPixelDataPaintBuffer,
   clearPixelData,
   color32ToCssRGBA,
   color32ToHex,
@@ -5225,14 +5240,11 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   fileToImageData,
   fillPixelData,
   fillPixelDataBinaryMask,
+  fillPixelDataFast,
   floodFillSelection,
   forEachLinePoint,
-  getCircleBrushOrPencilBounds,
-  getCircleBrushOrPencilStrokeBounds,
   getImageDataFromClipboard,
   getIndexedImageColorCounts,
-  getRectBrushOrPencilBounds,
-  getRectBrushOrPencilStrokeBounds,
   getRectsBounds,
   getSupportedPixelFormats,
   hardLightFast,
@@ -5265,15 +5277,22 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   makeAlphaMask,
   makeBinaryMask,
   makeBlendModeRegistry,
-  makeCircleBrushAlphaMask,
-  makeCircleBrushBinaryMask,
+  makeCanvasFrameRenderer,
+  makeCirclePaintAlphaMask,
+  makeCirclePaintBinaryMask,
   makeFastBlendModeRegistry,
   makeFullPixelMutator,
+  makeHistoryAction,
   makeImageDataLike,
+  makePaintAlphaMask,
+  makePaintBinaryMask,
+  makePaintBufferCanvasRenderer,
   makePerfectBlendModeRegistry,
   makePixelCanvas,
+  makeRectFalloffPaintAlphaMask,
   makeReusableCanvas,
   makeReusableImageData,
+  makeReusableOffscreenCanvas,
   merge2BinaryMaskRects,
   mergeAlphaMasks,
   mergeBinaryMaskRects,
@@ -5282,14 +5301,6 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   multiplyPerfect,
   mutatorApplyAlphaMask,
   mutatorApplyBinaryMask,
-  mutatorApplyCircleBrush,
-  mutatorApplyCircleBrushStroke,
-  mutatorApplyCirclePencil,
-  mutatorApplyCirclePencilStroke,
-  mutatorApplyRectBrush,
-  mutatorApplyRectBrushStroke,
-  mutatorApplyRectPencil,
-  mutatorApplyRectPencilStroke,
   mutatorBlendColor,
   mutatorBlendPixel,
   mutatorBlendPixelData,
@@ -5298,6 +5309,7 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   mutatorClear,
   mutatorFill,
   mutatorFillBinaryMask,
+  mutatorFillRect,
   mutatorInvert,
   overlayFast,
   overlayPerfect,
@@ -5329,6 +5341,7 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   subtractFast,
   subtractPerfect,
   toBlendModeIndexAndName,
+  trimMaskRectBounds,
   trimRectBounds,
   uInt32ArrayToImageData,
   uInt32ArrayToImageDataLike,
@@ -5344,6 +5357,7 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   writeImageDataBuffer,
   writeImageDataToClipboard,
   writeImgBlobToClipboard,
+  writePaintBufferToPixelData,
   writePixelDataBuffer
 });
 //# sourceMappingURL=index.dev.cjs.map