pixel-data-js 0.26.0 → 0.28.0

package/dist/index.prod.js

@@ -1,9 +1,17 @@
-// src/_types.ts
-var MaskType = /* @__PURE__ */ ((MaskType2) => {
-  MaskType2[MaskType2["ALPHA"] = 0] = "ALPHA";
-  MaskType2[MaskType2["BINARY"] = 1] = "BINARY";
-  return MaskType2;
-})(MaskType || {});
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/Internal/_errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  CANVAS_CTX_FAILED: () => CANVAS_CTX_FAILED,
+  OFFSCREEN_CANVAS_CTX_FAILED: () => OFFSCREEN_CANVAS_CTX_FAILED
+});
+var OFFSCREEN_CANVAS_CTX_FAILED = "Failed to create OffscreenCanvas context";
+var CANVAS_CTX_FAILED = "Failed to create Canvas context";
 
 // src/color.ts
 function packColor(r, g, b, a) {
@@ -78,7 +86,7 @@ function color32ToCssRGBA(color) {
   return `rgba(${r},${g},${b},${alpha})`;
 }
 
-// src/Internal/resolveClipping.ts
+// src/Rect/resolveClipping.ts
 var makeClippedRect = () => ({
   x: 0,
   y: 0,
@@ -196,6 +204,13 @@ function extractImageDataBuffer(imageData, _x, _y, _w, _h) {
   return out;
 }
 
+// src/Mask/_mask-types.ts
+var MaskType = /* @__PURE__ */ ((MaskType2) => {
+  MaskType2[MaskType2["ALPHA"] = 0] = "ALPHA";
+  MaskType2[MaskType2["BINARY"] = 1] = "BINARY";
+  return MaskType2;
+})(MaskType || {});
+
 // src/Mask/extractMaskBuffer.ts
 function extractMaskBuffer(maskBuffer, maskWidth, xOrRect, y, w, h) {
   let finalX;
@@ -298,9 +313,9 @@ function trimMaskRectBounds(target, bounds) {
 
 // src/Algorithm/floodFillSelection.ts
 function floodFillSelection(target, startX, startY, contiguous = true, tolerance = 0, bounds, out) {
-  const data32 = target.data32;
-  const width = target.width;
-  const height = target.height;
+  const data32 = target.data;
+  const width = target.w;
+  const height = target.h;
   const lx = bounds?.x ?? 0;
   const ly = bounds?.y ?? 0;
   const lw = bounds?.w ?? width;
@@ -414,13 +429,13 @@ function floodFillSelection(target, startX, startY, contiguous = true, tolerance
 
 // 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) {
+  if (x0 === x1 && y0 === y1) {
     callback(x0, y0);
     return;
   }
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const steps = Math.max(Math.abs(dx), Math.abs(dy));
   const xInc = dx / steps;
   const yInc = dy / steps;
   let curX = x0;
@@ -432,6 +447,66 @@ function forEachLinePoint(x0, y0, x1, y1, callback) {
   }
 }
 
+// src/Algorithm/resampleUint32Array.ts
+function resampleUint32Array(srcData32, srcW, srcH, factor, out) {
+  const dstW = Math.max(1, srcW * factor | 0);
+  const dstH = Math.max(1, srcH * factor | 0);
+  const dstData = new Uint32Array(dstW * dstH);
+  const scaleX = srcW / dstW;
+  const scaleY = srcH / dstH;
+  for (let y = 0; y < dstH; y++) {
+    const srcY = Math.min(srcH - 1, y * scaleY | 0);
+    const srcRowOffset = srcY * srcW;
+    const dstRowOffset = y * dstW;
+    for (let x = 0; x < dstW; x++) {
+      const srcX = Math.min(srcW - 1, x * scaleX | 0);
+      dstData[dstRowOffset + x] = srcData32[srcRowOffset + srcX];
+    }
+  }
+  out = out ?? {};
+  out.data = dstData;
+  out.w = dstW;
+  out.h = dstH;
+  return out;
+}
+
+// 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,
+  sourceIn: 23,
+  sourceOut: 24,
+  sourceAtop: 25,
+  destinationOver: 26,
+  destinationIn: 27,
+  destinationOut: 28,
+  destinationAtop: 29,
+  xor: 30
+};
+var overwriteBase = (src, _dst) => src;
+overwriteBase.isOverwrite = true;
+
 // src/BlendModes/BlendModeRegistry.ts
 function makeBlendModeRegistry(blendModes, initialEntries, registryName = "anonymous") {
   const blendToName = /* @__PURE__ */ new Map();
@@ -471,37 +546,134 @@ function makeBlendModeRegistry(blendModes, initialEntries, registryName = "anony
   };
 }
 
-// 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/blend-modes-fast.ts
 var overwriteFast = overwriteBase;
+var sourceInFast = (src, dst) => {
+  const da = dst >>> 24 & 255;
+  if (da === 0) return 0;
+  if (da === 255) return src;
+  const sa = src >>> 24 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const r = sr * da >> 8;
+  const g = sg * da >> 8;
+  const b = sb * da >> 8;
+  const a = sa * da >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var sourceOutFast = (src, dst) => {
+  const da = dst >>> 24 & 255;
+  if (da === 255) return 0;
+  if (da === 0) return src;
+  const sa = src >>> 24 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const invDa = 255 - da;
+  const r = sr * invDa >> 8;
+  const g = sg * invDa >> 8;
+  const b = sb * invDa >> 8;
+  const a = sa * invDa >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var sourceAtopFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  const da = dst >>> 24 & 255;
+  if (da === 0) return 0;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const invSa = 255 - sa;
+  const r = sr * da + dr * invSa >> 8;
+  const g = sg * da + dg * invSa >> 8;
+  const b = sb * da + db * invSa >> 8;
+  return (da << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var destinationOverFast = (src, dst) => {
+  const da = dst >>> 24 & 255;
+  if (da === 255) return dst;
+  if (da === 0) return src;
+  const sa = src >>> 24 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const invDa = 255 - da;
+  const r = dr * 255 + sr * invDa >> 8;
+  const g = dg * 255 + sg * invDa >> 8;
+  const b = db * 255 + sb * invDa >> 8;
+  const a = da * 255 + sa * invDa >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var destinationInFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return 0;
+  if (sa === 255) return dst;
+  const da = dst >>> 24 & 255;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const r = dr * sa >> 8;
+  const g = dg * sa >> 8;
+  const b = db * sa >> 8;
+  const a = da * sa >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var destinationOutFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 255) return 0;
+  if (sa === 0) return dst;
+  const da = dst >>> 24 & 255;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const invSa = 255 - sa;
+  const r = dr * invSa >> 8;
+  const g = dg * invSa >> 8;
+  const b = db * invSa >> 8;
+  const a = da * invSa >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var destinationAtopFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return 0;
+  const da = dst >>> 24 & 255;
+  if (da === 0) return 0;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const invDa = 255 - da;
+  const r = dr * sa + sr * invDa >> 8;
+  const g = dg * sa + sg * invDa >> 8;
+  const b = db * sa + sb * invDa >> 8;
+  return (sa << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var xorFast = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  const da = dst >>> 24 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const invDa = 255 - da;
+  const invSa = 255 - sa;
+  const r = sr * invDa + dr * invSa >> 8;
+  const g = sg * invDa + dg * invSa >> 8;
+  const b = sb * invDa + db * invSa >> 8;
+  const a = sa * invDa + da * invSa >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
 var sourceOverFast = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 255) return src;
@@ -887,6 +1059,14 @@ var divideFast = (src, dst) => {
 };
 var BASE_FAST_BLEND_MODE_FUNCTIONS = {
   [BaseBlendMode.overwrite]: overwriteFast,
+  [BaseBlendMode.sourceIn]: sourceInFast,
+  [BaseBlendMode.sourceOut]: sourceOutFast,
+  [BaseBlendMode.sourceAtop]: sourceAtopFast,
+  [BaseBlendMode.destinationOver]: destinationOverFast,
+  [BaseBlendMode.destinationIn]: destinationInFast,
+  [BaseBlendMode.destinationOut]: destinationOutFast,
+  [BaseBlendMode.destinationAtop]: destinationAtopFast,
+  [BaseBlendMode.xor]: xorFast,
   [BaseBlendMode.sourceOver]: sourceOverFast,
   [BaseBlendMode.darken]: darkenFast,
   [BaseBlendMode.multiply]: multiplyFast,
@@ -916,115 +1096,271 @@ function makeFastBlendModeRegistry(name = "fast") {
 
 // src/BlendModes/blend-modes-perfect.ts
 var overwritePerfect = overwriteBase;
-var sourceOverPerfect = (src, dst) => {
-  const sa = src >>> 24 & 255;
-  if (sa === 255) return src;
-  if (sa === 0) return dst;
+var sourceInPerfect = (src, dst) => {
   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 invA = 255 - sa;
-  const tR = sr * sa + dr * invA;
+  if (da === 0) return 0;
+  if (da === 255) return src;
+  const sa = src >>> 24 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const tR = sr * da;
   const r = tR + 1 + (tR >> 8) >> 8;
-  const tG = sg * sa + dg * invA;
+  const tG = sg * da;
   const g = tG + 1 + (tG >> 8) >> 8;
-  const tB = sb * sa + db * invA;
+  const tB = sb * da;
   const b = tB + 1 + (tB >> 8) >> 8;
-  const tA = 255 * sa + da * invA;
+  const tA = sa * da;
   const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var darkenPerfect = (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;
+var sourceOutPerfect = (src, dst) => {
   const da = dst >>> 24 & 255;
-  const tR = br * sa + dr * invA;
+  if (da === 255) return 0;
+  if (da === 0) return src;
+  const sa = src >>> 24 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const invDa = 255 - da;
+  const tR = sr * invDa;
   const r = tR + 1 + (tR >> 8) >> 8;
-  const tG = bg * sa + dg * invA;
+  const tG = sg * invDa;
   const g = tG + 1 + (tG >> 8) >> 8;
-  const tB = bb * sa + db * invA;
+  const tB = sb * invDa;
   const b = tB + 1 + (tB >> 8) >> 8;
-  const tA = 255 * sa + da * invA;
+  const tA = sa * invDa;
   const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var multiplyPerfect = (src, dst) => {
+var sourceAtopPerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
+  const da = dst >>> 24 & 255;
+  if (da === 0) return 0;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
   const dr = dst & 255;
   const dg = dst >>> 8 & 255;
   const db = dst >>> 16 & 255;
+  const invSa = 255 - sa;
+  const tR = sr * da + dr * invSa;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = sg * da + dg * invSa;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = sb * da + db * invSa;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  return (da << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var destinationOverPerfect = (src, dst) => {
   const da = dst >>> 24 & 255;
+  if (da === 255) return dst;
+  if (da === 0) return src;
+  const sa = src >>> 24 & 255;
   const sr = src & 255;
   const sg = src >>> 8 & 255;
   const sb = src >>> 16 & 255;
-  const mR = sr * dr;
-  const br = mR + 1 + (mR >> 8) >> 8;
-  const mG = sg * dg;
-  const bg = mG + 1 + (mG >> 8) >> 8;
-  const mB = sb * db;
-  const bb = mB + 1 + (mB >> 8) >> 8;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const tR = br * sa + dr * invA;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const invDa = 255 - da;
+  const tR = dr * 255 + sr * invDa;
   const r = tR + 1 + (tR >> 8) >> 8;
-  const tG = bg * sa + dg * invA;
+  const tG = dg * 255 + sg * invDa;
   const g = tG + 1 + (tG >> 8) >> 8;
-  const tB = bb * sa + db * invA;
+  const tB = db * 255 + sb * invDa;
   const b = tB + 1 + (tB >> 8) >> 8;
-  const tA = 255 * sa + da * invA;
+  const tA = da * 255 + sa * invDa;
   const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var colorBurnPerfect = (src, dst) => {
+var destinationInPerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
-  if (sa === 0) return dst;
+  if (sa === 0) return 0;
+  if (sa === 255) return dst;
+  const da = dst >>> 24 & 255;
   const dr = dst & 255;
   const dg = dst >>> 8 & 255;
   const db = dst >>> 16 & 255;
-  const sr = src & 255;
-  const sg = src >>> 8 & 255;
-  const sb = src >>> 16 & 255;
-  const resR = dr === 255 ? 255 : sr === 0 ? 0 : 255 - ((255 - dr) * 255 / sr | 0);
-  const br = resR < 0 ? 0 : resR;
-  const resG = dg === 255 ? 255 : sg === 0 ? 0 : 255 - ((255 - dg) * 255 / sg | 0);
-  const bg = resG < 0 ? 0 : resG;
-  const resB = db === 255 ? 255 : sb === 0 ? 0 : 255 - ((255 - db) * 255 / sb | 0);
-  const bb = resB < 0 ? 0 : resB;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
-  const da = dst >>> 24 & 255;
-  const tR = br * sa + dr * invA;
+  const tR = dr * sa;
   const r = tR + 1 + (tR >> 8) >> 8;
-  const tG = bg * sa + dg * invA;
+  const tG = dg * sa;
   const g = tG + 1 + (tG >> 8) >> 8;
-  const tB = bb * sa + db * invA;
+  const tB = db * sa;
   const b = tB + 1 + (tB >> 8) >> 8;
-  const tA = 255 * sa + da * invA;
+  const tA = da * sa;
   const a = tA + 1 + (tA >> 8) >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var linearBurnPerfect = (src, dst) => {
+var destinationOutPerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
+  if (sa === 255) return 0;
   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 br = brU < 0 ? 0 : brU;
-  const bgU = dg + sg - 255;
-  const bg = bgU < 0 ? 0 : bgU;
-  const bbU = db + sb - 255;
-  const bb = bbU < 0 ? 0 : bbU;
-  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
-  const invA = 255 - sa;
+  const da = dst >>> 24 & 255;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const invSa = 255 - sa;
+  const tR = dr * invSa;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = dg * invSa;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = db * invSa;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = da * invSa;
+  const a = tA + 1 + (tA >> 8) >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var destinationAtopPerfect = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return 0;
+  const da = dst >>> 24 & 255;
+  if (da === 0) return 0;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const invDa = 255 - da;
+  const tR = dr * sa + sr * invDa;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = dg * sa + sg * invDa;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = db * sa + sb * invDa;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  return (sa << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var xorPerfect = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  const da = dst >>> 24 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const invDa = 255 - da;
+  const invSa = 255 - sa;
+  const tR = sr * invDa + dr * invSa;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = sg * invDa + dg * invSa;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = sb * invDa + db * invSa;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = sa * invDa + da * invSa;
+  const a = tA + 1 + (tA >> 8) >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var sourceOverPerfect = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 255) return src;
+  if (sa === 0) return dst;
+  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 invA = 255 - sa;
+  const tR = sr * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = sg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = sb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var darkenPerfect = (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 da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var multiplyPerfect = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const da = dst >>> 24 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const mR = sr * dr;
+  const br = mR + 1 + (mR >> 8) >> 8;
+  const mG = sg * dg;
+  const bg = mG + 1 + (mG >> 8) >> 8;
+  const mB = sb * db;
+  const bb = mB + 1 + (mB >> 8) >> 8;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var colorBurnPerfect = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255;
+  const dg = dst >>> 8 & 255;
+  const db = dst >>> 16 & 255;
+  const sr = src & 255;
+  const sg = src >>> 8 & 255;
+  const sb = src >>> 16 & 255;
+  const resR = dr === 255 ? 255 : sr === 0 ? 0 : 255 - ((255 - dr) * 255 / sr | 0);
+  const br = resR < 0 ? 0 : resR;
+  const resG = dg === 255 ? 255 : sg === 0 ? 0 : 255 - ((255 - dg) * 255 / sg | 0);
+  const bg = resG < 0 ? 0 : resG;
+  const resB = db === 255 ? 255 : sb === 0 ? 0 : 255 - ((255 - db) * 255 / sb | 0);
+  const bb = resB < 0 ? 0 : resB;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const da = dst >>> 24 & 255;
+  const tR = br * sa + dr * invA;
+  const r = tR + 1 + (tR >> 8) >> 8;
+  const tG = bg * sa + dg * invA;
+  const g = tG + 1 + (tG >> 8) >> 8;
+  const tB = bb * sa + db * invA;
+  const b = tB + 1 + (tB >> 8) >> 8;
+  const tA = 255 * sa + da * invA;
+  const a = tA + 1 + (tA >> 8) >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var linearBurnPerfect = (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 br = brU < 0 ? 0 : brU;
+  const bgU = dg + sg - 255;
+  const bg = bgU < 0 ? 0 : bgU;
+  const bbU = db + sb - 255;
+  const bb = bbU < 0 ? 0 : bbU;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
   const da = dst >>> 24 & 255;
   const tR = br * sa + dr * invA;
   const r = tR + 1 + (tR >> 8) >> 8;
@@ -1443,6 +1779,14 @@ var dividePerfect = (src, dst) => {
 };
 var BASE_PERFECT_BLEND_MODE_FUNCTIONS = {
   [BaseBlendMode.overwrite]: overwritePerfect,
+  [BaseBlendMode.sourceIn]: sourceInPerfect,
+  [BaseBlendMode.sourceOut]: sourceOutPerfect,
+  [BaseBlendMode.sourceAtop]: sourceAtopPerfect,
+  [BaseBlendMode.destinationOver]: destinationOverPerfect,
+  [BaseBlendMode.destinationIn]: destinationInPerfect,
+  [BaseBlendMode.destinationOut]: destinationOutPerfect,
+  [BaseBlendMode.destinationAtop]: destinationAtopPerfect,
+  [BaseBlendMode.xor]: xorPerfect,
   [BaseBlendMode.sourceOver]: sourceOverPerfect,
   [BaseBlendMode.darken]: darkenPerfect,
   [BaseBlendMode.multiply]: multiplyPerfect,
@@ -1505,9 +1849,23 @@ var getKeyByValue = (obj, value) => {
   }
 };
 
-// support/error-strings.ts
-var OFFSCREEN_CANVAS_CTX_FAILED = "Failed to create OffscreenCanvas context";
-var CANVAS_CTX_FAILED = "Failed to create Canvas context";
+// src/Canvas/canvas-blend-modes.ts
+var CANVAS_COMPOSITE_MAP = {
+  [BaseBlendMode.overwrite]: "copy",
+  [BaseBlendMode.sourceOver]: "source-over",
+  [BaseBlendMode.darken]: "darken",
+  [BaseBlendMode.multiply]: "multiply",
+  [BaseBlendMode.colorBurn]: "color-burn",
+  [BaseBlendMode.lighten]: "lighten",
+  [BaseBlendMode.screen]: "screen",
+  [BaseBlendMode.colorDodge]: "color-dodge",
+  [BaseBlendMode.linearDodge]: "lighter",
+  [BaseBlendMode.overlay]: "overlay",
+  [BaseBlendMode.softLight]: "soft-light",
+  [BaseBlendMode.hardLight]: "hard-light",
+  [BaseBlendMode.difference]: "difference",
+  [BaseBlendMode.exclusion]: "exclusion"
+};
 
 // src/Canvas/ReusableCanvas.ts
 function makeReusableCanvas() {
@@ -1560,37 +1918,38 @@ function makeReusableCanvasMeta(factory) {
 }
 
 // src/Canvas/CanvasFrameRenderer.ts
-var defaults = {
-  makeReusableCanvas
-};
-function makeCanvasFrameRenderer(deps = defaults) {
-  const {
-    makeReusableCanvas: makeReusableCanvas2 = defaults.makeReusableCanvas
-  } = deps;
-  const bufferCanvas = makeReusableCanvas2();
+function makeCanvasFrameRenderer(reusableCanvasFactory = makeReusableOffscreenCanvas) {
+  const bufferCanvas = reusableCanvasFactory();
   return function renderCanvasFrame(pixelCanvas, scale, getImageData, drawPixelLayer, drawScreenLayer) {
-    const {
-      canvas,
-      ctx
-    } = pixelCanvas;
-    const {
-      ctx: pxCtx,
-      canvas: pxCanvas
-    } = bufferCanvas(canvas.width, canvas.height);
+    const canvas = pixelCanvas.canvas;
+    const ctx = pixelCanvas.ctx;
+    const w = canvas.width;
+    const h = canvas.height;
+    const buffer = bufferCanvas(w, h);
     const img = getImageData();
     if (img) {
-      pxCtx.putImageData(img, 0, 0);
+      buffer.ctx.putImageData(img, 0, 0);
     }
-    drawPixelLayer?.(pxCtx);
+    drawPixelLayer?.(buffer.ctx);
     ctx.setTransform(1, 0, 0, 1, 0, 0);
-    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    ctx.clearRect(0, 0, w, h);
     ctx.setTransform(scale, 0, 0, scale, 0, 0);
-    ctx.drawImage(pxCanvas, 0, 0);
+    ctx.drawImage(buffer.canvas, 0, 0);
     ctx.setTransform(1, 0, 0, 1, 0, 0);
     drawScreenLayer?.(ctx, scale);
   };
 }
 
+// src/Canvas/CanvasPixelDataRenderer.ts
+function makeCanvasPixelDataRenderer(reusableCanvasFactory = makeReusableOffscreenCanvas) {
+  const bufferCanvas = reusableCanvasFactory();
+  return function drawPixelData(targetCtx, pixelData, x = 0, y = 0) {
+    const buffer = bufferCanvas(pixelData.w, pixelData.h);
+    buffer.ctx.putImageData(pixelData.imageData, 0, 0);
+    targetCtx.drawImage(buffer.canvas, x, y);
+  };
+}
+
 // src/Canvas/PixelCanvas.ts
 function makePixelCanvas(canvas) {
   const ctx = canvas.getContext("2d");
@@ -1607,24 +1966,6 @@ function makePixelCanvas(canvas) {
   };
 }
 
-// src/Canvas/canvas-blend-modes.ts
-var CANVAS_COMPOSITE_MAP = {
-  [BaseBlendMode.overwrite]: "copy",
-  [BaseBlendMode.sourceOver]: "source-over",
-  [BaseBlendMode.darken]: "darken",
-  [BaseBlendMode.multiply]: "multiply",
-  [BaseBlendMode.colorBurn]: "color-burn",
-  [BaseBlendMode.lighten]: "lighten",
-  [BaseBlendMode.screen]: "screen",
-  [BaseBlendMode.colorDodge]: "color-dodge",
-  [BaseBlendMode.linearDodge]: "lighter",
-  [BaseBlendMode.overlay]: "overlay",
-  [BaseBlendMode.softLight]: "soft-light",
-  [BaseBlendMode.hardLight]: "hard-light",
-  [BaseBlendMode.difference]: "difference",
-  [BaseBlendMode.exclusion]: "exclusion"
-};
-
 // src/ImageData/imgBlobToImageData.ts
 async function imgBlobToImageData(blob) {
   let bitmap = null;
@@ -1689,10 +2030,10 @@ function applyPatchTiles(target, tiles, tileSize) {
   for (let i = 0; i < tiles.length; i++) {
     const tile = tiles[i];
     if (!tile) continue;
-    const dst = target.data32;
-    const src = tile.data32;
-    const dstWidth = target.width;
-    const dstHeight = target.height;
+    const dst = target.data;
+    const src = tile.data;
+    const dstWidth = target.w;
+    const dstHeight = target.h;
     const startX = tile.tx * tileSize;
     const startY = tile.ty * tileSize;
     const copyWidth = Math.max(0, Math.min(tileSize, dstWidth - startX));
@@ -1787,17 +2128,17 @@ var HistoryManager = class {
 
 // src/History/PixelAccumulator.ts
 var PixelAccumulator = class {
-  constructor(config, tilePool) {
+  constructor(config, pixelTilePool) {
     this.config = config;
-    this.tilePool = tilePool;
+    this.pixelTilePool = pixelTilePool;
     this.lookup = [];
     this.beforeTiles = [];
   }
   lookup;
   beforeTiles;
   recyclePatch(patch) {
-    this.tilePool.releaseTiles(patch.beforeTiles);
-    this.tilePool.releaseTiles(patch.afterTiles);
+    this.pixelTilePool.releaseTiles(patch.beforeTiles);
+    this.pixelTilePool.releaseTiles(patch.afterTiles);
   }
   /**
    * @param x pixel x coordinate
@@ -1812,7 +2153,7 @@ var PixelAccumulator = class {
     let tile = this.lookup[id];
     let added = false;
     if (!tile) {
-      tile = this.tilePool.getTile(id, tx, ty);
+      tile = this.pixelTilePool.getTile(id, tx, ty);
       this.extractState(tile);
       this.lookup[id] = tile;
       this.beforeTiles.push(tile);
@@ -1822,7 +2163,7 @@ var PixelAccumulator = class {
       if (!didChange && added) {
         this.beforeTiles.pop();
         this.lookup[id] = void 0;
-        this.tilePool.releaseTile(tile);
+        this.pixelTilePool.releaseTile(tile);
       }
       return didChange;
     };
@@ -1846,7 +2187,7 @@ var PixelAccumulator = class {
         const id = ty * columns + tx;
         let tile = this.lookup[id];
         if (!tile) {
-          tile = this.tilePool.getTile(id, tx, ty);
+          tile = this.pixelTilePool.getTile(id, tx, ty);
           this.extractState(tile);
           this.lookup[id] = tile;
           this.beforeTiles.push(tile);
@@ -1860,7 +2201,7 @@ var PixelAccumulator = class {
           let t = this.beforeTiles[i];
           if (t) {
             this.lookup[t.id] = void 0;
-            this.tilePool.releaseTile(t);
+            this.pixelTilePool.releaseTile(t);
           }
         }
         this.beforeTiles.length = startIndex;
@@ -1872,7 +2213,7 @@ var PixelAccumulator = class {
     let tile = this.lookup[id];
     let added = false;
     if (!tile) {
-      tile = this.tilePool.getTile(id, tx, ty);
+      tile = this.pixelTilePool.getTile(id, tx, ty);
       this.extractState(tile);
       this.lookup[id] = tile;
       this.beforeTiles.push(tile);
@@ -1882,7 +2223,7 @@ var PixelAccumulator = class {
       if (!didChange && added) {
         this.beforeTiles.pop();
         this.lookup[id] = void 0;
-        this.tilePool.releaseTile(tile);
+        this.pixelTilePool.releaseTile(tile);
       }
       return didChange;
     };
@@ -1890,12 +2231,12 @@ var PixelAccumulator = class {
   extractState(tile) {
     const target = this.config.target;
     const TILE_SIZE = this.config.tileSize;
-    const dst = tile.data32;
-    const src = target.data32;
+    const dst = tile.data;
+    const src = target.data;
     const startX = tile.tx * TILE_SIZE;
     const startY = tile.ty * TILE_SIZE;
-    const targetWidth = target.width;
-    const targetHeight = target.height;
+    const targetWidth = target.w;
+    const targetHeight = target.h;
     if (startX >= targetWidth || startX + TILE_SIZE <= 0 || startY >= targetHeight || startY + TILE_SIZE <= 0) {
       dst.fill(0);
       return;
@@ -1926,7 +2267,7 @@ var PixelAccumulator = class {
     for (let i = 0; i < length; i++) {
       let beforeTile = this.beforeTiles[i];
       if (beforeTile) {
-        let afterTile = this.tilePool.getTile(beforeTile.id, beforeTile.tx, beforeTile.ty);
+        let afterTile = this.pixelTilePool.getTile(beforeTile.id, beforeTile.tx, beforeTile.ty);
         this.extractState(afterTile);
         afterTiles.push(afterTile);
       }
@@ -1948,7 +2289,7 @@ var PixelAccumulator = class {
       let tile = this.beforeTiles[i];
       if (tile) {
         this.lookup[tile.id] = void 0;
-        this.tilePool.releaseTile(tile);
+        this.pixelTilePool.releaseTile(tile);
       }
     }
     this.beforeTiles.length = 0;
@@ -1976,8 +2317,8 @@ var PixelEngineConfig = class {
     this.tileMask = tileSize - 1;
     this.tileArea = tileSize * tileSize;
     this.target = target;
-    this.targetColumns = target.width + this.tileMask >> this.tileShift;
-    this.targetRows = target.height + this.tileMask >> this.tileShift;
+    this.targetColumns = target.w + this.tileMask >> this.tileShift;
+    this.targetRows = target.h + this.tileMask >> this.tileShift;
   }
 };
 
@@ -1985,8 +2326,8 @@ var PixelEngineConfig = class {
 function applyAlphaMaskToPixelData(target, mask, opts) {
   const targetX = opts?.x ?? 0;
   const targetY = opts?.y ?? 0;
-  const width = opts?.w ?? target.width;
-  const height = opts?.h ?? target.height;
+  const width = opts?.w ?? target.w;
+  const height = opts?.h ?? target.h;
   const globalAlpha = opts?.alpha ?? 255;
   const mx = opts?.mx ?? 0;
   const my = opts?.my ?? 0;
@@ -2004,8 +2345,8 @@ function applyAlphaMaskToPixelData(target, mask, opts) {
     h += y;
     y = 0;
   }
-  w = Math.min(w, target.width - x);
-  h = Math.min(h, target.height - y);
+  w = Math.min(w, target.w - x);
+  h = Math.min(h, target.h - y);
   if (w <= 0) return false;
   if (h <= 0) return false;
   const mPitch = mask.w;
@@ -2022,49 +2363,82 @@ function applyAlphaMaskToPixelData(target, mask, opts) {
   if (finalH <= 0) return false;
   const xShift = sX0 - startX;
   const yShift = sY0 - startY;
-  const dst32 = target.data32;
-  const dw = target.width;
+  const dst32 = target.data;
+  const dw = target.w;
   const dStride = dw - finalW;
   const mStride = mPitch - finalW;
   const maskData = mask.data;
   let dIdx = (y + yShift) * dw + (x + xShift);
   let mIdx = sY0 * mPitch + sX0;
   let didChange = false;
-  for (let iy = 0; iy < h; iy++) {
-    for (let ix = 0; ix < w; ix++) {
-      const mVal = maskData[mIdx];
-      const effectiveM = invertMask ? 255 - mVal : mVal;
-      let weight = 0;
-      if (effectiveM === 0) {
-        weight = 0;
-      } else if (effectiveM === 255) {
-        weight = globalAlpha;
-      } else if (globalAlpha === 255) {
-        weight = effectiveM;
-      } else {
-        weight = effectiveM * globalAlpha + 128 >> 8;
+  if (invertMask) {
+    for (let iy = 0; iy < finalH; iy++) {
+      for (let ix = 0; ix < finalW; ix++) {
+        const effectiveM = 255 - maskData[mIdx];
+        if (effectiveM === 0) {
+          const current = dst32[dIdx];
+          const next = (current & 16777215) >>> 0;
+          if (current !== next) {
+            dst32[dIdx] = next;
+            didChange = true;
+          }
+        } else {
+          const t1 = effectiveM * globalAlpha + 128;
+          const weight = t1 + (t1 >> 8) >> 8;
+          if (weight < 255) {
+            const current = dst32[dIdx];
+            const da = current >>> 24;
+            if (da !== 0) {
+              const t2 = da * weight + 128;
+              const finalAlpha = t2 + (t2 >> 8) >> 8;
+              const next = (current & 16777215 | finalAlpha << 24) >>> 0;
+              if (current !== next) {
+                dst32[dIdx] = next;
+                didChange = true;
+              }
+            }
+          }
+        }
+        dIdx++;
+        mIdx++;
       }
-      if (weight === 0) {
-        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
-        didChange = true;
-      } else if (weight !== 255) {
-        const d = dst32[dIdx];
-        const da = d >>> 24;
-        if (da !== 0) {
-          const finalAlpha = da === 255 ? weight : da * weight + 128 >> 8;
+      dIdx += dStride;
+      mIdx += mStride;
+    }
+  } else {
+    for (let iy = 0; iy < finalH; iy++) {
+      for (let ix = 0; ix < finalW; ix++) {
+        const effectiveM = maskData[mIdx];
+        if (effectiveM === 0) {
           const current = dst32[dIdx];
-          const next = (d & 16777215 | finalAlpha << 24) >>> 0;
+          const next = (current & 16777215) >>> 0;
           if (current !== next) {
             dst32[dIdx] = next;
             didChange = true;
           }
+        } else {
+          const t1 = effectiveM * globalAlpha + 128;
+          const weight = t1 + (t1 >> 8) >> 8;
+          if (weight < 255) {
+            const current = dst32[dIdx];
+            const da = current >>> 24;
+            if (da !== 0) {
+              const t2 = da * weight + 128;
+              const finalAlpha = t2 + (t2 >> 8) >> 8;
+              const next = (current & 16777215 | finalAlpha << 24) >>> 0;
+              if (current !== next) {
+                dst32[dIdx] = next;
+                didChange = true;
+              }
+            }
+          }
         }
+        dIdx++;
+        mIdx++;
       }
-      dIdx++;
-      mIdx++;
+      dIdx += dStride;
+      mIdx += mStride;
     }
-    dIdx += dStride;
-    mIdx += mStride;
   }
   return didChange;
 }
@@ -2098,338 +2472,77 @@ function resizeImageData(target, newWidth, newHeight, offsetX = 0, offsetY = 0)
   return result;
 }
 
-// src/Rect/trimRectBounds.ts
-function trimRectBounds(x, y, w, h, targetWidth, targetHeight, out) {
-  const res = out ?? {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
+// src/PixelData/PixelData.ts
+function makePixelData(imageData) {
+  return {
+    data: new Uint32Array(
+      imageData.data.buffer,
+      imageData.data.byteOffset,
+      // Shift right by 2 is a fast bitwise division by 4.
+      imageData.data.byteLength >> 2
+    ),
+    imageData,
+    w: imageData.width,
+    h: imageData.height
   };
-  const left = Math.max(0, x);
-  const top = Math.max(0, y);
-  const right = Math.min(targetWidth, x + w);
-  const bottom = Math.min(targetHeight, y + h);
-  res.x = left;
-  res.y = top;
-  res.w = Math.max(0, right - left);
-  res.h = Math.max(0, bottom - top);
-  return res;
+}
+function setPixelData(target, imageData) {
+  ;
+  target.data = new Uint32Array(
+    imageData.data.buffer,
+    imageData.data.byteOffset,
+    // Shift right by 2 is a fast bitwise division by 4.
+    imageData.data.byteLength >> 2
+  );
+  target.imageData = imageData;
+  target.w = imageData.width;
+  target.h = imageData.height;
 }
 
-// src/Paint/PaintBuffer.ts
-var PaintBuffer = class {
-  constructor(config, tilePool) {
-    this.config = config;
-    this.tilePool = tilePool;
-    this.lookup = [];
-  }
-  lookup;
-  scratchBounds = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-  eachTileInBounds(bounds, callback) {
-    const {
-      tileShift,
-      targetColumns,
-      targetRows,
-      tileSize
-    } = this.config;
-    const x1 = Math.max(0, bounds.x >> tileShift);
-    const y1 = Math.max(0, bounds.y >> tileShift);
-    const x2 = Math.min(targetColumns - 1, bounds.x + bounds.w - 1 >> tileShift);
-    const y2 = Math.min(targetRows - 1, bounds.y + bounds.h - 1 >> tileShift);
-    if (x1 > x2 || y1 > y2) return;
-    const lookup = this.lookup;
-    const tilePool = this.tilePool;
-    for (let ty = y1; ty <= y2; ty++) {
-      const rowOffset = ty * targetColumns;
-      const tileTop = ty << tileShift;
-      for (let tx = x1; tx <= x2; tx++) {
-        const id = rowOffset + tx;
-        const tile = lookup[id] ?? (lookup[id] = tilePool.getTile(id, tx, ty));
-        const tileLeft = tx << tileShift;
-        const startX = bounds.x > tileLeft ? bounds.x : tileLeft;
-        const startY = bounds.y > tileTop ? bounds.y : tileTop;
-        const maskEndX = bounds.x + bounds.w;
-        const tileEndX = tileLeft + tileSize;
-        const endX = maskEndX < tileEndX ? maskEndX : tileEndX;
-        const maskEndY = bounds.y + bounds.h;
-        const tileEndY = tileTop + tileSize;
-        const endY = maskEndY < tileEndY ? maskEndY : tileEndY;
-        callback(tile, startX, startY, endX - startX, endY - startY);
-      }
-    }
-  }
-  writePaintAlphaMaskStroke(color, brush, x0, y0, x1, y1) {
-    const cA = color >>> 24;
-    if (cA === 0) return false;
-    const {
-      tileShift,
-      tileMask,
-      target
-    } = this.config;
-    const {
-      w: bW,
-      h: bH,
-      data: bD,
-      centerOffsetX,
-      centerOffsetY
-    } = brush;
-    const cRGB = color & 16777215;
-    const scratch = this.scratchBounds;
-    let changed = false;
-    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
-      const topLeftX = Math.floor(px + centerOffsetX);
-      const topLeftY = Math.floor(py + centerOffsetY);
-      trimRectBounds(topLeftX, topLeftY, bW, bH, target.width, target.height, scratch);
-      if (scratch.w <= 0 || scratch.h <= 0) return;
-      this.eachTileInBounds(scratch, (tile, bX, bY, bW_t, bH_t) => {
-        const d32 = tile.data32;
-        let tileChanged = false;
-        for (let i = 0; i < bH_t; i++) {
-          const canvasY = bY + i;
-          const bOff = (canvasY - topLeftY) * bW;
-          const tOff = (canvasY & tileMask) << tileShift;
-          const dS = tOff + (bX & tileMask);
-          for (let j = 0; j < bW_t; j++) {
-            const canvasX = bX + j;
-            const brushA = bD[bOff + (canvasX - topLeftX)];
-            if (brushA === 0) continue;
-            const t = cA * brushA + 128;
-            const blendedA = t + (t >> 8) >> 8;
-            const idx = dS + j;
-            const cur = d32[idx];
-            if (brushA > cur >>> 24) {
-              const next = (cRGB | blendedA << 24) >>> 0;
-              if (cur !== next) {
-                d32[idx] = next;
-                tileChanged = true;
-              }
-            }
-          }
-        }
-        if (tileChanged) changed = true;
-      });
-    });
-    return changed;
-  }
-  writePaintBinaryMaskStroke(color, brush, x0, y0, x1, y1) {
-    const alphaIsZero = color >>> 24 === 0;
-    if (alphaIsZero) return false;
-    const {
-      tileShift,
-      tileMask,
-      target
-    } = this.config;
-    const {
-      w: bW,
-      h: bH,
-      data: bD,
-      centerOffsetX,
-      centerOffsetY
-    } = brush;
-    const scratch = this.scratchBounds;
-    let changed = false;
-    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
-      const topLeftX = Math.floor(px + centerOffsetX);
-      const topLeftY = Math.floor(py + centerOffsetY);
-      trimRectBounds(topLeftX, topLeftY, bW, bH, target.width, target.height, scratch);
-      if (scratch.w <= 0 || scratch.h <= 0) return;
-      this.eachTileInBounds(scratch, (tile, bX, bY, bW_t, bH_t) => {
-        const d32 = tile.data32;
-        let tileChanged = false;
-        for (let i = 0; i < bH_t; i++) {
-          const canvasY = bY + i;
-          const bOff = (canvasY - topLeftY) * bW;
-          const tOff = (canvasY & tileMask) << tileShift;
-          const dS = tOff + (bX & tileMask);
-          for (let j = 0; j < bW_t; j++) {
-            const canvasX = bX + j;
-            if (bD[bOff + (canvasX - topLeftX)]) {
-              const idx = dS + j;
-              if (d32[idx] !== color) {
-                d32[idx] = color;
-                tileChanged = true;
-              }
-            }
-          }
-        }
-        if (tileChanged) changed = true;
-      });
-    });
-    return changed;
-  }
-  writeRectStroke(color, brushWidth, brushHeight, x0, y0, x1, y1) {
-    const alphaIsZero = color >>> 24 === 0;
-    if (alphaIsZero) return false;
-    const config = this.config;
-    const tileShift = config.tileShift;
-    const tileMask = config.tileMask;
-    const target = config.target;
-    const scratch = this.scratchBounds;
-    const centerOffsetX = -(brushWidth - 1 >> 1);
-    const centerOffsetY = -(brushHeight - 1 >> 1);
-    let changed = false;
-    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
-      const topLeftX = Math.floor(px + centerOffsetX);
-      const topLeftY = Math.floor(py + centerOffsetY);
-      trimRectBounds(topLeftX, topLeftY, brushWidth, brushHeight, target.width, target.height, scratch);
-      if (scratch.w <= 0 || scratch.h <= 0) return;
-      this.eachTileInBounds(scratch, (tile, bX, bY, bW_t, bH_t) => {
-        const d32 = tile.data32;
-        let tileChanged = false;
-        for (let i = 0; i < bH_t; i++) {
-          const canvasY = bY + i;
-          const tOff = (canvasY & tileMask) << tileShift;
-          const dS = tOff + (bX & tileMask);
-          for (let j = 0; j < bW_t; j++) {
-            const idx = dS + j;
-            if (d32[idx] !== color) {
-              d32[idx] = color;
-              tileChanged = true;
-            }
-          }
-        }
-        if (tileChanged) {
-          changed = true;
-        }
-      });
-    });
-    return changed;
-  }
-  clear() {
-    this.tilePool.releaseTiles(this.lookup);
-  }
-};
+// src/Tile/_tile-types.ts
+var TileType = /* @__PURE__ */ ((TileType2) => {
+  TileType2[TileType2["PIXEL"] = 0] = "PIXEL";
+  TileType2[TileType2["MASK"] = 1] = "MASK";
+  return TileType2;
+})(TileType || {});
 
-// src/PixelData/blendPixelData.ts
-function blendPixelData(target, src, opts) {
-  const targetX = opts?.x ?? 0;
-  const targetY = opts?.y ?? 0;
-  const sourceX = opts?.sx ?? 0;
-  const sourceY = opts?.sy ?? 0;
-  const width = opts?.w ?? src.width;
-  const height = opts?.h ?? src.height;
-  const globalAlpha = opts?.alpha ?? 255;
-  const blendFn = opts?.blendFn ?? sourceOverPerfect;
-  if (globalAlpha === 0) return false;
-  let x = targetX;
-  let y = targetY;
-  let sx = sourceX;
-  let sy = sourceY;
-  let w = width;
-  let h = height;
-  if (sx < 0) {
-    x -= sx;
-    w += sx;
-    sx = 0;
-  }
-  if (sy < 0) {
-    y -= sy;
-    h += sy;
-    sy = 0;
-  }
-  w = Math.min(w, src.width - sx);
-  h = Math.min(h, src.height - sy);
-  if (x < 0) {
-    sx -= x;
-    w += x;
-    x = 0;
-  }
-  if (y < 0) {
-    sy -= y;
-    h += y;
-    y = 0;
-  }
-  const actualW = Math.min(w, target.width - x);
-  const actualH = Math.min(h, target.height - y);
-  if (actualW <= 0 || actualH <= 0) return false;
-  const dst32 = target.data32;
-  const src32 = src.data32;
-  const dw = target.width;
-  const sw = src.width;
-  let dIdx = y * dw + x | 0;
-  let sIdx = sy * sw + sx | 0;
-  const dStride = dw - actualW | 0;
-  const sStride = sw - actualW | 0;
-  const isOpaque = globalAlpha === 255;
-  const isOverwrite = blendFn.isOverwrite;
-  let didChange = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    for (let ix = 0; ix < actualW; ix++) {
-      const srcCol = src32[sIdx];
-      const srcAlpha = srcCol >>> 24;
-      if (srcAlpha === 0 && !isOverwrite) {
-        dIdx++;
-        sIdx++;
-        continue;
-      }
-      let finalCol = srcCol;
-      if (!isOpaque) {
-        const a = srcAlpha * globalAlpha + 128 >> 8;
-        if (a === 0 && !isOverwrite) {
-          dIdx++;
-          sIdx++;
-          continue;
-        }
-        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
-      }
-      const current = dst32[dIdx];
-      const next = blendFn(finalCol, dst32[dIdx]);
-      if (current !== next) {
-        dst32[dIdx] = next;
-        didChange = true;
-      }
-      dIdx++;
-      sIdx++;
-    }
-    dIdx += dStride;
-    sIdx += sStride;
-  }
-  return didChange;
+// src/Tile/PixelTile.ts
+function makePixelTile(id, tx, ty, tileSize, tileArea) {
+  const data32 = new Uint32Array(tileArea);
+  const data8 = new Uint8ClampedArray(data32.buffer);
+  return {
+    tileType: 0 /* PIXEL */,
+    id,
+    tx,
+    ty,
+    w: tileSize,
+    h: tileSize,
+    data: data32,
+    imageData: new ImageData(data8, tileSize, tileSize)
+  };
 }
 
-// src/PixelTile/PixelTile.ts
-var PixelTile = class {
-  constructor(id, tx, ty, tileSize, tileArea) {
-    this.id = id;
-    this.tx = tx;
-    this.ty = ty;
-    this.width = this.height = tileSize;
-    this.data32 = new Uint32Array(tileArea);
-    const data8 = new Uint8ClampedArray(this.data32.buffer);
-    this.imageData = new ImageData(data8, tileSize, tileSize);
-  }
-  data32;
-  width;
-  height;
-  imageData;
-};
-
-// src/PixelTile/PixelTilePool.ts
-var PixelTilePool = class {
-  pool;
-  tileSize;
-  tileArea;
-  constructor(config) {
+// src/Tile/TilePool.ts
+var TilePool = class {
+  constructor(config, tileFactory) {
+    this.tileFactory = tileFactory;
     this.pool = [];
     this.tileSize = config.tileSize;
     this.tileArea = config.tileArea;
   }
+  pool;
+  tileSize;
+  tileArea;
   getTile(id, tx, ty) {
     let tile = this.pool.pop();
     if (tile) {
       tile.id = id;
       tile.tx = tx;
       tile.ty = ty;
-      tile.data32.fill(0);
+      tile.data.fill(0);
       return tile;
     }
-    return new PixelTile(id, tx, ty, this.tileSize, this.tileArea);
+    return this.tileFactory(id, tx, ty, this.tileSize, this.tileArea);
   }
   releaseTile(tile) {
     this.pool.push(tile);
@@ -2453,16 +2566,7 @@ var PixelWriter = class {
   historyActionFactory;
   config;
   pixelTilePool;
-  paintBuffer;
   mutator;
-  blendPixelDataOpts = {
-    alpha: 255,
-    blendFn: sourceOverPerfect,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
   _inProgress = false;
   constructor(target, mutatorFactory, options) {
     const tileSize = options?.tileSize ?? 256;
@@ -2470,10 +2574,9 @@ var PixelWriter = class {
     this.config = new PixelEngineConfig(tileSize, target);
     this.historyManager = options?.historyManager ?? new HistoryManager(maxHistorySteps);
     this.historyActionFactory = options?.historyActionFactory ?? makeHistoryAction;
-    this.pixelTilePool = options?.pixelTilePool ?? new PixelTilePool(this.config);
+    this.pixelTilePool = options?.pixelTilePool ?? new TilePool(this.config, makePixelTile);
     this.accumulator = options?.accumulator ?? new PixelAccumulator(this.config, this.pixelTilePool);
     this.mutator = mutatorFactory(this);
-    this.paintBuffer = new PaintBuffer(this.config, this.pixelTilePool);
   }
   /**
    * Executes `transaction` and commits the resulting pixel changes as a single
@@ -2519,59 +2622,37 @@ var PixelWriter = class {
     const target = config.target;
     const beforeImageData = target.imageData;
     const afterImageData = resizeImageDataFn(beforeImageData, newWidth, newHeight, offsetX, offsetY);
-    target.set(afterImageData);
+    setPixelData(target, afterImageData);
     this.historyManager.commit({
       undo: () => {
-        target.set(beforeImageData);
+        setPixelData(target, beforeImageData);
         afterUndo?.(beforeImageData);
         after?.(beforeImageData);
       },
       redo: () => {
-        target.set(afterImageData);
+        setPixelData(target, afterImageData);
         afterRedo?.(afterImageData);
         after?.(afterImageData);
       }
     });
   }
-  commitPaintBuffer(alpha = 255, blendFn = sourceOverPerfect, blendPixelDataFn = blendPixelData) {
-    const paintBuffer = this.paintBuffer;
-    const tileShift = paintBuffer.config.tileShift;
-    const lookup = paintBuffer.lookup;
-    const opts = this.blendPixelDataOpts;
-    opts.alpha = alpha;
-    opts.blendFn = blendFn;
-    for (let i = 0; i < lookup.length; i++) {
-      const tile = lookup[i];
-      if (tile) {
-        const didChange = this.accumulator.storeTileBeforeState(tile.id, tile.tx, tile.ty);
-        const dx = tile.tx << tileShift;
-        const dy = tile.ty << tileShift;
-        opts.x = dx;
-        opts.y = dy;
-        opts.w = tile.width;
-        opts.h = tile.height;
-        didChange(blendPixelDataFn(this.config.target, tile, opts));
-      }
-    }
-    paintBuffer.clear();
-  }
 };
 
 // src/History/PixelMutator/mutatorApplyAlphaMask.ts
-var defaults2 = {
+var defaults = {
   applyAlphaMaskToPixelData
 };
-var mutatorApplyAlphaMask = ((writer, deps = defaults2) => {
+var mutatorApplyAlphaMask = ((writer, deps = defaults) => {
   const {
-    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults2.applyAlphaMaskToPixelData
+    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults.applyAlphaMaskToPixelData
   } = deps;
   return {
     applyAlphaMask(mask, opts) {
       const target = writer.config.target;
       const x = opts?.x ?? 0;
       const y = opts?.y ?? 0;
-      const w = opts?.w ?? target.width;
-      const h = opts?.h ?? target.height;
+      const w = opts?.w ?? target.w;
+      const h = opts?.h ?? target.h;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(applyAlphaMaskToPixelData2(target, mask, opts));
     }
@@ -2582,8 +2663,8 @@ var mutatorApplyAlphaMask = ((writer, deps = defaults2) => {
 function applyBinaryMaskToPixelData(target, mask, opts) {
   const targetX = opts?.x ?? 0;
   const targetY = opts?.y ?? 0;
-  const width = opts?.w ?? target.width;
-  const height = opts?.h ?? target.height;
+  const width = opts?.w ?? target.w;
+  const height = opts?.h ?? target.h;
   const globalAlpha = opts?.alpha ?? 255;
   const mx = opts?.mx ?? 0;
   const my = opts?.my ?? 0;
@@ -2601,8 +2682,8 @@ function applyBinaryMaskToPixelData(target, mask, opts) {
     h += y;
     y = 0;
   }
-  w = Math.min(w, target.width - x);
-  h = Math.min(h, target.height - y);
+  w = Math.min(w, target.w - x);
+  h = Math.min(h, target.h - y);
   if (w <= 0 || h <= 0) return false;
   const mPitch = mask.w;
   if (mPitch <= 0) return false;
@@ -2619,8 +2700,8 @@ function applyBinaryMaskToPixelData(target, mask, opts) {
   }
   const xShift = sX0 - startX;
   const yShift = sY0 - startY;
-  const dst32 = target.data32;
-  const dw = target.width;
+  const dst32 = target.data;
+  const dw = target.w;
   const dStride = dw - finalW;
   const mStride = mPitch - finalW;
   const maskData = mask.data;
@@ -2660,20 +2741,20 @@ function applyBinaryMaskToPixelData(target, mask, opts) {
 }
 
 // src/History/PixelMutator/mutatorApplyBinaryMask.ts
-var defaults3 = {
+var defaults2 = {
   applyBinaryMaskToPixelData
 };
-var mutatorApplyBinaryMask = ((writer, deps = defaults3) => {
+var mutatorApplyBinaryMask = ((writer, deps = defaults2) => {
   const {
-    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults3.applyBinaryMaskToPixelData
+    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults2.applyBinaryMaskToPixelData
   } = deps;
   return {
     applyBinaryMask(mask, opts) {
       const target = writer.config.target;
       const x = opts?.x ?? 0;
       const y = opts?.y ?? 0;
-      const w = opts?.w ?? target.width;
-      const h = opts?.h ?? target.height;
+      const w = opts?.w ?? target.w;
+      const h = opts?.h ?? target.h;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(applyBinaryMaskToPixelData2(target, mask, opts));
     }
@@ -2681,22 +2762,22 @@ var mutatorApplyBinaryMask = ((writer, deps = defaults3) => {
 });
 
 // src/History/PixelMutator/mutatorApplyMask.ts
-var defaults4 = {
+var defaults3 = {
   applyBinaryMaskToPixelData,
   applyAlphaMaskToPixelData
 };
-var mutatorApplyMask = ((writer, deps = defaults4) => {
+var mutatorApplyMask = ((writer, deps = defaults3) => {
   const {
-    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults4.applyBinaryMaskToPixelData,
-    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults4.applyAlphaMaskToPixelData
+    applyBinaryMaskToPixelData: applyBinaryMaskToPixelData2 = defaults3.applyBinaryMaskToPixelData,
+    applyAlphaMaskToPixelData: applyAlphaMaskToPixelData2 = defaults3.applyAlphaMaskToPixelData
   } = deps;
   return {
     applyMask(mask, opts) {
       const target = writer.config.target;
       const x = opts?.x ?? 0;
       const y = opts?.y ?? 0;
-      const w = opts?.w ?? target.width;
-      const h = opts?.h ?? target.height;
+      const w = opts?.w ?? target.w;
+      const h = opts?.h ?? target.h;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       if (mask.type === 1 /* BINARY */) {
         return didChange(applyBinaryMaskToPixelData2(target, mask, opts));
@@ -2713,8 +2794,8 @@ function blendPixelDataAlphaMask(target, src, alphaMask, opts) {
   const targetY = opts?.y ?? 0;
   const sourceX = opts?.sx ?? 0;
   const sourceY = opts?.sy ?? 0;
-  const width = opts?.w ?? src.width;
-  const height = opts?.h ?? src.height;
+  const width = opts?.w ?? src.w;
+  const height = opts?.h ?? src.h;
   const globalAlpha = opts?.alpha ?? 255;
   const blendFn = opts?.blendFn ?? sourceOverPerfect;
   const mx = opts?.mx ?? 0;
@@ -2737,8 +2818,8 @@ function blendPixelDataAlphaMask(target, src, alphaMask, opts) {
     h += sy;
     sy = 0;
   }
-  w = Math.min(w, src.width - sx);
-  h = Math.min(h, src.height - sy);
+  w = Math.min(w, src.w - sx);
+  h = Math.min(h, src.h - sy);
   if (x < 0) {
     sx -= x;
     w += x;
@@ -2749,17 +2830,17 @@ function blendPixelDataAlphaMask(target, src, alphaMask, opts) {
     h += y;
     y = 0;
   }
-  const actualW = Math.min(w, target.width - x);
-  const actualH = Math.min(h, target.height - y);
+  const actualW = Math.min(w, target.w - x);
+  const actualH = Math.min(h, target.h - y);
   if (actualW <= 0 || actualH <= 0) return false;
-  const dw = target.width;
-  const sw = src.width;
+  const dw = target.w;
+  const sw = src.w;
   const mPitch = alphaMask.w;
   const maskData = alphaMask.data;
   const dx = x - targetX | 0;
   const dy = y - targetY | 0;
-  const dst32 = target.data32;
-  const src32 = src.data32;
+  const dst32 = target.data;
+  const src32 = src.data;
   let dIdx = y * dw + x | 0;
   let sIdx = sy * sw + sx | 0;
   let mIdx = (my + dy) * mPitch + (mx + dx) | 0;
@@ -2828,19 +2909,19 @@ function blendPixelDataAlphaMask(target, src, alphaMask, opts) {
 }
 
 // src/History/PixelMutator/mutatorBlendAlphaMask.ts
-var defaults5 = {
+var defaults4 = {
   blendPixelDataAlphaMask
 };
-var mutatorBlendAlphaMask = ((writer, deps = defaults5) => {
+var mutatorBlendAlphaMask = ((writer, deps = defaults4) => {
   const {
-    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults5.blendPixelDataAlphaMask
+    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults4.blendPixelDataAlphaMask
   } = deps;
   return {
     blendAlphaMask(src, mask, opts) {
       const x = opts?.x ?? 0;
       const y = opts?.y ?? 0;
-      const w = opts?.w ?? src.width;
-      const h = opts?.h ?? src.height;
+      const w = opts?.w ?? src.w;
+      const h = opts?.h ?? src.h;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(blendPixelDataAlphaMask2(writer.config.target, src, mask, opts));
     }
@@ -2853,8 +2934,8 @@ function blendPixelDataBinaryMask(target, src, binaryMask, opts) {
   const targetY = opts?.y ?? 0;
   const sourceX = opts?.sx ?? 0;
   const sourceY = opts?.sy ?? 0;
-  const width = opts?.w ?? src.width;
-  const height = opts?.h ?? src.height;
+  const width = opts?.w ?? src.w;
+  const height = opts?.h ?? src.h;
   const globalAlpha = opts?.alpha ?? 255;
   const blendFn = opts?.blendFn ?? sourceOverPerfect;
   const mx = opts?.mx ?? 0;
@@ -2877,8 +2958,8 @@ function blendPixelDataBinaryMask(target, src, binaryMask, opts) {
     h += sy;
     sy = 0;
   }
-  w = Math.min(w, src.width - sx);
-  h = Math.min(h, src.height - sy);
+  w = Math.min(w, src.w - sx);
+  h = Math.min(h, src.h - sy);
   if (x < 0) {
     sx -= x;
     w += x;
@@ -2889,15 +2970,15 @@ function blendPixelDataBinaryMask(target, src, binaryMask, opts) {
     h += y;
     y = 0;
   }
-  const actualW = Math.min(w, target.width - x);
-  const actualH = Math.min(h, target.height - y);
+  const actualW = Math.min(w, target.w - x);
+  const actualH = Math.min(h, target.h - y);
   if (actualW <= 0 || actualH <= 0) return false;
   const dx = x - targetX | 0;
   const dy = y - targetY | 0;
-  const dst32 = target.data32;
-  const src32 = src.data32;
-  const dw = target.width;
-  const sw = src.width;
+  const dst32 = target.data;
+  const src32 = src.data;
+  const dw = target.w;
+  const sw = src.w;
   const mPitch = binaryMask.w;
   const maskData = binaryMask.data;
   let dIdx = y * dw + x | 0;
@@ -2955,19 +3036,19 @@ function blendPixelDataBinaryMask(target, src, binaryMask, opts) {
 }
 
 // src/History/PixelMutator/mutatorBlendBinaryMask.ts
-var defaults6 = {
+var defaults5 = {
   blendPixelDataBinaryMask
 };
-var mutatorBlendBinaryMask = ((writer, deps = defaults6) => {
+var mutatorBlendBinaryMask = ((writer, deps = defaults5) => {
   const {
-    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults6.blendPixelDataBinaryMask
+    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults5.blendPixelDataBinaryMask
   } = deps;
   return {
     blendBinaryMask(src, mask, opts) {
       const x = opts?.x ?? 0;
       const y = opts?.y ?? 0;
-      const w = opts?.w ?? src.width;
-      const h = opts?.h ?? src.height;
+      const w = opts?.w ?? src.w;
+      const h = opts?.h ?? src.h;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(blendPixelDataBinaryMask2(writer.config.target, src, mask, opts));
     }
@@ -2978,8 +3059,8 @@ var mutatorBlendBinaryMask = ((writer, deps = defaults6) => {
 function blendColorPixelData(target, color, opts) {
   const targetX = opts?.x ?? 0;
   const targetY = opts?.y ?? 0;
-  const width = opts?.w ?? target.width;
-  const height = opts?.h ?? target.height;
+  const width = opts?.w ?? target.w;
+  const height = opts?.h ?? target.h;
   const globalAlpha = opts?.alpha ?? 255;
   const blendFn = opts?.blendFn ?? sourceOverPerfect;
   if (globalAlpha === 0) return false;
@@ -2998,8 +3079,8 @@ function blendColorPixelData(target, color, opts) {
     h += y;
     y = 0;
   }
-  const actualW = Math.min(w, target.width - x);
-  const actualH = Math.min(h, target.height - y);
+  const actualW = Math.min(w, target.w - x);
+  const actualH = Math.min(h, target.h - y);
   if (actualW <= 0 || actualH <= 0) return false;
   let finalSrcColor = color;
   if (globalAlpha < 255) {
@@ -3007,8 +3088,8 @@ function blendColorPixelData(target, color, opts) {
     if (a === 0 && !isOverwrite) return false;
     finalSrcColor = (color & 16777215 | a << 24) >>> 0;
   }
-  const dst32 = target.data32;
-  const dw = target.width;
+  const dst32 = target.data;
+  const dw = target.w;
   let dIdx = y * dw + x | 0;
   const dStride = dw - actualW | 0;
   let didChange = false;
@@ -3028,20 +3109,20 @@ function blendColorPixelData(target, color, opts) {
 }
 
 // src/History/PixelMutator/mutatorBlendColor.ts
-var defaults7 = {
+var defaults6 = {
   blendColorPixelData
 };
-var mutatorBlendColor = ((writer, deps = defaults7) => {
+var mutatorBlendColor = ((writer, deps = defaults6) => {
   const {
-    blendColorPixelData: blendColorPixelData2 = defaults7.blendColorPixelData
+    blendColorPixelData: blendColorPixelData2 = defaults6.blendColorPixelData
   } = deps;
   return {
     blendColor(color, opts) {
       const target = writer.config.target;
       const x = opts?.x ?? 0;
       const y = opts?.y ?? 0;
-      const w = opts?.w ?? target.width;
-      const h = opts?.h ?? target.height;
+      const w = opts?.w ?? target.w;
+      const h = opts?.h ?? target.h;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(blendColorPixelData2(target, color, opts));
     }
@@ -3075,13 +3156,13 @@ function blendColorPixelDataAlphaMask(target, color, mask, opts) {
     actualH += y;
     y = 0;
   }
-  actualW = Math.min(actualW, target.width - x);
-  actualH = Math.min(actualH, target.height - y);
+  actualW = Math.min(actualW, target.w - x);
+  actualH = Math.min(actualH, target.h - y);
   if (actualW <= 0 || actualH <= 0) return false;
   const dx = x - targetX | 0;
   const dy = y - targetY | 0;
-  const dst32 = target.data32;
-  const dw = target.width;
+  const dst32 = target.data;
+  const dw = target.w;
   const mPitch = mask.w;
   const maskData = mask.data;
   let dIdx = y * dw + x | 0;
@@ -3137,12 +3218,12 @@ function blendColorPixelDataAlphaMask(target, color, mask, opts) {
 }
 
 // src/History/PixelMutator/mutatorBlendColorPaintAlphaMask.ts
-var defaults8 = {
+var defaults7 = {
   blendColorPixelDataAlphaMask
 };
-var mutatorBlendColorPaintAlphaMask = ((writer, deps = defaults8) => {
+var mutatorBlendColorPaintAlphaMask = ((writer, deps = defaults7) => {
   const {
-    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults8.blendColorPixelDataAlphaMask
+    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults7.blendColorPixelDataAlphaMask
   } = deps;
   const OPTS = {
     x: 0,
@@ -3189,8 +3270,8 @@ function blendColorPixelDataBinaryMask(target, color, mask, opts) {
     h += y;
     y = 0;
   }
-  const actualW = Math.min(w, target.width - x);
-  const actualH = Math.min(h, target.height - y);
+  const actualW = Math.min(w, target.w - x);
+  const actualH = Math.min(h, target.h - y);
   if (actualW <= 0 || actualH <= 0) return false;
   let baseColorWithGlobalAlpha = color;
   if (globalAlpha < 255) {
@@ -3200,8 +3281,8 @@ function blendColorPixelDataBinaryMask(target, color, mask, opts) {
   }
   const dx = x - targetX | 0;
   const dy = y - targetY | 0;
-  const dst32 = target.data32;
-  const dw = target.width;
+  const dst32 = target.data;
+  const dw = target.w;
   const mPitch = mask.w;
   const maskData = mask.data;
   let dIdx = y * dw + x | 0;
@@ -3233,12 +3314,12 @@ function blendColorPixelDataBinaryMask(target, color, mask, opts) {
 }
 
 // src/History/PixelMutator/mutatorBlendColorPaintBinaryMask.ts
-var defaults9 = {
+var defaults8 = {
   blendColorPixelDataBinaryMask
 };
-var mutatorBlendColorPaintBinaryMask = ((writer, deps = defaults9) => {
+var mutatorBlendColorPaintBinaryMask = ((writer, deps = defaults8) => {
   const {
-    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults9.blendColorPixelDataBinaryMask
+    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults8.blendColorPixelDataBinaryMask
   } = deps;
   const OPTS = {
     x: 0,
@@ -3261,14 +3342,14 @@ var mutatorBlendColorPaintBinaryMask = ((writer, deps = defaults9) => {
 });
 
 // src/History/PixelMutator/mutatorBlendColorPaintMask.ts
-var defaults10 = {
+var defaults9 = {
   blendColorPixelDataAlphaMask,
   blendColorPixelDataBinaryMask
 };
-var mutatorBlendColorPaintMask = ((writer, deps = defaults10) => {
+var mutatorBlendColorPaintMask = ((writer, deps = defaults9) => {
   const {
-    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults10.blendColorPixelDataBinaryMask,
-    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults10.blendColorPixelDataAlphaMask
+    blendColorPixelDataBinaryMask: blendColorPixelDataBinaryMask2 = defaults9.blendColorPixelDataBinaryMask,
+    blendColorPixelDataAlphaMask: blendColorPixelDataAlphaMask2 = defaults9.blendColorPixelDataAlphaMask
   } = deps;
   const OPTS = {
     x: 0,
@@ -3294,39 +3375,13 @@ var mutatorBlendColorPaintMask = ((writer, deps = defaults10) => {
   };
 });
 
-// src/History/PixelMutator/mutatorBlendMask.ts
-var defaults11 = {
-  blendPixelDataAlphaMask,
-  blendPixelDataBinaryMask
-};
-var mutatorBlendMask = ((writer, deps = defaults11) => {
-  const {
-    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults11.blendPixelDataAlphaMask,
-    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults11.blendPixelDataBinaryMask
-  } = deps;
-  return {
-    blendMask(src, mask, opts) {
-      const x = opts?.x ?? 0;
-      const y = opts?.y ?? 0;
-      const w = opts?.w ?? src.width;
-      const h = opts?.h ?? src.height;
-      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
-      if (mask.type === 1 /* BINARY */) {
-        return didChange(blendPixelDataBinaryMask2(writer.config.target, src, mask, opts));
-      } else {
-        return didChange(blendPixelDataAlphaMask2(writer.config.target, src, mask, opts));
-      }
-    }
-  };
-});
-
-// src/History/PixelMutator/mutatorBlendPaintRect.ts
-var defaults12 = {
+// src/History/PixelMutator/mutatorBlendColorPaintRect.ts
+var defaults10 = {
   blendColorPixelData
 };
-var mutatorBlendPaintRect = ((writer, deps = defaults12) => {
+var mutatorBlendColorPaintRect = ((writer, deps = defaults10) => {
   const {
-    blendColorPixelData: blendColorPixelData2 = defaults12.blendColorPixelData
+    blendColorPixelData: blendColorPixelData2 = defaults10.blendColorPixelData
   } = deps;
   const OPTS = {
     x: 0,
@@ -3337,7 +3392,7 @@ var mutatorBlendPaintRect = ((writer, deps = defaults12) => {
     alpha: 255
   };
   return {
-    blendPaintRect(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, blendFn = sourceOverPerfect) {
+    blendColorPaintRect(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, blendFn = sourceOverPerfect) {
       const target = writer.config.target;
       const topLeftX = centerX + -(brushWidth - 1 >> 1);
       const topLeftY = centerY + -(brushHeight - 1 >> 1);
@@ -3353,16 +3408,42 @@ var mutatorBlendPaintRect = ((writer, deps = defaults12) => {
   };
 });
 
+// src/History/PixelMutator/mutatorBlendMask.ts
+var defaults11 = {
+  blendPixelDataAlphaMask,
+  blendPixelDataBinaryMask
+};
+var mutatorBlendMask = ((writer, deps = defaults11) => {
+  const {
+    blendPixelDataAlphaMask: blendPixelDataAlphaMask2 = defaults11.blendPixelDataAlphaMask,
+    blendPixelDataBinaryMask: blendPixelDataBinaryMask2 = defaults11.blendPixelDataBinaryMask
+  } = deps;
+  return {
+    blendMask(src, mask, opts) {
+      const x = opts?.x ?? 0;
+      const y = opts?.y ?? 0;
+      const w = opts?.w ?? src.w;
+      const h = opts?.h ?? src.h;
+      const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      if (mask.type === 1 /* BINARY */) {
+        return didChange(blendPixelDataBinaryMask2(writer.config.target, src, mask, opts));
+      } else {
+        return didChange(blendPixelDataAlphaMask2(writer.config.target, src, mask, opts));
+      }
+    }
+  };
+});
+
 // src/PixelData/blendPixel.ts
 function blendPixel(target, x, y, color, alpha = 255, blendFn = sourceOverPerfect) {
   if (alpha === 0) return false;
-  let width = target.width;
-  let height = target.height;
+  let width = target.w;
+  let height = target.h;
   if (x < 0 || x >= width || y < 0 || y >= height) return false;
   let srcAlpha = color >>> 24;
   let isOverwrite = blendFn.isOverwrite;
   if (srcAlpha === 0 && !isOverwrite) return false;
-  let dst32 = target.data32;
+  let dst32 = target.data;
   let index = y * width + x;
   let finalColor = color;
   if (alpha !== 255) {
@@ -3380,12 +3461,12 @@ function blendPixel(target, x, y, color, alpha = 255, blendFn = sourceOverPerfec
 }
 
 // src/History/PixelMutator/mutatorBlendPixel.ts
-var defaults13 = {
+var defaults12 = {
   blendPixel
 };
-var mutatorBlendPixel = ((writer, deps = defaults13) => {
+var mutatorBlendPixel = ((writer, deps = defaults12) => {
   const {
-    blendPixel: blendPixel2 = defaults13.blendPixel
+    blendPixel: blendPixel2 = defaults12.blendPixel
   } = deps;
   return {
     blendPixel(x, y, color, alpha, blendFn) {
@@ -3395,20 +3476,107 @@ var mutatorBlendPixel = ((writer, deps = defaults13) => {
   };
 });
 
+// src/PixelData/blendPixelData.ts
+function blendPixelData(target, src, opts) {
+  const targetX = opts?.x ?? 0;
+  const targetY = opts?.y ?? 0;
+  const sourceX = opts?.sx ?? 0;
+  const sourceY = opts?.sy ?? 0;
+  const width = opts?.w ?? src.w;
+  const height = opts?.h ?? src.h;
+  const globalAlpha = opts?.alpha ?? 255;
+  const blendFn = opts?.blendFn ?? sourceOverPerfect;
+  if (globalAlpha === 0) return false;
+  let x = targetX;
+  let y = targetY;
+  let sx = sourceX;
+  let sy = sourceY;
+  let w = width;
+  let h = height;
+  if (sx < 0) {
+    x -= sx;
+    w += sx;
+    sx = 0;
+  }
+  if (sy < 0) {
+    y -= sy;
+    h += sy;
+    sy = 0;
+  }
+  w = Math.min(w, src.w - sx);
+  h = Math.min(h, src.h - sy);
+  if (x < 0) {
+    sx -= x;
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    sy -= y;
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, target.w - x);
+  const actualH = Math.min(h, target.h - y);
+  if (actualW <= 0 || actualH <= 0) return false;
+  const dst32 = target.data;
+  const src32 = src.data;
+  const dw = target.w;
+  const sw = src.w;
+  let dIdx = y * dw + x | 0;
+  let sIdx = sy * sw + sx | 0;
+  const dStride = dw - actualW | 0;
+  const sStride = sw - actualW | 0;
+  const isOpaque = globalAlpha === 255;
+  const isOverwrite = blendFn.isOverwrite;
+  let didChange = false;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      const srcCol = src32[sIdx];
+      const srcAlpha = srcCol >>> 24;
+      if (srcAlpha === 0 && !isOverwrite) {
+        dIdx++;
+        sIdx++;
+        continue;
+      }
+      let finalCol = srcCol;
+      if (!isOpaque) {
+        const a = srcAlpha * globalAlpha + 128 >> 8;
+        if (a === 0 && !isOverwrite) {
+          dIdx++;
+          sIdx++;
+          continue;
+        }
+        finalCol = (srcCol & 16777215 | a << 24) >>> 0;
+      }
+      const current = dst32[dIdx];
+      const next = blendFn(finalCol, dst32[dIdx]);
+      if (current !== next) {
+        dst32[dIdx] = next;
+        didChange = true;
+      }
+      dIdx++;
+      sIdx++;
+    }
+    dIdx += dStride;
+    sIdx += sStride;
+  }
+  return didChange;
+}
+
 // src/History/PixelMutator/mutatorBlendPixelData.ts
-var defaults14 = {
+var defaults13 = {
   blendPixelData
 };
-var mutatorBlendPixelData = ((writer, deps = defaults14) => {
+var mutatorBlendPixelData = ((writer, deps = defaults13) => {
   const {
-    blendPixelData: blendPixelData2 = defaults14.blendPixelData
+    blendPixelData: blendPixelData2 = defaults13.blendPixelData
   } = deps;
   return {
     blendPixelData(src, opts) {
       const x = opts?.x ?? 0;
       const y = opts?.y ?? 0;
-      const w = opts?.w ?? src.width;
-      const h = opts?.h ?? src.height;
+      const w = opts?.w ?? src.w;
+      const h = opts?.h ?? src.h;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(blendPixelData2(writer.config.target, src, opts));
     }
@@ -3425,8 +3593,8 @@ function fillPixelData(dst, color, _x, _y, _w, _h) {
   if (typeof _x === "object") {
     x = _x.x ?? 0;
     y = _x.y ?? 0;
-    w = _x.w ?? dst.width;
-    h = _x.h ?? dst.height;
+    w = _x.w ?? dst.w;
+    h = _x.h ?? dst.h;
   } else if (typeof _x === "number") {
     x = _x;
     y = _y;
@@ -3435,10 +3603,10 @@ function fillPixelData(dst, color, _x, _y, _w, _h) {
   } else {
     x = 0;
     y = 0;
-    w = dst.width;
-    h = dst.height;
+    w = dst.w;
+    h = dst.h;
   }
-  const clip = resolveRectClipping(x, y, w, h, dst.width, dst.height, SCRATCH_RECT);
+  const clip = resolveRectClipping(x, y, w, h, dst.w, dst.h, SCRATCH_RECT);
   if (!clip.inBounds) return false;
   const {
     x: finalX,
@@ -3446,8 +3614,8 @@ function fillPixelData(dst, color, _x, _y, _w, _h) {
     w: actualW,
     h: actualH
   } = clip;
-  const dst32 = dst.data32;
-  const dw = dst.width;
+  const dst32 = dst.data;
+  const dw = dst.w;
   let hasChanged = false;
   for (let iy = 0; iy < actualH; iy++) {
     const rowOffset = (finalY + iy) * dw;
@@ -3464,20 +3632,20 @@ function fillPixelData(dst, color, _x, _y, _w, _h) {
 }
 
 // src/History/PixelMutator/mutatorClear.ts
-var defaults15 = {
+var defaults14 = {
   fillPixelData
 };
-var mutatorClear = ((writer, deps = defaults15) => {
+var mutatorClear = ((writer, deps = defaults14) => {
   const {
-    fillPixelData: fillPixelData2 = defaults15.fillPixelData
+    fillPixelData: fillPixelData2 = defaults14.fillPixelData
   } = deps;
   return {
     clear(rect) {
       const target = writer.config.target;
       const x = rect?.x ?? 0;
       const y = rect?.y ?? 0;
-      const w = rect?.w ?? target.width;
-      const h = rect?.h ?? target.height;
+      const w = rect?.w ?? target.w;
+      const h = rect?.h ?? target.h;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(fillPixelData2(target, 0, x, y, w, h));
     }
@@ -3485,24 +3653,24 @@ var mutatorClear = ((writer, deps = defaults15) => {
 });
 
 // src/History/PixelMutator/mutatorFill.ts
-var defaults16 = {
+var defaults15 = {
   fillPixelData
 };
-var mutatorFill = ((writer, deps = defaults16) => {
+var mutatorFill = ((writer, deps = defaults15) => {
   const {
-    fillPixelData: fillPixelData2 = defaults16.fillPixelData
+    fillPixelData: fillPixelData2 = defaults15.fillPixelData
   } = deps;
   return {
-    fill(color, x = 0, y = 0, w = writer.config.target.width, h = writer.config.target.height) {
+    fill(color, x = 0, y = 0, w = writer.config.target.w, h = writer.config.target.h) {
       const target = writer.config.target;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(fillPixelData2(target, color, x, y, w, h));
     }
   };
 });
-var mutatorFillRect = ((writer, deps = defaults16) => {
+var mutatorFillRect = ((writer, deps = defaults15) => {
   const {
-    fillPixelData: fillPixelData2 = defaults16.fillPixelData
+    fillPixelData: fillPixelData2 = defaults15.fillPixelData
   } = deps;
   return {
     fillRect(color, rect) {
@@ -3518,7 +3686,7 @@ var SCRATCH_RECT2 = makeClippedRect();
 function fillPixelDataBinaryMask(target, color, mask, x = 0, y = 0) {
   const maskW = mask.w;
   const maskH = mask.h;
-  const clip = resolveRectClipping(x, y, maskW, maskH, target.width, target.height, SCRATCH_RECT2);
+  const clip = resolveRectClipping(x, y, maskW, maskH, target.w, target.h, SCRATCH_RECT2);
   if (!clip.inBounds) return false;
   const {
     x: finalX,
@@ -3527,8 +3695,8 @@ function fillPixelDataBinaryMask(target, color, mask, x = 0, y = 0) {
     h: actualH
   } = clip;
   const maskData = mask.data;
-  const dst32 = target.data32;
-  const dw = target.width;
+  const dst32 = target.data;
+  const dw = target.w;
   let hasChanged = false;
   for (let iy = 0; iy < actualH; iy++) {
     const currentY = finalY + iy;
@@ -3552,12 +3720,12 @@ function fillPixelDataBinaryMask(target, color, mask, x = 0, y = 0) {
 }
 
 // src/History/PixelMutator/mutatorFillBinaryMask.ts
-var defaults17 = {
+var defaults16 = {
   fillPixelDataBinaryMask
 };
-var mutatorFillBinaryMask = ((writer, deps = defaults17) => {
+var mutatorFillBinaryMask = ((writer, deps = defaults16) => {
   const {
-    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults17.fillPixelDataBinaryMask
+    fillPixelDataBinaryMask: fillPixelDataBinaryMask2 = defaults16.fillPixelDataBinaryMask
   } = deps;
   return {
     fillBinaryMask(color, mask, x = 0, y = 0) {
@@ -3575,10 +3743,10 @@ function invertPixelData(target, opts) {
   const targetY = opts?.y ?? 0;
   const mx = opts?.mx ?? 0;
   const my = opts?.my ?? 0;
-  const width = opts?.w ?? target.width;
-  const height = opts?.h ?? target.height;
+  const width = opts?.w ?? target.w;
+  const height = opts?.h ?? target.h;
   const invertMask = opts?.invertMask ?? false;
-  const clip = resolveRectClipping(targetX, targetY, width, height, target.width, target.height, SCRATCH_RECT3);
+  const clip = resolveRectClipping(targetX, targetY, width, height, target.w, target.h, SCRATCH_RECT3);
   if (!clip.inBounds) return false;
   const {
     x,
@@ -3586,8 +3754,8 @@ function invertPixelData(target, opts) {
     w: actualW,
     h: actualH
   } = clip;
-  const dst32 = target.data32;
-  const dw = target.width;
+  const dst32 = target.data;
+  const dw = target.w;
   const mPitch = mask?.w ?? width;
   const dx = x - targetX;
   const dy = y - targetY;
@@ -3623,20 +3791,20 @@ function invertPixelData(target, opts) {
 }
 
 // src/History/PixelMutator/mutatorInvert.ts
-var defaults18 = {
+var defaults17 = {
   invertPixelData
 };
-var mutatorInvert = ((writer, deps = defaults18) => {
+var mutatorInvert = ((writer, deps = defaults17) => {
   const {
-    invertPixelData: invertPixelData2 = defaults18.invertPixelData
+    invertPixelData: invertPixelData2 = defaults17.invertPixelData
   } = deps;
   return {
     invert(opts) {
       const target = writer.config.target;
       const x = opts?.x ?? 0;
       const y = opts?.y ?? 0;
-      const w = opts?.w ?? target.width;
-      const h = opts?.h ?? target.height;
+      const w = opts?.w ?? target.w;
+      const h = opts?.h ?? target.h;
       const didChange = writer.accumulator.storeRegionBeforeState(x, y, w, h);
       return didChange(invertPixelData2(target, opts));
     }
@@ -3656,8 +3824,8 @@ function makeFullPixelMutator(writer) {
     ...mutatorBlendColorPaintAlphaMask(writer),
     ...mutatorBlendColorPaintBinaryMask(writer),
     ...mutatorBlendColorPaintMask(writer),
+    ...mutatorBlendColorPaintRect(writer),
     ...mutatorBlendMask(writer),
-    ...mutatorBlendPaintRect(writer),
     ...mutatorBlendPixel(writer),
     ...mutatorBlendPixelData(writer),
     ...mutatorClear(writer),
@@ -3668,30 +3836,6 @@ function makeFullPixelMutator(writer) {
   };
 }
 
-// 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,
-    data: buffer
-  };
-}
-
-// src/ImageData/ReusableImageData.ts
-function makeReusableImageData() {
-  let imageData = null;
-  return function getReusableImageData(width, height) {
-    if (imageData === null || imageData.width !== width || imageData.height !== height) {
-      imageData = new ImageData(width, height);
-    } else {
-      imageData.data.fill(0);
-    }
-    return imageData;
-  };
-}
-
 // src/ImageData/copyImageData.ts
 function copyImageData({
   data,
@@ -3712,6 +3856,17 @@ function copyImageDataLike({
   };
 }
 
+// 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,
+    data: buffer
+  };
+}
+
 // src/ImageData/imageDataToAlphaMaskBuffer.ts
 function imageDataToAlphaMaskBuffer(imageData) {
   const {
@@ -3741,8 +3896,8 @@ function imageDataToDataUrl(imageData) {
 }
 imageDataToDataUrl.reset = get.reset;
 
-// src/ImageData/imageDataToUInt32Array.ts
-function imageDataToUInt32Array(imageData) {
+// src/ImageData/imageDataToUint32Array.ts
+function imageDataToUint32Array(imageData) {
   return new Uint32Array(
     imageData.data.buffer,
     imageData.data.byteOffset,
@@ -3763,43 +3918,29 @@ function invertImageData(imageData) {
   return imageData;
 }
 
-// src/Internal/resample32.ts
-var resample32Scratch = {
-  data: null,
-  width: 0,
-  height: 0
-};
-function resample32(srcData32, srcW, srcH, factor) {
-  const dstW = Math.max(1, srcW * factor | 0);
-  const dstH = Math.max(1, srcH * factor | 0);
-  const dstData = new Int32Array(dstW * dstH);
-  const scaleX = srcW / dstW;
-  const scaleY = srcH / dstH;
-  for (let y = 0; y < dstH; y++) {
-    const srcY = Math.min(srcH - 1, y * scaleY | 0);
-    const srcRowOffset = srcY * srcW;
-    const dstRowOffset = y * dstW;
-    for (let x = 0; x < dstW; x++) {
-      const srcX = Math.min(srcW - 1, x * scaleX | 0);
-      dstData[dstRowOffset + x] = srcData32[srcRowOffset + srcX];
-    }
-  }
-  resample32Scratch.data = dstData;
-  resample32Scratch.width = dstW;
-  resample32Scratch.height = dstH;
-  return resample32Scratch;
-}
-
 // 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);
+    w,
+    h
+  } = resampleUint32Array(src32, source.width, source.height, factor);
   const uint8ClampedArray = new Uint8ClampedArray(data.buffer);
-  return new ImageData(uint8ClampedArray, width, height);
+  return new ImageData(uint8ClampedArray, w, h);
+}
+
+// src/ImageData/ReusableImageData.ts
+function makeReusableImageData() {
+  let imageData = null;
+  return function getReusableImageData(width, height) {
+    if (imageData === null || imageData.width !== width || imageData.height !== height) {
+      imageData = new ImageData(width, height);
+    } else {
+      imageData.data.fill(0);
+    }
+    return imageData;
+  };
 }
 
 // src/ImageData/serialization.ts
@@ -3956,89 +4097,11 @@ function writeImageDataBuffer(target, data, _x, _y, _w, _h) {
   }
 }
 
-// src/IndexedImage/IndexedImage.ts
-var IndexedImage = class _IndexedImage {
-  /** The width of the image in pixels. */
-  width;
-  /** The height of the image in pixels. */
-  height;
-  /** Flat array of palette indices. Index = x + (y * width). */
-  data;
-  /** The palette of unique 32-bit colors (ABGR/RGBA packed) found in the image. */
-  palette;
-  /** The specific index in the palette reserved for fully transparent pixels. */
-  transparentPalletIndex;
-  /**
-   * @param width - Image width.
-   * @param height - Image height.
-   * @param data - The indexed pixel data.
-   * @param palette - The array of packed colors.
-   * @param transparentPalletIndex - The index representing alpha 0.
-   */
-  constructor(width, height, data, palette, transparentPalletIndex) {
-    this.width = width;
-    this.height = height;
-    this.data = data;
-    this.palette = palette;
-    this.transparentPalletIndex = transparentPalletIndex;
-  }
-  /**
-   * Creates an IndexedImage from standard browser ImageData.
-   * @param imageData - The source ImageData to convert.
-   * @returns A new IndexedImage instance.
-   */
-  static fromImageData(imageData) {
-    return _IndexedImage.fromRaw(imageData.data, imageData.width, imageData.height);
-  }
-  /**
-   * Creates an IndexedImage from a raw byte buffer and dimensions.
-   * Any pixel with an alpha channel of 0 is normalized to the transparent palette index.
-   * @param data - Raw RGBA byte data.
-   * @param width - Image width.
-   * @param height - Image height.
-   * @returns A new IndexedImage instance.
-   */
-  static fromRaw(data, width, height) {
-    const buffer = data.buffer;
-    const rawData = new Uint32Array(buffer);
-    const indexedData = new Int32Array(rawData.length);
-    const colorMap = /* @__PURE__ */ new Map();
-    const transparentColor = 0;
-    const transparentPalletIndex = 0;
-    colorMap.set(transparentColor, transparentPalletIndex);
-    for (let i = 0; i < rawData.length; i++) {
-      const pixel = rawData[i];
-      const alpha = pixel >>> 24 & 255;
-      const isTransparent = alpha === 0;
-      const colorKey = isTransparent ? transparentColor : pixel >>> 0;
-      let id = colorMap.get(colorKey);
-      if (id === void 0) {
-        id = colorMap.size;
-        colorMap.set(colorKey, id);
-      }
-      indexedData[i] = id;
-    }
-    const palette = Uint32Array.from(colorMap.keys());
-    return new _IndexedImage(width, height, indexedData, palette, transparentPalletIndex);
-  }
-  /**
-   * Retrieves the 32-bit packed color value at the given coordinates.
-   * @param x - X coordinate.
-   * @param y - Y coordinate.
-   * @returns The packed color from the palette.
-   */
-  getColorAt(x, y) {
-    const index = x + y * this.width;
-    const paletteIndex = this.data[index];
-    return this.palette[paletteIndex];
-  }
-};
-
 // src/IndexedImage/getIndexedImageColorCounts.ts
 function getIndexedImageColorCounts(indexedImage) {
   const data = indexedImage.data;
   const palette = indexedImage.palette;
-  const frequencies = new Int32Array(palette.length);
+  const frequencies = new Uint32Array(palette.length);
   for (let i = 0; i < data.length; i++) {
     const colorIndex = data[i];
     frequencies[colorIndex]++;
@@ -4046,6 +4109,48 @@ function getIndexedImageColorCounts(indexedImage) {
   return frequencies;
 }
 
+// src/IndexedImage/IndexedImage.ts
+function makeIndexedImage(width, height, data, palette, transparentPalletIndex) {
+  return {
+    w: width,
+    h: height,
+    data,
+    palette,
+    transparentPalletIndex
+  };
+}
+function makeIndexedImageFromImageDataRaw(data, width, height) {
+  const buffer = data.buffer;
+  const rawData = new Uint32Array(buffer);
+  const indexedData = new Uint32Array(rawData.length);
+  const colorMap = /* @__PURE__ */ new Map();
+  const transparentColor = 0;
+  const transparentPalletIndex = 0;
+  colorMap.set(transparentColor, transparentPalletIndex);
+  for (let i = 0; i < rawData.length; i++) {
+    const pixel = rawData[i];
+    const alpha = pixel >>> 24 & 255;
+    const isTransparent = alpha === 0;
+    const colorKey = isTransparent ? transparentColor : pixel >>> 0;
+    let id = colorMap.get(colorKey);
+    if (id === void 0) {
+      id = colorMap.size;
+      colorMap.set(colorKey, id);
+    }
+    indexedData[i] = id;
+  }
+  const palette = Uint32Array.from(colorMap.keys());
+  return makeIndexedImage(width, height, indexedData, palette, transparentPalletIndex);
+}
+function makeIndexedImageFromImageData(imageData) {
+  return makeIndexedImageFromImageDataRaw(imageData.data, imageData.width, imageData.height);
+}
+function getIndexedImageColor(target, x, y) {
+  const index = x + y * target.w;
+  const paletteIndex = target.data[index];
+  return target.palette[paletteIndex];
+}
+
 // src/IndexedImage/indexedImageToAverageColor.ts
 function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
   const {
@@ -4095,29 +4200,27 @@ function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
 // src/IndexedImage/indexedImageToImageData.ts
 function indexedImageToImageData(indexedImage) {
   const {
-    width,
-    height,
+    w,
+    h,
     data,
     palette
   } = indexedImage;
-  const result = new ImageData(width, height);
+  const result = new ImageData(w, h);
   const data32 = new Uint32Array(result.data.buffer);
   for (let i = 0; i < data.length; i++) {
     const paletteIndex = data[i];
-    const color = palette[paletteIndex];
-    data32[i] = color;
+    data32[i] = palette[paletteIndex];
   }
   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);
+  const output = {
+    palette: source.palette,
+    transparentPalletIndex: source.transparentPalletIndex
+  };
+  return resampleUint32Array(source.data, source.w, source.h, factor, output);
 }
 
 // src/Input/fileInputChangeToImageData.ts
@@ -4193,16 +4296,6 @@ function makeAlphaMask(w, h, data) {
   };
 }
 
-// src/Mask/BinaryMask.ts
-function makeBinaryMask(w, h, data) {
-  return {
-    type: 1 /* BINARY */,
-    data: data ?? new Uint8Array(w * h),
-    w,
-    h
-  };
-}
-
 // src/Mask/applyBinaryMaskToAlphaMask.ts
 function applyBinaryMaskToAlphaMask(alphaMaskDst, binaryMaskSrc, opts) {
   const targetX = opts?.x ?? 0;
@@ -4272,6 +4365,215 @@ function applyBinaryMaskToAlphaMask(alphaMaskDst, binaryMaskSrc, opts) {
   }
 }
 
+// src/Mask/BinaryMask.ts
+function makeBinaryMask(w, h, data) {
+  return {
+    type: 1 /* BINARY */,
+    data: data ?? new Uint8Array(w * h),
+    w,
+    h
+  };
+}
+
+// src/Mask/BinaryMask/makeBinaryMaskFromAlphaMask.ts
+function makeBinaryMaskFromAlphaMask(mask, threshold, out) {
+  const w = mask.w;
+  const h = mask.h;
+  const alphaData = mask.data;
+  const area = w * h;
+  const binaryData = new Uint8Array(area);
+  for (let i = 0; i < area; i++) {
+    if (alphaData[i] >= threshold) {
+      binaryData[i] = 1;
+    }
+  }
+  out = out ?? {
+    type: 1 /* BINARY */
+  };
+  out.data = binaryData;
+  out.w = w;
+  out.h = h;
+  return out;
+}
+
+// src/Mask/BinaryMask/makeBinaryMaskOutline.ts
+function makeBinaryMaskOutline(mask, scale = 1) {
+  const w = mask.w;
+  const h = mask.h;
+  const maskData = mask.data;
+  const size = w * scale + 2;
+  const outData = new Uint8Array(size * size);
+  for (let iy = 0; iy < h; iy++) {
+    for (let ix = 0; ix < w; ix++) {
+      const i = iy * w + ix;
+      if (maskData[i] === 0) continue;
+      const lx = ix * scale + 1;
+      const ly = iy * scale + 1;
+      const top = iy === 0 || maskData[i - w] === 0;
+      const bottom = iy === h - 1 || maskData[i + w] === 0;
+      const left = ix === 0 || maskData[i - 1] === 0;
+      const right = ix === w - 1 || maskData[i + 1] === 0;
+      const topLeft = iy === 0 || ix === 0 || maskData[i - w - 1] === 0;
+      const topRight = iy === 0 || ix === w - 1 || maskData[i - w + 1] === 0;
+      const bottomLeft = iy === h - 1 || ix === 0 || maskData[i + w - 1] === 0;
+      const bottomRight = iy === h - 1 || ix === w - 1 || maskData[i + w + 1] === 0;
+      if (top) {
+        for (let sx = 0; sx < scale; sx++) {
+          const outIdx = (ly - 1) * size + (lx + sx);
+          outData[outIdx] = 1;
+        }
+      }
+      if (bottom) {
+        for (let sx = 0; sx < scale; sx++) {
+          const outIdx = (ly + scale) * size + (lx + sx);
+          outData[outIdx] = 1;
+        }
+      }
+      if (left) {
+        for (let sy = 0; sy < scale; sy++) {
+          const outIdx = (ly + sy) * size + (lx - 1);
+          outData[outIdx] = 1;
+        }
+      }
+      if (right) {
+        for (let sy = 0; sy < scale; sy++) {
+          const outIdx = (ly + sy) * size + (lx + scale);
+          outData[outIdx] = 1;
+        }
+      }
+      if (topLeft) {
+        const outIdx = (ly - 1) * size + (lx - 1);
+        outData[outIdx] = 1;
+      }
+      if (topRight) {
+        const outIdx = (ly - 1) * size + (lx + scale);
+        outData[outIdx] = 1;
+      }
+      if (bottomLeft) {
+        const outIdx = (ly + scale) * size + (lx - 1);
+        outData[outIdx] = 1;
+      }
+      if (bottomRight) {
+        const outIdx = (ly + scale) * size + (lx + scale);
+        outData[outIdx] = 1;
+      }
+    }
+  }
+  return {
+    type: 1 /* BINARY */,
+    w: size,
+    h: size,
+    data: outData
+  };
+}
+
+// src/Mask/BinaryMask/makeCircleBinaryMaskOutline.ts
+function makeCircleBinaryMaskOutline(size, scale) {
+  const outSize = size * scale + 2;
+  const outArea = outSize * outSize;
+  const data = new Uint8Array(outArea);
+  const radius = size / 2;
+  const r2 = radius * radius;
+  let prevMinX = -1;
+  let prevMaxX = -1;
+  let currMinX = -1;
+  let currMaxX = -1;
+  const initialDy = 0 - radius + 0.5;
+  const initialDy2 = initialDy * initialDy;
+  if (initialDy2 <= r2) {
+    const dx = Math.sqrt(r2 - initialDy2);
+    currMinX = Math.ceil(radius - 0.5 - dx);
+    currMaxX = Math.floor(radius - 0.5 + dx);
+  }
+  for (let iy = 0; iy < size; iy++) {
+    let nextMinX = -1;
+    let nextMaxX = -1;
+    if (iy + 1 < size) {
+      const ny = iy + 1 - radius + 0.5;
+      const ny2 = ny * ny;
+      if (ny2 <= r2) {
+        const dx = Math.sqrt(r2 - ny2);
+        nextMinX = Math.ceil(radius - 0.5 - dx);
+        nextMaxX = Math.floor(radius - 0.5 + dx);
+      }
+    }
+    if (currMinX !== -1) {
+      for (let ix = currMinX; ix <= currMaxX; ix++) {
+        const sx = ix * scale + 1;
+        const sy = iy * scale + 1;
+        const isTop = prevMinX === -1 || ix < prevMinX || ix > prevMaxX;
+        const isBottom = nextMinX === -1 || ix < nextMinX || ix > nextMaxX;
+        const isLeft = ix === currMinX;
+        const isRight = ix === currMaxX;
+        if (isTop) {
+          const leftOut = prevMinX === -1 || ix - 1 < prevMinX || ix - 1 > prevMaxX;
+          const rightOut = prevMinX === -1 || ix + 1 < prevMinX || ix + 1 > prevMaxX;
+          const startX = leftOut ? sx - 1 : sx;
+          const endX = rightOut ? sx + scale : sx + scale - 1;
+          for (let x = startX; x <= endX; x++) {
+            const index = (sy - 1) * outSize + x;
+            data[index] = 1;
+          }
+        }
+        if (isBottom) {
+          const leftOut = nextMinX === -1 || ix - 1 < nextMinX || ix - 1 > nextMaxX;
+          const rightOut = nextMinX === -1 || ix + 1 < nextMinX || ix + 1 > nextMaxX;
+          const startX = leftOut ? sx - 1 : sx;
+          const endX = rightOut ? sx + scale : sx + scale - 1;
+          for (let x = startX; x <= endX; x++) {
+            const index = (sy + scale) * outSize + x;
+            data[index] = 1;
+          }
+        }
+        if (isLeft) {
+          for (let y = sy; y < sy + scale; y++) {
+            const index = y * outSize + (sx - 1);
+            data[index] = 1;
+          }
+        }
+        if (isRight) {
+          for (let y = sy; y < sy + scale; y++) {
+            const index = y * outSize + (sx + scale);
+            data[index] = 1;
+          }
+        }
+      }
+    }
+    prevMinX = currMinX;
+    prevMaxX = currMaxX;
+    currMinX = nextMinX;
+    currMaxX = nextMaxX;
+  }
+  return {
+    type: 1 /* BINARY */,
+    w: outSize,
+    h: outSize,
+    data
+  };
+}
+
+// src/Mask/BinaryMask/makeRectBinaryMaskOutline.ts
+function makeRectBinaryMaskOutline(w, h, scale = 1) {
+  const rw = w * scale;
+  const rh = h * scale;
+  const outW = rw + 2;
+  const outH = rh + 2;
+  const outData = new Uint8Array(outW * outH);
+  outData.fill(1, 0, outW);
+  outData.fill(1, (outH - 1) * outW, outH * outW);
+  for (let iy = 1; iy < outH - 1; iy++) {
+    const rowStart = iy * outW;
+    outData[rowStart] = 1;
+    outData[rowStart + outW - 1] = 1;
+  }
+  return {
+    type: 1 /* BINARY */,
+    w: outW,
+    h: outH,
+    data: outData
+  };
+}
+
 // src/Mask/copyMask.ts
 function copyMask(src) {
   return {
@@ -4379,7 +4681,8 @@ function mergeAlphaMasks(dst, src, opts) {
       } else if (globalAlpha === 255) {
         weight = effectiveM;
       } else {
-        weight = effectiveM * globalAlpha + 128 >> 8;
+        const t = effectiveM * globalAlpha + 128;
+        weight = t + (t >> 8) >> 8;
       }
       if (weight !== 255) {
         if (weight === 0) {
@@ -4389,7 +4692,8 @@ function mergeAlphaMasks(dst, src, opts) {
           if (da === 255) {
             dstData[dIdx] = weight;
           } else if (da !== 0) {
-            dstData[dIdx] = da * weight + 128 >> 8;
+            const t = da * weight + 128;
+            dstData[dIdx] = t + (t >> 8) >> 8;
           }
         }
       }
@@ -4550,92 +4854,758 @@ function merge2BinaryMaskRects(a, b) {
       }
     }
   }
-  return {
-    ...bounds,
-    data: maskData,
-    type: 1 /* BINARY */
-  };
-}
-
-// src/MaskRect/mergeBinaryMaskRects.ts
-function mergeBinaryMaskRects(current, adding) {
-  const rects = [...current, ...adding];
-  let changed = true;
-  while (changed) {
-    changed = false;
-    const next = [];
-    for (const r of rects) {
-      let merged = false;
-      for (let i = 0; i < next.length; i++) {
-        const n = next[i];
-        const overlap = r.x <= n.x + n.w && r.x + r.w >= n.x && r.y <= n.y + n.h && r.y + r.h >= n.y;
-        if (overlap) {
-          next[i] = merge2BinaryMaskRects(n, r);
-          merged = true;
+  return {
+    ...bounds,
+    data: maskData,
+    type: 1 /* BINARY */
+  };
+}
+
+// src/MaskRect/mergeBinaryMaskRects.ts
+function mergeBinaryMaskRects(current, adding) {
+  const rects = [...current, ...adding];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const next = [];
+    for (const r of rects) {
+      let merged = false;
+      for (let i = 0; i < next.length; i++) {
+        const n = next[i];
+        const overlap = r.x <= n.x + n.w && r.x + r.w >= n.x && r.y <= n.y + n.h && r.y + r.h >= n.y;
+        if (overlap) {
+          next[i] = merge2BinaryMaskRects(n, r);
+          merged = true;
+          changed = true;
+          break;
+        }
+      }
+      if (!merged) next.push(r);
+    }
+    rects.splice(0, rects.length, ...next);
+  }
+  return rects;
+}
+
+// src/MaskRect/subtractBinaryMaskRects.ts
+function subtractBinaryMaskRects(current, subtracting) {
+  let result = [...current];
+  for (const sub of subtracting) {
+    const next = [];
+    for (const r of result) {
+      const ix = Math.max(r.x, sub.x);
+      const iy = Math.max(r.y, sub.y);
+      const ix2 = Math.min(r.x + r.w, sub.x + sub.w);
+      const iy2 = Math.min(r.y + r.h, sub.y + sub.h);
+      if (ix >= ix2 || iy >= iy2) {
+        next.push(r);
+        continue;
+      }
+      if (r.y < iy) pushPiece(next, r, r.x, r.y, r.w, iy - r.y);
+      if (iy2 < r.y + r.h) pushPiece(next, r, r.x, iy2, r.w, r.y + r.h - iy2);
+      if (r.x < ix) pushPiece(next, r, r.x, iy, ix - r.x, iy2 - iy);
+      if (ix2 < r.x + r.w) pushPiece(next, r, ix2, iy, r.x + r.w - ix2, iy2 - iy);
+    }
+    result = next;
+  }
+  return result;
+}
+function pushPiece(dest, r, x, y, w, h) {
+  if (r.data === null || r.data === void 0) {
+    dest.push({
+      x,
+      y,
+      w,
+      h,
+      data: null,
+      type: null
+    });
+    return;
+  }
+  const lx = x - r.x;
+  const ly = y - r.y;
+  const data = new Uint8Array(w * h);
+  for (let row = 0; row < h; row++) {
+    data.set(r.data.subarray((ly + row) * r.w + lx, (ly + row) * r.w + lx + w), row * w);
+  }
+  dest.push({
+    x,
+    y,
+    w,
+    h,
+    data,
+    type: 1 /* BINARY */
+  });
+}
+
+// src/Paint/_paint-types.ts
+var PaintMaskOutline = /* @__PURE__ */ ((PaintMaskOutline2) => {
+  PaintMaskOutline2[PaintMaskOutline2["MASKED"] = 0] = "MASKED";
+  PaintMaskOutline2[PaintMaskOutline2["CIRCLE"] = 1] = "CIRCLE";
+  PaintMaskOutline2[PaintMaskOutline2["RECT"] = 2] = "RECT";
+  return PaintMaskOutline2;
+})(PaintMaskOutline || {});
+
+// src/Rect/trimRectBounds.ts
+function trimRectBounds(x, y, w, h, targetWidth, targetHeight, out) {
+  const res = out ?? {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  const left = Math.max(0, x);
+  const top = Math.max(0, y);
+  const right = Math.min(targetWidth, x + w);
+  const bottom = Math.min(targetHeight, y + h);
+  res.x = left;
+  res.y = top;
+  res.w = Math.max(0, right - left);
+  res.h = Math.max(0, bottom - top);
+  return res;
+}
+
+// src/Paint/eachTileInBounds.ts
+function eachTileInBounds(config, lookup, tilePool, bounds, callback) {
+  const {
+    tileShift,
+    targetColumns,
+    targetRows,
+    tileSize
+  } = config;
+  const x1 = Math.max(0, bounds.x >> tileShift);
+  const y1 = Math.max(0, bounds.y >> tileShift);
+  const x2 = Math.min(targetColumns - 1, bounds.x + bounds.w - 1 >> tileShift);
+  const y2 = Math.min(targetRows - 1, bounds.y + bounds.h - 1 >> tileShift);
+  if (x1 > x2 || y1 > y2) return;
+  for (let ty = y1; ty <= y2; ty++) {
+    const rowOffset = ty * targetColumns;
+    const tileTop = ty << tileShift;
+    for (let tx = x1; tx <= x2; tx++) {
+      const id = rowOffset + tx;
+      const tile = lookup[id] ?? (lookup[id] = tilePool.getTile(id, tx, ty));
+      const tileLeft = tx << tileShift;
+      const startX = bounds.x > tileLeft ? bounds.x : tileLeft;
+      const startY = bounds.y > tileTop ? bounds.y : tileTop;
+      const maskEndX = bounds.x + bounds.w;
+      const tileEndX = tileLeft + tileSize;
+      const endX = maskEndX < tileEndX ? maskEndX : tileEndX;
+      const maskEndY = bounds.y + bounds.h;
+      const tileEndY = tileTop + tileSize;
+      const endY = maskEndY < tileEndY ? maskEndY : tileEndY;
+      callback(tile, startX, startY, endX - startX, endY - startY);
+    }
+  }
+}
+
+// src/Paint/AlphaMaskPaintBuffer.ts
+var AlphaMaskPaintBuffer = class {
+  constructor(config, tilePool) {
+    this.config = config;
+    this.tilePool = tilePool;
+    this.lookup = [];
+  }
+  lookup;
+  scratchBounds = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  blendColorPixelDataAlphaMaskFn = blendColorPixelDataAlphaMask;
+  forEachLinePointFn = forEachLinePoint;
+  trimRectBoundsFn = trimRectBounds;
+  eachTileInBoundsFn = eachTileInBounds;
+  paintAlphaMask(brush, x0, y0, x1 = x0, y1 = y0) {
+    const scratch = this.scratchBounds;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    const config = this.config;
+    const tileShift = config.tileShift;
+    const tileMask = config.tileMask;
+    const target = config.target;
+    const {
+      w: bW,
+      h: bH,
+      data: bD,
+      centerOffsetX,
+      centerOffsetY
+    } = brush;
+    let changed = false;
+    const eachTileInBoundsFn = this.eachTileInBoundsFn;
+    const trimRectBoundsFn = this.trimRectBoundsFn;
+    this.forEachLinePointFn(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBoundsFn(topLeftX, topLeftY, bW, bH, target.w, target.h, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      eachTileInBoundsFn(config, lookup, tilePool, scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const data = tile.data;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const bOff = (canvasY - topLeftY) * bW;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const canvasX = bX + j;
+            const brushA = bD[bOff + (canvasX - topLeftX)];
+            if (brushA === 0) continue;
+            const idx = dS + j;
+            if (brushA > data[idx]) {
+              data[idx] = brushA;
+              tileChanged = true;
+            }
+          }
+        }
+        if (tileChanged) changed = true;
+      });
+    });
+    return changed;
+  }
+  paintBinaryMask(brush, alpha, x0, y0, x1 = x0, y1 = y0) {
+    if (alpha === 0) return false;
+    const scratch = this.scratchBounds;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    const config = this.config;
+    const tileShift = config.tileShift;
+    const tileMask = config.tileMask;
+    const target = config.target;
+    const {
+      w: bW,
+      h: bH,
+      data: bD,
+      centerOffsetX,
+      centerOffsetY
+    } = brush;
+    let changed = false;
+    const trimRectBoundsFn = this.trimRectBoundsFn;
+    const eachTileInBoundsFn = this.eachTileInBoundsFn;
+    this.forEachLinePointFn(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBoundsFn(topLeftX, topLeftY, bW, bH, target.w, target.h, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      eachTileInBoundsFn(config, lookup, tilePool, scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const data = tile.data;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const bOff = (canvasY - topLeftY) * bW;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const canvasX = bX + j;
+            if (bD[bOff + (canvasX - topLeftX)]) {
+              const idx = dS + j;
+              if (data[idx] < alpha) {
+                data[idx] = alpha;
+                tileChanged = true;
+              }
+            }
+          }
+        }
+        if (tileChanged) changed = true;
+      });
+    });
+    return changed;
+  }
+  paintRect(alpha, brushWidth, brushHeight, x0, y0, x1 = x0, y1 = y0) {
+    const scratch = this.scratchBounds;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    const config = this.config;
+    const tileShift = config.tileShift;
+    const tileMask = config.tileMask;
+    const target = config.target;
+    const centerOffsetX = -(brushWidth - 1 >> 1);
+    const centerOffsetY = -(brushHeight - 1 >> 1);
+    const trimRectBoundsFn = this.trimRectBoundsFn;
+    const eachTileInBoundsFn = this.eachTileInBoundsFn;
+    let changed = false;
+    this.forEachLinePointFn(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBoundsFn(topLeftX, topLeftY, brushWidth, brushHeight, target.w, target.h, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      eachTileInBoundsFn(config, lookup, tilePool, scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const data = tile.data;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const idx = dS + j;
+            if (alpha > data[idx]) {
+              data[idx] = alpha;
+              tileChanged = true;
+            }
+          }
+        }
+        if (tileChanged) {
+          changed = true;
+        }
+      });
+    });
+    return changed;
+  }
+  opts = {
+    alpha: 255,
+    blendFn: sourceOverPerfect,
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  commit(accumulator, color, alpha = 255, blendFn = sourceOverPerfect) {
+    const blendColorPixelDataAlphaMaskFn = this.blendColorPixelDataAlphaMaskFn;
+    const tileShift = this.config.tileShift;
+    const lookup = this.lookup;
+    const opts = this.opts;
+    opts.alpha = alpha;
+    opts.blendFn = blendFn;
+    for (let i = 0; i < lookup.length; i++) {
+      const tile = lookup[i];
+      if (tile) {
+        const didChange = accumulator.storeTileBeforeState(tile.id, tile.tx, tile.ty);
+        const dx = tile.tx << tileShift;
+        const dy = tile.ty << tileShift;
+        opts.x = dx;
+        opts.y = dy;
+        opts.w = tile.w;
+        opts.h = tile.h;
+        didChange(blendColorPixelDataAlphaMaskFn(this.config.target, color, tile, opts));
+      }
+    }
+    this.clear();
+  }
+  clear() {
+    this.tilePool.releaseTiles(this.lookup);
+  }
+};
+
+// src/Paint/AlphaMaskPaintBufferCanvasRenderer.ts
+function makeAlphaMaskPaintBufferCanvasRenderer(paintBuffer, offscreenCanvasClass = OffscreenCanvas) {
+  const config = paintBuffer.config;
+  const tileSize = config.tileSize;
+  const tileShift = config.tileShift;
+  const tileArea = config.tileArea;
+  const lookup = paintBuffer.lookup;
+  const canvas = new offscreenCanvasClass(tileSize, tileSize);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error(CANVAS_CTX_FAILED);
+  ctx.imageSmoothingEnabled = false;
+  const bridge = makePixelData(new ImageData(tileSize, tileSize));
+  const view32 = bridge.data;
+  return function drawPaintBuffer(targetCtx, color, alpha = 255, compOperation = "source-over") {
+    if (alpha === 0) return;
+    const baseSrcAlpha = color >>> 24;
+    const colorRGB = color & 16777215;
+    if (baseSrcAlpha === 0) return;
+    targetCtx.globalAlpha = alpha / 255;
+    targetCtx.globalCompositeOperation = compOperation;
+    for (let i = 0; i < lookup.length; i++) {
+      const tile = lookup[i];
+      if (tile) {
+        const data8 = tile.data;
+        view32.fill(0);
+        for (let p = 0; p < tileArea; p++) {
+          const maskA = data8[p];
+          if (maskA === 0) continue;
+          if (maskA === 255) {
+            view32[p] = color;
+          } else {
+            const t = baseSrcAlpha * maskA + 128;
+            const finalA = t + (t >> 8) >> 8;
+            view32[p] = (colorRGB | finalA << 24) >>> 0;
+          }
+        }
+        const dx = tile.tx << tileShift;
+        const dy = tile.ty << tileShift;
+        ctx.putImageData(bridge.imageData, 0, 0);
+        targetCtx.drawImage(canvas, dx, dy);
+      }
+    }
+    targetCtx.globalAlpha = 1;
+    targetCtx.globalCompositeOperation = "source-over";
+  };
+}
+
+// src/Paint/BinaryMaskPaintBuffer.ts
+var BinaryMaskPaintBuffer = class {
+  constructor(config, tilePool) {
+    this.config = config;
+    this.tilePool = tilePool;
+    this.lookup = [];
+  }
+  lookup;
+  scratchBounds = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  blendColorPixelDataBinaryMaskFn = blendColorPixelDataBinaryMask;
+  forEachLinePointFn = forEachLinePoint;
+  trimRectBoundsFn = trimRectBounds;
+  eachTileInBoundsFn = eachTileInBounds;
+  paintBinaryMask(brush, x0, y0, x1 = x0, y1 = y0) {
+    const scratch = this.scratchBounds;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    const config = this.config;
+    const tileShift = config.tileShift;
+    const tileMask = config.tileMask;
+    const target = config.target;
+    const {
+      w: bW,
+      h: bH,
+      data: bD,
+      centerOffsetX,
+      centerOffsetY
+    } = brush;
+    let changed = false;
+    const trimRectBoundsFn = this.trimRectBoundsFn;
+    const eachTileInBoundsFn = this.eachTileInBoundsFn;
+    this.forEachLinePointFn(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBoundsFn(topLeftX, topLeftY, bW, bH, target.w, target.h, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      eachTileInBoundsFn(config, lookup, tilePool, scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const data = tile.data;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const bOff = (canvasY - topLeftY) * bW;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const canvasX = bX + j;
+            if (bD[bOff + (canvasX - topLeftX)]) {
+              const idx = dS + j;
+              if (data[idx] === 0) {
+                data[idx] = 1;
+                tileChanged = true;
+              }
+            }
+          }
+        }
+        if (tileChanged) changed = true;
+      });
+    });
+    return changed;
+  }
+  paintRect(brushWidth, brushHeight, x0, y0, x1 = x0, y1 = y0) {
+    const scratch = this.scratchBounds;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    const config = this.config;
+    const tileShift = config.tileShift;
+    const tileMask = config.tileMask;
+    const target = config.target;
+    const centerOffsetX = -(brushWidth - 1 >> 1);
+    const centerOffsetY = -(brushHeight - 1 >> 1);
+    const trimRectBoundsFn = this.trimRectBoundsFn;
+    const eachTileInBoundsFn = this.eachTileInBoundsFn;
+    let changed = false;
+    this.forEachLinePointFn(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBoundsFn(topLeftX, topLeftY, brushWidth, brushHeight, target.w, target.h, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      eachTileInBoundsFn(config, lookup, tilePool, scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const data = tile.data;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const idx = dS + j;
+            if (data[idx] === 0) {
+              data[idx] = 1;
+              tileChanged = true;
+            }
+          }
+        }
+        if (tileChanged) {
+          changed = true;
+        }
+      });
+    });
+    return changed;
+  }
+  opts = {
+    alpha: 255,
+    blendFn: sourceOverPerfect,
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  commit(accumulator, color, alpha = 255, blendFn = sourceOverPerfect) {
+    const blendColorPixelDataBinaryMaskFn = this.blendColorPixelDataBinaryMaskFn;
+    const tileShift = this.config.tileShift;
+    const lookup = this.lookup;
+    const opts = this.opts;
+    opts.alpha = alpha;
+    opts.blendFn = blendFn;
+    for (let i = 0; i < lookup.length; i++) {
+      const tile = lookup[i];
+      if (tile) {
+        const didChange = accumulator.storeTileBeforeState(tile.id, tile.tx, tile.ty);
+        const dx = tile.tx << tileShift;
+        const dy = tile.ty << tileShift;
+        opts.x = dx;
+        opts.y = dy;
+        opts.w = tile.w;
+        opts.h = tile.h;
+        didChange(blendColorPixelDataBinaryMaskFn(this.config.target, color, tile, opts));
+      }
+    }
+    this.clear();
+  }
+  clear() {
+    this.tilePool.releaseTiles(this.lookup);
+  }
+};
+
+// src/Paint/BinaryMaskPaintBufferCanvasRenderer.ts
+function makeBinaryMaskPaintBufferCanvasRenderer(paintBuffer, offscreenCanvasClass = OffscreenCanvas) {
+  const config = paintBuffer.config;
+  const tileSize = config.tileSize;
+  const tileShift = config.tileShift;
+  const tileArea = config.tileArea;
+  const lookup = paintBuffer.lookup;
+  const canvas = new offscreenCanvasClass(tileSize, tileSize);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error(CANVAS_CTX_FAILED);
+  ctx.imageSmoothingEnabled = false;
+  const bridge = makePixelData(new ImageData(tileSize, tileSize));
+  const view32 = bridge.data;
+  return function drawPaintBuffer(targetCtx, color, alpha = 255, compOperation = "source-over") {
+    if (alpha === 0) return;
+    const baseSrcAlpha = color >>> 24;
+    if (baseSrcAlpha === 0) return;
+    targetCtx.globalAlpha = alpha / 255;
+    targetCtx.globalCompositeOperation = compOperation;
+    for (let i = 0; i < lookup.length; i++) {
+      const tile = lookup[i];
+      if (tile) {
+        const data8 = tile.data;
+        view32.fill(0);
+        for (let p = 0; p < tileArea; p++) {
+          if (data8[p] === 1) {
+            view32[p] = color;
+          }
+        }
+        const dx = tile.tx << tileShift;
+        const dy = tile.ty << tileShift;
+        ctx.putImageData(bridge.imageData, 0, 0);
+        targetCtx.drawImage(canvas, dx, dy);
+      }
+    }
+    targetCtx.globalAlpha = 1;
+    targetCtx.globalCompositeOperation = "source-over";
+  };
+}
+
+// src/Paint/ColorPaintBuffer.ts
+var ColorPaintBuffer = class {
+  constructor(config, tilePool, blendPixelDataFn = blendPixelData) {
+    this.config = config;
+    this.tilePool = tilePool;
+    this.blendPixelDataFn = blendPixelDataFn;
+    this.lookup = [];
+  }
+  lookup;
+  scratchBounds = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  paintAlphaMask(color, brush, x0, y0, x1 = x0, y1 = y0) {
+    const cA = color >>> 24;
+    if (cA === 0) return false;
+    const scratch = this.scratchBounds;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    const config = this.config;
+    const tileShift = config.tileShift;
+    const tileMask = config.tileMask;
+    const target = config.target;
+    const {
+      w: bW,
+      h: bH,
+      data: bD,
+      centerOffsetX,
+      centerOffsetY
+    } = brush;
+    const cRGB = color & 16777215;
+    let changed = false;
+    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBounds(topLeftX, topLeftY, bW, bH, target.w, target.h, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      eachTileInBounds(config, lookup, tilePool, scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const d32 = tile.data;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const bOff = (canvasY - topLeftY) * bW;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const canvasX = bX + j;
+            const brushA = bD[bOff + (canvasX - topLeftX)];
+            if (brushA === 0) continue;
+            const t = cA * brushA + 128;
+            const blendedA = t + (t >> 8) >> 8;
+            const idx = dS + j;
+            const cur = d32[idx];
+            if (brushA > cur >>> 24) {
+              const next = (cRGB | blendedA << 24) >>> 0;
+              if (cur !== next) {
+                d32[idx] = next;
+                tileChanged = true;
+              }
+            }
+          }
+        }
+        if (tileChanged) changed = true;
+      });
+    });
+    return changed;
+  }
+  paintBinaryMask(color, brush, x0, y0, x1 = x0, y1 = y0) {
+    const alphaIsZero = color >>> 24 === 0;
+    if (alphaIsZero) return false;
+    const scratch = this.scratchBounds;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    const config = this.config;
+    const tileShift = config.tileShift;
+    const tileMask = config.tileMask;
+    const target = config.target;
+    const {
+      w: bW,
+      h: bH,
+      data: bD,
+      centerOffsetX,
+      centerOffsetY
+    } = brush;
+    let changed = false;
+    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBounds(topLeftX, topLeftY, bW, bH, target.w, target.h, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      eachTileInBounds(config, lookup, tilePool, scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const d32 = tile.data;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const bOff = (canvasY - topLeftY) * bW;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const canvasX = bX + j;
+            if (bD[bOff + (canvasX - topLeftX)]) {
+              const idx = dS + j;
+              if (d32[idx] !== color) {
+                d32[idx] = color;
+                tileChanged = true;
+              }
+            }
+          }
+        }
+        if (tileChanged) changed = true;
+      });
+    });
+    return changed;
+  }
+  paintRect(color, brushWidth, brushHeight, x0, y0, x1 = x0, y1 = y0) {
+    const alphaIsZero = color >>> 24 === 0;
+    if (alphaIsZero) return false;
+    const scratch = this.scratchBounds;
+    const lookup = this.lookup;
+    const tilePool = this.tilePool;
+    const config = this.config;
+    const tileShift = config.tileShift;
+    const tileMask = config.tileMask;
+    const target = config.target;
+    const centerOffsetX = -(brushWidth - 1 >> 1);
+    const centerOffsetY = -(brushHeight - 1 >> 1);
+    let changed = false;
+    forEachLinePoint(x0, y0, x1, y1, (px, py) => {
+      const topLeftX = Math.floor(px + centerOffsetX);
+      const topLeftY = Math.floor(py + centerOffsetY);
+      trimRectBounds(topLeftX, topLeftY, brushWidth, brushHeight, target.w, target.h, scratch);
+      if (scratch.w <= 0 || scratch.h <= 0) return;
+      eachTileInBounds(config, lookup, tilePool, scratch, (tile, bX, bY, bW_t, bH_t) => {
+        const d32 = tile.data;
+        let tileChanged = false;
+        for (let i = 0; i < bH_t; i++) {
+          const canvasY = bY + i;
+          const tOff = (canvasY & tileMask) << tileShift;
+          const dS = tOff + (bX & tileMask);
+          for (let j = 0; j < bW_t; j++) {
+            const idx = dS + j;
+            if (d32[idx] !== color) {
+              d32[idx] = color;
+              tileChanged = true;
+            }
+          }
+        }
+        if (tileChanged) {
           changed = true;
-          break;
         }
-      }
-      if (!merged) next.push(r);
-    }
-    rects.splice(0, rects.length, ...next);
+      });
+    });
+    return changed;
   }
-  return rects;
-}
-
-// src/MaskRect/subtractBinaryMaskRects.ts
-function subtractBinaryMaskRects(current, subtracting) {
-  let result = [...current];
-  for (const sub of subtracting) {
-    const next = [];
-    for (const r of result) {
-      const ix = Math.max(r.x, sub.x);
-      const iy = Math.max(r.y, sub.y);
-      const ix2 = Math.min(r.x + r.w, sub.x + sub.w);
-      const iy2 = Math.min(r.y + r.h, sub.y + sub.h);
-      if (ix >= ix2 || iy >= iy2) {
-        next.push(r);
-        continue;
+  opts = {
+    alpha: 255,
+    blendFn: sourceOverPerfect,
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  commit(accumulator, alpha = 255, blendFn = sourceOverPerfect) {
+    const tileShift = this.config.tileShift;
+    const lookup = this.lookup;
+    const opts = this.opts;
+    const blendPixelDataFn = this.blendPixelDataFn;
+    opts.alpha = alpha;
+    opts.blendFn = blendFn;
+    for (let i = 0; i < lookup.length; i++) {
+      const tile = lookup[i];
+      if (tile) {
+        const didChange = accumulator.storeTileBeforeState(tile.id, tile.tx, tile.ty);
+        const dx = tile.tx << tileShift;
+        const dy = tile.ty << tileShift;
+        opts.x = dx;
+        opts.y = dy;
+        opts.w = tile.w;
+        opts.h = tile.h;
+        didChange(blendPixelDataFn(this.config.target, tile, opts));
       }
-      if (r.y < iy) pushPiece(next, r, r.x, r.y, r.w, iy - r.y);
-      if (iy2 < r.y + r.h) pushPiece(next, r, r.x, iy2, r.w, r.y + r.h - iy2);
-      if (r.x < ix) pushPiece(next, r, r.x, iy, ix - r.x, iy2 - iy);
-      if (ix2 < r.x + r.w) pushPiece(next, r, ix2, iy, r.x + r.w - ix2, iy2 - iy);
     }
-    result = next;
-  }
-  return result;
-}
-function pushPiece(dest, r, x, y, w, h) {
-  if (r.data === null || r.data === void 0) {
-    dest.push({
-      x,
-      y,
-      w,
-      h,
-      data: null,
-      type: null
-    });
-    return;
+    this.clear();
   }
-  const lx = x - r.x;
-  const ly = y - r.y;
-  const data = new Uint8Array(w * h);
-  for (let row = 0; row < h; row++) {
-    data.set(r.data.subarray((ly + row) * r.w + lx, (ly + row) * r.w + lx + w), row * w);
+  clear() {
+    this.tilePool.releaseTiles(this.lookup);
   }
-  dest.push({
-    x,
-    y,
-    w,
-    h,
-    data,
-    type: 1 /* BINARY */
-  });
-}
+};
 
-// src/Paint/PaintBufferCanvasRenderer.ts
-function makePaintBufferCanvasRenderer(paintBuffer, offscreenCanvasClass = OffscreenCanvas) {
+// src/Paint/ColorPaintBufferCanvasRenderer.ts
+function makeColorPaintBufferCanvasRenderer(paintBuffer, offscreenCanvasClass = OffscreenCanvas) {
   const config = paintBuffer.config;
   const tileSize = config.tileSize;
   const tileShift = config.tileShift;
@@ -4661,7 +5631,7 @@ function makePaintBufferCanvasRenderer(paintBuffer, offscreenCanvasClass = Offsc
   };
 }
 
-// src/Paint/makeCirclePaintAlphaMask.ts
+// src/Paint/makeCirclePaintMask.ts
 function makeCirclePaintAlphaMask(size, fallOff = (d) => d) {
   const area = size * size;
   const data = new Uint8Array(area);
@@ -4687,6 +5657,7 @@ function makeCirclePaintAlphaMask(size, fallOff = (d) => d) {
   }
   return {
     type: 0 /* ALPHA */,
+    outlineType: 1 /* CIRCLE */,
     data,
     w: size,
     h: size,
@@ -4694,28 +5665,28 @@ function makeCirclePaintAlphaMask(size, fallOff = (d) => d) {
     centerOffsetY: centerOffset
   };
 }
-
-// src/Paint/makeCirclePaintBinaryMask.ts
 function makeCirclePaintBinaryMask(size) {
   const area = size * size;
   const data = new Uint8Array(area);
   const radius = size / 2;
-  const centerOffset = -Math.ceil(radius - 0.5);
+  const r2 = radius * radius;
   for (let y = 0; y < size; y++) {
     for (let x = 0; x < size; x++) {
       const dx = x - radius + 0.5;
       const dy = y - radius + 0.5;
       const distSqr = dx * dx + dy * dy;
-      if (distSqr <= radius * radius) {
+      if (distSqr <= r2) {
         data[y * size + x] = 1;
       }
     }
   }
+  const centerOffset = -Math.ceil(radius - 0.5);
   return {
     type: 1 /* BINARY */,
-    data,
+    outlineType: 1 /* CIRCLE */,
     w: size,
     h: size,
+    data,
     centerOffsetX: centerOffset,
     centerOffsetY: centerOffset
   };
@@ -4725,6 +5696,7 @@ function makeCirclePaintBinaryMask(size) {
 function makePaintBinaryMask(mask) {
   return {
     type: 1 /* BINARY */,
+    outlineType: 0 /* MASKED */,
     data: mask.data,
     w: mask.w,
     h: mask.h,
@@ -4735,6 +5707,7 @@ function makePaintBinaryMask(mask) {
 function makePaintAlphaMask(mask) {
   return {
     type: 0 /* ALPHA */,
+    outlineType: 0 /* MASKED */,
     data: mask.data,
     w: mask.w,
     h: mask.h,
@@ -4768,6 +5741,7 @@ function makeRectFalloffPaintAlphaMask(width, height, fallOff = (d) => d) {
   }
   return {
     type: 0 /* ALPHA */,
+    outlineType: 2 /* RECT */,
     data,
     w: width,
     h: height,
@@ -4776,26 +5750,110 @@ function makeRectFalloffPaintAlphaMask(width, height, fallOff = (d) => d) {
   };
 }
 
-// src/PixelData/PixelData.ts
-var PixelData = class {
-  data32;
-  imageData;
-  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;
+// src/PixelData/ReusablePixelData.ts
+function makeReusablePixelData() {
+  const pixelData = {
+    w: 0,
+    h: 0,
+    data: null,
+    imageData: null
+  };
+  return function getReusablePixelData(width, height) {
+    if (pixelData.w !== width || pixelData.h !== height) {
+      setPixelData(pixelData, new ImageData(width, height));
+    } else {
+      pixelData.data.fill(0);
+    }
+    return pixelData;
+  };
+}
+
+// src/Paint/PaintCursorRenderer.ts
+function makePaintCursorRenderer(factory = (w, h) => new OffscreenCanvas(w, h)) {
+  const canvas = factory(1, 1);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error(CANVAS_CTX_FAILED);
+  ctx.imageSmoothingEnabled = false;
+  const getPixelData = makeReusablePixelData();
+  let _color = packColor(0, 255, 255, 255);
+  let _scale = 1;
+  let currentMask = {
+    type: 1 /* BINARY */,
+    outlineType: 2 /* RECT */,
+    w: 1,
+    h: 1,
+    centerOffsetX: -(10 - 1 >> 1),
+    centerOffsetY: -(10 - 1 >> 1)
+  };
+  let outline;
+  function update(paintMask, scale, color, alphaThreshold = 127) {
+    currentMask = paintMask ?? currentMask;
+    _scale = scale ?? _scale;
+    _color = color ?? _color;
+    canvas.width = currentMask.w * _scale + 2 * _scale;
+    canvas.height = currentMask.h * _scale + 2 * _scale;
+    if (currentMask.type === 1 /* BINARY */) {
+      if (currentMask.outlineType === 1 /* CIRCLE */) {
+        outline = makeCircleBinaryMaskOutline(currentMask.w, _scale);
+      } else if (currentMask.outlineType === 2 /* RECT */) {
+        outline = makeRectBinaryMaskOutline(currentMask.w, currentMask.h, _scale);
+      } else if (currentMask.outlineType === 0 /* MASKED */) {
+        outline = makeBinaryMaskOutline(currentMask, _scale);
+      }
+    } else if (currentMask.type === 0 /* ALPHA */) {
+      const mask = makeBinaryMaskFromAlphaMask(currentMask, alphaThreshold);
+      outline = makeBinaryMaskOutline(mask, _scale);
+    }
+    const pixelData = getPixelData(outline.w, outline.h);
+    fillPixelDataBinaryMask(pixelData, _color, outline);
+    ctx.putImageData(pixelData.imageData, 0, 0);
   }
-};
+  const boundsScratch = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  function getBounds(centerX, centerY) {
+    boundsScratch.x = centerX + currentMask.centerOffsetX;
+    boundsScratch.y = centerY + currentMask.centerOffsetY;
+    boundsScratch.w = currentMask.w;
+    boundsScratch.h = currentMask.h;
+    return boundsScratch;
+  }
+  const boundsScaledScratch = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  function getOutlineBoundsScaled(centerX, centerY) {
+    boundsScaledScratch.x = centerX * _scale + currentMask.centerOffsetX * _scale - 1;
+    boundsScaledScratch.y = centerY * _scale + currentMask.centerOffsetY * _scale - 1;
+    boundsScaledScratch.w = currentMask.w * _scale;
+    boundsScaledScratch.h = currentMask.h * _scale;
+    return boundsScaledScratch;
+  }
+  function draw(drawCtx, centerX, centerY) {
+    const dx = centerX * _scale + currentMask.centerOffsetX * _scale - 1;
+    const dy = centerY * _scale + currentMask.centerOffsetY * _scale - 1;
+    drawCtx.drawImage(canvas, Math.floor(dx), Math.floor(dy));
+  }
+  function getSettings() {
+    return {
+      color: _color,
+      scale: _scale,
+      currentMask
+    };
+  }
+  return {
+    update,
+    getBounds,
+    getBoundsScaled: getOutlineBoundsScaled,
+    draw,
+    getSettings
+  };
+}
 
 // src/PixelData/applyMaskToPixelData.ts
 function applyMaskToPixelData(dst, mask, opts) {
@@ -4913,8 +5971,8 @@ function fillPixelDataFast(dst, color, _x, _y, _w, _h) {
   if (typeof _x === "object") {
     x = _x.x ?? 0;
     y = _x.y ?? 0;
-    w = _x.w ?? dst.width;
-    h = _x.h ?? dst.height;
+    w = _x.w ?? dst.w;
+    h = _x.h ?? dst.h;
   } else if (typeof _x === "number") {
     x = _x;
     y = _y;
@@ -4923,10 +5981,10 @@ function fillPixelDataFast(dst, color, _x, _y, _w, _h) {
   } else {
     x = 0;
     y = 0;
-    w = dst.width;
-    h = dst.height;
+    w = dst.w;
+    h = dst.h;
   }
-  const clip = resolveRectClipping(x, y, w, h, dst.width, dst.height, SCRATCH_RECT4);
+  const clip = resolveRectClipping(x, y, w, h, dst.w, dst.h, SCRATCH_RECT4);
   if (!clip.inBounds) return;
   const {
     x: finalX,
@@ -4934,9 +5992,9 @@ function fillPixelDataFast(dst, color, _x, _y, _w, _h) {
     w: actualW,
     h: actualH
   } = clip;
-  const dst32 = dst.data32;
-  const dw = dst.width;
-  if (actualW === dw && actualH === dst.height && finalX === 0 && finalY === 0) {
+  const dst32 = dst.data;
+  const dw = dst.w;
+  if (actualW === dw && actualH === dst.h && finalX === 0 && finalY === 0) {
     dst32.fill(color);
     return;
   }
@@ -4952,6 +6010,13 @@ function clearPixelDataFast(dst, rect) {
   fillPixelDataFast(dst, 0, rect);
 }
 
+// src/PixelData/copyPixelData.ts
+function copyPixelData(target) {
+  const data = target.imageData.data;
+  const buffer = new Uint8ClampedArray(data);
+  return makePixelData(new ImageData(buffer, target.w, target.h));
+}
+
 // src/PixelData/extractPixelDataBuffer.ts
 var SCRATCH_BLIT4 = makeClippedBlit();
 function extractPixelDataBuffer(source, _x, _y, _w, _h) {
@@ -4966,9 +6031,9 @@ function extractPixelDataBuffer(source, _x, _y, _w, _h) {
     w: _w,
     h: _h
   };
-  const srcW = source.width;
-  const srcH = source.height;
-  const srcData = source.data32;
+  const srcW = source.w;
+  const srcH = source.h;
+  const srcData = source.data;
   if (w <= 0 || h <= 0) {
     return new Uint32Array(0);
   }
@@ -5005,24 +6070,24 @@ function extractPixelData(source, _x, _y, _w, _h) {
     w: _w,
     h: _h
   };
-  const result = new PixelData(new ImageData(w, h));
+  const result = makePixelData(new ImageData(w, h));
   const buffer = extractPixelDataBuffer(source, x, y, w, h);
-  result.data32.set(buffer);
+  result.data.set(buffer);
   return result;
 }
 
 // src/PixelData/pixelDataToAlphaMask.ts
 function pixelDataToAlphaMask(pixelData) {
   const {
-    data32,
-    width,
-    height
+    data,
+    w,
+    h
   } = pixelData;
-  const len = data32.length;
-  const mask = makeAlphaMask(width, height);
+  const len = data.length;
+  const mask = makeAlphaMask(w, h);
   const maskData = mask.data;
   for (let i = 0; i < len; i++) {
-    const val = data32[i];
+    const val = data[i];
     maskData[i] = val >>> 24 & 255;
   }
   return mask;
@@ -5030,9 +6095,9 @@ function pixelDataToAlphaMask(pixelData) {
 
 // src/PixelData/reflectPixelData.ts
 function reflectPixelDataHorizontal(pixelData) {
-  const width = pixelData.width;
-  const height = pixelData.height;
-  const data = pixelData.data32;
+  const width = pixelData.w;
+  const height = pixelData.h;
+  const data = pixelData.data;
   const halfWidth = Math.floor(width / 2);
   for (let y = 0; y < height; y++) {
     const rowOffset = y * width;
@@ -5046,9 +6111,9 @@ function reflectPixelDataHorizontal(pixelData) {
   }
 }
 function reflectPixelDataVertical(pixelData) {
-  const width = pixelData.width;
-  const height = pixelData.height;
-  const data = pixelData.data32;
+  const width = pixelData.w;
+  const height = pixelData.h;
+  const data = pixelData.data;
   const halfHeight = Math.floor(height / 2);
   for (let y = 0; y < halfHeight; y++) {
     const topRowOffset = y * width;
@@ -5065,19 +6130,21 @@ 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), width, height));
+  const output = {};
+  const resampled = resampleUint32Array(pixelData.data, pixelData.w, pixelData.h, factor, output);
+  resampled.imageData = uInt32ArrayToImageData(resampled.data, resampled.w, resampled.h);
+  return resampled;
+}
+function resamplePixelDataInPlace(pixelData, factor) {
+  const resampled = resampleUint32Array(pixelData.data, pixelData.w, pixelData.h, factor, pixelData);
+  resampled.imageData = uInt32ArrayToImageData(resampled.data, resampled.w, resampled.h);
 }
 
 // src/PixelData/rotatePixelData.ts
 function rotatePixelData(pixelData) {
-  const width = pixelData.width;
-  const height = pixelData.height;
-  const data = pixelData.data32;
+  const width = pixelData.w;
+  const height = pixelData.h;
+  const data = pixelData.data;
   if (width === height) {
     rotateSquareInPlace(pixelData);
     return;
@@ -5095,11 +6162,11 @@ function rotatePixelData(pixelData) {
     }
   }
   const newImageData = new ImageData(new Uint8ClampedArray(newData32.buffer), newWidth, newHeight);
-  pixelData.set(newImageData);
+  setPixelData(pixelData, newImageData);
 }
 function rotateSquareInPlace(pixelData) {
-  const n = pixelData.width;
-  const data = pixelData.data32;
+  const n = pixelData.w;
+  const data = pixelData.data;
   for (let i = 0; i < n / 2; i++) {
     for (let j = i; j < n - i - 1; j++) {
       const top = i * n + j;
@@ -5115,6 +6182,16 @@ function rotateSquareInPlace(pixelData) {
   }
 }
 
+// src/PixelData/uInt32ArrayToPixelData.ts
+function uInt32ArrayToPixelData(data, width, height) {
+  const buffer = data.buffer;
+  const byteOffset = data.byteOffset;
+  const byteLength = data.byteLength;
+  const clampedArray = new Uint8ClampedArray(buffer, byteOffset, byteLength);
+  const imageData = new ImageData(clampedArray, width, height);
+  return makePixelData(imageData);
+}
+
 // src/PixelData/writePixelDataBuffer.ts
 var SCRATCH_BLIT5 = makeClippedBlit();
 function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
@@ -5129,9 +6206,9 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
     w: _w,
     h: _h
   };
-  const dstW = target.width;
-  const dstH = target.height;
-  const dstData = target.data32;
+  const dstW = target.w;
+  const dstH = target.h;
+  const dstData = target.data;
   const clip = resolveBlitClipping(x, y, 0, 0, w, h, dstW, dstH, w, h, SCRATCH_BLIT5);
   if (!clip.inBounds) return;
   const {
@@ -5158,25 +6235,53 @@ function writePaintBufferToPixelData(target, paintBuffer, writePixelDataBufferFn
     if (tile) {
       const dx = tile.tx << tileShift;
       const dy = tile.ty << tileShift;
-      writePixelDataBufferFn(target, tile.data32, dx, dy, tile.width, tile.height);
+      writePixelDataBufferFn(target, tile.data, dx, dy, tile.w, tile.h);
     }
   }
 }
+
+// src/Tile/MaskTile.ts
+var makeAlphaMaskTile = (id, tx, ty, tileSize, tileArea) => {
+  return {
+    tileType: 1 /* MASK */,
+    type: 0 /* ALPHA */,
+    data: new Uint8Array(tileArea),
+    w: tileSize,
+    h: tileSize,
+    id,
+    tx,
+    ty
+  };
+};
+var makeBinaryMaskTile = (id, tx, ty, tileSize, tileArea) => {
+  return {
+    tileType: 1 /* MASK */,
+    type: 1 /* BINARY */,
+    data: new Uint8Array(tileArea),
+    w: tileSize,
+    h: tileSize,
+    id,
+    tx,
+    ty
+  };
+};
 export {
+  AlphaMaskPaintBuffer,
   BASE_FAST_BLEND_MODE_FUNCTIONS,
   BASE_PERFECT_BLEND_MODE_FUNCTIONS,
   BaseBlendMode,
+  BinaryMaskPaintBuffer,
   CANVAS_COMPOSITE_MAP,
+  ColorPaintBuffer,
+  errors_exports as ERRORS,
   HistoryManager,
-  IndexedImage,
   MaskType,
-  PaintBuffer,
+  PaintMaskOutline,
   PixelAccumulator,
-  PixelData,
   PixelEngineConfig,
-  PixelTile,
-  PixelTilePool,
   PixelWriter,
+  TilePool,
+  TileType,
   UnsupportedFormatError,
   applyAlphaMaskToPixelData,
   applyBinaryMaskToAlphaMask,
@@ -5209,6 +6314,7 @@ export {
   copyImageData,
   copyImageDataLike,
   copyMask,
+  copyPixelData,
   darkenFast,
   darkenPerfect,
   darkerFast,
@@ -5216,10 +6322,19 @@ export {
   deserializeImageData,
   deserializeNullableImageData,
   deserializeRawImageData,
+  destinationAtopFast,
+  destinationAtopPerfect,
+  destinationInFast,
+  destinationInPerfect,
+  destinationOutFast,
+  destinationOutPerfect,
+  destinationOverFast,
+  destinationOverPerfect,
   differenceFast,
   differencePerfect,
   divideFast,
   dividePerfect,
+  eachTileInBounds,
   exclusionFast,
   exclusionPerfect,
   extractImageDataBuffer,
@@ -5235,6 +6350,7 @@ export {
   floodFillSelection,
   forEachLinePoint,
   getImageDataFromClipboard,
+  getIndexedImageColor,
   getIndexedImageColorCounts,
   getRectsBounds,
   getSupportedPixelFormats,
@@ -5245,7 +6361,7 @@ export {
   imageDataToAlphaMaskBuffer,
   imageDataToDataUrl,
   imageDataToImgBlob,
-  imageDataToUInt32Array,
+  imageDataToUint32Array,
   imgBlobToImageData,
   indexedImageToAverageColor,
   indexedImageToImageData,
@@ -5266,26 +6382,42 @@ export {
   linearLightFast,
   linearLightPerfect,
   makeAlphaMask,
+  makeAlphaMaskPaintBufferCanvasRenderer,
+  makeAlphaMaskTile,
   makeBinaryMask,
+  makeBinaryMaskFromAlphaMask,
+  makeBinaryMaskOutline,
+  makeBinaryMaskPaintBufferCanvasRenderer,
+  makeBinaryMaskTile,
   makeBlendModeRegistry,
   makeCanvasFrameRenderer,
+  makeCanvasPixelDataRenderer,
+  makeCircleBinaryMaskOutline,
   makeCirclePaintAlphaMask,
   makeCirclePaintBinaryMask,
   makeClippedBlit,
   makeClippedRect,
+  makeColorPaintBufferCanvasRenderer,
   makeFastBlendModeRegistry,
   makeFullPixelMutator,
   makeHistoryAction,
   makeImageDataLike,
+  makeIndexedImage,
+  makeIndexedImageFromImageData,
+  makeIndexedImageFromImageDataRaw,
   makePaintAlphaMask,
   makePaintBinaryMask,
-  makePaintBufferCanvasRenderer,
+  makePaintCursorRenderer,
   makePerfectBlendModeRegistry,
   makePixelCanvas,
+  makePixelData,
+  makePixelTile,
+  makeRectBinaryMaskOutline,
   makeRectFalloffPaintAlphaMask,
   makeReusableCanvas,
   makeReusableImageData,
   makeReusableOffscreenCanvas,
+  makeReusablePixelData,
   merge2BinaryMaskRects,
   mergeAlphaMasks,
   mergeBinaryMaskRects,
@@ -5301,8 +6433,8 @@ export {
   mutatorBlendColorPaintAlphaMask,
   mutatorBlendColorPaintBinaryMask,
   mutatorBlendColorPaintMask,
+  mutatorBlendColorPaintRect,
   mutatorBlendMask,
-  mutatorBlendPaintRect,
   mutatorBlendPixel,
   mutatorBlendPixelData,
   mutatorClear,
@@ -5322,10 +6454,11 @@ export {
   pixelDataToAlphaMask,
   reflectPixelDataHorizontal,
   reflectPixelDataVertical,
-  resample32,
   resampleImageData,
   resampleIndexedImage,
   resamplePixelData,
+  resamplePixelDataInPlace,
+  resampleUint32Array,
   resizeImageData,
   resolveBlitClipping,
   resolveRectClipping,
@@ -5335,8 +6468,15 @@ export {
   serializeImageData,
   serializeNullableImageData,
   setMaskData,
+  setPixelData,
   softLightFast,
   softLightPerfect,
+  sourceAtopFast,
+  sourceAtopPerfect,
+  sourceInFast,
+  sourceInPerfect,
+  sourceOutFast,
+  sourceOutPerfect,
   sourceOverFast,
   sourceOverPerfect,
   subtractBinaryMaskRects,
@@ -5347,6 +6487,7 @@ export {
   trimRectBounds,
   uInt32ArrayToImageData,
   uInt32ArrayToImageDataLike,
+  uInt32ArrayToPixelData,
   unpackAlpha,
   unpackBlue,
   unpackColor,
@@ -5360,6 +6501,8 @@ export {
   writeImageDataToClipboard,
   writeImgBlobToClipboard,
   writePaintBufferToPixelData,
-  writePixelDataBuffer
+  writePixelDataBuffer,
+  xorFast,
+  xorPerfect
 };
 //# sourceMappingURL=index.prod.js.map