pixel-data-js 0.27.0 → 0.28.0

package/dist/index.prod.d.ts

@@ -1,40 +1,12 @@
-/** ALL values are 0-255 (including alpha which in CSS is 0-1) */
-type RGBA = {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-};
-/** Represents a 32-bit color in 0xAABBGGRR (Little endian) */
-type Color32 = number & {
-    readonly __brandColor32: unique symbol;
-};
-/**
- * A function that defines how to combine a source color with a destination color.
- * @param src - The incoming color (source).
- * @param dst - The existing color in the buffer (destination).
- * @returns The resulting 32-bit color to be written to the buffer.
- */
-type BlendColor32 = {
-    (src: Color32, dst: Color32): Color32;
-    isOverwrite?: true;
-};
-type ImageDataLike = {
-    width: number;
-    height: number;
-    data: Uint8ClampedArray<ArrayBufferLike>;
-};
-type ImageDataLikeConstructor<T extends ImageDataLike = ImageDataLike> = {
-    new (data: Uint8ClampedArray, width: number, height: number): T;
-};
-type SerializedImageData = {
-    width: number;
-    height: number;
-    data: string;
-};
-type Base64EncodedUInt8Array = string & {
-    readonly __brandBase64UInt8Array: unique symbol;
-};
+declare const OFFSCREEN_CANVAS_CTX_FAILED = "Failed to create OffscreenCanvas context";
+declare const CANVAS_CTX_FAILED = "Failed to create Canvas context";
+
+declare const _errors_CANVAS_CTX_FAILED: typeof CANVAS_CTX_FAILED;
+declare const _errors_OFFSCREEN_CANVAS_CTX_FAILED: typeof OFFSCREEN_CANVAS_CTX_FAILED;
+declare namespace _errors {
+  export { _errors_CANVAS_CTX_FAILED as CANVAS_CTX_FAILED, _errors_OFFSCREEN_CANVAS_CTX_FAILED as OFFSCREEN_CANVAS_CTX_FAILED };
+}
+
 /** Rectangle definition */
 type Rect = {
     x: number;
@@ -42,6 +14,7 @@ type Rect = {
     w: number;
     h: number;
 };
+
 /**
  * Defines how mask values should be interpreted during a draw operation.
  */
@@ -72,15 +45,58 @@ interface BinaryMask extends BaseMask {
 interface AlphaMask extends BaseMask {
     readonly type: MaskType.ALPHA;
 }
-interface BasePaintMask {
-    readonly centerOffsetX: number;
-    readonly centerOffsetY: number;
+interface MutableMask<T extends MaskType> {
+    readonly type: T;
+    data: Uint8Array;
+    w: number;
+    h: number;
 }
-interface PaintAlphaMask extends BasePaintMask, AlphaMask {
+interface MutableAlphaMask extends MutableMask<MaskType.ALPHA> {
 }
-interface PaintBinaryMask extends BasePaintMask, BinaryMask {
+interface MutableBinaryMask extends MutableMask<MaskType.BINARY> {
 }
-type PaintMask = PaintAlphaMask | PaintBinaryMask;
+type MaskRect<T extends MaskType> = Rect & {
+    type: T;
+    data: Uint8Array;
+};
+type BinaryMaskRect = MaskRect<MaskType.BINARY>;
+type AlphaMaskRect = MaskRect<MaskType.ALPHA>;
+type NullableBinaryMaskRect = Rect & ({
+    type: MaskType.BINARY;
+    data: Uint8Array;
+} | {
+    type?: null;
+    data?: null;
+});
+type NullableMaskRect = Rect & ({
+    type: MaskType;
+    data: Uint8Array;
+} | {
+    type?: null;
+    data?: null;
+});
+
+/** ALL values are 0-255 (including alpha which in CSS is 0-1) */
+type RGBA = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/** Represents a 32-bit color in 0xAABBGGRR (Little endian) */
+type Color32 = number & {
+    readonly __brandColor32: unique symbol;
+};
+/**
+ * A function that defines how to combine a source color with a destination color.
+ * @param src - The incoming color (source).
+ * @param dst - The existing color in the buffer (destination).
+ * @returns The resulting 32-bit color to be written to the buffer.
+ */
+type BlendColor32 = {
+    (src: Color32, dst: Color32): Color32;
+    isOverwrite?: true;
+};
 /**
  * Configuration for pixel manipulation operations.
  * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
@@ -177,44 +193,33 @@ interface ColorBlendOptions extends PixelRect, Alpha {
 }
 interface ColorBlendMaskOptions extends ColorBlendOptions, MaskOffset, InvertMask {
 }
-interface ColorBlendPaintMaskOptions extends Omit<ColorBlendOptions, 'w' | 'h'> {
+
+interface ImageDataLike {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray<ArrayBufferLike>;
 }
-type MaskRect<T extends MaskType> = Rect & {
-    type: T;
-    data: Uint8Array;
+type SerializedImageData = {
+    width: number;
+    height: number;
+    data: string;
 };
-type BinaryMaskRect = MaskRect<MaskType.BINARY>;
-type AlphaMaskRect = MaskRect<MaskType.ALPHA>;
-type NullableBinaryMaskRect = Rect & ({
-    type: MaskType.BINARY;
-    data: Uint8Array;
-} | {
-    type?: null;
-    data?: null;
-});
-type NullableMaskRect = Rect & ({
-    type: MaskType;
-    data: Uint8Array;
-} | {
-    type?: null;
-    data?: null;
-});
-interface IPixelData32 {
-    readonly data32: Uint32Array;
-    readonly width: number;
-    readonly height: number;
+type Base64EncodedUInt8Array = string & {
+    readonly __brandBase64UInt8Array: unique symbol;
+};
+
+interface PixelData32 {
+    readonly data: Uint32Array;
+    readonly w: number;
+    readonly h: number;
 }
-interface IPixelData<T extends ImageDataLike = ImageData> extends IPixelData32 {
-    readonly imageData: T;
+interface MutablePixelData32 {
+    data: Uint32Array;
+    w: number;
+    h: number;
 }
-
-declare class PixelData<T extends ImageDataLike = ImageData> implements IPixelData<T> {
-    readonly data32: Uint32Array;
+interface PixelData<T extends ImageDataLike = ImageData> extends PixelData32 {
     readonly imageData: T;
-    readonly width: number;
-    readonly height: number;
-    constructor(imageData: T);
-    set(imageData: T): void;
 }
 
 type FloodFillResult = BinaryMaskRect & {
@@ -223,7 +228,7 @@ type FloodFillResult = BinaryMaskRect & {
     pixels: Uint8ClampedArray;
 };
 /**
- * Performs a color-based flood fill selection on {@link ImageData} or {@link PixelData}.
+ * Performs a color-based flood fill selection {@link PixelData}.
  * This utility identifies pixels starting from a specific coordinate that fall within a
  * color tolerance. It can operate in "contiguous" mode (classic bucket fill) or
  * "non-contiguous" mode (selects all matching pixels in the buffer).
@@ -261,51 +266,17 @@ declare function floodFillSelection(target: PixelData, startX: number, startY: n
  */
 declare function forEachLinePoint(x0: number, y0: number, x1: number, y1: number, callback: (x: number, y: number) => void): void;
 
-declare const BaseBlendMode: {
-    readonly overwrite: 0;
-    readonly sourceOver: 1;
-    readonly darken: 2;
-    readonly multiply: 3;
-    readonly colorBurn: 4;
-    readonly linearBurn: 5;
-    readonly darkerColor: 6;
-    readonly lighten: 7;
-    readonly screen: 8;
-    readonly colorDodge: 9;
-    readonly linearDodge: 10;
-    readonly lighterColor: 11;
-    readonly overlay: 12;
-    readonly softLight: 13;
-    readonly hardLight: 14;
-    readonly vividLight: 15;
-    readonly linearLight: 16;
-    readonly pinLight: 17;
-    readonly hardMix: 18;
-    readonly difference: 19;
-    readonly exclusion: 20;
-    readonly subtract: 21;
-    readonly divide: 22;
-};
-interface RequiredBlendModes {
-    overwrite: 0;
-}
-type BaseBlendModes = RequiredBlendModes & Record<string, number>;
-declare const overwriteBase: BlendColor32;
-
-type BlendModeRegistry<BlendModes extends BaseBlendModes = BaseBlendModes, Name extends keyof BlendModes = keyof BlendModes, Index extends BlendModes[Name] = BlendModes[Name]> = ReturnType<typeof makeBlendModeRegistry<BlendModes, Name, Index>>;
-declare function makeBlendModeRegistry<BlendModes extends BaseBlendModes, Name extends keyof BlendModes = keyof BlendModes, Index extends BlendModes[Name] = BlendModes[Name]>(blendModes: BlendModes, initialEntries: Record<Index, BlendColor32>, registryName?: string): {
-    registryName: string;
-    nameToBlend: { [K in keyof BlendModes]: BlendColor32; };
-    nameToIndex: Record<Name, Index>;
-    blendToIndex: Map<BlendColor32, Index>;
-    blendToName: Map<BlendColor32, Name>;
-    indexToBlend: BlendColor32[];
-    indexToName: Name[];
-    indexType: Index;
-    nameType: Name;
-};
+declare function resampleUint32Array<T extends PixelData32, M extends MutablePixelData32>(srcData32: Uint32Array, srcW: number, srcH: number, factor: number, out?: M): T;
 
 declare const overwriteFast: BlendColor32;
+declare const sourceInFast: BlendColor32;
+declare const sourceOutFast: BlendColor32;
+declare const sourceAtopFast: BlendColor32;
+declare const destinationOverFast: BlendColor32;
+declare const destinationInFast: BlendColor32;
+declare const destinationOutFast: BlendColor32;
+declare const destinationAtopFast: BlendColor32;
+declare const xorFast: BlendColor32;
 declare const sourceOverFast: BlendColor32;
 declare const darkenFast: BlendColor32;
 /** (src * dst) / 255 */
@@ -378,17 +349,33 @@ declare function makeFastBlendModeRegistry(name?: string): {
         readonly exclusion: BlendColor32;
         readonly subtract: BlendColor32;
         readonly divide: BlendColor32;
+        readonly sourceIn: BlendColor32;
+        readonly sourceOut: BlendColor32;
+        readonly sourceAtop: BlendColor32;
+        readonly destinationOver: BlendColor32;
+        readonly destinationIn: BlendColor32;
+        readonly destinationOut: BlendColor32;
+        readonly destinationAtop: BlendColor32;
+        readonly xor: BlendColor32;
     };
-    nameToIndex: Record<"overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide", 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
-    blendToIndex: Map<BlendColor32, 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
-    blendToName: Map<BlendColor32, "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide">;
+    nameToIndex: Record<"overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide" | "sourceIn" | "sourceOut" | "sourceAtop" | "destinationOver" | "destinationIn" | "destinationOut" | "destinationAtop" | "xor", 0 | 24 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30>;
+    blendToIndex: Map<BlendColor32, 0 | 24 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30>;
+    blendToName: Map<BlendColor32, "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide" | "sourceIn" | "sourceOut" | "sourceAtop" | "destinationOver" | "destinationIn" | "destinationOut" | "destinationAtop" | "xor">;
     indexToBlend: BlendColor32[];
-    indexToName: ("overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide")[];
-    indexType: 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22;
-    nameType: "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide";
+    indexToName: ("overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide" | "sourceIn" | "sourceOut" | "sourceAtop" | "destinationOver" | "destinationIn" | "destinationOut" | "destinationAtop" | "xor")[];
+    indexType: 0 | 24 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30;
+    nameType: "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide" | "sourceIn" | "sourceOut" | "sourceAtop" | "destinationOver" | "destinationIn" | "destinationOut" | "destinationAtop" | "xor";
 };
 
 declare const overwritePerfect: BlendColor32;
+declare const sourceInPerfect: BlendColor32;
+declare const sourceOutPerfect: BlendColor32;
+declare const sourceAtopPerfect: BlendColor32;
+declare const destinationOverPerfect: BlendColor32;
+declare const destinationInPerfect: BlendColor32;
+declare const destinationOutPerfect: BlendColor32;
+declare const destinationAtopPerfect: BlendColor32;
+declare const xorPerfect: BlendColor32;
 declare const sourceOverPerfect: BlendColor32;
 declare const darkenPerfect: BlendColor32;
 /** (src * dst) / 255 */
@@ -461,14 +448,74 @@ declare function makePerfectBlendModeRegistry(name?: string): {
         readonly exclusion: BlendColor32;
         readonly subtract: BlendColor32;
         readonly divide: BlendColor32;
+        readonly sourceIn: BlendColor32;
+        readonly sourceOut: BlendColor32;
+        readonly sourceAtop: BlendColor32;
+        readonly destinationOver: BlendColor32;
+        readonly destinationIn: BlendColor32;
+        readonly destinationOut: BlendColor32;
+        readonly destinationAtop: BlendColor32;
+        readonly xor: BlendColor32;
     };
-    nameToIndex: Record<"overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide", 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
-    blendToIndex: Map<BlendColor32, 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
-    blendToName: Map<BlendColor32, "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide">;
+    nameToIndex: Record<"overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide" | "sourceIn" | "sourceOut" | "sourceAtop" | "destinationOver" | "destinationIn" | "destinationOut" | "destinationAtop" | "xor", 0 | 24 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30>;
+    blendToIndex: Map<BlendColor32, 0 | 24 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30>;
+    blendToName: Map<BlendColor32, "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide" | "sourceIn" | "sourceOut" | "sourceAtop" | "destinationOver" | "destinationIn" | "destinationOut" | "destinationAtop" | "xor">;
     indexToBlend: BlendColor32[];
-    indexToName: ("overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide")[];
-    indexType: 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22;
-    nameType: "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide";
+    indexToName: ("overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide" | "sourceIn" | "sourceOut" | "sourceAtop" | "destinationOver" | "destinationIn" | "destinationOut" | "destinationAtop" | "xor")[];
+    indexType: 0 | 24 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30;
+    nameType: "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide" | "sourceIn" | "sourceOut" | "sourceAtop" | "destinationOver" | "destinationIn" | "destinationOut" | "destinationAtop" | "xor";
+};
+
+declare const BaseBlendMode: {
+    readonly overwrite: 0;
+    readonly sourceOver: 1;
+    readonly darken: 2;
+    readonly multiply: 3;
+    readonly colorBurn: 4;
+    readonly linearBurn: 5;
+    readonly darkerColor: 6;
+    readonly lighten: 7;
+    readonly screen: 8;
+    readonly colorDodge: 9;
+    readonly linearDodge: 10;
+    readonly lighterColor: 11;
+    readonly overlay: 12;
+    readonly softLight: 13;
+    readonly hardLight: 14;
+    readonly vividLight: 15;
+    readonly linearLight: 16;
+    readonly pinLight: 17;
+    readonly hardMix: 18;
+    readonly difference: 19;
+    readonly exclusion: 20;
+    readonly subtract: 21;
+    readonly divide: 22;
+    readonly sourceIn: 23;
+    readonly sourceOut: 24;
+    readonly sourceAtop: 25;
+    readonly destinationOver: 26;
+    readonly destinationIn: 27;
+    readonly destinationOut: 28;
+    readonly destinationAtop: 29;
+    readonly xor: 30;
+};
+interface RequiredBlendModes {
+    overwrite: 0;
+}
+type BaseBlendModes = RequiredBlendModes & Record<string, number>;
+declare const overwriteBase: BlendColor32;
+
+type BlendModeRegistry<BlendModes extends BaseBlendModes = BaseBlendModes, Name extends keyof BlendModes = keyof BlendModes, Index extends BlendModes[Name] = BlendModes[Name]> = ReturnType<typeof makeBlendModeRegistry<BlendModes, Name, Index>>;
+declare function makeBlendModeRegistry<BlendModes extends BaseBlendModes, Name extends keyof BlendModes = keyof BlendModes, Index extends BlendModes[Name] = BlendModes[Name]>(blendModes: BlendModes, initialEntries: Record<Index, BlendColor32>, registryName?: string): {
+    registryName: string;
+    nameToBlend: { [K in keyof BlendModes]: BlendColor32; };
+    nameToIndex: Record<Name, Index>;
+    blendToIndex: Map<BlendColor32, Index>;
+    blendToName: Map<BlendColor32, Name>;
+    indexToBlend: BlendColor32[];
+    indexToName: Name[];
+    indexType: Index;
+    nameType: Name;
 };
 
 declare function toBlendModeIndexAndName(input: string | number): {
@@ -476,56 +523,23 @@ declare function toBlendModeIndexAndName(input: string | number): {
     blendName: string;
 };
 
-type PixelCanvas = {
-    readonly canvas: HTMLCanvasElement;
-    readonly ctx: CanvasRenderingContext2D;
-    readonly resize: (w: number, h: number) => void;
-};
-/**
- * Ensures the canvas ctx is always set to imageSmoothingEnabled = false.
- * Intended for canvas elements that are already part of the DOM.
- * @see makeReusableCanvas
- * @throws {Error} If the {@link HTMLCanvasElement} context cannot be initialized.
- */
-declare function makePixelCanvas(canvas: HTMLCanvasElement): PixelCanvas;
-
 type CanvasContext<T> = T extends HTMLCanvasElement ? CanvasRenderingContext2D : OffscreenCanvasRenderingContext2D;
-type ReusableCanvas<T extends HTMLCanvasElement | OffscreenCanvas> = {
+interface ReusableCanvas<T extends HTMLCanvasElement | OffscreenCanvas> {
     readonly canvas: T;
     readonly ctx: CanvasContext<T>;
-};
-/**
- * Creates a reusable HTMLCanvasElement and context that are not part of the DOM.
- * Ensures it is always set to `context.imageSmoothingEnabled = false`
- * @see makePixelCanvas
- * @throws {Error} If the {@link HTMLCanvasElement} context cannot be initialized.
- */
-declare function makeReusableCanvas(): {
-    (width: number, height: number): ReusableCanvas<HTMLCanvasElement>;
-    reset(): void;
-};
-/**
- * Creates a reusable OffscreenCanvas and context.
- * Ensures it is always set to `context.imageSmoothingEnabled = false`
- * @see makePixelCanvas
- * @throws {Error} If the {@link OffscreenCanvasRenderingContext2D} context cannot be initialized.
- */
-declare function makeReusableOffscreenCanvas(): {
-    (width: number, height: number): ReusableCanvas<OffscreenCanvas>;
+}
+type ReusableCanvasFactory<T extends HTMLCanvasElement | OffscreenCanvas> = {
+    (w: number, h: number): ReusableCanvas<T>;
     reset(): void;
 };
-
-type DrawPixelLayer = (ctx: CanvasRenderingContext2D) => void;
+type DrawPixelLayer<T extends HTMLCanvasElement | OffscreenCanvas> = (ctx: CanvasContext<T>) => void;
 type DrawScreenLayer = (ctx: CanvasRenderingContext2D, scale: number) => void;
-type CanvasFrameRenderer = ReturnType<typeof makeCanvasFrameRenderer>;
-declare const defaults$h: {
-    makeReusableCanvas: typeof makeReusableCanvas;
-};
-type Deps$h = Partial<typeof defaults$h>;
-/**
- * @param deps - @hidden
- */
-declare function makeCanvasFrameRenderer(deps?: Deps$h): (pixelCanvas: PixelCanvas, scale: number, getImageData: () => ImageData | undefined | null, drawPixelLayer?: DrawPixelLayer, drawScreenLayer?: DrawScreenLayer) => void;
+interface PixelCanvas {
+    readonly canvas: HTMLCanvasElement;
+    readonly ctx: CanvasRenderingContext2D;
+    readonly resize: (w: number, h: number) => void;
+}
+type CanvasObjectFactory<T extends HTMLCanvasElement | OffscreenCanvas> = (w: number, h: number) => T;
 
 declare const CANVAS_COMPOSITE_MAP: {
     readonly 0: "copy";
@@ -546,6 +560,35 @@ declare const CANVAS_COMPOSITE_MAP: {
 type CanvasBlendModeIndex = keyof typeof CANVAS_COMPOSITE_MAP;
 type CanvasCompositeOperation = typeof CANVAS_COMPOSITE_MAP[CanvasBlendModeIndex];
 
+type CanvasFrameRenderer<T extends HTMLCanvasElement | OffscreenCanvas = OffscreenCanvas> = ReturnType<typeof makeCanvasFrameRenderer<T>>;
+declare function makeCanvasFrameRenderer<T extends HTMLCanvasElement | OffscreenCanvas = OffscreenCanvas>(reusableCanvasFactory?: () => ReusableCanvasFactory<T>): (pixelCanvas: PixelCanvas, scale: number, getImageData: () => ImageData | undefined | null, drawPixelLayer?: DrawPixelLayer<T>, drawScreenLayer?: DrawScreenLayer) => void;
+
+type CanvasPixelDataRenderer = ReturnType<typeof makeCanvasPixelDataRenderer>;
+declare function makeCanvasPixelDataRenderer<T extends HTMLCanvasElement | OffscreenCanvas = OffscreenCanvas>(reusableCanvasFactory?: () => ReusableCanvasFactory<T>): (targetCtx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, pixelData: PixelData, x?: number, y?: number) => void;
+
+/**
+ * Ensures the canvas ctx is always set to imageSmoothingEnabled = false.
+ * Intended for canvas elements that are already part of the DOM.
+ * @see makeReusableCanvas
+ * @throws {Error} If the {@link HTMLCanvasElement} context cannot be initialized.
+ */
+declare function makePixelCanvas(canvas: HTMLCanvasElement): PixelCanvas;
+
+/**
+ * Creates a reusable HTMLCanvasElement and context that are not part of the DOM.
+ * Ensures it is always set to `context.imageSmoothingEnabled = false`
+ * @see makePixelCanvas
+ * @throws {Error} If the {@link HTMLCanvasElement} context cannot be initialized.
+ */
+declare function makeReusableCanvas(): ReusableCanvasFactory<HTMLCanvasElement>;
+/**
+ * Creates a reusable OffscreenCanvas and context.
+ * Ensures it is always set to `context.imageSmoothingEnabled = false`
+ * @see makePixelCanvas
+ * @throws {Error} If the {@link OffscreenCanvasRenderingContext2D} context cannot be initialized.
+ */
+declare function makeReusableOffscreenCanvas(): ReusableCanvasFactory<OffscreenCanvas>;
+
 /**
  * Extracts {@link ImageData} from a clipboard event if an image is present.
  *
@@ -589,23 +632,72 @@ declare function getImageDataFromClipboard(clipboardEvent: ClipboardEvent): Prom
 declare function writeImageDataToClipboard(imageData: ImageData): Promise<void>;
 
 /**
- * Writes a {@link Blob} image to the system clipboard.
- *
- * @param blob - The image blob (typically `image/png`) to copy.
- * @returns A promise that resolves when the clipboard has been updated.
+ * Writes a {@link Blob} image to the system clipboard.
+ *
+ * @param blob - The image blob (typically `image/png`) to copy.
+ * @returns A promise that resolves when the clipboard has been updated.
+ */
+declare function writeImgBlobToClipboard(blob: Blob): Promise<void>;
+
+/**
+ * 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 writeImgBlobToClipboard(blob: Blob): Promise<void>;
+declare function color32ToCssRGBA(color: Color32): string;
 
-declare class PixelTile implements IPixelData {
+declare const enum TileType {
+    PIXEL = 0,
+    MASK = 1
+}
+interface BaseTile {
+    tileType: TileType;
     id: number;
     tx: number;
     ty: number;
-    readonly data32: Uint32Array;
-    readonly width: number;
-    readonly height: number;
-    readonly imageData: ImageData;
-    constructor(id: number, tx: number, ty: number, tileSize: number, tileArea: number);
 }
+interface PixelTile extends PixelData, BaseTile {
+}
+interface AlphaMaskTile extends AlphaMask, BaseTile {
+}
+interface BinaryMaskTile extends BinaryMask, BaseTile {
+}
+type Tile = PixelTile | AlphaMaskTile | BinaryMaskTile;
+type TileFactory<T extends Tile> = (id: number, tx: number, ty: number, tileSize: number, tileArea: number) => T;
 
 declare class PixelEngineConfig {
     readonly tileSize: number;
@@ -618,29 +710,30 @@ declare class PixelEngineConfig {
     constructor(tileSize: number, target: PixelData);
 }
 
-declare class PixelTilePool {
-    pool: PixelTile[];
+declare class TilePool<T extends Tile> {
+    private tileFactory;
+    pool: T[];
     private tileSize;
     private tileArea;
-    constructor(config: PixelEngineConfig);
-    getTile(id: number, tx: number, ty: number): PixelTile;
-    releaseTile(tile: PixelTile): void;
-    releaseTiles(tiles: (PixelTile | undefined)[]): void;
+    constructor(config: PixelEngineConfig, tileFactory: TileFactory<T>);
+    getTile(id: number, tx: number, ty: number): T;
+    releaseTile(tile: T): void;
+    releaseTiles(tiles: (T | undefined)[]): void;
 }
 
 type PixelPatchTiles = {
     beforeTiles: PixelTile[];
     afterTiles: PixelTile[];
 };
-declare function applyPatchTiles(target: IPixelData32, tiles: PixelTile[], tileSize: number): void;
+declare function applyPatchTiles(target: PixelData32, tiles: PixelTile[], tileSize: number): void;
 
 type DidChangeFn = (didChange: boolean) => boolean;
 declare class PixelAccumulator {
     readonly config: PixelEngineConfig;
-    readonly tilePool: PixelTilePool;
+    readonly pixelTilePool: TilePool<PixelTile>;
     lookup: (PixelTile | undefined)[];
     beforeTiles: PixelTile[];
-    constructor(config: PixelEngineConfig, tilePool: PixelTilePool);
+    constructor(config: PixelEngineConfig, pixelTilePool: TilePool<PixelTile>);
     recyclePatch(patch: PixelPatchTiles): void;
     /**
      * @param x pixel x coordinate
@@ -715,41 +808,12 @@ declare class HistoryManager {
  */
 declare function resizeImageData(target: ImageDataLike, newWidth: number, newHeight: number, offsetX?: number, offsetY?: number): ImageData;
 
-declare class PaintBuffer {
-    readonly config: PixelEngineConfig;
-    readonly tilePool: PixelTilePool;
-    readonly lookup: (PixelTile | undefined)[];
-    private readonly scratchBounds;
-    constructor(config: PixelEngineConfig, tilePool: PixelTilePool);
-    private eachTileInBounds;
-    writePaintAlphaMaskStroke(color: Color32, brush: PaintAlphaMask, x0: number, y0: number, x1: number, y1: number): boolean;
-    writePaintBinaryMaskStroke(color: Color32, brush: PaintBinaryMask, x0: number, y0: number, x1: number, y1: number): boolean;
-    writeRectStroke(color: Color32, brushWidth: number, brushHeight: number, x0: number, y0: number, x1: number, y1: number): boolean;
-    clear(): void;
-}
-
-/**
- * Blits source PixelData into a destination PixelData using 32-bit integer bitwise blending.
- * This function bypasses standard ImageData 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
- *
- * const dst = new PixelData(ctx.getImageData(0,0,100,100))
- * blendImageData32(dst, sprite, {
- *   blendFn: COLOR_32_BLEND_MODES.multiply,
- *   mask: brushMask,
- *   maskType: MaskType.ALPHA
- * });
- */
-declare function blendPixelData(target: IPixelData32, src: IPixelData32, opts?: PixelBlendOptions): boolean;
-
 interface PixelWriterOptions {
     maxHistorySteps?: number;
     tileSize?: number;
     historyManager?: HistoryManager;
     historyActionFactory?: HistoryActionFactory;
-    pixelTilePool?: PixelTilePool;
+    pixelTilePool?: TilePool<PixelTile>;
     accumulator?: PixelAccumulator;
 }
 /**
@@ -778,10 +842,8 @@ declare class PixelWriter<M> {
     readonly accumulator: PixelAccumulator;
     readonly historyActionFactory: HistoryActionFactory;
     readonly config: PixelEngineConfig;
-    readonly pixelTilePool: PixelTilePool;
-    readonly paintBuffer: PaintBuffer;
+    readonly pixelTilePool: TilePool<PixelTile>;
     readonly mutator: M;
-    private blendPixelDataOpts;
     private _inProgress;
     constructor(target: PixelData, mutatorFactory: (writer: PixelWriter<any>) => M, options?: PixelWriterOptions);
     /**
@@ -801,7 +863,6 @@ declare class PixelWriter<M> {
      */
     withHistory(transaction: (mutator: M) => void, after?: () => void, afterUndo?: () => void, afterRedo?: () => void): void;
     resize(newWidth: number, newHeight: number, offsetX?: number, offsetY?: number, after?: (target: ImageData) => void, afterUndo?: (target: ImageData) => void, afterRedo?: (target: ImageData) => void, resizeImageDataFn?: typeof resizeImageData): void;
-    commitPaintBuffer(alpha?: number, blendFn?: BlendColor32, blendPixelDataFn?: typeof blendPixelData): void;
 }
 type HistoryMutator<T extends {}, D extends {}> = (writer: PixelWriter<any>, deps?: Partial<D>) => T;
 
@@ -811,16 +872,16 @@ declare function makeFullPixelMutator(writer: PixelWriter<any>): {
     fillBinaryMask(color: Color32, mask: BinaryMask, x?: number, y?: number): boolean;
     fill(color: Color32, x?: number, y?: number, w?: number, h?: number): boolean;
     clear(rect?: Partial<Rect>): boolean;
-    blendPixelData(src: IPixelData32, opts?: PixelBlendOptions): boolean;
+    blendPixelData(src: PixelData32, opts?: PixelBlendOptions): boolean;
     blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
-    blendMask(src: IPixelData32, mask: Mask, opts?: PixelBlendMaskOptions): boolean;
+    blendMask(src: PixelData32, mask: Mask, opts?: PixelBlendMaskOptions): boolean;
     blendColorPaintRect(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): boolean;
     blendColorPaintMask(color: Color32, mask: PaintMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
     blendColorPaintBinaryMask(color: Color32, mask: PaintBinaryMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
     blendColorPaintAlphaMask(color: Color32, mask: PaintAlphaMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
     blendColor(color: Color32, opts?: ColorBlendOptions): boolean;
-    blendBinaryMask(src: IPixelData32, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
-    blendAlphaMask(src: IPixelData32, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+    blendBinaryMask(src: PixelData32, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
+    blendAlphaMask(src: PixelData32, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
     applyMask(mask: Mask, opts?: ApplyMaskToPixelDataOptions): boolean;
     applyBinaryMask(mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
     applyAlphaMask(mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
@@ -831,7 +892,7 @@ declare function makeFullPixelMutator(writer: PixelWriter<any>): {
  * modifying the destination's alpha channel in-place.
  * @returns true if any pixels were actually modified.
  */
-declare function applyAlphaMaskToPixelData(target: IPixelData32, mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
+declare function applyAlphaMaskToPixelData(target: PixelData32, mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 
 declare const defaults$g: {
     applyAlphaMaskToPixelData: typeof applyAlphaMaskToPixelData;
@@ -849,7 +910,7 @@ declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$g) =
  * modifying the destination's alpha channel in-place.
  * @returns true if any pixels were actually modified.
  */
-declare function applyBinaryMaskToPixelData(target: IPixelData32, mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
+declare function applyBinaryMaskToPixelData(target: PixelData32, mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 
 declare const defaults$f: {
     applyBinaryMaskToPixelData: typeof applyBinaryMaskToPixelData;
@@ -874,7 +935,7 @@ declare const mutatorApplyMask: (writer: PixelWriter<any>, deps?: Deps$e) => {
     applyMask(mask: Mask, opts?: ApplyMaskToPixelDataOptions): boolean;
 };
 
-declare function blendPixelDataAlphaMask(target: IPixelData32, src: IPixelData32, alphaMask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+declare function blendPixelDataAlphaMask(target: PixelData32, src: PixelData32, alphaMask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
 
 declare const defaults$d: {
     blendPixelDataAlphaMask: typeof blendPixelDataAlphaMask;
@@ -884,10 +945,10 @@ type Deps$d = Partial<typeof defaults$d>;
  * @param deps - @hidden
  */
 declare const mutatorBlendAlphaMask: (writer: PixelWriter<any>, deps?: Partial<Deps$d>) => {
-    blendAlphaMask(src: IPixelData32, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+    blendAlphaMask(src: PixelData32, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
 };
 
-declare function blendPixelDataBinaryMask(target: IPixelData32, src: IPixelData32, binaryMask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
+declare function blendPixelDataBinaryMask(target: PixelData32, src: PixelData32, binaryMask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
 
 declare const defaults$c: {
     blendPixelDataBinaryMask: typeof blendPixelDataBinaryMask;
@@ -897,14 +958,14 @@ type Deps$c = Partial<typeof defaults$c>;
  * @param deps - @hidden
  */
 declare const mutatorBlendBinaryMask: (writer: PixelWriter<any>, deps?: Partial<Deps$c>) => {
-    blendBinaryMask(src: IPixelData32, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
+    blendBinaryMask(src: PixelData32, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
 };
 
 /**
  * Blends a solid color into a target pixel buffer.
  * @returns true if any pixels were actually modified.
  */
-declare function blendColorPixelData(target: IPixelData32, color: Color32, opts?: ColorBlendOptions): boolean;
+declare function blendColorPixelData(target: PixelData32, color: Color32, opts?: ColorBlendOptions): boolean;
 
 declare const defaults$b: {
     blendColorPixelData: typeof blendColorPixelData;
@@ -917,6 +978,22 @@ declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$b) => {
     blendColor(color: Color32, opts?: ColorBlendOptions): boolean;
 };
 
+declare enum PaintMaskOutline {
+    MASKED = 0,
+    CIRCLE = 1,
+    RECT = 2
+}
+interface BasePaintMask<T extends PaintMaskOutline = PaintMaskOutline> {
+    readonly outlineType: T;
+    readonly centerOffsetX: number;
+    readonly centerOffsetY: number;
+}
+interface PaintAlphaMask<T extends PaintMaskOutline = PaintMaskOutline> extends BasePaintMask<T>, AlphaMask {
+}
+interface PaintBinaryMask<T extends PaintMaskOutline = PaintMaskOutline> extends BasePaintMask<T>, BinaryMask {
+}
+type PaintMask = PaintAlphaMask<any> | PaintBinaryMask<any>;
+
 /**
  * Blends a solid color into a target pixel buffer using an alpha mask.
  *
@@ -924,13 +1001,13 @@ declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$b) => {
  * If the width (`w`) or height (`h`) are omitted from the options, they will safely
  * default to the dimensions of the provided mask to prevent out-of-bounds memory access.
  *
- * @param target - The destination {@link IPixelData32} buffer to modify.
+ * @param target - The destination {@link PixelData32} buffer to modify.
  * @param color - The solid color to apply.
  * @param mask - The mask defining the per-pixel opacity of the target area.
  * @param opts - Configuration options including placement coordinates, bounds, global alpha, and mask offsets.
  * @returns true if any pixels were actually modified.
  */
-declare function blendColorPixelDataAlphaMask(target: IPixelData32, color: Color32, mask: AlphaMask, opts?: ColorBlendMaskOptions): boolean;
+declare function blendColorPixelDataAlphaMask(target: PixelData32, color: Color32, mask: AlphaMask, opts?: ColorBlendMaskOptions): boolean;
 
 declare const defaults$a: {
     blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
@@ -950,13 +1027,13 @@ declare const mutatorBlendColorPaintAlphaMask: (writer: PixelWriter<any>, deps?:
  * If the width (`w`) or height (`h`) are omitted from the options, they will safely
  * default to the dimensions of the provided mask to prevent out-of-bounds memory access.
  *
- * @param target - The destination {@link IPixelData32} buffer to modify.
+ * @param target - The destination {@link PixelData32} buffer to modify.
  * @param color - The solid color to apply.
  * @param mask - The mask defining the per-pixel opacity of the target area.
  * @param opts - Configuration options including placement coordinates, bounds, global alpha, and mask offsets.
  * @returns true if any pixels were actually modified.
  */
-declare function blendColorPixelDataBinaryMask(target: IPixelData32, color: Color32, mask: BinaryMask, opts?: ColorBlendMaskOptions): boolean;
+declare function blendColorPixelDataBinaryMask(target: PixelData32, color: Color32, mask: BinaryMask, opts?: ColorBlendMaskOptions): boolean;
 
 declare const defaults$9: {
     blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
@@ -1001,10 +1078,10 @@ type Deps$6 = Partial<typeof defaults$6>;
  * @param deps - @hidden
  */
 declare const mutatorBlendMask: (writer: PixelWriter<any>, deps?: Partial<Deps$6>) => {
-    blendMask(src: IPixelData32, mask: Mask, opts?: PixelBlendMaskOptions): boolean;
+    blendMask(src: PixelData32, mask: Mask, opts?: PixelBlendMaskOptions): boolean;
 };
 
-declare function blendPixel(target: IPixelData32, x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
+declare function blendPixel(target: PixelData32, x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
 
 declare const defaults$5: {
     blendPixel: typeof blendPixel;
@@ -1017,6 +1094,22 @@ declare const mutatorBlendPixel: (writer: PixelWriter<any>, deps?: Partial<Deps$
     blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
 };
 
+/**
+ * Blits source PixelData into a destination PixelData using 32-bit integer bitwise blending.
+ * This function bypasses standard ImageData 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
+ *
+ * const dst = new PixelData(ctx.getImageData(0,0,100,100))
+ * blendImageData32(dst, sprite, {
+ *   blendFn: COLOR_32_BLEND_MODES.multiply,
+ *   mask: brushMask,
+ *   maskType: MaskType.ALPHA
+ * });
+ */
+declare function blendPixelData(target: PixelData32, src: PixelData32, opts?: PixelBlendOptions): boolean;
+
 declare const defaults$4: {
     blendPixelData: typeof blendPixelData;
 };
@@ -1025,18 +1118,18 @@ type Deps$4 = Partial<typeof defaults$4>;
  * @param deps - @hidden
  */
 declare const mutatorBlendPixelData: (writer: PixelWriter<any>, deps?: Partial<Deps$4>) => {
-    blendPixelData(src: IPixelData32, opts?: PixelBlendOptions): boolean;
+    blendPixelData(src: PixelData32, opts?: PixelBlendOptions): boolean;
 };
 
 /**
- * Fills a region or the {@link IPixelData32} buffer with a solid color.
+ * Fills a region or the {@link PixelData32} buffer with a solid color.
  *
  * @param dst - The target to modify.
  * @param color - The color to apply.
  * @param rect - Defines the area to fill. If omitted, the entire
  * @returns true if any pixels were actually modified.
  */
-declare function fillPixelData(dst: IPixelData32, color: Color32, rect?: Partial<Rect>): boolean;
+declare function fillPixelData(dst: PixelData32, color: Color32, rect?: Partial<Rect>): boolean;
 /**
  * @param dst - The target to modify.
  * @param color - The color to apply.
@@ -1045,7 +1138,7 @@ declare function fillPixelData(dst: IPixelData32, color: Color32, rect?: Partial
  * @param w - Width of the fill area.
  * @param h - Height of the fill area.
  */
-declare function fillPixelData(dst: IPixelData32, color: Color32, x: number, y: number, w: number, h: number): boolean;
+declare function fillPixelData(dst: PixelData32, color: Color32, x: number, y: number, w: number, h: number): boolean;
 
 declare const defaults$3: {
     fillPixelData: typeof fillPixelData;
@@ -1076,14 +1169,14 @@ declare const mutatorFillRect: (writer: PixelWriter<any>, deps?: Deps$2) => {
 };
 
 /**
- * Fills a region of the {@link IPixelData32} buffer with a solid color using a mask.
+ * Fills a region of the {@link PixelData32} buffer with a solid color using a mask.
  * @param target - The target to modify.
  * @param color - The color to apply.
  * @param mask - The mask defining the area to fill.
  * @param x - Starting horizontal coordinate for the mask placement.
  * @param y - Starting vertical coordinate for the mask placement.
  */
-declare function fillPixelDataBinaryMask(target: IPixelData32, color: Color32, mask: BinaryMask, x?: number, y?: number): boolean;
+declare function fillPixelDataBinaryMask(target: PixelData32, color: Color32, mask: BinaryMask, x?: number, y?: number): boolean;
 
 declare const defaults$1: {
     fillPixelDataBinaryMask: typeof fillPixelDataBinaryMask;
@@ -1096,7 +1189,7 @@ declare const mutatorFillBinaryMask: (writer: PixelWriter<any>, deps?: Deps$1) =
     fillBinaryMask(color: Color32, mask: BinaryMask, x?: number, y?: number): boolean;
 };
 
-declare function invertPixelData(target: IPixelData32, opts?: PixelMutateOptions): boolean;
+declare function invertPixelData(target: PixelData32, opts?: PixelMutateOptions): boolean;
 
 declare const defaults: {
     invertPixelData: typeof invertPixelData;
@@ -1109,17 +1202,6 @@ declare const mutatorInvert: (writer: PixelWriter<any>, deps?: Deps) => {
     invert(opts?: PixelMutateOptions): boolean;
 };
 
-declare function makeImageDataLike(width: number, height: number, data?: Buffer): ImageDataLike;
-
-type ReusableImageData = ReturnType<typeof makeReusableImageData>;
-/**
- * Creates a factory function that manages a single, reusable ImageData instance.
- * This is used to minimize garbage collection overhead by recycling the
- * underlying pixel buffer across multiple operations.
- * @returns A function that takes width and height and returns a pooled ImageData instance.
- */
-declare function makeReusableImageData(): (width: number, height: number) => ImageData;
-
 declare function copyImageData({ data, width, height }: ImageDataLike): ImageData;
 declare function copyImageDataLike({ data, width, height }: ImageDataLike): ImageDataLike;
 
@@ -1144,6 +1226,8 @@ declare function extractImageDataBuffer(imageData: ImageDataLike, rect: Rect): U
  */
 declare function extractImageDataBuffer(imageData: ImageDataLike, x: number, y: number, w: number, h: number): Uint8ClampedArray;
 
+declare function makeImageDataLike(width: number, height: number, data?: Buffer): ImageDataLike;
+
 /**
  * Extracts the alpha channel from raw ImageData into an AlphaMask.
  * When possible use {@link pixelDataToAlphaMask} instead.
@@ -1197,7 +1281,8 @@ declare function imageDataToImgBlob(imageData: ImageData): Promise<Blob>;
 /**
  * converts {@link ImageData} to a faster Uint32Array
  */
-declare function imageDataToUInt32Array(imageData: ImageDataLike): Uint32Array;
+declare function imageDataToUint32Array(imageData: ImageDataLike): Uint32Array;
+declare function _macro_imageDataToUint32Array(imageData: ImageDataLike): Uint32Array;
 
 /**
  * Decodes a {@link Blob} (typically PNG) back into an {@link ImageData} object.
@@ -1230,6 +1315,15 @@ declare function invertImageData(imageData: ImageData): ImageData;
  */
 declare function resampleImageData(source: ImageData, factor: number): ImageData;
 
+type ReusableImageData = ReturnType<typeof makeReusableImageData>;
+/**
+ * Creates a factory function that manages a single, reusable ImageData instance.
+ * This is used to minimize garbage collection overhead by recycling the
+ * underlying pixel buffer across multiple operations.
+ * @returns A function that takes width and height and returns a pooled ImageData instance.
+ */
+declare function makeReusableImageData(): (width: number, height: number) => ImageData;
+
 declare function base64EncodeArrayBuffer(buffer: ArrayBufferLike): Base64EncodedUInt8Array;
 declare function base64DecodeArrayBuffer(encoded: Base64EncodedUInt8Array): Uint8ClampedArray<ArrayBuffer>;
 /**
@@ -1288,47 +1382,17 @@ declare function writeImageDataBuffer(target: ImageData, data: Uint8ClampedArray
  * into a color palette. This format is optimized for memory efficiency and
  * high-speed pattern matching or recoloring operations.
  */
-declare class IndexedImage {
+interface IndexedImage {
     /** The width of the image in pixels. */
-    readonly width: number;
+    readonly w: number;
     /** The height of the image in pixels. */
-    readonly height: number;
+    readonly h: number;
     /** Flat array of palette indices. Index = x + (y * width). */
-    readonly data: Int32Array;
+    readonly data: Uint32Array;
     /** The palette of unique 32-bit colors (ABGR/RGBA packed) found in the image. */
     readonly palette: Uint32Array;
     /** The specific index in the palette reserved for fully transparent pixels. */
     readonly transparentPalletIndex: number;
-    /**
-     * @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: number, height: number, data: Int32Array, palette: Uint32Array, transparentPalletIndex: number);
-    /**
-     * Creates an IndexedImage from standard browser ImageData.
-     * @param imageData - The source ImageData to convert.
-     * @returns A new IndexedImage instance.
-     */
-    static fromImageData(imageData: ImageData): IndexedImage;
-    /**
-     * 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: Uint8ClampedArray, width: number, height: number): IndexedImage;
-    /**
-     * 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: number, y: number): Color32;
 }
 
 /**
@@ -1337,7 +1401,12 @@ declare class IndexedImage {
  * @param indexedImage - The source image containing data and palette definitions.
  * @returns A typed array where each entry represents the total count of that palette index.
  */
-declare function getIndexedImageColorCounts(indexedImage: IndexedImage): Int32Array;
+declare function getIndexedImageColorCounts(indexedImage: IndexedImage): Uint32Array;
+
+declare function makeIndexedImage(width: number, height: number, data: Uint32Array, palette: Uint32Array, transparentPalletIndex: number): IndexedImage;
+declare function makeIndexedImageFromImageDataRaw(data: Uint8ClampedArray, width: number, height: number): IndexedImage;
+declare function makeIndexedImageFromImageData(imageData: ImageData): IndexedImage;
+declare function getIndexedImageColor(target: IndexedImage, x: number, y: number): Color32;
 
 /**
  * Calculates the area-weighted average color of an IndexedImage.
@@ -1353,11 +1422,6 @@ declare function indexedImageToAverageColor(indexedImage: IndexedImage, includeT
  */
 declare function indexedImageToImageData(indexedImage: IndexedImage): ImageData;
 
-/**
- * Resamples an IndexedImage by a specific factor using nearest neighbor
- * Factor > 1 upscales, Factor < 1 downscales.
- */
-
 /**
  * Resamples an IndexedImage by a specific factor using nearest neighbor
  * Factor > 1 upscales, Factor < 1 downscales.
@@ -1451,49 +1515,6 @@ declare function fileToImageData(file: File | null | undefined): Promise<ImageDa
  */
 declare function getSupportedPixelFormats(rasterMimes?: string[]): Promise<string[]>;
 
-/**
- *  @internal
- */
-type Resample32Result = {
-    data: Int32Array;
-    width: number;
-    height: number;
-};
-/**
- *  @internal
- */
-declare function resample32(srcData32: Uint32Array | Int32Array, srcW: number, srcH: number, factor: number): Resample32Result;
-
-type ClippedRect = {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-    inBounds: boolean;
-};
-type ClippedBlit = {
-    x: number;
-    y: number;
-    sx: number;
-    sy: number;
-    w: number;
-    h: number;
-    inBounds: boolean;
-};
-declare const makeClippedRect: () => ClippedRect;
-declare const makeClippedBlit: () => ClippedBlit;
-/**
- * Calculates the intersection of a target rectangle and a bounding box (usually 0,0 -> width,height).
- * Handles negative offsets by shrinking dimensions.
- */
-declare function resolveRectClipping(x: number, y: number, w: number, h: number, boundaryW: number, boundaryH: number, out: ClippedRect): ClippedRect;
-/**
- * Calculates the clipping for transferring data from a Source to a Destination.
- * Handles cases where the source is out of bounds (shifting the destination target)
- * AND cases where the destination is out of bounds (shifting the source target).
- */
-declare function resolveBlitClipping(x: number, y: number, sx: number, sy: number, w: number, h: number, dstW: number, dstH: number, srcW: number, srcH: number, out: ClippedBlit): ClippedBlit;
-
 /**
  * Creates an Alpha Mask
  * @param w - width
@@ -1502,6 +1523,8 @@ declare function resolveBlitClipping(x: number, y: number, sx: number, sy: numbe
  */
 declare function makeAlphaMask(w: number, h: number, data?: Uint8Array): AlphaMask;
 
+declare function applyBinaryMaskToAlphaMask(alphaMaskDst: AlphaMask, binaryMaskSrc: BinaryMask, opts?: ApplyMaskToPixelDataOptions): void;
+
 /**
  * Creates a Binary Mask
  * @param w - width
@@ -1510,7 +1533,13 @@ declare function makeAlphaMask(w: number, h: number, data?: Uint8Array): AlphaMa
  */
 declare function makeBinaryMask(w: number, h: number, data?: Uint8Array): BinaryMask;
 
-declare function applyBinaryMaskToAlphaMask(alphaMaskDst: AlphaMask, binaryMaskSrc: BinaryMask, opts?: ApplyMaskToPixelDataOptions): void;
+declare function makeBinaryMaskFromAlphaMask(mask: AlphaMask, threshold: number, out?: MutableBinaryMask): BinaryMask;
+
+declare function makeBinaryMaskOutline(mask: BinaryMask, scale?: number): BinaryMask;
+
+declare function makeCircleBinaryMaskOutline(size: number, scale: number): BinaryMask;
+
+declare function makeRectBinaryMaskOutline(w: number, h: number, scale?: number): BinaryMask;
 
 /**
  * Creates a new copy of a mask.
@@ -1584,18 +1613,90 @@ declare function mergeBinaryMaskRects(current: NullableBinaryMaskRect[], adding:
 
 declare function subtractBinaryMaskRects(current: NullableBinaryMaskRect[], subtracting: NullableBinaryMaskRect[]): NullableBinaryMaskRect[];
 
-type PaintBufferCanvasRenderer = ReturnType<typeof makePaintBufferCanvasRenderer>;
+declare class AlphaMaskPaintBuffer {
+    readonly config: PixelEngineConfig;
+    readonly tilePool: TilePool<AlphaMaskTile>;
+    readonly lookup: (AlphaMaskTile | undefined)[];
+    private readonly scratchBounds;
+    private blendColorPixelDataAlphaMaskFn;
+    private forEachLinePointFn;
+    private trimRectBoundsFn;
+    private eachTileInBoundsFn;
+    constructor(config: PixelEngineConfig, tilePool: TilePool<AlphaMaskTile>);
+    paintAlphaMask(brush: PaintAlphaMask, x: number, y: number): boolean;
+    paintAlphaMask(brush: PaintAlphaMask, startX: number, startY: number, endX: number, endY: number): boolean;
+    paintBinaryMask(brush: PaintBinaryMask, alpha: number, x: number, y: number): boolean;
+    paintBinaryMask(brush: PaintBinaryMask, alpha: number, startX: number, startY: number, endX: number, endY: number): boolean;
+    paintRect(alpha: number, brushWidth: number, brushHeight: number, x: number, y: number): boolean;
+    paintRect(alpha: number, brushWidth: number, brushHeight: number, startX: number, startY: number, endX: number, endY: number): boolean;
+    private opts;
+    commit(accumulator: PixelAccumulator, color: Color32, alpha?: number, blendFn?: BlendColor32): void;
+    clear(): void;
+}
+
+type AlphaMaskPaintBufferCanvasRenderer = ReturnType<typeof makeAlphaMaskPaintBufferCanvasRenderer>;
+declare function makeAlphaMaskPaintBufferCanvasRenderer(paintBuffer: AlphaMaskPaintBuffer, offscreenCanvasClass?: {
+    new (width: number, height: number): OffscreenCanvas;
+    prototype: OffscreenCanvas;
+}): (targetCtx: CanvasRenderingContext2D, color: Color32, alpha?: number, compOperation?: GlobalCompositeOperation) => void;
+
+declare class BinaryMaskPaintBuffer {
+    readonly config: PixelEngineConfig;
+    readonly tilePool: TilePool<BinaryMaskTile>;
+    readonly lookup: (BinaryMaskTile | undefined)[];
+    private readonly scratchBounds;
+    private blendColorPixelDataBinaryMaskFn;
+    private forEachLinePointFn;
+    private trimRectBoundsFn;
+    private eachTileInBoundsFn;
+    constructor(config: PixelEngineConfig, tilePool: TilePool<BinaryMaskTile>);
+    paintBinaryMask(brush: PaintBinaryMask, x: number, y: number): boolean;
+    paintBinaryMask(brush: PaintBinaryMask, startX: number, startY: number, endX: number, endY: number): boolean;
+    paintRect(brushWidth: number, brushHeight: number, x: number, y: number): boolean;
+    paintRect(brushWidth: number, brushHeight: number, startX: number, startY: number, endX: number, endY: number): boolean;
+    private opts;
+    commit(accumulator: PixelAccumulator, color: Color32, alpha?: number, blendFn?: BlendColor32): void;
+    clear(): void;
+}
+
+type BinaryMaskPaintBufferCanvasRenderer = ReturnType<typeof makeBinaryMaskPaintBufferCanvasRenderer>;
+declare function makeBinaryMaskPaintBufferCanvasRenderer(paintBuffer: BinaryMaskPaintBuffer, offscreenCanvasClass?: {
+    new (width: number, height: number): OffscreenCanvas;
+    prototype: OffscreenCanvas;
+}): (targetCtx: CanvasRenderingContext2D, color: Color32, alpha?: number, compOperation?: GlobalCompositeOperation) => void;
+
+declare class ColorPaintBuffer {
+    readonly config: PixelEngineConfig;
+    readonly tilePool: TilePool<PixelTile>;
+    private blendPixelDataFn;
+    readonly lookup: (PixelTile | undefined)[];
+    private readonly scratchBounds;
+    constructor(config: PixelEngineConfig, tilePool: TilePool<PixelTile>, blendPixelDataFn?: typeof blendPixelData);
+    paintAlphaMask(color: Color32, brush: PaintAlphaMask, x: number, y: number): boolean;
+    paintAlphaMask(color: Color32, brush: PaintAlphaMask, startX: number, startY: number, endX: number, endY: number): boolean;
+    paintBinaryMask(color: Color32, brush: PaintBinaryMask, x: number, y: number): boolean;
+    paintBinaryMask(color: Color32, brush: PaintBinaryMask, startX: number, startY: number, endX: number, endY: number): boolean;
+    paintRect(color: Color32, brushWidth: number, brushHeight: number, x: number, y: number): boolean;
+    paintRect(color: Color32, brushWidth: number, brushHeight: number, startX: number, startY: number, endX: number, endY: number): boolean;
+    private opts;
+    commit(accumulator: PixelAccumulator, alpha?: number, blendFn?: BlendColor32): void;
+    clear(): void;
+}
+
+type ColorPaintBufferCanvasRenderer = ReturnType<typeof makeColorPaintBufferCanvasRenderer>;
 /**
  *
+ * @param paintBuffer
  * @param offscreenCanvasClass - @internal
  */
-declare function makePaintBufferCanvasRenderer(paintBuffer: PaintBuffer, offscreenCanvasClass?: {
+declare function makeColorPaintBufferCanvasRenderer(paintBuffer: ColorPaintBuffer, offscreenCanvasClass?: {
     new (width: number, height: number): OffscreenCanvas;
     prototype: OffscreenCanvas;
 }): (targetCtx: CanvasRenderingContext2D, alpha?: number, compOperation?: GlobalCompositeOperation) => void;
 
-declare function makeCirclePaintAlphaMask(size: number, fallOff?: (d: number) => number): PaintAlphaMask;
+declare function eachTileInBounds<T extends Tile>(config: PixelEngineConfig, lookup: (T | undefined)[], tilePool: TilePool<T>, bounds: Rect, callback: (tile: T, bX: number, bY: number, bW: number, bH: number) => void): void;
 
+declare function makeCirclePaintAlphaMask(size: number, fallOff?: (d: number) => number): PaintAlphaMask;
 declare function makeCirclePaintBinaryMask(size: number): PaintBinaryMask;
 
 declare function makePaintBinaryMask(mask: BinaryMask): PaintBinaryMask;
@@ -1603,42 +1704,57 @@ declare function makePaintAlphaMask(mask: AlphaMask): PaintAlphaMask;
 
 declare function makeRectFalloffPaintAlphaMask(width: number, height: number, fallOff?: (d: number) => number): PaintAlphaMask;
 
-declare function applyMaskToPixelData(dst: IPixelData32, mask: Mask, opts?: ApplyMaskToPixelDataOptions): boolean;
+type PaintCursorRenderer = ReturnType<typeof makePaintCursorRenderer>;
+declare function makePaintCursorRenderer<T extends HTMLCanvasElement | OffscreenCanvas>(factory?: CanvasObjectFactory<T>): {
+    update: (paintMask?: PaintMask, scale?: number, color?: Color32, alphaThreshold?: number) => void;
+    getBounds: (centerX: number, centerY: number) => Rect;
+    getBoundsScaled: (centerX: number, centerY: number) => Rect;
+    draw: (drawCtx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, centerX: number, centerY: number) => void;
+    getSettings: () => {
+        color: Color32;
+        scale: number;
+        currentMask: PaintMask;
+    };
+};
+
+declare function applyMaskToPixelData(dst: PixelData32, mask: Mask, opts?: ApplyMaskToPixelDataOptions): boolean;
 
-declare function blendColorPixelDataMask(dst: IPixelData32, color: Color32, mask: Mask, opts?: ColorBlendMaskOptions): boolean;
+declare function blendColorPixelDataMask(dst: PixelData32, color: Color32, mask: Mask, opts?: ColorBlendMaskOptions): boolean;
 
-declare function blendColorPixelDataPaintAlphaMask(dst: IPixelData32, color: Color32, mask: PaintAlphaMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
+declare function blendColorPixelDataPaintAlphaMask(dst: PixelData32, color: Color32, mask: PaintAlphaMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
 
-declare function blendColorPixelDataPaintBinaryMask(dst: IPixelData32, color: Color32, mask: PaintBinaryMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
+declare function blendColorPixelDataPaintBinaryMask(dst: PixelData32, color: Color32, mask: PaintBinaryMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
 
-declare function blendColorPixelDataPaintMask(dst: IPixelData32, color: Color32, mask: PaintMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
+declare function blendColorPixelDataPaintMask(dst: PixelData32, color: Color32, mask: PaintMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
 
-declare function blendPixelDataMask(target: IPixelData32, src: IPixelData32, mask: Mask, opts?: PixelBlendMaskOptions): boolean;
+declare function blendPixelDataMask(target: PixelData32, src: PixelData32, mask: Mask, opts?: PixelBlendMaskOptions): boolean;
 
-declare function blendPixelDataPaintBuffer(target: IPixelData32, paintBuffer: PaintBuffer, alpha?: number, blendFn?: BlendColor32, blendPixelDataFn?: typeof blendPixelData): void;
+declare function blendPixelDataPaintBuffer(target: PixelData32, paintBuffer: ColorPaintBuffer, alpha?: number, blendFn?: BlendColor32, blendPixelDataFn?: typeof blendPixelData): void;
 
 /**
  * Clears a region of the PixelData to transparent (0x00000000).
  * Internally uses the optimized fillPixelDataFast.
  */
-declare function clearPixelDataFast(dst: IPixelData32, rect?: Partial<BinaryMaskRect>): void;
+declare function clearPixelDataFast(dst: PixelData32, rect?: Partial<BinaryMaskRect>): void;
+
+declare function copyPixelData<T extends ImageDataLike = ImageData>(target: PixelData<T>): PixelData;
 
 /**
  * High-level extraction that returns a new PixelData instance.
  * Leverages extractPixelDataBuffer for optimized 32-bit memory moves.
  */
-declare function extractPixelData(source: IPixelData32, rect: Rect): PixelData;
-declare function extractPixelData(source: IPixelData32, x: number, y: number, w: number, h: number): PixelData;
+declare function extractPixelData(source: PixelData32, rect: Rect): PixelData;
+declare function extractPixelData(source: PixelData32, x: number, y: number, w: number, h: number): PixelData;
 
 /**
  * Extracts a rectangular region of pixels from PixelData.
  * Returns a new Uint32Array containing the extracted pixels.
  */
-declare function extractPixelDataBuffer(source: IPixelData32, rect: Rect): Uint32Array;
-declare function extractPixelDataBuffer(source: IPixelData32, x: number, y: number, w: number, h: number): Uint32Array;
+declare function extractPixelDataBuffer(source: PixelData32, rect: Rect): Uint32Array;
+declare function extractPixelDataBuffer(source: PixelData32, x: number, y: number, w: number, h: number): Uint32Array;
 
 /**
- * Fills a region or the {@link IPixelData32} buffer with a solid color.
+ * Fills a region or the {@link PixelData32} buffer with a solid color.
  * This function is faster than {@link fillPixelData} but does not
  * return a boolean value indicating changes were made.
  *
@@ -1647,7 +1763,7 @@ declare function extractPixelDataBuffer(source: IPixelData32, x: number, y: numb
  * @param rect - Defines the area to fill. If omitted, the entire
  * buffer is filled.
  */
-declare function fillPixelDataFast(target: IPixelData32, color: Color32, rect?: Partial<Rect>): void;
+declare function fillPixelDataFast(target: PixelData32, color: Color32, rect?: Partial<Rect>): void;
 /**
  * @param dst - The target to modify.
  * @param color - The color to apply.
@@ -1656,22 +1772,35 @@ declare function fillPixelDataFast(target: IPixelData32, color: Color32, rect?:
  * @param w - Width of the fill area.
  * @param h - Height of the fill area.
  */
-declare function fillPixelDataFast(dst: IPixelData32, color: Color32, x: number, y: number, w: number, h: number): void;
+declare function fillPixelDataFast(dst: PixelData32, color: Color32, x: number, y: number, w: number, h: number): void;
+
+declare function makePixelData<T extends ImageDataLike = ImageData>(imageData: T): PixelData<T>;
+declare function setPixelData(target: PixelData, imageData: ImageData): void;
 
 /**
  * Extracts the alpha channel from PixelData into a single-channel mask.
  * Returns a Uint8Array branded as AlphaMask.
  */
-declare function pixelDataToAlphaMask(pixelData: IPixelData32): AlphaMask;
+declare function pixelDataToAlphaMask(pixelData: PixelData32): AlphaMask;
 
-declare function reflectPixelDataHorizontal(pixelData: IPixelData32): void;
-declare function reflectPixelDataVertical(pixelData: IPixelData32): void;
+declare function reflectPixelDataHorizontal(pixelData: PixelData32): void;
+declare function reflectPixelDataVertical(pixelData: PixelData32): void;
 
 /**
  * Resamples PixelData by a specific factor using nearest neighbor.
  * Factor > 1 upscales, Factor < 1 downscales.
  */
-declare function resamplePixelData(pixelData: IPixelData32, factor: number): PixelData;
+declare function resamplePixelData(pixelData: PixelData32, factor: number): PixelData;
+declare function resamplePixelDataInPlace(pixelData: PixelData32, factor: number): void;
+
+type ReusablePixelData = ReturnType<typeof makeReusablePixelData>;
+/**
+ * Creates a factory function that manages a single, reusable PixelData instance.
+ * This is used to minimize garbage collection overhead by recycling the
+ * underlying pixel buffer across multiple operations.
+ * @returns A function that takes width and height and returns a pooled PixelData instance.
+ */
+declare function makeReusablePixelData(): (width: number, height: number) => PixelData;
 
 /**
  * Rotates pixel data 90 degrees clockwise.
@@ -1680,22 +1809,54 @@ declare function resamplePixelData(pixelData: IPixelData32, factor: number): Pix
  */
 declare function rotatePixelData(pixelData: PixelData): void;
 
+declare function uInt32ArrayToPixelData(data: Uint32Array, width: number, height: number): PixelData;
+
 /**
- * Copies a pixel buffer into a specific region of a {@link IPixelData32} object.
+ * Copies a pixel buffer into a specific region of a {@link PixelData32} object.
  *
  * This function performs a direct memory copy from a {@link Uint32Array}
  * into the target buffer.
  */
-declare function writePixelDataBuffer(target: IPixelData32, data: Uint32Array, rect: Rect): void;
-declare function writePixelDataBuffer(target: IPixelData32, data: Uint32Array, x: number, y: number, w: number, h: number): void;
+declare function writePixelDataBuffer(target: PixelData32, data: Uint32Array, rect: Rect): void;
+declare function writePixelDataBuffer(target: PixelData32, data: Uint32Array, x: number, y: number, w: number, h: number): void;
 
 /**
  * @param writePixelDataBufferFn - @hidden
  */
-declare function writePaintBufferToPixelData(target: IPixelData, paintBuffer: PaintBuffer, writePixelDataBufferFn?: typeof writePixelDataBuffer): void;
+declare function writePaintBufferToPixelData(target: PixelData, paintBuffer: ColorPaintBuffer, writePixelDataBufferFn?: typeof writePixelDataBuffer): void;
 
 declare function getRectsBounds<T extends Rect>(rects: T[]): T;
 
+type ClippedRect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    inBounds: boolean;
+};
+type ClippedBlit = {
+    x: number;
+    y: number;
+    sx: number;
+    sy: number;
+    w: number;
+    h: number;
+    inBounds: boolean;
+};
+declare const makeClippedRect: () => ClippedRect;
+declare const makeClippedBlit: () => ClippedBlit;
+/**
+ * Calculates the intersection of a target rectangle and a bounding box (usually 0,0 -> width,height).
+ * Handles negative offsets by shrinking dimensions.
+ */
+declare function resolveRectClipping(x: number, y: number, w: number, h: number, boundaryW: number, boundaryH: number, out: ClippedRect): ClippedRect;
+/**
+ * Calculates the clipping for transferring data from a Source to a Destination.
+ * Handles cases where the source is out of bounds (shifting the destination target)
+ * AND cases where the destination is out of bounds (shifting the source target).
+ */
+declare function resolveBlitClipping(x: number, y: number, sx: number, sy: number, w: number, h: number, dstW: number, dstH: number, srcW: number, srcH: number, out: ClippedBlit): ClippedBlit;
+
 /**
  * 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`.
@@ -1714,45 +1875,9 @@ declare function trimMaskRectBounds<T extends NullableMaskRect>(target: T, bound
 
 declare function trimRectBounds(x: number, y: number, w: number, h: number, targetWidth: number, targetHeight: number, out?: Rect): Rect;
 
-/**
- * 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 const makeAlphaMaskTile: TileFactory<AlphaMaskTile>;
+declare const makeBinaryMaskTile: TileFactory<BinaryMaskTile>;
+
+declare function makePixelTile(id: number, tx: number, ty: number, tileSize: number, tileArea: number): PixelTile;
 
-export { type AlphaMask, type AlphaMaskRect, type ApplyMaskToPixelDataOptions, BASE_FAST_BLEND_MODE_FUNCTIONS, BASE_PERFECT_BLEND_MODE_FUNCTIONS, type Base64EncodedUInt8Array, BaseBlendMode, type BaseBlendModes, type BaseMask, type BasePixelBlendOptions, type BinaryMask, type BinaryMaskRect, type BlendColor32, type BlendModeRegistry, CANVAS_COMPOSITE_MAP, type CanvasBlendModeIndex, type CanvasCompositeOperation, type CanvasContext, type CanvasFrameRenderer, type ClippedBlit, type ClippedRect, type Color32, type ColorBlendMaskOptions, type ColorBlendOptions, type ColorBlendPaintMaskOptions, type DidChangeFn, type DrawPixelLayer, type DrawScreenLayer, type FloodFillResult, type HistoryAction, type HistoryActionFactory, HistoryManager, type HistoryMutator, type IPixelData, type IPixelData32, type ImageDataLike, type ImageDataLikeConstructor, IndexedImage, type InvertMask, type Mask, type MaskOffset, type MaskRect, MaskType, type MergeAlphaMasksOptions, type NullableBinaryMaskRect, type NullableMaskRect, type PaintAlphaMask, type PaintBinaryMask, PaintBuffer, type PaintBufferCanvasRenderer, type PaintMask, PixelAccumulator, type PixelBlendMaskOptions, type PixelBlendOptions, type PixelCanvas, PixelData, PixelEngineConfig, type PixelMutateOptions, type PixelPatchTiles, type PixelRect, PixelTile, PixelTilePool, PixelWriter, type PixelWriterOptions, type RGBA, type Rect, type RequiredBlendModes, type ReusableCanvas, type ReusableImageData, type SerializedImageData, UnsupportedFormatError, applyAlphaMaskToPixelData, applyBinaryMaskToAlphaMask, applyBinaryMaskToPixelData, applyMaskToPixelData, applyPatchTiles, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendColorPixelDataAlphaMask, blendColorPixelDataBinaryMask, blendColorPixelDataMask, blendColorPixelDataPaintAlphaMask, blendColorPixelDataPaintBinaryMask, blendColorPixelDataPaintMask, blendPixel, blendPixelData, blendPixelDataAlphaMask, blendPixelDataBinaryMask, blendPixelDataMask, blendPixelDataPaintBuffer, clearPixelDataFast, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataBuffer, extractMask, extractMaskBuffer, extractPixelData, extractPixelDataBuffer, fileInputChangeToImageData, fileToImageData, fillPixelData, fillPixelDataBinaryMask, fillPixelDataFast, floodFillSelection, forEachLinePoint, getImageDataFromClipboard, getIndexedImageColorCounts, getRectsBounds, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMaskBuffer, imageDataToDataUrl, imageDataToImgBlob, imageDataToUInt32Array, imgBlobToImageData, indexedImageToAverageColor, indexedImageToImageData, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeAlphaMask, makeBinaryMask, makeBlendModeRegistry, makeCanvasFrameRenderer, makeCirclePaintAlphaMask, makeCirclePaintBinaryMask, makeClippedBlit, makeClippedRect, makeFastBlendModeRegistry, makeFullPixelMutator, makeHistoryAction, makeImageDataLike, makePaintAlphaMask, makePaintBinaryMask, makePaintBufferCanvasRenderer, makePerfectBlendModeRegistry, makePixelCanvas, makeRectFalloffPaintAlphaMask, makeReusableCanvas, makeReusableImageData, makeReusableOffscreenCanvas, merge2BinaryMaskRects, mergeAlphaMasks, mergeBinaryMaskRects, mergeBinaryMasks, multiplyFast, multiplyPerfect, mutatorApplyAlphaMask, mutatorApplyBinaryMask, mutatorApplyMask, mutatorBlendAlphaMask, mutatorBlendBinaryMask, mutatorBlendColor, mutatorBlendColorPaintAlphaMask, mutatorBlendColorPaintBinaryMask, mutatorBlendColorPaintMask, mutatorBlendColorPaintRect, mutatorBlendMask, mutatorBlendPixel, mutatorBlendPixelData, mutatorClear, mutatorFill, mutatorFillBinaryMask, mutatorFillRect, mutatorInvert, overlayFast, overlayPerfect, overwriteBase, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resample32, resampleImageData, resampleIndexedImage, resamplePixelData, resizeImageData, resolveBlitClipping, resolveRectClipping, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, setMaskData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractBinaryMaskRects, subtractFast, subtractPerfect, toBlendModeIndexAndName, trimMaskRectBounds, trimRectBounds, uInt32ArrayToImageData, uInt32ArrayToImageDataLike, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageData, writeImageDataBuffer, writeImageDataToClipboard, writeImgBlobToClipboard, writePaintBufferToPixelData, writePixelDataBuffer };
+export { type AlphaMask, AlphaMaskPaintBuffer, type AlphaMaskPaintBufferCanvasRenderer, type AlphaMaskRect, type AlphaMaskTile, type ApplyMaskToPixelDataOptions, BASE_FAST_BLEND_MODE_FUNCTIONS, BASE_PERFECT_BLEND_MODE_FUNCTIONS, type Base64EncodedUInt8Array, BaseBlendMode, type BaseBlendModes, type BaseMask, type BasePixelBlendOptions, type BinaryMask, BinaryMaskPaintBuffer, type BinaryMaskPaintBufferCanvasRenderer, type BinaryMaskRect, type BinaryMaskTile, type BlendColor32, type BlendModeRegistry, CANVAS_COMPOSITE_MAP, type CanvasBlendModeIndex, type CanvasCompositeOperation, type CanvasContext, type CanvasFrameRenderer, type CanvasObjectFactory, type CanvasPixelDataRenderer, type ClippedBlit, type ClippedRect, type Color32, type ColorBlendMaskOptions, type ColorBlendOptions, ColorPaintBuffer, type ColorPaintBufferCanvasRenderer, type DidChangeFn, type DrawPixelLayer, type DrawScreenLayer, _errors as ERRORS, type FloodFillResult, type HistoryAction, type HistoryActionFactory, HistoryManager, type HistoryMutator, type ImageDataLike, type IndexedImage, type InvertMask, type Mask, type MaskOffset, type MaskRect, MaskType, type MergeAlphaMasksOptions, type MutableAlphaMask, type MutableBinaryMask, type MutableMask, type MutablePixelData32, type NullableBinaryMaskRect, type NullableMaskRect, type PaintAlphaMask, type PaintBinaryMask, type PaintCursorRenderer, type PaintMask, PaintMaskOutline, PixelAccumulator, type PixelBlendMaskOptions, type PixelBlendOptions, type PixelCanvas, type PixelData, type PixelData32, PixelEngineConfig, type PixelMutateOptions, type PixelPatchTiles, type PixelRect, type PixelTile, PixelWriter, type PixelWriterOptions, type RGBA, type Rect, type RequiredBlendModes, type ReusableCanvas, type ReusableCanvasFactory, type ReusableImageData, type ReusablePixelData, type SerializedImageData, type Tile, type TileFactory, TilePool, TileType, UnsupportedFormatError, _macro_imageDataToUint32Array, applyAlphaMaskToPixelData, applyBinaryMaskToAlphaMask, applyBinaryMaskToPixelData, applyMaskToPixelData, applyPatchTiles, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendColorPixelDataAlphaMask, blendColorPixelDataBinaryMask, blendColorPixelDataMask, blendColorPixelDataPaintAlphaMask, blendColorPixelDataPaintBinaryMask, blendColorPixelDataPaintMask, blendPixel, blendPixelData, blendPixelDataAlphaMask, blendPixelDataBinaryMask, blendPixelDataMask, blendPixelDataPaintBuffer, clearPixelDataFast, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, copyPixelData, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, destinationAtopFast, destinationAtopPerfect, destinationInFast, destinationInPerfect, destinationOutFast, destinationOutPerfect, destinationOverFast, destinationOverPerfect, differenceFast, differencePerfect, divideFast, dividePerfect, eachTileInBounds, exclusionFast, exclusionPerfect, extractImageDataBuffer, extractMask, extractMaskBuffer, extractPixelData, extractPixelDataBuffer, fileInputChangeToImageData, fileToImageData, fillPixelData, fillPixelDataBinaryMask, fillPixelDataFast, floodFillSelection, forEachLinePoint, getImageDataFromClipboard, getIndexedImageColor, getIndexedImageColorCounts, getRectsBounds, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMaskBuffer, imageDataToDataUrl, imageDataToImgBlob, imageDataToUint32Array, imgBlobToImageData, indexedImageToAverageColor, indexedImageToImageData, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeAlphaMask, makeAlphaMaskPaintBufferCanvasRenderer, makeAlphaMaskTile, makeBinaryMask, makeBinaryMaskFromAlphaMask, makeBinaryMaskOutline, makeBinaryMaskPaintBufferCanvasRenderer, makeBinaryMaskTile, makeBlendModeRegistry, makeCanvasFrameRenderer, makeCanvasPixelDataRenderer, makeCircleBinaryMaskOutline, makeCirclePaintAlphaMask, makeCirclePaintBinaryMask, makeClippedBlit, makeClippedRect, makeColorPaintBufferCanvasRenderer, makeFastBlendModeRegistry, makeFullPixelMutator, makeHistoryAction, makeImageDataLike, makeIndexedImage, makeIndexedImageFromImageData, makeIndexedImageFromImageDataRaw, makePaintAlphaMask, makePaintBinaryMask, makePaintCursorRenderer, makePerfectBlendModeRegistry, makePixelCanvas, makePixelData, makePixelTile, makeRectBinaryMaskOutline, makeRectFalloffPaintAlphaMask, makeReusableCanvas, makeReusableImageData, makeReusableOffscreenCanvas, makeReusablePixelData, merge2BinaryMaskRects, mergeAlphaMasks, mergeBinaryMaskRects, mergeBinaryMasks, multiplyFast, multiplyPerfect, mutatorApplyAlphaMask, mutatorApplyBinaryMask, mutatorApplyMask, mutatorBlendAlphaMask, mutatorBlendBinaryMask, mutatorBlendColor, mutatorBlendColorPaintAlphaMask, mutatorBlendColorPaintBinaryMask, mutatorBlendColorPaintMask, mutatorBlendColorPaintRect, mutatorBlendMask, mutatorBlendPixel, mutatorBlendPixelData, mutatorClear, mutatorFill, mutatorFillBinaryMask, mutatorFillRect, mutatorInvert, overlayFast, overlayPerfect, overwriteBase, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resampleImageData, resampleIndexedImage, resamplePixelData, resamplePixelDataInPlace, resampleUint32Array, resizeImageData, resolveBlitClipping, resolveRectClipping, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, setMaskData, setPixelData, softLightFast, softLightPerfect, sourceAtopFast, sourceAtopPerfect, sourceInFast, sourceInPerfect, sourceOutFast, sourceOutPerfect, sourceOverFast, sourceOverPerfect, subtractBinaryMaskRects, subtractFast, subtractPerfect, toBlendModeIndexAndName, trimMaskRectBounds, trimRectBounds, uInt32ArrayToImageData, uInt32ArrayToImageDataLike, uInt32ArrayToPixelData, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageData, writeImageDataBuffer, writeImageDataToClipboard, writeImgBlobToClipboard, writePaintBufferToPixelData, writePixelDataBuffer, xorFast, xorPerfect };