pixel-data-js 0.30.0 → 0.32.0

package/dist/index.prod.cjs

@@ -93,6 +93,7 @@ __export(src_exports, {
   eachTileInBounds: () => eachTileInBounds,
   exclusionFast: () => exclusionFast,
   exclusionPerfect: () => exclusionPerfect,
+  extractImageData: () => extractImageData,
   extractImageDataBuffer: () => extractImageDataBuffer,
   extractMask: () => extractMask,
   extractMaskBuffer: () => extractMaskBuffer,
@@ -142,6 +143,7 @@ __export(src_exports, {
   makeAlphaMaskPaintBufferCommitter: () => makeAlphaMaskPaintBufferCommitter,
   makeAlphaMaskPaintBufferManager: () => makeAlphaMaskPaintBufferManager,
   makeAlphaMaskTile: () => makeAlphaMaskTile,
+  makeBatchedQueue: () => makeBatchedQueue,
   makeBinaryMask: () => makeBinaryMask,
   makeBinaryMaskFromAlphaMask: () => makeBinaryMaskFromAlphaMask,
   makeBinaryMaskOutline: () => makeBinaryMaskOutline,
@@ -155,8 +157,6 @@ __export(src_exports, {
   makeCircleBinaryMaskOutline: () => makeCircleBinaryMaskOutline,
   makeCirclePaintAlphaMask: () => makeCirclePaintAlphaMask,
   makeCirclePaintBinaryMask: () => makeCirclePaintBinaryMask,
-  makeClippedBlit: () => makeClippedBlit,
-  makeClippedRect: () => makeClippedRect,
   makeColorPaintBufferCanvasRenderer: () => makeColorPaintBufferCanvasRenderer,
   makeColorPaintBufferCommitter: () => makeColorPaintBufferCommitter,
   makeColorPaintBufferManager: () => makeColorPaintBufferManager,
@@ -176,6 +176,7 @@ __export(src_exports, {
   makePixelTile: () => makePixelTile,
   makeRectBinaryMaskOutline: () => makeRectBinaryMaskOutline,
   makeRectFalloffPaintAlphaMask: () => makeRectFalloffPaintAlphaMask,
+  makeRenderQueue: () => makeRenderQueue,
   makeReusableCanvas: () => makeReusableCanvas,
   makeReusableImageData: () => makeReusableImageData,
   makeReusableOffscreenCanvas: () => makeReusableOffscreenCanvas,
@@ -222,8 +223,7 @@ __export(src_exports, {
   resamplePixelDataInPlace: () => resamplePixelDataInPlace,
   resampleUint32Array: () => resampleUint32Array,
   resizeImageData: () => resizeImageData,
-  resolveBlitClipping: () => resolveBlitClipping,
-  resolveRectClipping: () => resolveRectClipping,
+  resizePixelData: () => resizePixelData,
   rotatePixelData: () => rotatePixelData,
   screenFast: () => screenFast,
   screenPerfect: () => screenPerfect,
@@ -351,86 +351,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,
@@ -443,28 +364,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;
 }
@@ -2290,6 +2235,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++) {
@@ -2852,11 +2858,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");
     }
@@ -2871,10 +2876,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");
     }
@@ -2890,12 +2895,10 @@ var PixelWriter = class {
       undo: () => {
         setPixelData(target, beforeImageData);
         afterUndo?.(beforeImageData);
-        after?.(beforeImageData);
       },
       redo: () => {
         setPixelData(target, afterImageData);
         afterRedo?.(afterImageData);
-        after?.(afterImageData);
       }
     });
   }
@@ -3847,8 +3850,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;
@@ -3856,8 +3860,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;
@@ -3866,24 +3870,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;
@@ -3945,39 +3967,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;
 }
@@ -3999,35 +4030,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];
@@ -4119,6 +4158,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;
@@ -4269,94 +4329,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);
+    }
   }
 }
 
@@ -6289,8 +6375,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;
@@ -6311,23 +6398,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);
   }
 }
@@ -6345,36 +6440,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;
@@ -6467,6 +6574,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;
@@ -6520,36 +6667,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);
   }
 }
 
@@ -6641,6 +6802,7 @@ function writePaintBufferToPixelData(target, paintBuffer, writePixelDataBufferFn
   eachTileInBounds,
   exclusionFast,
   exclusionPerfect,
+  extractImageData,
   extractImageDataBuffer,
   extractMask,
   extractMaskBuffer,
@@ -6690,6 +6852,7 @@ function writePaintBufferToPixelData(target, paintBuffer, writePixelDataBufferFn
   makeAlphaMaskPaintBufferCommitter,
   makeAlphaMaskPaintBufferManager,
   makeAlphaMaskTile,
+  makeBatchedQueue,
   makeBinaryMask,
   makeBinaryMaskFromAlphaMask,
   makeBinaryMaskOutline,
@@ -6703,8 +6866,6 @@ function writePaintBufferToPixelData(target, paintBuffer, writePixelDataBufferFn
   makeCircleBinaryMaskOutline,
   makeCirclePaintAlphaMask,
   makeCirclePaintBinaryMask,
-  makeClippedBlit,
-  makeClippedRect,
   makeColorPaintBufferCanvasRenderer,
   makeColorPaintBufferCommitter,
   makeColorPaintBufferManager,
@@ -6724,6 +6885,7 @@ function writePaintBufferToPixelData(target, paintBuffer, writePixelDataBufferFn
   makePixelTile,
   makeRectBinaryMaskOutline,
   makeRectFalloffPaintAlphaMask,
+  makeRenderQueue,
   makeReusableCanvas,
   makeReusableImageData,
   makeReusableOffscreenCanvas,
@@ -6770,8 +6932,7 @@ function writePaintBufferToPixelData(target, paintBuffer, writePixelDataBufferFn
   resamplePixelDataInPlace,
   resampleUint32Array,
   resizeImageData,
-  resolveBlitClipping,
-  resolveRectClipping,
+  resizePixelData,
   rotatePixelData,
   screenFast,
   screenPerfect,