pixel-data-js 0.11.1 → 0.13.0

package/dist/index.dev.cjs

@@ -27,6 +27,7 @@ __export(src_exports, {
   FAST_BLEND_TO_INDEX: () => FAST_BLEND_TO_INDEX,
   INDEX_TO_FAST_BLEND: () => INDEX_TO_FAST_BLEND,
   INDEX_TO_PERFECT_BLEND: () => INDEX_TO_PERFECT_BLEND,
+  IndexedImage: () => IndexedImage,
   MaskType: () => MaskType,
   PERFECT_BLENDER_REGISTRY: () => PERFECT_BLENDER_REGISTRY,
   PERFECT_BLEND_MODES: () => PERFECT_BLEND_MODES,
@@ -81,6 +82,7 @@ __export(src_exports, {
   imageDataToImgBlob: () => imageDataToImgBlob,
   imgBlobToImageData: () => imgBlobToImageData,
   indexedImageToAverageColor: () => indexedImageToAverageColor,
+  indexedImageToImageData: () => indexedImageToImageData,
   invertAlphaMask: () => invertAlphaMask,
   invertBinaryMask: () => invertBinaryMask,
   invertImageData: () => invertImageData,
@@ -97,9 +99,9 @@ __export(src_exports, {
   linearDodgePerfect: () => linearDodgePerfect,
   linearLightFast: () => linearLightFast,
   linearLightPerfect: () => linearLightPerfect,
-  makeIndexedImage: () => makeIndexedImage,
   makePixelCanvas: () => makePixelCanvas,
   makeReusableCanvas: () => makeReusableCanvas,
+  makeReusableImageData: () => makeReusableImageData,
   mergeMasks: () => mergeMasks,
   multiplyFast: () => multiplyFast,
   multiplyPerfect: () => multiplyPerfect,
@@ -138,6 +140,7 @@ __export(src_exports, {
   unpackRed: () => unpackRed,
   vividLightFast: () => vividLightFast,
   vividLightPerfect: () => vividLightPerfect,
+  writeImageData: () => writeImageData,
   writeImageDataPixels: () => writeImageDataPixels,
   writeImageDataToClipboard: () => writeImageDataToClipboard,
   writeImgBlobToClipboard: () => writeImgBlobToClipboard
@@ -171,9 +174,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;
@@ -988,7 +993,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;
@@ -1571,6 +1576,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);
@@ -1750,6 +1771,60 @@ function deserializeNullableImageData(serialized) {
   return deserializeImageData(serialized);
 }
 
+// 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;
+  const dstH = target.height;
+  const dstData = target.data;
+  const srcW = source.width;
+  const srcData = source.data;
+  const x0 = Math.max(0, x);
+  const y0 = Math.max(0, y);
+  const x1 = Math.min(dstW, x + sw);
+  const y1 = Math.min(dstH, y + sh);
+  if (x1 <= x0 || y1 <= y0) {
+    return;
+  }
+  const useMask = !!mask;
+  const rowCount = y1 - y0;
+  const rowLenPixels = x1 - x0;
+  for (let row = 0; row < rowCount; row++) {
+    const dstY = y0 + row;
+    const srcY = sy + (dstY - y);
+    const srcXBase = sx + (x0 - x);
+    const dstStart = (dstY * dstW + x0) * 4;
+    const srcStart = (srcY * srcW + srcXBase) * 4;
+    if (useMask && mask) {
+      for (let ix = 0; ix < rowLenPixels; ix++) {
+        const mi = srcY * srcW + (srcXBase + 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 = rowLenPixels * 4;
+      const sub = srcData.subarray(srcStart, srcStart + byteLen);
+      dstData.set(sub, dstStart);
+    }
+  }
+}
+
 // 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 };
@@ -1772,38 +1847,88 @@ function writeImageDataPixels(imageData, data, _x, _y, _w, _h) {
 }
 
 // src/IndexedImage/IndexedImage.ts
-function makeIndexedImage(imageOrData, width, height) {
-  const isImageData = "width" in imageOrData;
-  const actualWidth = isImageData ? imageOrData.width : width;
-  const actualHeight = isImageData ? imageOrData.height : height;
-  const buffer = isImageData ? imageOrData.data.buffer : imageOrData.buffer;
-  const rawData = new Uint32Array(buffer);
-  const indexedData = new Int32Array(rawData.length);
-  const colorMap = /* @__PURE__ */ new Map();
-  const transparentColor = 0;
-  const transparentPalletIndex = 0;
-  colorMap.set(transparentColor, transparentPalletIndex);
-  for (let i = 0; i < rawData.length; i++) {
-    const pixel = rawData[i];
-    const alpha = pixel >>> 24 & 255;
-    const isTransparent = alpha === 0;
-    const colorKey = isTransparent ? transparentColor : pixel >>> 0;
-    let id = colorMap.get(colorKey);
-    if (id === void 0) {
-      id = colorMap.size;
-      colorMap.set(colorKey, id);
+var IndexedImage = class _IndexedImage {
+  /** The width of the image in pixels. */
+  width;
+  /** The height of the image in pixels. */
+  height;
+  /** Flat array of palette indices. Index = x + (y * width). */
+  data;
+  /** The palette of unique 32-bit colors (ABGR/RGBA packed) found in the image. */
+  palette;
+  /** The specific index in the palette reserved for fully transparent pixels. */
+  transparentPalletIndex;
+  /**
+   * @param width - Image width.
+   * @param height - Image height.
+   * @param data - The indexed pixel data.
+   * @param palette - The array of packed colors.
+   * @param transparentPalletIndex - The index representing alpha 0.
+   */
+  constructor(width, height, data, palette, transparentPalletIndex) {
+    this.width = width;
+    this.height = height;
+    this.data = data;
+    this.palette = palette;
+    this.transparentPalletIndex = transparentPalletIndex;
+  }
+  /**
+   * Creates an IndexedImage from standard browser ImageData.
+   * @param imageData - The source ImageData to convert.
+   * @returns A new IndexedImage instance.
+   */
+  static fromImageData(imageData) {
+    return _IndexedImage.fromRaw(imageData.data, imageData.width, imageData.height);
+  }
+  /**
+   * Creates an IndexedImage from a raw byte buffer and dimensions.
+   * Any pixel with an alpha channel of 0 is normalized to the transparent palette index.
+   * @param data - Raw RGBA byte data.
+   * @param width - Image width.
+   * @param height - Image height.
+   * @returns A new IndexedImage instance.
+   */
+  static fromRaw(data, width, height) {
+    const buffer = data.buffer;
+    const rawData = new Uint32Array(buffer);
+    const indexedData = new Int32Array(rawData.length);
+    const colorMap = /* @__PURE__ */ new Map();
+    const transparentColor = 0;
+    const transparentPalletIndex = 0;
+    colorMap.set(transparentColor, transparentPalletIndex);
+    for (let i = 0; i < rawData.length; i++) {
+      const pixel = rawData[i];
+      const alpha = pixel >>> 24 & 255;
+      const isTransparent = alpha === 0;
+      const colorKey = isTransparent ? transparentColor : pixel >>> 0;
+      let id = colorMap.get(colorKey);
+      if (id === void 0) {
+        id = colorMap.size;
+        colorMap.set(colorKey, id);
+      }
+      indexedData[i] = id;
     }
-    indexedData[i] = id;
+    const palette = Uint32Array.from(colorMap.keys());
+    return new _IndexedImage(
+      width,
+      height,
+      indexedData,
+      palette,
+      transparentPalletIndex
+    );
   }
-  const palette = Uint32Array.from(colorMap.keys());
-  return {
-    width: actualWidth,
-    height: actualHeight,
-    data: indexedData,
-    transparentPalletIndex,
-    palette
-  };
-}
+  /**
+   * Retrieves the 32-bit packed color value at the given coordinates.
+   * @param x - X coordinate.
+   * @param y - Y coordinate.
+   * @returns The packed color from the palette.
+   */
+  getColorAt(x, y) {
+    const index = x + y * this.width;
+    const paletteIndex = this.data[index];
+    return this.palette[paletteIndex];
+  }
+};
 
 // src/IndexedImage/getIndexedImageColorCounts.ts
 function getIndexedImageColorCounts(indexedImage) {
@@ -1867,13 +1992,26 @@ function resampleIndexedImage(source, factor) {
     source.height,
     factor
   );
-  return {
+  return new IndexedImage(
     width,
     height,
     data,
-    palette: source.palette,
-    transparentPalletIndex: source.transparentPalletIndex
-  };
+    source.palette,
+    source.transparentPalletIndex
+  );
+}
+
+// src/IndexedImage/indexedImageToImageData.ts
+function indexedImageToImageData(indexedImage) {
+  const { width, height, data, palette } = indexedImage;
+  const result = new ImageData(width, height);
+  const data32 = new Uint32Array(result.data.buffer);
+  for (let i = 0; i < data.length; i++) {
+    const paletteIndex = data[i];
+    const color = palette[paletteIndex];
+    data32[i] = color;
+  }
+  return result;
 }
 
 // src/Input/fileInputChangeToImageData.ts
@@ -2160,14 +2298,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,
@@ -2176,6 +2314,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;
@@ -2201,15 +2342,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];
@@ -2242,20 +2376,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++;
@@ -2330,11 +2464,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++;
@@ -2375,15 +2510,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++;
@@ -2561,6 +2696,7 @@ function rotateSquareInPlace(pixelData) {
   FAST_BLEND_TO_INDEX,
   INDEX_TO_FAST_BLEND,
   INDEX_TO_PERFECT_BLEND,
+  IndexedImage,
   MaskType,
   PERFECT_BLENDER_REGISTRY,
   PERFECT_BLEND_MODES,
@@ -2615,6 +2751,7 @@ function rotateSquareInPlace(pixelData) {
   imageDataToImgBlob,
   imgBlobToImageData,
   indexedImageToAverageColor,
+  indexedImageToImageData,
   invertAlphaMask,
   invertBinaryMask,
   invertImageData,
@@ -2631,9 +2768,9 @@ function rotateSquareInPlace(pixelData) {
   linearDodgePerfect,
   linearLightFast,
   linearLightPerfect,
-  makeIndexedImage,
   makePixelCanvas,
   makeReusableCanvas,
+  makeReusableImageData,
   mergeMasks,
   multiplyFast,
   multiplyPerfect,
@@ -2672,6 +2809,7 @@ function rotateSquareInPlace(pixelData) {
   unpackRed,
   vividLightFast,
   vividLightPerfect,
+  writeImageData,
   writeImageDataPixels,
   writeImageDataToClipboard,
   writeImgBlobToClipboard