pixel-data-js 0.18.0 → 0.19.1

package/dist/index.prod.d.ts

@@ -24,6 +24,9 @@ type ImageDataLike = {
     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;
@@ -67,7 +70,7 @@ type AnyMask = BinaryMask | AlphaMask;
  * Configuration for pixel manipulation operations.
  * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
  */
-interface PixelRectOptions {
+interface PixelRect {
     /**
      * The starting X coordinate in the destination buffer.
      * @default 0
@@ -79,22 +82,17 @@ interface PixelRectOptions {
      */
     y?: number;
     /**
-     * The width of the region to process.
+     * The width of the region in the destination buffer.
      * @default Source width.
      */
     w?: number;
     /**
-     * The height of the region to process.
+     * The height of the region in the destination buffer.
      * @default Source height.
      */
     h?: number;
 }
-interface PixelMaskRectOptions {
-    /**
-     * Mask width.
-     * @default value of `w`
-     */
-    mw?: number;
+interface MaskOffset {
     /**
      * X offset into the mask buffer.
      * @default 0
@@ -106,38 +104,39 @@ interface PixelMaskRectOptions {
      */
     my?: number;
 }
-interface PixelMaskInvertOptions {
+interface MaskOffsetWidth {
+    /**
+     * Mask width.
+     * @default value of `w`
+     */
+    mw?: number;
+}
+interface InvertMask {
     /**
      * If true the inverse of the mask will be applied
      * @default false
      */
     invertMask?: boolean;
 }
-/**
- * Configuration for pixel manipulation operations.
- * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
- */
-interface PixelOptions extends PixelRectOptions, PixelMaskRectOptions, PixelMaskInvertOptions {
+interface Alpha {
     /**
      * Overall layer opacity 0-255.
      * @default 255
      */
     alpha?: number;
-    /** An optional mask to restrict where pixels are written. */
-    mask?: AnyMask | null;
-    /** The interpretation logic for the provided mask.
-     * @default {@link MaskType.ALPHA}
-     */
-    maskType?: MaskType;
 }
-interface PixelMutateOptions extends PixelRectOptions, PixelMaskRectOptions, PixelMaskInvertOptions {
+interface ApplyMaskToPixelDataOptions extends PixelRect, Alpha, MaskOffsetWidth, MaskOffset, InvertMask {
+}
+interface MergeAlphaMasksOptions extends PixelRect, Alpha, MaskOffset, InvertMask {
+}
+interface PixelMutateOptions extends PixelRect, MaskOffset, MaskOffsetWidth, InvertMask {
     /** An optional mask to restrict where pixels are mutated. */
     mask?: BinaryMask | null;
 }
 /**
  * Configuration for blitting (copying/blending) one image into another.
  */
-interface PixelBlendOptions extends PixelOptions {
+interface BasePixelBlendOptions {
     /**
      * The source rectangle x-coordinate
      * @default 0
@@ -150,21 +149,26 @@ interface PixelBlendOptions extends PixelOptions {
     sy?: number;
     /**
      * The blending algorithm to use for blending pixels.
-     * @default {@link sourceOverFast}
+     * @default {@link sourceOverPerfect}
      */
     blendFn?: BlendColor32;
 }
+interface PixelBlendOptions extends PixelRect, Alpha, BasePixelBlendOptions {
+}
+interface PixelBlendMaskOptions extends PixelRect, Alpha, MaskOffsetWidth, MaskOffset, InvertMask, BasePixelBlendOptions {
+}
 /**
  * Configuration for operations that require color blending.
  */
-interface ColorBlendOptions extends PixelOptions {
+interface ColorBlendOptions extends PixelRect, Alpha {
     /**
      * The blending algorithm to use for blending pixels.
-     * @default {@link sourceOverFast}
+     * @default {@link sourceOverPerfect}
      */
     blendFn?: BlendColor32;
 }
-type ApplyMaskOptions = Omit<PixelOptions, 'mask'>;
+interface ColorBlendMaskOptions extends ColorBlendOptions, MaskOffset, MaskOffsetWidth, InvertMask {
+}
 type SelectionRect = Rect & ({
     mask: Uint8Array;
     maskType: MaskType;
@@ -172,10 +176,12 @@ type SelectionRect = Rect & ({
     mask?: null;
     maskType?: null;
 });
-type Point = {
-    x: number;
-    y: number;
-};
+type HistoryMutator<T extends {}, D extends {}> = (writer: PixelWriter<any>, deps?: Partial<D>) => T;
+interface IPixelData {
+    readonly data32: Uint32Array;
+    readonly width: number;
+    readonly height: number;
+}
 
 /**
  * Packs RGBA into a 32-bit integer compatible with
@@ -218,17 +224,14 @@ declare function color32ToHex(color: Color32): string;
  */
 declare function color32ToCssRGBA(color: Color32): string;
 
-declare class PixelData {
-    data32: Uint32Array;
-    imageData: ImageData;
-    get width(): number;
-    get height(): number;
-    constructor(imageData: ImageData);
-    set(imageData: ImageData): void;
-    /**
-     * Creates a deep copy of the PixelData using the environment's ImageData constructor.
-     */
-    copy(): PixelData;
+declare class PixelData<T extends ImageDataLike = ImageData> implements IPixelData {
+    readonly data32: Uint32Array;
+    readonly imageData: T;
+    readonly width: number;
+    readonly height: number;
+    constructor(imageData: T);
+    set(imageData: T): void;
+    copy(): PixelData<T>;
 }
 
 type FloodFillImageDataOptions = {
@@ -276,49 +279,6 @@ type FloodFillResult = {
  */
 declare function floodFillSelection(img: ImageDataLike | PixelData, startX: number, startY: number, { contiguous, tolerance, bounds, }?: FloodFillImageDataOptions): FloodFillResult | null;
 
-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>): {
-    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 const overwriteFast: BlendColor32;
 declare const sourceOverFast: BlendColor32;
 declare const darkenFast: BlendColor32;
@@ -366,7 +326,8 @@ declare const subtractFast: BlendColor32;
 /** sr === 0 ? 255 : Math.min(255, (dr << 8) / sr) */
 declare const divideFast: BlendColor32;
 declare const BASE_FAST_BLEND_MODE_FUNCTIONS: Record<number, BlendColor32>;
-declare function makeFastBlendModeRegistry(): {
+declare function makeFastBlendModeRegistry(name?: string): {
+    registryName: string;
     nameToBlend: {
         readonly overwrite: BlendColor32;
         readonly sourceOver: BlendColor32;
@@ -392,12 +353,12 @@ declare function makeFastBlendModeRegistry(): {
         readonly subtract: BlendColor32;
         readonly divide: 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 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22>;
-    blendToIndex: Map<BlendColor32, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22>;
+    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 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
+    blendToIndex: Map<BlendColor32, 0 | 16 | 8 | 2 | 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">;
     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 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22;
+    indexType: 0 | 16 | 8 | 2 | 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";
 };
 
@@ -448,7 +409,8 @@ declare const subtractPerfect: BlendColor32;
 /** sr === 0 ? 255 : Math.min(255, (dr << 8) / sr) */
 declare const dividePerfect: BlendColor32;
 declare const BASE_PERFECT_BLEND_MODE_FUNCTIONS: Record<number, BlendColor32>;
-declare function makePerfectBlendModeRegistry(): {
+declare function makePerfectBlendModeRegistry(name?: string): {
+    registryName: string;
     nameToBlend: {
         readonly overwrite: BlendColor32;
         readonly sourceOver: BlendColor32;
@@ -474,15 +436,67 @@ declare function makePerfectBlendModeRegistry(): {
         readonly subtract: BlendColor32;
         readonly divide: 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 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22>;
-    blendToIndex: Map<BlendColor32, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22>;
+    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 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
+    blendToIndex: Map<BlendColor32, 0 | 16 | 8 | 2 | 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">;
     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 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22;
+    indexType: 0 | 16 | 8 | 2 | 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";
 };
 
+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 toBlendModeIndexAndName(input: string | number): {
+    blendIndex: number;
+    blendName: string;
+};
+
+declare const OFFSCREEN_CANVAS_CTX_FAILED = "Failed to create OffscreenCanvas context";
+declare const CANVAS_CTX_FAILED = "Failed to create Canvas context";
+
 type PixelCanvas = {
     readonly canvas: HTMLCanvasElement;
     readonly ctx: CanvasRenderingContext2D;
@@ -561,6 +575,27 @@ declare function writeImageDataToClipboard(imageData: ImageData): Promise<void>;
  */
 declare function writeImgBlobToClipboard(blob: Blob): Promise<void>;
 
+interface HistoryAction {
+    undo: () => void;
+    redo: () => void;
+    dispose?: () => void;
+}
+declare class HistoryManager {
+    maxSteps: number;
+    undoStack: HistoryAction[];
+    redoStack: HistoryAction[];
+    listeners: Set<() => void>;
+    constructor(maxSteps?: number);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    subscribe(fn: () => void): () => boolean;
+    notify(): void;
+    commit(action: HistoryAction): void;
+    undo(): void;
+    redo(): void;
+    clearRedoStack(): void;
+}
+
 declare class PixelEngineConfig {
     readonly tileSize: number;
     readonly tileShift: number;
@@ -580,15 +615,15 @@ declare class PixelTile {
     data32: Uint32Array;
     constructor(id: number, tx: number, ty: number, tileArea: number);
 }
-declare function applyPatchTiles(target: PixelData, tiles: PixelTile[], tileSize?: number): void;
+declare function applyPatchTiles(target: IPixelData, tiles: PixelTile[], tileSize?: number): void;
 
 declare class PixelAccumulator {
-    target: PixelData;
+    target: IPixelData;
     readonly config: PixelEngineConfig;
     lookup: (PixelTile | undefined)[];
     beforeTiles: PixelTile[];
     pool: PixelTile[];
-    constructor(target: PixelData, config: PixelEngineConfig);
+    constructor(target: IPixelData, config: PixelEngineConfig);
     getTile(id: number, tx: number, ty: number): PixelTile;
     recyclePatch(patch: PixelPatchTiles): void;
     /**
@@ -609,27 +644,6 @@ declare class PixelAccumulator {
     reset(): void;
 }
 
-interface HistoryAction {
-    undo: () => void;
-    redo: () => void;
-    dispose?: () => void;
-}
-declare class HistoryManager {
-    maxSteps: number;
-    undoStack: HistoryAction[];
-    redoStack: HistoryAction[];
-    listeners: Set<() => void>;
-    constructor(maxSteps?: number);
-    get canUndo(): boolean;
-    get canRedo(): boolean;
-    subscribe(fn: () => void): () => boolean;
-    notify(): void;
-    commit(action: HistoryAction): void;
-    undo(): void;
-    redo(): void;
-    clearRedoStack(): void;
-}
-
 interface PixelWriterOptions {
     maxHistorySteps?: number;
     tileSize?: number;
@@ -657,32 +671,184 @@ interface PixelWriterOptions {
  * })
  */
 declare class PixelWriter<M> {
-    target: PixelData;
+    target: IPixelData;
     historyManager: HistoryManager;
     accumulator: PixelAccumulator;
     protected config: PixelEngineConfig;
     readonly mutator: M;
-    constructor(target: PixelData, mutatorFactory: (writer: PixelWriter<any>) => M, { tileSize, maxHistorySteps, historyManager, }?: PixelWriterOptions);
+    constructor(target: IPixelData, mutatorFactory: (writer: PixelWriter<any>) => M, { tileSize, maxHistorySteps, historyManager, }?: PixelWriterOptions);
     withHistory(cb: (mutator: M) => void): void;
     captureHistory(): void;
 }
 
 declare function makeFullPixelMutator(writer: PixelWriter<any>): {
-    applyRectBrush(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, fallOff?: (dist: number) => number, blendFn?: BlendColor32): void;
-    applyCircleBrush(color: Color32, centerX: number, centerY: number, brushSize: number, alpha?: number, fallOff?: (dist: number) => number, blendFn?: BlendColor32): void;
+    clear(rect?: Partial<Rect>): void;
+    applyRectPencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
+    applyRectPencil(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
+    applyRectBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+    applyRectBrush(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushSize: number, alpha?: number, blendFn?: BlendColor32): void;
+    applyCircleBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+    applyCircleBrush(color: Color32, centerX: number, centerY: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
     invert(opts?: PixelMutateOptions): void;
     fill(color: Color32, rect?: Partial<Rect>): void;
     blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): void;
     blendColor(color: Color32, opts?: ColorBlendOptions): void;
-    blendPixelData(src: PixelData, opts: PixelBlendOptions): void;
-    applyMask: (mask: AnyMask, opts?: ApplyMaskOptions) => void;
+    blendPixelData(src: IPixelData, opts: PixelBlendOptions): void;
+    applyBinaryMask: (mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions) => void;
+    applyAlphaMask: (mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions) => void;
+};
+
+declare function applyAlphaMaskToPixelData(dst: IPixelData, mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): void;
+
+declare const defaults$e: {
+    applyAlphaMaskToPixelData: typeof applyAlphaMaskToPixelData;
+};
+type Deps$e = Partial<typeof defaults$e>;
+declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$e) => {
+    applyAlphaMask: (mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions) => void;
 };
 
-declare function mutatorApplyMask(writer: PixelWriter<any>): {
-    applyMask: (mask: AnyMask, opts?: ApplyMaskOptions) => void;
+/**
+ * Directly applies a mask to a region of PixelData,
+ * modifying the destination's alpha channel in-place.
+ */
+declare function applyBinaryMaskToPixelData(dst: IPixelData, mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): void;
+
+declare const defaults$d: {
+    applyBinaryMaskToPixelData: typeof applyBinaryMaskToPixelData;
+};
+type Deps$d = Partial<typeof defaults$d>;
+declare const mutatorApplyBinaryMask: (writer: PixelWriter<any>, deps?: Deps$d) => {
+    applyBinaryMask: (mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions) => void;
 };
 
-declare function mutatorBlendColor(writer: PixelWriter<any>): {
+/**
+ * Applies a circular brush to pixel data, blending a color with optional falloff.
+ *
+ * @param target The PixelData to modify.
+ * @param color The brush color.
+ * @param centerX The center x-coordinate of the brush.
+ * @param centerY The center y-coordinate of the brush.
+ * @param brushSize The diameter of the brush.
+ * @param alpha The overall opacity of the brush (0-255).
+ * @default 255
+ * @param fallOff A function that returns an alpha multiplier (0-1) based on the normalized distance (0-1) from the circle's center.
+ * @param blendFn
+ * @param bounds precalculated result from {@link getCircleBrushOrPencilBounds}
+ * @default sourceOverPerfect
+ */
+declare function applyCircleBrushToPixelData(target: IPixelData, color: Color32, centerX: number, centerY: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32, bounds?: Rect): void;
+
+declare function getCircleBrushOrPencilBounds(centerX: number, centerY: number, brushSize: number, targetWidth: number, targetHeight: number, out?: Rect): Rect;
+
+declare const defaults$c: {
+    applyCircleBrushToPixelData: typeof applyCircleBrushToPixelData;
+    getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
+};
+type Deps$c = Partial<typeof defaults$c>;
+declare const mutatorApplyCircleBrush: (writer: PixelWriter<any>, deps?: Deps$c) => {
+    applyCircleBrush(color: Color32, centerX: number, centerY: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+};
+
+/**
+ * Iterates through a line with sub-pixel precision.
+ * Guarantees that the first and last points are exactly (x0, y0) and (x1, y1).
+ */
+declare function forEachLinePoint(x0: number, y0: number, x1: number, y1: number, callback: (x: number, y: number) => void): void;
+
+declare function blendColorPixelDataAlphaMask(dst: IPixelData, color: Color32, mask: AlphaMask, opts: ColorBlendMaskOptions): void;
+
+declare function getCircleBrushOrPencilStrokeBounds(x0: number, y0: number, x1: number, y1: number, brushSize: number, result: Rect): Rect;
+
+declare const defaults$b: {
+    forEachLinePoint: typeof forEachLinePoint;
+    blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
+    getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
+    getCircleBrushOrPencilStrokeBounds: typeof getCircleBrushOrPencilStrokeBounds;
+};
+type Deps$b = Partial<typeof defaults$b>;
+declare const mutatorApplyCircleBrushStroke: (writer: PixelWriter<any>, deps?: Deps$b) => {
+    applyCircleBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+};
+
+declare const defaults$a: {
+    applyCircleBrushToPixelData: typeof applyCircleBrushToPixelData;
+    getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
+    fallOff: () => number;
+};
+type Deps$a = Partial<typeof defaults$a>;
+declare const mutatorApplyCirclePencil: (writer: PixelWriter<any>, deps?: Deps$a) => {
+    applyCirclePencil(color: Color32, centerX: number, centerY: number, brushSize: number, alpha?: number, blendFn?: BlendColor32): void;
+};
+
+declare function blendColorPixelDataBinaryMask(dst: IPixelData, color: Color32, mask: BinaryMask, opts?: ColorBlendMaskOptions): void;
+
+declare const defaults$9: {
+    forEachLinePoint: typeof forEachLinePoint;
+    blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
+    getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
+    getCircleBrushOrPencilStrokeBounds: typeof getCircleBrushOrPencilStrokeBounds;
+};
+type Deps$9 = Partial<typeof defaults$9>;
+declare const mutatorApplyCirclePencilStroke: (writer: PixelWriter<any>, deps?: Deps$9) => {
+    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushSize: number, alpha?: number, blendFn?: BlendColor32): void;
+};
+
+declare function applyRectBrushToPixelData(target: IPixelData, color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32, bounds?: Rect): void;
+
+declare function getRectBrushOrPencilBounds(centerX: number, centerY: number, brushWidth: number, brushHeight: number, targetWidth: number, targetHeight: number, out?: Rect): Rect;
+
+declare const defaults$8: {
+    applyRectBrushToPixelData: typeof applyRectBrushToPixelData;
+    getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
+    fallOff: () => number;
+};
+type Deps$8 = Partial<typeof defaults$8>;
+declare const mutatorApplyRectPencil: (writer: PixelWriter<any>, deps?: Deps$8) => {
+    applyRectPencil(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
+};
+
+declare function getRectBrushOrPencilStrokeBounds(x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, result: Rect): Rect;
+
+declare const defaults$7: {
+    forEachLinePoint: typeof forEachLinePoint;
+    getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
+    getRectBrushOrPencilStrokeBounds: typeof getRectBrushOrPencilStrokeBounds;
+    blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
+};
+type Deps$7 = Partial<typeof defaults$7>;
+declare const mutatorApplyRectPencilStroke: (writer: PixelWriter<any>, deps?: Deps$7) => {
+    applyRectPencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
+};
+
+declare const defaults$6: {
+    applyRectBrushToPixelData: typeof applyRectBrushToPixelData;
+    getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
+};
+type Deps$6 = Partial<typeof defaults$6>;
+declare const mutatorApplyRectBrush: (writer: PixelWriter<any>, deps?: Deps$6) => {
+    applyRectBrush(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+};
+
+declare const defaults$5: {
+    forEachLinePoint: typeof forEachLinePoint;
+    blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
+    getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
+    getRectBrushOrPencilStrokeBounds: typeof getRectBrushOrPencilStrokeBounds;
+};
+type Deps$5 = Partial<typeof defaults$5>;
+declare const mutatorApplyRectBrushStroke: (writer: PixelWriter<any>, deps?: Deps$5) => {
+    applyRectBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+};
+
+declare function blendColorPixelData(dst: IPixelData, color: Color32, opts?: ColorBlendOptions): void;
+
+declare const defaults$4: {
+    blendColorPixelData: typeof blendColorPixelData;
+};
+type Deps$4 = Partial<typeof defaults$4>;
+declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$4) => {
     blendColor(color: Color32, opts?: ColorBlendOptions): void;
 };
 
@@ -690,27 +856,75 @@ declare function mutatorBlendPixel(writer: PixelWriter<any>): {
     blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): void;
 };
 
-declare function mutatorBlendPixelData(writer: PixelWriter<any>): {
-    blendPixelData(src: PixelData, opts: PixelBlendOptions): 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(dst: IPixelData, src: IPixelData, opts: PixelBlendOptions): void;
+
+declare const defaults$3: {
+    blendPixelData: typeof blendPixelData;
+};
+type Deps$3 = Partial<typeof defaults$3>;
+declare const mutatorBlendPixelData: (writer: PixelWriter<any>, deps?: Partial<Deps$3>) => {
+    blendPixelData(src: IPixelData, opts: PixelBlendOptions): void;
 };
 
-declare function mutatorFill(writer: PixelWriter<any>): {
+/**
+ * Fills a region or the {@link PixelData} buffer with a solid color.
+ *
+ * @param dst - The target {@link PixelData} to modify.
+ * @param color - The {@link Color32} value to apply.
+ * @param rect - A {@link Rect} defining the area to fill. If omitted, the entire
+ * buffer is filled.
+ */
+declare function fillPixelData(dst: IPixelData, color: Color32, rect?: Partial<Rect>): void;
+/**
+ * @param dst - The target {@link PixelData} to modify.
+ * @param color - The {@link Color32} value to apply.
+ * @param x - Starting horizontal coordinate.
+ * @param y - Starting vertical coordinate.
+ * @param w - Width of the fill area.
+ * @param h - Height of the fill area.
+ */
+declare function fillPixelData(dst: IPixelData, color: Color32, x: number, y: number, w: number, h: number): void;
+
+declare const defaults$2: {
+    fillPixelData: typeof fillPixelData;
+};
+type Deps$2 = Partial<typeof defaults$2>;
+declare const mutatorClear: (writer: PixelWriter<any>, deps?: Deps$2) => {
+    clear(rect?: Partial<Rect>): void;
+};
+
+declare const defaults$1: {
+    fillPixelData: typeof fillPixelData;
+};
+type Deps$1 = Partial<typeof defaults$1>;
+declare const mutatorFill: (writer: PixelWriter<any>, deps?: Deps$1) => {
     fill(color: Color32, rect?: Partial<Rect>): void;
 };
 
-declare function mutatorInvert(writer: PixelWriter<any>): {
+declare function invertPixelData(pixelData: IPixelData, opts?: PixelMutateOptions): void;
+
+declare const defaults: {
+    invertPixelData: typeof invertPixelData;
+};
+type Deps = Partial<typeof defaults>;
+declare const mutatorInvert: (writer: PixelWriter<any>, deps?: Deps) => {
     invert(opts?: PixelMutateOptions): void;
 };
 
-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;
 
@@ -735,6 +949,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.
@@ -854,6 +1070,15 @@ declare function resampleImageData(source: ImageData, factor: number): ImageData
  */
 declare function resizeImageData(current: ImageDataLike, newWidth: number, newHeight: number, offsetX?: number, offsetY?: 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>;
 /**
@@ -865,6 +1090,9 @@ declare function deserializeRawImageData<T extends SerializedImageData>(serializ
 declare function deserializeImageData<T extends SerializedImageData>(serialized: T): ImageData;
 declare function deserializeNullableImageData<T extends SerializedImageData | null>(serialized: T): T extends null ? null : ImageData;
 
+declare function uInt32ArrayToImageData(data: Uint32Array, width: number, height: number): ImageData;
+declare function uInt32ArrayToImageDataLike(data: Uint32Array, width: number, height: number): ImageDataLike;
+
 /**
  * Writes image data from a source to a target with support for clipping and alpha masking.
  *
@@ -970,20 +1198,20 @@ declare function getIndexedImageColorCounts(indexedImage: IndexedImage): Int32Ar
 declare function indexedImageToAverageColor(indexedImage: IndexedImage, includeTransparent?: boolean): Color32;
 
 /**
- * Resamples an IndexedImage by a specific factor using nearest neighbor
- * Factor > 1 upscales, Factor < 1 downscales.
+ * Converts an IndexedImage back into standard ImageData.
  */
+declare function indexedImageToImageData(indexedImage: IndexedImage): ImageData;
 
 /**
  * Resamples an IndexedImage by a specific factor using nearest neighbor
  * Factor > 1 upscales, Factor < 1 downscales.
  */
-declare function resampleIndexedImage(source: IndexedImage, factor: number): IndexedImage;
 
 /**
- * Converts an IndexedImage back into standard ImageData.
+ * Resamples an IndexedImage by a specific factor using nearest neighbor
+ * Factor > 1 upscales, Factor < 1 downscales.
  */
-declare function indexedImageToImageData(indexedImage: IndexedImage): ImageData;
+declare function resampleIndexedImage(source: IndexedImage, factor: number): IndexedImage;
 
 /**
  * A convenience wrapper that extracts the first {@link File} from an
@@ -1072,11 +1300,13 @@ declare function fileToImageData(file: File | null | undefined): Promise<ImageDa
  */
 declare function getSupportedPixelFormats(rasterMimes?: string[]): Promise<string[]>;
 
+declare function applyBinaryMaskToAlphaMask(alphaMaskDst: AlphaMask, dstWidth: number, binaryMaskSrc: BinaryMask, srcWidth: number, opts?: ApplyMaskToPixelDataOptions): void;
+
 /**
  * Creates a new copy of a mask.
  * Uses the underlying buffer's slice method for high-performance memory copying.
  */
-declare function copyMask<T extends AnyMask>(src: T): T;
+declare function copyMask<T extends Uint8Array>(src: T): T;
 
 /**
  * Extracts a rectangular region from a 1D {@link Uint8Array} mask.
@@ -1110,135 +1340,59 @@ declare function invertBinaryMask(dst: BinaryMask): void;
 declare function invertAlphaMask(dst: AlphaMask): void;
 
 /**
- * Merges a source mask into a destination AlphaMask.
+ * Merges 2 alpha masks values are 0-255
  */
-declare function mergeMasks(dst: AlphaMask, dstWidth: number, src: AnyMask, opts: ApplyMaskOptions): void;
+declare function mergeAlphaMasks(dst: AlphaMask, dstWidth: number, src: AlphaMask, srcWidth: number, opts: MergeAlphaMasksOptions): void;
 
-/**
- * Applies a circular brush to pixel data, blending a color with optional falloff.
- *
- * @param target The PixelData to modify.
- * @param color The brush color.
- * @param centerX The center x-coordinate of the brush.
- * @param centerY The center y-coordinate of the brush.
- * @param brushSize The diameter of the brush.
- * @param alpha The overall opacity of the brush (0-255).
- * @default 255
- * @param fallOff A function that returns an alpha multiplier (0-1) based on the normalized distance (0-1) from the circle's center.
- * @param blendFn
- * @param bounds precalculated result from {@link getCircleBrushBounds}
- * @default sourceOverPerfect
- */
-declare function applyCircleBrushToPixelData(target: PixelData, color: Color32, centerX: number, centerY: number, brushSize: number, alpha?: number, fallOff?: (dist: number) => number, blendFn?: BlendColor32, bounds?: Rect): void;
-declare function getCircleBrushBounds(centerX: number, centerY: number, brushSize: number, targetWidth?: number, targetHeight?: number, out?: Rect): Rect;
+declare function mergeBinaryMasks(dst: BinaryMask, dstWidth: number, src: BinaryMask, srcWidth: number, opts: MergeAlphaMasksOptions): void;
 
-/**
- * Directly applies a mask to a region of PixelData,
- * modifying the destination's alpha channel in-place.
- */
-declare function applyMaskToPixelData(dst: PixelData, mask: AnyMask, opts?: ApplyMaskOptions): void;
+declare function blendPixelDataAlphaMask(dst: IPixelData, src: IPixelData, alphaMask: AlphaMask, opts?: PixelBlendMaskOptions): void;
 
-/**
- * Applies a rectangular brush to pixel data, blending a color with optional falloff.
- *
- * @param target The PixelData to modify.
- * @param color The brush color.
- * @param centerX The center x-coordinate of the brush.
- * @param centerY The center y-coordinate of the brush.
- * @param brushWidth
- * @param brushHeight
- * @param alpha The overall opacity of the brush (0-255).
- * @default 255
- * @param fallOff A function that returns an alpha multiplier (0-1) based on the normalized distance (0-1) from the circle's center.
- * @param blendFn
- * @param bounds precalculated result from {@link getRectBrushBounds}
- * @default sourceOverPerfect
- */
-declare function applyRectBrushToPixelData(target: PixelData, color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, fallOff?: (dist: number) => number, blendFn?: BlendColor32, bounds?: Rect): void;
-declare function getRectBrushBounds(centerX: number, centerY: number, brushWidth: number, brushHeight: number, targetWidth?: number, targetHeight?: number, out?: Rect): Rect;
-
-/**
- * Fills a rectangle in the destination PixelData with a single color,
- * supporting blend modes, global alpha, and masking.
- */
-declare function blendColorPixelData(dst: PixelData, color: Color32, opts?: ColorBlendOptions): 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(dst: PixelData, src: PixelData, opts: PixelBlendOptions): void;
+declare function blendPixelDataBinaryMask(dst: IPixelData, src: IPixelData, binaryMask: BinaryMask, opts: PixelBlendMaskOptions): void;
 
 /**
  * Clears a region of the PixelData to transparent (0x00000000).
  * Internally uses the optimized fillPixelData.
  */
-declare function clearPixelData(dst: PixelData, rect?: Partial<Rect>): void;
+declare function clearPixelData(dst: IPixelData, rect?: Partial<Rect>): void;
 
 /**
  * High-level extraction that returns a new PixelData instance.
  * Leverages extractPixelDataBuffer for optimized 32-bit memory moves.
  */
-declare function extractPixelData(source: PixelData, rect: Rect): PixelData;
-declare function extractPixelData(source: PixelData, x: number, y: number, w: number, h: number): PixelData;
+declare function extractPixelData(source: IPixelData, rect: Rect): PixelData;
+declare function extractPixelData(source: IPixelData, 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: PixelData, rect: Rect): Uint32Array;
-declare function extractPixelDataBuffer(source: PixelData, x: number, y: number, w: number, h: number): Uint32Array;
+declare function extractPixelDataBuffer(source: IPixelData, rect: Rect): Uint32Array;
+declare function extractPixelDataBuffer(source: IPixelData, x: number, y: number, w: number, h: number): Uint32Array;
 
-/**
- * Fills a region or the {@link PixelData} buffer with a solid color.
- *
- * @param dst - The target {@link PixelData} to modify.
- * @param color - The {@link Color32} value to apply.
- * @param rect - A {@link Rect} defining the area to fill. If omitted, the entire
- * buffer is filled.
- */
-declare function fillPixelData(dst: PixelData, color: Color32, rect?: Partial<Rect>): void;
-/**
- * @param dst - The target {@link PixelData} to modify.
- * @param color - The {@link Color32} value to apply.
- * @param x - Starting horizontal coordinate.
- * @param y - Starting vertical coordinate.
- * @param w - Width of the fill area.
- * @param h - Height of the fill area.
- */
-declare function fillPixelData(dst: PixelData, color: Color32, x: number, y: number, w: number, h: number): void;
-
-declare function invertPixelData(pixelData: PixelData, opts?: PixelMutateOptions): void;
+declare class PixelBuffer32 implements IPixelData {
+    readonly width: number;
+    readonly height: number;
+    readonly data32: Uint32Array;
+    constructor(width: number, height: number, data32?: Uint32Array);
+    set(width: number, height: number, data32?: Uint32Array): void;
+    copy(): PixelBuffer32;
+}
 
 /**
  * Extracts the alpha channel from PixelData into a single-channel mask.
  * Returns a Uint8Array branded as AlphaMask.
  */
-declare function pixelDataToAlphaMask(pixelData: PixelData): AlphaMask;
-
-declare function reflectPixelDataHorizontal(pixelData: PixelData): void;
-declare function reflectPixelDataVertical(pixelData: PixelData): void;
+declare function pixelDataToAlphaMask(pixelData: IPixelData): AlphaMask;
 
-/**
- * Resamples an PixelData by a specific factor using nearest neighbor
- * Factor > 1 upscales, Factor < 1 downscales.
- */
+declare function reflectPixelDataHorizontal(pixelData: IPixelData): void;
+declare function reflectPixelDataVertical(pixelData: IPixelData): void;
 
 /**
  * Resamples PixelData by a specific factor using nearest neighbor.
  * Factor > 1 upscales, Factor < 1 downscales.
  */
-declare function resamplePixelData(pixelData: PixelData, factor: number): PixelData;
+declare function resamplePixelData(pixelData: IPixelData, factor: number): PixelData;
 
 /**
  * Rotates pixel data 90 degrees clockwise.
@@ -1253,8 +1407,8 @@ declare function rotatePixelData(pixelData: PixelData): void;
  * This function performs a direct memory copy from a {@link Uint32Array}
  * into the target {@link PixelData} buffer.
  */
-declare function writePixelDataBuffer(target: PixelData, data: Uint32Array, rect: Rect): void;
-declare function writePixelDataBuffer(target: PixelData, data: Uint32Array, x: number, y: number, w: number, h: number): void;
+declare function writePixelDataBuffer(target: IPixelData, data: Uint32Array, rect: Rect): void;
+declare function writePixelDataBuffer(target: IPixelData, data: Uint32Array, x: number, y: number, w: number, h: number): void;
 
 /**
  * Intersects a target rectangle with a boundary, trimming dimensions and masks in-place.
@@ -1272,4 +1426,4 @@ declare function writePixelDataBuffer(target: PixelData, data: Uint32Array, x: n
  */
 declare function trimRectBounds<T extends Rect | SelectionRect>(target: T, bounds: Rect): void;
 
-export { type AlphaMask, type AnyMask, type ApplyMaskOptions, BASE_FAST_BLEND_MODE_FUNCTIONS, BASE_PERFECT_BLEND_MODE_FUNCTIONS, type Base64EncodedUInt8Array, BaseBlendMode, type BaseBlendModes, type BinaryMask, type BlendColor32, type BlendModeRegistry, type Color32, type ColorBlendOptions, type FloodFillImageDataOptions, type FloodFillResult, type HistoryAction, HistoryManager, type ImageDataLike, IndexedImage, MaskType, PixelAccumulator, type PixelBlendOptions, type PixelCanvas, PixelData, PixelEngineConfig, type PixelMaskInvertOptions, type PixelMaskRectOptions, type PixelMutateOptions, type PixelOptions, type PixelPatchTiles, type PixelRectOptions, PixelTile, PixelWriter, type PixelWriterOptions, type Point, type RGBA, type Rect, type RequiredBlendModes, type ReusableCanvas, type ReusableImageData, type SelectionRect, type SerializedImageData, UnsupportedFormatError, applyCircleBrushToPixelData, applyMaskToPixelData, applyPatchTiles, applyRectBrushToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendPixelData, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataBuffer, extractMask, extractPixelData, extractPixelDataBuffer, fileInputChangeToImageData, fileToImageData, fillPixelData, floodFillSelection, getCircleBrushBounds, getImageDataFromClipboard, getIndexedImageColorCounts, getRectBrushBounds, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMask, imageDataToDataUrl, imageDataToImgBlob, imageDataToUInt32Array, imgBlobToImageData, indexedImageToAverageColor, indexedImageToImageData, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeBlendModeRegistry, makeFastBlendModeRegistry, makeFullPixelMutator, makePerfectBlendModeRegistry, makePixelCanvas, makeReusableCanvas, makeReusableImageData, mergeMasks, multiplyFast, multiplyPerfect, mutatorApplyMask, mutatorBlendColor, mutatorBlendPixel, mutatorBlendPixelData, mutatorFill, mutatorInvert, overlayFast, overlayPerfect, overwriteBase, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resampleImageData, resampleIndexedImage, resamplePixelData, resizeImageData, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractFast, subtractPerfect, trimRectBounds, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageData, writeImageDataBuffer, writeImageDataToClipboard, writeImgBlobToClipboard, writePixelDataBuffer };
+export { type Alpha, type AlphaMask, type AnyMask, type ApplyMaskToPixelDataOptions, BASE_FAST_BLEND_MODE_FUNCTIONS, BASE_PERFECT_BLEND_MODE_FUNCTIONS, type Base64EncodedUInt8Array, BaseBlendMode, type BaseBlendModes, type BasePixelBlendOptions, type BinaryMask, type BlendColor32, type BlendModeRegistry, CANVAS_CTX_FAILED, type Color32, type ColorBlendMaskOptions, type ColorBlendOptions, type FloodFillImageDataOptions, type FloodFillResult, type HistoryAction, HistoryManager, type HistoryMutator, type IPixelData, type ImageDataLike, type ImageDataLikeConstructor, IndexedImage, type InvertMask, type MaskOffset, type MaskOffsetWidth, MaskType, type MergeAlphaMasksOptions, OFFSCREEN_CANVAS_CTX_FAILED, PixelAccumulator, type PixelBlendMaskOptions, type PixelBlendOptions, PixelBuffer32, type PixelCanvas, PixelData, PixelEngineConfig, type PixelMutateOptions, type PixelPatchTiles, type PixelRect, PixelTile, PixelWriter, type PixelWriterOptions, type RGBA, type Rect, type RequiredBlendModes, type ReusableCanvas, type ReusableImageData, type SelectionRect, type SerializedImageData, UnsupportedFormatError, applyAlphaMaskToPixelData, applyBinaryMaskToAlphaMask, applyBinaryMaskToPixelData, applyCircleBrushToPixelData, applyPatchTiles, applyRectBrushToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendColorPixelDataAlphaMask, blendColorPixelDataBinaryMask, blendPixelData, blendPixelDataAlphaMask, blendPixelDataBinaryMask, clearPixelData, 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, extractPixelData, extractPixelDataBuffer, fileInputChangeToImageData, fileToImageData, fillPixelData, floodFillSelection, forEachLinePoint, getCircleBrushOrPencilBounds, getCircleBrushOrPencilStrokeBounds, getImageDataFromClipboard, getIndexedImageColorCounts, getRectBrushOrPencilBounds, getRectBrushOrPencilStrokeBounds, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMask, imageDataToDataUrl, imageDataToImgBlob, imageDataToUInt32Array, imgBlobToImageData, indexedImageToAverageColor, indexedImageToImageData, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeBlendModeRegistry, makeFastBlendModeRegistry, makeFullPixelMutator, makeImageDataLike, makePerfectBlendModeRegistry, makePixelCanvas, makeReusableCanvas, makeReusableImageData, mergeAlphaMasks, mergeBinaryMasks, multiplyFast, multiplyPerfect, mutatorApplyAlphaMask, mutatorApplyBinaryMask, mutatorApplyCircleBrush, mutatorApplyCircleBrushStroke, mutatorApplyCirclePencil, mutatorApplyCirclePencilStroke, mutatorApplyRectBrush, mutatorApplyRectBrushStroke, mutatorApplyRectPencil, mutatorApplyRectPencilStroke, mutatorBlendColor, mutatorBlendPixel, mutatorBlendPixelData, mutatorClear, mutatorFill, mutatorInvert, overlayFast, overlayPerfect, overwriteBase, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resampleImageData, resampleIndexedImage, resamplePixelData, resizeImageData, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractFast, subtractPerfect, toBlendModeIndexAndName, trimRectBounds, uInt32ArrayToImageData, uInt32ArrayToImageDataLike, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageData, writeImageDataBuffer, writeImageDataToClipboard, writeImgBlobToClipboard, writePixelDataBuffer };