pixel-data-js 0.8.0 → 0.9.1

package/dist/index.prod.d.ts

@@ -155,6 +155,10 @@ type SelectionRect = Rect & ({
     mask?: null;
     maskType?: null;
 });
+type Point = {
+    x: number;
+    y: number;
+};
 
 /**
  * Packs RGBA into a 32-bit integer compatible with
@@ -276,6 +280,7 @@ declare enum BlendMode {
     subtract = 21,
     divide = 22
 }
+type BlendModeIndex = typeof BlendMode[keyof typeof BlendMode];
 
 declare const overwriteFast: BlendColor32;
 declare const sourceOverFast: BlendColor32;
@@ -325,16 +330,9 @@ declare const subtractFast: BlendColor32;
 declare const divideFast: BlendColor32;
 declare const FAST_BLENDER_REGISTRY: readonly [readonly [BlendMode.overwrite, BlendColor32], readonly [BlendMode.sourceOver, BlendColor32], readonly [BlendMode.darken, BlendColor32], readonly [BlendMode.multiply, BlendColor32], readonly [BlendMode.colorBurn, BlendColor32], readonly [BlendMode.linearBurn, BlendColor32], readonly [BlendMode.darkerColor, BlendColor32], readonly [BlendMode.lighten, BlendColor32], readonly [BlendMode.screen, BlendColor32], readonly [BlendMode.colorDodge, BlendColor32], readonly [BlendMode.linearDodge, BlendColor32], readonly [BlendMode.lighterColor, BlendColor32], readonly [BlendMode.overlay, BlendColor32], readonly [BlendMode.softLight, BlendColor32], readonly [BlendMode.hardLight, BlendColor32], readonly [BlendMode.vividLight, BlendColor32], readonly [BlendMode.linearLight, BlendColor32], readonly [BlendMode.pinLight, BlendColor32], readonly [BlendMode.hardMix, BlendColor32], readonly [BlendMode.difference, BlendColor32], readonly [BlendMode.exclusion, BlendColor32], readonly [BlendMode.subtract, BlendColor32], readonly [BlendMode.divide, BlendColor32]];
 type RegisteredFastBlender = typeof FAST_BLENDER_REGISTRY[number][1];
-type FastBlendModeIndex = number & {
-    readonly __brandBlendModeIndex: unique symbol;
-};
 declare const FAST_BLEND_MODES: BlendColor32[];
-declare const FAST_BLEND_TO_INDEX: {
-    get: (blend: RegisteredFastBlender) => FastBlendModeIndex;
-};
-declare const INDEX_TO_FAST_BLEND: {
-    get: (index: FastBlendModeIndex) => RegisteredFastBlender;
-};
+declare const FAST_BLEND_TO_INDEX: BaseBlendToIndexGetter<RegisteredFastBlender>;
+declare const INDEX_TO_FAST_BLEND: BaseIndexToBlendGetter<RegisteredFastBlender>;
 type FastBlendModes = {
     [K in keyof typeof BlendMode]: RegisteredFastBlender;
 };
@@ -388,21 +386,23 @@ declare const subtractPerfect: BlendColor32;
 declare const dividePerfect: BlendColor32;
 declare const PERFECT_BLENDER_REGISTRY: readonly [readonly [BlendMode.overwrite, BlendColor32], readonly [BlendMode.sourceOver, BlendColor32], readonly [BlendMode.darken, BlendColor32], readonly [BlendMode.multiply, BlendColor32], readonly [BlendMode.colorBurn, BlendColor32], readonly [BlendMode.linearBurn, BlendColor32], readonly [BlendMode.darkerColor, BlendColor32], readonly [BlendMode.lighten, BlendColor32], readonly [BlendMode.screen, BlendColor32], readonly [BlendMode.colorDodge, BlendColor32], readonly [BlendMode.linearDodge, BlendColor32], readonly [BlendMode.lighterColor, BlendColor32], readonly [BlendMode.overlay, BlendColor32], readonly [BlendMode.softLight, BlendColor32], readonly [BlendMode.hardLight, BlendColor32], readonly [BlendMode.vividLight, BlendColor32], readonly [BlendMode.linearLight, BlendColor32], readonly [BlendMode.pinLight, BlendColor32], readonly [BlendMode.hardMix, BlendColor32], readonly [BlendMode.difference, BlendColor32], readonly [BlendMode.exclusion, BlendColor32], readonly [BlendMode.subtract, BlendColor32], readonly [BlendMode.divide, BlendColor32]];
 type RegisteredPerfectBlender = typeof PERFECT_BLENDER_REGISTRY[number][1];
-type PerfectBlendModeIndex = number & {
-    readonly __brandBlendModeIndex: unique symbol;
-};
 declare const PERFECT_BLEND_MODES: BlendColor32[];
-declare const PERFECT_BLEND_TO_INDEX: {
-    get: (blend: RegisteredPerfectBlender) => PerfectBlendModeIndex;
-};
-declare const INDEX_TO_PERFECT_BLEND: {
-    get: (index: PerfectBlendModeIndex) => RegisteredPerfectBlender;
-};
+declare const PERFECT_BLEND_TO_INDEX: BaseBlendToIndexGetter<RegisteredPerfectBlender>;
+declare const INDEX_TO_PERFECT_BLEND: BaseIndexToBlendGetter<RegisteredPerfectBlender>;
 type PerfectBlendModes = {
     [K in keyof typeof BlendMode]: RegisteredPerfectBlender;
 };
 declare const PERFECT_BLEND_MODE_BY_NAME: PerfectBlendModes;
 
+type BaseIndexToBlendGetter<B extends BlendColor32> = {
+    get: (index: BlendModeIndex) => B;
+};
+type IndexToBlendGetter = typeof INDEX_TO_FAST_BLEND | typeof INDEX_TO_PERFECT_BLEND;
+type BaseBlendToIndexGetter<B extends BlendColor32> = {
+    get: (blend: B) => BlendModeIndex;
+};
+type BlendToIndexGetter = typeof FAST_BLEND_TO_INDEX | typeof PERFECT_BLEND_TO_INDEX;
+
 type PixelCanvas = {
     readonly canvas: HTMLCanvasElement;
     readonly ctx: CanvasRenderingContext2D;
@@ -670,6 +670,9 @@ type IndexedImage = {
      */
     transparentPalletIndex: number;
 };
+/**
+ * Converts standard ImageData into an IndexedImage format.
+ */
 /**
  * Converts standard ImageData into an IndexedImage format.
  */
@@ -874,6 +877,16 @@ declare function invertPixelData(pixelData: PixelData): PixelData;
  */
 declare function pixelDataToAlphaMask(pixelData: PixelData): AlphaMask;
 
+declare function reflectPixelDataHorizontal(pixelData: PixelData): void;
+declare function reflectPixelDataVertical(pixelData: PixelData): void;
+
+/**
+ * Rotates pixel data 90 degrees clockwise.
+ * If the image is square, it performs the rotation in-place.
+ * If rectangular, it returns a new Uint32Array and updates dimensions.
+ */
+declare function rotatePixelData(pixelData: PixelData): void;
+
 /**
  * Intersects a target rectangle with a boundary, trimming dimensions and masks in-place.
  * This utility calculates the axis-aligned intersection between the `target` and `bounds`.
@@ -890,4 +903,4 @@ declare function pixelDataToAlphaMask(pixelData: PixelData): AlphaMask;
  */
 declare function trimRectBounds<T extends Rect | SelectionRect>(target: T, bounds: Rect): void;
 
-export { type AlphaMask, type AnyMask, type ApplyMaskOptions, type Base64EncodedUInt8Array, type BinaryMask, type BlendColor32, BlendMode, type Color32, type ColorBlendOptions, FAST_BLENDER_REGISTRY, FAST_BLEND_MODES, FAST_BLEND_MODE_BY_NAME, FAST_BLEND_TO_INDEX, type FastBlendModeIndex, type FastBlendModes, type FloodFillImageDataOptions, type FloodFillResult, INDEX_TO_FAST_BLEND, INDEX_TO_PERFECT_BLEND, type ImageDataLike, type IndexedImage, MaskType, PERFECT_BLENDER_REGISTRY, PERFECT_BLEND_MODES, PERFECT_BLEND_MODE_BY_NAME, PERFECT_BLEND_TO_INDEX, type PerfectBlendModeIndex, type PerfectBlendModes, type PixelBlendOptions, type PixelCanvas, PixelData, type PixelOptions, type RGBA, type Rect, type RegisteredFastBlender, type RegisteredPerfectBlender, type ReusableCanvas, type SelectionRect, type SerializedImageData, UnsupportedFormatError, applyMaskToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendPixelData, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataPixels, extractMask, fileInputChangeToImageData, fileToImageData, fillPixelData, floodFillSelection, getImageDataFromClipboard, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMask, imageDataToDataUrl, imageDataToImgBlob, imgBlobToImageData, indexedImageToAverageColor, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeIndexedImage, makePixelCanvas, makeReusableCanvas, mergeMasks, multiplyFast, multiplyPerfect, overlayFast, overlayPerfect, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, resizeImageData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractFast, subtractPerfect, trimRectBounds, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageDataPixels, writeImageDataToClipboard, writeImgBlobToClipboard };
+export { type AlphaMask, type AnyMask, type ApplyMaskOptions, type Base64EncodedUInt8Array, type BinaryMask, type BlendColor32, BlendMode, type BlendModeIndex, type BlendToIndexGetter, type Color32, type ColorBlendOptions, FAST_BLENDER_REGISTRY, FAST_BLEND_MODES, FAST_BLEND_MODE_BY_NAME, FAST_BLEND_TO_INDEX, type FastBlendModes, type FloodFillImageDataOptions, type FloodFillResult, INDEX_TO_FAST_BLEND, INDEX_TO_PERFECT_BLEND, type ImageDataLike, type IndexToBlendGetter, type IndexedImage, MaskType, PERFECT_BLENDER_REGISTRY, PERFECT_BLEND_MODES, PERFECT_BLEND_MODE_BY_NAME, PERFECT_BLEND_TO_INDEX, type PerfectBlendModes, type PixelBlendOptions, type PixelCanvas, PixelData, type PixelOptions, type Point, type RGBA, type Rect, type RegisteredFastBlender, type RegisteredPerfectBlender, type ReusableCanvas, type SelectionRect, type SerializedImageData, UnsupportedFormatError, applyMaskToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendPixelData, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataPixels, extractMask, fileInputChangeToImageData, fileToImageData, fillPixelData, floodFillSelection, getImageDataFromClipboard, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMask, imageDataToDataUrl, imageDataToImgBlob, imgBlobToImageData, indexedImageToAverageColor, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeIndexedImage, makePixelCanvas, makeReusableCanvas, mergeMasks, multiplyFast, multiplyPerfect, overlayFast, overlayPerfect, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resizeImageData, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractFast, subtractPerfect, trimRectBounds, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageDataPixels, writeImageDataToClipboard, writeImgBlobToClipboard };

package/dist/index.prod.js

@@ -1595,24 +1595,22 @@ function makeIndexedImage(imageData) {
   const rawData = new Uint32Array(imageData.data.buffer);
   const indexedData = new Int32Array(rawData.length);
   const colorMap = /* @__PURE__ */ new Map();
-  const tempPalette = [];
   const transparentColor = 0;
   const transparentPalletIndex = 0;
   colorMap.set(transparentColor, transparentPalletIndex);
-  tempPalette.push(transparentColor);
   for (let i = 0; i < rawData.length; i++) {
     const pixel = rawData[i];
-    const isTransparent = pixel >>> 24 === 0;
+    const alpha = pixel >>> 24 & 255;
+    const isTransparent = alpha === 0;
     const colorKey = isTransparent ? transparentColor : pixel;
     let id = colorMap.get(colorKey);
     if (id === void 0) {
       id = colorMap.size;
-      tempPalette.push(colorKey);
       colorMap.set(colorKey, id);
     }
     indexedData[i] = id;
   }
-  const palette = new Int32Array(tempPalette);
+  const palette = new Int32Array(colorMap.keys());
   return {
     width,
     height,
@@ -1625,7 +1623,7 @@ function makeIndexedImage(imageData) {
 // src/IndexedImage/indexedImageToAverageColor.ts
 function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
   const { data, palette, transparentPalletIndex } = indexedImage;
-  const counts = new Uint32Array(palette.length / 4);
+  const counts = new Uint32Array(palette.length);
   for (let i = 0; i < data.length; i++) {
     const id = data[i];
     counts[id]++;
@@ -1643,11 +1641,11 @@ function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
     if (!includeTransparent && id === transparentPalletIndex) {
       continue;
     }
-    const pIdx = id * 4;
-    const r2 = palette[pIdx];
-    const g2 = palette[pIdx + 1];
-    const b2 = palette[pIdx + 2];
-    const a2 = palette[pIdx + 3];
+    const color = palette[id] >>> 0;
+    const r2 = color & 255;
+    const g2 = color >> 8 & 255;
+    const b2 = color >> 16 & 255;
+    const a2 = color >> 24 & 255;
     rSum += r2 * weight;
     gSum += g2 * weight;
     bSum += b2 * weight;
@@ -2252,6 +2250,84 @@ function invertPixelData(pixelData) {
   }
   return pixelData;
 }
+
+// src/PixelData/reflectPixelData.ts
+function reflectPixelDataHorizontal(pixelData) {
+  const width = pixelData.width;
+  const height = pixelData.height;
+  const data = pixelData.data32;
+  const halfWidth = Math.floor(width / 2);
+  for (let y = 0; y < height; y++) {
+    const rowOffset = y * width;
+    for (let x = 0; x < halfWidth; x++) {
+      const leftIdx = rowOffset + x;
+      const rightIdx = rowOffset + (width - 1 - x);
+      const temp = data[leftIdx];
+      data[leftIdx] = data[rightIdx];
+      data[rightIdx] = temp;
+    }
+  }
+}
+function reflectPixelDataVertical(pixelData) {
+  const width = pixelData.width;
+  const height = pixelData.height;
+  const data = pixelData.data32;
+  const halfHeight = Math.floor(height / 2);
+  for (let y = 0; y < halfHeight; y++) {
+    const topRowOffset = y * width;
+    const bottomRowOffset = (height - 1 - y) * width;
+    for (let x = 0; x < width; x++) {
+      const topIdx = topRowOffset + x;
+      const bottomIdx = bottomRowOffset + x;
+      const temp = data[topIdx];
+      data[topIdx] = data[bottomIdx];
+      data[bottomIdx] = temp;
+    }
+  }
+}
+
+// src/PixelData/rotatePixelData.ts
+function rotatePixelData(pixelData) {
+  const width = pixelData.width;
+  const height = pixelData.height;
+  const data = pixelData.data32;
+  if (width === height) {
+    rotateSquareInPlace(pixelData);
+    return;
+  }
+  const newWidth = height;
+  const newHeight = width;
+  const newData = 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];
+    }
+  }
+  pixelData.width = newWidth;
+  pixelData.height = newHeight;
+  pixelData.data32 = newData;
+}
+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;
+      data[top] = data[left];
+      data[left] = data[bottom];
+      data[bottom] = data[right];
+      data[right] = temp;
+    }
+  }
+}
 export {
   BlendMode,
   FAST_BLENDER_REGISTRY,
@@ -2344,7 +2420,10 @@ export {
   pinLightFast,
   pinLightPerfect,
   pixelDataToAlphaMask,
+  reflectPixelDataHorizontal,
+  reflectPixelDataVertical,
   resizeImageData,
+  rotatePixelData,
   screenFast,
   screenPerfect,
   serializeImageData,