pixel-data-js 0.24.0 → 0.25.2

package/dist/index.prod.d.ts

@@ -71,16 +71,15 @@ interface BinaryMask extends Mask {
 interface AlphaMask extends Mask {
     readonly type: MaskType.ALPHA;
 }
-interface BaseCircleMask {
-    readonly size: number;
-    readonly radius: number;
-    readonly minOffset: number;
+interface BasePaintMask {
+    readonly centerOffsetX: number;
+    readonly centerOffsetY: number;
 }
-interface CircleAlphaMask extends BaseCircleMask, AlphaMask {
+interface PaintAlphaMask extends BasePaintMask, AlphaMask {
 }
-interface CircleBinaryMask extends BaseCircleMask, BinaryMask {
+interface PaintBinaryMask extends BasePaintMask, BinaryMask {
 }
-type CircleMask = CircleAlphaMask | CircleBinaryMask;
+type PaintMask = PaintAlphaMask | PaintBinaryMask;
 /**
  * Configuration for pixel manipulation operations.
  * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
@@ -177,14 +176,12 @@ interface ColorBlendOptions extends PixelRect, Alpha {
 }
 interface ColorBlendMaskOptions extends ColorBlendOptions, MaskOffset, InvertMask {
 }
-type BinaryMaskRect = Rect & {
-    type: MaskType.BINARY;
-    data: Uint8Array;
-};
-type AlphaMaskRect = Rect & {
-    type: MaskType.ALPHA;
+type MaskRect<T extends MaskType> = Rect & {
+    type: T;
     data: Uint8Array;
 };
+type BinaryMaskRect = MaskRect<MaskType.BINARY>;
+type AlphaMaskRect = MaskRect<MaskType.ALPHA>;
 type NullableBinaryMaskRect = Rect & ({
     type: MaskType.BINARY;
     data: Uint8Array;
@@ -200,11 +197,14 @@ type NullableMaskRect = Rect & ({
     data?: null;
 });
 type HistoryMutator<T extends {}, D extends {}> = (writer: PixelWriter<any>, deps?: Partial<D>) => T;
-interface IPixelData {
+interface IPixelData32 {
     readonly data32: Uint32Array;
     readonly width: number;
     readonly height: number;
 }
+interface IPixelData<T extends ImageDataLike = ImageData> extends IPixelData32 {
+    readonly imageData: T;
+}
 
 /**
  * Packs RGBA into a 32-bit integer compatible with
@@ -247,7 +247,7 @@ declare function color32ToHex(color: Color32): string;
  */
 declare function color32ToCssRGBA(color: Color32): string;
 
-declare class PixelData<T extends ImageDataLike = ImageData> implements IPixelData {
+declare class PixelData<T extends ImageDataLike = ImageData> implements IPixelData<T> {
     readonly data32: Uint32Array;
     readonly imageData: T;
     readonly width: number;
@@ -381,12 +381,12 @@ declare function makeFastBlendModeRegistry(name?: string): {
         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 | 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>;
+    nameToIndex: Record<"overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide", 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
+    blendToIndex: Map<BlendColor32, 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
     blendToName: Map<BlendColor32, "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide">;
     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 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22;
+    indexType: 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22;
     nameType: "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide";
 };
 
@@ -464,12 +464,12 @@ declare function makePerfectBlendModeRegistry(name?: string): {
         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 | 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>;
+    nameToIndex: Record<"overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide", 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
+    blendToIndex: Map<BlendColor32, 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22>;
     blendToName: Map<BlendColor32, "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide">;
     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 | 16 | 8 | 2 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22;
+    indexType: 0 | 2 | 16 | 8 | 3 | 1 | 4 | 5 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 17 | 18 | 19 | 20 | 21 | 22;
     nameType: "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide";
 };
 
@@ -525,6 +525,25 @@ declare function toBlendModeIndexAndName(input: string | number): {
 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;
@@ -567,14 +586,14 @@ declare function makeReusableOffscreenCanvas(): {
 type DrawPixelLayer = (ctx: CanvasRenderingContext2D) => void;
 type DrawScreenLayer = (ctx: CanvasRenderingContext2D, scale: number) => void;
 type CanvasFrameRenderer = ReturnType<typeof makeCanvasFrameRenderer>;
-declare const defaults$j: {
+declare const defaults$c: {
     makeReusableCanvas: typeof makeReusableCanvas;
 };
-type Deps$j = Partial<typeof defaults$j>;
+type Deps$c = Partial<typeof defaults$c>;
 /**
  * @param deps - @hidden
  */
-declare function makeCanvasFrameRenderer(deps?: Deps$j): (pixelCanvas: PixelCanvas, scale: number, getImageData: () => ImageData | undefined | null, drawPixelLayer?: DrawPixelLayer, drawScreenLayer?: DrawScreenLayer) => void;
+declare function makeCanvasFrameRenderer(deps?: Deps$c): (pixelCanvas: PixelCanvas, scale: number, getImageData: () => ImageData | undefined | null, drawPixelLayer?: DrawPixelLayer, drawScreenLayer?: DrawScreenLayer) => void;
 
 /**
  * Extracts {@link ImageData} from a clipboard event if an image is present.
@@ -641,33 +660,48 @@ type PixelPatchTiles = {
     beforeTiles: PixelTile[];
     afterTiles: PixelTile[];
 };
-declare function applyPatchTiles(target: IPixelData, tiles: PixelTile[], tileSize: number): void;
+declare function applyPatchTiles(target: IPixelData32, tiles: PixelTile[], tileSize: number): void;
 
-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.
+ * This operation creates a new buffer. It does not scale or stretch pixels;
+ * instead, it crops or pads the image based on the new dimensions and
+ * provides an offset for repositioning.
+ *
+ * @param target The target to resize.
+ * @param newWidth The target width in pixels.
+ * @param newHeight The target height in pixels.
+ * @param offsetX The horizontal offset for placing the
+ * original image within the new buffer.
+ * @param offsetY The vertical offset for placing the
+ * original image within the new buffer.
+ *
+ * @returns A new {@link ImageData} instance with the specified dimensions.
+ *
+ * @example
+ * ```typescript
+ * // Centers an 80x80 image in a new 100x100 buffer
+ * const resized = resizeImageData(
+ *   originalData,
+ *   100,
+ *   100,
+ *   10,
+ *   10
+ * );
+ * ```
+ */
+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: IPixelData;
+    readonly target: PixelData;
     readonly targetColumns: number;
-    constructor(tileSize: number, target: IPixelData);
-    setTarget(target: IPixelData): void;
+    readonly targetRows: number;
+    constructor(tileSize: number, target: PixelData);
 }
 
 declare class PixelTilePool {
@@ -680,6 +714,51 @@ declare class PixelTilePool {
     releaseTiles(tiles: (PixelTile | undefined)[]): void;
 }
 
+declare class PaintBuffer {
+    readonly config: PixelEngineConfig;
+    readonly tilePool: PixelTilePool;
+    readonly lookup: (PixelTile | undefined)[];
+    private readonly scratchBounds;
+    constructor(config: PixelEngineConfig, tilePool: PixelTilePool);
+    private eachTileInBounds;
+    writePaintAlphaMaskStroke(color: Color32, brush: PaintAlphaMask, x0: number, y0: number, x1: number, y1: number): boolean;
+    writePaintBinaryMaskStroke(color: Color32, brush: PaintBinaryMask, x0: number, y0: number, x1: number, y1: number): boolean;
+    writeRectStroke(color: Color32, brushWidth: number, brushHeight: number, x0: number, y0: number, x1: number, y1: number): boolean;
+    clear(): void;
+}
+
+/**
+ * Blits source PixelData into a destination PixelData using 32-bit integer bitwise blending.
+ * This function bypasses standard ImageData limitations by operating directly on
+ * Uint32Array views. It supports various blend modes, binary/alpha masking, and
+ * automatic clipping of both source and destination bounds.
+ * @example
+ *
+ * const dst = new PixelData(ctx.getImageData(0,0,100,100))
+ * blendImageData32(dst, sprite, {
+ *   blendFn: COLOR_32_BLEND_MODES.multiply,
+ *   mask: brushMask,
+ *   maskType: MaskType.ALPHA
+ * });
+ */
+declare function blendPixelData(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;
@@ -700,9 +779,10 @@ declare class PixelAccumulator {
      * @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;
-    rollback(): void;
+    rollbackAfterError(): void;
 }
 
 interface PixelWriterOptions {
@@ -711,6 +791,7 @@ interface PixelWriterOptions {
     historyManager?: HistoryManager;
     historyActionFactory?: HistoryActionFactory;
     pixelTilePool?: PixelTilePool;
+    accumulator?: PixelAccumulator;
 }
 /**
  * @example
@@ -738,9 +819,30 @@ declare class PixelWriter<M> {
     readonly accumulator: PixelAccumulator;
     readonly historyActionFactory: HistoryActionFactory;
     readonly config: PixelEngineConfig;
+    readonly pixelTilePool: PixelTilePool;
+    readonly paintBuffer: PaintBuffer;
     readonly mutator: M;
-    constructor(target: IPixelData, mutatorFactory: (writer: PixelWriter<any>) => M, { tileSize, maxHistorySteps, historyManager, historyActionFactory, pixelTilePool, }?: PixelWriterOptions);
-    withHistory(cb: (mutator: M) => void, after?: () => void, afterUndo?: () => void, afterRedo?: () => void): void;
+    private blendPixelDataOpts;
+    private _inProgress;
+    constructor(target: PixelData, mutatorFactory: (writer: PixelWriter<any>) => M, { tileSize, maxHistorySteps, historyManager, historyActionFactory, pixelTilePool, accumulator, }?: PixelWriterOptions);
+    /**
+     * Executes `transaction` and commits the resulting pixel changes as a single
+     * undoable history action.
+     *
+     * - If `transaction` throws, all accumulated changes are rolled back and the error
+     *   is re-thrown. No action is committed.
+     * - If `transaction` completes without modifying any pixels, no action is committed.
+     * - `withHistory` is not re-entrant. Calling it again from inside `transaction` will
+     *   throw immediately to prevent silent data loss from a nested extractPatch.
+     *
+     * @param transaction Callback to be executed inside the transaction.
+     * @param after    Called after both undo and redo — use for generic change notifications.
+     * @param afterUndo Called after undo only — use for dimension or state changes specific to undo.
+     * @param afterRedo Called after redo only.
+     */
+    withHistory(transaction: (mutator: M) => void, after?: () => void, afterUndo?: () => void, afterRedo?: () => void): void;
+    resize(newWidth: number, newHeight: number, offsetX?: number, offsetY?: number, after?: (target: ImageData) => void, afterUndo?: (target: ImageData) => void, afterRedo?: (target: ImageData) => void, resizeImageDataFn?: typeof resizeImageData): void;
+    commitPaintBuffer(alpha?: number, blendFn?: BlendColor32, blendPixelDataFn?: typeof blendPixelData): void;
 }
 
 interface HistoryAction {
@@ -757,21 +859,11 @@ declare function makeFullPixelMutator(writer: PixelWriter<any>): {
     fillBinaryMask(color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): boolean;
     fill(color: Color32, x?: number, y?: number, w?: number, h?: number): boolean;
     clear(rect?: Partial<Rect>): void;
-    blendPixelDataBinaryMask(src: IPixelData, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
-    blendPixelDataAlphaMask(src: IPixelData, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
-    blendPixelData(src: IPixelData, opts?: PixelBlendOptions): boolean;
+    blendPixelDataBinaryMask(src: IPixelData32, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
+    blendPixelDataAlphaMask(src: IPixelData32, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+    blendPixelData(src: IPixelData32, opts?: PixelBlendOptions): boolean;
     blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
-    applyCircleMask(color: Color32, centerX: number, centerY: number, brush: CircleMask, alpha?: number, blendFn?: BlendColor32): boolean;
     blendColor(color: Color32, opts?: ColorBlendOptions): boolean;
-    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): boolean;
-    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): boolean;
-    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleBinaryMask, alpha?: number, blendFn?: BlendColor32): void;
-    applyCirclePencil(color: Color32, centerX: number, centerY: number, brush: CircleMask, alpha?: number, blendFn?: BlendColor32): boolean;
-    applyCircleBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleAlphaMask, alpha?: number, blendFn?: BlendColor32): void;
-    applyBinaryMask(mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
-    applyAlphaMask(mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 };
 
 /**
@@ -779,16 +871,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: IPixelData, mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
+declare function applyAlphaMaskToPixelData(dst: IPixelData32, mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 
-declare const defaults$i: {
+declare const defaults$b: {
     applyAlphaMaskToPixelData: typeof applyAlphaMaskToPixelData;
 };
-type Deps$i = Partial<typeof defaults$i>;
+type Deps$b = Partial<typeof defaults$b>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$i) => {
+declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$b) => {
     applyAlphaMask(mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 };
 
@@ -797,90 +889,50 @@ declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$i) =
  * modifying the destination's alpha channel in-place.
  * @returns true if any pixels were actually modified.
  */
-declare function applyBinaryMaskToPixelData(dst: IPixelData, mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
+declare function applyBinaryMaskToPixelData(dst: IPixelData32, mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 
-declare const defaults$h: {
+declare const defaults$a: {
     applyBinaryMaskToPixelData: typeof applyBinaryMaskToPixelData;
 };
-type Deps$h = Partial<typeof defaults$h>;
+type Deps$a = Partial<typeof defaults$a>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyBinaryMask: (writer: PixelWriter<any>, deps?: Deps$h) => {
+declare const mutatorApplyBinaryMask: (writer: PixelWriter<any>, deps?: Deps$a) => {
     applyBinaryMask(mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 };
 
 /**
- * Blends a solid color into a target pixel buffer using an alpha mask.
- *
- * @remarks
- * 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 IPixelData} 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.
+ * Blends a solid color into a target pixel buffer.
  * @returns true if any pixels were actually modified.
  */
-declare function blendColorPixelDataAlphaMask(dst: IPixelData, color: Color32, mask: AlphaMask, opts?: ColorBlendMaskOptions): boolean;
-
-declare function getCircleBrushOrPencilBounds(centerX: number, centerY: number, brushSize: number, targetWidth: number, targetHeight: number, out?: Rect): Rect;
+declare function blendColorPixelData(dst: IPixelData32, color: Color32, opts?: ColorBlendOptions): boolean;
 
-declare function getCircleBrushOrPencilStrokeBounds(x0: number, y0: number, x1: number, y1: number, brushSize: number, result: Rect): Rect;
-
-declare const defaults$g: {
-    forEachLinePoint: typeof forEachLinePoint;
-    blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
-    getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
-    getCircleBrushOrPencilStrokeBounds: typeof getCircleBrushOrPencilStrokeBounds;
+declare const defaults$9: {
+    blendColorPixelData: typeof blendColorPixelData;
 };
-type Deps$g = Partial<typeof defaults$g>;
+type Deps$9 = Partial<typeof defaults$9>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyCircleBrushStroke: (writer: PixelWriter<any>, deps?: Deps$g) => {
-    applyCircleBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleAlphaMask, alpha?: number, blendFn?: BlendColor32): void;
+declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$9) => {
+    blendColor(color: Color32, opts?: ColorBlendOptions): boolean;
 };
 
 /**
- * Applies a circular mask to pixel data using a pre-calculated alpha mask.
+ * Blends a solid color into a target pixel buffer using an alpha mask.
  *
- * @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 brush The pre-calculated CircleBrushAlphaMask.
- * @param alpha The overall opacity of the brush (0-255).
- * @param blendFn
- * @param scratchOptions
- * @param bounds precalculated result from {@link getCircleBrushOrPencilBounds}
- */
-declare function blendColorPixelDataCircleMask(target: IPixelData, color: Color32, centerX: number, centerY: number, brush: CircleMask, alpha?: number, blendFn?: BlendColor32, scratchOptions?: ColorBlendMaskOptions, bounds?: Rect): boolean;
-
-declare const defaults$f: {
-    blendColorPixelDataCircleMask: typeof blendColorPixelDataCircleMask;
-    getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
-};
-type Deps$f = Partial<typeof defaults$f>;
-/**
- * @param deps - @hidden
+ * @remarks
+ * 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 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 const mutatorBlendColorCircleMask: (writer: PixelWriter<any>, deps?: Deps$f) => {
-    applyCircleMask(color: Color32, centerX: number, centerY: number, brush: CircleMask, alpha?: number, blendFn?: BlendColor32): boolean;
-};
-
-declare const defaults$e: {
-    applyCircleMaskToPixelData: typeof blendColorPixelDataCircleMask;
-    getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
-};
-type Deps$e = Partial<typeof defaults$e>;
-/**
- * @param deps - @hidden
- **/
-declare const mutatorApplyCirclePencil: (writer: PixelWriter<any>, deps?: Deps$e) => {
-    applyCirclePencil(color: Color32, centerX: number, centerY: number, brush: CircleMask, alpha?: number, blendFn?: BlendColor32): boolean;
-};
+declare function blendColorPixelDataAlphaMask(dst: IPixelData32, color: Color32, mask: AlphaMask, opts?: ColorBlendMaskOptions): boolean;
 
 /**
  * Blends a solid color into a target pixel buffer using a binary mask.
@@ -889,109 +941,27 @@ declare const mutatorApplyCirclePencil: (writer: PixelWriter<any>, deps?: Deps$e
  * 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 IPixelData} buffer to modify.
+ * @param dst - 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: IPixelData, color: Color32, mask: BinaryMask, opts?: ColorBlendMaskOptions): boolean;
-
-declare const defaults$d: {
-    forEachLinePoint: typeof forEachLinePoint;
-    blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
-    getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
-    getCircleBrushOrPencilStrokeBounds: typeof getCircleBrushOrPencilStrokeBounds;
-};
-type Deps$d = Partial<typeof defaults$d>;
-/**
- * @param deps - @hidden
- */
-declare const mutatorApplyCirclePencilStroke: (writer: PixelWriter<any>, deps?: Deps$d) => {
-    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleBinaryMask, alpha?: number, blendFn?: BlendColor32): void;
-};
-
-/**
- * Applies a rectangular brush to the pixel data.
- * @returns true if any pixels were actually modified.
- */
-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): boolean;
-
-declare function getRectBrushOrPencilBounds(centerX: number, centerY: number, brushWidth: number, brushHeight: number, targetWidth: number, targetHeight: number, out?: Rect): Rect;
-
-declare const defaults$c: {
-    applyRectBrushToPixelData: typeof applyRectBrushToPixelData;
-    getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
-    fallOff: () => number;
-};
-type Deps$c = Partial<typeof defaults$c>;
-/**
- * @param deps - @hidden
- */
-declare const mutatorApplyRectPencil: (writer: PixelWriter<any>, deps?: Deps$c) => {
-    applyRectPencil(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): boolean;
-};
-
-declare function getRectBrushOrPencilStrokeBounds(x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, result: Rect): Rect;
-
-declare const defaults$b: {
-    forEachLinePoint: typeof forEachLinePoint;
-    getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
-    getRectBrushOrPencilStrokeBounds: typeof getRectBrushOrPencilStrokeBounds;
-    blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
-};
-type Deps$b = Partial<typeof defaults$b>;
-/**
- * @param deps - @hidden
- */
-declare const mutatorApplyRectPencilStroke: (writer: PixelWriter<any>, deps?: Deps$b) => {
-    applyRectPencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
-};
-
-declare const defaults$a: {
-    applyRectBrushToPixelData: typeof applyRectBrushToPixelData;
-    getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
-};
-type Deps$a = Partial<typeof defaults$a>;
-/**
- * @param deps - @hidden
- */
-declare const mutatorApplyRectBrush: (writer: PixelWriter<any>, deps?: Deps$a) => {
-    applyRectBrush(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): boolean;
-};
-
-declare const defaults$9: {
-    forEachLinePoint: typeof forEachLinePoint;
-    blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
-    getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
-    getRectBrushOrPencilStrokeBounds: typeof getRectBrushOrPencilStrokeBounds;
-};
-type Deps$9 = Partial<typeof defaults$9>;
-/**
- * @param deps - @hidden
- */
-declare const mutatorApplyRectBrushStroke: (writer: PixelWriter<any>, deps?: Deps$9) => {
-    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;
-};
-
-/**
- * Blends a solid color into a target pixel buffer.
- * @returns true if any pixels were actually modified.
- */
-declare function blendColorPixelData(dst: IPixelData, color: Color32, opts?: ColorBlendOptions): boolean;
+declare function blendColorPixelDataBinaryMask(dst: IPixelData32, color: Color32, mask: BinaryMask, opts?: ColorBlendMaskOptions): boolean;
 
 declare const defaults$8: {
-    blendColorPixelData: typeof blendColorPixelData;
+    blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
+    blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
 };
 type Deps$8 = Partial<typeof defaults$8>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$8) => {
-    blendColor(color: Color32, opts?: ColorBlendOptions): boolean;
+declare const mutatorBlendPaintMask: (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: IPixelData, x: number, y: number, color: Color32, 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;
@@ -1004,22 +974,6 @@ declare const mutatorBlendPixel: (writer: PixelWriter<any>, deps?: Partial<Deps$
     blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
 };
 
-/**
- * Blits source PixelData into a destination PixelData using 32-bit integer bitwise blending.
- * This function bypasses standard ImageData limitations by operating directly on
- * Uint32Array views. It supports various blend modes, binary/alpha masking, and
- * automatic clipping of both source and destination bounds.
- * @example
- *
- * const dst = new PixelData(ctx.getImageData(0,0,100,100))
- * blendImageData32(dst, sprite, {
- *   blendFn: COLOR_32_BLEND_MODES.multiply,
- *   mask: brushMask,
- *   maskType: MaskType.ALPHA
- * });
- */
-declare function blendPixelData(dst: IPixelData, src: IPixelData, opts?: PixelBlendOptions): boolean;
-
 declare const defaults$6: {
     blendPixelData: typeof blendPixelData;
 };
@@ -1028,10 +982,10 @@ type Deps$6 = Partial<typeof defaults$6>;
  * @param deps - @hidden
  */
 declare const mutatorBlendPixelData: (writer: PixelWriter<any>, deps?: Partial<Deps$6>) => {
-    blendPixelData(src: IPixelData, opts?: PixelBlendOptions): boolean;
+    blendPixelData(src: IPixelData32, opts?: PixelBlendOptions): boolean;
 };
 
-declare function blendPixelDataAlphaMask(dst: IPixelData, src: IPixelData, alphaMask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+declare function blendPixelDataAlphaMask(dst: IPixelData32, src: IPixelData32, alphaMask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
 
 declare const defaults$5: {
     blendPixelDataAlphaMask: typeof blendPixelDataAlphaMask;
@@ -1041,10 +995,10 @@ type Deps$5 = Partial<typeof defaults$5>;
  * @param deps - @hidden
  */
 declare const mutatorBlendPixelDataAlphaMask: (writer: PixelWriter<any>, deps?: Partial<Deps$5>) => {
-    blendPixelDataAlphaMask(src: IPixelData, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+    blendPixelDataAlphaMask(src: IPixelData32, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
 };
 
-declare function blendPixelDataBinaryMask(dst: IPixelData, src: IPixelData, binaryMask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
+declare function blendPixelDataBinaryMask(dst: IPixelData32, src: IPixelData32, binaryMask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
 
 declare const defaults$4: {
     blendPixelDataBinaryMask: typeof blendPixelDataBinaryMask;
@@ -1054,11 +1008,11 @@ type Deps$4 = Partial<typeof defaults$4>;
  * @param deps - @hidden
  */
 declare const mutatorBlendPixelDataBinaryMask: (writer: PixelWriter<any>, deps?: Partial<Deps$4>) => {
-    blendPixelDataBinaryMask(src: IPixelData, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
+    blendPixelDataBinaryMask(src: IPixelData32, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
 };
 
 /**
- * Fills a region or the {@link IPixelData} buffer with a solid color.
+ * 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.
  *
@@ -1067,7 +1021,7 @@ declare const mutatorBlendPixelDataBinaryMask: (writer: PixelWriter<any>, deps?:
  * @param rect - Defines the area to fill. If omitted, the entire
  * buffer is filled.
  */
-declare function fillPixelDataFast(dst: IPixelData, color: Color32, rect?: Partial<Rect>): void;
+declare function fillPixelDataFast(dst: IPixelData32, color: Color32, rect?: Partial<Rect>): void;
 /**
  * @param dst - The target to modify.
  * @param color - The color to apply.
@@ -1076,7 +1030,7 @@ declare function fillPixelDataFast(dst: IPixelData, color: Color32, rect?: Parti
  * @param w - Width of the fill area.
  * @param h - Height of the fill area.
  */
-declare function fillPixelDataFast(dst: IPixelData, color: Color32, x: number, y: number, w: number, h: number): void;
+declare function fillPixelDataFast(dst: IPixelData32, color: Color32, x: number, y: number, w: number, h: number): void;
 
 declare const defaults$3: {
     fillPixelData: typeof fillPixelDataFast;
@@ -1090,14 +1044,14 @@ declare const mutatorClear: (writer: PixelWriter<any>, deps?: Deps$3) => {
 };
 
 /**
- * Fills a region or the {@link IPixelData} buffer with a solid color.
+ * 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: IPixelData, color: Color32, rect?: Partial<Rect>): boolean;
+declare function fillPixelData(dst: IPixelData32, color: Color32, rect?: Partial<Rect>): boolean;
 /**
  * @param dst - The target to modify.
  * @param color - The color to apply.
@@ -1106,7 +1060,7 @@ declare function fillPixelData(dst: IPixelData, color: Color32, rect?: Partial<R
  * @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): boolean;
+declare function fillPixelData(dst: IPixelData32, color: Color32, x: number, y: number, w: number, h: number): boolean;
 
 declare const defaults$2: {
     fillPixelData: typeof fillPixelData;
@@ -1126,7 +1080,7 @@ declare const mutatorFillRect: (writer: PixelWriter<any>, deps?: Deps$2) => {
 };
 
 /**
- * Fills a region of the {@link IPixelData} buffer with a solid color using a mask.
+ * Fills a region of the {@link IPixelData32} buffer with a solid color using a mask.
  * @param dst - The target to modify.
  * @param color - The color to apply.
  * @param mask - The mask defining the area to fill.
@@ -1134,7 +1088,7 @@ declare const mutatorFillRect: (writer: PixelWriter<any>, deps?: Deps$2) => {
  * @param x - Starting horizontal coordinate for the mask placement.
  * @param y - Starting vertical coordinate for the mask placement.
  */
-declare function fillPixelDataBinaryMask(dst: IPixelData, color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): boolean;
+declare function fillPixelDataBinaryMask(dst: IPixelData32, color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): boolean;
 
 declare const defaults$1: {
     fillPixelDataBinaryMask: typeof fillPixelDataBinaryMask;
@@ -1147,7 +1101,7 @@ declare const mutatorFillBinaryMask: (writer: PixelWriter<any>, deps?: Deps$1) =
     fillBinaryMask(color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): boolean;
 };
 
-declare function invertPixelData(pixelData: IPixelData, opts?: PixelMutateOptions): boolean;
+declare function invertPixelData(pixelData: IPixelData32, opts?: PixelMutateOptions): boolean;
 
 declare const defaults: {
     invertPixelData: typeof invertPixelData;
@@ -1272,37 +1226,6 @@ declare function invertImageData(imageData: ImageData): ImageData;
  */
 declare function resampleImageData(source: ImageData, factor: number): ImageData;
 
-/**
- * Non destructively resizes the {@link ImageData} buffer to new dimensions, optionally
- * offsetting the original content.
- * This operation creates a new buffer. It does not scale or stretch pixels;
- * instead, it crops or pads the image based on the new dimensions and
- * provides an offset for repositioning.
- *
- * @param target The target to resize.
- * @param newWidth The target width in pixels.
- * @param newHeight The target height in pixels.
- * @param offsetX The horizontal offset for placing the
- * original image within the new buffer.
- * @param offsetY The vertical offset for placing the
- * original image within the new buffer.
- *
- * @returns A new {@link ImageData} instance with the specified dimensions.
- *
- * @example
- * ```typescript
- * // Centers an 80x80 image in a new 100x100 buffer
- * const resized = resizeImageData(
- *   originalData,
- *   100,
- *   100,
- *   10,
- *   10
- * );
- * ```
- */
-declare function resizeImageData(target: 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.
@@ -1549,10 +1472,6 @@ declare function makeAlphaMask(w: number, h: number, data?: Uint8Array): AlphaMa
  */
 declare function makeBinaryMask(w: number, h: number, data?: Uint8Array): BinaryMask;
 
-declare function makeCircleAlphaMask(size: number, fallOff?: (d: number) => number): CircleAlphaMask;
-
-declare function makeCircleBinaryMask(size: number): CircleBinaryMask;
-
 declare function applyBinaryMaskToAlphaMask(alphaMaskDst: AlphaMask, binaryMaskSrc: BinaryMask, opts?: ApplyMaskToPixelDataOptions): void;
 
 /**
@@ -1627,40 +1546,29 @@ declare function mergeBinaryMaskRects(current: NullableBinaryMaskRect[], adding:
 
 declare function subtractBinaryMaskRects(current: NullableBinaryMaskRect[], subtracting: NullableBinaryMaskRect[]): NullableBinaryMaskRect[];
 
-declare class PaintBuffer {
-    readonly config: PixelEngineConfig;
-    readonly tilePool: PixelTilePool;
-    readonly lookup: (PixelTile | undefined)[];
-    constructor(config: PixelEngineConfig, tilePool: PixelTilePool);
-    private processMaskTiles;
-    writeColorBinaryMaskRect(color: Color32, mask: BinaryMaskRect): void;
-    writeColorAlphaMaskRect(color: Color32, mask: AlphaMaskRect): void;
-    clear(): void;
-}
-
-declare function blendPixelDataPaintBuffer(paintBuffer: PaintBuffer, target: IPixelData, alpha?: number, blendFn?: BlendColor32, blendPixelDataFn?: typeof blendPixelData): void;
+declare function blendPixelDataPaintBuffer(paintBuffer: PaintBuffer, target: IPixelData32, alpha?: number, blendFn?: BlendColor32, blendPixelDataFn?: typeof blendPixelData): void;
 
 /**
  * Clears a region of the PixelData to transparent (0x00000000).
  * Internally uses the optimized fillPixelData.
  */
-declare function clearPixelData(dst: IPixelData, rect?: Partial<BinaryMaskRect>): void;
+declare function clearPixelData(dst: IPixelData32, rect?: Partial<BinaryMaskRect>): void;
 
 /**
  * High-level extraction that returns a new PixelData instance.
  * Leverages extractPixelDataBuffer for optimized 32-bit memory moves.
  */
-declare function extractPixelData(source: IPixelData, rect: Rect): PixelData;
-declare function extractPixelData(source: IPixelData, x: number, y: number, w: number, h: number): PixelData;
+declare function extractPixelData(source: IPixelData32, rect: Rect): PixelData;
+declare function extractPixelData(source: IPixelData32, 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: IPixelData, rect: Rect): Uint32Array;
-declare function extractPixelDataBuffer(source: IPixelData, x: number, y: number, w: number, h: number): Uint32Array;
+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 IPixelData {
+declare class PixelBuffer32 implements IPixelData32 {
     readonly width: number;
     readonly height: number;
     readonly data32: Uint32Array;
@@ -1673,16 +1581,16 @@ declare class PixelBuffer32 implements IPixelData {
  * Extracts the alpha channel from PixelData into a single-channel mask.
  * Returns a Uint8Array branded as AlphaMask.
  */
-declare function pixelDataToAlphaMask(pixelData: IPixelData): AlphaMask;
+declare function pixelDataToAlphaMask(pixelData: IPixelData32): AlphaMask;
 
-declare function reflectPixelDataHorizontal(pixelData: IPixelData): void;
-declare function reflectPixelDataVertical(pixelData: IPixelData): void;
+declare function reflectPixelDataHorizontal(pixelData: IPixelData32): void;
+declare function reflectPixelDataVertical(pixelData: IPixelData32): void;
 
 /**
  * Resamples PixelData by a specific factor using nearest neighbor.
  * Factor > 1 upscales, Factor < 1 downscales.
  */
-declare function resamplePixelData(pixelData: IPixelData, factor: number): PixelData;
+declare function resamplePixelData(pixelData: IPixelData32, factor: number): PixelData;
 
 /**
  * Rotates pixel data 90 degrees clockwise.
@@ -1692,13 +1600,18 @@ declare function resamplePixelData(pixelData: IPixelData, factor: number): Pixel
 declare function rotatePixelData(pixelData: PixelData): void;
 
 /**
- * Copies a pixel buffer into a specific region of a {@link IPixelData} object.
+ * Copies a pixel buffer into a specific region of a {@link IPixelData32} object.
  *
  * This function performs a direct memory copy from a {@link Uint32Array}
  * into the target buffer.
  */
-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;
+declare function writePixelDataBuffer(target: IPixelData32, data: Uint32Array, rect: Rect): void;
+declare function writePixelDataBuffer(target: IPixelData32, data: Uint32Array, x: number, y: number, w: number, h: number): void;
+
+/**
+ * @param writePixelDataBufferFn - @hidden
+ */
+declare function writePaintBufferToPixelData(target: IPixelData, paintBuffer: PaintBuffer, writePixelDataBufferFn?: typeof writePixelDataBuffer): void;
 
 declare function getRectsBounds<T extends Rect>(rects: T[]): T;
 
@@ -1716,17 +1629,27 @@ declare function getRectsBounds<T extends Rect>(rects: T[]): T;
  * // The mask is cropped by 10 px on the top and left.
  * trimRectBounds(selection, canvas);
  */
-declare function trimRectBounds<T extends NullableMaskRect>(target: T, bounds: Rect): void;
+declare function trimMaskRectBounds<T extends NullableMaskRect>(target: T, bounds: Rect): void;
+
+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 PaintBufferRenderer = ReturnType<typeof makePaintBufferRenderer>;
+type PaintBufferCanvasRenderer = ReturnType<typeof makePaintBufferCanvasRenderer>;
 /**
  *
- * @param paintBuffer
  * @param offscreenCanvasClass - @internal
  */
-declare function makePaintBufferRenderer(paintBuffer: PaintBuffer, offscreenCanvasClass?: {
+declare function makePaintBufferCanvasRenderer(paintBuffer: PaintBuffer, offscreenCanvasClass?: {
     new (width: number, height: number): OffscreenCanvas;
     prototype: OffscreenCanvas;
-}): (target: CanvasRenderingContext2D) => void;
+}): (targetCtx: CanvasRenderingContext2D, alpha?: number, compOperation?: GlobalCompositeOperation) => void;
 
-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_CTX_FAILED, type CanvasContext, type CanvasFrameRenderer, type CircleAlphaMask, type CircleBinaryMask, type CircleMask, 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 ImageDataLike, type ImageDataLikeConstructor, IndexedImage, type InvertMask, type Mask, type MaskOffset, MaskType, type MergeAlphaMasksOptions, type NullableBinaryMaskRect, type NullableMaskRect, OFFSCREEN_CANVAS_CTX_FAILED, PaintBuffer, type PaintBufferRenderer, 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, applyRectBrushToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendColorPixelDataAlphaMask, blendColorPixelDataBinaryMask, blendColorPixelDataCircleMask, 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, getCircleBrushOrPencilBounds, getCircleBrushOrPencilStrokeBounds, getImageDataFromClipboard, getIndexedImageColorCounts, getRectBrushOrPencilBounds, getRectBrushOrPencilStrokeBounds, 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, makeCircleAlphaMask, makeCircleBinaryMask, makeFastBlendModeRegistry, makeFullPixelMutator, makeHistoryAction, makeImageDataLike, makePaintBufferRenderer, makePerfectBlendModeRegistry, makePixelCanvas, makeReusableCanvas, makeReusableImageData, makeReusableOffscreenCanvas, merge2BinaryMaskRects, mergeAlphaMasks, mergeBinaryMaskRects, mergeBinaryMasks, multiplyFast, multiplyPerfect, mutatorApplyAlphaMask, mutatorApplyBinaryMask, mutatorApplyCircleBrushStroke, mutatorApplyCirclePencil, mutatorApplyCirclePencilStroke, mutatorApplyRectBrush, mutatorApplyRectBrushStroke, mutatorApplyRectPencil, mutatorApplyRectPencilStroke, mutatorBlendColor, mutatorBlendColorCircleMask, 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, trimRectBounds, uInt32ArrayToImageData, uInt32ArrayToImageDataLike, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageData, writeImageDataBuffer, writeImageDataToClipboard, writeImgBlobToClipboard, writePixelDataBuffer };
+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 };