pixel-data-js 0.24.0 → 0.25.2

package/dist/index.prod.js

@@ -232,8 +232,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;
@@ -421,7 +421,7 @@ function floodFillSelection(img, startX, startY, {
       finalMask[my * sw + mx] = 1;
     }
   }
-  trimRectBounds(selectionRect, {
+  trimMaskRectBounds(selectionRect, {
     x: 0,
     y: 0,
     w: width,
@@ -1533,6 +1533,24 @@ 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/canvas-blend-modes.ts
+var CANVAS_COMPOSITE_MAP = {
+  [BaseBlendMode.overwrite]: "copy",
+  [BaseBlendMode.sourceOver]: "source-over",
+  [BaseBlendMode.darken]: "darken",
+  [BaseBlendMode.multiply]: "multiply",
+  [BaseBlendMode.colorBurn]: "color-burn",
+  [BaseBlendMode.lighten]: "lighten",
+  [BaseBlendMode.screen]: "screen",
+  [BaseBlendMode.colorDodge]: "color-dodge",
+  [BaseBlendMode.linearDodge]: "lighter",
+  [BaseBlendMode.overlay]: "overlay",
+  [BaseBlendMode.softLight]: "soft-light",
+  [BaseBlendMode.hardLight]: "hard-light",
+  [BaseBlendMode.difference]: "difference",
+  [BaseBlendMode.exclusion]: "exclusion"
+};
+
 // src/Canvas/ReusableCanvas.ts
 function makeReusableCanvas() {
   return makeReusableCanvasMeta((w, h) => {
@@ -1811,11 +1829,11 @@ var PixelAccumulator = class {
    * @param y pixel y coordinate
    */
   storePixelBeforeState(x, y) {
-    let shift = this.config.tileShift;
-    let columns = this.config.targetColumns;
-    let tx = x >> shift;
-    let ty = y >> shift;
-    let id = ty * columns + tx;
+    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) {
@@ -1841,16 +1859,16 @@ var PixelAccumulator = class {
    * @param h pixel height
    */
   storeRegionBeforeState(x, y, w, h) {
-    let shift = this.config.tileShift;
-    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;
+    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.tilePool.getTile(id, tx, ty);
@@ -1862,7 +1880,7 @@ var PixelAccumulator = class {
     }
     return (didChange) => {
       if (!didChange) {
-        let length = this.beforeTiles.length;
+        const length = this.beforeTiles.length;
         for (let i = startIndex; i < length; i++) {
           let t = this.beforeTiles[i];
           if (t) {
@@ -1875,15 +1893,34 @@ var PixelAccumulator = class {
       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.config.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;
+    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;
@@ -1909,8 +1946,8 @@ var PixelAccumulator = class {
     }
   }
   extractPatch() {
-    let afterTiles = [];
-    let length = this.beforeTiles.length;
+    const afterTiles = [];
+    const length = this.beforeTiles.length;
     for (let i = 0; i < length; i++) {
       let beforeTile = this.beforeTiles[i];
       if (beforeTile) {
@@ -1919,7 +1956,7 @@ var PixelAccumulator = class {
         afterTiles.push(afterTile);
       }
     }
-    let beforeTiles = this.beforeTiles;
+    const beforeTiles = this.beforeTiles;
     this.beforeTiles = [];
     this.lookup.length = 0;
     return {
@@ -1927,10 +1964,10 @@ var PixelAccumulator = class {
       afterTiles
     };
   }
-  rollback() {
-    let target = this.config.target;
-    let tileSize = this.config.tileSize;
-    let length = this.beforeTiles.length;
+  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];
@@ -1954,6 +1991,7 @@ var PixelEngineConfig = class {
   tileArea;
   target;
   targetColumns = 0;
+  targetRows = 0;
   constructor(tileSize, target) {
     if ((tileSize & tileSize - 1) !== 0) {
       throw new Error("tileSize must be a power of 2");
@@ -1962,28 +2000,26 @@ var PixelEngineConfig = class {
     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;
+    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 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;
@@ -1996,82 +2032,46 @@ 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 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 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;
+  let dIdx = y * dw + x | 0;
+  const dStride = dw - actualW | 0;
   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;
+  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;
-      } 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/mutatorApplyAlphaMask.ts
+// src/History/PixelMutator/mutatorBlendColor.ts
 var defaults2 = {
-  applyAlphaMaskToPixelData
+  blendColorPixelData
 };
-var mutatorApplyAlphaMask = ((writer, deps = defaults2) => {
+var mutatorBlendColor = ((writer, deps = defaults2) => {
   const {
-    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults2.applyAlphaMaskToPixelData
+    blendColorPixelData: blendColorPixelData2 = defaults2.blendColorPixelData
   } = deps;
   return {
-    applyAlphaMask(mask, opts = {}) {
-      let target = writer.config.target;
+    blendColor(color, opts = {}) {
+      const target = writer.config.target;
       const {
         x = 0,
         y = 0,
@@ -2079,159 +2079,227 @@ var mutatorApplyAlphaMask = ((writer, deps = defaults2) => {
         h = target.height
       } = opts;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(applyAlphaMaskToPixelData2(target, mask, opts));
+      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 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 || 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 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;
+  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 < 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;
-          }
+  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 defaults3 = {
-  applyBinaryMaskToPixelData
+// src/History/PixelMutator/mutatorBlendPixelData.ts
+var defaults4 = {
+  blendPixelData
 };
-var mutatorApplyBinaryMask = ((writer, deps = defaults3) => {
+var mutatorBlendPixelData = ((writer, deps = defaults4) => {
   const {
-    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults3.applyBinaryMaskToPixelData
+    blendPixelData: blendPixelData2 = defaults4.blendPixelData
   } = deps;
   return {
-    applyBinaryMask(mask, opts = {}) {
-      let target = writer.config.target;
+    blendPixelData(src, opts = {}) {
       const {
         x = 0,
         y = 0,
-        w = target.width,
-        h = target.height
+        w = src.width,
+        h = src.height
       } = opts;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(applyBinaryMaskToPixelData2(target, mask, opts));
+      return didChange(blendPixelData2(writer.config.target, src, opts));
     }
   };
 });
 
-// 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;
+// 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;
-  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;
+  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);
+  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;
+  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++) {
@@ -2239,6 +2307,15 @@ function blendColorPixelDataAlphaMask(dst, color, mask, opts = {}) {
       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;
       }
@@ -2250,844 +2327,459 @@ 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, current);
+      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/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/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/mutatorBlendPixelDataAlphaMask.ts
+var defaults5 = {
+  blendPixelDataAlphaMask
 };
-var mutatorApplyCircleBrushStroke = ((writer, deps = defaults4) => {
+var mutatorBlendPixelDataAlphaMask = ((writer, deps = defaults5) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults4.forEachLinePoint,
-    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults4.blendColorPixelDataAlphaMask,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults4.getCircleBrushOrPencilBounds,
-    getCircleBrushOrPencilStrokeBounds: getCircleBrushOrPencilStrokeBounds2 = defaults4.getCircleBrushOrPencilStrokeBounds
+    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults5.blendPixelDataAlphaMask
   } = 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 target = writer.config.target;
-      const targetWidth = target.width;
-      const targetHeight = 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(target, color, mask, blendColorPixelOptions);
+    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/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;
+// 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;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) 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;
-  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 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;
       }
+      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(baseColorWithGlobalAlpha, current);
+      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/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 = {
-  blendColorPixelDataCircleMask,
-  getCircleBrushOrPencilBounds
+// src/History/PixelMutator/mutatorBlendPixelDataBinaryMask.ts
+var defaults6 = {
+  blendPixelDataBinaryMask
 };
-var mutatorBlendColorCircleMask = ((writer, deps = defaults5) => {
+var mutatorBlendPixelDataBinaryMask = ((writer, deps = defaults6) => {
   const {
-    blendColorPixelDataCircleMask: blendColorPixelDataCircleMask2 = defaults5.blendColorPixelDataCircleMask,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults5.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 {
-    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));
+    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/History/PixelMutator/mutatorApplyCirclePencil.ts
-var defaults6 = {
-  applyCircleMaskToPixelData: blendColorPixelDataCircleMask,
-  getCircleBrushOrPencilBounds
-};
-var mutatorApplyCirclePencil = ((writer, deps = defaults6) => {
+// 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 {
-    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 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));
-    }
-  };
-});
+    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/mutatorApplyCirclePencilStroke.ts
+// src/History/PixelMutator/mutatorClear.ts
 var defaults7 = {
-  forEachLinePoint,
-  blendColorPixelDataBinaryMask,
-  getCircleBrushOrPencilBounds,
-  getCircleBrushOrPencilStrokeBounds
+  fillPixelData: fillPixelDataFast
 };
-var mutatorApplyCirclePencilStroke = ((writer, deps = defaults7) => {
+var mutatorClear = ((writer, deps = defaults7) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults7.forEachLinePoint,
-    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults7.blendColorPixelDataBinaryMask,
-    getCircleBrushOrPencilStrokeBounds: getCircleBrushOrPencilStrokeBounds2 = defaults7.getCircleBrushOrPencilStrokeBounds,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults7.getCircleBrushOrPencilBounds
+    fillPixelData: fillPixelData2 = defaults7.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;
+    clear(rect = {}) {
       const target = writer.config.target;
-      const targetWidth = target.width;
-      const targetHeight = 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(target, color, mask, blendColorPixelOptions);
+      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/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 false;
+// 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 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;
-  let didChange = false;
-  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;
-      }
-      const current = data32[idx];
-      const next = blendFn(finalCol, current);
-      if (current !== next) {
-        data32[idx] = next;
-        didChange = true;
+  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 didChange;
+  return hasChanged;
 }
 
-// src/History/PixelMutator/mutatorApplyRectBrush.ts
+// src/History/PixelMutator/mutatorFill.ts
 var defaults8 = {
-  applyRectBrushToPixelData,
-  getRectBrushOrPencilBounds
+  fillPixelData
 };
-var mutatorApplyRectBrush = ((writer, deps = defaults8) => {
+var mutatorFill = ((writer, deps = defaults8) => {
   const {
-    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults8.applyRectBrushToPixelData,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults8.getRectBrushOrPencilBounds
+    fillPixelData: fillPixelData2 = defaults8.fillPixelData
   } = deps;
-  const boundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
   return {
-    applyRectBrush(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn) {
+    fill(color, x = 0, y = 0, w = writer.config.target.width, h = writer.config.target.height) {
       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));
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(fillPixelData2(target, color, x, y, w, h));
     }
   };
 });
-
-// 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/History/PixelMutator/mutatorApplyRectBrushStroke.ts
-var defaults9 = {
-  forEachLinePoint,
-  blendColorPixelDataAlphaMask,
-  getRectBrushOrPencilBounds,
-  getRectBrushOrPencilStrokeBounds
-};
-var mutatorApplyRectBrushStroke = ((writer, deps = defaults9) => {
+var mutatorFillRect = ((writer, deps = defaults8) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults9.forEachLinePoint,
-    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults9.blendColorPixelDataAlphaMask,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults9.getRectBrushOrPencilBounds,
-    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults9.getRectBrushOrPencilStrokeBounds
+    fillPixelData: fillPixelData2 = defaults8.fillPixelData
   } = 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) {
-      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;
+    fillRect(color, rect) {
       const target = writer.config.target;
-      const targetWidth = target.width;
-      const targetHeight = 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(target, color, mask, blendColorPixelOptions);
+      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/History/PixelMutator/mutatorApplyRectPencil.ts
-var defaults10 = {
-  applyRectBrushToPixelData,
-  getRectBrushOrPencilBounds,
-  fallOff: () => 1
-};
-var mutatorApplyRectPencil = ((writer, deps = defaults10) => {
+// 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 {
-    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults10.applyRectBrushToPixelData,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults10.getRectBrushOrPencilBounds,
-    fallOff = defaults10.fallOff
-  } = deps;
-  const boundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  return {
-    applyRectPencil(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, blendFn) {
-      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 defaults11 = {
-  forEachLinePoint,
-  getRectBrushOrPencilBounds,
-  getRectBrushOrPencilStrokeBounds,
-  blendColorPixelDataBinaryMask
+    x: finalX,
+    y: finalY,
+    w: actualW,
+    h: actualH
+  } = clip;
+  const maskData = mask.data;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  let finalCol = color;
+  if (alpha < 255) {
+    const baseSrcAlpha = color >>> 24;
+    const colorRGB = color & 16777215;
+    const a = baseSrcAlpha * alpha + 128 >> 8;
+    finalCol = (colorRGB | a << 24) >>> 0;
+  }
+  let hasChanged = false;
+  for (let iy = 0; iy < actualH; iy++) {
+    const currentY = finalY + iy;
+    const maskY = currentY - y;
+    const maskOffset = maskY * maskW;
+    const dstRowOffset = currentY * dw;
+    for (let ix = 0; ix < actualW; ix++) {
+      const currentX = finalX + ix;
+      const maskX = currentX - x;
+      const maskIndex = maskOffset + maskX;
+      if (maskData[maskIndex]) {
+        const current = dst32[dstRowOffset + currentX];
+        if (current !== finalCol) {
+          dst32[dstRowOffset + currentX] = finalCol;
+          hasChanged = true;
+        }
+      }
+    }
+  }
+  return hasChanged;
+}
+
+// src/History/PixelMutator/mutatorFillBinaryMask.ts
+var defaults9 = {
+  fillPixelDataBinaryMask
 };
-var mutatorApplyRectPencilStroke = ((writer, deps = defaults11) => {
+var mutatorFillBinaryMask = ((writer, deps = defaults9) => {
   const {
-    forEachLinePoint: forEachLinePoint2 = defaults11.forEachLinePoint,
-    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults11.blendColorPixelDataBinaryMask,
-    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults11.getRectBrushOrPencilBounds,
-    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults11.getRectBrushOrPencilStrokeBounds
+    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults9.fillPixelDataBinaryMask
   } = deps;
-  const strokeBoundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  const rectPencilBounds = {
-    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 {
-    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 target = writer.config.target;
-      const targetWidth = target.width;
-      const targetHeight = 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(target, color, mask, blendColorPixelOptions);
+    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/PixelData/blendColorPixelData.ts
-function blendColorPixelData(dst, color, opts = {}) {
+// src/PixelData/invertPixelData.ts
+var SCRATCH_RECT4 = makeClippedRect();
+function invertPixelData(pixelData, opts = {}) {
+  const dst = pixelData;
   const {
     x: targetX = 0,
     y: targetY = 0,
-    w: width = dst.width,
-    h: height = dst.height,
-    alpha: globalAlpha = 255,
-    blendFn = sourceOverPerfect
+    w: width = pixelData.width,
+    h: height = pixelData.height,
+    mask,
+    mx = 0,
+    my = 0,
+    invertMask = false
   } = opts;
-  if (globalAlpha === 0) return false;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) return false;
-  let x = targetX;
-  let y = targetY;
-  let w = width;
-  let h = height;
-  if (x < 0) {
-    w += x;
-    x = 0;
-  }
-  if (y < 0) {
-    h += y;
-    y = 0;
-  }
-  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 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;
-  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;
+  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++;
+      dIdx += dStride;
+      mIdx += mStride;
+    }
+  } else {
+    for (let iy = 0; iy < actualH; iy++) {
+      for (let ix = 0; ix < actualW; ix++) {
+        dst32[dIdx] = dst32[dIdx] ^ 16777215;
+        dIdx++;
+      }
+      dIdx += dStride;
     }
-    dIdx += dStride;
   }
-  return didChange;
+  return true;
 }
 
-// src/History/PixelMutator/mutatorBlendColor.ts
-var defaults12 = {
-  blendColorPixelData
+// src/History/PixelMutator/mutatorInvert.ts
+var defaults10 = {
+  invertPixelData
 };
-var mutatorBlendColor = ((writer, deps = defaults12) => {
+var mutatorInvert = ((writer, deps = defaults10) => {
   const {
-    blendColorPixelData: blendColorPixelData2 = defaults12.blendColorPixelData
+    invertPixelData: invertPixelData2 = defaults10.invertPixelData
   } = deps;
   return {
-    blendColor(color, opts = {}) {
+    invert(opts = {}) {
       const target = writer.config.target;
       const {
         x = 0,
@@ -3096,708 +2788,644 @@ var mutatorBlendColor = ((writer, deps = defaults12) => {
         h = target.height
       } = opts;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(blendColorPixelData2(target, color, opts));
+      return didChange(invertPixelData2(target, 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;
+// src/History/PixelMutator.ts
+function makeFullPixelMutator(writer) {
+  return {
+    // @sort
+    ...mutatorBlendColor(writer),
+    ...mutatorBlendPixel(writer),
+    ...mutatorBlendPixelData(writer),
+    ...mutatorBlendPixelDataAlphaMask(writer),
+    ...mutatorBlendPixelDataBinaryMask(writer),
+    ...mutatorClear(writer),
+    ...mutatorFill(writer),
+    ...mutatorFillBinaryMask(writer),
+    ...mutatorFillRect(writer),
+    ...mutatorInvert(writer)
+  };
+}
+
+// src/ImageData/resizeImageData.ts
+function resizeImageData(target, newWidth, newHeight, offsetX = 0, offsetY = 0) {
+  const result = new ImageData(newWidth, newHeight);
+  const {
+    width: oldW,
+    height: oldH,
+    data: oldData
+  } = target;
+  const newData = result.data;
+  const x0 = Math.max(0, offsetX);
+  const y0 = Math.max(0, offsetY);
+  const x1 = Math.min(newWidth, offsetX + oldW);
+  const y1 = Math.min(newHeight, offsetY + oldH);
+  if (x1 <= x0 || y1 <= y0) {
+    return result;
   }
-  let current = dst32[index];
-  let next = blendFn(finalColor, current);
-  if (current !== next) {
-    dst32[index] = next;
-    return true;
+  const rowCount = y1 - y0;
+  const rowLen = (x1 - x0) * 4;
+  for (let row = 0; row < rowCount; row++) {
+    const dstY = y0 + row;
+    const srcY = dstY - offsetY;
+    const srcX = x0 - offsetX;
+    const dstStart = (dstY * newWidth + x0) * 4;
+    const srcStart = (srcY * oldW + srcX) * 4;
+    newData.set(oldData.subarray(srcStart, srcStart + rowLen), dstStart);
   }
-  return false;
+  return result;
 }
 
-// src/History/PixelMutator/mutatorBlendPixel.ts
-var defaults13 = {
-  blendPixel
-};
-var mutatorBlendPixel = ((writer, deps = defaults13) => {
-  const {
-    blendPixel: blendPixel2 = defaults13.blendPixel
-  } = deps;
-  return {
-    blendPixel(x, y, color, alpha, blendFn) {
-      const didChange = writer.accumulator.storePixelBeforeState(x, y);
-      return didChange(blendPixel2(writer.config.target, x, y, color, alpha, blendFn));
-    }
-  };
-});
+// src/Internal/helpers.ts
+var macro_halfAndFloor = (value) => value >> 1;
 
-// src/PixelData/blendPixelData.ts
-function blendPixelData(dst, src, opts = {}) {
-  const {
-    x: targetX = 0,
-    y: targetY = 0,
-    sx: sourceX = 0,
-    sy: sourceY = 0,
-    w: width = src.width,
-    h: height = src.height,
-    alpha: globalAlpha = 255,
-    blendFn = sourceOverPerfect
-  } = opts;
-  if (globalAlpha === 0) return false;
-  let x = targetX;
-  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 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;
-  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++;
-      sIdx++;
-    }
-    dIdx += dStride;
-    sIdx += sStride;
-  }
-  return didChange;
-}
-
-// src/History/PixelMutator/mutatorBlendPixelData.ts
-var defaults14 = {
-  blendPixelData
-};
-var mutatorBlendPixelData = ((writer, deps = defaults14) => {
-  const {
-    blendPixelData: blendPixelData2 = defaults14.blendPixelData
-  } = deps;
-  return {
-    blendPixelData(src, opts = {}) {
-      const {
-        x = 0,
-        y = 0,
-        w = src.width,
-        h = src.height
-      } = opts;
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(blendPixelData2(writer.config.target, src, opts));
-    }
-  };
-});
-
-// src/PixelData/blendPixelDataAlphaMask.ts
-function blendPixelDataAlphaMask(dst, src, alphaMask, opts = {}) {
-  const {
-    x: targetX = 0,
-    y: targetY = 0,
-    sx: sourceX = 0,
-    sy: sourceY = 0,
-    w: width = src.width,
-    h: height = src.height,
-    alpha: globalAlpha = 255,
-    blendFn = sourceOverPerfect,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
-  if (globalAlpha === 0) return false;
-  let x = targetX;
-  let y = targetY;
-  let sx = sourceX;
-  let sy = sourceY;
-  let w = width;
-  let h = height;
-  if (sx < 0) {
-    x -= sx;
-    w += sx;
-    sx = 0;
-  }
-  if (sy < 0) {
-    y -= sy;
-    h += sy;
-    sy = 0;
-  }
-  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 dw = dst.width;
-  const sw = src.width;
-  const mPitch = alphaMask.w;
-  const maskData = alphaMask.data;
-  const dx = x - targetX | 0;
-  const dy = y - targetY | 0;
-  const dst32 = dst.data32;
-  const src32 = src.data32;
-  let dIdx = y * dw + x | 0;
-  let sIdx = sy * sw + sx | 0;
-  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
-  const dStride = dw - actualW | 0;
-  const sStride = sw - actualW | 0;
-  const mStride = mPitch - actualW | 0;
-  const isOpaque = globalAlpha === 255;
-  const isOverwrite = blendFn.isOverwrite || false;
-  let didChange = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      const mVal = maskData[mIdx];
-      const effM = invertMask ? 255 - mVal : mVal;
-      if (effM === 0) {
-        dIdx++;
-        sIdx++;
-        mIdx++;
-        continue;
-      }
-      const srcCol = src32[sIdx];
-      const srcAlpha = srcCol >>> 24;
-      if (srcAlpha === 0 && !isOverwrite) {
-        dIdx++;
-        sIdx++;
-        mIdx++;
-        continue;
-      }
-      let weight = globalAlpha;
-      if (isOpaque) {
-        weight = effM;
-      } else if (effM !== 255) {
-        weight = effM * globalAlpha + 128 >> 8;
-      }
-      if (weight === 0) {
-        dIdx++;
-        sIdx++;
-        mIdx++;
-        continue;
-      }
-      let finalCol = srcCol;
-      if (weight < 255) {
-        const a = srcAlpha * weight + 128 >> 8;
-        if (a === 0 && !isOverwrite) {
-          dIdx++;
-          sIdx++;
-          mIdx++;
-          continue;
-        }
-        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
-      }
-      const current = dst32[dIdx];
-      const next = blendFn(finalCol, dst32[dIdx]);
-      if (current !== next) {
-        dst32[dIdx] = next;
-        didChange = true;
-      }
-      dIdx++;
-      sIdx++;
-      mIdx++;
-    }
-    dIdx += dStride;
-    sIdx += sStride;
-    mIdx += mStride;
-  }
-  return didChange;
-}
-
-// src/History/PixelMutator/mutatorBlendPixelDataAlphaMask.ts
-var defaults15 = {
-  blendPixelDataAlphaMask
-};
-var mutatorBlendPixelDataAlphaMask = ((writer, deps = defaults15) => {
-  const {
-    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults15.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/Rect/trimRectBounds.ts
+function trimRectBounds(x, y, w, h, targetWidth, targetHeight, out) {
+  const res = out ?? {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
   };
-});
-
-// 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 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 = [];
   }
-  const actualW = Math.min(w, dst.width - x);
-  const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0) return false;
-  const dx = x - targetX | 0;
-  const dy = y - targetY | 0;
-  const dst32 = dst.data32;
-  const src32 = src.data32;
-  const dw = dst.width;
-  const sw = src.width;
-  const mPitch = binaryMask.w;
-  const maskData = binaryMask.data;
-  let dIdx = y * dw + x | 0;
-  let sIdx = sy * sw + sx | 0;
-  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
-  const dStride = dw - actualW | 0;
-  const sStride = sw - actualW | 0;
-  const mStride = mPitch - actualW | 0;
-  const skipVal = invertMask ? 1 : 0;
-  const isOpaque = globalAlpha === 255;
-  const isOverwrite = blendFn.isOverwrite || false;
-  let didChange = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      if (maskData[mIdx] === skipVal) {
-        dIdx++;
-        sIdx++;
-        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;
-      }
-      const current = dst32[dIdx];
-      const next = blendFn(finalCol, dst32[dIdx]);
-      if (current !== next) {
-        dst32[dIdx] = next;
-        didChange = true;
+  lookup;
+  scratchBounds = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  eachTileInBounds(bounds, callback) {
+    const {
+      tileShift,
+      targetColumns,
+      targetRows,
+      tileSize
+    } = this.config;
+    const x1 = Math.max(0, bounds.x >> tileShift);
+    const y1 = Math.max(0, bounds.y >> tileShift);
+    const x2 = Math.min(targetColumns - 1, bounds.x + bounds.w - 1 >> tileShift);
+    const y2 = Math.min(targetRows - 1, bounds.y + bounds.h - 1 >> tileShift);
+    if (x1 > x2 || y1 > y2) return;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    for (let ty = y1; ty <= y2; ty++) {
+      const rowOffset = ty * targetColumns;
+      const tileTop = ty << tileShift;
+      for (let tx = x1; tx <= x2; tx++) {
+        const id = rowOffset + tx;
+        const tile = lookup[id] ?? (lookup[id] = tilePool.getTile(id, tx, ty));
+        const tileLeft = tx << tileShift;
+        const startX = bounds.x > tileLeft ? bounds.x : tileLeft;
+        const startY = bounds.y > tileTop ? bounds.y : tileTop;
+        const maskEndX = bounds.x + bounds.w;
+        const tileEndX = tileLeft + tileSize;
+        const endX = maskEndX < tileEndX ? maskEndX : tileEndX;
+        const maskEndY = bounds.y + bounds.h;
+        const tileEndY = tileTop + tileSize;
+        const endY = maskEndY < tileEndY ? maskEndY : tileEndY;
+        callback(tile, startX, startY, endX - startX, endY - startY);
       }
-      dIdx++;
-      sIdx++;
-      mIdx++;
     }
-    dIdx += dStride;
-    sIdx += sStride;
-    mIdx += mStride;
   }
-  return didChange;
-}
-
-// src/History/PixelMutator/mutatorBlendPixelDataBinaryMask.ts
-var defaults16 = {
-  blendPixelDataBinaryMask
-};
-var mutatorBlendPixelDataBinaryMask = ((writer, deps = defaults16) => {
-  const {
-    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults16.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;
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(blendPixelDataBinaryMask2(writer.config.target, src, mask, opts));
-    }
-  };
-});
-
-// src/PixelData/fillPixelDataFast.ts
-var SCRATCH_RECT = makeClippedRect();
-function fillPixelDataFast(dst, color, _x, _y, _w, _h) {
-  let x;
-  let y;
-  let w;
-  let h;
-  if (typeof _x === "object") {
-    x = _x.x ?? 0;
-    y = _x.y ?? 0;
-    w = _x.w ?? dst.width;
-    h = _x.h ?? dst.height;
-  } else if (typeof _x === "number") {
-    x = _x;
-    y = _y;
-    w = _w;
-    h = _h;
-  } else {
-    x = 0;
-    y = 0;
-    w = dst.width;
-    h = dst.height;
+  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;
   }
-  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;
+  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;
   }
-  for (let iy = 0; iy < actualH; iy++) {
-    const start = (finalY + iy) * dw + finalX;
-    const end = start + actualW;
-    dst32.fill(color, start, end);
+  clear() {
+    this.tilePool.releaseTiles(this.lookup);
   }
-}
+};
 
-// src/History/PixelMutator/mutatorClear.ts
-var defaults17 = {
-  fillPixelData: fillPixelDataFast
+// src/PixelTile/PixelTile.ts
+var PixelTile = class {
+  constructor(id, tx, ty, tileSize, tileArea) {
+    this.id = id;
+    this.tx = tx;
+    this.ty = ty;
+    this.width = this.height = tileSize;
+    this.data32 = new Uint32Array(tileArea);
+    const data8 = new Uint8ClampedArray(this.data32.buffer);
+    this.imageData = new ImageData(data8, tileSize, tileSize);
+  }
+  data32;
+  width;
+  height;
+  imageData;
 };
-var mutatorClear = ((writer, deps = defaults17) => {
-  const {
-    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 ?? target.width;
-      const h = rect.h ?? target.height;
-      writer.accumulator.storeRegionBeforeState(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;
+// src/PixelTile/PixelTilePool.ts
+var PixelTilePool = class {
+  pool;
+  tileSize;
+  tileArea;
+  constructor(config) {
+    this.pool = [];
+    this.tileSize = config.tileSize;
+    this.tileArea = config.tileArea;
   }
-  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;
+  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;
   }
-  return hasChanged;
-}
-
-// src/History/PixelMutator/mutatorFill.ts
-var defaults18 = {
-  fillPixelData
 };
-var mutatorFill = ((writer, deps = defaults18) => {
-  const {
-    fillPixelData: fillPixelData2 = defaults18.fillPixelData
-  } = deps;
-  return {
-    fill(color, x = 0, y = 0, w = writer.config.target.width, h = writer.config.target.height) {
-      const target = writer.config.target;
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(fillPixelData2(target, color, x, y, w, h));
-    }
+
+// 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
   };
-});
-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));
+  _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/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;
+// src/PixelData/applyAlphaMaskToPixelData.ts
+function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
   const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH
-  } = clip;
-  const maskData = mask.data;
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (globalAlpha === 0) return false;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  w = Math.min(w, dst.width - x);
+  h = Math.min(h, dst.height - y);
+  if (w <= 0) return false;
+  if (h <= 0) return false;
+  const mPitch = mask.w;
+  if (mPitch <= 0) return false;
+  const startX = mx + (x - targetX);
+  const startY = my + (y - targetY);
+  const sX0 = Math.max(0, startX);
+  const sY0 = Math.max(0, startY);
+  const sX1 = Math.min(mPitch, startX + w);
+  const sY1 = Math.min(mask.h, startY + h);
+  const finalW = sX1 - sX0;
+  const finalH = sY1 - sY0;
+  if (finalW <= 0) return false;
+  if (finalH <= 0) return false;
+  const xShift = sX0 - startX;
+  const yShift = sY0 - startY;
   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;
+  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 hasChanged;
+  return didChange;
 }
 
-// src/History/PixelMutator/mutatorFillBinaryMask.ts
-var defaults19 = {
-  fillPixelDataBinaryMask
+// src/History/PixelMutator/mutatorApplyAlphaMask.ts
+var defaults11 = {
+  applyAlphaMaskToPixelData
 };
-var mutatorFillBinaryMask = ((writer, deps = defaults19) => {
+var mutatorApplyAlphaMask = ((writer, deps = defaults11) => {
   const {
-    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults19.fillPixelDataBinaryMask
+    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults11.applyAlphaMaskToPixelData
   } = deps;
   return {
-    fillBinaryMask(color, mask, alpha = 255, x = 0, y = 0) {
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, mask.w, mask.h);
-      return didChange(fillPixelDataBinaryMask2(writer.config.target, color, mask, alpha, x, y));
+    applyAlphaMask(mask, opts = {}) {
+      let target = writer.config.target;
+      const {
+        x = 0,
+        y = 0,
+        w = target.width,
+        h = target.height
+      } = opts;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      return didChange(applyAlphaMaskToPixelData2(target, mask, opts));
     }
   };
 });
 
-// src/PixelData/invertPixelData.ts
-var SCRATCH_RECT4 = makeClippedRect();
-function invertPixelData(pixelData, opts = {}) {
-  const dst = pixelData;
+// src/PixelData/applyBinaryMaskToPixelData.ts
+function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
   const {
     x: targetX = 0,
     y: targetY = 0,
-    w: width = pixelData.width,
-    h: height = pixelData.height,
-    mask,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
     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;
+  if (globalAlpha === 0) return false;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  w = Math.min(w, dst.width - x);
+  h = Math.min(h, dst.height - y);
+  if (w <= 0 || h <= 0) return false;
+  const mPitch = mask.w;
+  if (mPitch <= 0) return false;
+  const startX = mx + (x - targetX);
+  const startY = my + (y - targetY);
+  const sX0 = Math.max(0, startX);
+  const sY0 = Math.max(0, startY);
+  const sX1 = Math.min(mPitch, startX + w);
+  const sY1 = Math.min(mask.h, startY + h);
+  const finalW = sX1 - sX0;
+  const finalH = sY1 - sY0;
+  if (finalW <= 0 || finalH <= 0) {
+    return false;
+  }
+  const xShift = sX0 - startX;
+  const yShift = sY0 - startY;
   const dst32 = dst.data32;
   const dw = dst.width;
-  const 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 true;
+  return didChange;
 }
 
-// src/History/PixelMutator/mutatorInvert.ts
-var defaults20 = {
-  invertPixelData
+// src/History/PixelMutator/mutatorApplyBinaryMask.ts
+var defaults12 = {
+  applyBinaryMaskToPixelData
 };
-var mutatorInvert = ((writer, deps = defaults20) => {
+var mutatorApplyBinaryMask = ((writer, deps = defaults12) => {
   const {
-    invertPixelData: invertPixelData2 = defaults20.invertPixelData
+    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults12.applyBinaryMaskToPixelData
   } = deps;
   return {
-    invert(opts = {}) {
-      const target = writer.config.target;
+    applyBinaryMask(mask, opts = {}) {
+      let target = writer.config.target;
       const {
         x = 0,
         y = 0,
@@ -3805,125 +3433,200 @@ var mutatorInvert = ((writer, deps = defaults20) => {
         h = target.height
       } = opts;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      return didChange(invertPixelData2(target, opts));
+      return didChange(applyBinaryMaskToPixelData2(target, mask, opts));
     }
   };
 });
 
-// src/History/PixelMutator.ts
-function makeFullPixelMutator(writer) {
-  return {
-    // @sort
-    ...mutatorApplyAlphaMask(writer),
-    ...mutatorApplyBinaryMask(writer),
-    ...mutatorApplyCircleBrushStroke(writer),
-    ...mutatorApplyCirclePencil(writer),
-    ...mutatorApplyCirclePencilStroke(writer),
-    ...mutatorApplyRectBrush(writer),
-    ...mutatorApplyRectBrushStroke(writer),
-    ...mutatorApplyRectPencil(writer),
-    ...mutatorApplyRectPencilStroke(writer),
-    ...mutatorBlendColor(writer),
-    ...mutatorBlendColorCircleMask(writer),
-    ...mutatorBlendPixel(writer),
-    ...mutatorBlendPixelData(writer),
-    ...mutatorBlendPixelDataAlphaMask(writer),
-    ...mutatorBlendPixelDataBinaryMask(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);
+// 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;
   }
-  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;
+  if (y < 0) {
+    actualH += y;
+    y = 0;
   }
-  getTile(id, tx, ty) {
-    let tile = this.pool.pop();
-    if (tile) {
-      tile.id = id;
-      tile.tx = tx;
-      tile.ty = ty;
-      tile.data32.fill(0);
-      return tile;
+  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++;
     }
-    return new PixelTile(id, tx, ty, this.tileSize, this.tileArea);
+    dIdx += dStride;
+    mIdx += mStride;
   }
-  releaseTile(tile) {
-    this.pool.push(tile);
+  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;
   }
-  releaseTiles(tiles) {
-    let length = tiles.length;
-    for (let i = 0; i < length; i++) {
-      let tile = tiles[i];
-      if (tile) {
-        this.pool.push(tile);
+  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++;
     }
-    tiles.length = 0;
+    dIdx += dStride;
+    mIdx += mStride;
   }
-};
+  return didChange;
+}
 
-// src/History/PixelWriter.ts
-var PixelWriter = class {
-  historyManager;
-  accumulator;
-  historyActionFactory;
-  config;
-  mutator;
-  constructor(target, mutatorFactory, {
-    tileSize = 256,
-    maxHistorySteps = 50,
-    historyManager = new HistoryManager(maxHistorySteps),
-    historyActionFactory = makeHistoryAction,
-    pixelTilePool
-  } = {}) {
-    this.config = new PixelEngineConfig(tileSize, target);
-    this.historyManager = historyManager;
-    pixelTilePool ??= new PixelTilePool(this.config);
-    this.accumulator = new PixelAccumulator(this.config, pixelTilePool);
-    this.historyActionFactory = historyActionFactory;
-    this.mutator = mutatorFactory(this);
-  }
-  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);
-  }
+// src/History/PixelMutator/mutatorBlendPaintMask.ts
+var defaults13 = {
+  blendColorPixelDataAlphaMask,
+  blendColorPixelDataBinaryMask
 };
+var mutatorBlendPaintMask = ((writer, deps = defaults13) => {
+  const {
+    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults13.blendColorPixelDataBinaryMask,
+    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults13.blendColorPixelDataAlphaMask
+  } = deps;
+  const OPTS = {
+    x: 0,
+    y: 0,
+    blendFn: sourceOverPerfect,
+    alpha: 255
+  };
+  return {
+    blendColorPaintMask(color, mask, x, y, alpha = 255, blendFn = sourceOverPerfect) {
+      const tx = x + mask.centerOffsetX;
+      const ty = y + mask.centerOffsetY;
+      const didChange = writer.accumulator.storeRegionBeforeState(tx, ty, mask.w, mask.h);
+      OPTS.x = tx;
+      OPTS.y = ty;
+      OPTS.alpha = alpha;
+      OPTS.blendFn = blendFn;
+      if (mask.type === 1 /* BINARY */) {
+        return didChange(blendColorPixelDataBinaryMask2(writer.config.target, color, mask, OPTS));
+      } else {
+        return didChange(blendColorPixelDataAlphaMask2(writer.config.target, color, mask, OPTS));
+      }
+    }
+  };
+});
 
 // src/ImageData/copyImageData.ts
 function copyImageData({
@@ -4046,35 +3749,6 @@ 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;
@@ -4489,62 +4163,6 @@ function makeBinaryMask(w, h, data) {
   };
 }
 
-// src/Mask/CircleAlphaMask.ts
-function makeCircleAlphaMask(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/CircleBinaryMask.ts
-function makeCircleBinaryMask(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 {
@@ -5245,103 +4863,137 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   }
 }
 
-// src/PixelTile/PaintBuffer.ts
-var PaintBuffer = class {
-  constructor(config, tilePool) {
-    this.config = config;
-    this.tilePool = tilePool;
-    this.lookup = [];
+// 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);
+    }
   }
-  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;
+}
+
+// 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));
         }
-        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;
-          }
-        }
+  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;
       }
-    });
+    }
   }
-  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;
-          }
-        }
+  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));
       }
-    });
-  }
-  clear() {
-    this.tilePool.releaseTiles(this.lookup);
+    }
   }
-};
+  return {
+    type: 0 /* ALPHA */,
+    data,
+    w: width,
+    h: height,
+    centerOffsetX: -macro_halfAndFloor(width),
+    centerOffsetY: -macro_halfAndFloor(height)
+  };
+}
 
-// src/PixelTile/PaintBufferRenderer.ts
-function makePaintBufferRenderer(paintBuffer, offscreenCanvasClass = OffscreenCanvas) {
+// src/Paint/PaintBufferCanvasRenderer.ts
+function makePaintBufferCanvasRenderer(paintBuffer, offscreenCanvasClass = OffscreenCanvas) {
   const config = paintBuffer.config;
   const tileSize = config.tileSize;
   const tileShift = config.tileShift;
@@ -5350,22 +5002,27 @@ function makePaintBufferRenderer(paintBuffer, offscreenCanvasClass = OffscreenCa
   const ctx = canvas.getContext("2d");
   if (!ctx) throw new Error(CANVAS_CTX_FAILED);
   ctx.imageSmoothingEnabled = false;
-  return function drawPaintBuffer(target) {
+  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);
-        target.drawImage(canvas, dx, dy);
+        targetCtx.drawImage(canvas, dx, dy);
       }
     }
+    targetCtx.globalAlpha = 1;
+    targetCtx.globalCompositeOperation = "source-over";
   };
 }
 export {
   BASE_FAST_BLEND_MODE_FUNCTIONS,
   BASE_PERFECT_BLEND_MODE_FUNCTIONS,
   BaseBlendMode,
+  CANVAS_COMPOSITE_MAP,
   CANVAS_CTX_FAILED,
   HistoryManager,
   IndexedImage,
@@ -5384,13 +5041,11 @@ export {
   applyBinaryMaskToAlphaMask,
   applyBinaryMaskToPixelData,
   applyPatchTiles,
-  applyRectBrushToPixelData,
   base64DecodeArrayBuffer,
   base64EncodeArrayBuffer,
   blendColorPixelData,
   blendColorPixelDataAlphaMask,
   blendColorPixelDataBinaryMask,
-  blendColorPixelDataCircleMask,
   blendPixel,
   blendPixelData,
   blendPixelDataAlphaMask,
@@ -5432,12 +5087,8 @@ export {
   fillPixelDataFast,
   floodFillSelection,
   forEachLinePoint,
-  getCircleBrushOrPencilBounds,
-  getCircleBrushOrPencilStrokeBounds,
   getImageDataFromClipboard,
   getIndexedImageColorCounts,
-  getRectBrushOrPencilBounds,
-  getRectBrushOrPencilStrokeBounds,
   getRectsBounds,
   getSupportedPixelFormats,
   hardLightFast,
@@ -5471,15 +5122,18 @@ export {
   makeBinaryMask,
   makeBlendModeRegistry,
   makeCanvasFrameRenderer,
-  makeCircleAlphaMask,
-  makeCircleBinaryMask,
+  makeCirclePaintAlphaMask,
+  makeCirclePaintBinaryMask,
   makeFastBlendModeRegistry,
   makeFullPixelMutator,
   makeHistoryAction,
   makeImageDataLike,
-  makePaintBufferRenderer,
+  makePaintAlphaMask,
+  makePaintBinaryMask,
+  makePaintBufferCanvasRenderer,
   makePerfectBlendModeRegistry,
   makePixelCanvas,
+  makeRectFalloffPaintAlphaMask,
   makeReusableCanvas,
   makeReusableImageData,
   makeReusableOffscreenCanvas,
@@ -5491,15 +5145,8 @@ export {
   multiplyPerfect,
   mutatorApplyAlphaMask,
   mutatorApplyBinaryMask,
-  mutatorApplyCircleBrushStroke,
-  mutatorApplyCirclePencil,
-  mutatorApplyCirclePencilStroke,
-  mutatorApplyRectBrush,
-  mutatorApplyRectBrushStroke,
-  mutatorApplyRectPencil,
-  mutatorApplyRectPencilStroke,
   mutatorBlendColor,
-  mutatorBlendColorCircleMask,
+  mutatorBlendPaintMask,
   mutatorBlendPixel,
   mutatorBlendPixelData,
   mutatorBlendPixelDataAlphaMask,
@@ -5539,6 +5186,7 @@ export {
   subtractFast,
   subtractPerfect,
   toBlendModeIndexAndName,
+  trimMaskRectBounds,
   trimRectBounds,
   uInt32ArrayToImageData,
   uInt32ArrayToImageDataLike,
@@ -5554,6 +5202,7 @@ export {
   writeImageDataBuffer,
   writeImageDataToClipboard,
   writeImgBlobToClipboard,
+  writePaintBufferToPixelData,
   writePixelDataBuffer
 };
 //# sourceMappingURL=index.prod.js.map