pixel-data-js 0.30.0 → 0.32.0

package/dist/index.prod.js

@@ -86,86 +86,7 @@ function color32ToCssRGBA(color) {
   return `rgba(${r},${g},${b},${alpha})`;
 }
 
-// src/Rect/resolveClipping.ts
-var makeClippedRect = () => ({
-  x: 0,
-  y: 0,
-  w: 0,
-  h: 0,
-  inBounds: false
-});
-var makeClippedBlit = () => ({
-  x: 0,
-  y: 0,
-  sx: 0,
-  sy: 0,
-  w: 0,
-  h: 0,
-  inBounds: false
-});
-function resolveRectClipping(x, y, w, h, boundaryW, boundaryH, out) {
-  if (x < 0) {
-    w += x;
-    x = 0;
-  }
-  if (y < 0) {
-    h += y;
-    y = 0;
-  }
-  const actualW = Math.min(w, boundaryW - x);
-  const actualH = Math.min(h, boundaryH - y);
-  if (actualW <= 0 || actualH <= 0) {
-    out.inBounds = false;
-    return out;
-  }
-  out.x = x;
-  out.y = y;
-  out.w = actualW;
-  out.h = actualH;
-  out.inBounds = true;
-  return out;
-}
-function resolveBlitClipping(x, y, sx, sy, w, h, dstW, dstH, srcW, srcH, out) {
-  if (sx < 0) {
-    x -= sx;
-    w += sx;
-    sx = 0;
-  }
-  if (sy < 0) {
-    y -= sy;
-    h += sy;
-    sy = 0;
-  }
-  w = Math.min(w, srcW - sx);
-  h = Math.min(h, srcH - sy);
-  if (x < 0) {
-    sx -= x;
-    w += x;
-    x = 0;
-  }
-  if (y < 0) {
-    sy -= y;
-    h += y;
-    y = 0;
-  }
-  const actualW = Math.min(w, dstW - x);
-  const actualH = Math.min(h, dstH - y);
-  if (actualW <= 0 || actualH <= 0) {
-    out.inBounds = false;
-    return out;
-  }
-  out.x = x;
-  out.y = y;
-  out.sx = sx;
-  out.sy = sy;
-  out.w = actualW;
-  out.h = actualH;
-  out.inBounds = true;
-  return out;
-}
-
 // src/ImageData/extractImageDataBuffer.ts
-var SCRATCH_BLIT = makeClippedBlit();
 function extractImageDataBuffer(imageData, _x, _y, _w, _h) {
   const {
     x,
@@ -178,28 +99,52 @@ function extractImageDataBuffer(imageData, _x, _y, _w, _h) {
     w: _w,
     h: _h
   };
-  const {
-    width: srcW,
-    height: srcH,
-    data: src
-  } = imageData;
-  if (w <= 0 || h <= 0) return new Uint8ClampedArray(0);
-  const out = new Uint8ClampedArray(w * h * 4);
-  const clip = resolveBlitClipping(0, 0, x, y, w, h, w, h, srcW, srcH, SCRATCH_BLIT);
-  if (!clip.inBounds) return out;
-  const {
-    x: dstX,
-    y: dstY,
-    sx: srcX,
-    sy: srcY,
-    w: copyW,
-    h: copyH
-  } = clip;
-  const rowLen = copyW * 4;
-  for (let row = 0; row < copyH; row++) {
-    const srcStart = ((srcY + row) * srcW + srcX) * 4;
-    const dstStart = ((dstY + row) * w + dstX) * 4;
-    out.set(src.subarray(srcStart, srcStart + rowLen), dstStart);
+  if (w <= 0) return new Uint8ClampedArray(0);
+  if (h <= 0) return new Uint8ClampedArray(0);
+  const srcW = imageData.width;
+  const srcH = imageData.height;
+  const src = imageData.data;
+  const outLen = w * h * 4;
+  const out = new Uint8ClampedArray(outLen);
+  let srcX = x;
+  let srcY = y;
+  let dstX = 0;
+  let dstY = 0;
+  let copyW = w;
+  let copyH = h;
+  if (srcX < 0) {
+    dstX = -srcX;
+    copyW += srcX;
+    srcX = 0;
+  }
+  if (srcY < 0) {
+    dstY = -srcY;
+    copyH += srcY;
+    srcY = 0;
+  }
+  copyW = Math.min(copyW, srcW - srcX);
+  copyH = Math.min(copyH, srcH - srcY);
+  if (copyW <= 0) return out;
+  if (copyH <= 0) return out;
+  const isAligned = src.byteOffset % 4 === 0;
+  if (isAligned) {
+    const srcLen32 = src.byteLength / 4;
+    const src32 = new Uint32Array(src.buffer, src.byteOffset, srcLen32);
+    const out32 = new Uint32Array(out.buffer);
+    for (let row = 0; row < copyH; row++) {
+      const srcStart = (srcY + row) * srcW + srcX;
+      const dstStart = (dstY + row) * w + dstX;
+      const chunk = src32.subarray(srcStart, srcStart + copyW);
+      out32.set(chunk, dstStart);
+    }
+  } else {
+    const rowLen = copyW * 4;
+    for (let row = 0; row < copyH; row++) {
+      const srcStart = ((srcY + row) * srcW + srcX) * 4;
+      const dstStart = ((dstY + row) * w + dstX) * 4;
+      const chunk = src.subarray(srcStart, srcStart + rowLen);
+      out.set(chunk, dstStart);
+    }
   }
   return out;
 }
@@ -2025,6 +1970,67 @@ async function writeImageDataToClipboard(imageData) {
   return writeImgBlobToClipboard(blob);
 }
 
+// src/Control/BatchedQueue.ts
+function makeBatchedQueue(processor, queue) {
+  let activeSet = /* @__PURE__ */ new Set();
+  let processingSet = /* @__PURE__ */ new Set();
+  let scheduled = false;
+  const flush = () => {
+    const current = activeSet;
+    activeSet = processingSet;
+    processingSet = current;
+    scheduled = false;
+    try {
+      processor(processingSet);
+    } finally {
+      processingSet.clear();
+    }
+  };
+  function markDirty(item) {
+    activeSet.add(item);
+    if (!scheduled) {
+      scheduled = true;
+      queue(flush);
+    }
+  }
+  function markMultipleDirty(items) {
+    let len = items.length;
+    if (len === 0) return;
+    for (let i = 0; i < len; i++) {
+      activeSet.add(items[i]);
+    }
+    if (!scheduled) {
+      scheduled = true;
+      queue(flush);
+    }
+  }
+  return {
+    markDirty,
+    markMultipleDirty
+  };
+}
+
+// src/Control/RenderQueue.ts
+function makeRenderQueue(cb) {
+  let needsRender = false;
+  let frameId = 0;
+  const trigger = () => {
+    if (needsRender) return;
+    needsRender = true;
+    frameId = requestAnimationFrame(() => {
+      needsRender = false;
+      cb();
+    });
+  };
+  trigger.cancel = () => {
+    if (needsRender) {
+      cancelAnimationFrame(frameId);
+      needsRender = false;
+    }
+  };
+  return trigger;
+}
+
 // src/History/PixelPatchTiles.ts
 function applyPatchTiles(target, tiles, tileSize) {
   for (let i = 0; i < tiles.length; i++) {
@@ -2587,11 +2593,10 @@ var PixelWriter = class {
    *   throw immediately to prevent silent data loss from a nested extractPatch.
    *
    * @param transaction Callback to be executed inside the transaction.
-   * @param after    Called after both undo and redo — use for generic change notifications.
-   * @param afterUndo Called after undo only — use for dimension or state changes specific to undo.
+   * @param afterUndo Called after undo only.
    * @param afterRedo Called after redo only.
    */
-  withHistory(transaction, after, afterUndo, afterRedo) {
+  withHistory(transaction, afterUndo, afterRedo) {
     if (this._inProgress) {
       throw new Error("withHistory is not re-entrant \u2014 commit or rollback the current operation first");
     }
@@ -2606,10 +2611,10 @@ var PixelWriter = class {
     }
     if (this.accumulator.beforeTiles.length === 0) return;
     const patch = this.accumulator.extractPatch();
-    const action = this.historyActionFactory(this.config, this.accumulator, patch, after, afterUndo, afterRedo);
+    const action = this.historyActionFactory(this.config, this.accumulator, patch, afterUndo, afterRedo);
     this.historyManager.commit(action);
   }
-  resize(newWidth, newHeight, offsetX = 0, offsetY = 0, after, afterUndo, afterRedo, resizeImageDataFn = resizeImageData) {
+  resize(newWidth, newHeight, offsetX = 0, offsetY = 0, afterUndo, afterRedo, resizeImageDataFn = resizeImageData) {
     if (this._inProgress) {
       throw new Error("Cannot resize inside a withHistory callback");
     }
@@ -2625,12 +2630,10 @@ var PixelWriter = class {
       undo: () => {
         setPixelData(target, beforeImageData);
         afterUndo?.(beforeImageData);
-        after?.(beforeImageData);
       },
       redo: () => {
         setPixelData(target, afterImageData);
         afterRedo?.(afterImageData);
-        after?.(afterImageData);
       }
     });
   }
@@ -3582,8 +3585,9 @@ var mutatorBlendPixelData = ((writer, deps = defaults13) => {
 });
 
 // src/PixelData/fillPixelData.ts
-var SCRATCH_RECT = makeClippedRect();
 function fillPixelData(dst, color, _x, _y, _w, _h) {
+  const dstW = dst.w;
+  const dstH = dst.h;
   let x;
   let y;
   let w;
@@ -3591,8 +3595,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.w;
-    h = _x.h ?? dst.h;
+    w = _x.w ?? dstW;
+    h = _x.h ?? dstH;
   } else if (typeof _x === "number") {
     x = _x;
     y = _y;
@@ -3601,24 +3605,42 @@ function fillPixelData(dst, color, _x, _y, _w, _h) {
   } else {
     x = 0;
     y = 0;
-    w = dst.w;
-    h = dst.h;
-  }
-  const clip = resolveRectClipping(x, y, w, h, dst.w, dst.h, SCRATCH_RECT);
-  if (!clip.inBounds) return false;
-  const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH
-  } = clip;
+    w = dstW;
+    h = dstH;
+  }
+  let dstX = x;
+  let dstY = y;
+  let fillW = w;
+  let fillH = h;
+  if (dstX < 0) {
+    fillW += dstX;
+    dstX = 0;
+  }
+  if (dstY < 0) {
+    fillH += dstY;
+    dstY = 0;
+  }
+  fillW = Math.min(fillW, dstW - dstX);
+  fillH = Math.min(fillH, dstH - dstY);
+  if (fillW <= 0) return false;
+  if (fillH <= 0) return false;
   const dst32 = dst.data;
-  const dw = dst.w;
   let hasChanged = false;
-  for (let iy = 0; iy < actualH; iy++) {
-    const rowOffset = (finalY + iy) * dw;
-    const start = rowOffset + finalX;
-    const end = start + actualW;
+  if (dstX === 0 && fillW === dstW) {
+    const start = dstY * dstW;
+    const end = start + fillW * fillH;
+    for (let i = start; i < end; i++) {
+      if (dst32[i] !== color) {
+        dst32[i] = color;
+        hasChanged = true;
+      }
+    }
+    return hasChanged;
+  }
+  for (let iy = 0; iy < fillH; iy++) {
+    const rowOffset = (dstY + iy) * dstW;
+    const start = rowOffset + dstX;
+    const end = start + fillW;
     for (let i = start; i < end; i++) {
       if (dst32[i] !== color) {
         dst32[i] = color;
@@ -3680,39 +3702,48 @@ var mutatorFillRect = ((writer, deps = defaults15) => {
 });
 
 // src/PixelData/fillPixelDataBinaryMask.ts
-var SCRATCH_RECT2 = makeClippedRect();
 function fillPixelDataBinaryMask(target, color, mask, x = 0, y = 0) {
+  const targetW = target.w;
+  const targetH = target.h;
   const maskW = mask.w;
   const maskH = mask.h;
-  const clip = resolveRectClipping(x, y, maskW, maskH, target.w, target.h, SCRATCH_RECT2);
-  if (!clip.inBounds) return false;
-  const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH
-  } = clip;
+  let dstX = x;
+  let dstY = y;
+  let actualW = maskW;
+  let actualH = maskH;
+  if (dstX < 0) {
+    actualW += dstX;
+    dstX = 0;
+  }
+  if (dstY < 0) {
+    actualH += dstY;
+    dstY = 0;
+  }
+  actualW = Math.min(actualW, targetW - dstX);
+  actualH = Math.min(actualH, targetH - dstY);
+  if (actualW <= 0 || actualH <= 0) return false;
   const maskData = mask.data;
   const dst32 = target.data;
-  const dw = target.w;
+  const mx = dstX - x;
+  const my = dstY - y;
   let hasChanged = false;
+  let dIdx = dstY * targetW + dstX;
+  let mIdx = my * maskW + mx;
+  const dStride = targetW - actualW;
+  const mStride = maskW - actualW;
   for (let iy = 0; iy < actualH; iy++) {
-    const currentY = finalY + iy;
-    const maskY = currentY - y;
-    const maskOffset = maskY * maskW;
-    const dstRowOffset = currentY * dw;
     for (let ix = 0; ix < actualW; ix++) {
-      const currentX = finalX + ix;
-      const maskX = currentX - x;
-      const maskIndex = maskOffset + maskX;
-      if (maskData[maskIndex]) {
-        const current = dst32[dstRowOffset + currentX];
-        if (current !== color) {
-          dst32[dstRowOffset + currentX] = color;
+      if (maskData[mIdx]) {
+        if (dst32[dIdx] !== color) {
+          dst32[dIdx] = color;
           hasChanged = true;
         }
       }
+      dIdx++;
+      mIdx++;
     }
+    dIdx += dStride;
+    mIdx += mStride;
   }
   return hasChanged;
 }
@@ -3734,35 +3765,43 @@ var mutatorFillBinaryMask = ((writer, deps = defaults16) => {
 });
 
 // src/PixelData/invertPixelData.ts
-var SCRATCH_RECT3 = makeClippedRect();
 function invertPixelData(target, opts) {
+  const targetW = target.w;
+  const targetH = target.h;
   const mask = opts?.mask;
+  const invertMask = opts?.invertMask ?? false;
   const targetX = opts?.x ?? 0;
   const targetY = opts?.y ?? 0;
   const mx = opts?.mx ?? 0;
   const my = opts?.my ?? 0;
-  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.w, target.h, SCRATCH_RECT3);
-  if (!clip.inBounds) return false;
-  const {
-    x,
-    y,
-    w: actualW,
-    h: actualH
-  } = clip;
+  const w = opts?.w ?? targetW;
+  const h = opts?.h ?? targetH;
+  let x = targetX;
+  let y = targetY;
+  let actualW = w;
+  let actualH = h;
+  if (x < 0) {
+    actualW += x;
+    x = 0;
+  }
+  if (y < 0) {
+    actualH += y;
+    y = 0;
+  }
+  actualW = Math.min(actualW, targetW - x);
+  actualH = Math.min(actualH, targetH - y);
+  if (actualW <= 0 || actualH <= 0) return false;
   const dst32 = target.data;
-  const dw = target.w;
-  const mPitch = mask?.w ?? width;
+  const dw = targetW;
   const dx = x - targetX;
   const dy = y - targetY;
   let dIdx = y * dw + x;
-  let mIdx = (my + dy) * mPitch + (mx + dx);
   const dStride = dw - actualW;
-  const mStride = mPitch - actualW;
   if (mask) {
     const maskData = mask.data;
+    const mPitch = mask.w;
+    let mIdx = (my + dy) * mPitch + (mx + dx);
+    const mStride = mPitch - actualW;
     for (let iy = 0; iy < actualH; iy++) {
       for (let ix = 0; ix < actualW; ix++) {
         const mVal = maskData[mIdx];
@@ -3854,6 +3893,27 @@ function copyImageDataLike({
   };
 }
 
+// src/ImageData/extractImageData.ts
+function extractImageData(imageData, _x, _y, _w, _h) {
+  const {
+    x,
+    y,
+    w,
+    h
+  } = typeof _x === "object" ? _x : {
+    x: _x,
+    y: _y,
+    w: _w,
+    h: _h
+  };
+  if (w <= 0) return null;
+  if (h <= 0) return null;
+  const result = new ImageData(w, h);
+  const buffer = extractImageDataBuffer(imageData, x, y, w, h);
+  result.data.set(buffer);
+  return result;
+}
+
 // src/ImageData/ImageDataLike.ts
 function makeImageDataLike(width, height, data) {
   const size = width * height * 4;
@@ -4004,94 +4064,120 @@ function uInt32ArrayToImageDataLike(data, width, height) {
 }
 
 // src/ImageData/writeImageData.ts
-var SCRATCH_BLIT2 = makeClippedBlit();
-function writeImageData(target, source, x, y, sx = 0, sy = 0, sw = source.width, sh = source.height, mask = null, maskType = 1 /* BINARY */) {
+function writeImageData(target, source, x, y) {
   const dstW = target.width;
   const dstH = target.height;
-  const dstData = target.data;
+  const dst = target.data;
   const srcW = source.width;
-  const srcData = source.data;
-  const clip = resolveBlitClipping(x, y, sx, sy, sw, sh, dstW, dstH, srcW, source.height, SCRATCH_BLIT2);
-  if (!clip.inBounds) return;
-  const {
-    x: dstX,
-    y: dstY,
-    sx: srcX,
-    sy: srcY,
-    w: copyW,
-    h: copyH
-  } = clip;
-  const useMask = !!mask;
-  for (let row = 0; row < copyH; row++) {
-    const currentDstY = dstY + row;
-    const currentSrcY = srcY + row;
-    const dstStart = (currentDstY * dstW + dstX) * 4;
-    const srcStart = (currentSrcY * srcW + srcX) * 4;
-    if (useMask && mask) {
-      for (let ix = 0; ix < copyW; ix++) {
-        const mi = currentSrcY * srcW + (srcX + ix);
-        const alpha = mask[mi];
-        if (alpha === 0) {
-          continue;
-        }
-        const di = dstStart + ix * 4;
-        const si = srcStart + ix * 4;
-        if (maskType === 1 /* BINARY */ || alpha === 255) {
-          dstData[di] = srcData[si];
-          dstData[di + 1] = srcData[si + 1];
-          dstData[di + 2] = srcData[si + 2];
-          dstData[di + 3] = srcData[si + 3];
-        } else {
-          const a = alpha / 255;
-          const invA = 1 - a;
-          dstData[di] = srcData[si] * a + dstData[di] * invA;
-          dstData[di + 1] = srcData[si + 1] * a + dstData[di + 1] * invA;
-          dstData[di + 2] = srcData[si + 2] * a + dstData[di + 2] * invA;
-          dstData[di + 3] = srcData[si + 3] * a + dstData[di + 3] * invA;
-        }
-      }
-    } else {
-      const byteLen = copyW * 4;
-      const sub = srcData.subarray(srcStart, srcStart + byteLen);
-      dstData.set(sub, dstStart);
+  const srcH = source.height;
+  const src = source.data;
+  let dstX = x;
+  let dstY = y;
+  let srcX = 0;
+  let srcY = 0;
+  let copyW = srcW;
+  let copyH = srcH;
+  if (dstX < 0) {
+    srcX = -dstX;
+    copyW += dstX;
+    dstX = 0;
+  }
+  if (dstY < 0) {
+    srcY = -dstY;
+    copyH += dstY;
+    dstY = 0;
+  }
+  copyW = Math.min(copyW, dstW - dstX);
+  copyH = Math.min(copyH, dstH - dstY);
+  if (copyW <= 0) return;
+  if (copyH <= 0) return;
+  const isDstAligned = dst.byteOffset % 4 === 0;
+  const isSrcAligned = src.byteOffset % 4 === 0;
+  if (isDstAligned && isSrcAligned) {
+    const dstLen32 = dst.byteLength / 4;
+    const dst32 = new Uint32Array(dst.buffer, dst.byteOffset, dstLen32);
+    const srcLen32 = src.byteLength / 4;
+    const src32 = new Uint32Array(src.buffer, src.byteOffset, srcLen32);
+    for (let row = 0; row < copyH; row++) {
+      const dstStart = (dstY + row) * dstW + dstX;
+      const srcStart = (srcY + row) * srcW + srcX;
+      const chunk = src32.subarray(srcStart, srcStart + copyW);
+      dst32.set(chunk, dstStart);
+    }
+  } else {
+    const rowLen = copyW * 4;
+    for (let row = 0; row < copyH; row++) {
+      const dstStart = ((dstY + row) * dstW + dstX) * 4;
+      const srcStart = ((srcY + row) * srcW + srcX) * 4;
+      const chunk = src.subarray(srcStart, srcStart + rowLen);
+      dst.set(chunk, dstStart);
     }
   }
 }
 
 // src/ImageData/writeImageDataBuffer.ts
-var SCRATCH_BLIT3 = makeClippedBlit();
 function writeImageDataBuffer(target, data, _x, _y, _w, _h) {
-  const {
-    x,
-    y,
-    w,
-    h
-  } = typeof _x === "object" ? _x : {
-    x: _x,
-    y: _y,
-    w: _w,
-    h: _h
-  };
-  const {
-    width: dstW,
-    height: dstH,
-    data: dst
-  } = target;
-  const clip = resolveBlitClipping(x, y, 0, 0, w, h, dstW, dstH, w, h, SCRATCH_BLIT3);
-  if (!clip.inBounds) return;
-  const {
-    x: dstX,
-    y: dstY,
-    sx: srcX,
-    sy: srcY,
-    w: copyW,
-    h: copyH
-  } = clip;
-  const rowLen = copyW * 4;
-  for (let row = 0; row < copyH; row++) {
-    const dstStart = ((dstY + row) * dstW + dstX) * 4;
-    const srcStart = ((srcY + row) * w + srcX) * 4;
-    dst.set(data.subarray(srcStart, srcStart + rowLen), dstStart);
+  let x;
+  let y;
+  let w;
+  let h;
+  if (typeof _x === "object") {
+    x = _x.x;
+    y = _x.y;
+    w = _x.w;
+    h = _x.h;
+  } else {
+    x = _x;
+    y = _y;
+    w = _w;
+    h = _h;
+  }
+  if (w <= 0) return;
+  if (h <= 0) return;
+  const dstW = target.width;
+  const dstH = target.height;
+  const dst = target.data;
+  let dstX = x;
+  let dstY = y;
+  let srcX = 0;
+  let srcY = 0;
+  let copyW = w;
+  let copyH = h;
+  if (dstX < 0) {
+    srcX = -dstX;
+    copyW += dstX;
+    dstX = 0;
+  }
+  if (dstY < 0) {
+    srcY = -dstY;
+    copyH += dstY;
+    dstY = 0;
+  }
+  copyW = Math.min(copyW, dstW - dstX);
+  copyH = Math.min(copyH, dstH - dstY);
+  if (copyW <= 0) return;
+  if (copyH <= 0) return;
+  const isDstAligned = dst.byteOffset % 4 === 0;
+  const isSrcAligned = data.byteOffset % 4 === 0;
+  if (isDstAligned && isSrcAligned) {
+    const dstLen32 = dst.byteLength / 4;
+    const dst32 = new Uint32Array(dst.buffer, dst.byteOffset, dstLen32);
+    const srcLen32 = data.byteLength / 4;
+    const src32 = new Uint32Array(data.buffer, data.byteOffset, srcLen32);
+    for (let row = 0; row < copyH; row++) {
+      const dstStart = (dstY + row) * dstW + dstX;
+      const srcStart = (srcY + row) * w + srcX;
+      const chunk = src32.subarray(srcStart, srcStart + copyW);
+      dst32.set(chunk, dstStart);
+    }
+  } else {
+    const rowLen = copyW * 4;
+    for (let row = 0; row < copyH; row++) {
+      const dstStart = ((dstY + row) * dstW + dstX) * 4;
+      const srcStart = ((srcY + row) * w + srcX) * 4;
+      const chunk = data.subarray(srcStart, srcStart + rowLen);
+      dst.set(chunk, dstStart);
+    }
   }
 }
 
@@ -6024,8 +6110,9 @@ function blendPixelDataPaintBuffer(target, paintBuffer, alpha = 255, blendFn, bl
 }
 
 // src/PixelData/fillPixelDataFast.ts
-var SCRATCH_RECT4 = makeClippedRect();
 function fillPixelDataFast(dst, color, _x, _y, _w, _h) {
+  const dstW = dst.w;
+  const dstH = dst.h;
   let x;
   let y;
   let w;
@@ -6046,23 +6133,31 @@ function fillPixelDataFast(dst, color, _x, _y, _w, _h) {
     w = dst.w;
     h = dst.h;
   }
-  const clip = resolveRectClipping(x, y, w, h, dst.w, dst.h, SCRATCH_RECT4);
-  if (!clip.inBounds) return;
-  const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH
-  } = clip;
+  let dstX = x;
+  let dstY = y;
+  let fillW = w;
+  let fillH = h;
+  if (dstX < 0) {
+    fillW += dstX;
+    dstX = 0;
+  }
+  if (dstY < 0) {
+    fillH += dstY;
+    dstY = 0;
+  }
+  fillW = Math.min(fillW, dstW - dstX);
+  fillH = Math.min(fillH, dstH - dstY);
+  if (fillW <= 0) return;
+  if (fillH <= 0) return;
   const dst32 = dst.data;
   const dw = dst.w;
-  if (actualW === dw && actualH === dst.h && finalX === 0 && finalY === 0) {
+  if (fillW === dw && fillH === dst.h && dstX === 0 && dstY === 0) {
     dst32.fill(color);
     return;
   }
-  for (let iy = 0; iy < actualH; iy++) {
-    const start = (finalY + iy) * dw + finalX;
-    const end = start + actualW;
+  for (let iy = 0; iy < fillH; iy++) {
+    const start = (dstY + iy) * dw + dstX;
+    const end = start + fillW;
     dst32.fill(color, start, end);
   }
 }
@@ -6080,36 +6175,48 @@ function copyPixelData(target) {
 }
 
 // src/PixelData/extractPixelDataBuffer.ts
-var SCRATCH_BLIT4 = makeClippedBlit();
 function extractPixelDataBuffer(source, _x, _y, _w, _h) {
-  const {
-    x,
-    y,
-    w,
-    h
-  } = typeof _x === "object" ? _x : {
-    x: _x,
-    y: _y,
-    w: _w,
-    h: _h
-  };
+  let x;
+  let y;
+  let w;
+  let h;
+  if (typeof _x === "object") {
+    x = _x.x;
+    y = _x.y;
+    w = _x.w;
+    h = _x.h;
+  } else {
+    x = _x;
+    y = _y;
+    w = _w;
+    h = _h;
+  }
   const srcW = source.w;
   const srcH = source.h;
   const srcData = source.data;
-  if (w <= 0 || h <= 0) {
-    return new Uint32Array(0);
-  }
+  if (w <= 0) return new Uint32Array(0);
+  if (h <= 0) return new Uint32Array(0);
   const dstData = new Uint32Array(w * h);
-  const clip = resolveBlitClipping(0, 0, x, y, w, h, w, h, srcW, srcH, SCRATCH_BLIT4);
-  if (!clip.inBounds) return dstData;
-  const {
-    x: dstX,
-    y: dstY,
-    sx: srcX,
-    sy: srcY,
-    w: copyW,
-    h: copyH
-  } = clip;
+  let srcX = x;
+  let srcY = y;
+  let dstX = 0;
+  let dstY = 0;
+  let copyW = w;
+  let copyH = h;
+  if (srcX < 0) {
+    dstX = -srcX;
+    copyW += srcX;
+    srcX = 0;
+  }
+  if (srcY < 0) {
+    dstY = -srcY;
+    copyH += srcY;
+    srcY = 0;
+  }
+  copyW = Math.min(copyW, srcW - srcX);
+  copyH = Math.min(copyH, srcH - srcY);
+  if (copyW <= 0) return dstData;
+  if (copyH <= 0) return dstData;
   for (let row = 0; row < copyH; row++) {
     const srcStart = (srcY + row) * srcW + srcX;
     const dstStart = (dstY + row) * w + dstX;
@@ -6202,6 +6309,46 @@ function resamplePixelDataInPlace(pixelData, factor) {
   resampled.imageData = uInt32ArrayToImageData(resampled.data, resampled.w, resampled.h);
 }
 
+// src/PixelData/resizePixelData.ts
+function resizePixelData(target, newWidth, newHeight, offsetX = 0, offsetY = 0, out) {
+  const newData = new Uint32Array(newWidth * newHeight);
+  const {
+    w: oldW,
+    h: oldH,
+    data: oldData
+  } = target;
+  const result = out ?? {};
+  result.w = newWidth;
+  result.h = newHeight;
+  result.data = newData;
+  const x0 = Math.max(0, offsetX);
+  const y0 = Math.max(0, offsetY);
+  const x1 = Math.min(newWidth, offsetX + oldW);
+  const y1 = Math.min(newHeight, offsetY + oldH);
+  if (x1 <= x0 || y1 <= y0) {
+    return result;
+  }
+  const copyW = x1 - x0;
+  const copyH = y1 - y0;
+  if (copyW === oldW && copyW === newWidth && offsetX === 0) {
+    const srcStart = (y0 - offsetY) * oldW;
+    const dstStart = y0 * newWidth;
+    const len = copyW * copyH;
+    newData.set(oldData.subarray(srcStart, srcStart + len), dstStart);
+    return result;
+  }
+  for (let row = 0; row < copyH; row++) {
+    const dstY = y0 + row;
+    const srcY = dstY - offsetY;
+    const srcX = x0 - offsetX;
+    const dstStart = dstY * newWidth + x0;
+    const srcStart = srcY * oldW + srcX;
+    const chunk = oldData.subarray(srcStart, srcStart + copyW);
+    newData.set(chunk, dstStart);
+  }
+  return result;
+}
+
 // src/PixelData/rotatePixelData.ts
 function rotatePixelData(pixelData) {
   const width = pixelData.w;
@@ -6255,36 +6402,50 @@ function uInt32ArrayToPixelData(data, width, height) {
 }
 
 // src/PixelData/writePixelDataBuffer.ts
-var SCRATCH_BLIT5 = makeClippedBlit();
 function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
-  const {
-    x,
-    y,
-    w,
-    h
-  } = typeof _x === "object" ? _x : {
-    x: _x,
-    y: _y,
-    w: _w,
-    h: _h
-  };
+  let x;
+  let y;
+  let w;
+  let h;
+  if (typeof _x === "object") {
+    x = _x.x;
+    y = _x.y;
+    w = _x.w;
+    h = _x.h;
+  } else {
+    x = _x;
+    y = _y;
+    w = _w;
+    h = _h;
+  }
+  if (w <= 0 || h <= 0) return;
   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 {
-    x: dstX,
-    y: dstY,
-    sx: srcX,
-    sy: srcY,
-    w: copyW,
-    h: copyH
-  } = clip;
+  let dstX = x;
+  let dstY = y;
+  let srcX = 0;
+  let srcY = 0;
+  let copyW = w;
+  let copyH = h;
+  if (dstX < 0) {
+    srcX = -dstX;
+    copyW += dstX;
+    dstX = 0;
+  }
+  if (dstY < 0) {
+    srcY = -dstY;
+    copyH += dstY;
+    dstY = 0;
+  }
+  copyW = Math.min(copyW, dstW - dstX);
+  copyH = Math.min(copyH, dstH - dstY);
+  if (copyW <= 0 || copyH <= 0) return;
   for (let row = 0; row < copyH; row++) {
     const dstStart = (dstY + row) * dstW + dstX;
     const srcStart = (srcY + row) * w + srcX;
-    dstData.set(data.subarray(srcStart, srcStart + copyW), dstStart);
+    const chunk = data.subarray(srcStart, srcStart + copyW);
+    dstData.set(chunk, dstStart);
   }
 }
 
@@ -6375,6 +6536,7 @@ export {
   eachTileInBounds,
   exclusionFast,
   exclusionPerfect,
+  extractImageData,
   extractImageDataBuffer,
   extractMask,
   extractMaskBuffer,
@@ -6424,6 +6586,7 @@ export {
   makeAlphaMaskPaintBufferCommitter,
   makeAlphaMaskPaintBufferManager,
   makeAlphaMaskTile,
+  makeBatchedQueue,
   makeBinaryMask,
   makeBinaryMaskFromAlphaMask,
   makeBinaryMaskOutline,
@@ -6437,8 +6600,6 @@ export {
   makeCircleBinaryMaskOutline,
   makeCirclePaintAlphaMask,
   makeCirclePaintBinaryMask,
-  makeClippedBlit,
-  makeClippedRect,
   makeColorPaintBufferCanvasRenderer,
   makeColorPaintBufferCommitter,
   makeColorPaintBufferManager,
@@ -6458,6 +6619,7 @@ export {
   makePixelTile,
   makeRectBinaryMaskOutline,
   makeRectFalloffPaintAlphaMask,
+  makeRenderQueue,
   makeReusableCanvas,
   makeReusableImageData,
   makeReusableOffscreenCanvas,
@@ -6504,8 +6666,7 @@ export {
   resamplePixelDataInPlace,
   resampleUint32Array,
   resizeImageData,
-  resolveBlitClipping,
-  resolveRectClipping,
+  resizePixelData,
   rotatePixelData,
   screenFast,
   screenPerfect,