pixel-data-js 0.25.2 → 0.26.0

package/dist/index.prod.d.ts

@@ -57,18 +57,19 @@ declare enum MaskType {
      */
     BINARY = 1
 }
-interface Mask {
+interface BaseMask {
     readonly type: MaskType;
     readonly data: Uint8Array;
     readonly w: number;
     readonly h: number;
 }
+type Mask = BinaryMask | AlphaMask;
 /** Strictly 0 or 1 */
-interface BinaryMask extends Mask {
+interface BinaryMask extends BaseMask {
     readonly type: MaskType.BINARY;
 }
 /** Strictly 0-255 */
-interface AlphaMask extends Mask {
+interface AlphaMask extends BaseMask {
     readonly type: MaskType.ALPHA;
 }
 interface BasePaintMask {
@@ -176,6 +177,8 @@ interface ColorBlendOptions extends PixelRect, Alpha {
 }
 interface ColorBlendMaskOptions extends ColorBlendOptions, MaskOffset, InvertMask {
 }
+interface ColorBlendPaintMaskOptions extends Omit<ColorBlendOptions, 'w' | 'h'> {
+}
 type MaskRect<T extends MaskType> = Rect & {
     type: T;
     data: Uint8Array;
@@ -196,7 +199,6 @@ type NullableMaskRect = Rect & ({
     type?: null;
     data?: null;
 });
-type HistoryMutator<T extends {}, D extends {}> = (writer: PixelWriter<any>, deps?: Partial<D>) => T;
 interface IPixelData32 {
     readonly data32: Uint32Array;
     readonly width: number;
@@ -206,47 +208,6 @@ interface IPixelData<T extends ImageDataLike = ImageData> extends IPixelData32 {
     readonly imageData: T;
 }
 
-/**
- * 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 class PixelData<T extends ImageDataLike = ImageData> implements IPixelData<T> {
     readonly data32: Uint32Array;
     readonly imageData: T;
@@ -256,15 +217,9 @@ declare class PixelData<T extends ImageDataLike = ImageData> implements IPixelDa
     set(imageData: T): void;
 }
 
-type FloodFillImageDataOptions = {
-    contiguous?: boolean;
-    tolerance?: number;
-    bounds?: Rect;
-};
-type FloodFillResult = {
+type FloodFillResult = BinaryMaskRect & {
     startX: number;
     startY: number;
-    selectionRect: BinaryMaskRect;
     pixels: Uint8ClampedArray;
 };
 /**
@@ -273,16 +228,15 @@ type FloodFillResult = {
  * color tolerance. It can operate in "contiguous" mode (classic bucket fill) or
  * "non-contiguous" mode (selects all matching pixels in the buffer).
  *
- * @param img - The source image data to process.
+ * @param target - The source image data to process.
  * @param startX - The starting horizontal coordinate.
  * @param startY - The starting vertical coordinate.
- * @param options - Configuration for the fill operation.
- * @param options.contiguous - If true, only connected pixels are
+ * @param contiguous - If true, only connected pixels are
  * selected. If false, all pixels within tolerance are selected regardless of position.
- * @param options.tolerance - The maximum allowed difference in color
+ * @param tolerance - The maximum allowed difference in color
  * distance (0-255) for a pixel to be included.
- * @param options.bounds - Optional bounding box to restrict the search area.
- *
+ * @param bounds - Optional bounding box to restrict the search area.
+ * @param out output object
  * @returns A {@link FloodFillResult} containing the mask and bounds of the selection,
  * or `null` if the starting coordinates are out of bounds.
  *
@@ -299,7 +253,7 @@ type FloodFillResult = {
  * );
  * ```
  */
-declare function floodFillSelection(img: ImageDataLike | PixelData, startX: number, startY: number, { contiguous, tolerance, bounds, }?: FloodFillImageDataOptions): FloodFillResult | null;
+declare function floodFillSelection(target: PixelData, startX: number, startY: number, contiguous?: boolean, tolerance?: number, bounds?: Rect, out?: FloodFillResult): FloodFillResult | null;
 
 /**
  * Iterates through a line with sub-pixel precision.
@@ -307,6 +261,50 @@ declare function floodFillSelection(img: ImageDataLike | PixelData, startX: numb
  */
 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 const overwriteFast: BlendColor32;
 declare const sourceOverFast: BlendColor32;
 declare const darkenFast: BlendColor32;
@@ -473,77 +471,11 @@ declare function makePerfectBlendModeRegistry(name?: string): {
     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";
-
-declare const CANVAS_COMPOSITE_MAP: {
-    readonly 0: "copy";
-    readonly 1: "source-over";
-    readonly 2: "darken";
-    readonly 3: "multiply";
-    readonly 4: "color-burn";
-    readonly 7: "lighten";
-    readonly 8: "screen";
-    readonly 9: "color-dodge";
-    readonly 10: "lighter";
-    readonly 12: "overlay";
-    readonly 13: "soft-light";
-    readonly 14: "hard-light";
-    readonly 19: "difference";
-    readonly 20: "exclusion";
-};
-type CanvasBlendModeIndex = keyof typeof CANVAS_COMPOSITE_MAP;
-type CanvasCompositeOperation = typeof CANVAS_COMPOSITE_MAP[CanvasBlendModeIndex];
-
 type PixelCanvas = {
     readonly canvas: HTMLCanvasElement;
     readonly ctx: CanvasRenderingContext2D;
@@ -586,14 +518,33 @@ declare function makeReusableOffscreenCanvas(): {
 type DrawPixelLayer = (ctx: CanvasRenderingContext2D) => void;
 type DrawScreenLayer = (ctx: CanvasRenderingContext2D, scale: number) => void;
 type CanvasFrameRenderer = ReturnType<typeof makeCanvasFrameRenderer>;
-declare const defaults$c: {
+declare const defaults$h: {
     makeReusableCanvas: typeof makeReusableCanvas;
 };
-type Deps$c = Partial<typeof defaults$c>;
+type Deps$h = Partial<typeof defaults$h>;
 /**
  * @param deps - @hidden
  */
-declare function makeCanvasFrameRenderer(deps?: Deps$c): (pixelCanvas: PixelCanvas, scale: number, getImageData: () => ImageData | undefined | null, drawPixelLayer?: DrawPixelLayer, drawScreenLayer?: DrawScreenLayer) => void;
+declare function makeCanvasFrameRenderer(deps?: Deps$h): (pixelCanvas: PixelCanvas, scale: number, getImageData: () => ImageData | undefined | null, drawPixelLayer?: DrawPixelLayer, drawScreenLayer?: DrawScreenLayer) => void;
+
+declare const CANVAS_COMPOSITE_MAP: {
+    readonly 0: "copy";
+    readonly 1: "source-over";
+    readonly 2: "darken";
+    readonly 3: "multiply";
+    readonly 4: "color-burn";
+    readonly 7: "lighten";
+    readonly 8: "screen";
+    readonly 9: "color-dodge";
+    readonly 10: "lighter";
+    readonly 12: "overlay";
+    readonly 13: "soft-light";
+    readonly 14: "hard-light";
+    readonly 19: "difference";
+    readonly 20: "exclusion";
+};
+type CanvasBlendModeIndex = keyof typeof CANVAS_COMPOSITE_MAP;
+type CanvasCompositeOperation = typeof CANVAS_COMPOSITE_MAP[CanvasBlendModeIndex];
 
 /**
  * Extracts {@link ImageData} from a clipboard event if an image is present.
@@ -656,12 +607,83 @@ declare class PixelTile implements IPixelData {
     constructor(id: number, tx: number, ty: number, tileSize: number, tileArea: number);
 }
 
+declare class PixelEngineConfig {
+    readonly tileSize: number;
+    readonly tileShift: number;
+    readonly tileMask: number;
+    readonly tileArea: number;
+    readonly target: PixelData;
+    readonly targetColumns: number;
+    readonly targetRows: number;
+    constructor(tileSize: number, target: PixelData);
+}
+
+declare class PixelTilePool {
+    pool: PixelTile[];
+    private tileSize;
+    private tileArea;
+    constructor(config: PixelEngineConfig);
+    getTile(id: number, tx: number, ty: number): PixelTile;
+    releaseTile(tile: PixelTile): void;
+    releaseTiles(tiles: (PixelTile | undefined)[]): void;
+}
+
 type PixelPatchTiles = {
     beforeTiles: PixelTile[];
     afterTiles: PixelTile[];
 };
 declare function applyPatchTiles(target: IPixelData32, tiles: PixelTile[], tileSize: number): void;
 
+type DidChangeFn = (didChange: boolean) => boolean;
+declare class PixelAccumulator {
+    readonly config: PixelEngineConfig;
+    readonly tilePool: PixelTilePool;
+    lookup: (PixelTile | undefined)[];
+    beforeTiles: PixelTile[];
+    constructor(config: PixelEngineConfig, tilePool: PixelTilePool);
+    recyclePatch(patch: PixelPatchTiles): void;
+    /**
+     * @param x pixel x coordinate
+     * @param y pixel y coordinate
+     */
+    storePixelBeforeState(x: number, y: number): DidChangeFn;
+    /**
+     * @param x pixel x coordinate
+     * @param y pixel y coordinate
+     * @param w pixel width
+     * @param h pixel height
+     */
+    storeRegionBeforeState(x: number, y: number, w: number, h: number): DidChangeFn;
+    storeTileBeforeState(id: number, tx: number, ty: number): DidChangeFn;
+    extractState(tile: PixelTile): void;
+    extractPatch(): PixelPatchTiles;
+    rollbackAfterError(): void;
+}
+
+interface HistoryAction {
+    undo: () => void;
+    redo: () => void;
+    dispose?: () => void;
+}
+type HistoryActionFactory = typeof makeHistoryAction;
+declare function makeHistoryAction(config: PixelEngineConfig, accumulator: PixelAccumulator, patch: PixelPatchTiles, after?: () => void, afterUndo?: () => void, afterRedo?: () => void, applyPatchTilesFn?: typeof applyPatchTiles): HistoryAction;
+
+declare class HistoryManager {
+    maxSteps: number;
+    readonly undoStack: HistoryAction[];
+    readonly redoStack: HistoryAction[];
+    readonly 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;
+}
+
 /**
  * Non destructively resizes the {@link ImageData} buffer to new dimensions, optionally
  * offsetting the original content.
@@ -693,27 +715,6 @@ declare function applyPatchTiles(target: IPixelData32, tiles: PixelTile[], tileS
  */
 declare function resizeImageData(target: ImageDataLike, newWidth: number, newHeight: number, offsetX?: number, offsetY?: number): ImageData;
 
-declare class PixelEngineConfig {
-    readonly tileSize: number;
-    readonly tileShift: number;
-    readonly tileMask: number;
-    readonly tileArea: number;
-    readonly target: PixelData;
-    readonly targetColumns: number;
-    readonly targetRows: number;
-    constructor(tileSize: number, target: PixelData);
-}
-
-declare class PixelTilePool {
-    pool: PixelTile[];
-    private tileSize;
-    private tileArea;
-    constructor(config: PixelEngineConfig);
-    getTile(id: number, tx: number, ty: number): PixelTile;
-    releaseTile(tile: PixelTile): void;
-    releaseTiles(tiles: (PixelTile | undefined)[]): void;
-}
-
 declare class PaintBuffer {
     readonly config: PixelEngineConfig;
     readonly tilePool: PixelTilePool;
@@ -739,51 +740,9 @@ declare class PaintBuffer {
  *   blendFn: COLOR_32_BLEND_MODES.multiply,
  *   mask: brushMask,
  *   maskType: MaskType.ALPHA
- * });
- */
-declare function blendPixelData(dst: IPixelData32, src: IPixelData32, opts?: PixelBlendOptions): boolean;
-
-declare class HistoryManager {
-    maxSteps: number;
-    readonly undoStack: HistoryAction[];
-    readonly redoStack: HistoryAction[];
-    readonly 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;
-}
-
-type DidChangeFn = (didChange: boolean) => boolean;
-declare class PixelAccumulator {
-    readonly config: PixelEngineConfig;
-    readonly tilePool: PixelTilePool;
-    lookup: (PixelTile | undefined)[];
-    beforeTiles: PixelTile[];
-    constructor(config: PixelEngineConfig, tilePool: PixelTilePool);
-    recyclePatch(patch: PixelPatchTiles): void;
-    /**
-     * @param x pixel x coordinate
-     * @param y pixel y coordinate
-     */
-    storePixelBeforeState(x: number, y: number): DidChangeFn;
-    /**
-     * @param x pixel x coordinate
-     * @param y pixel y coordinate
-     * @param w pixel width
-     * @param h pixel height
-     */
-    storeRegionBeforeState(x: number, y: number, w: number, h: number): DidChangeFn;
-    storeTileBeforeState(id: number, tx: number, ty: number): DidChangeFn;
-    extractState(tile: PixelTile): void;
-    extractPatch(): PixelPatchTiles;
-    rollbackAfterError(): void;
-}
+ * });
+ */
+declare function blendPixelData(target: IPixelData32, src: IPixelData32, opts?: PixelBlendOptions): boolean;
 
 interface PixelWriterOptions {
     maxHistorySteps?: number;
@@ -824,7 +783,7 @@ declare class PixelWriter<M> {
     readonly mutator: M;
     private blendPixelDataOpts;
     private _inProgress;
-    constructor(target: PixelData, mutatorFactory: (writer: PixelWriter<any>) => M, { tileSize, maxHistorySteps, historyManager, historyActionFactory, pixelTilePool, accumulator, }?: PixelWriterOptions);
+    constructor(target: PixelData, mutatorFactory: (writer: PixelWriter<any>) => M, options?: PixelWriterOptions);
     /**
      * Executes `transaction` and commits the resulting pixel changes as a single
      * undoable history action.
@@ -844,26 +803,27 @@ declare class PixelWriter<M> {
     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;
 }
-
-interface HistoryAction {
-    undo: () => void;
-    redo: () => void;
-    dispose?: () => void;
-}
-type HistoryActionFactory = typeof makeHistoryAction;
-declare function makeHistoryAction(writer: PixelWriter<any>, patch: PixelPatchTiles, after?: () => void, afterUndo?: () => void, afterRedo?: () => void, applyPatchTilesFn?: typeof applyPatchTiles): HistoryAction;
+type HistoryMutator<T extends {}, D extends {}> = (writer: PixelWriter<any>, deps?: Partial<D>) => T;
 
 declare function makeFullPixelMutator(writer: PixelWriter<any>): {
     invert(opts?: PixelMutateOptions): boolean;
     fillRect(color: Color32, rect: Rect): boolean;
-    fillBinaryMask(color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): boolean;
+    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>): void;
-    blendPixelDataBinaryMask(src: IPixelData32, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
-    blendPixelDataAlphaMask(src: IPixelData32, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+    clear(rect?: Partial<Rect>): boolean;
     blendPixelData(src: IPixelData32, opts?: PixelBlendOptions): boolean;
     blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
+    blendPaintRect(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): boolean;
+    blendMask(src: IPixelData32, mask: Mask, opts?: PixelBlendMaskOptions): 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;
+    applyMask(mask: Mask, opts?: ApplyMaskToPixelDataOptions): boolean;
+    applyBinaryMask(mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
+    applyAlphaMask(mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 };
 
 /**
@@ -871,16 +831,16 @@ 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(dst: IPixelData32, mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
+declare function applyAlphaMaskToPixelData(target: IPixelData32, mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 
-declare const defaults$b: {
+declare const defaults$g: {
     applyAlphaMaskToPixelData: typeof applyAlphaMaskToPixelData;
 };
-type Deps$b = Partial<typeof defaults$b>;
+type Deps$g = Partial<typeof defaults$g>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$b) => {
+declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$g) => {
     applyAlphaMask(mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 };
 
@@ -889,33 +849,71 @@ declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$b) =
  * modifying the destination's alpha channel in-place.
  * @returns true if any pixels were actually modified.
  */
-declare function applyBinaryMaskToPixelData(dst: IPixelData32, mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
+declare function applyBinaryMaskToPixelData(target: IPixelData32, mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 
-declare const defaults$a: {
+declare const defaults$f: {
     applyBinaryMaskToPixelData: typeof applyBinaryMaskToPixelData;
 };
-type Deps$a = Partial<typeof defaults$a>;
+type Deps$f = Partial<typeof defaults$f>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyBinaryMask: (writer: PixelWriter<any>, deps?: Deps$a) => {
+declare const mutatorApplyBinaryMask: (writer: PixelWriter<any>, deps?: Deps$f) => {
     applyBinaryMask(mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 };
 
+declare const defaults$e: {
+    applyBinaryMaskToPixelData: typeof applyBinaryMaskToPixelData;
+    applyAlphaMaskToPixelData: typeof applyAlphaMaskToPixelData;
+};
+type Deps$e = Partial<typeof defaults$e>;
+/**
+ * @param deps - @hidden
+ */
+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 const defaults$d: {
+    blendPixelDataAlphaMask: typeof blendPixelDataAlphaMask;
+};
+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;
+};
+
+declare function blendPixelDataBinaryMask(target: IPixelData32, src: IPixelData32, binaryMask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
+
+declare const defaults$c: {
+    blendPixelDataBinaryMask: typeof blendPixelDataBinaryMask;
+};
+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;
+};
+
 /**
  * Blends a solid color into a target pixel buffer.
  * @returns true if any pixels were actually modified.
  */
-declare function blendColorPixelData(dst: IPixelData32, color: Color32, opts?: ColorBlendOptions): boolean;
+declare function blendColorPixelData(target: IPixelData32, color: Color32, opts?: ColorBlendOptions): boolean;
 
-declare const defaults$9: {
+declare const defaults$b: {
     blendColorPixelData: typeof blendColorPixelData;
 };
-type Deps$9 = Partial<typeof defaults$9>;
+type Deps$b = Partial<typeof defaults$b>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$9) => {
+declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$b) => {
     blendColor(color: Color32, opts?: ColorBlendOptions): boolean;
 };
 
@@ -926,13 +924,24 @@ declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$9) => {
  * 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 dst - The destination {@link IPixelData32} buffer to modify.
+ * @param target - The destination {@link IPixelData32} 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(dst: IPixelData32, color: Color32, mask: AlphaMask, opts?: ColorBlendMaskOptions): boolean;
+declare function blendColorPixelDataAlphaMask(target: IPixelData32, color: Color32, mask: AlphaMask, opts?: ColorBlendMaskOptions): boolean;
+
+declare const defaults$a: {
+    blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
+};
+type Deps$a = Partial<typeof defaults$a>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorBlendColorPaintAlphaMask: (writer: PixelWriter<any>, deps?: Partial<Deps$a>) => {
+    blendColorPaintAlphaMask(color: Color32, mask: PaintAlphaMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
+};
 
 /**
  * Blends a solid color into a target pixel buffer using a binary mask.
@@ -941,13 +950,24 @@ declare function blendColorPixelDataAlphaMask(dst: IPixelData32, color: Color32,
  * 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 dst - The destination {@link IPixelData32} buffer to modify.
+ * @param target - The destination {@link IPixelData32} 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(dst: IPixelData32, color: Color32, mask: BinaryMask, opts?: ColorBlendMaskOptions): boolean;
+declare function blendColorPixelDataBinaryMask(target: IPixelData32, color: Color32, mask: BinaryMask, opts?: ColorBlendMaskOptions): boolean;
+
+declare const defaults$9: {
+    blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
+};
+type Deps$9 = Partial<typeof defaults$9>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorBlendColorPaintBinaryMask: (writer: PixelWriter<any>, deps?: Partial<Deps$9>) => {
+    blendColorPaintBinaryMask(color: Color32, mask: PaintBinaryMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
+};
 
 declare const defaults$8: {
     blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
@@ -957,71 +977,66 @@ type Deps$8 = Partial<typeof defaults$8>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorBlendPaintMask: (writer: PixelWriter<any>, deps?: Partial<Deps$8>) => {
+declare const mutatorBlendColorPaintMask: (writer: PixelWriter<any>, deps?: Partial<Deps$8>) => {
     blendColorPaintMask(color: Color32, mask: PaintMask, x: number, y: number, alpha?: number, blendFn?: BlendColor32): boolean;
 };
 
-declare function blendPixel(target: IPixelData32, x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
-
 declare const defaults$7: {
-    blendPixel: typeof blendPixel;
+    blendPixelDataAlphaMask: typeof blendPixelDataAlphaMask;
+    blendPixelDataBinaryMask: typeof blendPixelDataBinaryMask;
 };
 type Deps$7 = Partial<typeof defaults$7>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorBlendPixel: (writer: PixelWriter<any>, deps?: Partial<Deps$7>) => {
-    blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
+declare const mutatorBlendMask: (writer: PixelWriter<any>, deps?: Partial<Deps$7>) => {
+    blendMask(src: IPixelData32, mask: Mask, opts?: PixelBlendMaskOptions): boolean;
 };
 
 declare const defaults$6: {
-    blendPixelData: typeof blendPixelData;
+    blendColorPixelData: typeof blendColorPixelData;
 };
 type Deps$6 = Partial<typeof defaults$6>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorBlendPixelData: (writer: PixelWriter<any>, deps?: Partial<Deps$6>) => {
-    blendPixelData(src: IPixelData32, opts?: PixelBlendOptions): boolean;
+declare const mutatorBlendPaintRect: (writer: PixelWriter<any>, deps?: Deps$6) => {
+    blendPaintRect(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): boolean;
 };
 
-declare function blendPixelDataAlphaMask(dst: IPixelData32, src: IPixelData32, alphaMask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+declare function blendPixel(target: IPixelData32, x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
 
 declare const defaults$5: {
-    blendPixelDataAlphaMask: typeof blendPixelDataAlphaMask;
+    blendPixel: typeof blendPixel;
 };
 type Deps$5 = Partial<typeof defaults$5>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorBlendPixelDataAlphaMask: (writer: PixelWriter<any>, deps?: Partial<Deps$5>) => {
-    blendPixelDataAlphaMask(src: IPixelData32, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+declare const mutatorBlendPixel: (writer: PixelWriter<any>, deps?: Partial<Deps$5>) => {
+    blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
 };
 
-declare function blendPixelDataBinaryMask(dst: IPixelData32, src: IPixelData32, binaryMask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
-
 declare const defaults$4: {
-    blendPixelDataBinaryMask: typeof blendPixelDataBinaryMask;
+    blendPixelData: typeof blendPixelData;
 };
 type Deps$4 = Partial<typeof defaults$4>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorBlendPixelDataBinaryMask: (writer: PixelWriter<any>, deps?: Partial<Deps$4>) => {
-    blendPixelDataBinaryMask(src: IPixelData32, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
+declare const mutatorBlendPixelData: (writer: PixelWriter<any>, deps?: Partial<Deps$4>) => {
+    blendPixelData(src: IPixelData32, opts?: PixelBlendOptions): boolean;
 };
 
 /**
  * Fills a region or the {@link IPixelData32} buffer with a solid color.
- * This function is faster than {@link fillPixelData} but does not
- * return a boolean value indicating changes were made.
  *
  * @param dst - The target to modify.
  * @param color - The color to apply.
  * @param rect - Defines the area to fill. If omitted, the entire
- * buffer is filled.
+ * @returns true if any pixels were actually modified.
  */
-declare function fillPixelDataFast(dst: IPixelData32, color: Color32, rect?: Partial<Rect>): void;
+declare function fillPixelData(dst: IPixelData32, color: Color32, rect?: Partial<Rect>): boolean;
 /**
  * @param dst - The target to modify.
  * @param color - The color to apply.
@@ -1030,38 +1045,19 @@ declare function fillPixelDataFast(dst: IPixelData32, color: Color32, rect?: Par
  * @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 fillPixelData(dst: IPixelData32, color: Color32, x: number, y: number, w: number, h: number): boolean;
 
 declare const defaults$3: {
-    fillPixelData: typeof fillPixelDataFast;
+    fillPixelData: typeof fillPixelData;
 };
 type Deps$3 = Partial<typeof defaults$3>;
 /**
  * @param deps - @hidden
  */
 declare const mutatorClear: (writer: PixelWriter<any>, deps?: Deps$3) => {
-    clear(rect?: Partial<Rect>): void;
+    clear(rect?: Partial<Rect>): boolean;
 };
 
-/**
- * Fills a region or the {@link IPixelData32} 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;
-/**
- * @param dst - The target to modify.
- * @param color - The color 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: IPixelData32, color: Color32, x: number, y: number, w: number, h: number): boolean;
-
 declare const defaults$2: {
     fillPixelData: typeof fillPixelData;
 };
@@ -1081,14 +1077,13 @@ declare const mutatorFillRect: (writer: PixelWriter<any>, deps?: Deps$2) => {
 
 /**
  * Fills a region of the {@link IPixelData32} buffer with a solid color using a mask.
- * @param dst - The target to modify.
+ * @param target - The target to modify.
  * @param color - The color to apply.
  * @param mask - The mask defining the area to fill.
- * @param alpha - The overall opacity of the fill (0-255).
  * @param x - Starting horizontal coordinate for the mask placement.
  * @param y - Starting vertical coordinate for the mask placement.
  */
-declare function fillPixelDataBinaryMask(dst: IPixelData32, color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): boolean;
+declare function fillPixelDataBinaryMask(target: IPixelData32, color: Color32, mask: BinaryMask, x?: number, y?: number): boolean;
 
 declare const defaults$1: {
     fillPixelDataBinaryMask: typeof fillPixelDataBinaryMask;
@@ -1098,10 +1093,10 @@ type Deps$1 = Partial<typeof defaults$1>;
  * @param deps - @hidden
  */
 declare const mutatorFillBinaryMask: (writer: PixelWriter<any>, deps?: Deps$1) => {
-    fillBinaryMask(color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): boolean;
+    fillBinaryMask(color: Color32, mask: BinaryMask, x?: number, y?: number): boolean;
 };
 
-declare function invertPixelData(pixelData: IPixelData32, opts?: PixelMutateOptions): boolean;
+declare function invertPixelData(target: IPixelData32, opts?: PixelMutateOptions): boolean;
 
 declare const defaults: {
     invertPixelData: typeof invertPixelData;
@@ -1114,6 +1109,17 @@ 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;
 
@@ -1138,8 +1144,6 @@ 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.
@@ -1226,15 +1230,6 @@ 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>;
 /**
@@ -1456,6 +1451,49 @@ 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
@@ -1546,13 +1584,44 @@ declare function mergeBinaryMaskRects(current: NullableBinaryMaskRect[], adding:
 
 declare function subtractBinaryMaskRects(current: NullableBinaryMaskRect[], subtracting: NullableBinaryMaskRect[]): NullableBinaryMaskRect[];
 
-declare function blendPixelDataPaintBuffer(paintBuffer: PaintBuffer, target: IPixelData32, alpha?: number, blendFn?: BlendColor32, blendPixelDataFn?: typeof blendPixelData): void;
+type PaintBufferCanvasRenderer = ReturnType<typeof makePaintBufferCanvasRenderer>;
+/**
+ *
+ * @param offscreenCanvasClass - @internal
+ */
+declare function makePaintBufferCanvasRenderer(paintBuffer: PaintBuffer, 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 makeCirclePaintBinaryMask(size: number): PaintBinaryMask;
+
+declare function makePaintBinaryMask(mask: BinaryMask): PaintBinaryMask;
+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;
+
+declare function blendColorPixelDataMask(dst: IPixelData32, 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 blendColorPixelDataPaintBinaryMask(dst: IPixelData32, 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 blendPixelDataMask(target: IPixelData32, src: IPixelData32, mask: Mask, opts?: PixelBlendMaskOptions): boolean;
+
+declare function blendPixelDataPaintBuffer(target: IPixelData32, paintBuffer: PaintBuffer, alpha?: number, blendFn?: BlendColor32, blendPixelDataFn?: typeof blendPixelData): void;
 
 /**
  * Clears a region of the PixelData to transparent (0x00000000).
- * Internally uses the optimized fillPixelData.
+ * Internally uses the optimized fillPixelDataFast.
  */
-declare function clearPixelData(dst: IPixelData32, rect?: Partial<BinaryMaskRect>): void;
+declare function clearPixelDataFast(dst: IPixelData32, rect?: Partial<BinaryMaskRect>): void;
 
 /**
  * High-level extraction that returns a new PixelData instance.
@@ -1568,14 +1637,26 @@ declare function extractPixelData(source: IPixelData32, x: number, y: number, w:
 declare function extractPixelDataBuffer(source: IPixelData32, rect: Rect): Uint32Array;
 declare function extractPixelDataBuffer(source: IPixelData32, x: number, y: number, w: number, h: number): Uint32Array;
 
-declare class PixelBuffer32 implements IPixelData32 {
-    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;
-}
+/**
+ * Fills a region or the {@link IPixelData32} buffer with a solid color.
+ * This function is faster than {@link fillPixelData} but does not
+ * return a boolean value indicating changes were made.
+ *
+ * @param target - The target to modify.
+ * @param color - The color to apply.
+ * @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;
+/**
+ * @param dst - The target to modify.
+ * @param color - The color 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 fillPixelDataFast(dst: IPixelData32, color: Color32, x: number, y: number, w: number, h: number): void;
 
 /**
  * Extracts the alpha channel from PixelData into a single-channel mask.
@@ -1633,23 +1714,45 @@ 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;
 
-declare function makeCirclePaintAlphaMask(size: number, fallOff?: (d: number) => number): PaintAlphaMask;
-
-declare function makeCirclePaintBinaryMask(size: number): PaintBinaryMask;
-
-declare function makePaintBinaryMask(mask: BinaryMask): PaintBinaryMask;
-declare function makePaintAlphaMask(mask: AlphaMask): PaintAlphaMask;
-
-declare function makeRectFalloffPaintAlphaMask(width: number, height: number, fallOff?: (d: number) => number): PaintAlphaMask;
-
-type PaintBufferCanvasRenderer = ReturnType<typeof makePaintBufferCanvasRenderer>;
 /**
- *
- * @param offscreenCanvasClass - @internal
+ * Packs RGBA into a 32-bit integer compatible with
+ * Little-Endian Uint32Array views on ImageData.
  */
-declare function makePaintBufferCanvasRenderer(paintBuffer: PaintBuffer, offscreenCanvasClass?: {
-    new (width: number, height: number): OffscreenCanvas;
-    prototype: OffscreenCanvas;
-}): (targetCtx: CanvasRenderingContext2D, alpha?: number, compOperation?: GlobalCompositeOperation) => void;
+declare function packColor(r: number, g: number, b: number, a: number): Color32;
+declare function packRGBA({ r, g, b, a }: RGBA): Color32;
+declare const unpackRed: (packed: Color32) => number;
+declare const unpackGreen: (packed: Color32) => number;
+declare const unpackBlue: (packed: Color32) => number;
+declare const unpackAlpha: (packed: Color32) => number;
+declare function unpackColor(packed: Color32): RGBA;
+declare function unpackColorTo(packed: Color32, scratch?: RGBA): RGBA;
+declare function colorDistance(a: Color32, b: Color32): number;
+/**
+ * Linearly interpolates between two 32-bit colors using a floating-point weight.
+ * * This is the preferred method for UI animations or scenarios where high
+ * precision is required. It uses the standard `a + t * (b - a)` formula
+ * for each channel.
+ * @param a - The starting color as a 32-bit integer (AABBGGRR).
+ * @param b - The target color as a 32-bit integer (AABBGGRR).
+ * @param t - The interpolation factor between 0.0 and 1.0.
+ * @returns The interpolated 32-bit color.
+ */
+declare function lerpColor32(a: Color32, b: Color32, t: number): Color32;
+/**
+ * Linearly interpolates between two 32-bit colors using integer fixed-point math.
+ * Highly optimized for image processing and real-time blitting. It processes
+ * channels in parallel using bitmasks (RB and GA pairs).
+ * **Note:** Subject to a 1-bit drift (rounding down) due to fast bit-shift division.
+ * @param src - The source (foreground) color as a 32-bit integer.
+ * @param dst - The destination (background) color as a 32-bit integer.
+ * @param w - The blend weight as a byte value from 0 to 255. Where 0 is 100% dst and 255 is 100% src
+ * @returns The blended 32-bit color.
+ */ declare function lerpColor32Fast(src: Color32, dst: Color32, w: number): Color32;
+declare function color32ToHex(color: Color32): string;
+/**
+ * Converts a 32-bit integer (0xAABBGGRR) to a CSS rgba() string.
+ * Example: 0xFF0000FF -> "rgba(255,0,0,1)"
+ */
+declare function color32ToCssRGBA(color: Color32): string;
 
-export { type AlphaMask, type AlphaMaskRect, type ApplyMaskToPixelDataOptions, BASE_FAST_BLEND_MODE_FUNCTIONS, BASE_PERFECT_BLEND_MODE_FUNCTIONS, type Base64EncodedUInt8Array, BaseBlendMode, type BaseBlendModes, type BasePixelBlendOptions, type BinaryMask, type BinaryMaskRect, type BlendColor32, type BlendModeRegistry, CANVAS_COMPOSITE_MAP, CANVAS_CTX_FAILED, type CanvasBlendModeIndex, type CanvasCompositeOperation, type CanvasContext, type CanvasFrameRenderer, type Color32, type ColorBlendMaskOptions, type ColorBlendOptions, type DidChangeFn, type DrawPixelLayer, type DrawScreenLayer, type FloodFillImageDataOptions, 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, OFFSCREEN_CANVAS_CTX_FAILED, type PaintAlphaMask, type PaintBinaryMask, PaintBuffer, type PaintBufferCanvasRenderer, type PaintMask, PixelAccumulator, type PixelBlendMaskOptions, type PixelBlendOptions, PixelBuffer32, 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, applyPatchTiles, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendColorPixelDataAlphaMask, blendColorPixelDataBinaryMask, blendPixel, blendPixelData, blendPixelDataAlphaMask, blendPixelDataBinaryMask, blendPixelDataPaintBuffer, 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, 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, makeFastBlendModeRegistry, makeFullPixelMutator, makeHistoryAction, makeImageDataLike, makePaintAlphaMask, makePaintBinaryMask, makePaintBufferCanvasRenderer, makePerfectBlendModeRegistry, makePixelCanvas, makeRectFalloffPaintAlphaMask, makeReusableCanvas, makeReusableImageData, makeReusableOffscreenCanvas, merge2BinaryMaskRects, mergeAlphaMasks, mergeBinaryMaskRects, mergeBinaryMasks, multiplyFast, multiplyPerfect, mutatorApplyAlphaMask, mutatorApplyBinaryMask, mutatorBlendColor, mutatorBlendPaintMask, mutatorBlendPixel, mutatorBlendPixelData, mutatorBlendPixelDataAlphaMask, mutatorBlendPixelDataBinaryMask, mutatorClear, mutatorFill, mutatorFillBinaryMask, mutatorFillRect, mutatorInvert, overlayFast, overlayPerfect, overwriteBase, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resampleImageData, resampleIndexedImage, resamplePixelData, resizeImageData, 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, 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, mutatorBlendMask, mutatorBlendPaintRect, 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 };