pixel-data-js 0.2.0 → 0.4.0

package/dist/index.dev.cjs

@@ -22,27 +22,32 @@ var src_exports = {};
 __export(src_exports, {
   COLOR_32_BLEND_MODES: () => COLOR_32_BLEND_MODES,
   MaskType: () => MaskType,
-  applyAlphaMask: () => applyAlphaMask,
-  applyBinaryMask: () => applyBinaryMask,
+  applyMaskToPixelData: () => applyMaskToPixelData,
   base64DecodeArrayBuffer: () => base64DecodeArrayBuffer,
   base64EncodeArrayBuffer: () => base64EncodeArrayBuffer,
-  blendImageData: () => blendImageData,
+  blendColorPixelData: () => blendColorPixelData,
+  blendPixelData: () => blendPixelData,
+  clearPixelData: () => clearPixelData,
   color32ToCssRGBA: () => color32ToCssRGBA,
   color32ToHex: () => color32ToHex,
   colorBurnColor32: () => colorBurnColor32,
   colorDistance: () => colorDistance,
   copyImageData: () => copyImageData,
   copyImageDataLike: () => copyImageDataLike,
+  copyMask: () => copyMask,
   deserializeImageData: () => deserializeImageData,
   deserializeNullableImageData: () => deserializeNullableImageData,
   deserializeRawImageData: () => deserializeRawImageData,
   differenceColor32: () => differenceColor32,
-  extractPixelData: () => extractPixelData,
+  extractImageData: () => extractImageData,
+  fillPixelData: () => fillPixelData,
   hardLightColor32: () => hardLightColor32,
+  invertAlphaMask: () => invertAlphaMask,
+  invertBinaryMask: () => invertBinaryMask,
   lerpColor32: () => lerpColor32,
   lerpColor32Fast: () => lerpColor32Fast,
   linearDodgeColor32: () => linearDodgeColor32,
-  makeImageDataColor32Adapter: () => makeImageDataColor32Adapter,
+  mergeMasks: () => mergeMasks,
   multiplyColor32: () => multiplyColor32,
   overlayColor32: () => overlayColor32,
   packColor: () => packColor,
@@ -56,11 +61,19 @@ __export(src_exports, {
   unpackColor: () => unpackColor,
   unpackColorTo: () => unpackColorTo,
   unpackGreen: () => unpackGreen,
-  unpackRed: () => unpackRed
+  unpackRed: () => unpackRed,
+  writeImageData: () => writeImageData
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/ImageData/blend-modes.ts
+// src/_types.ts
+var MaskType = /* @__PURE__ */ ((MaskType2) => {
+  MaskType2[MaskType2["ALPHA"] = 0] = "ALPHA";
+  MaskType2[MaskType2["BINARY"] = 1] = "BINARY";
+  return MaskType2;
+})(MaskType || {});
+
+// src/blend-modes.ts
 var sourceOverColor32 = (src, dst) => {
   const a = src >>> 24 & 255;
   if (a === 255) return src;
@@ -196,176 +209,83 @@ var COLOR_32_BLEND_MODES = {
   colorBurn: colorBurnColor32
 };
 
-// src/_types.ts
-var MaskType = /* @__PURE__ */ ((MaskType2) => {
-  MaskType2[MaskType2["ALPHA"] = 0] = "ALPHA";
-  MaskType2[MaskType2["BINARY"] = 1] = "BINARY";
-  return MaskType2;
-})(MaskType || {});
-
-// src/ImageData/blit.ts
-function blendImageData(dst, src, opts) {
-  let {
-    dx = 0,
-    dy = 0,
-    sx = 0,
-    sy = 0,
-    sw = src.width,
-    sh = src.height,
-    opacity = 1,
-    alpha,
-    blendFn = sourceOverColor32,
-    mask
-  } = opts;
-  if (sx < 0) {
-    dx -= sx;
-    sw += sx;
-    sx = 0;
-  }
-  if (sy < 0) {
-    dy -= sy;
-    sh += sy;
-    sy = 0;
-  }
-  sw = Math.min(sw, src.width - sx);
-  sh = Math.min(sh, src.height - sy);
-  if (dx < 0) {
-    sx -= dx;
-    sw += dx;
-    dx = 0;
-  }
-  if (dy < 0) {
-    sy -= dy;
-    sh += dy;
-    dy = 0;
-  }
-  const actualW = Math.min(sw, dst.width - dx);
-  const actualH = Math.min(sh, dst.height - dy);
-  if (actualW <= 0 || actualH <= 0) return;
-  const dst32 = new Uint32Array(dst.data.buffer);
-  const src32 = new Uint32Array(src.data.buffer);
-  const dw = dst.width;
-  const sw_orig = src.width;
-  const gAlpha = alpha !== void 0 ? alpha | 0 : Math.round(opacity * 255);
-  const maskIsAlpha = mask?.type === 0 /* ALPHA */;
-  for (let iy = 0; iy < actualH; iy++) {
-    const dRow = (iy + dy) * dw;
-    const sRow = (iy + sy) * sw_orig;
-    for (let ix = 0; ix < actualW; ix++) {
-      const di = dRow + (ix + dx);
-      const si = sRow + (ix + sx);
-      let s = src32[si];
-      let sa = s >>> 24 & 255;
-      if (sa === 0) continue;
-      let activeWeight = gAlpha;
-      if (mask) {
-        const m = mask.data[si];
-        if (m === 0) continue;
-        activeWeight = maskIsAlpha ? m * activeWeight + 128 >> 8 : activeWeight;
-      }
-      if (activeWeight < 255) {
-        sa = sa * activeWeight + 128 >> 8;
-      }
-      if (sa === 0) continue;
-      s = (s & 16777215 | sa << 24) >>> 0;
-      dst32[di] = blendFn(s, dst32[di]);
-    }
-  }
+// src/color.ts
+function packColor(r, g, b, a) {
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 }
-
-// src/ImageData/mask.ts
-function applyBinaryMask(dst, mask, opts = {}) {
-  const { width: maskWidth, height: maskHeight } = mask;
-  const { dx = 0, dy = 0, sx = 0, sy = 0, sw = maskWidth, sh = maskHeight } = opts;
-  const x0 = Math.max(0, dx, dx + (0 - sx));
-  const y0 = Math.max(0, dy, dy + (0 - sy));
-  const x1 = Math.min(dst.width, dx + sw, dx + (maskWidth - sx));
-  const y1 = Math.min(dst.height, dy + sh, dy + (maskHeight - sy));
-  if (x1 <= x0 || y1 <= y0) return;
-  const { data: dstData, width: dstW } = dst;
-  for (let y = y0; y < y1; y++) {
-    const maskY = y - dy + sy;
-    const dstRowOffset = y * dstW * 4;
-    const maskRowOffset = maskY * maskWidth;
-    for (let x = x0; x < x1; x++) {
-      const maskX = x - dx + sx;
-      const mIdx = maskRowOffset + maskX;
-      if (mask.data[mIdx] === 0) {
-        const aIdx = dstRowOffset + x * 4 + 3;
-        dstData[aIdx] = 0;
-      }
-    }
-  }
-  return dst;
+function packRGBA({ r, g, b, a }) {
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 }
-function applyAlphaMask(dst, mask, opts = {}) {
-  let { dx = 0, dy = 0, sx = 0, sy = 0, sw = mask.width, sh = mask.height } = opts;
-  if (dx < 0) {
-    sx -= dx;
-    sw += dx;
-    dx = 0;
-  }
-  if (dy < 0) {
-    sy -= dy;
-    sh += dy;
-    dy = 0;
-  }
-  if (sx < 0) {
-    dx -= sx;
-    sw += sx;
-    sx = 0;
-  }
-  if (sy < 0) {
-    dy -= sy;
-    sh += sy;
-    sy = 0;
-  }
-  const actualW = Math.min(sw, dst.width - dx, mask.width - sx);
-  const actualH = Math.min(sh, dst.height - dy, mask.height - sy);
-  if (actualW <= 0 || actualH <= 0) return;
-  const dData = dst.data;
-  const mData = mask.data;
-  const dW = dst.width;
-  const mW = mask.width;
-  for (let y = 0; y < actualH; y++) {
-    const dOffset = (dy + y) * dW + dx << 2;
-    const mOffset = (sy + y) * mW + sx;
-    for (let x = 0; x < actualW; x++) {
-      const mVal = mData[mOffset + x];
-      if (mVal === 255) continue;
-      const aIdx = dOffset + (x << 2) + 3;
-      if (mVal === 0) {
-        dData[aIdx] = 0;
-        continue;
-      }
-      dData[aIdx] = dData[aIdx] * mVal + 257 >> 8;
-    }
-  }
+var unpackRed = (packed) => packed >>> 0 & 255;
+var unpackGreen = (packed) => packed >>> 8 & 255;
+var unpackBlue = (packed) => packed >>> 16 & 255;
+var unpackAlpha = (packed) => packed >>> 24 & 255;
+function unpackColor(packed) {
+  return {
+    r: packed >>> 0 & 255,
+    g: packed >>> 8 & 255,
+    b: packed >>> 16 & 255,
+    a: packed >>> 24 & 255
+  };
+}
+var SCRATCH_RGBA = { r: 0, g: 0, b: 0, a: 0 };
+function unpackColorTo(packed, scratch = SCRATCH_RGBA) {
+  scratch.r = packed >>> 0 & 255;
+  scratch.g = packed >>> 8 & 255;
+  scratch.b = packed >>> 16 & 255;
+  scratch.a = packed >>> 24 & 255;
+  return scratch;
+}
+function colorDistance(a, b) {
+  const dr = (a & 255) - (b & 255);
+  const dg = (a >>> 8 & 255) - (b >>> 8 & 255);
+  const db = (a >>> 16 & 255) - (b >>> 16 & 255);
+  const da = (a >>> 24 & 255) - (b >>> 24 & 255);
+  return dr * dr + dg * dg + db * db + da * da;
+}
+function lerpColor32(a, b, t) {
+  const r = (a & 255) + t * ((b & 255) - (a & 255));
+  const g = (a >>> 8 & 255) + t * ((b >>> 8 & 255) - (a >>> 8 & 255));
+  const b_ = (a >>> 16 & 255) + t * ((b >>> 16 & 255) - (a >>> 16 & 255));
+  const a_ = (a >>> 24 & 255) + t * ((b >>> 24 & 255) - (a >>> 24 & 255));
+  return (a_ << 24 | b_ << 16 | g << 8 | r) >>> 0;
+}
+function lerpColor32Fast(src, dst, w) {
+  const invA = 255 - w;
+  const rb = (src & 16711935) * w + (dst & 16711935) * invA >>> 8 & 16711935;
+  const ga = (src >>> 8 & 16711935) * w + (dst >>> 8 & 16711935) * invA >>> 8 & 16711935;
+  return (rb | ga << 8) >>> 0;
+}
+function color32ToHex(color) {
+  const r = (color & 255).toString(16).padStart(2, "0");
+  const g = (color >>> 8 & 255).toString(16).padStart(2, "0");
+  const b = (color >>> 16 & 255).toString(16).padStart(2, "0");
+  const a = (color >>> 24 & 255).toString(16).padStart(2, "0");
+  return `#${r}${g}${b}${a}`;
+}
+function color32ToCssRGBA(color) {
+  const r = color & 255;
+  const g = color >>> 8 & 255;
+  const b = color >>> 16 & 255;
+  const a = color >>> 24 & 255;
+  const alpha = Number((a / 255).toFixed(3));
+  return `rgba(${r},${g},${b},${alpha})`;
 }
 
-// src/ImageData/read-write-pixels.ts
-function makeImageDataColor32Adapter(imageData) {
-  const data32 = new Uint32Array(imageData.data.buffer);
-  function inBounds(x, y) {
-    return x < 0 || x >= imageData.width || y < 0 || y >= imageData.height;
-  }
-  function setPixel(x, y, color) {
-    if (x < 0 || x >= imageData.width || y < 0 || y >= imageData.height) return;
-    data32[y * imageData.width + x] = color;
-  }
-  function getPixel(x, y) {
-    if (x < 0 || x >= imageData.width || y < 0 || y >= imageData.height) return;
-    return data32[y * imageData.width + x];
-  }
+// src/ImageData/copyImageData.ts
+function copyImageData({ data, width, height }) {
+  return new ImageData(data.slice(), width, height);
+}
+function copyImageDataLike({ data, width, height }) {
   return {
-    inBounds,
-    imageData,
-    data32,
-    setPixel,
-    getPixel
+    data: data.slice(),
+    width,
+    height
   };
 }
-function extractPixelData(imageData, _x, _y, _w, _h) {
+
+// 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 };
   const { width: srcW, height: srcH, data: src } = imageData;
   if (w <= 0 || h <= 0) return new Uint8ClampedArray(0);
@@ -386,16 +306,6 @@ function extractPixelData(imageData, _x, _y, _w, _h) {
   }
   return out;
 }
-function copyImageData({ data, width, height }) {
-  return new ImageData(data.slice(), width, height);
-}
-function copyImageDataLike({ data, width, height }) {
-  return {
-    data: data.slice(),
-    width,
-    height
-  };
-}
 
 // src/ImageData/serialization.ts
 function base64EncodeArrayBuffer(buffer) {
@@ -437,93 +347,514 @@ function deserializeNullableImageData(serialized) {
   return deserializeImageData(serialized);
 }
 
-// src/color.ts
-function packColor(r, g, b, a) {
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+// src/ImageData/writeImageData.ts
+function writeImageData(imageData, data, _x, _y, _w, _h) {
+  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
+  const { width: dstW, height: dstH, data: dst } = imageData;
+  const x0 = Math.max(0, x);
+  const y0 = Math.max(0, y);
+  const x1 = Math.min(dstW, x + w);
+  const y1 = Math.min(dstH, y + h);
+  if (x1 <= x0 || y1 <= y0) return;
+  const rowLen = (x1 - x0) * 4;
+  const srcCol = x0 - x;
+  const srcYOffset = y0 - y;
+  const actualH = y1 - y0;
+  for (let row = 0; row < actualH; row++) {
+    const dstStart = ((y0 + row) * dstW + x0) * 4;
+    const srcRow = srcYOffset + row;
+    const o = (srcRow * w + srcCol) * 4;
+    dst.set(data.subarray(o, o + rowLen), dstStart);
+  }
 }
-function packRGBA({ r, g, b, a }) {
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+
+// src/Mask/copyMask.ts
+function copyMask(src) {
+  return src.slice();
 }
-var unpackRed = (packed) => packed >>> 0 & 255;
-var unpackGreen = (packed) => packed >>> 8 & 255;
-var unpackBlue = (packed) => packed >>> 16 & 255;
-var unpackAlpha = (packed) => packed >>> 24 & 255;
-function unpackColor(packed) {
-  return {
-    r: packed >>> 0 & 255,
-    g: packed >>> 8 & 255,
-    b: packed >>> 16 & 255,
-    a: packed >>> 24 & 255
-  };
+
+// src/Mask/invertMask.ts
+function invertBinaryMask(dst) {
+  const len = dst.length;
+  for (let i = 0; i < len; i++) {
+    dst[i] = dst[i] === 0 ? 1 : 0;
+  }
 }
-var SCRATCH_RGBA = { r: 0, g: 0, b: 0, a: 0 };
-function unpackColorTo(packed, scratch = SCRATCH_RGBA) {
-  scratch.r = packed >>> 0 & 255;
-  scratch.g = packed >>> 8 & 255;
-  scratch.b = packed >>> 16 & 255;
-  scratch.a = packed >>> 24 & 255;
-  return scratch;
+function invertAlphaMask(dst) {
+  const len = dst.length;
+  for (let i = 0; i < len; i++) {
+    dst[i] = 255 - dst[i];
+  }
 }
-function colorDistance(a, b) {
-  const dr = (a & 255) - (b & 255);
-  const dg = (a >>> 8 & 255) - (b >>> 8 & 255);
-  const db = (a >>> 16 & 255) - (b >>> 16 & 255);
-  const da = (a >>> 24 & 255) - (b >>> 24 & 255);
-  return dr * dr + dg * dg + db * db + da * da;
+
+// src/Mask/mergeMasks.ts
+function mergeMasks(dst, dstWidth, src, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = 0,
+    h: height = 0,
+    alpha: globalAlpha = 255,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (width <= 0 || height <= 0 || globalAlpha === 0) {
+    return;
+  }
+  const sPitch = mw ?? width;
+  const isAlpha = maskType === 0 /* ALPHA */;
+  for (let iy = 0; iy < height; iy++) {
+    const dy = targetY + iy;
+    const sy = my + iy;
+    if (dy < 0 || sy < 0) {
+      continue;
+    }
+    for (let ix = 0; ix < width; ix++) {
+      const dx = targetX + ix;
+      const sx = mx + ix;
+      if (dx < 0 || dx >= dstWidth || sx < 0 || sx >= sPitch) {
+        continue;
+      }
+      const dIdx = dy * dstWidth + dx;
+      const sIdx = sy * sPitch + sx;
+      const mVal = src[sIdx];
+      let weight = globalAlpha;
+      if (isAlpha) {
+        const effectiveM = invertMask ? 255 - mVal : mVal;
+        if (effectiveM === 0) {
+          dst[dIdx] = 0;
+          continue;
+        }
+        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
+      } else {
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (!isHit) {
+          dst[dIdx] = 0;
+          continue;
+        }
+        weight = globalAlpha;
+      }
+      if (weight === 0) {
+        dst[dIdx] = 0;
+        continue;
+      }
+      const da = dst[dIdx];
+      if (da === 0) {
+      } else if (weight === 255) {
+      } else if (da === 255) {
+        dst[dIdx] = weight;
+      } else {
+        dst[dIdx] = da * weight + 128 >> 8;
+      }
+    }
+  }
 }
-function lerpColor32(a, b, t) {
-  const r = (a & 255) + t * ((b & 255) - (a & 255));
-  const g = (a >>> 8 & 255) + t * ((b >>> 8 & 255) - (a >>> 8 & 255));
-  const b_ = (a >>> 16 & 255) + t * ((b >>> 16 & 255) - (a >>> 16 & 255));
-  const a_ = (a >>> 24 & 255) + t * ((b >>> 24 & 255) - (a >>> 24 & 255));
-  return (a_ << 24 | b_ << 16 | g << 8 | r) >>> 0;
+
+// src/PixelData/applyMaskToPixelData.ts
+function applyMaskToPixelData(dst, mask, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0 || globalAlpha === 0) {
+    return;
+  }
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const mPitch = mw ?? width;
+  const isAlpha = maskType === 0 /* ALPHA */;
+  const dx = x - targetX;
+  const dy = y - targetY;
+  let dIdx = y * dw + x;
+  let mIdx = (my + dy) * mPitch + (mx + dx);
+  const dStride = dw - actualW;
+  const mStride = mPitch - actualW;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      const mVal = mask[mIdx];
+      let weight = globalAlpha;
+      if (isAlpha) {
+        const effectiveM = invertMask ? 255 - mVal : mVal;
+        if (effectiveM === 0) {
+          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
+      } else {
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (!isHit) {
+          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        weight = globalAlpha;
+      }
+      if (weight === 0) {
+        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+      } else {
+        const d = dst32[dIdx];
+        const da = d >>> 24;
+        let finalAlpha = da;
+        if (da === 0) {
+        } else if (weight === 255) {
+        } else if (da === 255) {
+          finalAlpha = weight;
+        } else {
+          finalAlpha = da * weight + 128 >> 8;
+        }
+        dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+      }
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
 }
-function lerpColor32Fast(src, dst, w) {
-  const invA = 255 - w;
-  const rb = (src & 16711935) * w + (dst & 16711935) * invA >>> 8 & 16711935;
-  const ga = (src >>> 8 & 16711935) * w + (dst >>> 8 & 16711935) * invA >>> 8 & 16711935;
-  return (rb | ga << 8) >>> 0;
+
+// src/PixelData/blendColorPixelData.ts
+function blendColorPixelData(dst, color, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
+    blendFn = sourceOverColor32,
+    mask,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (globalAlpha === 0) return;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) return;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const mPitch = mw ?? width;
+  const isAlphaMask = maskType === 0 /* ALPHA */;
+  const dx = x - targetX;
+  const dy = y - targetY;
+  let dIdx = y * dw + x;
+  let mIdx = (my + dy) * mPitch + (mx + dx);
+  const dStride = dw - actualW;
+  const mStride = mPitch - actualW;
+  const baseSrcColor = color;
+  const baseSrcAlpha = baseSrcColor >>> 24;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      if (baseSrcAlpha === 0) {
+        dIdx++;
+        mIdx++;
+        continue;
+      }
+      let weight = globalAlpha;
+      if (mask) {
+        const mVal = mask[mIdx];
+        if (isAlphaMask) {
+          const effectiveM = invertMask ? 255 - mVal : mVal;
+          if (effectiveM === 0) {
+            dIdx++;
+            mIdx++;
+            continue;
+          }
+          if (globalAlpha === 255) {
+            weight = effectiveM;
+          } else if (effectiveM === 255) {
+            weight = globalAlpha;
+          } else {
+            weight = effectiveM * globalAlpha + 128 >> 8;
+          }
+        } else {
+          const isHit = invertMask ? mVal === 0 : mVal === 1;
+          if (!isHit) {
+            dIdx++;
+            mIdx++;
+            continue;
+          }
+          weight = globalAlpha;
+        }
+        if (weight === 0) {
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+      }
+      let currentSrcAlpha = baseSrcAlpha;
+      let currentSrcColor = baseSrcColor;
+      if (weight < 255) {
+        if (baseSrcAlpha === 255) {
+          currentSrcAlpha = weight;
+        } else {
+          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
+        }
+        if (currentSrcAlpha === 0) {
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        currentSrcColor = (baseSrcColor & 16777215 | currentSrcAlpha << 24) >>> 0;
+      }
+      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
 }
-function color32ToHex(color) {
-  const r = (color & 255).toString(16).padStart(2, "0");
-  const g = (color >>> 8 & 255).toString(16).padStart(2, "0");
-  const b = (color >>> 16 & 255).toString(16).padStart(2, "0");
-  const a = (color >>> 24 & 255).toString(16).padStart(2, "0");
-  return `#${r}${g}${b}${a}`;
+
+// src/PixelData/blendPixelData.ts
+function blendPixelData(dst, src, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    sx: sourceX = 0,
+    sy: sourceY = 0,
+    w: width = src.width,
+    h: height = src.height,
+    alpha: globalAlpha = 255,
+    blendFn = sourceOverColor32,
+    mask,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (globalAlpha === 0) return;
+  let x = targetX;
+  let y = targetY;
+  let sx = sourceX;
+  let sy = sourceY;
+  let w = width;
+  let h = height;
+  if (sx < 0) {
+    x -= sx;
+    w += sx;
+    sx = 0;
+  }
+  if (sy < 0) {
+    y -= sy;
+    h += sy;
+    sy = 0;
+  }
+  w = Math.min(w, src.width - sx);
+  h = Math.min(h, src.height - sy);
+  if (x < 0) {
+    sx -= x;
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    sy -= y;
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) return;
+  const dst32 = dst.data32;
+  const src32 = src.data32;
+  const dw = dst.width;
+  const sw = src.width;
+  const mPitch = mw ?? width;
+  const isAlphaMask = maskType === 0 /* ALPHA */;
+  const dx = x - targetX;
+  const dy = y - targetY;
+  let dIdx = y * dw + x;
+  let sIdx = sy * sw + sx;
+  let mIdx = (my + dy) * mPitch + (mx + dx);
+  const dStride = dw - actualW;
+  const sStride = sw - actualW;
+  const mStride = mPitch - actualW;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      const baseSrcColor = src32[sIdx];
+      const baseSrcAlpha = baseSrcColor >>> 24;
+      if (baseSrcAlpha === 0) {
+        dIdx++;
+        sIdx++;
+        mIdx++;
+        continue;
+      }
+      let weight = globalAlpha;
+      if (mask) {
+        const mVal = mask[mIdx];
+        if (isAlphaMask) {
+          const effectiveM = invertMask ? 255 - mVal : mVal;
+          if (effectiveM === 0) {
+            dIdx++;
+            sIdx++;
+            mIdx++;
+            continue;
+          }
+          if (globalAlpha === 255) {
+            weight = effectiveM;
+          } else if (effectiveM === 255) {
+            weight = globalAlpha;
+          } else {
+            weight = effectiveM * globalAlpha + 128 >> 8;
+          }
+        } else {
+          const isHit = invertMask ? mVal === 0 : mVal === 1;
+          if (!isHit) {
+            dIdx++;
+            sIdx++;
+            mIdx++;
+            continue;
+          }
+          weight = globalAlpha;
+        }
+        if (weight === 0) {
+          dIdx++;
+          sIdx++;
+          mIdx++;
+          continue;
+        }
+      }
+      let currentSrcAlpha = baseSrcAlpha;
+      let currentSrcColor = baseSrcColor;
+      if (weight < 255) {
+        if (baseSrcAlpha === 255) {
+          currentSrcAlpha = weight;
+        } else {
+          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
+        }
+        if (currentSrcAlpha === 0) {
+          dIdx++;
+          sIdx++;
+          mIdx++;
+          continue;
+        }
+        currentSrcColor = (baseSrcColor & 16777215 | currentSrcAlpha << 24) >>> 0;
+      }
+      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
+      dIdx++;
+      sIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    sIdx += sStride;
+    mIdx += mStride;
+  }
 }
-function color32ToCssRGBA(color) {
-  const r = color & 255;
-  const g = color >>> 8 & 255;
-  const b = color >>> 16 & 255;
-  const a = color >>> 24 & 255;
-  const alpha = Number((a / 255).toFixed(3));
-  return `rgba(${r},${g},${b},${alpha})`;
+
+// src/PixelData/fillPixelData.ts
+function fillPixelData(dst, color, rect) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height
+  } = rect || {};
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) {
+    return;
+  }
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  if (actualW === dw && actualH === dst.height && x === 0 && y === 0) {
+    dst32.fill(color);
+    return;
+  }
+  for (let iy = 0; iy < actualH; iy++) {
+    const start = (y + iy) * dw + x;
+    const end = start + actualW;
+    dst32.fill(color, start, end);
+  }
+}
+
+// src/PixelData/clearPixelData.ts
+function clearPixelData(dst, rect) {
+  fillPixelData(dst, 0, rect);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   COLOR_32_BLEND_MODES,
   MaskType,
-  applyAlphaMask,
-  applyBinaryMask,
+  applyMaskToPixelData,
   base64DecodeArrayBuffer,
   base64EncodeArrayBuffer,
-  blendImageData,
+  blendColorPixelData,
+  blendPixelData,
+  clearPixelData,
   color32ToCssRGBA,
   color32ToHex,
   colorBurnColor32,
   colorDistance,
   copyImageData,
   copyImageDataLike,
+  copyMask,
   deserializeImageData,
   deserializeNullableImageData,
   deserializeRawImageData,
   differenceColor32,
-  extractPixelData,
+  extractImageData,
+  fillPixelData,
   hardLightColor32,
+  invertAlphaMask,
+  invertBinaryMask,
   lerpColor32,
   lerpColor32Fast,
   linearDodgeColor32,
-  makeImageDataColor32Adapter,
+  mergeMasks,
   multiplyColor32,
   overlayColor32,
   packColor,
@@ -537,6 +868,7 @@ function color32ToCssRGBA(color) {
   unpackColor,
   unpackColorTo,
   unpackGreen,
-  unpackRed
+  unpackRed,
+  writeImageData
 });
 //# sourceMappingURL=index.dev.cjs.map