pixel-data-js 0.12.0 → 0.14.0

package/dist/index.dev.cjs

@@ -80,6 +80,7 @@ __export(src_exports, {
   imageDataToAlphaMask: () => imageDataToAlphaMask,
   imageDataToDataUrl: () => imageDataToDataUrl,
   imageDataToImgBlob: () => imageDataToImgBlob,
+  imageDataToUInt32Array: () => imageDataToUInt32Array,
   imgBlobToImageData: () => imgBlobToImageData,
   indexedImageToAverageColor: () => indexedImageToAverageColor,
   indexedImageToImageData: () => indexedImageToImageData,
@@ -101,6 +102,7 @@ __export(src_exports, {
   linearLightPerfect: () => linearLightPerfect,
   makePixelCanvas: () => makePixelCanvas,
   makeReusableCanvas: () => makeReusableCanvas,
+  makeReusableImageData: () => makeReusableImageData,
   mergeMasks: () => mergeMasks,
   multiplyFast: () => multiplyFast,
   multiplyPerfect: () => multiplyPerfect,
@@ -173,9 +175,11 @@ var BlendMode = /* @__PURE__ */ ((BlendMode2) => {
   BlendMode2[BlendMode2["divide"] = 22] = "divide";
   return BlendMode2;
 })(BlendMode || {});
+var overwriteBase = (src, _dst) => src;
+overwriteBase.isOverwrite = true;
 
 // src/BlendModes/blend-modes-fast.ts
-var overwriteFast = (src, _dst) => src;
+var overwriteFast = overwriteBase;
 var sourceOverFast = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 255) return src;
@@ -990,7 +994,7 @@ function floodFillSelection(img, startX, startY, {
 }
 
 // src/BlendModes/blend-modes-perfect.ts
-var overwritePerfect = (src, _dst) => src;
+var overwritePerfect = overwriteBase;
 var sourceOverPerfect = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 255) return src;
@@ -1573,6 +1577,22 @@ async function writeImageDataToClipboard(imageData) {
   return writeImgBlobToClipboard(blob);
 }
 
+// src/ImageData/ReusableImageData.ts
+function makeReusableImageData() {
+  let imageData = null;
+  let buffer = null;
+  return function getReusableImageData(width, height) {
+    const hasInstance = !!imageData;
+    const widthMatches = hasInstance && imageData.width === width;
+    const heightMatches = hasInstance && imageData.height === height;
+    if (!widthMatches || !heightMatches) {
+      const buffer2 = new Uint8ClampedArray(width * height * 4);
+      imageData = new ImageData(buffer2, width, height);
+    }
+    return imageData;
+  };
+}
+
 // src/ImageData/copyImageData.ts
 function copyImageData({ data, width, height }) {
   return new ImageData(data.slice(), width, height);
@@ -1631,6 +1651,16 @@ function imageDataToDataUrl(imageData) {
 }
 imageDataToDataUrl.reset = get.reset;
 
+// src/ImageData/imageDataToUInt32Array.ts
+function imageDataToUInt32Array(imageData) {
+  return new Uint32Array(
+    imageData.data.buffer,
+    imageData.data.byteOffset,
+    // Shift right by 2 is a fast bitwise division by 4.
+    imageData.data.byteLength >> 2
+  );
+}
+
 // src/ImageData/invertImageData.ts
 function invertImageData(imageData) {
   const data = imageData.data;
@@ -1752,27 +1782,6 @@ function deserializeNullableImageData(serialized) {
   return deserializeImageData(serialized);
 }
 
-// src/ImageData/writeImageDataPixels.ts
-function writeImageDataPixels(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);
-  }
-}
-
 // src/ImageData/writeImageData.ts
 function writeImageData(target, source, x, y, sx = 0, sy = 0, sw = source.width, sh = source.height, mask = null, maskType = 1 /* BINARY */) {
   const dstW = target.width;
@@ -1827,6 +1836,27 @@ function writeImageData(target, source, x, y, sx = 0, sy = 0, sw = source.width,
   }
 }
 
+// src/ImageData/writeImageDataPixels.ts
+function writeImageDataPixels(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);
+  }
+}
+
 // src/IndexedImage/IndexedImage.ts
 var IndexedImage = class _IndexedImage {
   /** The width of the image in pixels. */
@@ -2166,28 +2196,34 @@ function mergeMasks(dst, dstWidth, src, opts) {
 
 // src/PixelData/PixelData.ts
 var PixelData = class _PixelData {
+  data32;
+  imageData;
+  get width() {
+    return this.imageData.width;
+  }
+  get height() {
+    return this.imageData.height;
+  }
   constructor(imageData) {
+    this.data32 = imageDataToUInt32Array(imageData);
     this.imageData = imageData;
-    this.width = imageData.width;
-    this.height = imageData.height;
-    this.data32 = new Uint32Array(
-      imageData.data.buffer,
-      imageData.data.byteOffset,
-      // Shift right by 2 is a fast bitwise division by 4.
-      imageData.data.byteLength >> 2
-    );
   }
-  data32;
-  width;
-  height;
+  set(imageData) {
+    this.imageData = imageData;
+    this.data32 = imageDataToUInt32Array(imageData);
+  }
+  /**
+   * Creates a deep copy of the PixelData using the environment's ImageData constructor.
+   */
   copy() {
-    const buffer = new Uint8ClampedArray(this.data32.buffer.slice(0));
-    const imageData = {
-      data: buffer,
-      width: this.width,
-      height: this.height
-    };
-    return new _PixelData(imageData);
+    const buffer = new Uint8ClampedArray(this.imageData.data);
+    const ImageConstructor = typeof ImageData !== "undefined" ? ImageData : this.imageData.constructor;
+    const newImageData = new ImageConstructor(
+      buffer,
+      this.width,
+      this.height
+    );
+    return new _PixelData(newImageData);
   }
 };
 
@@ -2279,14 +2315,14 @@ function applyMaskToPixelData(dst, mask, opts) {
 }
 
 // src/PixelData/blendColorPixelData.ts
-function blendColorPixelData(dst, color, opts) {
+function blendColorPixelData(dst, color, opts = {}) {
   const {
     x: targetX = 0,
     y: targetY = 0,
     w: width = dst.width,
     h: height = dst.height,
     alpha: globalAlpha = 255,
-    blendFn = FAST_BLEND_MODES[1 /* sourceOver */],
+    blendFn = sourceOverFast,
     mask,
     maskType = 0 /* ALPHA */,
     mw,
@@ -2295,6 +2331,9 @@ function blendColorPixelData(dst, color, opts) {
     invertMask = false
   } = opts;
   if (globalAlpha === 0) return;
+  const baseSrcAlpha = color >>> 24;
+  const isOverwrite = blendFn.isOverwrite;
+  if (baseSrcAlpha === 0 && !isOverwrite) return;
   let x = targetX;
   let y = targetY;
   let w = width;
@@ -2320,15 +2359,8 @@ function blendColorPixelData(dst, color, opts) {
   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];
@@ -2361,20 +2393,20 @@ function blendColorPixelData(dst, color, opts) {
           continue;
         }
       }
-      let currentSrcAlpha = baseSrcAlpha;
-      let currentSrcColor = baseSrcColor;
+      let currentSrcColor = color;
       if (weight < 255) {
+        let currentSrcAlpha = baseSrcAlpha;
         if (baseSrcAlpha === 255) {
           currentSrcAlpha = weight;
         } else {
           currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
         }
-        if (currentSrcAlpha === 0) {
+        if (!isOverwrite && currentSrcAlpha === 0) {
           dIdx++;
           mIdx++;
           continue;
         }
-        currentSrcColor = (baseSrcColor & 16777215 | currentSrcAlpha << 24) >>> 0;
+        currentSrcColor = (color & 16777215 | currentSrcAlpha << 24) >>> 0;
       }
       dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
       dIdx++;
@@ -2449,11 +2481,12 @@ function blendPixelData(dst, src, opts) {
   const dStride = dw - actualW;
   const sStride = sw - actualW;
   const mStride = mPitch - actualW;
+  const isOverwrite = blendFn.isOverwrite;
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
       const baseSrcColor = src32[sIdx];
       const baseSrcAlpha = baseSrcColor >>> 24;
-      if (baseSrcAlpha === 0) {
+      if (baseSrcAlpha === 0 && !isOverwrite) {
         dIdx++;
         sIdx++;
         mIdx++;
@@ -2494,15 +2527,15 @@ function blendPixelData(dst, src, opts) {
           continue;
         }
       }
-      let currentSrcAlpha = baseSrcAlpha;
       let currentSrcColor = baseSrcColor;
       if (weight < 255) {
+        let currentSrcAlpha = baseSrcAlpha;
         if (baseSrcAlpha === 255) {
           currentSrcAlpha = weight;
         } else {
           currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
         }
-        if (currentSrcAlpha === 0) {
+        if (!isOverwrite && currentSrcAlpha === 0) {
           dIdx++;
           sIdx++;
           mIdx++;
@@ -2622,11 +2655,11 @@ 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({
+  return new PixelData(new ImageData(
+    new Uint8ClampedArray(data.buffer),
     width,
-    height,
-    data: new Uint8ClampedArray(data.buffer)
-  });
+    height
+  ));
 }
 
 // src/PixelData/rotatePixelData.ts
@@ -2640,30 +2673,33 @@ function rotatePixelData(pixelData) {
   }
   const newWidth = height;
   const newHeight = width;
-  const newData = new Uint32Array(data.length);
+  const newData32 = new Uint32Array(data.length);
   for (let y = 0; y < height; y++) {
     for (let x = 0; x < width; x++) {
       const oldIdx = y * width + x;
       const newX = height - 1 - y;
       const newY = x;
       const newIdx = newY * newWidth + newX;
-      newData[newIdx] = data[oldIdx];
+      newData32[newIdx] = data[oldIdx];
     }
   }
-  pixelData.width = newWidth;
-  pixelData.height = newHeight;
-  pixelData.data32 = newData;
+  const newImageData = new ImageData(
+    new Uint8ClampedArray(newData32.buffer),
+    newWidth,
+    newHeight
+  );
+  pixelData.set(newImageData);
 }
 function rotateSquareInPlace(pixelData) {
   const n = pixelData.width;
   const data = pixelData.data32;
   for (let i = 0; i < n / 2; i++) {
     for (let j = i; j < n - i - 1; j++) {
-      const temp = data[i * n + j];
       const top = i * n + j;
       const right = j * n + (n - 1 - i);
       const bottom = (n - 1 - i) * n + (n - 1 - j);
       const left = (n - 1 - j) * n + i;
+      const temp = data[top];
       data[top] = data[left];
       data[left] = data[bottom];
       data[bottom] = data[right];
@@ -2733,6 +2769,7 @@ function rotateSquareInPlace(pixelData) {
   imageDataToAlphaMask,
   imageDataToDataUrl,
   imageDataToImgBlob,
+  imageDataToUInt32Array,
   imgBlobToImageData,
   indexedImageToAverageColor,
   indexedImageToImageData,
@@ -2754,6 +2791,7 @@ function rotateSquareInPlace(pixelData) {
   linearLightPerfect,
   makePixelCanvas,
   makeReusableCanvas,
+  makeReusableImageData,
   mergeMasks,
   multiplyFast,
   multiplyPerfect,