pixel-data-js 0.20.0 → 0.22.2

package/dist/index.prod.js

@@ -196,8 +196,8 @@ function extractImageDataBuffer(imageData, _x, _y, _w, _h) {
   return out;
 }
 
-// src/Mask/extractMask.ts
-function extractMask(mask, maskWidth, xOrRect, y, w, h) {
+// src/Mask/extractMaskBuffer.ts
+function extractMaskBuffer(maskBuffer, maskWidth, xOrRect, y, w, h) {
   let finalX;
   let finalY;
   let finalW;
@@ -214,7 +214,7 @@ function extractMask(mask, maskWidth, xOrRect, y, w, h) {
     finalH = h;
   }
   const out = new Uint8Array(finalW * finalH);
-  const srcH = mask.length / maskWidth;
+  const srcH = maskBuffer.length / maskWidth;
   for (let row = 0; row < finalH; row++) {
     const currentSrcY = finalY + row;
     if (currentSrcY < 0 || currentSrcY >= srcH) {
@@ -226,7 +226,7 @@ function extractMask(mask, maskWidth, xOrRect, y, w, h) {
       const srcOffset = currentSrcY * maskWidth + start;
       const dstOffset = row * finalW + (start - finalX);
       const count = end - start;
-      out.set(mask.subarray(srcOffset, srcOffset + count), dstOffset);
+      out.set(maskBuffer.subarray(srcOffset, srcOffset + count), dstOffset);
     }
   }
   return out;
@@ -244,8 +244,8 @@ function trimRectBounds(target, bounds) {
   if (intersectedMaxX <= intersectedX || intersectedMaxY <= intersectedY) {
     target.w = 0;
     target.h = 0;
-    if ("mask" in target && target.mask) {
-      target.mask = new Uint8Array(0);
+    if ("data" in target && target.data) {
+      target.data = new Uint8Array(0);
     }
     return;
   }
@@ -257,15 +257,15 @@ function trimRectBounds(target, bounds) {
   target.y = intersectedY;
   target.w = intersectedW;
   target.h = intersectedH;
-  if ("mask" in target && target.mask) {
-    const currentMask = extractMask(target.mask, originalW, offsetX, offsetY, intersectedW, intersectedH);
+  if ("data" in target && target.data) {
+    const currentMaskBuffer = extractMaskBuffer(target.data, originalW, offsetX, offsetY, intersectedW, intersectedH);
     let minX = intersectedW;
     let maxX = -1;
     let minY = intersectedH;
     let maxY = -1;
     for (let y = 0; y < intersectedH; y++) {
       for (let x = 0; x < intersectedW; x++) {
-        if (currentMask[y * intersectedW + x] !== 0) {
+        if (currentMaskBuffer[y * intersectedW + x] !== 0) {
           if (x < minX) minX = x;
           if (x > maxX) maxX = x;
           if (y < minY) minY = y;
@@ -276,19 +276,22 @@ function trimRectBounds(target, bounds) {
     if (maxX === -1) {
       target.w = 0;
       target.h = 0;
-      target.mask = new Uint8Array(0);
+      target.data = new Uint8Array(0);
       return;
     }
     const finalW = maxX - minX + 1;
     const finalH = maxY - minY + 1;
     if (finalW !== intersectedW || finalH !== intersectedH) {
-      target.mask = extractMask(currentMask, intersectedW, minX, minY, finalW, finalH);
+      const newMaskBuffer = extractMaskBuffer(currentMaskBuffer, intersectedW, minX, minY, finalW, finalH);
       target.x += minX;
       target.y += minY;
       target.w = finalW;
       target.h = finalH;
+      target.data = newMaskBuffer;
     } else {
-      target.mask = currentMask;
+      target.w = finalW;
+      target.h = finalH;
+      target.data = currentMaskBuffer;
     }
   }
 }
@@ -398,17 +401,19 @@ function floodFillSelection(img, startX, startY, {
   if (matchCount === 0) {
     return null;
   }
+  const w = maxX - minX + 1;
+  const h = maxY - minY + 1;
   const selectionRect = {
     x: minX,
     y: minY,
-    w: maxX - minX + 1,
-    h: maxY - minY + 1,
-    mask: new Uint8Array((maxX - minX + 1) * (maxY - minY + 1)),
-    maskType: 1 /* BINARY */
+    w,
+    h,
+    data: new Uint8Array(w * h),
+    type: 1 /* BINARY */
   };
   const sw = selectionRect.w;
   const sh = selectionRect.h;
-  const finalMask = selectionRect.mask;
+  const finalMask = selectionRect.data;
   for (let i = 0; i < matchCount; i++) {
     const mx = matchX[i] - selectionRect.x;
     const my = matchY[i] - selectionRect.y;
@@ -1483,16 +1488,7 @@ function toBlendModeIndexAndName(input) {
   const num = Number(trimmed);
   const isNumeric = trimmed !== "" && !Number.isNaN(num);
   if (isNumeric && Number.isInteger(num)) {
-    console.log({
-      trimmed,
-      num,
-      isNumeric,
-      isInt: Number.isInteger(num)
-    });
     const name = getKeyByValue(BaseBlendMode, num);
-    console.log({
-      name
-    });
     if (name === void 0) throw new Error(`Invalid index: ${num}`);
     return {
       blendIndex: num,
@@ -1866,7 +1862,6 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
     w: width = dst.width,
     h: height = dst.height,
     alpha: globalAlpha = 255,
-    mw,
     mx = 0,
     my = 0,
     invertMask = false
@@ -1888,15 +1883,14 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
   h = Math.min(h, dst.height - y);
   if (w <= 0) return;
   if (h <= 0) return;
-  const mPitch = mw ?? width;
+  const mPitch = mask.w;
   if (mPitch <= 0) return;
-  const maskHeight = mask.length / mPitch | 0;
   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(maskHeight, startY + h);
+  const sY1 = Math.min(mask.h, startY + h);
   const finalW = sX1 - sX0;
   const finalH = sY1 - sY0;
   if (finalW <= 0) return;
@@ -1907,11 +1901,12 @@ function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
   const dw = dst.width;
   const dStride = dw - finalW;
   const mStride = mPitch - finalW;
+  const maskData = mask.data;
   let dIdx = (y + yShift) * dw + (x + xShift);
   let mIdx = sY0 * mPitch + sX0;
   for (let iy = 0; iy < h; iy++) {
     for (let ix = 0; ix < w; ix++) {
-      const mVal = mask[mIdx];
+      const mVal = maskData[mIdx];
       const effectiveM = invertMask ? 255 - mVal : mVal;
       let weight = 0;
       if (effectiveM === 0) {
@@ -1971,13 +1966,12 @@ function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
     y: targetY = 0,
     w: width = dst.width,
     h: height = dst.height,
-    alpha = 255,
-    mw,
+    alpha: globalAlpha = 255,
     mx = 0,
     my = 0,
     invertMask = false
   } = opts;
-  if (alpha === 0) return;
+  if (globalAlpha === 0) return;
   let x = targetX;
   let y = targetY;
   let w = width;
@@ -1994,15 +1988,14 @@ function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
   h = Math.min(h, dst.height - y);
   if (w <= 0) return;
   if (h <= 0) return;
-  const mPitch = mw ?? width;
+  const mPitch = mask.w;
   if (mPitch <= 0) return;
-  const maskHeight = mask.length / mPitch | 0;
   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(maskHeight, startY + h);
+  const sY1 = Math.min(mask.h, startY + h);
   const finalW = sX1 - sX0;
   const finalH = sY1 - sY0;
   if (finalW <= 0) return;
@@ -2013,19 +2006,20 @@ function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
   const dw = dst.width;
   const dStride = dw - finalW;
   const mStride = mPitch - finalW;
+  const maskData = mask.data;
   let dIdx = (y + yShift) * dw + (x + xShift);
   let mIdx = sY0 * mPitch + sX0;
   for (let iy = 0; iy < h; iy++) {
     for (let ix = 0; ix < w; ix++) {
-      const mVal = mask[mIdx];
+      const mVal = maskData[mIdx];
       const isMaskedOut = invertMask ? mVal !== 0 : mVal === 0;
       if (isMaskedOut) {
         dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
-      } else if (alpha !== 255) {
+      } else if (globalAlpha !== 255) {
         const d = dst32[dIdx];
         const da = d >>> 24;
         if (da !== 0) {
-          const finalAlpha = da === 255 ? alpha : da * alpha + 128 >> 8;
+          const finalAlpha = da === 255 ? globalAlpha : da * globalAlpha + 128 >> 8;
           dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
         }
       }
@@ -2088,144 +2082,42 @@ function getCircleBrushOrPencilBounds(centerX, centerY, brushSize, targetWidth,
   return res;
 }
 
-// src/PixelData/applyCircleBrushToPixelData.ts
-function applyCircleBrushToPixelData(target, color, centerX, centerY, brushSize, alpha = 255, fallOff, blendFn = sourceOverPerfect, bounds) {
-  const targetWidth = target.width;
-  const targetHeight = target.height;
-  const b = bounds ?? getCircleBrushOrPencilBounds(centerX, centerY, brushSize, targetWidth, targetHeight);
-  if (b.w <= 0 || b.h <= 0) return;
-  const data32 = target.data32;
-  const r = brushSize / 2;
-  const rSqr = r * r;
-  const invR = 1 / r;
-  const centerOffset = brushSize % 2 === 0 ? 0.5 : 0;
-  const endX = b.x + b.w;
-  const endY = b.y + b.h;
-  const fCenterX = Math.floor(centerX);
-  const fCenterY = Math.floor(centerY);
-  const baseSrcAlpha = color >>> 24;
-  const colorRGB = color & 16777215;
-  const isOpaque = alpha === 255;
-  const isOverwrite = blendFn.isOverwrite;
-  for (let cy = b.y; cy < endY; cy++) {
-    const relY = cy - fCenterY + centerOffset;
-    const dySqr = relY * relY;
-    const rowOffset = cy * targetWidth;
-    for (let cx = b.x; cx < endX; cx++) {
-      const relX = cx - fCenterX + centerOffset;
-      const dSqr = relX * relX + dySqr;
-      if (dSqr <= rSqr) {
-        const idx = rowOffset + cx;
-        let weight = alpha;
-        const strength = fallOff(1 - Math.sqrt(dSqr) * invR);
-        const maskVal = strength * 255 | 0;
-        if (maskVal === 0) continue;
-        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 = (colorRGB | a << 24) >>> 0;
-        }
-        data32[idx] = blendFn(finalCol, data32[idx]);
-      }
-    }
-  }
-}
-
-// src/History/PixelMutator/mutatorApplyCircleBrush.ts
-var defaults3 = {
-  applyCircleBrushToPixelData,
-  getCircleBrushOrPencilBounds
-};
-var mutatorApplyCircleBrush = ((writer, deps = defaults3) => {
-  const {
-    applyCircleBrushToPixelData: applyCircleBrushToPixelData2 = defaults3.applyCircleBrushToPixelData,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults3.getCircleBrushOrPencilBounds
-  } = deps;
-  const boundsOut = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  return {
-    applyCircleBrush(color, centerX, centerY, brushSize, alpha = 255, fallOff, blendFn) {
-      const bounds = getCircleBrushOrPencilBounds2(centerX, centerY, brushSize, writer.target.width, writer.target.height, boundsOut);
-      const {
-        x,
-        y,
-        w,
-        h
-      } = bounds;
-      writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      applyCircleBrushToPixelData2(writer.target, color, centerX, centerY, brushSize, alpha, fallOff, blendFn, bounds);
-    }
-  };
-});
-
-// src/Algorithm/forEachLinePoint.ts
-function forEachLinePoint(x0, y0, x1, y1, callback) {
-  const dx = x1 - x0;
-  const dy = y1 - y0;
-  const steps = Math.max(Math.abs(dx), Math.abs(dy));
-  if (steps === 0) {
-    callback(x0, y0);
-    return;
-  }
-  const xInc = dx / steps;
-  const yInc = dy / steps;
-  let curX = x0;
-  let curY = y0;
-  for (let i = 0; i <= steps; i++) {
-    callback(curX, curY);
-    curX += xInc;
-    curY += yInc;
-  }
-}
-
 // src/PixelData/blendColorPixelDataAlphaMask.ts
-function blendColorPixelDataAlphaMask(dst, color, mask, opts) {
-  const {
-    x: targetX = 0,
-    y: targetY = 0,
-    w: width = dst.width,
-    h: height = dst.height,
-    alpha: globalAlpha = 255,
-    blendFn = sourceOverPerfect,
-    mw = width,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
-  if (globalAlpha === 0 || !mask) return;
+function blendColorPixelDataAlphaMask(dst, color, mask, opts = {}) {
+  const targetX = opts.x ?? 0;
+  const targetY = opts.y ?? 0;
+  const w = opts.w ?? mask.w;
+  const h = opts.h ?? mask.h;
+  const globalAlpha = opts.alpha ?? 255;
+  const blendFn = opts.blendFn ?? sourceOverPerfect;
+  const mx = opts.mx ?? 0;
+  const my = opts.my ?? 0;
+  const invertMask = opts.invertMask ?? false;
+  if (globalAlpha === 0) return;
   const baseSrcAlpha = color >>> 24;
   const isOverwrite = blendFn.isOverwrite || false;
   if (baseSrcAlpha === 0 && !isOverwrite) return;
   let x = targetX;
   let y = targetY;
-  let w = width;
-  let h = height;
+  let actualW = w;
+  let actualH = h;
   if (x < 0) {
-    w += x;
+    actualW += x;
     x = 0;
   }
   if (y < 0) {
-    h += y;
+    actualH += y;
     y = 0;
   }
-  const actualW = Math.min(w, dst.width - x);
-  const actualH = Math.min(h, dst.height - y);
+  actualW = Math.min(actualW, dst.width - x);
+  actualH = Math.min(actualH, dst.height - y);
   if (actualW <= 0 || actualH <= 0) return;
   const dx = x - targetX | 0;
   const dy = y - targetY | 0;
   const dst32 = dst.data32;
   const dw = dst.width;
-  const mPitch = mw;
+  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;
@@ -2234,7 +2126,7 @@ function blendColorPixelDataAlphaMask(dst, color, mask, opts) {
   const colorRGB = color & 16777215;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
-      const mVal = mask[mIdx];
+      const mVal = maskData[mIdx];
       const effM = invertMask ? 255 - mVal : mVal;
       if (effM === 0) {
         dIdx++;
@@ -2271,6 +2163,155 @@ function blendColorPixelDataAlphaMask(dst, color, 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;
+  if (globalAlpha === 0) return;
+  const baseSrcAlpha = color >>> 24;
+  const isOverwrite = blendFn.isOverwrite || false;
+  if (baseSrcAlpha === 0 && !isOverwrite) return;
+  let x = targetX;
+  let y = targetY;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) return;
+  let baseColorWithGlobalAlpha = color;
+  if (globalAlpha < 255) {
+    const a = baseSrcAlpha * globalAlpha + 128 >> 8;
+    if (a === 0 && !isOverwrite) return;
+    baseColorWithGlobalAlpha = (color & 16777215 | a << 24) >>> 0;
+  }
+  const dx = x - targetX | 0;
+  const dy = y - targetY | 0;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const mPitch = mask.w;
+  const maskData = mask.data;
+  let dIdx = y * dw + x | 0;
+  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
+  const dStride = dw - actualW | 0;
+  const mStride = mPitch - actualW | 0;
+  const skipVal = invertMask ? 1 : 0;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      if (maskData[mIdx] === skipVal) {
+        dIdx++;
+        mIdx++;
+        continue;
+      }
+      dst32[dIdx] = blendFn(baseColorWithGlobalAlpha, dst32[dIdx]);
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+}
+
+// src/PixelData/applyCircleBrushToPixelData.ts
+function applyCircleBrushToPixelData(target, color, centerX, centerY, brush, alpha = 255, blendFn = sourceOverPerfect, scratchOptions = {}, bounds) {
+  const b = bounds ?? getCircleBrushOrPencilBounds(centerX, centerY, brush.size, target.width, target.height);
+  if (b.w <= 0 || b.h <= 0) return;
+  const unclippedStartX = Math.floor(centerX + brush.minOffset);
+  const unclippedStartY = Math.floor(centerY + brush.minOffset);
+  const ix = Math.max(unclippedStartX, b.x);
+  const iy = Math.max(unclippedStartY, b.y);
+  const ir = Math.min(unclippedStartX + brush.w, b.x + b.w);
+  const ib = Math.min(unclippedStartY + brush.h, b.y + b.h);
+  const iw = ir - ix;
+  const ih = ib - iy;
+  if (iw <= 0 || ih <= 0) return;
+  scratchOptions.x = ix;
+  scratchOptions.y = iy;
+  scratchOptions.w = iw;
+  scratchOptions.h = ih;
+  scratchOptions.mx = ix - unclippedStartX;
+  scratchOptions.my = iy - unclippedStartY;
+  scratchOptions.alpha = alpha;
+  scratchOptions.blendFn = blendFn;
+  if (brush.type === 0 /* ALPHA */) {
+    blendColorPixelDataAlphaMask(target, color, brush, scratchOptions);
+  }
+  if (brush.type === 1 /* BINARY */) {
+    blendColorPixelDataBinaryMask(target, color, brush, scratchOptions);
+  }
+}
+
+// src/History/PixelMutator/mutatorApplyCircleBrush.ts
+var defaults3 = {
+  applyCircleBrushToPixelData,
+  getCircleBrushOrPencilBounds
+};
+var mutatorApplyCircleBrush = ((writer, deps = defaults3) => {
+  const {
+    applyCircleBrushToPixelData: applyCircleBrushToPixelData2 = defaults3.applyCircleBrushToPixelData,
+    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults3.getCircleBrushOrPencilBounds
+  } = deps;
+  const boundsOut = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  const blendColorPixelOptions = {
+    alpha: 255,
+    blendFn: sourceOverPerfect,
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  return {
+    applyCircleBrush(color, centerX, centerY, brush, alpha = 255, blendFn) {
+      const bounds = getCircleBrushOrPencilBounds2(centerX, centerY, brush.size, writer.target.width, writer.target.height, boundsOut);
+      const {
+        x,
+        y,
+        w,
+        h
+      } = bounds;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      applyCircleBrushToPixelData2(writer.target, color, centerX, centerY, brush, alpha, blendFn, blendColorPixelOptions, bounds);
+    }
+  };
+});
+
+// src/Algorithm/forEachLinePoint.ts
+function forEachLinePoint(x0, y0, x1, y1, callback) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const steps = Math.max(Math.abs(dx), Math.abs(dy));
+  if (steps === 0) {
+    callback(x0, y0);
+    return;
+  }
+  const xInc = dx / steps;
+  const yInc = dy / steps;
+  let curX = x0;
+  let curY = y0;
+  for (let i = 0; i <= steps; i++) {
+    callback(curX, curY);
+    curX += xInc;
+    curY += yInc;
+  }
+}
+
 // src/Rect/getCircleBrushOrPencilStrokeBounds.ts
 function getCircleBrushOrPencilStrokeBounds(x0, y0, x1, y1, brushSize, result) {
   const r = Math.ceil(brushSize / 2);
@@ -2319,8 +2360,15 @@ var mutatorApplyCircleBrushStroke = ((writer, deps = defaults4) => {
     w: 0,
     h: 0
   };
+  const mask = {
+    type: 0 /* ALPHA */,
+    data: null,
+    w: 0,
+    h: 0
+  };
   return {
-    applyCircleBrushStroke(color, x0, y0, x1, y1, brushSize, alpha = 255, fallOff, blendFn = sourceOverPerfect) {
+    applyCircleBrushStroke(color, x0, y0, x1, y1, brush, alpha = 255, blendFn = sourceOverPerfect) {
+      const brushSize = brush.size;
       const {
         x: bx,
         y: by,
@@ -2328,11 +2376,12 @@ var mutatorApplyCircleBrushStroke = ((writer, deps = defaults4) => {
         h: bh
       } = getCircleBrushOrPencilStrokeBounds2(x0, y0, x1, y1, brushSize, strokeBoundsOut);
       if (bw <= 0 || bh <= 0) return;
-      const mask = new Uint8Array(bw * bh);
-      const r = brushSize / 2;
-      const rSqr = r * r;
-      const invR = 1 / r;
-      const centerOffset = brushSize % 2 === 0 ? 0.5 : 0;
+      mask.data = new Uint8Array(bw * bh);
+      mask.w = bw;
+      mask.h = bh;
+      const maskData = mask.data;
+      const brushData = brush.data;
+      const minOffset = brush.minOffset;
       const targetWidth = writer.target.width;
       const targetHeight = writer.target.height;
       forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
@@ -2347,21 +2396,20 @@ var mutatorApplyCircleBrushStroke = ((writer, deps = defaults4) => {
         const startY = Math.max(by, cby);
         const endX = Math.min(bx + bw, cbx + cbw);
         const endY = Math.min(by + bh, cby + cbh);
-        const fPx = Math.floor(px);
-        const fPy = Math.floor(py);
+        const unclippedStartX = Math.floor(px + minOffset);
+        const unclippedStartY = Math.floor(py + minOffset);
         for (let my = startY; my < endY; my++) {
-          const dy = my - fPy + centerOffset;
-          const dySqr = dy * dy;
-          const maskRowOffset = (my - by) * bw;
+          const strokeMaskY = my - by;
+          const strokeMaskRowOffset = strokeMaskY * bw;
+          const brushY = my - unclippedStartY;
+          const brushRowOffset = brushY * brushSize;
           for (let mx = startX; mx < endX; mx++) {
-            const dx = mx - fPx + centerOffset;
-            const dSqr = dx * dx + dySqr;
-            if (dSqr <= rSqr) {
-              const maskIdx = maskRowOffset + (mx - bx);
-              const dist = Math.sqrt(dSqr) * invR;
-              const intensity = fallOff(1 - dist) * 255 | 0;
-              if (intensity > mask[maskIdx]) {
-                mask[maskIdx] = intensity;
+            const brushX = mx - unclippedStartX;
+            const brushVal = brushData[brushRowOffset + brushX];
+            if (brushVal > 0) {
+              const strokeMaskIdx = strokeMaskRowOffset + (mx - bx);
+              if (brushVal > maskData[strokeMaskIdx]) {
+                maskData[strokeMaskIdx] = brushVal;
               }
             }
           }
@@ -2378,71 +2426,6 @@ var mutatorApplyCircleBrushStroke = ((writer, deps = defaults4) => {
   };
 });
 
-// src/PixelData/blendColorPixelDataBinaryMask.ts
-function blendColorPixelDataBinaryMask(dst, color, mask, opts = {}) {
-  const {
-    x: targetX = 0,
-    y: targetY = 0,
-    w: width = dst.width,
-    h: height = dst.height,
-    alpha: globalAlpha = 255,
-    blendFn = sourceOverPerfect,
-    mw = width,
-    mx = 0,
-    my = 0,
-    invertMask = false
-  } = opts;
-  if (globalAlpha === 0 || !mask) return;
-  const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite || false;
-  if (baseSrcAlpha === 0 && !isOverwrite) return;
-  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;
-  let baseColorWithGlobalAlpha = color;
-  if (globalAlpha < 255) {
-    const a = baseSrcAlpha * globalAlpha + 128 >> 8;
-    if (a === 0 && !isOverwrite) return;
-    baseColorWithGlobalAlpha = (color & 16777215 | a << 24) >>> 0;
-  }
-  const dx = x - targetX | 0;
-  const dy = y - targetY | 0;
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  const mPitch = mw;
-  let dIdx = y * dw + x | 0;
-  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
-  const dStride = dw - actualW | 0;
-  const mStride = mPitch - actualW | 0;
-  const skipVal = invertMask ? 1 : 0;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      if (mask[mIdx] === skipVal) {
-        dIdx++;
-        mIdx++;
-        continue;
-      }
-      dst32[dIdx] = blendFn(baseColorWithGlobalAlpha, dst32[dIdx]);
-      dIdx++;
-      mIdx++;
-    }
-    dIdx += dStride;
-    mIdx += mStride;
-  }
-}
-
 // src/History/PixelMutator/mutatorApplyCirclePencilStroke.ts
 var defaults5 = {
   forEachLinePoint,
@@ -2477,19 +2460,25 @@ var mutatorApplyCirclePencilStroke = ((writer, deps = defaults5) => {
     w: 0,
     h: 0
   };
+  const mask = {
+    type: 1 /* BINARY */,
+    data: null,
+    w: 0,
+    h: 0
+  };
   return {
-    applyCirclePencilStroke(color, x0, y0, x1, y1, brushSize, alpha = 255, blendFn = sourceOverPerfect) {
+    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, brushSize, strokeBoundsOut);
+      } = getCircleBrushOrPencilStrokeBounds2(x0, y0, x1, y1, brush.size, strokeBoundsOut);
       if (bw <= 0 || bh <= 0) return;
-      const mask = new Uint8Array(bw * bh);
-      const r = brushSize / 2;
-      const rSqr = r * r;
-      const centerOffset = brushSize % 2 === 0 ? 0.5 : 0;
+      mask.data = new Uint8Array(bw * bh);
+      mask.w = bw;
+      mask.h = bh;
+      const maskData = mask.data;
       const targetWidth = writer.target.width;
       const targetHeight = writer.target.height;
       forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
@@ -2498,24 +2487,24 @@ var mutatorApplyCirclePencilStroke = ((writer, deps = defaults5) => {
           y: cby,
           w: cbw,
           h: cbh
-        } = getCircleBrushOrPencilBounds2(px, py, brushSize, targetWidth, targetHeight, circlePencilBounds);
+        } = getCircleBrushOrPencilBounds2(px, py, brush.size, targetWidth, targetHeight, circlePencilBounds);
         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 fPx = Math.floor(px);
-        const fPy = Math.floor(py);
+        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 dy = my - fPy + centerOffset;
-          const dySqr = dy * dy;
+          const brushY = my - unclippedStartY;
           const maskRowOffset = (my - by) * bw;
+          const brushRowOffset = brushY * brush.w;
           for (let mx = startX; mx < endX; mx++) {
-            const dx = mx - fPx + centerOffset;
-            const dSqr = dx * dx + dySqr;
-            if (dSqr <= rSqr) {
+            const brushX = mx - unclippedStartX;
+            const brushAlpha = brush.data[brushRowOffset + brushX];
+            if (brushAlpha > 0) {
               const maskIdx = maskRowOffset + (mx - bx);
-              mask[maskIdx] = 1;
+              maskData[maskIdx] = brushAlpha;
             }
           }
         }
@@ -2682,6 +2671,12 @@ var mutatorApplyRectBrushStroke = ((writer, deps = defaults7) => {
     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 {
@@ -2691,7 +2686,10 @@ var mutatorApplyRectBrushStroke = ((writer, deps = defaults7) => {
         h: bh
       } = getRectBrushOrPencilStrokeBounds2(x0, y0, x1, y1, brushWidth, brushHeight, strokeBoundsOut);
       if (bw <= 0 || bh <= 0) return;
-      const mask = new Uint8Array(bw * bh);
+      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;
@@ -2724,8 +2722,8 @@ var mutatorApplyRectBrushStroke = ((writer, deps = defaults7) => {
             const strength = fallOff(dist);
             if (strength > 0) {
               const intensity = strength * 255 | 0;
-              if (intensity > mask[maskIdx]) {
-                mask[maskIdx] = intensity;
+              if (intensity > maskData[maskIdx]) {
+                maskData[maskIdx] = intensity;
               }
             }
           }
@@ -2809,6 +2807,12 @@ var mutatorApplyRectPencilStroke = ((writer, deps = defaults9) => {
     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 {
@@ -2818,7 +2822,10 @@ var mutatorApplyRectPencilStroke = ((writer, deps = defaults9) => {
         h: bh
       } = getRectBrushOrPencilStrokeBounds2(x0, y0, x1, y1, brushWidth, brushHeight, strokeBoundsOut);
       if (bw <= 0 || bh <= 0) return;
-      const mask = new Uint8Array(bw * bh);
+      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;
@@ -2845,7 +2852,7 @@ var mutatorApplyRectPencilStroke = ((writer, deps = defaults9) => {
             const dx = Math.abs(mx - fPx + centerOffset);
             const maskIdx = maskRowOffset + (mx - bx);
             if (dx <= halfW && dy <= halfH) {
-              mask[maskIdx] = 1;
+              maskData[maskIdx] = 1;
             }
           }
         }
@@ -3056,24 +3063,21 @@ var mutatorBlendPixelData = ((writer, deps = defaults11) => {
 
 // src/PixelData/fillPixelData.ts
 var SCRATCH_RECT = makeClippedRect();
-function fillPixelData(dst, color, _x, _y, _w, _h, _mask) {
+function fillPixelData(dst, color, _x, _y, _w, _h) {
   let x;
   let y;
   let w;
   let h;
-  let mask;
   if (typeof _x === "object") {
     x = _x.x ?? 0;
     y = _x.y ?? 0;
     w = _x.w ?? dst.width;
     h = _x.h ?? dst.height;
-    mask = _x.mask;
   } else if (typeof _x === "number") {
     x = _x;
     y = _y;
     w = _w;
     h = _h;
-    mask = _mask;
   } else {
     x = 0;
     y = 0;
@@ -3094,28 +3098,10 @@ function fillPixelData(dst, color, _x, _y, _w, _h, _mask) {
     dst32.fill(color);
     return;
   }
-  if (mask) {
-    for (let iy = 0; iy < actualH; iy++) {
-      const currentY = finalY + iy;
-      const maskY = currentY - y;
-      const maskOffset = maskY * w;
-      for (let ix = 0; ix < actualW; ix++) {
-        const currentX = finalX + ix;
-        const maskX = currentX - x;
-        const maskIndex = maskOffset + maskX;
-        const isMasked = mask[maskIndex];
-        if (isMasked) {
-          const dstIndex = currentY * dw + currentX;
-          dst32[dstIndex] = color;
-        }
-      }
-    }
-  } else {
-    for (let iy = 0; iy < actualH; iy++) {
-      const start = (finalY + iy) * dw + finalX;
-      const end = start + actualW;
-      dst32.fill(color, start, end);
-    }
+  for (let iy = 0; iy < actualH; iy++) {
+    const start = (finalY + iy) * dw + finalX;
+    const end = start + actualW;
+    dst32.fill(color, start, end);
   }
 }
 
@@ -3129,12 +3115,10 @@ var mutatorClear = ((writer, deps = defaults12) => {
   } = deps;
   return {
     clear(rect = {}) {
-      const {
-        x = 0,
-        y = 0,
-        w = writer.target.width,
-        h = writer.target.height
-      } = rect;
+      const x = rect.x ?? 0;
+      const y = rect.y ?? 0;
+      const w = rect.w ?? writer.target.width;
+      const h = rect.h ?? writer.target.height;
       writer.accumulator.storeRegionBeforeState(x, y, w, h);
       fillPixelData2(writer.target, 0, x, y, w, h);
     }
@@ -3173,7 +3157,6 @@ function invertPixelData(pixelData, opts = {}) {
     w: width = pixelData.width,
     h: height = pixelData.height,
     mask,
-    mw,
     mx = 0,
     my = 0,
     invertMask = false
@@ -3188,7 +3171,7 @@ function invertPixelData(pixelData, opts = {}) {
   } = clip;
   const dst32 = dst.data32;
   const dw = dst.width;
-  const mPitch = mw ?? width;
+  const mPitch = mask?.w ?? width;
   const dx = x - targetX;
   const dy = y - targetY;
   let dIdx = y * dw + x;
@@ -3196,9 +3179,10 @@ function invertPixelData(pixelData, opts = {}) {
   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 = mask[mIdx];
+        const mVal = maskData[mIdx];
         const isHit = invertMask ? mVal === 0 : mVal === 1;
         if (isHit) {
           dst32[dIdx] = dst32[dIdx] ^ 16777215;
@@ -3309,14 +3293,12 @@ var PixelWriter = class {
 // src/History/PixelMutator/mutatorApplyCirclePencil.ts
 var defaults15 = {
   applyCircleBrushToPixelData,
-  getCircleBrushOrPencilBounds,
-  fallOff: () => 1
+  getCircleBrushOrPencilBounds
 };
 var mutatorApplyCirclePencil = ((writer, deps = defaults15) => {
   const {
     applyCircleBrushToPixelData: applyCircleBrushToPixelData2 = defaults15.applyCircleBrushToPixelData,
-    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults15.getCircleBrushOrPencilBounds,
-    fallOff = defaults15.fallOff
+    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults15.getCircleBrushOrPencilBounds
   } = deps;
   const boundsOut = {
     x: 0,
@@ -3325,8 +3307,8 @@ var mutatorApplyCirclePencil = ((writer, deps = defaults15) => {
     h: 0
   };
   return {
-    applyCirclePencil(color, centerX, centerY, brushSize, alpha = 255, blendFn) {
-      const bounds = getCircleBrushOrPencilBounds2(centerX, centerY, brushSize, writer.target.width, writer.target.height, boundsOut);
+    applyCirclePencil(color, centerX, centerY, brush, alpha = 255, blendFn) {
+      const bounds = getCircleBrushOrPencilBounds2(centerX, centerY, brush.size, writer.target.width, writer.target.height, boundsOut);
       const {
         x,
         y,
@@ -3334,7 +3316,63 @@ var mutatorApplyCirclePencil = ((writer, deps = defaults15) => {
         h
       } = bounds;
       writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      applyCircleBrushToPixelData2(writer.target, color, centerX, centerY, brushSize, alpha, fallOff, blendFn, bounds);
+      applyCircleBrushToPixelData2(writer.target, color, centerX, centerY, brush, alpha, blendFn, bounds);
+    }
+  };
+});
+
+// src/PixelData/fillPixelDataBinaryMask.ts
+var SCRATCH_RECT3 = makeClippedRect();
+function fillPixelDataBinaryMask(dst, color, mask, alpha = 255, x = 0, y = 0) {
+  if (alpha === 0) return;
+  const maskW = mask.w;
+  const maskH = mask.h;
+  const clip = resolveRectClipping(x, y, maskW, maskH, dst.width, dst.height, SCRATCH_RECT3);
+  if (!clip.inBounds) return;
+  const {
+    x: finalX,
+    y: finalY,
+    w: actualW,
+    h: actualH
+  } = clip;
+  const maskData = mask.data;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  let finalCol = color;
+  if (alpha < 255) {
+    const baseSrcAlpha = color >>> 24;
+    const colorRGB = color & 16777215;
+    const a = baseSrcAlpha * alpha + 128 >> 8;
+    finalCol = (colorRGB | a << 24) >>> 0;
+  }
+  for (let iy = 0; iy < actualH; iy++) {
+    const currentY = finalY + iy;
+    const maskY = currentY - y;
+    const maskOffset = maskY * maskW;
+    const dstRowOffset = currentY * dw;
+    for (let ix = 0; ix < actualW; ix++) {
+      const currentX = finalX + ix;
+      const maskX = currentX - x;
+      const maskIndex = maskOffset + maskX;
+      if (maskData[maskIndex]) {
+        dst32[dstRowOffset + currentX] = finalCol;
+      }
+    }
+  }
+}
+
+// src/History/PixelMutator/mutatorFillBinaryMask.ts
+var defaults16 = {
+  fillPixelDataBinaryMask
+};
+var mutatorFillBinaryMask = ((writer, deps = defaults16) => {
+  const {
+    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults16.fillPixelDataBinaryMask
+  } = deps;
+  return {
+    fillBinaryMask(color, mask, alpha = 255, x = 0, y = 0) {
+      writer.accumulator.storeRegionBeforeState(x, y, mask.w, mask.h);
+      fillPixelDataBinaryMask2(writer.target, color, mask, alpha, x, y);
     }
   };
 });
@@ -3370,8 +3408,8 @@ function makeImageDataLike(width, height, data) {
   };
 }
 
-// src/ImageData/imageDataToAlphaMask.ts
-function imageDataToAlphaMask(imageData) {
+// src/ImageData/imageDataToAlphaMaskBuffer.ts
+function imageDataToAlphaMaskBuffer(imageData) {
   const {
     width,
     height,
@@ -3461,13 +3499,13 @@ function resampleImageData(source, factor) {
 }
 
 // src/ImageData/resizeImageData.ts
-function resizeImageData(current, newWidth, newHeight, offsetX = 0, offsetY = 0) {
+function resizeImageData(target, newWidth, newHeight, offsetX = 0, offsetY = 0) {
   const result = new ImageData(newWidth, newHeight);
   const {
     width: oldW,
     height: oldH,
     data: oldData
-  } = current;
+  } = target;
   const newData = result.data;
   const x0 = Math.max(0, offsetX);
   const y0 = Math.max(0, offsetY);
@@ -3622,7 +3660,7 @@ function writeImageData(target, source, x, y, sx = 0, sy = 0, sw = source.width,
 
 // src/ImageData/writeImageDataBuffer.ts
 var SCRATCH_BLIT3 = makeClippedBlit();
-function writeImageDataBuffer(imageData, data, _x, _y, _w, _h) {
+function writeImageDataBuffer(target, data, _x, _y, _w, _h) {
   const {
     x,
     y,
@@ -3638,7 +3676,7 @@ function writeImageDataBuffer(imageData, data, _x, _y, _w, _h) {
     width: dstW,
     height: dstH,
     data: dst
-  } = imageData;
+  } = target;
   const clip = resolveBlitClipping(x, y, 0, 0, w, h, dstW, dstH, w, h, SCRATCH_BLIT3);
   if (!clip.inBounds) return;
   const {
@@ -3884,8 +3922,84 @@ async function getSupportedPixelFormats(rasterMimes = defaultRasterMimes) {
   return formatsPromise;
 }
 
+// src/Mask/AlphaMask.ts
+function makeAlphaMask(w, h, data) {
+  return {
+    type: 0 /* ALPHA */,
+    data: data ?? new Uint8Array(w * h),
+    w,
+    h
+  };
+}
+
+// src/Mask/BinaryMask.ts
+function makeBinaryMask(w, h, data) {
+  return {
+    type: 1 /* BINARY */,
+    data: data ?? new Uint8Array(w * h),
+    w,
+    h
+  };
+}
+
+// src/Mask/CircleBrushAlphaMask.ts
+function makeCircleBrushAlphaMask(size, fallOff = () => 1) {
+  const area = size * size;
+  const data = new Uint8Array(area);
+  const radius = size / 2;
+  const invR = 1 / radius;
+  const minOffset = -Math.ceil(radius - 0.5);
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const dx = x - radius + 0.5;
+      const dy = y - radius + 0.5;
+      const distSqr = dx * dx + dy * dy;
+      if (distSqr <= radius * radius) {
+        const dist = Math.sqrt(distSqr);
+        data[y * size + x] = fallOff(1 - dist * invR) * 255 | 0;
+      }
+    }
+  }
+  return {
+    type: 0 /* ALPHA */,
+    data,
+    w: size,
+    h: size,
+    radius,
+    size,
+    minOffset
+  };
+}
+
+// src/Mask/CircleBrushBinaryMask.ts
+function makeCircleBrushBinaryMask(size) {
+  const area = size * size;
+  const data = new Uint8Array(area);
+  const radius = size / 2;
+  const minOffset = -Math.ceil(radius - 0.5);
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const dx = x - radius + 0.5;
+      const dy = y - radius + 0.5;
+      const distSqr = dx * dx + dy * dy;
+      if (distSqr <= radius * radius) {
+        data[y * size + x] = 1;
+      }
+    }
+  }
+  return {
+    type: 1 /* BINARY */,
+    data,
+    w: size,
+    h: size,
+    radius,
+    size,
+    minOffset
+  };
+}
+
 // src/Mask/applyBinaryMaskToAlphaMask.ts
-function applyBinaryMaskToAlphaMask(alphaMaskDst, dstWidth, binaryMaskSrc, srcWidth, opts = {}) {
+function applyBinaryMaskToAlphaMask(alphaMaskDst, binaryMaskSrc, opts = {}) {
   const {
     x: targetX = 0,
     y: targetY = 0,
@@ -3895,11 +4009,13 @@ function applyBinaryMaskToAlphaMask(alphaMaskDst, dstWidth, binaryMaskSrc, srcWi
     my = 0,
     invertMask = false
   } = opts;
+  const dstWidth = alphaMaskDst.w;
   if (dstWidth <= 0) return;
-  if (binaryMaskSrc.length === 0) return;
+  if (binaryMaskSrc.data.length === 0) return;
+  const srcWidth = binaryMaskSrc.w;
   if (srcWidth <= 0) return;
-  const dstHeight = alphaMaskDst.length / dstWidth | 0;
-  const srcHeight = binaryMaskSrc.length / srcWidth | 0;
+  const dstHeight = alphaMaskDst.data.length / dstWidth | 0;
+  const srcHeight = binaryMaskSrc.data.length / srcWidth | 0;
   if (dstHeight <= 0) return;
   if (srcHeight <= 0) return;
   const dstX0 = Math.max(0, targetX);
@@ -3916,6 +4032,8 @@ function applyBinaryMaskToAlphaMask(alphaMaskDst, dstWidth, binaryMaskSrc, srcWi
   if (srcY0 + (dstY1 - dstY0) <= 0) return;
   const iterW = Math.min(dstX1 - dstX0, srcWidth - srcX0);
   const iterH = Math.min(dstY1 - dstY0, srcHeight - srcY0);
+  const srcData = binaryMaskSrc.data;
+  const dstData = alphaMaskDst.data;
   let dstIdx = dstY0 * dstWidth + dstX0;
   let srcIdx = srcY0 * srcWidth + srcX0;
   if (invertMask) {
@@ -3924,8 +4042,8 @@ function applyBinaryMaskToAlphaMask(alphaMaskDst, dstWidth, binaryMaskSrc, srcWi
       let d = dstIdx;
       let s = srcIdx;
       while (d < dstEnd) {
-        if (binaryMaskSrc[s] !== 0) {
-          alphaMaskDst[d] = 0;
+        if (srcData[s] !== 0) {
+          dstData[d] = 0;
         }
         d++;
         s++;
@@ -3939,8 +4057,8 @@ function applyBinaryMaskToAlphaMask(alphaMaskDst, dstWidth, binaryMaskSrc, srcWi
       let d = dstIdx;
       let s = srcIdx;
       while (d < dstEnd) {
-        if (binaryMaskSrc[s] === 0) {
-          alphaMaskDst[d] = 0;
+        if (srcData[s] === 0) {
+          dstData[d] = 0;
         }
         d++;
         s++;
@@ -3953,25 +4071,72 @@ function applyBinaryMaskToAlphaMask(alphaMaskDst, dstWidth, binaryMaskSrc, srcWi
 
 // src/Mask/copyMask.ts
 function copyMask(src) {
-  return src.slice();
+  return {
+    type: src.type,
+    data: src.data.slice(),
+    w: src.w,
+    h: src.h
+  };
+}
+
+// src/Mask/extractMask.ts
+function extractMask(mask, xOrRect, y, w, h) {
+  let finalX;
+  let finalY;
+  let finalW;
+  let finalH;
+  if (typeof xOrRect === "object") {
+    finalX = xOrRect.x;
+    finalY = xOrRect.y;
+    finalW = xOrRect.w;
+    finalH = xOrRect.h;
+  } else {
+    finalX = xOrRect;
+    finalY = y;
+    finalW = w;
+    finalH = h;
+  }
+  const out = {
+    type: mask.type,
+    w: finalW,
+    h: finalH,
+    data: new Uint8Array(finalW * finalH)
+  };
+  const srcH = mask.h;
+  const stride = mask.w;
+  for (let row = 0; row < finalH; row++) {
+    const currentSrcY = finalY + row;
+    if (currentSrcY < 0 || currentSrcY >= srcH) continue;
+    const start = Math.max(0, finalX);
+    const end = Math.min(stride, finalX + finalW);
+    if (start < end) {
+      const srcOffset = currentSrcY * stride + start;
+      const dstOffset = row * finalW + (start - finalX);
+      const count = end - start;
+      out.data.set(mask.data.subarray(srcOffset, srcOffset + count), dstOffset);
+    }
+  }
+  return out;
 }
 
 // src/Mask/invertMask.ts
 function invertBinaryMask(dst) {
-  const len = dst.length;
+  const data = dst.data;
+  const len = data.length;
   for (let i = 0; i < len; i++) {
-    dst[i] = dst[i] === 0 ? 1 : 0;
+    data[i] = data[i] === 0 ? 1 : 0;
   }
 }
 function invertAlphaMask(dst) {
-  const len = dst.length;
+  const data = dst.data;
+  const len = data.length;
   for (let i = 0; i < len; i++) {
-    dst[i] = 255 - dst[i];
+    data[i] = 255 - data[i];
   }
 }
 
 // src/Mask/mergeAlphaMasks.ts
-function mergeAlphaMasks(dst, dstWidth, src, srcWidth, opts) {
+function mergeAlphaMasks(dst, src, opts) {
   const {
     x: targetX = 0,
     y: targetY = 0,
@@ -3982,15 +4147,17 @@ function mergeAlphaMasks(dst, dstWidth, src, srcWidth, opts) {
     my = 0,
     invertMask = false
   } = opts;
-  const dstHeight = dst.length / dstWidth | 0;
-  const srcHeight = src.length / srcWidth | 0;
   if (width <= 0) return;
   if (height <= 0) return;
   if (globalAlpha === 0) return;
+  const dstData = dst.data;
+  const srcData = src.data;
+  const srcWidth = src.w;
+  const dstWidth = dst.w;
   const startX = Math.max(0, -targetX, -mx);
   const startY = Math.max(0, -targetY, -my);
   const endX = Math.min(width, dstWidth - targetX, srcWidth - mx);
-  const endY = Math.min(height, dstHeight - targetY, srcHeight - my);
+  const endY = Math.min(height, dst.h - targetY, src.h - my);
   if (startX >= endX) return;
   if (startY >= endY) return;
   for (let iy = startY; iy < endY; iy++) {
@@ -3999,7 +4166,7 @@ function mergeAlphaMasks(dst, dstWidth, src, srcWidth, opts) {
     let dIdx = dy * dstWidth + targetX + startX;
     let sIdx = sy * srcWidth + mx + startX;
     for (let ix = startX; ix < endX; ix++) {
-      const rawM = src[sIdx];
+      const rawM = srcData[sIdx];
       const effectiveM = invertMask ? 255 - rawM : rawM;
       let weight = 0;
       if (effectiveM === 0) {
@@ -4013,13 +4180,13 @@ function mergeAlphaMasks(dst, dstWidth, src, srcWidth, opts) {
       }
       if (weight !== 255) {
         if (weight === 0) {
-          dst[dIdx] = 0;
+          dstData[dIdx] = 0;
         } else {
-          const da = dst[dIdx];
+          const da = dstData[dIdx];
           if (da === 255) {
-            dst[dIdx] = weight;
+            dstData[dIdx] = weight;
           } else if (da !== 0) {
-            dst[dIdx] = da * weight + 128 >> 8;
+            dstData[dIdx] = da * weight + 128 >> 8;
           }
         }
       }
@@ -4030,7 +4197,7 @@ function mergeAlphaMasks(dst, dstWidth, src, srcWidth, opts) {
 }
 
 // src/Mask/mergeBinaryMasks.ts
-function mergeBinaryMasks(dst, dstWidth, src, srcWidth, opts) {
+function mergeBinaryMasks(dst, src, opts) {
   const {
     x: targetX = 0,
     y: targetY = 0,
@@ -4040,10 +4207,12 @@ function mergeBinaryMasks(dst, dstWidth, src, srcWidth, opts) {
     my = 0,
     invertMask = false
   } = opts;
+  const dstData = dst.data;
+  const srcData = src.data;
+  const srcWidth = src.w;
+  const dstWidth = dst.w;
   if (dstWidth <= 0) return;
   if (srcWidth <= 0) return;
-  const dstHeight = dst.length / dstWidth | 0;
-  const srcHeight = src.length / srcWidth | 0;
   let x = targetX;
   let y = targetY;
   let w = width;
@@ -4057,7 +4226,7 @@ function mergeBinaryMasks(dst, dstWidth, src, srcWidth, opts) {
     y = 0;
   }
   w = Math.min(w, dstWidth - x);
-  h = Math.min(h, dstHeight - y);
+  h = Math.min(h, dst.h - y);
   if (w <= 0) return;
   if (h <= 0) return;
   const startX = mx + (x - targetX);
@@ -4065,7 +4234,7 @@ function mergeBinaryMasks(dst, dstWidth, src, srcWidth, opts) {
   const sX0 = Math.max(0, startX);
   const sY0 = Math.max(0, startY);
   const sX1 = Math.min(srcWidth, startX + w);
-  const sY1 = Math.min(srcHeight, startY + h);
+  const sY1 = Math.min(src.h, startY + h);
   const finalW = sX1 - sX0;
   const finalH = sY1 - sY0;
   if (finalW <= 0) return;
@@ -4078,10 +4247,10 @@ function mergeBinaryMasks(dst, dstWidth, src, srcWidth, opts) {
   let sIdx = sY0 * srcWidth + sX0;
   for (let iy = 0; iy < finalH; iy++) {
     for (let ix = 0; ix < finalW; ix++) {
-      const mVal = src[sIdx];
+      const mVal = srcData[sIdx];
       const isMaskedOut = invertMask ? mVal !== 0 : mVal === 0;
       if (isMaskedOut) {
-        dst[dIdx] = 0;
+        dstData[dIdx] = 0;
       }
       dIdx++;
       sIdx++;
@@ -4091,6 +4260,177 @@ function mergeBinaryMasks(dst, dstWidth, src, srcWidth, opts) {
   }
 }
 
+// src/Mask/setMaskData.ts
+function setMaskData(mask, width, height, data) {
+  ;
+  mask.w = width;
+  mask.h = height;
+  mask.data = data;
+}
+
+// src/MaskRect/subtractBinaryMaskRects.ts
+function subtractBinaryMaskRects(current, subtracting) {
+  let result = [...current];
+  for (const sub of subtracting) {
+    const next = [];
+    for (const r of result) {
+      const ix = Math.max(r.x, sub.x);
+      const iy = Math.max(r.y, sub.y);
+      const ix2 = Math.min(r.x + r.w, sub.x + sub.w);
+      const iy2 = Math.min(r.y + r.h, sub.y + sub.h);
+      if (ix >= ix2 || iy >= iy2) {
+        next.push(r);
+        continue;
+      }
+      if (r.y < iy) pushPiece(next, r, r.x, r.y, r.w, iy - r.y);
+      if (iy2 < r.y + r.h) pushPiece(next, r, r.x, iy2, r.w, r.y + r.h - iy2);
+      if (r.x < ix) pushPiece(next, r, r.x, iy, ix - r.x, iy2 - iy);
+      if (ix2 < r.x + r.w) pushPiece(next, r, ix2, iy, r.x + r.w - ix2, iy2 - iy);
+    }
+    result = next;
+  }
+  return result;
+}
+function pushPiece(dest, r, x, y, w, h) {
+  if (r.data === null || r.data === void 0) {
+    dest.push({
+      x,
+      y,
+      w,
+      h,
+      data: null,
+      type: null
+    });
+    return;
+  }
+  const lx = x - r.x;
+  const ly = y - r.y;
+  const data = new Uint8Array(w * h);
+  for (let row = 0; row < h; row++) {
+    data.set(r.data.subarray((ly + row) * r.w + lx, (ly + row) * r.w + lx + w), row * w);
+  }
+  dest.push({
+    x,
+    y,
+    w,
+    h,
+    data,
+    type: 1 /* BINARY */
+  });
+}
+
+// src/Rect/getRectsBounds.ts
+function getRectsBounds(rects) {
+  if (rects.length === 1) return {
+    ...rects[0]
+  };
+  let minX = Infinity, minY = Infinity;
+  let maxX = -Infinity, maxY = -Infinity;
+  for (let i = 0; i < rects.length; i++) {
+    const r = rects[i];
+    const x1 = r.x;
+    const y1 = r.y;
+    const x2 = x1 + r.w;
+    const y2 = y1 + r.h;
+    if (x1 < minX) minX = x1;
+    if (y1 < minY) minY = y1;
+    if (x2 > maxX) maxX = x2;
+    if (y2 > maxY) maxY = y2;
+  }
+  return {
+    x: minX,
+    y: minY,
+    w: maxX - minX,
+    h: maxY - minY
+  };
+}
+
+// src/MaskRect/merge2BinaryMaskRects.ts
+function merge2BinaryMaskRects(a, b) {
+  const bounds = getRectsBounds([a, b]);
+  if ((a.data === null || a.data === void 0) && (b.data === null || b.data === void 0)) {
+    const ix = Math.max(a.x, b.x);
+    const iy = Math.max(a.y, b.y);
+    const ir = Math.min(a.x + a.w, b.x + b.w);
+    const ib = Math.min(a.y + a.h, b.y + b.h);
+    const iw = Math.max(0, ir - ix);
+    const ih = Math.max(0, ib - iy);
+    const intersectionArea = iw * ih;
+    const areaA = a.w * a.h;
+    const areaB = b.w * b.h;
+    const boundsArea = bounds.w * bounds.h;
+    if (boundsArea === areaA + areaB - intersectionArea) {
+      return {
+        ...bounds,
+        data: null,
+        type: null
+      };
+    }
+  }
+  const maskData = new Uint8Array(bounds.w * bounds.h);
+  const aOffY = a.y - bounds.y;
+  const aOffX = a.x - bounds.x;
+  if (a.data === void 0 || a.data === null) {
+    for (let ay = 0; ay < a.h; ay++) {
+      const destRow = (aOffY + ay) * bounds.w + aOffX;
+      maskData.fill(1, destRow, destRow + a.w);
+    }
+  } else {
+    for (let ay = 0; ay < a.h; ay++) {
+      const srcRow = ay * a.w;
+      const destRow = (aOffY + ay) * bounds.w + aOffX;
+      maskData.set(a.data.subarray(srcRow, srcRow + a.w), destRow);
+    }
+  }
+  const bOffY = b.y - bounds.y;
+  const bOffX = b.x - bounds.x;
+  if (b.data === void 0 || b.data === null) {
+    for (let by = 0; by < b.h; by++) {
+      const destRow = (bOffY + by) * bounds.w + bOffX;
+      maskData.fill(1, destRow, destRow + b.w);
+    }
+  } else {
+    for (let by = 0; by < b.h; by++) {
+      const srcRow = by * b.w;
+      const destRow = (bOffY + by) * bounds.w + bOffX;
+      for (let bx = 0; bx < b.w; bx++) {
+        maskData[destRow + bx] |= b.data[srcRow + bx];
+      }
+    }
+  }
+  return {
+    ...bounds,
+    data: maskData,
+    type: 1 /* BINARY */
+  };
+}
+
+// src/MaskRect/mergeBinaryMaskRects.ts
+function mergeBinaryMaskRects(current, adding) {
+  const rects = [...current, ...adding];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const next = [];
+    for (const r of rects) {
+      let merged = false;
+      for (let i = 0; i < next.length; i++) {
+        const n = next[i];
+        const overlap = r.x <= n.x + n.w && r.x + r.w >= n.x && r.y <= n.y + n.h && r.y + r.h >= n.y;
+        if (overlap) {
+          next[i] = merge2BinaryMaskRects(n, r);
+          merged = true;
+          changed = true;
+          break;
+        }
+      }
+      if (!merged) next.push(r);
+    }
+    rects.splice(0, rects.length, ...next);
+  }
+  return rects;
+}
+
 // src/PixelData/PixelData.ts
 var PixelData = class _PixelData {
   data32;
@@ -4142,7 +4482,6 @@ function blendPixelDataAlphaMask(dst, src, alphaMask, opts = {}) {
     h: height = src.height,
     alpha: globalAlpha = 255,
     blendFn = sourceOverPerfect,
-    mw = src.width,
     mx = 0,
     my = 0,
     invertMask = false
@@ -4181,7 +4520,8 @@ function blendPixelDataAlphaMask(dst, src, alphaMask, opts = {}) {
   if (actualW <= 0 || actualH <= 0) return;
   const dw = dst.width;
   const sw = src.width;
-  const mPitch = mw;
+  const mPitch = alphaMask.w;
+  const maskData = alphaMask.data;
   const dx = x - targetX | 0;
   const dy = y - targetY | 0;
   const dst32 = dst.data32;
@@ -4196,7 +4536,7 @@ function blendPixelDataAlphaMask(dst, src, alphaMask, opts = {}) {
   const isOverwrite = blendFn.isOverwrite || false;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
-      const mVal = alphaMask[mIdx];
+      const mVal = maskData[mIdx];
       const effM = invertMask ? 255 - mVal : mVal;
       if (effM === 0) {
         dIdx++;
@@ -4257,7 +4597,6 @@ function blendPixelDataBinaryMask(dst, src, binaryMask, opts) {
     h: height = src.height,
     alpha: globalAlpha = 255,
     blendFn = sourceOverPerfect,
-    mw = src.width,
     mx = 0,
     my = 0,
     invertMask = false
@@ -4300,7 +4639,8 @@ function blendPixelDataBinaryMask(dst, src, binaryMask, opts) {
   const src32 = src.data32;
   const dw = dst.width;
   const sw = src.width;
-  const mPitch = mw;
+  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;
@@ -4312,7 +4652,7 @@ function blendPixelDataBinaryMask(dst, src, binaryMask, opts) {
   const isOverwrite = blendFn.isOverwrite || false;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
-      if (binaryMask[mIdx] === skipVal) {
+      if (maskData[mIdx] === skipVal) {
         dIdx++;
         sIdx++;
         mIdx++;
@@ -4440,10 +4780,11 @@ function pixelDataToAlphaMask(pixelData) {
     height
   } = pixelData;
   const len = data32.length;
-  const mask = new Uint8Array(width * height);
+  const mask = makeAlphaMask(width, height);
+  const maskData = mask.data;
   for (let i = 0; i < len; i++) {
     const val = data32[i];
-    mask[i] = val >>> 24 & 255;
+    maskData[i] = val >>> 24 & 255;
   }
   return mask;
 }
@@ -4624,11 +4965,13 @@ export {
   exclusionPerfect,
   extractImageDataBuffer,
   extractMask,
+  extractMaskBuffer,
   extractPixelData,
   extractPixelDataBuffer,
   fileInputChangeToImageData,
   fileToImageData,
   fillPixelData,
+  fillPixelDataBinaryMask,
   floodFillSelection,
   forEachLinePoint,
   getCircleBrushOrPencilBounds,
@@ -4637,12 +4980,13 @@ export {
   getIndexedImageColorCounts,
   getRectBrushOrPencilBounds,
   getRectBrushOrPencilStrokeBounds,
+  getRectsBounds,
   getSupportedPixelFormats,
   hardLightFast,
   hardLightPerfect,
   hardMixFast,
   hardMixPerfect,
-  imageDataToAlphaMask,
+  imageDataToAlphaMaskBuffer,
   imageDataToDataUrl,
   imageDataToImgBlob,
   imageDataToUInt32Array,
@@ -4665,7 +5009,11 @@ export {
   linearDodgePerfect,
   linearLightFast,
   linearLightPerfect,
+  makeAlphaMask,
+  makeBinaryMask,
   makeBlendModeRegistry,
+  makeCircleBrushAlphaMask,
+  makeCircleBrushBinaryMask,
   makeFastBlendModeRegistry,
   makeFullPixelMutator,
   makeImageDataLike,
@@ -4673,7 +5021,9 @@ export {
   makePixelCanvas,
   makeReusableCanvas,
   makeReusableImageData,
+  merge2BinaryMaskRects,
   mergeAlphaMasks,
+  mergeBinaryMaskRects,
   mergeBinaryMasks,
   multiplyFast,
   multiplyPerfect,
@@ -4692,6 +5042,7 @@ export {
   mutatorBlendPixelData,
   mutatorClear,
   mutatorFill,
+  mutatorFillBinaryMask,
   mutatorInvert,
   overlayFast,
   overlayPerfect,
@@ -4714,10 +5065,12 @@ export {
   screenPerfect,
   serializeImageData,
   serializeNullableImageData,
+  setMaskData,
   softLightFast,
   softLightPerfect,
   sourceOverFast,
   sourceOverPerfect,
+  subtractBinaryMaskRects,
   subtractFast,
   subtractPerfect,
   toBlendModeIndexAndName,