pixel-data-js 0.1.0 → 0.2.0

package/dist/index.prod.d.ts

@@ -11,7 +11,7 @@ type BlendColor32 = (src: Color32, dst: Color32) => Color32;
 type ImageDataLike = {
     width: number;
     height: number;
-    data: Uint8ClampedArray;
+    data: Uint8ClampedArray<ArrayBuffer>;
 };
 type SerializedImageData = {
     width: number;
@@ -21,103 +21,28 @@ type SerializedImageData = {
 type Base64EncodedUInt8Array = string & {
     readonly __brandBase64UInt8Array: unique symbol;
 };
-
-/**
- * Packs RGBA into a 32-bit integer compatible with
- * Little-Endian Uint32Array views on ImageData.
- */
-declare function packColor(r: number, g: number, b: number, a: number): Color32;
-declare function packRGBA({ r, g, b, a }: RGBA): Color32;
-declare const unpackRed: (packed: Color32) => number;
-declare const unpackGreen: (packed: Color32) => number;
-declare const unpackBlue: (packed: Color32) => number;
-declare const unpackAlpha: (packed: Color32) => number;
-declare function unpackColor(packed: Color32): RGBA;
-declare function unpackColorTo(packed: Color32, scratch?: RGBA): RGBA;
-declare function colorDistance(a: Color32, b: Color32): number;
-/**
- * Linearly interpolates between two 32-bit colors using a floating-point weight.
- * * This is the preferred method for UI animations or scenarios where high
- * precision is required. It uses the standard `a + t * (b - a)` formula
- * for each channel.
- * @param a - The starting color as a 32-bit integer (AABBGGRR).
- * @param b - The target color as a 32-bit integer (AABBGGRR).
- * @param t - The interpolation factor between 0.0 and 1.0.
- * @returns The interpolated 32-bit color.
- */
-declare function lerpColor32(a: Color32, b: Color32, t: number): Color32;
-/**
- * Linearly interpolates between two 32-bit colors using integer fixed-point math.
- * Highly optimized for image processing and real-time blitting. It processes
- * channels in parallel using bitmasks (RB and GA pairs).
- * @note Subject to a 1-bit drift (rounding down) due to fast bit-shift division.
- * @param src - The source (foreground) color as a 32-bit integer.
- * @param dst - The destination (background) color as a 32-bit integer.
- * @param w - The blend weight as a byte value from 0 to 255. Where 0 is 100% dst and 255 is 100% src
- * @returns The blended 32-bit color.
- */ declare function lerpColor32Fast(src: Color32, dst: Color32, w: number): Color32;
-declare function color32ToHex(color: Color32): string;
-/**
- * Converts a 32-bit integer (0xAABBGGRR) to a CSS rgba() string.
- * Example: 0xFF0000FF -> "rgba(255,0,0,1)"
- */
-declare function color32ToCssRGBA(color: Color32): string;
-
-declare function base64EncodeArrayBuffer(buffer: ArrayBufferLike): Base64EncodedUInt8Array;
-declare function base64DecodeArrayBuffer(encoded: Base64EncodedUInt8Array): Uint8ClampedArray;
-/**
- * Serialize for use in JSON. Pixel data is stored as base64 encoded string.
- */
-declare function serializeImageData<T extends ImageDataLike>(imageData: T): SerializedImageData;
-declare function serializeNullableImageData<T extends ImageDataLike | null>(imageData: T): T extends null ? null : SerializedImageData;
-declare function deserializeRawImageData<T extends SerializedImageData>(serialized: T): ImageDataLike;
-declare function deserializeImageData<T extends SerializedImageData>(serialized: T): ImageData;
-declare function deserializeNullableImageData<T extends SerializedImageData | null>(serialized: T): T extends null ? null : ImageData;
-
-type BlendImageDataOptions = {
-    dx?: number;
-    dy?: number;
-    sx?: number;
-    sy?: number;
-    sw?: number;
-    sh?: number;
-    opacity?: number;
-    alpha?: number;
-    mask?: Uint8Array | null;
-    maskMode?: 'binary' | 'alpha';
-    blendFn?: BlendColor32;
+type Rect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
 };
-/**
- * Blits source ImageData into a destination ImageData using 32-bit integer bitwise blending.
- * * This function bypasses standard Canvas API limitations by operating directly on
- * Uint32Array views. It supports various blend modes, binary/alpha masking, and
- * automatic clipping of both source and destination bounds.
- * * @param dst - The destination ImageData to write into.
- * @param src - The source ImageData to read from.
- * @param dst - The destination ImageData to write to.
- * @param opts - Configuration for the blit operation.
- * @param opts.dx - Destination X offset. Defaults to 0.
- * @param opts.dy - Destination Y offset. Defaults to 0.
- * @param opts.sx - Source X offset. Defaults to 0.
- * @param opts.sy - Source Y offset. Defaults to 0.
- * @param opts.sw - Width of the source area to blit. Defaults to src.width.
- * @param opts.sh - Height of the source area to blit. Defaults to src.height.
- * @param opts.opacity - Global strength of the blit (0.0 to 1.0). Defaults to 1.0.
- * @param opts.alpha - Global strength of the blit (0 to 255). Overrides 'opacity' if provided.
- * @param opts.mask - An optional Uint8Array acting as a stencil or alpha mask.
- * Must match source dimensions.
- * @param opts.maskMode - 'binary' ignores pixels where mask is 0.
- * 'alpha' scales source alpha by mask value (0-255).
- * @param opts.blendFn - The math logic used to combine pixels.
- * Defaults to `sourceOverColor32`.
- * * @example
- * blendImageData32(ctx.getImageData(0,0,100,100), sprite, {
- * blendFn: COLOR_32_BLEND_MODES.multiply,
- * mask: brushMask,
- * maskMode: 'alpha'
- * });
- */
-declare function blendImageData(dst: ImageData, src: ImageData, opts: BlendImageDataOptions): void;
+declare enum MaskType {
+    ALPHA = 0,
+    BINARY = 1
+}
+interface BaseMaskData {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+}
+interface AlphaMask extends BaseMaskData {
+    readonly type: MaskType.ALPHA;
+}
+interface BinaryMask extends BaseMaskData {
+    readonly type: MaskType.BINARY;
+}
+type AnyMask = AlphaMask | BinaryMask;
 
 declare const sourceOverColor32: BlendColor32;
 /**
@@ -166,12 +91,182 @@ declare const COLOR_32_BLEND_MODES: {
     colorBurn: BlendColor32;
 };
 
+type BlendImageDataOptions = {
+    /**
+     * The x-coordinate in the destination image where the blend begins.
+     * @default 0
+     */
+    dx?: number;
+    /**
+     * The y-coordinate in the destination image where the blend begins.
+     * @default 0
+     */
+    dy?: number;
+    /**
+     * The x-coordinate of the top-left corner of the sub-rectangle
+     * of the source image to extract.
+     * @default 0
+     */
+    sx?: number;
+    /**
+     * The y-coordinate of the top-left corner of the sub-rectangle
+     * of the source image to extract.
+     * @default 0
+     */
+    sy?: number;
+    /**
+     * The width of the sub-rectangle of the source image to extract.
+     * Defaults to the full remaining width of the source.
+     */
+    sw?: number;
+    /**
+     * The height of the sub-rectangle of the source image to extract.
+     * Defaults to the full remaining height of the source.
+     */
+    sh?: number;
+    /**
+     * Overall layer opacity, typically ranging from 0.0 (transparent) to 1.0 (opaque).
+     * @default 1.0
+     */
+    opacity?: number;
+    /**
+     * Same as opacity but is 0-255 and faster when processing. If Present opacity is ignored.
+     * @default undefined
+     */
+    alpha?: number;
+    /**
+     * An optional alpha mask buffer.
+     * The values in this array (0-255) determine the intensity of the blend
+     * at each corresponding pixel.
+     */
+    mask?: AnyMask | null;
+    /**
+     * The specific blending function/algorithm to use for pixel math
+     * (e.g., Multiply, Screen, Overlay).
+     */
+    blendFn?: BlendColor32;
+};
+/**
+ * Blits source ImageData into a destination ImageData using 32-bit integer bitwise blending.
+ * This function bypasses standard Canvas API limitations by operating directly on
+ * Uint32Array views. It supports various blend modes, binary/alpha masking, and
+ * automatic clipping of both source and destination bounds.
+ * @example
+ * blendImageData32(ctx.getImageData(0,0,100,100), sprite, {
+ *   blendFn: COLOR_32_BLEND_MODES.multiply,
+ *   mask: brushMask,
+ *   maskMode: MaskMode.ALPHA
+ * });
+ */
+declare function blendImageData(dst: ImageDataLike, src: ImageDataLike, opts: BlendImageDataOptions): void;
+
+type ApplyMaskOptions = {
+    /**
+     * The x-coordinate in the destination image where the mask begins.
+     * @default 0
+     */
+    dx?: number;
+    /**
+     * The y-coordinate in the destination image where the mask begins.
+     * @default 0
+     */
+    dy?: number;
+    /**
+     * The x-coordinate of the top-left corner of the sub-rectangle
+     * of the source image to extract.
+     * @default 0
+     */
+    sx?: number;
+    /**
+     * The y-coordinate of the top-left corner of the sub-rectangle
+     * of the source image to extract.
+     * @default 0
+     */
+    sy?: number;
+    /**
+     * The width of the sub-rectangle of the source image to extract.
+     * Defaults to the full remaining width of the source.
+     */
+    sw?: number;
+    /**
+     * The height of the sub-rectangle of the source image to extract.
+     * Defaults to the full remaining height of the source.
+     */
+    sh?: number;
+};
+/**
+ * Applies a binary (on/off) mask to an RGBA buffer.
+ * If mask value is 0, pixel becomes transparent.
+ */
+declare function applyBinaryMask(dst: ImageDataLike, mask: BinaryMask, opts?: ApplyMaskOptions): ImageDataLike | undefined;
+/**
+ * Applies a smooth alpha mask to an RGBA buffer.
+ * Multiplies existing Alpha by (maskValue / 255).
+ */
+declare function applyAlphaMask(dst: ImageData, mask: AlphaMask, opts?: ApplyMaskOptions): void;
+
 declare function makeImageDataColor32Adapter(imageData: ImageDataLike): {
     inBounds: (x: number, y: number) => boolean;
     imageData: ImageDataLike;
-    data32: Uint32Array<ArrayBufferLike>;
+    data32: Uint32Array<ArrayBuffer>;
     setPixel: (x: number, y: number, color: Color32) => void;
     getPixel: (x: number, y: number) => Color32 | undefined;
 };
+declare function extractPixelData(imageData: ImageDataLike, rect: Rect): Uint8ClampedArray;
+declare function extractPixelData(imageData: ImageDataLike, x: number, y: number, w: number, h: number): Uint8ClampedArray;
+declare function copyImageData({ data, width, height }: ImageDataLike): ImageData;
+declare function copyImageDataLike({ data, width, height }: ImageDataLike): ImageDataLike;
+
+declare function base64EncodeArrayBuffer(buffer: ArrayBufferLike): Base64EncodedUInt8Array;
+declare function base64DecodeArrayBuffer(encoded: Base64EncodedUInt8Array): Uint8ClampedArray<ArrayBuffer>;
+/**
+ * Serialize for use in JSON. Pixel data is stored as base64 encoded string.
+ */
+declare function serializeImageData<T extends ImageDataLike>(imageData: T): SerializedImageData;
+declare function serializeNullableImageData<T extends ImageDataLike | null>(imageData: T): T extends null ? null : SerializedImageData;
+declare function deserializeRawImageData<T extends SerializedImageData>(serialized: T): ImageDataLike;
+declare function deserializeImageData<T extends SerializedImageData>(serialized: T): ImageData;
+declare function deserializeNullableImageData<T extends SerializedImageData | null>(serialized: T): T extends null ? null : ImageData;
+
+/**
+ * Packs RGBA into a 32-bit integer compatible with
+ * Little-Endian Uint32Array views on ImageData.
+ */
+declare function packColor(r: number, g: number, b: number, a: number): Color32;
+declare function packRGBA({ r, g, b, a }: RGBA): Color32;
+declare const unpackRed: (packed: Color32) => number;
+declare const unpackGreen: (packed: Color32) => number;
+declare const unpackBlue: (packed: Color32) => number;
+declare const unpackAlpha: (packed: Color32) => number;
+declare function unpackColor(packed: Color32): RGBA;
+declare function unpackColorTo(packed: Color32, scratch?: RGBA): RGBA;
+declare function colorDistance(a: Color32, b: Color32): number;
+/**
+ * Linearly interpolates between two 32-bit colors using a floating-point weight.
+ * * This is the preferred method for UI animations or scenarios where high
+ * precision is required. It uses the standard `a + t * (b - a)` formula
+ * for each channel.
+ * @param a - The starting color as a 32-bit integer (AABBGGRR).
+ * @param b - The target color as a 32-bit integer (AABBGGRR).
+ * @param t - The interpolation factor between 0.0 and 1.0.
+ * @returns The interpolated 32-bit color.
+ */
+declare function lerpColor32(a: Color32, b: Color32, t: number): Color32;
+/**
+ * Linearly interpolates between two 32-bit colors using integer fixed-point math.
+ * Highly optimized for image processing and real-time blitting. It processes
+ * channels in parallel using bitmasks (RB and GA pairs).
+ * @note Subject to a 1-bit drift (rounding down) due to fast bit-shift division.
+ * @param src - The source (foreground) color as a 32-bit integer.
+ * @param dst - The destination (background) color as a 32-bit integer.
+ * @param w - The blend weight as a byte value from 0 to 255. Where 0 is 100% dst and 255 is 100% src
+ * @returns The blended 32-bit color.
+ */ declare function lerpColor32Fast(src: Color32, dst: Color32, w: number): Color32;
+declare function color32ToHex(color: Color32): string;
+/**
+ * Converts a 32-bit integer (0xAABBGGRR) to a CSS rgba() string.
+ * Example: 0xFF0000FF -> "rgba(255,0,0,1)"
+ */
+declare function color32ToCssRGBA(color: Color32): string;
 
-export { type BlendImageDataOptions, COLOR_32_BLEND_MODES, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendImageData, color32ToCssRGBA, color32ToHex, colorBurnColor32, colorDistance, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceColor32, hardLightColor32, lerpColor32, lerpColor32Fast, linearDodgeColor32, makeImageDataColor32Adapter, multiplyColor32, overlayColor32, packColor, packRGBA, screenColor32, serializeImageData, serializeNullableImageData, sourceOverColor32, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed };
+export { type AlphaMask, type AnyMask, type ApplyMaskOptions, type Base64EncodedUInt8Array, type BinaryMask, type BlendColor32, type BlendImageDataOptions, COLOR_32_BLEND_MODES, type Color32, type ImageDataLike, MaskType, type RGBA, type Rect, type SerializedImageData, applyAlphaMask, applyBinaryMask, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendImageData, color32ToCssRGBA, color32ToHex, colorBurnColor32, colorDistance, copyImageData, copyImageDataLike, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceColor32, extractPixelData, hardLightColor32, lerpColor32, lerpColor32Fast, linearDodgeColor32, makeImageDataColor32Adapter, multiplyColor32, overlayColor32, packColor, packRGBA, screenColor32, serializeImageData, serializeNullableImageData, sourceOverColor32, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed };

package/dist/index.prod.js

@@ -1,106 +1,3 @@
-// src/color.ts
-function packColor(r, g, b, a) {
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-}
-function packRGBA({ r, g, b, a }) {
-  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
-}
-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/serialization.ts
-function base64EncodeArrayBuffer(buffer) {
-  const binary = String.fromCharCode(...new Uint8Array(buffer));
-  return btoa(binary);
-}
-function base64DecodeArrayBuffer(encoded) {
-  const binary = atob(encoded);
-  const bytes = new Uint8ClampedArray(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
-}
-function serializeImageData(imageData) {
-  return {
-    width: imageData.width,
-    height: imageData.height,
-    data: base64EncodeArrayBuffer(imageData.data.buffer)
-  };
-}
-function serializeNullableImageData(imageData) {
-  if (!imageData) return null;
-  return serializeImageData(imageData);
-}
-function deserializeRawImageData(serialized) {
-  return {
-    width: serialized.width,
-    height: serialized.height,
-    data: base64DecodeArrayBuffer(serialized.data)
-  };
-}
-function deserializeImageData(serialized) {
-  const data = base64DecodeArrayBuffer(serialized.data);
-  return new ImageData(data, serialized.width, serialized.height);
-}
-function deserializeNullableImageData(serialized) {
-  if (!serialized) return null;
-  return deserializeImageData(serialized);
-}
-
 // src/ImageData/blend-modes.ts
 var sourceOverColor32 = (src, dst) => {
   const a = src >>> 24 & 255;
@@ -237,6 +134,13 @@ 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 {
@@ -246,7 +150,6 @@ function blendImageData(dst, src, opts) {
     sy = 0,
     sw = src.width,
     sh = src.height,
-    maskMode = "alpha",
     opacity = 1,
     alpha,
     blendFn = sourceOverColor32,
@@ -282,7 +185,7 @@ function blendImageData(dst, src, opts) {
   const dw = dst.width;
   const sw_orig = src.width;
   const gAlpha = alpha !== void 0 ? alpha | 0 : Math.round(opacity * 255);
-  const maskIsAlpha = maskMode === "alpha";
+  const maskIsAlpha = mask?.type === 0 /* ALPHA */;
   for (let iy = 0; iy < actualH; iy++) {
     const dRow = (iy + dy) * dw;
     const sRow = (iy + sy) * sw_orig;
@@ -294,7 +197,7 @@ function blendImageData(dst, src, opts) {
       if (sa === 0) continue;
       let activeWeight = gAlpha;
       if (mask) {
-        const m = mask[si];
+        const m = mask.data[si];
         if (m === 0) continue;
         activeWeight = maskIsAlpha ? m * activeWeight + 128 >> 8 : activeWeight;
       }
@@ -308,6 +211,76 @@ function blendImageData(dst, src, opts) {
   }
 }
 
+// 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 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;
+    }
+  }
+}
+
 // src/ImageData/read-write-pixels.ts
 function makeImageDataColor32Adapter(imageData) {
   const data32 = new Uint32Array(imageData.data.buffer);
@@ -330,8 +303,145 @@ function makeImageDataColor32Adapter(imageData) {
     getPixel
   };
 }
+function extractPixelData(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);
+  const out = new Uint8ClampedArray(w * h * 4);
+  const x0 = Math.max(0, x);
+  const y0 = Math.max(0, y);
+  const x1 = Math.min(srcW, x + w);
+  const y1 = Math.min(srcH, y + h);
+  if (x1 <= x0 || y1 <= y0) return out;
+  for (let row = 0; row < y1 - y0; row++) {
+    const srcRow = y0 + row;
+    const srcStart = (srcRow * srcW + x0) * 4;
+    const rowLen = (x1 - x0) * 4;
+    const dstRow = y0 - y + row;
+    const dstCol = x0 - x;
+    const dstStart = (dstRow * w + dstCol) * 4;
+    out.set(src.subarray(srcStart, srcStart + rowLen), dstStart);
+  }
+  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) {
+  const binary = String.fromCharCode(...new Uint8Array(buffer));
+  return btoa(binary);
+}
+function base64DecodeArrayBuffer(encoded) {
+  const binary = atob(encoded);
+  const bytes = new Uint8ClampedArray(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function serializeImageData(imageData) {
+  return {
+    width: imageData.width,
+    height: imageData.height,
+    data: base64EncodeArrayBuffer(imageData.data.buffer)
+  };
+}
+function serializeNullableImageData(imageData) {
+  if (!imageData) return null;
+  return serializeImageData(imageData);
+}
+function deserializeRawImageData(serialized) {
+  return {
+    width: serialized.width,
+    height: serialized.height,
+    data: base64DecodeArrayBuffer(serialized.data)
+  };
+}
+function deserializeImageData(serialized) {
+  const data = base64DecodeArrayBuffer(serialized.data);
+  return new ImageData(data, serialized.width, serialized.height);
+}
+function deserializeNullableImageData(serialized) {
+  if (!serialized) return null;
+  return deserializeImageData(serialized);
+}
+
+// src/color.ts
+function packColor(r, g, b, a) {
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+}
+function packRGBA({ r, g, b, a }) {
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+}
+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})`;
+}
 export {
   COLOR_32_BLEND_MODES,
+  MaskType,
+  applyAlphaMask,
+  applyBinaryMask,
   base64DecodeArrayBuffer,
   base64EncodeArrayBuffer,
   blendImageData,
@@ -339,10 +449,13 @@ export {
   color32ToHex,
   colorBurnColor32,
   colorDistance,
+  copyImageData,
+  copyImageDataLike,
   deserializeImageData,
   deserializeNullableImageData,
   deserializeRawImageData,
   differenceColor32,
+  extractPixelData,
   hardLightColor32,
   lerpColor32,
   lerpColor32Fast,