pixel-data-js 0.17.1 → 0.19.0

package/dist/index.dev.js

@@ -1,614 +1,235 @@
-// src/BlendModes/blend-modes.ts
-var BaseBlendMode = {
-  overwrite: 0,
-  sourceOver: 1,
-  darken: 2,
-  multiply: 3,
-  colorBurn: 4,
-  linearBurn: 5,
-  darkerColor: 6,
-  lighten: 7,
-  screen: 8,
-  colorDodge: 9,
-  linearDodge: 10,
-  lighterColor: 11,
-  overlay: 12,
-  softLight: 13,
-  hardLight: 14,
-  vividLight: 15,
-  linearLight: 16,
-  pinLight: 17,
-  hardMix: 18,
-  difference: 19,
-  exclusion: 20,
-  subtract: 21,
-  divide: 22
+// src/_types.ts
+var MaskType = /* @__PURE__ */ ((MaskType2) => {
+  MaskType2[MaskType2["ALPHA"] = 0] = "ALPHA";
+  MaskType2[MaskType2["BINARY"] = 1] = "BINARY";
+  return MaskType2;
+})(MaskType || {});
+
+// src/color.ts
+function packColor(r, g, b, a) {
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+}
+function packRGBA({
+  r,
+  g,
+  b,
+  a
+}) {
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+}
+var unpackRed = (packed) => packed >>> 0 & 255;
+var unpackGreen = (packed) => packed >>> 8 & 255;
+var unpackBlue = (packed) => packed >>> 16 & 255;
+var unpackAlpha = (packed) => packed >>> 24 & 255;
+function unpackColor(packed) {
+  return {
+    r: packed >>> 0 & 255,
+    g: packed >>> 8 & 255,
+    b: packed >>> 16 & 255,
+    a: packed >>> 24 & 255
+  };
+}
+var SCRATCH_RGBA = {
+  r: 0,
+  g: 0,
+  b: 0,
+  a: 0
 };
-var overwriteBase = (src, _dst) => src;
-overwriteBase.isOverwrite = true;
+function unpackColorTo(packed, scratch = SCRATCH_RGBA) {
+  scratch.r = packed >>> 0 & 255;
+  scratch.g = packed >>> 8 & 255;
+  scratch.b = packed >>> 16 & 255;
+  scratch.a = packed >>> 24 & 255;
+  return scratch;
+}
+function colorDistance(a, b) {
+  const dr = (a & 255) - (b & 255);
+  const dg = (a >>> 8 & 255) - (b >>> 8 & 255);
+  const db = (a >>> 16 & 255) - (b >>> 16 & 255);
+  const da = (a >>> 24 & 255) - (b >>> 24 & 255);
+  return dr * dr + dg * dg + db * db + da * da;
+}
+function lerpColor32(a, b, t) {
+  const r = (a & 255) + t * ((b & 255) - (a & 255));
+  const g = (a >>> 8 & 255) + t * ((b >>> 8 & 255) - (a >>> 8 & 255));
+  const b_ = (a >>> 16 & 255) + t * ((b >>> 16 & 255) - (a >>> 16 & 255));
+  const a_ = (a >>> 24 & 255) + t * ((b >>> 24 & 255) - (a >>> 24 & 255));
+  return (a_ << 24 | b_ << 16 | g << 8 | r) >>> 0;
+}
+function lerpColor32Fast(src, dst, w) {
+  const invA = 255 - w;
+  const rb = (src & 16711935) * w + (dst & 16711935) * invA >>> 8 & 16711935;
+  const ga = (src >>> 8 & 16711935) * w + (dst >>> 8 & 16711935) * invA >>> 8 & 16711935;
+  return (rb | ga << 8) >>> 0;
+}
+function color32ToHex(color) {
+  const r = (color & 255).toString(16).padStart(2, "0");
+  const g = (color >>> 8 & 255).toString(16).padStart(2, "0");
+  const b = (color >>> 16 & 255).toString(16).padStart(2, "0");
+  const a = (color >>> 24 & 255).toString(16).padStart(2, "0");
+  return `#${r}${g}${b}${a}`;
+}
+function color32ToCssRGBA(color) {
+  const r = color & 255;
+  const g = color >>> 8 & 255;
+  const b = color >>> 16 & 255;
+  const a = color >>> 24 & 255;
+  const alpha = Number((a / 255).toFixed(3));
+  return `rgba(${r},${g},${b},${alpha})`;
+}
 
-// src/BlendModes/BlendModeRegistry.ts
-function makeBlendModeRegistry(blendModes, initialEntries) {
-  const blendToName = /* @__PURE__ */ new Map();
-  const blendToIndex = /* @__PURE__ */ new Map();
-  const indexToName = [];
-  const indexToBlend = [];
-  const nameToBlend = {};
-  const nameToIndex = {};
-  const add = (name, index, blendFn) => {
-    if (!Number.isFinite(index)) {
-      throw new Error(`Index "${index}" is not a number. Attempting to add name: "${name}", index: "${index}"`);
+// src/Internal/resolveClipping.ts
+var makeClippedRect = () => ({
+  x: 0,
+  y: 0,
+  w: 0,
+  h: 0,
+  inBounds: false
+});
+var makeClippedBlit = () => ({
+  x: 0,
+  y: 0,
+  sx: 0,
+  sy: 0,
+  w: 0,
+  h: 0,
+  inBounds: false
+});
+function resolveRectClipping(x, y, w, h, boundaryW, boundaryH, out) {
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, boundaryW - x);
+  const actualH = Math.min(h, boundaryH - y);
+  if (actualW <= 0 || actualH <= 0) {
+    out.inBounds = false;
+    return out;
+  }
+  out.x = x;
+  out.y = y;
+  out.w = actualW;
+  out.h = actualH;
+  out.inBounds = true;
+  return out;
+}
+function resolveBlitClipping(x, y, sx, sy, w, h, dstW, dstH, srcW, srcH, out) {
+  if (sx < 0) {
+    x -= sx;
+    w += sx;
+    sx = 0;
+  }
+  if (sy < 0) {
+    y -= sy;
+    h += sy;
+    sy = 0;
+  }
+  w = Math.min(w, srcW - sx);
+  h = Math.min(h, srcH - sy);
+  if (x < 0) {
+    sx -= x;
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    sy -= y;
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dstW - x);
+  const actualH = Math.min(h, dstH - y);
+  if (actualW <= 0 || actualH <= 0) {
+    out.inBounds = false;
+    return out;
+  }
+  out.x = x;
+  out.y = y;
+  out.sx = sx;
+  out.sy = sy;
+  out.w = actualW;
+  out.h = actualH;
+  out.inBounds = true;
+  return out;
+}
+
+// src/ImageData/extractImageDataBuffer.ts
+var SCRATCH_BLIT = makeClippedBlit();
+function extractImageDataBuffer(imageData, _x, _y, _w, _h) {
+  const {
+    x,
+    y,
+    w,
+    h
+  } = typeof _x === "object" ? _x : {
+    x: _x,
+    y: _y,
+    w: _w,
+    h: _h
+  };
+  const {
+    width: srcW,
+    height: srcH,
+    data: src
+  } = imageData;
+  if (w <= 0 || h <= 0) return new Uint8ClampedArray(0);
+  const out = new Uint8ClampedArray(w * h * 4);
+  const clip = resolveBlitClipping(0, 0, x, y, w, h, w, h, srcW, srcH, SCRATCH_BLIT);
+  if (!clip.inBounds) return out;
+  const {
+    x: dstX,
+    y: dstY,
+    sx: srcX,
+    sy: srcY,
+    w: copyW,
+    h: copyH
+  } = clip;
+  const rowLen = copyW * 4;
+  for (let row = 0; row < copyH; row++) {
+    const srcStart = ((srcY + row) * srcW + srcX) * 4;
+    const dstStart = ((dstY + row) * w + dstX) * 4;
+    out.set(src.subarray(srcStart, srcStart + rowLen), dstStart);
+  }
+  return out;
+}
+
+// src/Mask/extractMask.ts
+function extractMask(mask, maskWidth, 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 = new Uint8Array(finalW * finalH);
+  const srcH = mask.length / maskWidth;
+  for (let row = 0; row < finalH; row++) {
+    const currentSrcY = finalY + row;
+    if (currentSrcY < 0 || currentSrcY >= srcH) {
+      continue;
     }
-    if (indexToBlend[index]) {
-      throw new Error(`Blend Mode index: ${index} is already used. Attempting to add name: "${name}", index: "${index}"`);
+    const start = Math.max(0, finalX);
+    const end = Math.min(maskWidth, finalX + finalW);
+    if (start < end) {
+      const srcOffset = currentSrcY * maskWidth + start;
+      const dstOffset = row * finalW + (start - finalX);
+      const count = end - start;
+      out.set(mask.subarray(srcOffset, srcOffset + count), dstOffset);
     }
-    indexToName[index] = name;
-    indexToBlend[index] = blendFn;
-    blendToIndex.set(blendFn, index);
-    blendToName.set(blendFn, name);
-    nameToBlend[name] = blendFn;
-    nameToIndex[name] = index;
-  };
-  for (const [name, index] of Object.entries(blendModes)) {
-    const blend = initialEntries[index];
-    add(name, index, blend);
   }
-  return {
-    nameToBlend,
-    nameToIndex,
-    blendToIndex,
-    blendToName,
-    indexToBlend,
-    indexToName,
-    indexType: null,
-    nameType: null
-  };
-}
-
-// src/BlendModes/blend-modes-fast.ts
-var overwriteFast = overwriteBase;
-var sourceOverFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 255) return src;
-  if (sa === 0) return dst;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const da = dst >>> 24 & 255;
-  const invA = 255 - sa;
-  const r = sr * sa + dr * invA >> 8;
-  const g = sg * sa + dg * invA >> 8;
-  const b = sb * sa + db * invA >> 8;
-  const a = 255 * sa + da * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var darkenFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const br = sr < dr ? sr : dr;
-  const bg = sg < dg ? sg : dg;
-  const bb = sb < db ? sb : db;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var multiplyFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const br = sr * dr >> 8;
-  const bg = sg * dg >> 8;
-  const bb = sb * db >> 8;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const da = dst >>> 24 & 255;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + da * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var colorBurnFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const br = dr === 255 ? 255 : sr === 0 ? 0 : Math.max(0, 255 - (255 - dr << 8) / sr | 0);
-  const bg = dg === 255 ? 255 : sg === 0 ? 0 : Math.max(0, 255 - (255 - dg << 8) / sg | 0);
-  const bb = db === 255 ? 255 : sb === 0 ? 0 : Math.max(0, 255 - (255 - db << 8) / sb | 0);
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const da = dst >>> 24 & 255;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + da * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var linearBurnFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const brU = dr + sr - 255;
-  const bgU = dg + sg - 255;
-  const bbU = db + sb - 255;
-  const br = brU < 0 ? 0 : brU;
-  const bg = bgU < 0 ? 0 : bgU;
-  const bb = bbU < 0 ? 0 : bbU;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var darkerFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const lumSrc = sr * 77 + sg * 151 + sb * 28;
-  const lumDst = dr * 77 + dg * 151 + db * 28;
-  let br, bg, bb;
-  if (lumSrc < lumDst) {
-    br = sr;
-    bg = sg;
-    bb = sb;
-  } else {
-    br = dr;
-    bg = dg;
-    bb = db;
-  }
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var lightenFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const br = Math.max(src & 255, dst & 255);
-  const bg = Math.max(src >> 8 & 255, dst >> 8 & 255);
-  const bb = Math.max(src >> 16 & 255, dst >> 16 & 255);
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const dr = dst & 255;
-  const dg = dst >> 8 & 255;
-  const db = dst >> 16 & 255;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var screenFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const br = 255 - ((255 - (src & 255)) * (255 - dr) >> 8);
-  const bg = 255 - ((255 - (src >>> 8 & 255)) * (255 - dg) >> 8);
-  const bb = 255 - ((255 - (src >>> 16 & 255)) * (255 - db) >> 8);
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var colorDodgeFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = sr === 255 ? 255 : Math.min(255, (dr << 8) / (255 - sr) | 0);
-  const bg = sg === 255 ? 255 : Math.min(255, (dg << 8) / (255 - sg) | 0);
-  const bb = sb === 255 ? 255 : Math.min(255, (db << 8) / (255 - sb) | 0);
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var linearDodgeFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const brU = (src & 255) + dr;
-  const bgU = (src >>> 8 & 255) + dg;
-  const bbU = (src >>> 16 & 255) + db;
-  const br = brU > 255 ? 255 : brU;
-  const bg = bgU > 255 ? 255 : bgU;
-  const bb = bbU > 255 ? 255 : bbU;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var lighterFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const lumSrc = sr * 77 + sg * 151 + sb * 28;
-  const lumDst = dr * 77 + dg * 151 + db * 28;
-  let br, bg, bb;
-  if (lumSrc > lumDst) {
-    br = sr;
-    bg = sg;
-    bb = sb;
-  } else {
-    br = dr;
-    bg = dg;
-    bb = db;
-  }
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var overlayFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const br = dr < 128 ? 2 * sr * dr >> 8 : 255 - (2 * (255 - sr) * (255 - dr) >> 8);
-  const bg = dg < 128 ? 2 * sg * dg >> 8 : 255 - (2 * (255 - sg) * (255 - dg) >> 8);
-  const bb = db < 128 ? 2 * sb * db >> 8 : 255 - (2 * (255 - sb) * (255 - db) >> 8);
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var softLightFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = (255 - dr) * (sr * dr >> 8) + dr * (255 - ((255 - sr) * (255 - dr) >> 8)) >> 8;
-  const bg = (255 - dg) * (sg * dg >> 8) + dg * (255 - ((255 - sg) * (255 - dg) >> 8)) >> 8;
-  const bb = (255 - db) * (sb * db >> 8) + db * (255 - ((255 - sb) * (255 - db) >> 8)) >> 8;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var hardLightFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = sr < 128 ? 2 * sr * dr >> 8 : 255 - (2 * (255 - sr) * (255 - dr) >> 8);
-  const bg = sg < 128 ? 2 * sg * dg >> 8 : 255 - (2 * (255 - sg) * (255 - dg) >> 8);
-  const bb = sb < 128 ? 2 * sb * db >> 8 : 255 - (2 * (255 - sb) * (255 - db) >> 8);
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var vividLightFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = sr < 128 ? sr === 0 ? 0 : Math.max(0, 255 - (255 - dr << 8) / (2 * sr) | 0) : sr === 255 ? 255 : Math.min(255, (dr << 8) / (2 * (255 - sr)) | 0);
-  const bg = sg < 128 ? sg === 0 ? 0 : Math.max(0, 255 - (255 - dg << 8) / (2 * sg) | 0) : sg === 255 ? 255 : Math.min(255, (dg << 8) / (2 * (255 - sg)) | 0);
-  const bb = sb < 128 ? sb === 0 ? 0 : Math.max(0, 255 - (255 - db << 8) / (2 * sb) | 0) : sb === 255 ? 255 : Math.min(255, (db << 8) / (2 * (255 - sb)) | 0);
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var linearLightFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const brU = dr + 2 * sr - 255;
-  const bgU = dg + 2 * sg - 255;
-  const bbU = db + 2 * sb - 255;
-  const br = brU < 0 ? 0 : brU > 255 ? 255 : brU;
-  const bg = bgU < 0 ? 0 : bgU > 255 ? 255 : bgU;
-  const bb = bbU < 0 ? 0 : bbU > 255 ? 255 : bbU;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var pinLightFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = sr < 128 ? dr < 2 * sr ? dr : 2 * sr : dr > 2 * sr - 256 ? dr : 2 * sr - 256;
-  const bg = sg < 128 ? dg < 2 * sg ? dg : 2 * sg : dg > 2 * sg - 256 ? dg : 2 * sg - 256;
-  const bb = sb < 128 ? db < 2 * sb ? db : 2 * sb : db > 2 * sb - 256 ? db : 2 * sb - 256;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var hardMixFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = (sr < 128 ? sr === 0 ? 0 : Math.max(0, 255 - (255 - dr << 8) / (2 * sr) | 0) : sr === 255 ? 255 : Math.min(255, (dr << 8) / (2 * (255 - sr)) | 0)) < 128 ? 0 : 255;
-  const bg = (sg < 128 ? sg === 0 ? 0 : Math.max(0, 255 - (255 - dg << 8) / (2 * sg) | 0) : sg === 255 ? 255 : Math.min(255, (dg << 8) / (2 * (255 - sg)) | 0)) < 128 ? 0 : 255;
-  const bb = (sb < 128 ? sb === 0 ? 0 : Math.max(0, 255 - (255 - db << 8) / (2 * sb) | 0) : sb === 255 ? 255 : Math.min(255, (db << 8) / (2 * (255 - sb)) | 0)) < 128 ? 0 : 255;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var differenceFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const brD = (src & 255) - dr;
-  const bgD = (src >>> 8 & 255) - dg;
-  const bbD = (src >>> 16 & 255) - db;
-  const br = brD < 0 ? -brD : brD;
-  const bg = bgD < 0 ? -bgD : bgD;
-  const bb = bbD < 0 ? -bbD : bbD;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var exclusionFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = dr + sr - (dr * sr >> 7);
-  const bg = dg + sg - (dg * sg >> 7);
-  const bb = db + sb - (db * sb >> 7);
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var subtractFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const brU = dr - sr;
-  const bgU = dg - sg;
-  const bbU = db - sb;
-  const br = brU < 0 ? 0 : brU;
-  const bg = bgU < 0 ? 0 : bgU;
-  const bb = bbU < 0 ? 0 : bbU;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var divideFast = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
-  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
-  const br = sr === 0 ? 255 : Math.min(255, (dr << 8) / sr | 0);
-  const bg = sg === 0 ? 255 : Math.min(255, (dg << 8) / sg | 0);
-  const bb = sb === 0 ? 255 : Math.min(255, (db << 8) / sb | 0);
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const r = br * sa + dr * invA >> 8;
-  const g = bg * sa + dg * invA >> 8;
-  const b = bb * sa + db * invA >> 8;
-  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-};
-var BASE_FAST_BLEND_MODE_FUNCTIONS = {
-  [BaseBlendMode.overwrite]: overwriteFast,
-  [BaseBlendMode.sourceOver]: sourceOverFast,
-  [BaseBlendMode.darken]: darkenFast,
-  [BaseBlendMode.multiply]: multiplyFast,
-  [BaseBlendMode.colorBurn]: colorBurnFast,
-  [BaseBlendMode.linearBurn]: linearBurnFast,
-  [BaseBlendMode.darkerColor]: darkerFast,
-  [BaseBlendMode.lighten]: lightenFast,
-  [BaseBlendMode.screen]: screenFast,
-  [BaseBlendMode.colorDodge]: colorDodgeFast,
-  [BaseBlendMode.linearDodge]: linearDodgeFast,
-  [BaseBlendMode.lighterColor]: lighterFast,
-  [BaseBlendMode.overlay]: overlayFast,
-  [BaseBlendMode.softLight]: softLightFast,
-  [BaseBlendMode.hardLight]: hardLightFast,
-  [BaseBlendMode.vividLight]: vividLightFast,
-  [BaseBlendMode.linearLight]: linearLightFast,
-  [BaseBlendMode.pinLight]: pinLightFast,
-  [BaseBlendMode.hardMix]: hardMixFast,
-  [BaseBlendMode.difference]: differenceFast,
-  [BaseBlendMode.exclusion]: exclusionFast,
-  [BaseBlendMode.subtract]: subtractFast,
-  [BaseBlendMode.divide]: divideFast
-};
-function makeFastBlendModeRegistry() {
-  return makeBlendModeRegistry(BaseBlendMode, BASE_FAST_BLEND_MODE_FUNCTIONS);
-}
-
-// src/_types.ts
-var MaskType = /* @__PURE__ */ ((MaskType2) => {
-  MaskType2[MaskType2["ALPHA"] = 0] = "ALPHA";
-  MaskType2[MaskType2["BINARY"] = 1] = "BINARY";
-  return MaskType2;
-})(MaskType || {});
-
-// src/color.ts
-function packColor(r, g, b, a) {
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-}
-function packRGBA({ r, g, b, a }) {
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-}
-var unpackRed = (packed) => packed >>> 0 & 255;
-var unpackGreen = (packed) => packed >>> 8 & 255;
-var unpackBlue = (packed) => packed >>> 16 & 255;
-var unpackAlpha = (packed) => packed >>> 24 & 255;
-function unpackColor(packed) {
-  return {
-    r: packed >>> 0 & 255,
-    g: packed >>> 8 & 255,
-    b: packed >>> 16 & 255,
-    a: packed >>> 24 & 255
-  };
-}
-var SCRATCH_RGBA = { r: 0, g: 0, b: 0, a: 0 };
-function unpackColorTo(packed, scratch = SCRATCH_RGBA) {
-  scratch.r = packed >>> 0 & 255;
-  scratch.g = packed >>> 8 & 255;
-  scratch.b = packed >>> 16 & 255;
-  scratch.a = packed >>> 24 & 255;
-  return scratch;
-}
-function colorDistance(a, b) {
-  const dr = (a & 255) - (b & 255);
-  const dg = (a >>> 8 & 255) - (b >>> 8 & 255);
-  const db = (a >>> 16 & 255) - (b >>> 16 & 255);
-  const da = (a >>> 24 & 255) - (b >>> 24 & 255);
-  return dr * dr + dg * dg + db * db + da * da;
-}
-function lerpColor32(a, b, t) {
-  const r = (a & 255) + t * ((b & 255) - (a & 255));
-  const g = (a >>> 8 & 255) + t * ((b >>> 8 & 255) - (a >>> 8 & 255));
-  const b_ = (a >>> 16 & 255) + t * ((b >>> 16 & 255) - (a >>> 16 & 255));
-  const a_ = (a >>> 24 & 255) + t * ((b >>> 24 & 255) - (a >>> 24 & 255));
-  return (a_ << 24 | b_ << 16 | g << 8 | r) >>> 0;
-}
-function lerpColor32Fast(src, dst, w) {
-  const invA = 255 - w;
-  const rb = (src & 16711935) * w + (dst & 16711935) * invA >>> 8 & 16711935;
-  const ga = (src >>> 8 & 16711935) * w + (dst >>> 8 & 16711935) * invA >>> 8 & 16711935;
-  return (rb | ga << 8) >>> 0;
-}
-function color32ToHex(color) {
-  const r = (color & 255).toString(16).padStart(2, "0");
-  const g = (color >>> 8 & 255).toString(16).padStart(2, "0");
-  const b = (color >>> 16 & 255).toString(16).padStart(2, "0");
-  const a = (color >>> 24 & 255).toString(16).padStart(2, "0");
-  return `#${r}${g}${b}${a}`;
-}
-function color32ToCssRGBA(color) {
-  const r = color & 255;
-  const g = color >>> 8 & 255;
-  const b = color >>> 16 & 255;
-  const a = color >>> 24 & 255;
-  const alpha = Number((a / 255).toFixed(3));
-  return `rgba(${r},${g},${b},${alpha})`;
-}
-
-// src/ImageData/extractImageDataBuffer.ts
-function extractImageDataBuffer(imageData, _x, _y, _w, _h) {
-  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
-  const { width: srcW, height: srcH, data: src } = imageData;
-  if (w <= 0 || h <= 0) return new Uint8ClampedArray(0);
-  const out = new Uint8ClampedArray(w * h * 4);
-  const x0 = Math.max(0, x);
-  const y0 = Math.max(0, y);
-  const x1 = Math.min(srcW, x + w);
-  const y1 = Math.min(srcH, y + h);
-  if (x1 <= x0 || y1 <= y0) return out;
-  for (let row = 0; row < y1 - y0; row++) {
-    const srcRow = y0 + row;
-    const srcStart = (srcRow * srcW + x0) * 4;
-    const rowLen = (x1 - x0) * 4;
-    const dstRow = y0 - y + row;
-    const dstCol = x0 - x;
-    const dstStart = (dstRow * w + dstCol) * 4;
-    out.set(src.subarray(srcStart, srcStart + rowLen), dstStart);
-  }
-  return out;
-}
-
-// src/Mask/extractMask.ts
-function extractMask(mask, maskWidth, 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 = new Uint8Array(finalW * finalH);
-  const srcH = mask.length / maskWidth;
-  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(maskWidth, finalX + finalW);
-    if (start < end) {
-      const srcOffset = currentSrcY * maskWidth + start;
-      const dstOffset = row * finalW + (start - finalX);
-      const count = end - start;
-      out.set(
-        mask.subarray(srcOffset, srcOffset + count),
-        dstOffset
-      );
-    }
-  }
-  return out;
+  return out;
 }
 
 // src/Rect/trimRectBounds.ts
@@ -618,14 +239,8 @@ function trimRectBounds(target, bounds) {
   const originalW = target.w;
   const intersectedX = Math.max(target.x, bounds.x);
   const intersectedY = Math.max(target.y, bounds.y);
-  const intersectedMaxX = Math.min(
-    target.x + target.w,
-    bounds.x + bounds.w
-  );
-  const intersectedMaxY = Math.min(
-    target.y + target.h,
-    bounds.y + bounds.h
-  );
+  const intersectedMaxX = Math.min(target.x + target.w, bounds.x + bounds.w);
+  const intersectedMaxY = Math.min(target.y + target.h, bounds.y + bounds.h);
   if (intersectedMaxX <= intersectedX || intersectedMaxY <= intersectedY) {
     target.w = 0;
     target.h = 0;
@@ -643,14 +258,7 @@ function trimRectBounds(target, bounds) {
   target.w = intersectedW;
   target.h = intersectedH;
   if ("mask" in target && target.mask) {
-    const currentMask = extractMask(
-      target.mask,
-      originalW,
-      offsetX,
-      offsetY,
-      intersectedW,
-      intersectedH
-    );
+    const currentMask = extractMask(target.mask, originalW, offsetX, offsetY, intersectedW, intersectedH);
     let minX = intersectedW;
     let maxX = -1;
     let minY = intersectedH;
@@ -674,14 +282,7 @@ function trimRectBounds(target, bounds) {
     const finalW = maxX - minX + 1;
     const finalH = maxY - minY + 1;
     if (finalW !== intersectedW || finalH !== intersectedH) {
-      target.mask = extractMask(
-        currentMask,
-        intersectedW,
-        minX,
-        minY,
-        finalW,
-        finalH
-      );
+      target.mask = extractMask(currentMask, intersectedW, minX, minY, finalW, finalH);
       target.x += minX;
       target.y += minY;
       target.w = finalW;
@@ -704,11 +305,7 @@ function floodFillSelection(img, startX, startY, {
     data32 = img.data32;
     imageData = img.imageData;
   } else {
-    data32 = new Uint32Array(
-      img.data.buffer,
-      img.data.byteOffset,
-      img.data.byteLength >> 2
-    );
+    data32 = new Uint32Array(img.data.buffer, img.data.byteOffset, img.data.byteLength >> 2);
     imageData = img;
   }
   const {
@@ -783,59 +380,537 @@ function floodFillSelection(img, startX, startY, {
       }
     }
   } else {
-    for (let y = yMin; y <= yMax; y++) {
-      for (let x = xMin; x <= xMax; x++) {
-        const color = data32[y * width + x];
-        if (colorDistance(color, baseColor) <= tolerance) {
-          matchX[matchCount] = x;
-          matchY[matchCount] = y;
-          matchCount++;
-          if (x < minX) minX = x;
-          if (x > maxX) maxX = x;
-          if (y < minY) minY = y;
-          if (y > maxY) maxY = y;
-        }
-      }
-    }
-  }
-  if (matchCount === 0) {
-    return null;
+    for (let y = yMin; y <= yMax; y++) {
+      for (let x = xMin; x <= xMax; x++) {
+        const color = data32[y * width + x];
+        if (colorDistance(color, baseColor) <= tolerance) {
+          matchX[matchCount] = x;
+          matchY[matchCount] = y;
+          matchCount++;
+          if (x < minX) minX = x;
+          if (x > maxX) maxX = x;
+          if (y < minY) minY = y;
+          if (y > maxY) maxY = y;
+        }
+      }
+    }
+  }
+  if (matchCount === 0) {
+    return null;
+  }
+  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 */
+  };
+  const sw = selectionRect.w;
+  const sh = selectionRect.h;
+  const finalMask = selectionRect.mask;
+  for (let i = 0; i < matchCount; i++) {
+    const mx = matchX[i] - selectionRect.x;
+    const my = matchY[i] - selectionRect.y;
+    if (mx >= 0 && mx < sw && my >= 0 && my < sh) {
+      finalMask[my * sw + mx] = 1;
+    }
+  }
+  trimRectBounds(selectionRect, {
+    x: 0,
+    y: 0,
+    w: width,
+    h: height
+  });
+  const extracted = extractImageDataBuffer(imageData, selectionRect.x, selectionRect.y, selectionRect.w, selectionRect.h);
+  return {
+    startX,
+    startY,
+    selectionRect,
+    pixels: extracted
+  };
+}
+
+// src/BlendModes/blend-modes.ts
+var BaseBlendMode = {
+  overwrite: 0,
+  sourceOver: 1,
+  darken: 2,
+  multiply: 3,
+  colorBurn: 4,
+  linearBurn: 5,
+  darkerColor: 6,
+  lighten: 7,
+  screen: 8,
+  colorDodge: 9,
+  linearDodge: 10,
+  lighterColor: 11,
+  overlay: 12,
+  softLight: 13,
+  hardLight: 14,
+  vividLight: 15,
+  linearLight: 16,
+  pinLight: 17,
+  hardMix: 18,
+  difference: 19,
+  exclusion: 20,
+  subtract: 21,
+  divide: 22
+};
+var overwriteBase = (src, _dst) => src;
+overwriteBase.isOverwrite = true;
+
+// src/BlendModes/BlendModeRegistry.ts
+function makeBlendModeRegistry(blendModes, initialEntries, registryName = "anonymous") {
+  const blendToName = /* @__PURE__ */ new Map();
+  const blendToIndex = /* @__PURE__ */ new Map();
+  const indexToName = [];
+  const indexToBlend = [];
+  const nameToBlend = {};
+  const nameToIndex = {};
+  const add = (name, index, blendFn) => {
+    if (!Number.isFinite(index)) {
+      throw new Error(`Index "${index}" is not a number. Attempting to add name: "${name}", index: "${index}"`);
+    }
+    if (indexToBlend[index]) {
+      throw new Error(`Blend Mode index: ${index} is already used. Attempting to add name: "${name}", index: "${index}"`);
+    }
+    indexToName[index] = name;
+    indexToBlend[index] = blendFn;
+    blendToIndex.set(blendFn, index);
+    blendToName.set(blendFn, name);
+    nameToBlend[name] = blendFn;
+    nameToIndex[name] = index;
+  };
+  for (const [name, index] of Object.entries(blendModes)) {
+    const blend = initialEntries[index];
+    add(name, index, blend);
+  }
+  return {
+    registryName,
+    nameToBlend,
+    nameToIndex,
+    blendToIndex,
+    blendToName,
+    indexToBlend,
+    indexToName,
+    indexType: null,
+    nameType: null
+  };
+}
+
+// src/BlendModes/blend-modes-fast.ts
+var overwriteFast = overwriteBase;
+var sourceOverFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 255) return src;
+  if (sa === 0) return dst;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const da = dst >>> 24 & 255;
+  const invA = 255 - sa;
+  const r = sr * sa + dr * invA >> 8;
+  const g = sg * sa + dg * invA >> 8;
+  const b = sb * sa + db * invA >> 8;
+  const a = 255 * sa + da * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var darkenFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const br = sr < dr ? sr : dr;
+  const bg = sg < dg ? sg : dg;
+  const bb = sb < db ? sb : db;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var multiplyFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const br = sr * dr >> 8;
+  const bg = sg * dg >> 8;
+  const bb = sb * db >> 8;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const da = dst >>> 24 & 255;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + da * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var colorBurnFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const br = dr === 255 ? 255 : sr === 0 ? 0 : Math.max(0, 255 - (255 - dr << 8) / sr | 0);
+  const bg = dg === 255 ? 255 : sg === 0 ? 0 : Math.max(0, 255 - (255 - dg << 8) / sg | 0);
+  const bb = db === 255 ? 255 : sb === 0 ? 0 : Math.max(0, 255 - (255 - db << 8) / sb | 0);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const da = dst >>> 24 & 255;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + da * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var linearBurnFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const brU = dr + sr - 255;
+  const bgU = dg + sg - 255;
+  const bbU = db + sb - 255;
+  const br = brU < 0 ? 0 : brU;
+  const bg = bgU < 0 ? 0 : bgU;
+  const bb = bbU < 0 ? 0 : bbU;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var darkerFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const lumSrc = sr * 77 + sg * 151 + sb * 28;
+  const lumDst = dr * 77 + dg * 151 + db * 28;
+  let br, bg, bb;
+  if (lumSrc < lumDst) {
+    br = sr;
+    bg = sg;
+    bb = sb;
+  } else {
+    br = dr;
+    bg = dg;
+    bb = db;
   }
-  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 */
-  };
-  const sw = selectionRect.w;
-  const sh = selectionRect.h;
-  const finalMask = selectionRect.mask;
-  for (let i = 0; i < matchCount; i++) {
-    const mx = matchX[i] - selectionRect.x;
-    const my = matchY[i] - selectionRect.y;
-    if (mx >= 0 && mx < sw && my >= 0 && my < sh) {
-      finalMask[my * sw + mx] = 1;
-    }
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var lightenFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const br = Math.max(src & 255, dst & 255);
+  const bg = Math.max(src >> 8 & 255, dst >> 8 & 255);
+  const bb = Math.max(src >> 16 & 255, dst >> 16 & 255);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const dr = dst & 255;
+  const dg = dst >> 8 & 255;
+  const db = dst >> 16 & 255;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var screenFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const br = 255 - ((255 - (src & 255)) * (255 - dr) >> 8);
+  const bg = 255 - ((255 - (src >>> 8 & 255)) * (255 - dg) >> 8);
+  const bb = 255 - ((255 - (src >>> 16 & 255)) * (255 - db) >> 8);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var colorDodgeFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const br = sr === 255 ? 255 : Math.min(255, (dr << 8) / (255 - sr) | 0);
+  const bg = sg === 255 ? 255 : Math.min(255, (dg << 8) / (255 - sg) | 0);
+  const bb = sb === 255 ? 255 : Math.min(255, (db << 8) / (255 - sb) | 0);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var linearDodgeFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const brU = (src & 255) + dr;
+  const bgU = (src >>> 8 & 255) + dg;
+  const bbU = (src >>> 16 & 255) + db;
+  const br = brU > 255 ? 255 : brU;
+  const bg = bgU > 255 ? 255 : bgU;
+  const bb = bbU > 255 ? 255 : bbU;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var lighterFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const lumSrc = sr * 77 + sg * 151 + sb * 28;
+  const lumDst = dr * 77 + dg * 151 + db * 28;
+  let br, bg, bb;
+  if (lumSrc > lumDst) {
+    br = sr;
+    bg = sg;
+    bb = sb;
+  } else {
+    br = dr;
+    bg = dg;
+    bb = db;
   }
-  trimRectBounds(
-    selectionRect,
-    { x: 0, y: 0, w: width, h: height }
-  );
-  const extracted = extractImageDataBuffer(
-    imageData,
-    selectionRect.x,
-    selectionRect.y,
-    selectionRect.w,
-    selectionRect.h
-  );
-  return {
-    startX,
-    startY,
-    selectionRect,
-    pixels: extracted
-  };
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var overlayFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const br = dr < 128 ? 2 * sr * dr >> 8 : 255 - (2 * (255 - sr) * (255 - dr) >> 8);
+  const bg = dg < 128 ? 2 * sg * dg >> 8 : 255 - (2 * (255 - sg) * (255 - dg) >> 8);
+  const bb = db < 128 ? 2 * sb * db >> 8 : 255 - (2 * (255 - sb) * (255 - db) >> 8);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var softLightFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const br = (255 - dr) * (sr * dr >> 8) + dr * (255 - ((255 - sr) * (255 - dr) >> 8)) >> 8;
+  const bg = (255 - dg) * (sg * dg >> 8) + dg * (255 - ((255 - sg) * (255 - dg) >> 8)) >> 8;
+  const bb = (255 - db) * (sb * db >> 8) + db * (255 - ((255 - sb) * (255 - db) >> 8)) >> 8;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var hardLightFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const br = sr < 128 ? 2 * sr * dr >> 8 : 255 - (2 * (255 - sr) * (255 - dr) >> 8);
+  const bg = sg < 128 ? 2 * sg * dg >> 8 : 255 - (2 * (255 - sg) * (255 - dg) >> 8);
+  const bb = sb < 128 ? 2 * sb * db >> 8 : 255 - (2 * (255 - sb) * (255 - db) >> 8);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var vividLightFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const br = sr < 128 ? sr === 0 ? 0 : Math.max(0, 255 - (255 - dr << 8) / (2 * sr) | 0) : sr === 255 ? 255 : Math.min(255, (dr << 8) / (2 * (255 - sr)) | 0);
+  const bg = sg < 128 ? sg === 0 ? 0 : Math.max(0, 255 - (255 - dg << 8) / (2 * sg) | 0) : sg === 255 ? 255 : Math.min(255, (dg << 8) / (2 * (255 - sg)) | 0);
+  const bb = sb < 128 ? sb === 0 ? 0 : Math.max(0, 255 - (255 - db << 8) / (2 * sb) | 0) : sb === 255 ? 255 : Math.min(255, (db << 8) / (2 * (255 - sb)) | 0);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var linearLightFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const brU = dr + 2 * sr - 255;
+  const bgU = dg + 2 * sg - 255;
+  const bbU = db + 2 * sb - 255;
+  const br = brU < 0 ? 0 : brU > 255 ? 255 : brU;
+  const bg = bgU < 0 ? 0 : bgU > 255 ? 255 : bgU;
+  const bb = bbU < 0 ? 0 : bbU > 255 ? 255 : bbU;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var pinLightFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const br = sr < 128 ? dr < 2 * sr ? dr : 2 * sr : dr > 2 * sr - 256 ? dr : 2 * sr - 256;
+  const bg = sg < 128 ? dg < 2 * sg ? dg : 2 * sg : dg > 2 * sg - 256 ? dg : 2 * sg - 256;
+  const bb = sb < 128 ? db < 2 * sb ? db : 2 * sb : db > 2 * sb - 256 ? db : 2 * sb - 256;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var hardMixFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const br = (sr < 128 ? sr === 0 ? 0 : Math.max(0, 255 - (255 - dr << 8) / (2 * sr) | 0) : sr === 255 ? 255 : Math.min(255, (dr << 8) / (2 * (255 - sr)) | 0)) < 128 ? 0 : 255;
+  const bg = (sg < 128 ? sg === 0 ? 0 : Math.max(0, 255 - (255 - dg << 8) / (2 * sg) | 0) : sg === 255 ? 255 : Math.min(255, (dg << 8) / (2 * (255 - sg)) | 0)) < 128 ? 0 : 255;
+  const bb = (sb < 128 ? sb === 0 ? 0 : Math.max(0, 255 - (255 - db << 8) / (2 * sb) | 0) : sb === 255 ? 255 : Math.min(255, (db << 8) / (2 * (255 - sb)) | 0)) < 128 ? 0 : 255;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var differenceFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const brD = (src & 255) - dr;
+  const bgD = (src >>> 8 & 255) - dg;
+  const bbD = (src >>> 16 & 255) - db;
+  const br = brD < 0 ? -brD : brD;
+  const bg = bgD < 0 ? -bgD : bgD;
+  const bb = bbD < 0 ? -bbD : bbD;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var exclusionFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const br = dr + sr - (dr * sr >> 7);
+  const bg = dg + sg - (dg * sg >> 7);
+  const bb = db + sb - (db * sb >> 7);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var subtractFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const brU = dr - sr;
+  const bgU = dg - sg;
+  const bbU = db - sb;
+  const br = brU < 0 ? 0 : brU;
+  const bg = bgU < 0 ? 0 : bgU;
+  const bb = bbU < 0 ? 0 : bbU;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var divideFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
+  const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
+  const br = sr === 0 ? 255 : Math.min(255, (dr << 8) / sr | 0);
+  const bg = sg === 0 ? 255 : Math.min(255, (dg << 8) / sg | 0);
+  const bb = sb === 0 ? 255 : Math.min(255, (db << 8) / sb | 0);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var BASE_FAST_BLEND_MODE_FUNCTIONS = {
+  [BaseBlendMode.overwrite]: overwriteFast,
+  [BaseBlendMode.sourceOver]: sourceOverFast,
+  [BaseBlendMode.darken]: darkenFast,
+  [BaseBlendMode.multiply]: multiplyFast,
+  [BaseBlendMode.colorBurn]: colorBurnFast,
+  [BaseBlendMode.linearBurn]: linearBurnFast,
+  [BaseBlendMode.darkerColor]: darkerFast,
+  [BaseBlendMode.lighten]: lightenFast,
+  [BaseBlendMode.screen]: screenFast,
+  [BaseBlendMode.colorDodge]: colorDodgeFast,
+  [BaseBlendMode.linearDodge]: linearDodgeFast,
+  [BaseBlendMode.lighterColor]: lighterFast,
+  [BaseBlendMode.overlay]: overlayFast,
+  [BaseBlendMode.softLight]: softLightFast,
+  [BaseBlendMode.hardLight]: hardLightFast,
+  [BaseBlendMode.vividLight]: vividLightFast,
+  [BaseBlendMode.linearLight]: linearLightFast,
+  [BaseBlendMode.pinLight]: pinLightFast,
+  [BaseBlendMode.hardMix]: hardMixFast,
+  [BaseBlendMode.difference]: differenceFast,
+  [BaseBlendMode.exclusion]: exclusionFast,
+  [BaseBlendMode.subtract]: subtractFast,
+  [BaseBlendMode.divide]: divideFast
+};
+function makeFastBlendModeRegistry(name = "fast") {
+  return makeBlendModeRegistry(BaseBlendMode, BASE_FAST_BLEND_MODE_FUNCTIONS, name);
 }
 
 // src/BlendModes/blend-modes-perfect.ts
@@ -844,10 +919,11 @@ var sourceOverPerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 255) return src;
   if (sa === 0) return dst;
-  const invA = 255 - sa;
+  const da = dst >>> 24 & 255;
+  if (da === 0) return src;
   const sr = src & 255, sg = src >>> 8 & 255, sb = src >>> 16 & 255;
   const dr = dst & 255, dg = dst >>> 8 & 255, db = dst >>> 16 & 255;
-  const da = dst >>> 24 & 255;
+  const invA = 255 - sa;
   const tR = sr * sa + dr * invA;
   const r = tR + 1 + (tR >> 8) >> 8;
   const tG = sg * sa + dg * invA;
@@ -1389,9 +1465,53 @@ var BASE_PERFECT_BLEND_MODE_FUNCTIONS = {
   [BaseBlendMode.subtract]: subtractPerfect,
   [BaseBlendMode.divide]: dividePerfect
 };
-function makePerfectBlendModeRegistry() {
-  return makeBlendModeRegistry(BaseBlendMode, BASE_PERFECT_BLEND_MODE_FUNCTIONS);
+function makePerfectBlendModeRegistry(name = "perfect") {
+  return makeBlendModeRegistry(BaseBlendMode, BASE_PERFECT_BLEND_MODE_FUNCTIONS, name);
+}
+
+// src/BlendModes/toBlendModeIndexAndName.ts
+function toBlendModeIndexAndName(input) {
+  if (typeof input === "number") {
+    const name = getKeyByValue(BaseBlendMode, input);
+    if (name === void 0) throw new Error(`Invalid index: ${input}`);
+    return {
+      blendIndex: input,
+      blendName: name
+    };
+  }
+  const trimmed = input.trim();
+  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,
+      blendName: name
+    };
+  }
+  if (trimmed in BaseBlendMode) {
+    return {
+      blendIndex: BaseBlendMode[trimmed],
+      blendName: trimmed
+    };
+  }
+  throw new Error(`Invalid blend mode: ${JSON.stringify(input)}`);
 }
+var getKeyByValue = (obj, value) => {
+  for (const key in obj) {
+    if (obj[key] === value) return key;
+  }
+};
 
 // src/Canvas/_constants.ts
 var OFFSCREEN_CANVAS_CTX_FAILED = "Failed to create OffscreenCanvas context";
@@ -1430,7 +1550,10 @@ function makeReusableCanvas() {
     } else {
       ctx.clearRect(0, 0, width, height);
     }
-    return { canvas, ctx };
+    return {
+      canvas,
+      ctx
+    };
   }
   get2.reset = () => {
     canvas = null;
@@ -1444,21 +1567,13 @@ async function imgBlobToImageData(blob) {
   let bitmap = null;
   try {
     bitmap = await createImageBitmap(blob);
-    const canvas = new OffscreenCanvas(
-      bitmap.width,
-      bitmap.height
-    );
+    const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
     const ctx = canvas.getContext("2d");
     if (!ctx) {
       throw new Error("Failed to get 2D context");
     }
     ctx.drawImage(bitmap, 0, 0);
-    return ctx.getImageData(
-      0,
-      0,
-      bitmap.width,
-      bitmap.height
-    );
+    return ctx.getImageData(0, 0, bitmap.width, bitmap.height);
   } finally {
     bitmap?.close();
   }
@@ -1506,6 +1621,64 @@ async function writeImageDataToClipboard(imageData) {
   return writeImgBlobToClipboard(blob);
 }
 
+// src/History/HistoryManager.ts
+var HistoryManager = class {
+  constructor(maxSteps = 50) {
+    this.maxSteps = maxSteps;
+    this.undoStack = [];
+    this.redoStack = [];
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  undoStack;
+  redoStack;
+  listeners;
+  get canUndo() {
+    return this.undoStack.length > 0;
+  }
+  get canRedo() {
+    return this.redoStack.length > 0;
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  notify() {
+    this.listeners.forEach((fn) => fn());
+  }
+  commit(action) {
+    this.undoStack.push(action);
+    this.clearRedoStack();
+    if (this.undoStack.length > this.maxSteps) {
+      this.undoStack.shift()?.dispose?.();
+    }
+    this.notify();
+  }
+  undo() {
+    let action = this.undoStack.pop();
+    if (!action) return;
+    this.redoStack.push(action);
+    action.undo();
+    this.notify();
+  }
+  redo() {
+    let action = this.redoStack.pop();
+    if (!action) return;
+    this.undoStack.push(action);
+    action.redo();
+    this.notify();
+  }
+  clearRedoStack() {
+    let length = this.redoStack.length;
+    for (let i = 0; i < length; i++) {
+      let action = this.redoStack[i];
+      if (action) {
+        action.dispose?.();
+      }
+    }
+    this.redoStack.length = 0;
+  }
+};
+
 // src/History/PixelPatchTiles.ts
 var PixelTile = class {
   constructor(id, tx, ty, tileArea) {
@@ -1559,12 +1732,7 @@ var PixelAccumulator = class {
       tile.ty = ty;
       return tile;
     }
-    return new PixelTile(
-      id,
-      tx,
-      ty,
-      this.config.tileArea
-    );
+    return new PixelTile(id, tx, ty, this.config.tileArea);
   }
   recyclePatch(patch) {
     const before = patch.beforeTiles;
@@ -1595,11 +1763,7 @@ var PixelAccumulator = class {
     let id = ty * columns + tx;
     let tile = this.lookup[id];
     if (!tile) {
-      tile = this.getTile(
-        id,
-        tx,
-        ty
-      );
+      tile = this.getTile(id, tx, ty);
       this.extractState(tile);
       this.lookup[id] = tile;
       this.beforeTiles.push(tile);
@@ -1625,11 +1789,7 @@ var PixelAccumulator = class {
         let id = ty * columns + tx;
         let tile = this.lookup[id];
         if (!tile) {
-          tile = this.getTile(
-            id,
-            tx,
-            ty
-          );
+          tile = this.getTile(id, tx, ty);
           this.extractState(tile);
           this.lookup[id] = tile;
           this.beforeTiles.push(tile);
@@ -1656,90 +1816,28 @@ var PixelAccumulator = class {
       }
       let srcIndex = globalY * targetWidth + startX;
       let rowData = src.subarray(srcIndex, srcIndex + copyWidth);
-      dst.set(rowData, dstIndex);
-      if (copyWidth < TILE_SIZE) {
-        dst.fill(0, dstIndex + copyWidth, dstIndex + TILE_SIZE);
-      }
-    }
-  }
-  extractAfterTiles() {
-    let afterTiles = [];
-    let length = this.beforeTiles.length;
-    for (let i = 0; i < length; i++) {
-      let beforeTile = this.beforeTiles[i];
-      if (beforeTile) {
-        let afterTile = this.getTile(
-          beforeTile.id,
-          beforeTile.tx,
-          beforeTile.ty
-        );
-        this.extractState(afterTile);
-        afterTiles.push(afterTile);
-      }
-    }
-    return afterTiles;
-  }
-  reset() {
-    this.lookup = [];
-    this.beforeTiles = [];
-  }
-};
-
-// src/History/HistoryManager.ts
-var HistoryManager = class {
-  constructor(maxSteps = 50) {
-    this.maxSteps = maxSteps;
-    this.undoStack = [];
-    this.redoStack = [];
-    this.listeners = /* @__PURE__ */ new Set();
-  }
-  undoStack;
-  redoStack;
-  listeners;
-  get canUndo() {
-    return this.undoStack.length > 0;
-  }
-  get canRedo() {
-    return this.redoStack.length > 0;
-  }
-  subscribe(fn) {
-    this.listeners.add(fn);
-    return () => this.listeners.delete(fn);
-  }
-  notify() {
-    this.listeners.forEach((fn) => fn());
-  }
-  commit(action) {
-    this.undoStack.push(action);
-    this.clearRedoStack();
-    if (this.undoStack.length > this.maxSteps) {
-      this.undoStack.shift()?.dispose?.();
-    }
-    this.notify();
-  }
-  undo() {
-    let action = this.undoStack.pop();
-    if (!action) return;
-    this.redoStack.push(action);
-    action.undo();
-    this.notify();
-  }
-  redo() {
-    let action = this.redoStack.pop();
-    if (!action) return;
-    this.undoStack.push(action);
-    action.redo();
-    this.notify();
+      dst.set(rowData, dstIndex);
+      if (copyWidth < TILE_SIZE) {
+        dst.fill(0, dstIndex + copyWidth, dstIndex + TILE_SIZE);
+      }
+    }
   }
-  clearRedoStack() {
-    let length = this.redoStack.length;
+  extractAfterTiles() {
+    let afterTiles = [];
+    let length = this.beforeTiles.length;
     for (let i = 0; i < length; i++) {
-      let action = this.redoStack[i];
-      if (action) {
-        action.dispose?.();
+      let beforeTile = this.beforeTiles[i];
+      if (beforeTile) {
+        let afterTile = this.getTile(beforeTile.id, beforeTile.tx, beforeTile.ty);
+        this.extractState(afterTile);
+        afterTiles.push(afterTile);
       }
     }
-    this.redoStack.length = 0;
+    return afterTiles;
+  }
+  reset() {
+    this.lookup = [];
+    this.beforeTiles = [];
   }
 };
 
@@ -1760,20 +1858,20 @@ var PixelEngineConfig = class {
   }
 };
 
-// src/PixelData/applyMaskToPixelData.ts
-function applyMaskToPixelData(dst, mask, opts = {}) {
+// src/PixelData/applyAlphaMaskToPixelData.ts
+function applyAlphaMaskToPixelData(dst, mask, opts = {}) {
   const {
     x: targetX = 0,
     y: targetY = 0,
     w: width = dst.width,
     h: height = dst.height,
     alpha: globalAlpha = 255,
-    maskType = 0 /* ALPHA */,
     mw,
     mx = 0,
     my = 0,
     invertMask = false
   } = opts;
+  if (globalAlpha === 0) return;
   let x = targetX;
   let y = targetY;
   let w = width;
@@ -1786,59 +1884,557 @@ function applyMaskToPixelData(dst, mask, opts = {}) {
     h += y;
     y = 0;
   }
-  const actualW = Math.min(w, dst.width - x);
-  const actualH = Math.min(h, dst.height - y);
-  if (actualW <= 0 || actualH <= 0 || globalAlpha === 0) {
+  w = Math.min(w, dst.width - x);
+  h = Math.min(h, dst.height - y);
+  if (w <= 0) return;
+  if (h <= 0) return;
+  const mPitch = mw ?? width;
+  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 finalW = sX1 - sX0;
+  const finalH = sY1 - sY0;
+  if (finalW <= 0) return;
+  if (finalH <= 0) return;
+  const xShift = sX0 - startX;
+  const yShift = sY0 - startY;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const dStride = dw - finalW;
+  const mStride = mPitch - finalW;
+  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 effectiveM = invertMask ? 255 - mVal : mVal;
+      let weight = 0;
+      if (effectiveM === 0) {
+        weight = 0;
+      } else if (effectiveM === 255) {
+        weight = globalAlpha;
+      } else if (globalAlpha === 255) {
+        weight = effectiveM;
+      } else {
+        weight = effectiveM * globalAlpha + 128 >> 8;
+      }
+      if (weight === 0) {
+        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+      } else if (weight !== 255) {
+        const d = dst32[dIdx];
+        const da = d >>> 24;
+        if (da !== 0) {
+          const finalAlpha = da === 255 ? weight : da * weight + 128 >> 8;
+          dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+        }
+      }
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+}
+
+// src/History/PixelMutator/mutatorApplyAlphaMask.ts
+var defaults = {
+  applyAlphaMaskToPixelData
+};
+var mutatorApplyAlphaMask = ((writer, deps = defaults) => {
+  const {
+    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults.applyAlphaMaskToPixelData
+  } = deps;
+  return {
+    applyAlphaMask: (mask, opts = {}) => {
+      let target = writer.target;
+      const {
+        x = 0,
+        y = 0,
+        w = writer.target.width,
+        h = writer.target.height
+      } = opts;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      applyAlphaMaskToPixelData2(target, mask, opts);
+    }
+  };
+});
+
+// src/PixelData/applyBinaryMaskToPixelData.ts
+function applyBinaryMaskToPixelData(dst, mask, opts = {}) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha = 255,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (alpha === 0) 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;
+  }
+  w = Math.min(w, dst.width - x);
+  h = Math.min(h, dst.height - y);
+  if (w <= 0) return;
+  if (h <= 0) return;
+  const mPitch = mw ?? width;
+  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 finalW = sX1 - sX0;
+  const finalH = sY1 - sY0;
+  if (finalW <= 0) return;
+  if (finalH <= 0) return;
+  const xShift = sX0 - startX;
+  const yShift = sY0 - startY;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const dStride = dw - finalW;
+  const mStride = mPitch - finalW;
+  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 isMaskedOut = invertMask ? mVal !== 0 : mVal === 0;
+      if (isMaskedOut) {
+        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+      } else if (alpha !== 255) {
+        const d = dst32[dIdx];
+        const da = d >>> 24;
+        if (da !== 0) {
+          const finalAlpha = da === 255 ? alpha : da * alpha + 128 >> 8;
+          dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+        }
+      }
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+}
+
+// src/History/PixelMutator/mutatorApplyBinaryMask.ts
+var defaults2 = {
+  applyBinaryMaskToPixelData
+};
+var mutatorApplyBinaryMask = ((writer, deps = defaults2) => {
+  const {
+    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults2.applyBinaryMaskToPixelData
+  } = deps;
+  return {
+    applyBinaryMask: (mask, opts = {}) => {
+      let target = writer.target;
+      const {
+        x = 0,
+        y = 0,
+        w = writer.target.width,
+        h = writer.target.height
+      } = opts;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      applyBinaryMaskToPixelData2(target, mask, opts);
+    }
+  };
+});
+
+// src/Rect/getCircleBrushOrPencilBounds.ts
+function getCircleBrushOrPencilBounds(centerX, centerY, brushSize, targetWidth, targetHeight, out) {
+  const r = brushSize / 2;
+  const minOffset = -Math.ceil(r - 0.5);
+  const maxOffset = Math.floor(r - 0.5);
+  const startX = Math.floor(centerX + minOffset);
+  const startY = Math.floor(centerY + minOffset);
+  const endX = Math.floor(centerX + maxOffset) + 1;
+  const endY = Math.floor(centerY + maxOffset) + 1;
+  const res = out ?? {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  const cStartX = Math.max(0, startX);
+  const cStartY = Math.max(0, startY);
+  const cEndX = Math.min(targetWidth, endX);
+  const cEndY = Math.min(targetHeight, endY);
+  const w = cEndX - cStartX;
+  const h = cEndY - cStartY;
+  res.x = cStartX;
+  res.y = cStartY;
+  res.w = w < 0 ? 0 : w;
+  res.h = h < 0 ? 0 : h;
+  return res;
+}
+
+// src/PixelData/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;
+  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;
+  const dx = x - targetX | 0;
+  const dy = y - targetY | 0;
   const dst32 = dst.data32;
   const dw = dst.width;
-  const mPitch = mw ?? width;
-  const isAlpha = maskType === 0 /* ALPHA */;
-  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;
+  const mPitch = mw;
+  let dIdx = y * dw + x | 0;
+  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
+  const dStride = dw - actualW | 0;
+  let mStride = mPitch - actualW | 0;
+  const isOpaque = globalAlpha === 255;
+  const colorRGB = color & 16777215;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
       const mVal = mask[mIdx];
+      const effM = invertMask ? 255 - mVal : mVal;
+      if (effM === 0) {
+        dIdx++;
+        mIdx++;
+        continue;
+      }
       let weight = globalAlpha;
-      if (isAlpha) {
-        const effectiveM = invertMask ? 255 - mVal : mVal;
-        if (effectiveM === 0) {
-          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
-          dIdx++;
-          mIdx++;
-          continue;
-        }
-        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
-      } else {
-        const isHit = invertMask ? mVal === 0 : mVal === 1;
-        if (!isHit) {
-          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+      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;
         }
-        weight = globalAlpha;
+        finalCol = (colorRGB | a << 24) >>> 0;
       }
-      if (weight === 0) {
-        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
-      } else {
-        const d = dst32[dIdx];
-        const da = d >>> 24;
-        let finalAlpha = da;
-        if (da === 0) {
-        } else if (weight === 255) {
-        } else if (da === 255) {
-          finalAlpha = weight;
-        } else {
-          finalAlpha = da * weight + 128 >> 8;
+      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+}
+
+// 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
+};
+var mutatorApplyCircleBrushStroke = ((writer, deps = defaults4) => {
+  const {
+    forEachLinePoint: forEachLinePoint2 = defaults4.forEachLinePoint,
+    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults4.blendColorPixelDataAlphaMask,
+    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults4.getCircleBrushOrPencilBounds,
+    getCircleBrushOrPencilStrokeBounds: getCircleBrushOrPencilStrokeBounds2 = defaults4.getCircleBrushOrPencilStrokeBounds
+  } = 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
+  };
+  return {
+    applyCircleBrushStroke(color, x0, y0, x1, y1, brushSize, alpha = 255, fallOff, blendFn = sourceOverPerfect) {
+      const {
+        x: bx,
+        y: by,
+        w: bw,
+        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;
+      const targetWidth = writer.target.width;
+      const targetHeight = writer.target.height;
+      forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
+        const {
+          x: cbx,
+          y: cby,
+          w: cbw,
+          h: cbh
+        } = getCircleBrushOrPencilBounds2(px, py, brushSize, targetWidth, targetHeight, circleBrushBounds);
+        writer.accumulator.storeRegionBeforeState(cbx, cby, cbw, cbh);
+        const startX = Math.max(bx, cbx);
+        const startY = Math.max(by, cby);
+        const endX = Math.min(bx + bw, cbx + cbw);
+        const endY = Math.min(by + bh, cby + cbh);
+        const fPx = Math.floor(px);
+        const fPy = Math.floor(py);
+        for (let my = startY; my < endY; my++) {
+          const dy = my - fPy + centerOffset;
+          const dySqr = dy * dy;
+          const maskRowOffset = (my - by) * bw;
+          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;
+              }
+            }
+          }
         }
-        dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+      });
+      blendColorPixelOptions.blendFn = blendFn;
+      blendColorPixelOptions.alpha = alpha;
+      blendColorPixelOptions.x = bx;
+      blendColorPixelOptions.y = by;
+      blendColorPixelOptions.w = bw;
+      blendColorPixelOptions.h = bh;
+      blendColorPixelDataAlphaMask2(writer.target, color, mask, blendColorPixelOptions);
+    }
+  };
+});
+
+// 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++;
     }
@@ -1847,63 +2443,424 @@ function applyMaskToPixelData(dst, mask, opts = {}) {
   }
 }
 
-// src/History/PixelWriter.ts
-var PixelWriter = class {
-  target;
-  historyManager;
-  accumulator;
-  config;
-  mutator;
-  constructor(target, mutatorFactory, {
-    tileSize = 256,
-    maxHistorySteps = 50,
-    historyManager = new HistoryManager(maxHistorySteps)
-  } = {}) {
-    this.target = target;
-    this.config = new PixelEngineConfig(tileSize);
-    this.historyManager = historyManager;
-    this.accumulator = new PixelAccumulator(target, this.config);
-    this.mutator = mutatorFactory(this);
-  }
-  withHistory(cb) {
-    cb(this.mutator);
-    const beforeTiles = this.accumulator.beforeTiles;
-    if (beforeTiles.length === 0) return;
-    const afterTiles = this.accumulator.extractAfterTiles();
-    const patch = {
-      beforeTiles,
-      afterTiles
-    };
-    const target = this.target;
-    const tileSize = this.config.tileSize;
-    const accumulator = this.accumulator;
-    const action = {
-      undo: () => applyPatchTiles(target, patch.beforeTiles, tileSize),
-      redo: () => applyPatchTiles(target, patch.afterTiles, tileSize),
-      dispose: () => accumulator.recyclePatch(patch)
-    };
-    this.historyManager.commit(action);
-    this.accumulator.reset();
-  }
+// src/History/PixelMutator/mutatorApplyCirclePencilStroke.ts
+var defaults5 = {
+  forEachLinePoint,
+  blendColorPixelDataBinaryMask,
+  getCircleBrushOrPencilBounds,
+  getCircleBrushOrPencilStrokeBounds
 };
+var mutatorApplyCirclePencilStroke = ((writer, deps = defaults5) => {
+  const {
+    forEachLinePoint: forEachLinePoint2 = defaults5.forEachLinePoint,
+    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults5.blendColorPixelDataBinaryMask,
+    getCircleBrushOrPencilStrokeBounds: getCircleBrushOrPencilStrokeBounds2 = defaults5.getCircleBrushOrPencilStrokeBounds,
+    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults5.getCircleBrushOrPencilBounds
+  } = 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
+  };
+  return {
+    applyCirclePencilStroke(color, x0, y0, x1, y1, brushSize, alpha = 255, blendFn = sourceOverPerfect) {
+      const {
+        x: bx,
+        y: by,
+        w: bw,
+        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 centerOffset = brushSize % 2 === 0 ? 0.5 : 0;
+      const targetWidth = writer.target.width;
+      const targetHeight = writer.target.height;
+      forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
+        const {
+          x: cbx,
+          y: cby,
+          w: cbw,
+          h: cbh
+        } = getCircleBrushOrPencilBounds2(px, py, brushSize, targetWidth, targetHeight, 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);
+        for (let my = startY; my < endY; my++) {
+          const dy = my - fPy + centerOffset;
+          const dySqr = dy * dy;
+          const maskRowOffset = (my - by) * bw;
+          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);
+              mask[maskIdx] = 1;
+            }
+          }
+        }
+      });
+      blendColorPixelOptions.blendFn = blendFn;
+      blendColorPixelOptions.alpha = alpha;
+      blendColorPixelOptions.x = bx;
+      blendColorPixelOptions.y = by;
+      blendColorPixelOptions.w = bw;
+      blendColorPixelOptions.h = bh;
+      blendColorPixelDataBinaryMask2(writer.target, color, mask, blendColorPixelOptions);
+    }
+  };
+});
+
+// src/Rect/getRectBrushOrPencilBounds.ts
+function getRectBrushOrPencilBounds(centerX, centerY, brushWidth, brushHeight, targetWidth, targetHeight, out) {
+  const startX = Math.floor(centerX - brushWidth / 2);
+  const startY = Math.floor(centerY - brushHeight / 2);
+  const endX = startX + brushWidth;
+  const endY = startY + brushHeight;
+  const res = out ?? {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  const cStartX = Math.max(0, startX);
+  const cStartY = Math.max(0, startY);
+  const cEndX = Math.min(targetWidth, endX);
+  const cEndY = Math.min(targetHeight, endY);
+  const w = cEndX - cStartX;
+  const h = cEndY - cStartY;
+  res.x = cStartX;
+  res.y = cStartY;
+  res.w = w < 0 ? 0 : w;
+  res.h = h < 0 ? 0 : h;
+  return res;
+}
+
+// src/PixelData/applyRectBrushToPixelData.ts
+function applyRectBrushToPixelData(target, color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn = sourceOverPerfect, bounds) {
+  const targetWidth = target.width;
+  const targetHeight = target.height;
+  const b = bounds ?? getRectBrushOrPencilBounds(centerX, centerY, brushWidth, brushHeight, targetWidth, targetHeight);
+  if (b.w <= 0 || b.h <= 0) return;
+  const data32 = target.data32;
+  const baseColor = color & 16777215;
+  const baseSrcAlpha = color >>> 24;
+  const isOpaque = alpha === 255;
+  const invHalfW = 1 / (brushWidth / 2);
+  const invHalfH = 1 / (brushHeight / 2);
+  const centerOffsetX = brushWidth % 2 === 0 ? 0.5 : 0;
+  const centerOffsetY = brushHeight % 2 === 0 ? 0.5 : 0;
+  const fCenterX = Math.floor(centerX);
+  const fCenterY = Math.floor(centerY);
+  const endX = b.x + b.w;
+  const endY = b.y + b.h;
+  const isOverwrite = blendFn.isOverwrite;
+  for (let py = b.y; py < endY; py++) {
+    const rowOffset = py * targetWidth;
+    const dy = Math.abs(py - fCenterY + centerOffsetY) * invHalfH;
+    for (let px = b.x; px < endX; px++) {
+      const idx = rowOffset + px;
+      const dx = Math.abs(px - fCenterX + centerOffsetX) * invHalfW;
+      const dist = dx > dy ? dx : dy;
+      const strength = fallOff(dist);
+      const maskVal = strength * 255 | 0;
+      if (maskVal <= 0) continue;
+      let weight = alpha;
+      if (isOpaque) {
+        weight = maskVal;
+      } else if (maskVal !== 255) {
+        weight = maskVal * alpha + 128 >> 8;
+      }
+      let finalCol = color;
+      if (weight < 255) {
+        const a = baseSrcAlpha * weight + 128 >> 8;
+        if (a === 0 && !isOverwrite) continue;
+        finalCol = (a << 24 | baseColor) >>> 0;
+      }
+      data32[idx] = blendFn(finalCol, data32[idx]);
+    }
+  }
+}
 
-// src/History/PixelMutator/mutatorApplyMask.ts
-function mutatorApplyMask(writer) {
+// src/History/PixelMutator/mutatorApplyRectBrush.ts
+var defaults6 = {
+  applyRectBrushToPixelData,
+  getRectBrushOrPencilBounds
+};
+var mutatorApplyRectBrush = ((writer, deps = defaults6) => {
+  const {
+    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults6.applyRectBrushToPixelData,
+    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults6.getRectBrushOrPencilBounds
+  } = deps;
+  const boundsOut = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
   return {
-    applyMask: (mask, opts = {}) => {
-      let target = writer.target;
+    applyRectBrush(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn) {
+      const bounds = getRectBrushOrPencilBounds2(centerX, centerY, brushWidth, brushHeight, writer.target.width, writer.target.height, boundsOut);
       const {
-        x = 0,
-        y = 0,
-        w = writer.target.width,
-        h = writer.target.height
-      } = opts;
+        x,
+        y,
+        w,
+        h
+      } = bounds;
       writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      applyMaskToPixelData(target, mask, opts);
+      applyRectBrushToPixelData2(writer.target, color, centerX, centerY, brushWidth, brushHeight, alpha, fallOff, blendFn, bounds);
     }
   };
+});
+
+// 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 defaults7 = {
+  forEachLinePoint,
+  blendColorPixelDataAlphaMask,
+  getRectBrushOrPencilBounds,
+  getRectBrushOrPencilStrokeBounds
+};
+var mutatorApplyRectBrushStroke = ((writer, deps = defaults7) => {
+  const {
+    forEachLinePoint: forEachLinePoint2 = defaults7.forEachLinePoint,
+    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults7.blendColorPixelDataAlphaMask,
+    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults7.getRectBrushOrPencilBounds,
+    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults7.getRectBrushOrPencilStrokeBounds
+  } = 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
+  };
+  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;
+      const mask = new Uint8Array(bw * bh);
+      const halfW = brushWidth / 2;
+      const halfH = brushHeight / 2;
+      const invHalfW = 1 / halfW;
+      const invHalfH = 1 / halfH;
+      const centerOffsetX = brushWidth % 2 === 0 ? 0.5 : 0;
+      const centerOffsetY = brushHeight % 2 === 0 ? 0.5 : 0;
+      const targetWidth = writer.target.width;
+      const targetHeight = writer.target.height;
+      forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
+        const {
+          x: rbx,
+          y: rby,
+          w: rbw,
+          h: rbh
+        } = getRectBrushOrPencilBounds2(px, py, brushWidth, brushHeight, targetWidth, targetHeight, rectBrushBounds);
+        writer.accumulator.storeRegionBeforeState(rbx, rby, rbw, rbh);
+        const startX = Math.max(bx, rbx);
+        const startY = Math.max(by, rby);
+        const endX = Math.min(bx + bw, rbx + rbw);
+        const endY = Math.min(by + bh, rby + rbh);
+        const fPx = Math.floor(px);
+        const fPy = Math.floor(py);
+        for (let my = startY; my < endY; my++) {
+          const dy = Math.abs(my - fPy + centerOffsetY) * invHalfH;
+          const maskRowOffset = (my - by) * bw;
+          for (let mx = startX; mx < endX; mx++) {
+            const dx = Math.abs(mx - fPx + centerOffsetX) * invHalfW;
+            const maskIdx = maskRowOffset + (mx - bx);
+            const dist = dx > dy ? dx : dy;
+            const strength = fallOff(dist);
+            if (strength > 0) {
+              const intensity = strength * 255 | 0;
+              if (intensity > mask[maskIdx]) {
+                mask[maskIdx] = intensity;
+              }
+            }
+          }
+        }
+      });
+      blendColorPixelOptions.blendFn = blendFn;
+      blendColorPixelOptions.alpha = alpha;
+      blendColorPixelOptions.x = bx;
+      blendColorPixelOptions.y = by;
+      blendColorPixelOptions.w = bw;
+      blendColorPixelOptions.h = bh;
+      blendColorPixelDataAlphaMask2(writer.target, color, mask, blendColorPixelOptions);
+    }
+  };
+});
+
+// src/History/PixelMutator/mutatorApplyRectPencil.ts
+var defaults8 = {
+  applyRectBrushToPixelData,
+  getRectBrushOrPencilBounds,
+  fallOff: () => 1
+};
+var mutatorApplyRectPencil = ((writer, deps = defaults8) => {
+  const {
+    applyRectBrushToPixelData: applyRectBrushToPixelData2 = defaults8.applyRectBrushToPixelData,
+    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults8.getRectBrushOrPencilBounds,
+    fallOff = defaults8.fallOff
+  } = deps;
+  const boundsOut = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  return {
+    applyRectPencil(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, blendFn) {
+      const bounds = getRectBrushOrPencilBounds2(centerX, centerY, brushWidth, brushHeight, writer.target.width, writer.target.height, boundsOut);
+      const {
+        x,
+        y,
+        w,
+        h
+      } = bounds;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      applyRectBrushToPixelData2(writer.target, color, centerX, centerY, brushWidth, brushHeight, alpha, fallOff, blendFn, bounds);
+    }
+  };
+});
+
+// src/History/PixelMutator/mutatorApplyRectPencilStroke.ts
+var defaults9 = {
+  forEachLinePoint,
+  getRectBrushOrPencilBounds,
+  getRectBrushOrPencilStrokeBounds,
+  blendColorPixelDataBinaryMask
+};
+var mutatorApplyRectPencilStroke = ((writer, deps = defaults9) => {
+  const {
+    forEachLinePoint: forEachLinePoint2 = defaults9.forEachLinePoint,
+    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults9.blendColorPixelDataBinaryMask,
+    getRectBrushOrPencilBounds: getRectBrushOrPencilBounds2 = defaults9.getRectBrushOrPencilBounds,
+    getRectBrushOrPencilStrokeBounds: getRectBrushOrPencilStrokeBounds2 = defaults9.getRectBrushOrPencilStrokeBounds
+  } = 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
+  };
+  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;
+      const mask = new Uint8Array(bw * bh);
+      const halfW = brushWidth / 2;
+      const halfH = brushHeight / 2;
+      const centerOffset = brushWidth % 2 === 0 ? 0.5 : 0;
+      const targetWidth = writer.target.width;
+      const targetHeight = writer.target.height;
+      forEachLinePoint2(x0, y0, x1, y1, (px, py) => {
+        const {
+          x: rbx,
+          y: rby,
+          w: rbw,
+          h: rbh
+        } = getRectBrushOrPencilBounds2(px, py, brushWidth, brushHeight, targetWidth, targetHeight, rectPencilBounds);
+        writer.accumulator.storeRegionBeforeState(rbx, rby, rbw, rbh);
+        const startX = Math.max(bx, rbx);
+        const startY = Math.max(by, rby);
+        const endX = Math.min(bx + bw, rbx + rbw);
+        const endY = Math.min(by + bh, rby + rbh);
+        const fPx = Math.floor(px);
+        const fPy = Math.floor(py);
+        for (let my = startY; my < endY; my++) {
+          const dy = Math.abs(my - fPy + centerOffset);
+          const maskRowOffset = (my - by) * bw;
+          for (let mx = startX; mx < endX; mx++) {
+            const dx = Math.abs(mx - fPx + centerOffset);
+            const maskIdx = maskRowOffset + (mx - bx);
+            if (dx <= halfW && dy <= halfH) {
+              mask[maskIdx] = 1;
+            }
+          }
+        }
+      });
+      blendColorPixelOptions.blendFn = blendFn;
+      blendColorPixelOptions.alpha = alpha;
+      blendColorPixelOptions.x = bx;
+      blendColorPixelOptions.y = by;
+      blendColorPixelOptions.w = bw;
+      blendColorPixelOptions.h = bh;
+      blendColorPixelDataBinaryMask2(writer.target, color, mask, blendColorPixelOptions);
+    }
+  };
+});
+
 // src/PixelData/blendColorPixelData.ts
 function blendColorPixelData(dst, color, opts = {}) {
   const {
@@ -1912,22 +2869,13 @@ function blendColorPixelData(dst, color, opts = {}) {
     w: width = dst.width,
     h: height = dst.height,
     alpha: globalAlpha = 255,
-    blendFn = sourceOverFast,
-    mask,
-    maskType = 0 /* ALPHA */,
-    mw,
-    mx = 0,
-    my = 0,
-    invertMask = false
+    blendFn = sourceOverPerfect
   } = opts;
   if (globalAlpha === 0) return;
   const baseSrcAlpha = color >>> 24;
-  const isOverwrite = blendFn.isOverwrite;
+  const isOverwrite = blendFn.isOverwrite || false;
   if (baseSrcAlpha === 0 && !isOverwrite) return;
-  let x = targetX;
-  let y = targetY;
-  let w = width;
-  let h = height;
+  let x = targetX, y = targetY, w = width, h = height;
   if (x < 0) {
     w += x;
     x = 0;
@@ -1939,76 +2887,33 @@ function blendColorPixelData(dst, color, opts = {}) {
   const actualW = Math.min(w, dst.width - x);
   const actualH = Math.min(h, dst.height - y);
   if (actualW <= 0 || actualH <= 0) return;
+  let finalSrcColor = color;
+  if (globalAlpha < 255) {
+    const a = baseSrcAlpha * globalAlpha + 128 >> 8;
+    if (a === 0 && !isOverwrite) return;
+    finalSrcColor = (color & 16777215 | a << 24) >>> 0;
+  }
   const dst32 = dst.data32;
   const dw = dst.width;
-  const mPitch = mw ?? width;
-  const isAlphaMask = maskType === 0 /* ALPHA */;
-  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;
+  let dIdx = y * dw + x | 0;
+  const dStride = dw - actualW | 0;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
-      let weight = globalAlpha;
-      if (mask) {
-        const mVal = mask[mIdx];
-        if (isAlphaMask) {
-          const effectiveM = invertMask ? 255 - mVal : mVal;
-          if (effectiveM === 0) {
-            dIdx++;
-            mIdx++;
-            continue;
-          }
-          if (globalAlpha === 255) {
-            weight = effectiveM;
-          } else if (effectiveM === 255) {
-            weight = globalAlpha;
-          } else {
-            weight = effectiveM * globalAlpha + 128 >> 8;
-          }
-        } else {
-          const isHit = invertMask ? mVal === 0 : mVal === 1;
-          if (!isHit) {
-            dIdx++;
-            mIdx++;
-            continue;
-          }
-          weight = globalAlpha;
-        }
-        if (weight === 0) {
-          dIdx++;
-          mIdx++;
-          continue;
-        }
-      }
-      let currentSrcColor = color;
-      if (weight < 255) {
-        let currentSrcAlpha = baseSrcAlpha;
-        if (baseSrcAlpha === 255) {
-          currentSrcAlpha = weight;
-        } else {
-          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
-        }
-        if (!isOverwrite && currentSrcAlpha === 0) {
-          dIdx++;
-          mIdx++;
-          continue;
-        }
-        currentSrcColor = (color & 16777215 | currentSrcAlpha << 24) >>> 0;
-      }
-      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
+      dst32[dIdx] = blendFn(finalSrcColor, dst32[dIdx]);
       dIdx++;
-      mIdx++;
     }
     dIdx += dStride;
-    mIdx += mStride;
   }
 }
 
 // src/History/PixelMutator/mutatorBlendColor.ts
-function mutatorBlendColor(writer) {
+var defaults10 = {
+  blendColorPixelData
+};
+var mutatorBlendColor = ((writer, deps = defaults10) => {
+  const {
+    blendColorPixelData: blendColorPixelData2 = defaults10.blendColorPixelData
+  } = deps;
   return {
     blendColor(color, opts = {}) {
       const {
@@ -2018,10 +2923,10 @@ function mutatorBlendColor(writer) {
         h = writer.target.height
       } = opts;
       writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      blendColorPixelData(writer.target, color, opts);
+      blendColorPixelData2(writer.target, color, opts);
     }
   };
-}
+});
 
 // src/History/PixelMutator/mutatorBlendPixel.ts
 function mutatorBlendPixel(writer) {
@@ -2055,13 +2960,7 @@ function blendPixelData(dst, src, opts) {
     w: width = src.width,
     h: height = src.height,
     alpha: globalAlpha = 255,
-    blendFn = sourceOverFast,
-    mask,
-    maskType = 0 /* ALPHA */,
-    mw,
-    mx = 0,
-    my = 0,
-    invertMask = false
+    blendFn = sourceOverPerfect
   } = opts;
   if (globalAlpha === 0) return;
   let x = targetX;
@@ -2099,91 +2998,48 @@ function blendPixelData(dst, src, opts) {
   const src32 = src.data32;
   const dw = dst.width;
   const sw = src.width;
-  const mPitch = mw ?? width;
-  const isAlphaMask = maskType === 0 /* ALPHA */;
-  const dx = x - targetX;
-  const dy = y - targetY;
-  let dIdx = y * dw + x;
-  let sIdx = sy * sw + sx;
-  let mIdx = (my + dy) * mPitch + (mx + dx);
-  const dStride = dw - actualW;
-  const sStride = sw - actualW;
-  const mStride = mPitch - actualW;
+  let dIdx = y * dw + x | 0;
+  let sIdx = sy * sw + sx | 0;
+  const dStride = dw - actualW | 0;
+  const sStride = sw - actualW | 0;
+  const isOpaque = globalAlpha === 255;
   const isOverwrite = blendFn.isOverwrite;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
-      const baseSrcColor = src32[sIdx];
-      const baseSrcAlpha = baseSrcColor >>> 24;
-      if (baseSrcAlpha === 0 && !isOverwrite) {
+      const srcCol = src32[sIdx];
+      const srcAlpha = srcCol >>> 24;
+      if (srcAlpha === 0 && !isOverwrite) {
         dIdx++;
         sIdx++;
-        mIdx++;
         continue;
       }
-      let weight = globalAlpha;
-      if (mask) {
-        const mVal = mask[mIdx];
-        if (isAlphaMask) {
-          const effectiveM = invertMask ? 255 - mVal : mVal;
-          if (effectiveM === 0) {
-            dIdx++;
-            sIdx++;
-            mIdx++;
-            continue;
-          }
-          if (globalAlpha === 255) {
-            weight = effectiveM;
-          } else if (effectiveM === 255) {
-            weight = globalAlpha;
-          } else {
-            weight = effectiveM * globalAlpha + 128 >> 8;
-          }
-        } else {
-          const isHit = invertMask ? mVal === 0 : mVal === 1;
-          if (!isHit) {
-            dIdx++;
-            sIdx++;
-            mIdx++;
-            continue;
-          }
-          weight = globalAlpha;
-        }
-        if (weight === 0) {
-          dIdx++;
-          sIdx++;
-          mIdx++;
-          continue;
-        }
-      }
-      let currentSrcColor = baseSrcColor;
-      if (weight < 255) {
-        let currentSrcAlpha = baseSrcAlpha;
-        if (baseSrcAlpha === 255) {
-          currentSrcAlpha = weight;
-        } else {
-          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
-        }
-        if (!isOverwrite && currentSrcAlpha === 0) {
+      let finalCol = srcCol;
+      if (!isOpaque) {
+        const a = srcAlpha * globalAlpha + 128 >> 8;
+        if (a === 0 && !isOverwrite) {
           dIdx++;
           sIdx++;
-          mIdx++;
           continue;
         }
-        currentSrcColor = (baseSrcColor & 16777215 | currentSrcAlpha << 24) >>> 0;
+        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
       }
-      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
+      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
       dIdx++;
       sIdx++;
-      mIdx++;
     }
     dIdx += dStride;
     sIdx += sStride;
-    mIdx += mStride;
   }
 }
 
 // src/History/PixelMutator/mutatorBlendPixelData.ts
-function mutatorBlendPixelData(writer) {
+var defaults11 = {
+  blendPixelData
+};
+var mutatorBlendPixelData = ((writer, deps = defaults11) => {
+  const {
+    blendPixelData: blendPixelData2 = defaults11.blendPixelData
+  } = deps;
   return {
     blendPixelData(src, opts) {
       const {
@@ -2193,12 +3049,13 @@ function mutatorBlendPixelData(writer) {
         h = src.height
       } = opts;
       writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      blendPixelData(writer.target, src, opts);
+      blendPixelData2(writer.target, src, opts);
     }
   };
-}
+});
 
 // src/PixelData/fillPixelData.ts
+var SCRATCH_RECT = makeClippedRect();
 function fillPixelData(dst, color, _x, _y, _w, _h) {
   let x;
   let y;
@@ -2220,34 +3077,57 @@ function fillPixelData(dst, color, _x, _y, _w, _h) {
     w = dst.width;
     h = dst.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;
-  }
+  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 && x === 0 && y === 0) {
+  if (actualW === dw && actualH === dst.height && finalX === 0 && finalY === 0) {
     dst32.fill(color);
     return;
   }
   for (let iy = 0; iy < actualH; iy++) {
-    const start = (y + iy) * dw + x;
+    const start = (finalY + iy) * dw + finalX;
     const end = start + actualW;
     dst32.fill(color, start, end);
   }
 }
 
-// src/History/PixelMutator/mutatorFillPixelData.ts
-function mutatorFill(writer) {
+// src/History/PixelMutator/mutatorClear.ts
+var defaults12 = {
+  fillPixelData
+};
+var mutatorClear = ((writer, deps = defaults12) => {
+  const {
+    fillPixelData: fillPixelData2 = defaults12.fillPixelData
+  } = deps;
+  return {
+    clear(rect = {}) {
+      const {
+        x = 0,
+        y = 0,
+        w = writer.target.width,
+        h = writer.target.height
+      } = rect;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      fillPixelData2(writer.target, 0, x, y, w, h);
+    }
+  };
+});
+
+// src/History/PixelMutator/mutatorFill.ts
+var defaults13 = {
+  fillPixelData
+};
+var mutatorFill = ((writer, deps = defaults13) => {
+  const {
+    fillPixelData: fillPixelData2 = defaults13.fillPixelData
+  } = deps;
   return {
     fill(color, rect = {}) {
       const {
@@ -2257,12 +3137,13 @@ function mutatorFill(writer) {
         h = writer.target.height
       } = rect;
       writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      fillPixelData(writer.target, color, x, y, w, h);
+      fillPixelData2(writer.target, color, x, y, w, h);
     }
   };
-}
+});
 
 // src/PixelData/invertPixelData.ts
+var SCRATCH_RECT2 = makeClippedRect();
 function invertPixelData(pixelData, opts = {}) {
   const dst = pixelData;
   const {
@@ -2276,21 +3157,14 @@ function invertPixelData(pixelData, opts = {}) {
     my = 0,
     invertMask = false
   } = opts;
-  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;
+  const clip = resolveRectClipping(targetX, targetY, width, height, dst.width, dst.height, SCRATCH_RECT2);
+  if (!clip.inBounds) return;
+  const {
+    x,
+    y,
+    w: actualW,
+    h: actualH
+  } = clip;
   const dst32 = dst.data32;
   const dw = dst.width;
   const mPitch = mw ?? width;
@@ -2326,7 +3200,13 @@ function invertPixelData(pixelData, opts = {}) {
 }
 
 // src/History/PixelMutator/mutatorInvert.ts
-function mutatorInvert(writer) {
+var defaults14 = {
+  invertPixelData
+};
+var mutatorInvert = ((writer, deps = defaults14) => {
+  const {
+    invertPixelData: invertPixelData2 = defaults14.invertPixelData
+  } = deps;
   return {
     invert(opts = {}) {
       const {
@@ -2336,44 +3216,121 @@ function mutatorInvert(writer) {
         h = writer.target.height
       } = opts;
       writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      invertPixelData(writer.target, opts);
+      invertPixelData2(writer.target, opts);
     }
   };
-}
+});
 
 // src/History/PixelMutator.ts
 function makeFullPixelMutator(writer) {
   return {
-    ...mutatorApplyMask(writer),
+    ...mutatorApplyAlphaMask(writer),
+    ...mutatorApplyBinaryMask(writer),
     ...mutatorBlendPixelData(writer),
     ...mutatorBlendColor(writer),
     ...mutatorBlendPixel(writer),
     ...mutatorFill(writer),
-    ...mutatorInvert(writer)
+    ...mutatorInvert(writer),
+    ...mutatorApplyCircleBrush(writer),
+    ...mutatorApplyCircleBrushStroke(writer),
+    ...mutatorApplyCirclePencilStroke(writer),
+    ...mutatorApplyRectBrush(writer),
+    ...mutatorApplyRectBrushStroke(writer),
+    ...mutatorApplyRectPencil(writer),
+    ...mutatorApplyRectPencilStroke(writer),
+    ...mutatorClear(writer)
   };
 }
 
-// src/ImageData/ReusableImageData.ts
-function makeReusableImageData() {
-  let imageData = null;
-  let buffer = null;
-  return function getReusableImageData(width, height) {
-    const hasInstance = !!imageData;
-    const widthMatches = hasInstance && imageData.width === width;
-    const heightMatches = hasInstance && imageData.height === height;
-    if (!widthMatches || !heightMatches) {
-      const buffer2 = new Uint8ClampedArray(width * height * 4);
-      imageData = new ImageData(buffer2, width, height);
+// src/History/PixelWriter.ts
+var PixelWriter = class {
+  target;
+  historyManager;
+  accumulator;
+  config;
+  mutator;
+  constructor(target, mutatorFactory, {
+    tileSize = 256,
+    maxHistorySteps = 50,
+    historyManager = new HistoryManager(maxHistorySteps)
+  } = {}) {
+    this.target = target;
+    this.config = new PixelEngineConfig(tileSize);
+    this.historyManager = historyManager;
+    this.accumulator = new PixelAccumulator(target, this.config);
+    this.mutator = mutatorFactory(this);
+  }
+  withHistory(cb) {
+    cb(this.mutator);
+    this.captureHistory();
+  }
+  captureHistory() {
+    const beforeTiles = this.accumulator.beforeTiles;
+    if (beforeTiles.length === 0) return;
+    const afterTiles = this.accumulator.extractAfterTiles();
+    const patch = {
+      beforeTiles,
+      afterTiles
+    };
+    const target = this.target;
+    const tileSize = this.config.tileSize;
+    const accumulator = this.accumulator;
+    const action = {
+      undo: () => applyPatchTiles(target, patch.beforeTiles, tileSize),
+      redo: () => applyPatchTiles(target, patch.afterTiles, tileSize),
+      dispose: () => accumulator.recyclePatch(patch)
+    };
+    this.historyManager.commit(action);
+    this.accumulator.reset();
+  }
+};
+
+// src/History/PixelMutator/mutatorApplyCirclePencil.ts
+var defaults15 = {
+  applyCircleBrushToPixelData,
+  getCircleBrushOrPencilBounds,
+  fallOff: () => 1
+};
+var mutatorApplyCirclePencil = ((writer, deps = defaults15) => {
+  const {
+    applyCircleBrushToPixelData: applyCircleBrushToPixelData2 = defaults15.applyCircleBrushToPixelData,
+    getCircleBrushOrPencilBounds: getCircleBrushOrPencilBounds2 = defaults15.getCircleBrushOrPencilBounds,
+    fallOff = defaults15.fallOff
+  } = deps;
+  const boundsOut = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  return {
+    applyCirclePencil(color, centerX, centerY, brushSize, alpha = 255, 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);
     }
-    return imageData;
   };
-}
+});
 
 // src/ImageData/copyImageData.ts
-function copyImageData({ data, width, height }) {
+function copyImageData({
+  data,
+  width,
+  height
+}) {
   return new ImageData(data.slice(), width, height);
 }
-function copyImageDataLike({ data, width, height }) {
+function copyImageDataLike({
+  data,
+  width,
+  height
+}) {
   return {
     data: data.slice(),
     width,
@@ -2381,20 +3338,15 @@ function copyImageDataLike({ data, width, height }) {
   };
 }
 
-// src/PixelData/pixelDataToAlphaMask.ts
-function pixelDataToAlphaMask(pixelData) {
-  const {
-    data32,
+// src/ImageData/ImageDataLike.ts
+function makeImageDataLike(width, height, data) {
+  const size = width * height * 4;
+  const buffer = data ? new Uint8ClampedArray(data.buffer, data.byteOffset, size) : new Uint8ClampedArray(size);
+  return {
     width,
-    height
-  } = pixelData;
-  const len = data32.length;
-  const mask = new Uint8Array(width * height);
-  for (let i = 0; i < len; i++) {
-    const val = data32[i];
-    mask[i] = val >>> 24 & 255;
-  }
-  return mask;
+    height,
+    data: buffer
+  };
 }
 
 // src/ImageData/imageDataToAlphaMask.ts
@@ -2404,11 +3356,7 @@ function imageDataToAlphaMask(imageData) {
     height,
     data
   } = imageData;
-  const data32 = new Uint32Array(
-    data.buffer,
-    data.byteOffset,
-    data.byteLength >> 2
-  );
+  const data32 = new Uint32Array(data.buffer, data.byteOffset, data.byteLength >> 2);
   const len = data32.length;
   const mask = new Uint8Array(width * height);
   for (let i = 0; i < len; i++) {
@@ -2421,7 +3369,10 @@ function imageDataToAlphaMask(imageData) {
 // src/ImageData/imageDataToDataUrl.ts
 var get = makeReusableCanvas();
 function imageDataToDataUrl(imageData) {
-  const { canvas, ctx } = get(imageData.width, imageData.height);
+  const {
+    canvas,
+    ctx
+  } = get(imageData.width, imageData.height);
   ctx.putImageData(imageData, 0, 0);
   return canvas.toDataURL();
 }
@@ -2479,7 +3430,11 @@ function resample32(srcData32, srcW, srcH, factor) {
 // src/ImageData/resampleImageData.ts
 function resampleImageData(source, factor) {
   const src32 = new Uint32Array(source.data.buffer);
-  const { data, width, height } = resample32(src32, source.width, source.height, factor);
+  const {
+    data,
+    width,
+    height
+  } = resample32(src32, source.width, source.height, factor);
   const uint8ClampedArray = new Uint8ClampedArray(data.buffer);
   return new ImageData(uint8ClampedArray, width, height);
 }
@@ -2508,14 +3463,25 @@ function resizeImageData(current, newWidth, newHeight, offsetX = 0, offsetY = 0)
     const srcX = x0 - offsetX;
     const dstStart = (dstY * newWidth + x0) * 4;
     const srcStart = (srcY * oldW + srcX) * 4;
-    newData.set(
-      oldData.subarray(srcStart, srcStart + rowLen),
-      dstStart
-    );
+    newData.set(oldData.subarray(srcStart, srcStart + rowLen), dstStart);
   }
   return result;
 }
 
+// src/ImageData/ReusableImageData.ts
+function makeReusableImageData() {
+  let imageData = null;
+  return function getReusableImageData(width, height) {
+    const hasInstance = !!imageData;
+    const widthMatches = hasInstance && imageData.width === width;
+    const heightMatches = hasInstance && imageData.height === height;
+    if (!widthMatches || !heightMatches) {
+      imageData = new ImageData(width, height);
+    }
+    return imageData;
+  };
+}
+
 // src/ImageData/serialization.ts
 function base64EncodeArrayBuffer(buffer) {
   const uint8 = new Uint8Array(buffer);
@@ -2558,32 +3524,53 @@ function deserializeNullableImageData(serialized) {
   return deserializeImageData(serialized);
 }
 
+// src/ImageData/uInt32ArrayToImageData.ts
+function uInt32ArrayToImageData(data, width, height) {
+  const buffer = data.buffer;
+  const byteOffset = data.byteOffset;
+  const byteLength = data.byteLength;
+  const clampedArray = new Uint8ClampedArray(buffer, byteOffset, byteLength);
+  return new ImageData(clampedArray, width, height);
+}
+function uInt32ArrayToImageDataLike(data, width, height) {
+  const buffer = data.buffer;
+  const byteOffset = data.byteOffset;
+  const byteLength = data.byteLength;
+  const clampedArray = new Uint8ClampedArray(buffer, byteOffset, byteLength);
+  return {
+    width,
+    height,
+    data: clampedArray
+  };
+}
+
 // src/ImageData/writeImageData.ts
+var SCRATCH_BLIT2 = makeClippedBlit();
 function writeImageData(target, source, x, y, sx = 0, sy = 0, sw = source.width, sh = source.height, mask = null, maskType = 1 /* BINARY */) {
   const dstW = target.width;
   const dstH = target.height;
   const dstData = target.data;
   const srcW = source.width;
   const srcData = source.data;
-  const x0 = Math.max(0, x);
-  const y0 = Math.max(0, y);
-  const x1 = Math.min(dstW, x + sw);
-  const y1 = Math.min(dstH, y + sh);
-  if (x1 <= x0 || y1 <= y0) {
-    return;
-  }
+  const clip = resolveBlitClipping(x, y, sx, sy, sw, sh, dstW, dstH, srcW, source.height, SCRATCH_BLIT2);
+  if (!clip.inBounds) return;
+  const {
+    x: dstX,
+    y: dstY,
+    sx: srcX,
+    sy: srcY,
+    w: copyW,
+    h: copyH
+  } = clip;
   const useMask = !!mask;
-  const rowCount = y1 - y0;
-  const rowLenPixels = x1 - x0;
-  for (let row = 0; row < rowCount; row++) {
-    const dstY = y0 + row;
-    const srcY = sy + (dstY - y);
-    const srcXBase = sx + (x0 - x);
-    const dstStart = (dstY * dstW + x0) * 4;
-    const srcStart = (srcY * srcW + srcXBase) * 4;
+  for (let row = 0; row < copyH; row++) {
+    const currentDstY = dstY + row;
+    const currentSrcY = srcY + row;
+    const dstStart = (currentDstY * dstW + dstX) * 4;
+    const srcStart = (currentSrcY * srcW + srcX) * 4;
     if (useMask && mask) {
-      for (let ix = 0; ix < rowLenPixels; ix++) {
-        const mi = srcY * srcW + (srcXBase + ix);
+      for (let ix = 0; ix < copyW; ix++) {
+        const mi = currentSrcY * srcW + (srcX + ix);
         const alpha = mask[mi];
         if (alpha === 0) {
           continue;
@@ -2605,7 +3592,7 @@ function writeImageData(target, source, x, y, sx = 0, sy = 0, sw = source.width,
         }
       }
     } else {
-      const byteLen = rowLenPixels * 4;
+      const byteLen = copyW * 4;
       const sub = srcData.subarray(srcStart, srcStart + byteLen);
       dstData.set(sub, dstStart);
     }
@@ -2613,24 +3600,52 @@ 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) {
-  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
-  const { width: dstW, height: dstH, data: dst } = imageData;
-  const x0 = Math.max(0, x);
-  const y0 = Math.max(0, y);
-  const x1 = Math.min(dstW, x + w);
-  const y1 = Math.min(dstH, y + h);
-  if (x1 <= x0 || y1 <= y0) return;
-  const rowLen = (x1 - x0) * 4;
-  const srcCol = x0 - x;
-  const srcYOffset = y0 - y;
-  const actualH = y1 - y0;
-  for (let row = 0; row < actualH; row++) {
-    const dstStart = ((y0 + row) * dstW + x0) * 4;
-    const srcRow = srcYOffset + row;
-    const o = (srcRow * w + srcCol) * 4;
-    dst.set(data.subarray(o, o + rowLen), dstStart);
+  const {
+    x,
+    y,
+    w,
+    h
+  } = typeof _x === "object" ? _x : {
+    x: _x,
+    y: _y,
+    w: _w,
+    h: _h
+  };
+  const {
+    width: dstW,
+    height: dstH,
+    data: dst
+  } = imageData;
+  const clip = resolveBlitClipping(x, y, 0, 0, w, h, dstW, dstH, w, h, SCRATCH_BLIT3);
+  if (!clip.inBounds) return;
+  const {
+    x: dstX,
+    y: dstY,
+    sx: srcX,
+    sy: srcY,
+    w: copyW,
+    h: copyH
+  } = clip;
+  const rowLen = copyW * 4;
+  for (let row = 0; row < copyH; row++) {
+    const dstStart = ((dstY + row) * dstW + dstX) * 4;
+    const srcStart = ((srcY + row) * w + srcX) * 4;
+    dst.set(data.subarray(srcStart, srcStart + rowLen), dstStart);
+  }
+}
+
+// src/IndexedImage/getIndexedImageColorCounts.ts
+function getIndexedImageColorCounts(indexedImage) {
+  const data = indexedImage.data;
+  const palette = indexedImage.palette;
+  const frequencies = new Int32Array(palette.length);
+  for (let i = 0; i < data.length; i++) {
+    const colorIndex = data[i];
+    frequencies[colorIndex]++;
   }
+  return frequencies;
 }
 
 // src/IndexedImage/IndexedImage.ts
@@ -2696,13 +3711,7 @@ var IndexedImage = class _IndexedImage {
       indexedData[i] = id;
     }
     const palette = Uint32Array.from(colorMap.keys());
-    return new _IndexedImage(
-      width,
-      height,
-      indexedData,
-      palette,
-      transparentPalletIndex
-    );
+    return new _IndexedImage(width, height, indexedData, palette, transparentPalletIndex);
   }
   /**
    * Retrieves the 32-bit packed color value at the given coordinates.
@@ -2717,21 +3726,13 @@ var IndexedImage = class _IndexedImage {
   }
 };
 
-// src/IndexedImage/getIndexedImageColorCounts.ts
-function getIndexedImageColorCounts(indexedImage) {
-  const data = indexedImage.data;
-  const palette = indexedImage.palette;
-  const frequencies = new Int32Array(palette.length);
-  for (let i = 0; i < data.length; i++) {
-    const colorIndex = data[i];
-    frequencies[colorIndex]++;
-  }
-  return frequencies;
-}
-
 // src/IndexedImage/indexedImageToAverageColor.ts
 function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
-  const { data, palette, transparentPalletIndex } = indexedImage;
+  const {
+    data,
+    palette,
+    transparentPalletIndex
+  } = indexedImage;
   const counts = new Uint32Array(palette.length);
   for (let i = 0; i < data.length; i++) {
     const id = data[i];
@@ -2771,26 +3772,14 @@ function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
   return packColor(r, g, b, a);
 }
 
-// src/IndexedImage/resampleIndexedImage.ts
-function resampleIndexedImage(source, factor) {
-  const { data, width, height } = resample32(
-    source.data,
-    source.width,
-    source.height,
-    factor
-  );
-  return new IndexedImage(
+// src/IndexedImage/indexedImageToImageData.ts
+function indexedImageToImageData(indexedImage) {
+  const {
     width,
     height,
     data,
-    source.palette,
-    source.transparentPalletIndex
-  );
-}
-
-// src/IndexedImage/indexedImageToImageData.ts
-function indexedImageToImageData(indexedImage) {
-  const { width, height, data, palette } = indexedImage;
+    palette
+  } = indexedImage;
   const result = new ImageData(width, height);
   const data32 = new Uint32Array(result.data.buffer);
   for (let i = 0; i < data.length; i++) {
@@ -2801,6 +3790,16 @@ function indexedImageToImageData(indexedImage) {
   return result;
 }
 
+// src/IndexedImage/resampleIndexedImage.ts
+function resampleIndexedImage(source, factor) {
+  const {
+    data,
+    width,
+    height
+  } = resample32(source.data, source.width, source.height, factor);
+  return new IndexedImage(width, height, data, source.palette, source.transparentPalletIndex);
+}
+
 // src/Input/fileInputChangeToImageData.ts
 async function fileInputChangeToImageData(event) {
   const target = event.target;
@@ -2824,23 +3823,11 @@ async function fileToImageData(file) {
   let bitmap = null;
   try {
     bitmap = await createImageBitmap(file);
-    const canvas = new OffscreenCanvas(
-      bitmap.width,
-      bitmap.height
-    );
+    const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
     const ctx = canvas.getContext("2d");
     if (!ctx) throw new Error(OFFSCREEN_CANVAS_CTX_FAILED);
-    ctx.drawImage(
-      bitmap,
-      0,
-      0
-    );
-    return ctx.getImageData(
-      0,
-      0,
-      bitmap.width,
-      bitmap.height
-    );
+    ctx.drawImage(bitmap, 0, 0);
+    return ctx.getImageData(0, 0, bitmap.width, bitmap.height);
   } finally {
     bitmap?.close();
   }
@@ -2848,32 +3835,23 @@ async function fileToImageData(file) {
 
 // src/Input/getSupportedRasterFormats.ts
 var formatsPromise = null;
-var defaultRasterMimes = [
-  "image/png",
-  "image/jpeg",
-  "image/webp",
-  "image/avif",
-  "image/gif",
-  "image/bmp"
-];
+var defaultRasterMimes = ["image/png", "image/jpeg", "image/webp", "image/avif", "image/gif", "image/bmp"];
 async function getSupportedPixelFormats(rasterMimes = defaultRasterMimes) {
   if (formatsPromise) {
     return formatsPromise;
   }
   const probeCanvas = async () => {
     const canvas = new OffscreenCanvas(1, 1);
-    const results = await Promise.all(
-      rasterMimes.map(async (mime) => {
-        try {
-          const blob = await canvas.convertToBlob({
-            type: mime
-          });
-          return blob.type === mime ? mime : null;
-        } catch {
-          return null;
-        }
-      })
-    );
+    const results = await Promise.all(rasterMimes.map(async (mime) => {
+      try {
+        const blob = await canvas.convertToBlob({
+          type: mime
+        });
+        return blob.type === mime ? mime : null;
+      } catch {
+        return null;
+      }
+    }));
     return results.filter((type) => {
       return type !== null;
     });
@@ -2885,6 +3863,73 @@ async function getSupportedPixelFormats(rasterMimes = defaultRasterMimes) {
   return formatsPromise;
 }
 
+// src/Mask/applyBinaryMaskToAlphaMask.ts
+function applyBinaryMaskToAlphaMask(alphaMaskDst, dstWidth, binaryMaskSrc, srcWidth, opts = {}) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: reqWidth = 0,
+    h: reqHeight = 0,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (dstWidth <= 0) return;
+  if (binaryMaskSrc.length === 0) return;
+  if (srcWidth <= 0) return;
+  const dstHeight = alphaMaskDst.length / dstWidth | 0;
+  const srcHeight = binaryMaskSrc.length / srcWidth | 0;
+  if (dstHeight <= 0) return;
+  if (srcHeight <= 0) return;
+  const dstX0 = Math.max(0, targetX);
+  const dstY0 = Math.max(0, targetY);
+  const dstX1 = reqWidth > 0 ? Math.min(dstWidth, targetX + reqWidth) : dstWidth;
+  const dstY1 = reqHeight > 0 ? Math.min(dstHeight, targetY + reqHeight) : dstHeight;
+  if (dstX0 >= dstX1) return;
+  if (dstY0 >= dstY1) return;
+  const srcX0 = mx + (dstX0 - targetX);
+  const srcY0 = my + (dstY0 - targetY);
+  if (srcX0 >= srcWidth) return;
+  if (srcY0 >= srcHeight) return;
+  if (srcX0 + (dstX1 - dstX0) <= 0) return;
+  if (srcY0 + (dstY1 - dstY0) <= 0) return;
+  const iterW = Math.min(dstX1 - dstX0, srcWidth - srcX0);
+  const iterH = Math.min(dstY1 - dstY0, srcHeight - srcY0);
+  let dstIdx = dstY0 * dstWidth + dstX0;
+  let srcIdx = srcY0 * srcWidth + srcX0;
+  if (invertMask) {
+    for (let row = 0; row < iterH; row++) {
+      const dstEnd = dstIdx + iterW;
+      let d = dstIdx;
+      let s = srcIdx;
+      while (d < dstEnd) {
+        if (binaryMaskSrc[s] !== 0) {
+          alphaMaskDst[d] = 0;
+        }
+        d++;
+        s++;
+      }
+      dstIdx += dstWidth;
+      srcIdx += srcWidth;
+    }
+  } else {
+    for (let row = 0; row < iterH; row++) {
+      const dstEnd = dstIdx + iterW;
+      let d = dstIdx;
+      let s = srcIdx;
+      while (d < dstEnd) {
+        if (binaryMaskSrc[s] === 0) {
+          alphaMaskDst[d] = 0;
+        }
+        d++;
+        s++;
+      }
+      dstIdx += dstWidth;
+      srcIdx += srcWidth;
+    }
+  }
+}
+
 // src/Mask/copyMask.ts
 function copyMask(src) {
   return src.slice();
@@ -2904,69 +3949,124 @@ function invertAlphaMask(dst) {
   }
 }
 
-// src/Mask/mergeMasks.ts
-function mergeMasks(dst, dstWidth, src, opts) {
+// src/Mask/mergeAlphaMasks.ts
+function mergeAlphaMasks(dst, dstWidth, src, srcWidth, opts) {
   const {
     x: targetX = 0,
     y: targetY = 0,
     w: width = 0,
     h: height = 0,
     alpha: globalAlpha = 255,
-    maskType = 0 /* ALPHA */,
-    mw,
     mx = 0,
     my = 0,
     invertMask = false
   } = opts;
-  if (width <= 0 || height <= 0 || globalAlpha === 0) {
-    return;
+  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 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);
+  if (startX >= endX) return;
+  if (startY >= endY) return;
+  for (let iy = startY; iy < endY; iy++) {
+    const dy = targetY + iy;
+    const sy = my + iy;
+    let dIdx = dy * dstWidth + targetX + startX;
+    let sIdx = sy * srcWidth + mx + startX;
+    for (let ix = startX; ix < endX; ix++) {
+      const rawM = src[sIdx];
+      const effectiveM = invertMask ? 255 - rawM : rawM;
+      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 !== 255) {
+        if (weight === 0) {
+          dst[dIdx] = 0;
+        } else {
+          const da = dst[dIdx];
+          if (da === 255) {
+            dst[dIdx] = weight;
+          } else if (da !== 0) {
+            dst[dIdx] = da * weight + 128 >> 8;
+          }
+        }
+      }
+      sIdx++;
+      dIdx++;
+    }
+  }
+}
+
+// src/Mask/mergeBinaryMasks.ts
+function mergeBinaryMasks(dst, dstWidth, src, srcWidth, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = 0,
+    h: height = 0,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  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;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
   }
-  const sPitch = mw ?? width;
-  const isAlpha = maskType === 0 /* ALPHA */;
-  for (let iy = 0; iy < height; iy++) {
-    const dy = targetY + iy;
-    const sy = my + iy;
-    if (dy < 0 || sy < 0) {
-      continue;
-    }
-    for (let ix = 0; ix < width; ix++) {
-      const dx = targetX + ix;
-      const sx = mx + ix;
-      if (dx < 0 || dx >= dstWidth || sx < 0 || sx >= sPitch) {
-        continue;
-      }
-      const dIdx = dy * dstWidth + dx;
-      const sIdx = sy * sPitch + sx;
+  w = Math.min(w, dstWidth - x);
+  h = Math.min(h, dstHeight - y);
+  if (w <= 0) return;
+  if (h <= 0) return;
+  const startX = mx + (x - targetX);
+  const startY = my + (y - targetY);
+  const sX0 = Math.max(0, startX);
+  const sY0 = Math.max(0, startY);
+  const sX1 = Math.min(srcWidth, startX + w);
+  const sY1 = Math.min(srcHeight, startY + h);
+  const finalW = sX1 - sX0;
+  const finalH = sY1 - sY0;
+  if (finalW <= 0) return;
+  if (finalH <= 0) return;
+  const xShift = sX0 - startX;
+  const yShift = sY0 - startY;
+  const dStride = dstWidth - finalW;
+  const sStride = srcWidth - finalW;
+  let dIdx = (y + yShift) * dstWidth + (x + xShift);
+  let sIdx = sY0 * srcWidth + sX0;
+  for (let iy = 0; iy < finalH; iy++) {
+    for (let ix = 0; ix < finalW; ix++) {
       const mVal = src[sIdx];
-      let weight = globalAlpha;
-      if (isAlpha) {
-        const effectiveM = invertMask ? 255 - mVal : mVal;
-        if (effectiveM === 0) {
-          dst[dIdx] = 0;
-          continue;
-        }
-        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
-      } else {
-        const isHit = invertMask ? mVal === 0 : mVal === 1;
-        if (!isHit) {
-          dst[dIdx] = 0;
-          continue;
-        }
-        weight = globalAlpha;
-      }
-      if (weight === 0) {
+      const isMaskedOut = invertMask ? mVal !== 0 : mVal === 0;
+      if (isMaskedOut) {
         dst[dIdx] = 0;
-        continue;
-      }
-      const da = dst[dIdx];
-      if (da === 0) {
-      } else if (weight === 255) {
-      } else if (da === 255) {
-        dst[dIdx] = weight;
-      } else {
-        dst[dIdx] = da * weight + 128 >> 8;
       }
+      dIdx++;
+      sIdx++;
     }
+    dIdx += dStride;
+    sIdx += sStride;
   }
 }
 
@@ -2974,118 +4074,258 @@ function mergeMasks(dst, dstWidth, src, opts) {
 var PixelData = class _PixelData {
   data32;
   imageData;
-  get width() {
-    return this.imageData.width;
-  }
-  get height() {
-    return this.imageData.height;
-  }
+  width;
+  height;
   constructor(imageData) {
     this.data32 = imageDataToUInt32Array(imageData);
     this.imageData = imageData;
+    this.width = imageData.width;
+    this.height = imageData.height;
   }
   set(imageData) {
+    ;
     this.imageData = imageData;
     this.data32 = imageDataToUInt32Array(imageData);
+    this.width = imageData.width;
+    this.height = imageData.height;
   }
-  /**
-   * Creates a deep copy of the PixelData using the environment's ImageData constructor.
-   */
+  // should only be used for debug and testing
   copy() {
-    const buffer = new Uint8ClampedArray(this.imageData.data);
-    const ImageConstructor = typeof ImageData !== "undefined" ? ImageData : this.imageData.constructor;
-    const newImageData = new ImageConstructor(
-      buffer,
-      this.width,
-      this.height
-    );
+    const data = this.imageData.data;
+    const buffer = new Uint8ClampedArray(data);
+    const Ctor = this.imageData.constructor;
+    const isCtorValid = typeof Ctor === "function";
+    let newImageData;
+    if (isCtorValid && Ctor !== Object) {
+      const ImageConstructor = Ctor;
+      newImageData = new ImageConstructor(buffer, this.width, this.height);
+    } else {
+      newImageData = {
+        width: this.width,
+        height: this.height,
+        data: buffer
+      };
+    }
     return new _PixelData(newImageData);
   }
 };
 
-// src/PixelData/applyCircleBrushToPixelData.ts
-function applyCircleBrushToPixelData(target, color, centerX, centerY, brushSize, alpha = 255, fallOff, blendFn = sourceOverPerfect) {
-  const r = brushSize / 2;
-  const rSqr = r * r;
-  const centerOffset = brushSize % 2 === 0 ? 0.5 : 0;
-  const xStart = Math.max(0, Math.ceil(centerX - r));
-  const xEnd = Math.min(target.width - 1, Math.floor(centerX + r));
-  const yStart = Math.max(0, Math.ceil(centerY - r));
-  const yEnd = Math.min(target.height - 1, Math.floor(centerY + r));
-  const data32 = target.data32;
-  const targetWidth = target.width;
-  const baseColor = color & 16777215;
-  const invR = 1 / r;
-  const constantSrc = (alpha << 24 | baseColor) >>> 0;
-  for (let cy = yStart; cy <= yEnd; cy++) {
-    const dy = cy - centerY + centerOffset;
-    const dySqr = dy * dy;
-    const rowOffset = cy * targetWidth;
-    for (let cx = xStart; cx <= xEnd; cx++) {
-      const dx = cx - centerX + centerOffset;
-      const dSqr = dx * dx + dySqr;
-      if (dSqr <= rSqr) {
-        const idx = rowOffset + cx;
-        if (fallOff) {
-          const strength = fallOff(Math.sqrt(dSqr) * invR);
-          const fAlpha = alpha * strength & 255;
-          const src = (fAlpha << 24 | baseColor) >>> 0;
-          data32[idx] = blendFn(src, data32[idx]);
-        } else {
-          data32[idx] = blendFn(constantSrc, data32[idx]);
+// 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,
+    mw = src.width,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (globalAlpha === 0) return;
+  let x = targetX;
+  let y = targetY;
+  let sx = sourceX;
+  let sy = sourceY;
+  let w = width;
+  let h = height;
+  if (sx < 0) {
+    x -= sx;
+    w += sx;
+    sx = 0;
+  }
+  if (sy < 0) {
+    y -= sy;
+    h += sy;
+    sy = 0;
+  }
+  w = Math.min(w, src.width - sx);
+  h = Math.min(h, src.height - sy);
+  if (x < 0) {
+    sx -= x;
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    sy -= y;
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) return;
+  const dw = dst.width;
+  const sw = src.width;
+  const mPitch = mw;
+  const dx = x - targetX | 0;
+  const dy = y - targetY | 0;
+  const dst32 = dst.data32;
+  const src32 = src.data32;
+  let dIdx = y * dw + x | 0;
+  let sIdx = sy * sw + sx | 0;
+  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
+  const dStride = dw - actualW | 0;
+  const sStride = sw - actualW | 0;
+  const mStride = mPitch - actualW | 0;
+  const isOpaque = globalAlpha === 255;
+  const isOverwrite = blendFn.isOverwrite || false;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      const mVal = alphaMask[mIdx];
+      const effM = invertMask ? 255 - mVal : mVal;
+      if (effM === 0) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
+      }
+      const srcCol = src32[sIdx];
+      const srcAlpha = srcCol >>> 24;
+      if (srcAlpha === 0 && !isOverwrite) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
+      }
+      let weight = globalAlpha;
+      if (isOpaque) {
+        weight = effM;
+      } else if (effM !== 255) {
+        weight = effM * globalAlpha + 128 >> 8;
+      }
+      if (weight === 0) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
+      }
+      let finalCol = srcCol;
+      if (weight < 255) {
+        const a = srcAlpha * weight + 128 >> 8;
+        if (a === 0 && !isOverwrite) {
+          dIdx++;
+          sIdx++;
+          mIdx++;
+          continue;
         }
+        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
       }
+      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
+      dIdx++;
+      sIdx++;
+      mIdx++;
     }
+    dIdx += dStride;
+    sIdx += sStride;
+    mIdx += mStride;
   }
 }
 
-// src/PixelData/applyRectBrushToPixelData.ts
-function applyRectBrushToPixelData(target, color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn = sourceOverPerfect) {
-  const targetWidth = target.width;
-  const targetHeight = target.height;
-  const data32 = target.data32;
-  const rawStartX = Math.floor(centerX - brushWidth / 2);
-  const rawStartY = Math.floor(centerY - brushHeight / 2);
-  const endX = Math.min(targetWidth, rawStartX + brushWidth);
-  const endY = Math.min(targetHeight, rawStartY + brushHeight);
-  const startX = Math.max(0, rawStartX);
-  const startY = Math.max(0, rawStartY);
-  const baseColor = color & 16777215;
-  const constantSrc = (alpha << 24 | baseColor) >>> 0;
-  const invHalfW = 1 / (brushWidth / 2);
-  const invHalfH = 1 / (brushHeight / 2);
-  for (let py = startY; py < endY; py++) {
-    const rowOffset = py * targetWidth;
-    const dy = Math.abs(py + 0.5 - centerY) * invHalfH;
-    for (let px = startX; px < endX; px++) {
-      if (fallOff) {
-        const dx = Math.abs(px + 0.5 - centerX) * invHalfW;
-        const dist = dx > dy ? dx : dy;
-        const fAlpha = alpha * fallOff(dist) | 0;
-        const src = (fAlpha << 24 | baseColor) >>> 0;
-        data32[rowOffset + px] = blendFn(src, data32[rowOffset + px]);
-      } else {
-        data32[rowOffset + px] = blendFn(constantSrc, data32[rowOffset + px]);
+// 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,
+    mw = src.width,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (globalAlpha === 0) return;
+  let x = targetX;
+  let y = targetY;
+  let sx = sourceX;
+  let sy = sourceY;
+  let w = width;
+  let h = height;
+  if (sx < 0) {
+    x -= sx;
+    w += sx;
+    sx = 0;
+  }
+  if (sy < 0) {
+    y -= sy;
+    h += sy;
+    sy = 0;
+  }
+  w = Math.min(w, src.width - sx);
+  h = Math.min(h, src.height - sy);
+  if (x < 0) {
+    sx -= x;
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    sy -= y;
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) return;
+  const dx = x - targetX | 0;
+  const dy = y - targetY | 0;
+  const dst32 = dst.data32;
+  const src32 = src.data32;
+  const dw = dst.width;
+  const sw = src.width;
+  const mPitch = mw;
+  let dIdx = y * dw + x | 0;
+  let sIdx = sy * sw + sx | 0;
+  let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
+  const dStride = dw - actualW | 0;
+  const sStride = sw - actualW | 0;
+  const mStride = mPitch - actualW | 0;
+  const skipVal = invertMask ? 1 : 0;
+  const isOpaque = globalAlpha === 255;
+  const isOverwrite = blendFn.isOverwrite || false;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      if (binaryMask[mIdx] === skipVal) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
+      }
+      const srcCol = src32[sIdx];
+      const srcAlpha = srcCol >>> 24;
+      if (srcAlpha === 0 && !isOverwrite) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
       }
+      let finalCol = srcCol;
+      if (!isOpaque) {
+        const a = srcAlpha * globalAlpha + 128 >> 8;
+        if (a === 0 && !isOverwrite) {
+          dIdx++;
+          sIdx++;
+          mIdx++;
+          continue;
+        }
+        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
+      }
+      dst32[dIdx] = blendFn(finalCol, dst32[dIdx]);
+      dIdx++;
+      sIdx++;
+      mIdx++;
     }
+    dIdx += dStride;
+    sIdx += sStride;
+    mIdx += mStride;
   }
 }
-function getRectBrushBounds(centerX, centerY, brushWidth, brushHeight, targetWidth, targetHeight) {
-  const rawStartX = Math.floor(centerX - brushWidth / 2);
-  const rawStartY = Math.floor(centerY - brushHeight / 2);
-  const rawEndX = rawStartX + brushWidth;
-  const rawEndY = rawStartY + brushHeight;
-  const startX = targetWidth !== void 0 ? Math.max(0, rawStartX) : rawStartX;
-  const startY = targetHeight !== void 0 ? Math.max(0, rawStartY) : rawStartY;
-  const endX = targetWidth !== void 0 ? Math.min(targetWidth, rawEndX) : rawEndX;
-  const endY = targetHeight !== void 0 ? Math.min(targetHeight, rawEndY) : rawEndY;
-  return {
-    x: startX,
-    y: startY,
-    w: endX - startX,
-    h: endY - startY
-  };
-}
 
 // src/PixelData/clearPixelData.ts
 function clearPixelData(dst, rect) {
@@ -3093,32 +4333,40 @@ function clearPixelData(dst, rect) {
 }
 
 // src/PixelData/extractPixelDataBuffer.ts
+var SCRATCH_BLIT4 = makeClippedBlit();
 function extractPixelDataBuffer(source, _x, _y, _w, _h) {
-  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
+  const {
+    x,
+    y,
+    w,
+    h
+  } = typeof _x === "object" ? _x : {
+    x: _x,
+    y: _y,
+    w: _w,
+    h: _h
+  };
   const srcW = source.width;
   const srcH = source.height;
   const srcData = source.data32;
   if (w <= 0 || h <= 0) {
     return new Uint32Array(0);
   }
-  const dstImageData = new ImageData(w, h);
-  const dstData = new Uint32Array(dstImageData.data.buffer);
-  const x0 = Math.max(0, x);
-  const y0 = Math.max(0, y);
-  const x1 = Math.min(srcW, x + w);
-  const y1 = Math.min(srcH, y + h);
-  if (x1 <= x0 || y1 <= y0) {
-    return dstData;
-  }
-  const copyWidth = x1 - x0;
-  const copyHeight = y1 - y0;
-  for (let row = 0; row < copyHeight; row++) {
-    const srcRow = y0 + row;
-    const srcStart = srcRow * srcW + x0;
-    const dstRow = y0 - y + row;
-    const dstCol = x0 - x;
-    const dstStart = dstRow * w + dstCol;
-    const chunk = srcData.subarray(srcStart, srcStart + copyWidth);
+  const dstData = new Uint32Array(w * h);
+  const clip = resolveBlitClipping(0, 0, x, y, w, h, w, h, srcW, srcH, SCRATCH_BLIT4);
+  if (!clip.inBounds) return dstData;
+  const {
+    x: dstX,
+    y: dstY,
+    sx: srcX,
+    sy: srcY,
+    w: copyW,
+    h: copyH
+  } = clip;
+  for (let row = 0; row < copyH; row++) {
+    const srcStart = (srcY + row) * srcW + srcX;
+    const dstStart = (dstY + row) * w + dstX;
+    const chunk = srcData.subarray(srcStart, srcStart + copyW);
     dstData.set(chunk, dstStart);
   }
   return dstData;
@@ -3126,13 +4374,59 @@ function extractPixelDataBuffer(source, _x, _y, _w, _h) {
 
 // src/PixelData/extractPixelData.ts
 function extractPixelData(source, _x, _y, _w, _h) {
-  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
+  const {
+    x,
+    y,
+    w,
+    h
+  } = typeof _x === "object" ? _x : {
+    x: _x,
+    y: _y,
+    w: _w,
+    h: _h
+  };
   const result = new PixelData(new ImageData(w, h));
   const buffer = extractPixelDataBuffer(source, x, y, w, h);
   result.data32.set(buffer);
   return result;
 }
 
+// src/PixelData/PixelBuffer32.ts
+var PixelBuffer32 = class _PixelBuffer32 {
+  constructor(width, height, data32) {
+    this.width = width;
+    this.height = height;
+    this.data32 = data32 ?? new Uint32Array(width * height);
+  }
+  data32;
+  set(width, height, data32) {
+    ;
+    this.data32 = data32 ?? new Uint32Array(width * height);
+    this.width = width;
+    this.height = height;
+  }
+  copy() {
+    const newData32 = new Uint32Array(this.data32);
+    return new _PixelBuffer32(this.width, this.height, newData32);
+  }
+};
+
+// src/PixelData/pixelDataToAlphaMask.ts
+function pixelDataToAlphaMask(pixelData) {
+  const {
+    data32,
+    width,
+    height
+  } = pixelData;
+  const len = data32.length;
+  const mask = new Uint8Array(width * height);
+  for (let i = 0; i < len; i++) {
+    const val = data32[i];
+    mask[i] = val >>> 24 & 255;
+  }
+  return mask;
+}
+
 // src/PixelData/reflectPixelData.ts
 function reflectPixelDataHorizontal(pixelData) {
   const width = pixelData.width;
@@ -3170,12 +4464,12 @@ function reflectPixelDataVertical(pixelData) {
 
 // src/PixelData/resamplePixelData.ts
 function resamplePixelData(pixelData, factor) {
-  const { data, width, height } = resample32(pixelData.data32, pixelData.width, pixelData.height, factor);
-  return new PixelData(new ImageData(
-    new Uint8ClampedArray(data.buffer),
+  const {
+    data,
     width,
     height
-  ));
+  } = resample32(pixelData.data32, pixelData.width, pixelData.height, factor);
+  return new PixelData(new ImageData(new Uint8ClampedArray(data.buffer), width, height));
 }
 
 // src/PixelData/rotatePixelData.ts
@@ -3199,11 +4493,7 @@ function rotatePixelData(pixelData) {
       newData32[newIdx] = data[oldIdx];
     }
   }
-  const newImageData = new ImageData(
-    new Uint8ClampedArray(newData32.buffer),
-    newWidth,
-    newHeight
-  );
+  const newImageData = new ImageData(new Uint8ClampedArray(newData32.buffer), newWidth, newHeight);
   pixelData.set(newImageData);
 }
 function rotateSquareInPlace(pixelData) {
@@ -3225,8 +4515,14 @@ function rotateSquareInPlace(pixelData) {
 }
 
 // src/PixelData/writePixelDataBuffer.ts
+var SCRATCH_BLIT5 = makeClippedBlit();
 function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
-  const { x, y, w, h } = typeof _x === "object" ? _x : {
+  const {
+    x,
+    y,
+    w,
+    h
+  } = typeof _x === "object" ? _x : {
     x: _x,
     y: _y,
     w: _w,
@@ -3235,45 +4531,52 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   const dstW = target.width;
   const dstH = target.height;
   const dstData = target.data32;
-  const x0 = Math.max(0, x);
-  const y0 = Math.max(0, y);
-  const x1 = Math.min(dstW, x + w);
-  const y1 = Math.min(dstH, y + h);
-  if (x1 <= x0 || y1 <= y0) {
-    return;
-  }
-  const rowLen = x1 - x0;
-  const srcCol = x0 - x;
-  const srcYOffset = y0 - y;
-  const actualH = y1 - y0;
-  for (let row = 0; row < actualH; row++) {
-    const dstStart = (y0 + row) * dstW + x0;
-    const srcRow = srcYOffset + row;
-    const srcStart = srcRow * w + srcCol;
-    dstData.set(data.subarray(srcStart, srcStart + rowLen), dstStart);
+  const clip = resolveBlitClipping(x, y, 0, 0, w, h, dstW, dstH, w, h, SCRATCH_BLIT5);
+  if (!clip.inBounds) return;
+  const {
+    x: dstX,
+    y: dstY,
+    sx: srcX,
+    sy: srcY,
+    w: copyW,
+    h: copyH
+  } = clip;
+  for (let row = 0; row < copyH; row++) {
+    const dstStart = (dstY + row) * dstW + dstX;
+    const srcStart = (srcY + row) * w + srcX;
+    dstData.set(data.subarray(srcStart, srcStart + copyW), dstStart);
   }
 }
 export {
   BASE_FAST_BLEND_MODE_FUNCTIONS,
   BASE_PERFECT_BLEND_MODE_FUNCTIONS,
   BaseBlendMode,
+  CANVAS_CTX_FAILED,
   HistoryManager,
   IndexedImage,
   MaskType,
+  OFFSCREEN_CANVAS_CTX_FAILED,
   PixelAccumulator,
+  PixelBuffer32,
   PixelData,
   PixelEngineConfig,
   PixelTile,
   PixelWriter,
   UnsupportedFormatError,
+  applyAlphaMaskToPixelData,
+  applyBinaryMaskToAlphaMask,
+  applyBinaryMaskToPixelData,
   applyCircleBrushToPixelData,
-  applyMaskToPixelData,
   applyPatchTiles,
   applyRectBrushToPixelData,
   base64DecodeArrayBuffer,
   base64EncodeArrayBuffer,
   blendColorPixelData,
+  blendColorPixelDataAlphaMask,
+  blendColorPixelDataBinaryMask,
   blendPixelData,
+  blendPixelDataAlphaMask,
+  blendPixelDataBinaryMask,
   clearPixelData,
   color32ToCssRGBA,
   color32ToHex,
@@ -3306,9 +4609,13 @@ export {
   fileToImageData,
   fillPixelData,
   floodFillSelection,
+  forEachLinePoint,
+  getCircleBrushOrPencilBounds,
+  getCircleBrushOrPencilStrokeBounds,
   getImageDataFromClipboard,
   getIndexedImageColorCounts,
-  getRectBrushBounds,
+  getRectBrushOrPencilBounds,
+  getRectBrushOrPencilStrokeBounds,
   getSupportedPixelFormats,
   hardLightFast,
   hardLightPerfect,
@@ -3340,17 +4647,29 @@ export {
   makeBlendModeRegistry,
   makeFastBlendModeRegistry,
   makeFullPixelMutator,
+  makeImageDataLike,
   makePerfectBlendModeRegistry,
   makePixelCanvas,
   makeReusableCanvas,
   makeReusableImageData,
-  mergeMasks,
+  mergeAlphaMasks,
+  mergeBinaryMasks,
   multiplyFast,
   multiplyPerfect,
-  mutatorApplyMask,
+  mutatorApplyAlphaMask,
+  mutatorApplyBinaryMask,
+  mutatorApplyCircleBrush,
+  mutatorApplyCircleBrushStroke,
+  mutatorApplyCirclePencil,
+  mutatorApplyCirclePencilStroke,
+  mutatorApplyRectBrush,
+  mutatorApplyRectBrushStroke,
+  mutatorApplyRectPencil,
+  mutatorApplyRectPencilStroke,
   mutatorBlendColor,
   mutatorBlendPixel,
   mutatorBlendPixelData,
+  mutatorClear,
   mutatorFill,
   mutatorInvert,
   overlayFast,
@@ -3380,7 +4699,10 @@ export {
   sourceOverPerfect,
   subtractFast,
   subtractPerfect,
+  toBlendModeIndexAndName,
   trimRectBounds,
+  uInt32ArrayToImageData,
+  uInt32ArrayToImageDataLike,
   unpackAlpha,
   unpackBlue,
   unpackColor,