pixel-data-js 0.11.0 → 0.12.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,7 +99,6 @@ __export(src_exports, {
   linearDodgePerfect: () => linearDodgePerfect,
   linearLightFast: () => linearLightFast,
   linearLightPerfect: () => linearLightPerfect,
-  makeIndexedImage: () => makeIndexedImage,
   makePixelCanvas: () => makePixelCanvas,
   makeReusableCanvas: () => makeReusableCanvas,
   mergeMasks: () => mergeMasks,
@@ -138,6 +139,7 @@ __export(src_exports, {
   unpackRed: () => unpackRed,
   vividLightFast: () => vividLightFast,
   vividLightPerfect: () => vividLightPerfect,
+  writeImageData: () => writeImageData,
   writeImageDataPixels: () => writeImageDataPixels,
   writeImageDataToClipboard: () => writeImageDataToClipboard,
   writeImgBlobToClipboard: () => writeImgBlobToClipboard
@@ -1710,7 +1712,9 @@ function resizeImageData(current, newWidth, newHeight, offsetX = 0, offsetY = 0)
 
 // src/ImageData/serialization.ts
 function base64EncodeArrayBuffer(buffer) {
-  const binary = String.fromCharCode(...new Uint8Array(buffer));
+  const uint8 = new Uint8Array(buffer);
+  const decoder = new TextDecoder("latin1");
+  const binary = decoder.decode(uint8);
   return btoa(binary);
 }
 function base64DecodeArrayBuffer(encoded) {
@@ -1769,40 +1773,144 @@ 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);
+// 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);
     }
-    indexedData[i] = id;
   }
-  const palette = Uint32Array.from(colorMap.keys());
-  return {
-    width: actualWidth,
-    height: actualHeight,
-    data: indexedData,
-    transparentPalletIndex,
-    palette
-  };
 }
 
+// src/IndexedImage/IndexedImage.ts
+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;
+    }
+    const palette = Uint32Array.from(colorMap.keys());
+    return new _IndexedImage(
+      width,
+      height,
+      indexedData,
+      palette,
+      transparentPalletIndex
+    );
+  }
+  /**
+   * 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) {
   const data = indexedImage.data;
@@ -1865,13 +1973,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
@@ -2559,6 +2680,7 @@ function rotateSquareInPlace(pixelData) {
   FAST_BLEND_TO_INDEX,
   INDEX_TO_FAST_BLEND,
   INDEX_TO_PERFECT_BLEND,
+  IndexedImage,
   MaskType,
   PERFECT_BLENDER_REGISTRY,
   PERFECT_BLEND_MODES,
@@ -2613,6 +2735,7 @@ function rotateSquareInPlace(pixelData) {
   imageDataToImgBlob,
   imgBlobToImageData,
   indexedImageToAverageColor,
+  indexedImageToImageData,
   invertAlphaMask,
   invertBinaryMask,
   invertImageData,
@@ -2629,7 +2752,6 @@ function rotateSquareInPlace(pixelData) {
   linearDodgePerfect,
   linearLightFast,
   linearLightPerfect,
-  makeIndexedImage,
   makePixelCanvas,
   makeReusableCanvas,
   mergeMasks,
@@ -2670,6 +2792,7 @@ function rotateSquareInPlace(pixelData) {
   unpackRed,
   vividLightFast,
   vividLightPerfect,
+  writeImageData,
   writeImageDataPixels,
   writeImageDataToClipboard,
   writeImgBlobToClipboard