pixel-data-js 0.23.0 → 0.24.0

package/dist/index.dev.js

@@ -436,6 +436,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,
@@ -1513,51 +1533,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;
@@ -1617,6 +1690,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) {
@@ -1675,126 +1792,91 @@ 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;
+  storePixelBeforeState(x, y) {
     let shift = this.config.tileShift;
-    let columns = target.width + this.config.tileMask >> shift;
+    let columns = this.config.targetColumns;
     let tx = x >> shift;
     let ty = y >> shift;
     let 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 columns = this.config.targetColumns;
     let startX = x >> shift;
     let startY = y >> shift;
     let endX = x + w - 1 >> shift;
     let endY = y + h - 1 >> shift;
+    let startIndex = this.beforeTiles.length;
     for (let ty = startY; ty <= endY; ty++) {
       for (let tx = startX; tx <= endX; tx++) {
         let id = ty * columns + tx;
         let tile = this.lookup[id];
         if (!tile) {
-          tile = this.getTile(id, tx, ty);
+          tile = this.tilePool.getTile(id, tx, ty);
           this.extractState(tile);
           this.lookup[id] = tile;
           this.beforeTiles.push(tile);
         }
       }
     }
+    return (didChange) => {
+      if (!didChange) {
+        let 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;
+    };
   }
   extractState(tile) {
-    let target = this.target;
+    let target = this.config.target;
     let TILE_SIZE = this.config.tileSize;
     let dst = tile.data32;
     let src = target.data32;
@@ -1802,7 +1884,12 @@ var PixelAccumulator = class {
     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));
+    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;
@@ -1810,47 +1897,77 @@ 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() {
+  extractPatch() {
     let afterTiles = [];
     let length = this.beforeTiles.length;
     for (let i = 0; i < length; i++) {
       let beforeTile = this.beforeTiles[i];
       if (beforeTile) {
-        let afterTile = this.getTile(beforeTile.id, beforeTile.tx, beforeTile.ty);
+        let afterTile = this.tilePool.getTile(beforeTile.id, beforeTile.tx, beforeTile.ty);
         this.extractState(afterTile);
         afterTiles.push(afterTile);
       }
     }
-    return afterTiles;
-  }
-  reset() {
-    this.lookup = [];
+    let beforeTiles = this.beforeTiles;
     this.beforeTiles = [];
+    this.lookup.length = 0;
+    return {
+      beforeTiles,
+      afterTiles
+    };
+  }
+  rollback() {
+    let target = this.config.target;
+    let tileSize = this.config.tileSize;
+    let 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;
+  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.setTarget(target);
+  }
+  setTarget(target) {
+    ;
+    this.target = target;
+    this.targetColumns = target.width + this.tileMask >> this.tileShift;
   }
 };
 
@@ -1866,7 +1983,7 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
     my = 0,
     invertMask = false
   } = opts;
-  if (globalAlpha === 0) return;
+  if (globalAlpha === 0) return false;
   let x = targetX;
   let y = targetY;
   let w = width;
@@ -1881,10 +1998,10 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
   }
   w = Math.min(w, dst.width - x);
   h = Math.min(h, dst.height - y);
-  if (w <= 0) return;
-  if (h <= 0) return;
+  if (w <= 0) return false;
+  if (h <= 0) return false;
   const mPitch = mask.w;
-  if (mPitch <= 0) return;
+  if (mPitch <= 0) return false;
   const startX = mx + (x - targetX);
   const startY = my + (y - targetY);
   const sX0 = Math.max(0, startX);
@@ -1893,8 +2010,8 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
   const sY1 = Math.min(mask.h, startY + h);
   const finalW = sX1 - sX0;
   const finalH = sY1 - sY0;
-  if (finalW <= 0) return;
-  if (finalH <= 0) return;
+  if (finalW <= 0) return false;
+  if (finalH <= 0) return false;
   const xShift = sX0 - startX;
   const yShift = sY0 - startY;
   const dst32 = dst.data32;
@@ -1904,6 +2021,7 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
   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];
@@ -1920,12 +2038,18 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
       }
       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;
-          dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+          const current = dst32[dIdx];
+          const next = (d & 16777215 | finalAlpha << 24) >>> 0;
+          if (current !== next) {
+            dst32[dIdx] = next;
+            didChange = true;
+          }
         }
       }
       dIdx++;
@@ -1934,27 +2058,28 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
     dIdx += dStride;
     mIdx += mStride;
   }
+  return didChange;
 }
 
 // src/History/PixelMutator/mutatorApplyAlphaMask.ts
-var defaults = {
+var defaults2 = {
   applyAlphaMaskToPixelData
 };
-var mutatorApplyAlphaMask = ((writer, deps = defaults) => {
+var mutatorApplyAlphaMask = ((writer, deps = defaults2) => {
   const {
-    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults.applyAlphaMaskToPixelData
+    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults2.applyAlphaMaskToPixelData
   } = deps;
   return {
-    applyAlphaMask: (mask, opts = {}) => {
-      let target = writer.target;
+    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);
-      applyAlphaMaskToPixelData2(target, mask, opts);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(applyAlphaMaskToPixelData2(target, mask, opts));
     }
   };
 });
@@ -1971,7 +2096,7 @@ function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
     my = 0,
     invertMask = false
   } = opts;
-  if (globalAlpha === 0) return;
+  if (globalAlpha === 0) return false;
   let x = targetX;
   let y = targetY;
   let w = width;
@@ -1986,10 +2111,9 @@ function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
   }
   w = Math.min(w, dst.width - x);
   h = Math.min(h, dst.height - y);
-  if (w <= 0) return;
-  if (h <= 0) return;
+  if (w <= 0 || h <= 0) return false;
   const mPitch = mask.w;
-  if (mPitch <= 0) return;
+  if (mPitch <= 0) return false;
   const startX = mx + (x - targetX);
   const startY = my + (y - targetY);
   const sX0 = Math.max(0, startX);
@@ -1998,8 +2122,9 @@ function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
   const sY1 = Math.min(mask.h, startY + h);
   const finalW = sX1 - sX0;
   const finalH = sY1 - sY0;
-  if (finalW <= 0) return;
-  if (finalH <= 0) return;
+  if (finalW <= 0 || finalH <= 0) {
+    return false;
+  }
   const xShift = sX0 - startX;
   const yShift = sY0 - startY;
   const dst32 = dst.data32;
@@ -2009,18 +2134,28 @@ function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
   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++) {
+  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) {
-        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+        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;
-          dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+          const next = (d & 16777215 | finalAlpha << 24) >>> 0;
+          if (d !== next) {
+            dst32[dIdx] = next;
+            didChange = true;
+          }
         }
       }
       dIdx++;
@@ -2029,59 +2164,32 @@ function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
     dIdx += dStride;
     mIdx += mStride;
   }
+  return didChange;
 }
 
 // src/History/PixelMutator/mutatorApplyBinaryMask.ts
-var defaults2 = {
+var defaults3 = {
   applyBinaryMaskToPixelData
 };
-var mutatorApplyBinaryMask = ((writer, deps = defaults2) => {
+var mutatorApplyBinaryMask = ((writer, deps = defaults3) => {
   const {
-    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults2.applyBinaryMaskToPixelData
+    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults3.applyBinaryMaskToPixelData
   } = deps;
   return {
-    applyBinaryMask: (mask, opts = {}) => {
-      let target = writer.target;
+    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);
-      applyBinaryMaskToPixelData2(target, mask, opts);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(applyBinaryMaskToPixelData2(target, mask, 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;
@@ -2093,10 +2201,10 @@ function blendColorPixelDataAlphaMask(dst, color, mask, opts = {}) {
   const mx = opts.mx ?? 0;
   const my = opts.my ?? 0;
   const invertMask = opts.invertMask ?? false;
-  if (globalAlpha === 0) return;
+  if (globalAlpha === 0) return false;
   const baseSrcAlpha = color >>> 24;
   const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) return;
+  if (baseSrcAlpha === 0 && !isOverwrite) return false;
   let x = targetX;
   let y = targetY;
   let actualW = w;
@@ -2111,7 +2219,7 @@ function blendColorPixelDataAlphaMask(dst, color, mask, opts = {}) {
   }
   actualW = Math.min(actualW, dst.width - x);
   actualH = Math.min(actualH, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return;
+  if (actualW <= 0 || actualH <= 0) return false;
   const dx = x - targetX | 0;
   const dy = y - targetY | 0;
   const dst32 = dst.data32;
@@ -2121,9 +2229,10 @@ function blendColorPixelDataAlphaMask(dst, color, mask, opts = {}) {
   let dIdx = y * dw + x | 0;
   let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
   const dStride = dw - actualW | 0;
-  let mStride = mPitch - 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];
@@ -2154,162 +2263,47 @@ function blendColorPixelDataAlphaMask(dst, color, mask, opts = {}) {
         }
         finalCol = (colorRGB | a << 24) >>> 0;
       }
-      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
+      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;
-  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;
-  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;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      if (maskData[mIdx] === skipVal) {
-        dIdx++;
-        mIdx++;
-        continue;
-      }
-      dst32[dIdx] = blendFn(baseColorWithGlobalAlpha, dst32[dIdx]);
-      dIdx++;
-      mIdx++;
-    }
-    dIdx += dStride;
-    mIdx += mStride;
-  }
-}
-
-// 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
-};
-var mutatorApplyCircleBrush = ((writer, deps = defaults3) => {
-  const {
-    applyCircleBrushToPixelData: applyCircleBrushToPixelData2 = defaults3.applyCircleBrushToPixelData,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults3.getCircleBrushOrPencilBounds
-  } = deps;
-  const boundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const blendColorPixelOptions = {
-    alpha: 255,
-    blendFn: sourceOverPerfect,
+// 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
   };
-  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);
-    }
-  };
-});
-
-// 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;
-  }
+  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/Rect/getCircleBrushOrPencilStrokeBounds.ts
@@ -2382,8 +2376,9 @@ var mutatorApplyCircleBrushStroke = ((writer, deps = defaults4) => {
       const maskData = mask.data;
       const brushData = brush.data;
       const minOffset = brush.minOffset;
-      const targetWidth = writer.target.width;
-      const targetHeight = writer.target.height;
+      const target = writer.config.target;
+      const targetWidth = target.width;
+      const targetHeight = target.height;
       forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
         const {
           x: cbx,
@@ -2421,19 +2416,117 @@ var mutatorApplyCircleBrushStroke = ((writer, deps = defaults4) => {
       blendColorPixelOptions.y = by;
       blendColorPixelOptions.w = bw;
       blendColorPixelOptions.h = bh;
-      blendColorPixelDataAlphaMask2(writer.target, color, mask, blendColorPixelOptions);
+      blendColorPixelDataAlphaMask2(target, color, mask, blendColorPixelOptions);
     }
   };
 });
 
-// src/History/PixelMutator/mutatorApplyCirclePencil.ts
+// 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++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+  return didChange;
+}
+
+// src/PixelData/blendColorPixelDataCircleMask.ts
+function blendColorPixelDataCircleMask(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 false;
+  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 false;
+  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 */) {
+    return blendColorPixelDataAlphaMask(target, color, brush, scratchOptions);
+  }
+  if (brush.type === 1 /* BINARY */) {
+    return blendColorPixelDataBinaryMask(target, color, brush, scratchOptions);
+  }
+  return false;
+}
+
+// src/History/PixelMutator/mutatorBlendColorCircleMask.ts
 var defaults5 = {
-  applyCircleBrushToPixelData,
+  blendColorPixelDataCircleMask,
   getCircleBrushOrPencilBounds
 };
-var mutatorApplyCirclePencil = ((writer, deps = defaults5) => {
+var mutatorBlendColorCircleMask = ((writer, deps = defaults5) => {
   const {
-    applyCircleBrushToPixelData: applyCircleBrushToPixelData2 = defaults5.applyCircleBrushToPixelData,
+    blendColorPixelDataCircleMask: blendColorPixelDataCircleMask2 = defaults5.blendColorPixelDataCircleMask,
     getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults5.getCircleBrushOrPencilBounds
   } = deps;
   const boundsOut = {
@@ -2442,34 +2535,63 @@ var mutatorApplyCirclePencil = ((writer, deps = defaults5) => {
     w: 0,
     h: 0
   };
+  const blendColorPixelOptions = {
+    alpha: 255,
+    blendFn: sourceOverPerfect,
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  return {
+    applyCircleMask(color, centerX, centerY, brush, alpha = 255, blendFn) {
+      const target = writer.config.target;
+      const b = getCircleBrushOrPencilBounds2(centerX, centerY, brush.size, target.width, target.height, boundsOut);
+      const didChange = writer.accumulator.storeRegionBeforeState(b.x, b.y, b.w, b.h);
+      return didChange(blendColorPixelDataCircleMask2(target, color, centerX, centerY, brush, alpha, blendFn, blendColorPixelOptions, b));
+    }
+  };
+});
+
+// src/History/PixelMutator/mutatorApplyCirclePencil.ts
+var defaults6 = {
+  applyCircleMaskToPixelData: blendColorPixelDataCircleMask,
+  getCircleBrushOrPencilBounds
+};
+var mutatorApplyCirclePencil = ((writer, deps = defaults6) => {
+  const {
+    applyCircleMaskToPixelData = defaults6.applyCircleMaskToPixelData,
+    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults6.getCircleBrushOrPencilBounds
+  } = 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);
+      const target = writer.config.target;
+      const b = getCircleBrushOrPencilBounds2(centerX, centerY, brush.size, target.width, target.height, boundsOut);
+      const didChange = writer.accumulator.storeRegionBeforeState(b.x, b.y, b.w, b.h);
+      return didChange(applyCircleMaskToPixelData(target, color, centerX, centerY, brush, alpha, blendFn, b));
     }
   };
 });
 
 // src/History/PixelMutator/mutatorApplyCirclePencilStroke.ts
-var defaults6 = {
+var defaults7 = {
   forEachLinePoint,
   blendColorPixelDataBinaryMask,
   getCircleBrushOrPencilBounds,
   getCircleBrushOrPencilStrokeBounds
 };
-var mutatorApplyCirclePencilStroke = ((writer, deps = defaults6) => {
+var mutatorApplyCirclePencilStroke = ((writer, deps = defaults7) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults6.forEachLinePoint,
-    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults6.blendColorPixelDataBinaryMask,
-    getCircleBrushOrPencilStrokeBounds: getCircleBrushOrPencilStrokeBounds2 = defaults6.getCircleBrushOrPencilStrokeBounds,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults6.getCircleBrushOrPencilBounds
+    forEachLinePoint: forEachLinePoint2 = defaults7.forEachLinePoint,
+    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults7.blendColorPixelDataBinaryMask,
+    getCircleBrushOrPencilStrokeBounds: getCircleBrushOrPencilStrokeBounds2 = defaults7.getCircleBrushOrPencilStrokeBounds,
+    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults7.getCircleBrushOrPencilBounds
   } = deps;
   const strokeBoundsOut = {
     x: 0,
@@ -2510,8 +2632,9 @@ var mutatorApplyCirclePencilStroke = ((writer, deps = defaults6) => {
       mask.w = bw;
       mask.h = bh;
       const maskData = mask.data;
-      const targetWidth = writer.target.width;
-      const targetHeight = writer.target.height;
+      const target = writer.config.target;
+      const targetWidth = target.width;
+      const targetHeight = target.height;
       forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
         const {
           x: cbx,
@@ -2546,7 +2669,7 @@ var mutatorApplyCirclePencilStroke = ((writer, deps = defaults6) => {
       blendColorPixelOptions.y = by;
       blendColorPixelOptions.w = bw;
       blendColorPixelOptions.h = bh;
-      blendColorPixelDataBinaryMask2(writer.target, color, mask, blendColorPixelOptions);
+      blendColorPixelDataBinaryMask2(target, color, mask, blendColorPixelOptions);
     }
   };
 });
@@ -2581,7 +2704,9 @@ function applyRectBrushToPixelData(target, color, centerX, centerY, brushWidth,
   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;
+  if (b.w <= 0 || b.h <= 0) {
+    return false;
+  }
   const data32 = target.data32;
   const baseColor = color & 16777215;
   const baseSrcAlpha = color >>> 24;
@@ -2595,6 +2720,7 @@ function applyRectBrushToPixelData(target, color, centerX, centerY, brushWidth,
   const endX = b.x + b.w;
   const endY = b.y + b.h;
   const isOverwrite = blendFn.isOverwrite;
+  let didChange = false;
   for (let py = b.y; py < endY; py++) {
     const rowOffset = py * targetWidth;
     const dy = Math.abs(py - fCenterY + centerOffsetY) * invHalfH;
@@ -2617,20 +2743,26 @@ function applyRectBrushToPixelData(target, color, centerX, centerY, brushWidth,
         if (a === 0 && !isOverwrite) continue;
         finalCol = (a << 24 | baseColor) >>> 0;
       }
-      data32[idx] = blendFn(finalCol, data32[idx]);
+      const current = data32[idx];
+      const next = blendFn(finalCol, current);
+      if (current !== next) {
+        data32[idx] = next;
+        didChange = true;
+      }
     }
   }
+  return didChange;
 }
 
 // src/History/PixelMutator/mutatorApplyRectBrush.ts
-var defaults7 = {
+var defaults8 = {
   applyRectBrushToPixelData,
   getRectBrushOrPencilBounds
 };
-var mutatorApplyRectBrush = ((writer, deps = defaults7) => {
+var mutatorApplyRectBrush = ((writer, deps = defaults8) => {
   const {
-    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults7.applyRectBrushToPixelData,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults7.getRectBrushOrPencilBounds
+    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults8.applyRectBrushToPixelData,
+    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults8.getRectBrushOrPencilBounds
   } = deps;
   const boundsOut = {
     x: 0,
@@ -2640,15 +2772,10 @@ var mutatorApplyRectBrush = ((writer, deps = defaults7) => {
   };
   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);
+      const target = writer.config.target;
+      const b = getRectBrushOrPencilBounds2(centerX, centerY, brushWidth, brushHeight, target.width, target.height, boundsOut);
+      const didChange = writer.accumulator.storeRegionBeforeState(b.x, b.y, b.w, b.h);
+      return didChange(applyRectBrushToPixelData2(target, color, centerX, centerY, brushWidth, brushHeight, alpha, fallOff, blendFn, b));
     }
   };
 });
@@ -2669,18 +2796,18 @@ function getRectBrushOrPencilStrokeBounds(x0, y0, x1, y1, brushWidth, brushHeigh
 }
 
 // src/History/PixelMutator/mutatorApplyRectBrushStroke.ts
-var defaults8 = {
+var defaults9 = {
   forEachLinePoint,
   blendColorPixelDataAlphaMask,
   getRectBrushOrPencilBounds,
   getRectBrushOrPencilStrokeBounds
 };
-var mutatorApplyRectBrushStroke = ((writer, deps = defaults8) => {
+var mutatorApplyRectBrushStroke = ((writer, deps = defaults9) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults8.forEachLinePoint,
-    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults8.blendColorPixelDataAlphaMask,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults8.getRectBrushOrPencilBounds,
-    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults8.getRectBrushOrPencilStrokeBounds
+    forEachLinePoint: forEachLinePoint2 = defaults9.forEachLinePoint,
+    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults9.blendColorPixelDataAlphaMask,
+    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults9.getRectBrushOrPencilBounds,
+    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults9.getRectBrushOrPencilStrokeBounds
   } = deps;
   const strokeBoundsOut = {
     x: 0,
@@ -2727,8 +2854,9 @@ var mutatorApplyRectBrushStroke = ((writer, deps = defaults8) => {
       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;
+      const target = writer.config.target;
+      const targetWidth = target.width;
+      const targetHeight = target.height;
       forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
         const {
           x: rbx,
@@ -2766,22 +2894,22 @@ var mutatorApplyRectBrushStroke = ((writer, deps = defaults8) => {
       blendColorPixelOptions.y = by;
       blendColorPixelOptions.w = bw;
       blendColorPixelOptions.h = bh;
-      blendColorPixelDataAlphaMask2(writer.target, color, mask, blendColorPixelOptions);
+      blendColorPixelDataAlphaMask2(target, color, mask, blendColorPixelOptions);
     }
   };
 });
 
 // src/History/PixelMutator/mutatorApplyRectPencil.ts
-var defaults9 = {
+var defaults10 = {
   applyRectBrushToPixelData,
   getRectBrushOrPencilBounds,
   fallOff: () => 1
 };
-var mutatorApplyRectPencil = ((writer, deps = defaults9) => {
+var mutatorApplyRectPencil = ((writer, deps = defaults10) => {
   const {
-    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults9.applyRectBrushToPixelData,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults9.getRectBrushOrPencilBounds,
-    fallOff = defaults9.fallOff
+    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults10.applyRectBrushToPixelData,
+    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults10.getRectBrushOrPencilBounds,
+    fallOff = defaults10.fallOff
   } = deps;
   const boundsOut = {
     x: 0,
@@ -2791,32 +2919,27 @@ var mutatorApplyRectPencil = ((writer, deps = defaults9) => {
   };
   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);
+      const target = writer.config.target;
+      const b = getRectBrushOrPencilBounds2(centerX, centerY, brushWidth, brushHeight, target.width, target.height, boundsOut);
+      const didChange = writer.accumulator.storeRegionBeforeState(b.x, b.y, b.w, b.h);
+      return didChange(applyRectBrushToPixelData2(target, color, centerX, centerY, brushWidth, brushHeight, alpha, fallOff, blendFn, b));
     }
   };
 });
 
 // src/History/PixelMutator/mutatorApplyRectPencilStroke.ts
-var defaults10 = {
+var defaults11 = {
   forEachLinePoint,
   getRectBrushOrPencilBounds,
   getRectBrushOrPencilStrokeBounds,
   blendColorPixelDataBinaryMask
 };
-var mutatorApplyRectPencilStroke = ((writer, deps = defaults10) => {
+var mutatorApplyRectPencilStroke = ((writer, deps = defaults11) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults10.forEachLinePoint,
-    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults10.blendColorPixelDataBinaryMask,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults10.getRectBrushOrPencilBounds,
-    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults10.getRectBrushOrPencilStrokeBounds
+    forEachLinePoint: forEachLinePoint2 = defaults11.forEachLinePoint,
+    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults11.blendColorPixelDataBinaryMask,
+    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults11.getRectBrushOrPencilBounds,
+    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults11.getRectBrushOrPencilStrokeBounds
   } = deps;
   const strokeBoundsOut = {
     x: 0,
@@ -2860,8 +2983,9 @@ var mutatorApplyRectPencilStroke = ((writer, deps = defaults10) => {
       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;
+      const target = writer.config.target;
+      const targetWidth = target.width;
+      const targetHeight = target.height;
       forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
         const {
           x: rbx,
@@ -2894,7 +3018,7 @@ var mutatorApplyRectPencilStroke = ((writer, deps = defaults10) => {
       blendColorPixelOptions.y = by;
       blendColorPixelOptions.w = bw;
       blendColorPixelOptions.h = bh;
-      blendColorPixelDataBinaryMask2(writer.target, color, mask, blendColorPixelOptions);
+      blendColorPixelDataBinaryMask2(target, color, mask, blendColorPixelOptions);
     }
   };
 });
@@ -2909,11 +3033,14 @@ function blendColorPixelData(dst, color, opts = {}) {
     alpha: globalAlpha = 255,
     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;
-  let x = targetX, y = targetY, w = width, h = height;
+  if (baseSrcAlpha === 0 && !isOverwrite) return false;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
   if (x < 0) {
     w += x;
     x = 0;
@@ -2924,69 +3051,97 @@ function blendColorPixelData(dst, color, opts = {}) {
   }
   const actualW = Math.min(w, dst.width - x);
   const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return;
+  if (actualW <= 0 || actualH <= 0) return false;
   let finalSrcColor = color;
   if (globalAlpha < 255) {
     const a = baseSrcAlpha * globalAlpha + 128 >> 8;
-    if (a === 0 && !isOverwrite) return;
+    if (a === 0 && !isOverwrite) return false;
     finalSrcColor = (color & 16777215 | a << 24) >>> 0;
   }
   const dst32 = dst.data32;
   const dw = dst.width;
   let dIdx = y * dw + x | 0;
   const dStride = dw - actualW | 0;
+  let didChange = false;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
-      dst32[dIdx] = blendFn(finalSrcColor, dst32[dIdx]);
+      const current = dst32[dIdx];
+      const next = blendFn(finalSrcColor, current);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
+      }
       dIdx++;
     }
     dIdx += dStride;
   }
+  return didChange;
 }
 
 // src/History/PixelMutator/mutatorBlendColor.ts
-var defaults11 = {
+var defaults12 = {
   blendColorPixelData
 };
-var mutatorBlendColor = ((writer, deps = defaults11) => {
+var mutatorBlendColor = ((writer, deps = defaults12) => {
   const {
-    blendColorPixelData: blendColorPixelData2 = defaults11.blendColorPixelData
+    blendColorPixelData: blendColorPixelData2 = defaults12.blendColorPixelData
   } = deps;
   return {
     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);
-      blendColorPixelData2(writer.target, color, opts);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendColorPixelData2(target, color, opts));
     }
   };
 });
 
+// src/PixelData/blendPixel.ts
+function blendPixel(target, x, y, color, alpha = 255, blendFn = sourceOverPerfect) {
+  if (alpha === 0) return false;
+  let width = target.width;
+  let height = target.height;
+  if (x < 0 || x >= width || y < 0 || y >= height) return false;
+  let srcAlpha = color >>> 24;
+  let isOverwrite = blendFn.isOverwrite;
+  if (srcAlpha === 0 && !isOverwrite) return false;
+  let dst32 = target.data32;
+  let index = y * width + x;
+  let finalColor = color;
+  if (alpha !== 255) {
+    let finalAlpha = srcAlpha * alpha + 128 >> 8;
+    if (finalAlpha === 0 && !isOverwrite) return false;
+    finalColor = (color & 16777215 | finalAlpha << 24) >>> 0;
+  }
+  let current = dst32[index];
+  let next = blendFn(finalColor, current);
+  if (current !== next) {
+    dst32[index] = next;
+    return true;
+  }
+  return false;
+}
+
 // src/History/PixelMutator/mutatorBlendPixel.ts
-function mutatorBlendPixel(writer) {
+var defaults13 = {
+  blendPixel
+};
+var mutatorBlendPixel = ((writer, deps = defaults13) => {
+  const {
+    blendPixel: blendPixel2 = defaults13.blendPixel
+  } = deps;
   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);
+    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 = {}) {
@@ -3000,7 +3155,7 @@ function blendPixelData(dst, src, opts = {}) {
     alpha: globalAlpha = 255,
     blendFn = sourceOverPerfect
   } = opts;
-  if (globalAlpha === 0) return;
+  if (globalAlpha === 0) return false;
   let x = targetX;
   let y = targetY;
   let sx = sourceX;
@@ -3031,7 +3186,7 @@ function blendPixelData(dst, src, opts = {}) {
   }
   const actualW = Math.min(w, dst.width - x);
   const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return;
+  if (actualW <= 0 || actualH <= 0) return false;
   const dst32 = dst.data32;
   const src32 = src.data32;
   const dw = dst.width;
@@ -3042,6 +3197,7 @@ function blendPixelData(dst, src, opts = {}) {
   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];
@@ -3061,22 +3217,28 @@ function blendPixelData(dst, src, opts = {}) {
         }
         finalCol = (srcCol & 16777215 | a << 24) >>> 0;
       }
-      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
+      const current = dst32[dIdx];
+      const next = blendFn(finalCol, dst32[dIdx]);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
+      }
       dIdx++;
       sIdx++;
     }
     dIdx += dStride;
     sIdx += sStride;
   }
+  return didChange;
 }
 
 // src/History/PixelMutator/mutatorBlendPixelData.ts
-var defaults12 = {
+var defaults14 = {
   blendPixelData
 };
-var mutatorBlendPixelData = ((writer, deps = defaults12) => {
+var mutatorBlendPixelData = ((writer, deps = defaults14) => {
   const {
-    blendPixelData: blendPixelData2 = defaults12.blendPixelData
+    blendPixelData: blendPixelData2 = defaults14.blendPixelData
   } = deps;
   return {
     blendPixelData(src, opts = {}) {
@@ -3086,8 +3248,8 @@ var mutatorBlendPixelData = ((writer, deps = defaults12) => {
         w = src.width,
         h = src.height
       } = opts;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      blendPixelData2(writer.target, src, opts);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendPixelData2(writer.config.target, src, opts));
     }
   };
 });
@@ -3107,7 +3269,7 @@ function blendPixelDataAlphaMask(dst, src, alphaMask, opts = {}) {
     my = 0,
     invertMask = false
   } = opts;
-  if (globalAlpha === 0) return;
+  if (globalAlpha === 0) return false;
   let x = targetX;
   let y = targetY;
   let sx = sourceX;
@@ -3138,7 +3300,7 @@ function blendPixelDataAlphaMask(dst, src, alphaMask, opts = {}) {
   }
   const actualW = Math.min(w, dst.width - x);
   const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return;
+  if (actualW <= 0 || actualH <= 0) return false;
   const dw = dst.width;
   const sw = src.width;
   const mPitch = alphaMask.w;
@@ -3155,6 +3317,7 @@ function blendPixelDataAlphaMask(dst, src, alphaMask, opts = {}) {
   const mStride = mPitch - actualW | 0;
   const isOpaque = globalAlpha === 255;
   const isOverwrite = blendFn.isOverwrite || false;
+  let didChange = false;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
       const mVal = maskData[mIdx];
@@ -3196,7 +3359,12 @@ function blendPixelDataAlphaMask(dst, src, alphaMask, opts = {}) {
         }
         finalCol = (srcCol & 16777215 | a << 24) >>> 0;
       }
-      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
+      const current = dst32[dIdx];
+      const next = blendFn(finalCol, dst32[dIdx]);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
+      }
       dIdx++;
       sIdx++;
       mIdx++;
@@ -3205,15 +3373,16 @@ function blendPixelDataAlphaMask(dst, src, alphaMask, opts = {}) {
     sIdx += sStride;
     mIdx += mStride;
   }
+  return didChange;
 }
 
 // src/History/PixelMutator/mutatorBlendPixelDataAlphaMask.ts
-var defaults13 = {
+var defaults15 = {
   blendPixelDataAlphaMask
 };
-var mutatorBlendPixelDataAlphaMask = ((writer, deps = defaults13) => {
+var mutatorBlendPixelDataAlphaMask = ((writer, deps = defaults15) => {
   const {
-    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults13.blendPixelDataAlphaMask
+    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults15.blendPixelDataAlphaMask
   } = deps;
   return {
     blendPixelDataAlphaMask(src, mask, opts = {}) {
@@ -3221,8 +3390,8 @@ var mutatorBlendPixelDataAlphaMask = ((writer, deps = defaults13) => {
       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);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendPixelDataAlphaMask2(writer.config.target, src, mask, opts));
     }
   };
 });
@@ -3242,7 +3411,7 @@ function blendPixelDataBinaryMask(dst, src, binaryMask, opts = {}) {
     my = 0,
     invertMask = false
   } = opts;
-  if (globalAlpha === 0) return;
+  if (globalAlpha === 0) return false;
   let x = targetX;
   let y = targetY;
   let sx = sourceX;
@@ -3273,7 +3442,7 @@ function blendPixelDataBinaryMask(dst, src, binaryMask, opts = {}) {
   }
   const actualW = Math.min(w, dst.width - x);
   const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return;
+  if (actualW <= 0 || actualH <= 0) return false;
   const dx = x - targetX | 0;
   const dy = y - targetY | 0;
   const dst32 = dst.data32;
@@ -3291,6 +3460,7 @@ function blendPixelDataBinaryMask(dst, src, binaryMask, opts = {}) {
   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) {
@@ -3318,7 +3488,12 @@ function blendPixelDataBinaryMask(dst, src, binaryMask, opts = {}) {
         }
         finalCol = (srcCol & 16777215 | a << 24) >>> 0;
       }
-      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
+      const current = dst32[dIdx];
+      const next = blendFn(finalCol, dst32[dIdx]);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
+      }
       dIdx++;
       sIdx++;
       mIdx++;
@@ -3327,15 +3502,16 @@ function blendPixelDataBinaryMask(dst, src, binaryMask, opts = {}) {
     sIdx += sStride;
     mIdx += mStride;
   }
+  return didChange;
 }
 
 // src/History/PixelMutator/mutatorBlendPixelDataBinaryMask.ts
-var defaults14 = {
+var defaults16 = {
   blendPixelDataBinaryMask
 };
-var mutatorBlendPixelDataBinaryMask = ((writer, deps = defaults14) => {
+var mutatorBlendPixelDataBinaryMask = ((writer, deps = defaults16) => {
   const {
-    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults14.blendPixelDataBinaryMask
+    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults16.blendPixelDataBinaryMask
   } = deps;
   return {
     blendPixelDataBinaryMask(src, mask, opts = {}) {
@@ -3343,15 +3519,15 @@ var mutatorBlendPixelDataBinaryMask = ((writer, deps = defaults14) => {
       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);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(blendPixelDataBinaryMask2(writer.config.target, src, mask, opts));
     }
   };
 });
 
-// src/PixelData/fillPixelData.ts
+// src/PixelData/fillPixelDataFast.ts
 var SCRATCH_RECT = makeClippedRect();
-function fillPixelData(dst, color, _x, _y, _w, _h) {
+function fillPixelDataFast(dst, color, _x, _y, _w, _h) {
   let x;
   let y;
   let w;
@@ -3394,55 +3570,111 @@ function fillPixelData(dst, color, _x, _y, _w, _h) {
 }
 
 // src/History/PixelMutator/mutatorClear.ts
-var defaults15 = {
-  fillPixelData
+var defaults17 = {
+  fillPixelData: fillPixelDataFast
 };
-var mutatorClear = ((writer, deps = defaults15) => {
+var mutatorClear = ((writer, deps = defaults17) => {
   const {
-    fillPixelData: fillPixelData2 = defaults15.fillPixelData
+    fillPixelData: fillPixelData2 = defaults17.fillPixelData
   } = deps;
   return {
     clear(rect = {}) {
+      const target = writer.config.target;
       const x = rect.x ?? 0;
       const y = rect.y ?? 0;
-      const w = rect.w ?? writer.target.width;
-      const h = rect.h ?? writer.target.height;
+      const w = rect.w ?? target.width;
+      const h = rect.h ?? target.height;
       writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      fillPixelData2(writer.target, 0, x, y, w, h);
+      fillPixelData2(target, 0, x, y, w, h);
     }
   };
 });
 
+// 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 defaults16 = {
+var defaults18 = {
   fillPixelData
 };
-var mutatorFill = ((writer, deps = defaults16) => {
+var mutatorFill = ((writer, deps = defaults18) => {
   const {
-    fillPixelData: fillPixelData2 = defaults16.fillPixelData
+    fillPixelData: fillPixelData2 = defaults18.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);
+    fill(color, x = 0, y = 0, w = writer.config.target.width, h = writer.config.target.height) {
+      const target = writer.config.target;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(fillPixelData2(target, color, x, y, w, h));
+    }
+  };
+});
+var mutatorFillRect = ((writer, deps = defaults18) => {
+  const {
+    fillPixelData: fillPixelData2 = defaults18.fillPixelData
+  } = deps;
+  return {
+    fillRect(color, rect) {
+      const target = writer.config.target;
+      const didChange = writer.accumulator.storeRegionBeforeState(rect.x, rect.y, rect.w, rect.h);
+      return didChange(fillPixelData2(target, color, rect.x, rect.y, rect.w, rect.h));
     }
   };
 });
 
 // src/PixelData/fillPixelDataBinaryMask.ts
-var SCRATCH_RECT2 = makeClippedRect();
+var SCRATCH_RECT3 = makeClippedRect();
 function fillPixelDataBinaryMask(dst, color, mask, alpha = 255, x = 0, y = 0) {
-  if (alpha === 0) return;
+  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_RECT2);
-  if (!clip.inBounds) return;
+  const clip = resolveRectClipping(x, y, maskW, maskH, dst.width, dst.height, SCRATCH_RECT3);
+  if (!clip.inBounds) return false;
   const {
     x: finalX,
     y: finalY,
@@ -3459,6 +3691,7 @@ function fillPixelDataBinaryMask(dst, color, mask, alpha = 255, x = 0, y = 0) {
     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;
@@ -3469,30 +3702,35 @@ function fillPixelDataBinaryMask(dst, color, mask, alpha = 255, x = 0, y = 0) {
       const maskX = currentX - x;
       const maskIndex = maskOffset + maskX;
       if (maskData[maskIndex]) {
-        dst32[dstRowOffset + currentX] = finalCol;
+        const current = dst32[dstRowOffset + currentX];
+        if (current !== finalCol) {
+          dst32[dstRowOffset + currentX] = finalCol;
+          hasChanged = true;
+        }
       }
     }
   }
+  return hasChanged;
 }
 
 // src/History/PixelMutator/mutatorFillBinaryMask.ts
-var defaults17 = {
+var defaults19 = {
   fillPixelDataBinaryMask
 };
-var mutatorFillBinaryMask = ((writer, deps = defaults17) => {
+var mutatorFillBinaryMask = ((writer, deps = defaults19) => {
   const {
-    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults17.fillPixelDataBinaryMask
+    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults19.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);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, mask.w, mask.h);
+      return didChange(fillPixelDataBinaryMask2(writer.config.target, color, mask, alpha, x, y));
     }
   };
 });
 
 // src/PixelData/invertPixelData.ts
-var SCRATCH_RECT3 = makeClippedRect();
+var SCRATCH_RECT4 = makeClippedRect();
 function invertPixelData(pixelData, opts = {}) {
   const dst = pixelData;
   const {
@@ -3505,8 +3743,8 @@ function invertPixelData(pixelData, opts = {}) {
     my = 0,
     invertMask = false
   } = opts;
-  const clip = resolveRectClipping(targetX, targetY, width, height, dst.width, dst.height, SCRATCH_RECT3);
-  if (!clip.inBounds) return;
+  const clip = resolveRectClipping(targetX, targetY, width, height, dst.width, dst.height, SCRATCH_RECT4);
+  if (!clip.inBounds) return false;
   const {
     x,
     y,
@@ -3546,26 +3784,28 @@ function invertPixelData(pixelData, opts = {}) {
       dIdx += dStride;
     }
   }
+  return true;
 }
 
 // src/History/PixelMutator/mutatorInvert.ts
-var defaults18 = {
+var defaults20 = {
   invertPixelData
 };
-var mutatorInvert = ((writer, deps = defaults18) => {
+var mutatorInvert = ((writer, deps = defaults20) => {
   const {
-    invertPixelData: invertPixelData2 = defaults18.invertPixelData
+    invertPixelData: invertPixelData2 = defaults20.invertPixelData
   } = deps;
   return {
     invert(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);
-      invertPixelData2(writer.target, opts);
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(invertPixelData2(target, opts));
     }
   };
 });
@@ -3576,7 +3816,6 @@ function makeFullPixelMutator(writer) {
     // @sort
     ...mutatorApplyAlphaMask(writer),
     ...mutatorApplyBinaryMask(writer),
-    ...mutatorApplyCircleBrush(writer),
     ...mutatorApplyCircleBrushStroke(writer),
     ...mutatorApplyCirclePencil(writer),
     ...mutatorApplyCirclePencilStroke(writer),
@@ -3585,6 +3824,7 @@ function makeFullPixelMutator(writer) {
     ...mutatorApplyRectPencil(writer),
     ...mutatorApplyRectPencilStroke(writer),
     ...mutatorBlendColor(writer),
+    ...mutatorBlendColorCircleMask(writer),
     ...mutatorBlendPixel(writer),
     ...mutatorBlendPixelData(writer),
     ...mutatorBlendPixelDataAlphaMask(writer),
@@ -3592,50 +3832,96 @@ function makeFullPixelMutator(writer) {
     ...mutatorClear(writer),
     ...mutatorFill(writer),
     ...mutatorFillBinaryMask(writer),
+    ...mutatorFillRect(writer),
     ...mutatorInvert(writer)
   };
 }
 
+// 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 {
-  target;
   historyManager;
   accumulator;
+  historyActionFactory;
   config;
   mutator;
   constructor(target, mutatorFactory, {
     tileSize = 256,
     maxHistorySteps = 50,
-    historyManager = new HistoryManager(maxHistorySteps)
+    historyManager = new HistoryManager(maxHistorySteps),
+    historyActionFactory = makeHistoryAction,
+    pixelTilePool
   } = {}) {
-    this.target = target;
-    this.config = new PixelEngineConfig(tileSize);
+    this.config = new PixelEngineConfig(tileSize, target);
     this.historyManager = historyManager;
-    this.accumulator = new PixelAccumulator(target, this.config);
+    pixelTilePool ??= new PixelTilePool(this.config);
+    this.accumulator = new PixelAccumulator(this.config, pixelTilePool);
+    this.historyActionFactory = historyActionFactory;
     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)
-    };
+  withHistory(cb, after, afterUndo, afterRedo) {
+    try {
+      cb(this.mutator);
+    } catch (e) {
+      this.accumulator.rollback();
+      throw e;
+    }
+    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);
-    this.accumulator.reset();
   }
 };
 
@@ -3793,11 +4079,10 @@ function resizeImageData(target, newWidth, newHeight, offsetX = 0, offsetY = 0)
 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;
   };
@@ -4204,8 +4489,8 @@ function makeBinaryMask(w, h, data) {
   };
 }
 
-// src/Mask/CircleBrushAlphaMask.ts
-function makeCircleBrushAlphaMask(size, fallOff = () => 1) {
+// src/Mask/CircleAlphaMask.ts
+function makeCircleAlphaMask(size, fallOff = () => 1) {
   const area = size * size;
   const data = new Uint8Array(area);
   const radius = size / 2;
@@ -4233,8 +4518,8 @@ function makeCircleBrushAlphaMask(size, fallOff = () => 1) {
   };
 }
 
-// src/Mask/CircleBrushBinaryMask.ts
-function makeCircleBrushBinaryMask(size) {
+// src/Mask/CircleBinaryMask.ts
+function makeCircleBinaryMask(size) {
   const area = size * size;
   const data = new Uint8Array(area);
   const radius = size / 2;
@@ -4530,57 +4815,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 {
@@ -4693,8 +4927,59 @@ function mergeBinaryMaskRects(current, adding) {
   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 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;
@@ -4712,30 +4997,35 @@ 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/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);
     }
-    return new _PixelData(newImageData);
   }
-};
+}
 
 // src/PixelData/clearPixelData.ts
 function clearPixelData(dst, rect) {
-  fillPixelData(dst, 0, rect);
+  fillPixelDataFast(dst, 0, rect);
 }
 
 // src/PixelData/extractPixelDataBuffer.ts
@@ -4954,6 +5244,124 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
     dstData.set(data.subarray(srcStart, srcStart + copyW), dstStart);
   }
 }
+
+// src/PixelTile/PaintBuffer.ts
+var PaintBuffer = class {
+  constructor(config, tilePool) {
+    this.config = config;
+    this.tilePool = tilePool;
+    this.lookup = [];
+  }
+  lookup;
+  processMaskTiles(mask, callback) {
+    const {
+      tileShift,
+      targetColumns
+    } = this.config;
+    const x1 = mask.x >> tileShift;
+    const y1 = mask.y >> tileShift;
+    const x2 = mask.x + mask.w - 1 >> tileShift;
+    const y2 = mask.y + mask.h - 1 >> tileShift;
+    for (let ty = y1; ty <= y2; ty++) {
+      const tileRowIndex = ty * targetColumns;
+      const tileTop = ty << tileShift;
+      for (let tx = x1; tx <= x2; tx++) {
+        const id = tileRowIndex + tx;
+        let tile = this.lookup[id];
+        if (!tile) {
+          tile = this.tilePool.getTile(id, tx, ty);
+          this.lookup[id] = tile;
+        }
+        const tileLeft = tx << tileShift;
+        const startX = Math.max(mask.x, tileLeft);
+        const endX = Math.min(mask.x + mask.w, tileLeft + this.config.tileSize);
+        const startY = Math.max(mask.y, tileTop);
+        const endY = Math.min(mask.y + mask.h, tileTop + this.config.tileSize);
+        callback(tile, startX, startY, endX - startX, endY - startY, startX - mask.x, startY - mask.y);
+      }
+    }
+  }
+  writeColorBinaryMaskRect(color, mask) {
+    const {
+      tileShift,
+      tileMask
+    } = this.config;
+    const maskData = mask.data;
+    const maskW = mask.w;
+    this.processMaskTiles(mask, (tile, bX, bY, bW, bH, mX, mY) => {
+      const data32 = tile.data32;
+      const startTileX = bX & tileMask;
+      for (let i = 0; i < bH; i++) {
+        const tileY = bY + i & tileMask;
+        const maskY = mY + i;
+        const tileRowOffset = tileY << tileShift;
+        const maskRowOffset = maskY * maskW;
+        const destStart = tileRowOffset + startTileX;
+        const maskStart = maskRowOffset + mX;
+        for (let j = 0; j < bW; j++) {
+          if (maskData[maskStart + j]) {
+            data32[destStart + j] = color;
+          }
+        }
+      }
+    });
+  }
+  writeColorAlphaMaskRect(color, mask) {
+    const {
+      tileShift,
+      tileMask
+    } = this.config;
+    const maskData = mask.data;
+    const maskW = mask.w;
+    const colorRGB = color & 16777215;
+    const colorA = color >>> 24;
+    this.processMaskTiles(mask, (tile, bX, bY, bW, bH, mX, mY) => {
+      const data32 = tile.data32;
+      const startTileX = bX & tileMask;
+      for (let i = 0; i < bH; i++) {
+        const tileY = bY + i & tileMask;
+        const maskY = mY + i;
+        const tileRowOffset = tileY << tileShift;
+        const maskRowOffset = maskY * maskW;
+        const destStart = tileRowOffset + startTileX;
+        const maskStart = maskRowOffset + mX;
+        for (let j = 0; j < bW; j++) {
+          const maskA = maskData[maskStart + j];
+          if (maskA > 0) {
+            const finalA = colorA * maskA + 128 >> 8;
+            data32[destStart + j] = (colorRGB | finalA << 24) >>> 0;
+          }
+        }
+      }
+    });
+  }
+  clear() {
+    this.tilePool.releaseTiles(this.lookup);
+  }
+};
+
+// src/PixelTile/PaintBufferRenderer.ts
+function makePaintBufferRenderer(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(target) {
+    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);
+        target.drawImage(canvas, dx, dy);
+      }
+    }
+  };
+}
 export {
   BASE_FAST_BLEND_MODE_FUNCTIONS,
   BASE_PERFECT_BLEND_MODE_FUNCTIONS,
@@ -4963,17 +5371,18 @@ export {
   IndexedImage,
   MaskType,
   OFFSCREEN_CANVAS_CTX_FAILED,
+  PaintBuffer,
   PixelAccumulator,
   PixelBuffer32,
   PixelData,
   PixelEngineConfig,
   PixelTile,
+  PixelTilePool,
   PixelWriter,
   UnsupportedFormatError,
   applyAlphaMaskToPixelData,
   applyBinaryMaskToAlphaMask,
   applyBinaryMaskToPixelData,
-  applyCircleBrushToPixelData,
   applyPatchTiles,
   applyRectBrushToPixelData,
   base64DecodeArrayBuffer,
@@ -4981,9 +5390,12 @@ export {
   blendColorPixelData,
   blendColorPixelDataAlphaMask,
   blendColorPixelDataBinaryMask,
+  blendColorPixelDataCircleMask,
+  blendPixel,
   blendPixelData,
   blendPixelDataAlphaMask,
   blendPixelDataBinaryMask,
+  blendPixelDataPaintBuffer,
   clearPixelData,
   color32ToCssRGBA,
   color32ToHex,
@@ -5017,6 +5429,7 @@ export {
   fileToImageData,
   fillPixelData,
   fillPixelDataBinaryMask,
+  fillPixelDataFast,
   floodFillSelection,
   forEachLinePoint,
   getCircleBrushOrPencilBounds,
@@ -5057,15 +5470,19 @@ export {
   makeAlphaMask,
   makeBinaryMask,
   makeBlendModeRegistry,
-  makeCircleBrushAlphaMask,
-  makeCircleBrushBinaryMask,
+  makeCanvasFrameRenderer,
+  makeCircleAlphaMask,
+  makeCircleBinaryMask,
   makeFastBlendModeRegistry,
   makeFullPixelMutator,
+  makeHistoryAction,
   makeImageDataLike,
+  makePaintBufferRenderer,
   makePerfectBlendModeRegistry,
   makePixelCanvas,
   makeReusableCanvas,
   makeReusableImageData,
+  makeReusableOffscreenCanvas,
   merge2BinaryMaskRects,
   mergeAlphaMasks,
   mergeBinaryMaskRects,
@@ -5074,7 +5491,6 @@ export {
   multiplyPerfect,
   mutatorApplyAlphaMask,
   mutatorApplyBinaryMask,
-  mutatorApplyCircleBrush,
   mutatorApplyCircleBrushStroke,
   mutatorApplyCirclePencil,
   mutatorApplyCirclePencilStroke,
@@ -5083,6 +5499,7 @@ export {
   mutatorApplyRectPencil,
   mutatorApplyRectPencilStroke,
   mutatorBlendColor,
+  mutatorBlendColorCircleMask,
   mutatorBlendPixel,
   mutatorBlendPixelData,
   mutatorBlendPixelDataAlphaMask,
@@ -5090,6 +5507,7 @@ export {
   mutatorClear,
   mutatorFill,
   mutatorFillBinaryMask,
+  mutatorFillRect,
   mutatorInvert,
   overlayFast,
   overlayPerfect,