pixel-data-js 0.23.0 → 0.24.0

package/dist/index.prod.d.ts

@@ -71,16 +71,16 @@ interface BinaryMask extends Mask {
 interface AlphaMask extends Mask {
     readonly type: MaskType.ALPHA;
 }
-interface CircleBrush {
+interface BaseCircleMask {
     readonly size: number;
     readonly radius: number;
     readonly minOffset: number;
 }
-interface CircleBrushAlphaMask extends CircleBrush, AlphaMask {
+interface CircleAlphaMask extends BaseCircleMask, AlphaMask {
 }
-interface CircleBrushBinaryMask extends CircleBrush, BinaryMask {
+interface CircleBinaryMask extends BaseCircleMask, BinaryMask {
 }
-type CircleBrushMask = CircleBrushAlphaMask | CircleBrushBinaryMask;
+type CircleMask = CircleAlphaMask | CircleBinaryMask;
 /**
  * Configuration for pixel manipulation operations.
  * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
@@ -181,6 +181,10 @@ type BinaryMaskRect = Rect & {
     type: MaskType.BINARY;
     data: Uint8Array;
 };
+type AlphaMaskRect = Rect & {
+    type: MaskType.ALPHA;
+    data: Uint8Array;
+};
 type NullableBinaryMaskRect = Rect & ({
     type: MaskType.BINARY;
     data: Uint8Array;
@@ -195,9 +199,6 @@ type NullableMaskRect = Rect & ({
     type?: null;
     data?: null;
 });
-type AlphaMaskRect = Rect & {
-    mask: AlphaMask;
-};
 type HistoryMutator<T extends {}, D extends {}> = (writer: PixelWriter<any>, deps?: Partial<D>) => T;
 interface IPixelData {
     readonly data32: Uint32Array;
@@ -253,7 +254,6 @@ declare class PixelData<T extends ImageDataLike = ImageData> implements IPixelDa
     readonly height: number;
     constructor(imageData: T);
     set(imageData: T): void;
-    copy(): PixelData<T>;
 }
 
 type FloodFillImageDataOptions = {
@@ -301,6 +301,12 @@ type FloodFillResult = {
  */
 declare function floodFillSelection(img: ImageDataLike | PixelData, startX: number, startY: number, { contiguous, tolerance, bounds, }?: FloodFillImageDataOptions): FloodFillResult | null;
 
+/**
+ * Iterates through a line with sub-pixel precision.
+ * Guarantees that the first and last points are exactly (x0, y0) and (x1, y1).
+ */
+declare function forEachLinePoint(x0: number, y0: number, x1: number, y1: number, callback: (x: number, y: number) => void): void;
+
 declare const overwriteFast: BlendColor32;
 declare const sourceOverFast: BlendColor32;
 declare const darkenFast: BlendColor32;
@@ -532,21 +538,44 @@ type PixelCanvas = {
  */
 declare function makePixelCanvas(canvas: HTMLCanvasElement): PixelCanvas;
 
-type ReusableCanvas = {
-    readonly canvas: HTMLCanvasElement;
-    readonly ctx: CanvasRenderingContext2D;
+type CanvasContext<T> = T extends HTMLCanvasElement ? CanvasRenderingContext2D : OffscreenCanvasRenderingContext2D;
+type ReusableCanvas<T extends HTMLCanvasElement | OffscreenCanvas> = {
+    readonly canvas: T;
+    readonly ctx: CanvasContext<T>;
 };
 /**
- * Creates a reusable canvas and context that are not part of the DOM.
+ * Creates a reusable HTMLCanvasElement and context that are not part of the DOM.
  * Ensures it is always set to `context.imageSmoothingEnabled = false`
  * @see makePixelCanvas
  * @throws {Error} If the {@link HTMLCanvasElement} context cannot be initialized.
  */
 declare function makeReusableCanvas(): {
-    (width: number, height: number): ReusableCanvas;
+    (width: number, height: number): ReusableCanvas<HTMLCanvasElement>;
+    reset(): void;
+};
+/**
+ * Creates a reusable OffscreenCanvas and context.
+ * Ensures it is always set to `context.imageSmoothingEnabled = false`
+ * @see makePixelCanvas
+ * @throws {Error} If the {@link OffscreenCanvasRenderingContext2D} context cannot be initialized.
+ */
+declare function makeReusableOffscreenCanvas(): {
+    (width: number, height: number): ReusableCanvas<OffscreenCanvas>;
     reset(): void;
 };
 
+type DrawPixelLayer = (ctx: CanvasRenderingContext2D) => void;
+type DrawScreenLayer = (ctx: CanvasRenderingContext2D, scale: number) => void;
+type CanvasFrameRenderer = ReturnType<typeof makeCanvasFrameRenderer>;
+declare const defaults$j: {
+    makeReusableCanvas: typeof makeReusableCanvas;
+};
+type Deps$j = Partial<typeof defaults$j>;
+/**
+ * @param deps - @hidden
+ */
+declare function makeCanvasFrameRenderer(deps?: Deps$j): (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.
  *
@@ -597,16 +626,28 @@ declare function writeImageDataToClipboard(imageData: ImageData): Promise<void>;
  */
 declare function writeImgBlobToClipboard(blob: Blob): Promise<void>;
 
-interface HistoryAction {
-    undo: () => void;
-    redo: () => void;
-    dispose?: () => void;
+declare class PixelTile implements IPixelData {
+    id: number;
+    tx: number;
+    ty: number;
+    readonly data32: Uint32Array;
+    readonly width: number;
+    readonly height: number;
+    readonly imageData: ImageData;
+    constructor(id: number, tx: number, ty: number, tileSize: number, tileArea: number);
 }
+
+type PixelPatchTiles = {
+    beforeTiles: PixelTile[];
+    afterTiles: PixelTile[];
+};
+declare function applyPatchTiles(target: IPixelData, tiles: PixelTile[], tileSize: number): void;
+
 declare class HistoryManager {
     maxSteps: number;
-    undoStack: HistoryAction[];
-    redoStack: HistoryAction[];
-    listeners: Set<() => void>;
+    readonly undoStack: HistoryAction[];
+    readonly redoStack: HistoryAction[];
+    readonly listeners: Set<() => void>;
     constructor(maxSteps?: number);
     get canUndo(): boolean;
     get canRedo(): boolean;
@@ -623,53 +664,53 @@ declare class PixelEngineConfig {
     readonly tileShift: number;
     readonly tileMask: number;
     readonly tileArea: number;
-    constructor(tileSize?: number);
+    readonly target: IPixelData;
+    readonly targetColumns: number;
+    constructor(tileSize: number, target: IPixelData);
+    setTarget(target: IPixelData): void;
 }
 
-type PixelPatchTiles = {
-    beforeTiles: PixelTile[];
-    afterTiles: PixelTile[];
-};
-declare class PixelTile {
-    id: number;
-    tx: number;
-    ty: number;
-    data32: Uint32Array;
-    constructor(id: number, tx: number, ty: number, tileArea: number);
+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 function applyPatchTiles(target: IPixelData, tiles: PixelTile[], tileSize?: number): void;
 
+type DidChangeFn = (didChange: boolean) => boolean;
 declare class PixelAccumulator {
-    target: IPixelData;
     readonly config: PixelEngineConfig;
+    readonly tilePool: PixelTilePool;
     lookup: (PixelTile | undefined)[];
     beforeTiles: PixelTile[];
-    pool: PixelTile[];
-    constructor(target: IPixelData, config: PixelEngineConfig);
-    getTile(id: number, tx: number, ty: number): PixelTile;
+    constructor(config: PixelEngineConfig, tilePool: PixelTilePool);
     recyclePatch(patch: PixelPatchTiles): void;
     /**
      * @param x pixel x coordinate
      * @param y pixel y coordinate
      */
-    storeTileBeforeState(x: number, y: number): void;
+    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): void;
+    storeRegionBeforeState(x: number, y: number, w: number, h: number): DidChangeFn;
     extractState(tile: PixelTile): void;
-    extractAfterTiles(): PixelTile[];
-    reset(): void;
+    extractPatch(): PixelPatchTiles;
+    rollback(): void;
 }
 
 interface PixelWriterOptions {
     maxHistorySteps?: number;
     tileSize?: number;
     historyManager?: HistoryManager;
+    historyActionFactory?: HistoryActionFactory;
+    pixelTilePool?: PixelTilePool;
 }
 /**
  * @example
@@ -693,107 +734,82 @@ interface PixelWriterOptions {
  * })
  */
 declare class PixelWriter<M> {
-    target: IPixelData;
-    historyManager: HistoryManager;
-    accumulator: PixelAccumulator;
-    protected config: PixelEngineConfig;
+    readonly historyManager: HistoryManager;
+    readonly accumulator: PixelAccumulator;
+    readonly historyActionFactory: HistoryActionFactory;
+    readonly config: PixelEngineConfig;
     readonly mutator: M;
-    constructor(target: IPixelData, mutatorFactory: (writer: PixelWriter<any>) => M, { tileSize, maxHistorySteps, historyManager, }?: PixelWriterOptions);
-    withHistory(cb: (mutator: M) => void): void;
-    captureHistory(): void;
+    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;
 }
 
+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;
+
 declare function makeFullPixelMutator(writer: PixelWriter<any>): {
-    invert(opts?: PixelMutateOptions): void;
-    fillBinaryMask(color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): void;
-    fill(color: Color32, rect?: Partial<Rect>): void;
+    invert(opts?: PixelMutateOptions): boolean;
+    fillRect(color: Color32, rect: Rect): boolean;
+    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): void;
-    blendPixelDataAlphaMask(src: IPixelData, mask: AlphaMask, opts?: PixelBlendMaskOptions): void;
-    blendPixelData(src: IPixelData, opts?: PixelBlendOptions): void;
-    blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): void;
-    blendColor(color: Color32, opts?: ColorBlendOptions): void;
+    blendPixelDataBinaryMask(src: IPixelData, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
+    blendPixelDataAlphaMask(src: IPixelData, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
+    blendPixelData(src: IPixelData, 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): 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): void;
-    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleBrushBinaryMask, alpha?: number, blendFn?: BlendColor32): void;
-    applyCirclePencil(color: Color32, centerX: number, centerY: number, brush: CircleBrushMask, alpha?: number, blendFn?: BlendColor32): void;
-    applyCircleBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleBrushAlphaMask, alpha?: number, blendFn?: BlendColor32): void;
-    applyCircleBrush(color: Color32, centerX: number, centerY: number, brush: CircleBrushAlphaMask, alpha?: number, blendFn?: BlendColor32): void;
-    applyBinaryMask: (mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions) => void;
-    applyAlphaMask: (mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions) => 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;
 };
 
 /**
  * Directly applies a mask to a region of PixelData,
  * 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): void;
+declare function applyAlphaMaskToPixelData(dst: IPixelData, mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 
-declare const defaults$h: {
+declare const defaults$i: {
     applyAlphaMaskToPixelData: typeof applyAlphaMaskToPixelData;
 };
-type Deps$h = Partial<typeof defaults$h>;
+type Deps$i = Partial<typeof defaults$i>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$h) => {
-    applyAlphaMask: (mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions) => void;
+declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$i) => {
+    applyAlphaMask(mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 };
 
 /**
  * Directly applies a mask to a region of PixelData,
  * 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): void;
+declare function applyBinaryMaskToPixelData(dst: IPixelData, mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 
-declare const defaults$g: {
+declare const defaults$h: {
     applyBinaryMaskToPixelData: typeof applyBinaryMaskToPixelData;
 };
-type Deps$g = Partial<typeof defaults$g>;
-/**
- * @param deps - @hidden
- */
-declare const mutatorApplyBinaryMask: (writer: PixelWriter<any>, deps?: Deps$g) => {
-    applyBinaryMask: (mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions) => void;
-};
-
-/**
- * Applies a circular brush to pixel data using a pre-calculated 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 applyCircleBrushToPixelData(target: IPixelData, color: Color32, centerX: number, centerY: number, brush: CircleBrushMask, alpha?: number, blendFn?: BlendColor32, scratchOptions?: ColorBlendMaskOptions, bounds?: Rect): void;
-
-declare function getCircleBrushOrPencilBounds(centerX: number, centerY: number, brushSize: number, targetWidth: number, targetHeight: number, out?: Rect): Rect;
-
-declare const defaults$f: {
-    applyCircleBrushToPixelData: typeof applyCircleBrushToPixelData;
-    getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
-};
-type Deps$f = Partial<typeof defaults$f>;
+type Deps$h = Partial<typeof defaults$h>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyCircleBrush: (writer: PixelWriter<any>, deps?: Deps$f) => {
-    applyCircleBrush(color: Color32, centerX: number, centerY: number, brush: CircleBrushAlphaMask, alpha?: number, blendFn?: BlendColor32): void;
+declare const mutatorApplyBinaryMask: (writer: PixelWriter<any>, deps?: Deps$h) => {
+    applyBinaryMask(mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): boolean;
 };
 
-/**
- * Iterates through a line with sub-pixel precision.
- * Guarantees that the first and last points are exactly (x0, y0) and (x1, y1).
- */
-declare function forEachLinePoint(x0: number, y0: number, x1: number, y1: number, callback: (x: number, y: number) => void): void;
-
 /**
  * Blends a solid color into a target pixel buffer using an alpha mask.
  *
@@ -805,35 +821,65 @@ declare function forEachLinePoint(x0: number, y0: number, x1: number, y1: number
  * @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: IPixelData, color: Color32, mask: AlphaMask, opts?: ColorBlendMaskOptions): void;
+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 getCircleBrushOrPencilStrokeBounds(x0: number, y0: number, x1: number, y1: number, brushSize: number, result: Rect): Rect;
 
-declare const defaults$e: {
+declare const defaults$g: {
     forEachLinePoint: typeof forEachLinePoint;
     blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
     getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
     getCircleBrushOrPencilStrokeBounds: typeof getCircleBrushOrPencilStrokeBounds;
 };
-type Deps$e = Partial<typeof defaults$e>;
+type Deps$g = Partial<typeof defaults$g>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyCircleBrushStroke: (writer: PixelWriter<any>, deps?: Deps$e) => {
-    applyCircleBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleBrushAlphaMask, alpha?: number, blendFn?: BlendColor32): void;
+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 defaults$d: {
-    applyCircleBrushToPixelData: typeof applyCircleBrushToPixelData;
+/**
+ * Applies a circular mask to pixel data using a pre-calculated 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$d = Partial<typeof defaults$d>;
+type Deps$f = Partial<typeof defaults$f>;
+/**
+ * @param deps - @hidden
+ */
+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$d) => {
-    applyCirclePencil(color: Color32, centerX: number, centerY: number, brush: CircleBrushMask, alpha?: number, blendFn?: BlendColor32): void;
+declare const mutatorApplyCirclePencil: (writer: PixelWriter<any>, deps?: Deps$e) => {
+    applyCirclePencil(color: Color32, centerX: number, centerY: number, brush: CircleMask, alpha?: number, blendFn?: BlendColor32): boolean;
 };
 
 /**
@@ -847,97 +893,115 @@ declare const mutatorApplyCirclePencil: (writer: PixelWriter<any>, deps?: Deps$d
  * @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): void;
+declare function blendColorPixelDataBinaryMask(dst: IPixelData, color: Color32, mask: BinaryMask, opts?: ColorBlendMaskOptions): boolean;
 
-declare const defaults$c: {
+declare const defaults$d: {
     forEachLinePoint: typeof forEachLinePoint;
     blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
     getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
     getCircleBrushOrPencilStrokeBounds: typeof getCircleBrushOrPencilStrokeBounds;
 };
-type Deps$c = Partial<typeof defaults$c>;
+type Deps$d = Partial<typeof defaults$d>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyCirclePencilStroke: (writer: PixelWriter<any>, deps?: Deps$c) => {
-    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleBrushBinaryMask, alpha?: number, blendFn?: BlendColor32): void;
+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;
 };
 
-declare function applyRectBrushToPixelData(target: IPixelData, color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32, bounds?: Rect): void;
+/**
+ * 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$b: {
+declare const defaults$c: {
     applyRectBrushToPixelData: typeof applyRectBrushToPixelData;
     getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
     fallOff: () => number;
 };
-type Deps$b = Partial<typeof defaults$b>;
+type Deps$c = Partial<typeof defaults$c>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyRectPencil: (writer: PixelWriter<any>, deps?: Deps$b) => {
-    applyRectPencil(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
+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$a: {
+declare const defaults$b: {
     forEachLinePoint: typeof forEachLinePoint;
     getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
     getRectBrushOrPencilStrokeBounds: typeof getRectBrushOrPencilStrokeBounds;
     blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
 };
-type Deps$a = Partial<typeof defaults$a>;
+type Deps$b = Partial<typeof defaults$b>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyRectPencilStroke: (writer: PixelWriter<any>, deps?: Deps$a) => {
+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$9: {
+declare const defaults$a: {
     applyRectBrushToPixelData: typeof applyRectBrushToPixelData;
     getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
 };
-type Deps$9 = Partial<typeof defaults$9>;
+type Deps$a = Partial<typeof defaults$a>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyRectBrush: (writer: PixelWriter<any>, deps?: Deps$9) => {
-    applyRectBrush(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+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$8: {
+declare const defaults$9: {
     forEachLinePoint: typeof forEachLinePoint;
     blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
     getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
     getRectBrushOrPencilStrokeBounds: typeof getRectBrushOrPencilStrokeBounds;
 };
-type Deps$8 = Partial<typeof defaults$8>;
+type Deps$9 = Partial<typeof defaults$9>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorApplyRectBrushStroke: (writer: PixelWriter<any>, deps?: Deps$8) => {
+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;
 };
 
-declare function blendColorPixelData(dst: IPixelData, color: Color32, opts?: ColorBlendOptions): 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 const defaults$7: {
+declare const defaults$8: {
     blendColorPixelData: typeof blendColorPixelData;
 };
-type Deps$7 = Partial<typeof defaults$7>;
+type Deps$8 = Partial<typeof defaults$8>;
 /**
  * @param deps - @hidden
  */
-declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$7) => {
-    blendColor(color: Color32, opts?: ColorBlendOptions): void;
+declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$8) => {
+    blendColor(color: Color32, opts?: ColorBlendOptions): boolean;
 };
 
-declare function mutatorBlendPixel(writer: PixelWriter<any>): {
-    blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): void;
+declare function blendPixel(target: IPixelData, x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): boolean;
+
+declare const defaults$7: {
+    blendPixel: typeof blendPixel;
+};
+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;
 };
 
 /**
@@ -954,7 +1018,7 @@ declare function mutatorBlendPixel(writer: PixelWriter<any>): {
  *   maskType: MaskType.ALPHA
  * });
  */
-declare function blendPixelData(dst: IPixelData, src: IPixelData, opts?: PixelBlendOptions): void;
+declare function blendPixelData(dst: IPixelData, src: IPixelData, opts?: PixelBlendOptions): boolean;
 
 declare const defaults$6: {
     blendPixelData: typeof blendPixelData;
@@ -964,10 +1028,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): void;
+    blendPixelData(src: IPixelData, opts?: PixelBlendOptions): boolean;
 };
 
-declare function blendPixelDataAlphaMask(dst: IPixelData, src: IPixelData, alphaMask: AlphaMask, opts?: PixelBlendMaskOptions): void;
+declare function blendPixelDataAlphaMask(dst: IPixelData, src: IPixelData, alphaMask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
 
 declare const defaults$5: {
     blendPixelDataAlphaMask: typeof blendPixelDataAlphaMask;
@@ -977,10 +1041,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): void;
+    blendPixelDataAlphaMask(src: IPixelData, mask: AlphaMask, opts?: PixelBlendMaskOptions): boolean;
 };
 
-declare function blendPixelDataBinaryMask(dst: IPixelData, src: IPixelData, binaryMask: BinaryMask, opts?: PixelBlendMaskOptions): void;
+declare function blendPixelDataBinaryMask(dst: IPixelData, src: IPixelData, binaryMask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
 
 declare const defaults$4: {
     blendPixelDataBinaryMask: typeof blendPixelDataBinaryMask;
@@ -990,18 +1054,20 @@ 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): void;
+    blendPixelDataBinaryMask(src: IPixelData, mask: BinaryMask, opts?: PixelBlendMaskOptions): boolean;
 };
 
 /**
  * Fills a region or the {@link IPixelData} 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.
  */
-declare function fillPixelData(dst: IPixelData, color: Color32, rect?: Partial<Rect>): void;
+declare function fillPixelDataFast(dst: IPixelData, color: Color32, rect?: Partial<Rect>): void;
 /**
  * @param dst - The target to modify.
  * @param color - The color to apply.
@@ -1010,10 +1076,10 @@ 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): void;
+declare function fillPixelDataFast(dst: IPixelData, color: Color32, x: number, y: number, w: number, h: number): void;
 
 declare const defaults$3: {
-    fillPixelData: typeof fillPixelData;
+    fillPixelData: typeof fillPixelDataFast;
 };
 type Deps$3 = Partial<typeof defaults$3>;
 /**
@@ -1023,6 +1089,25 @@ declare const mutatorClear: (writer: PixelWriter<any>, deps?: Deps$3) => {
     clear(rect?: Partial<Rect>): void;
 };
 
+/**
+ * Fills a region or the {@link IPixelData} 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;
+/**
+ * @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: IPixelData, color: Color32, x: number, y: number, w: number, h: number): boolean;
+
 declare const defaults$2: {
     fillPixelData: typeof fillPixelData;
 };
@@ -1031,7 +1116,13 @@ type Deps$2 = Partial<typeof defaults$2>;
  * @param deps - @hidden
  */
 declare const mutatorFill: (writer: PixelWriter<any>, deps?: Deps$2) => {
-    fill(color: Color32, rect?: Partial<Rect>): void;
+    fill(color: Color32, x?: number, y?: number, w?: number, h?: number): boolean;
+};
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorFillRect: (writer: PixelWriter<any>, deps?: Deps$2) => {
+    fillRect(color: Color32, rect: Rect): boolean;
 };
 
 /**
@@ -1043,7 +1134,7 @@ declare const mutatorFill: (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): void;
+declare function fillPixelDataBinaryMask(dst: IPixelData, color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): boolean;
 
 declare const defaults$1: {
     fillPixelDataBinaryMask: typeof fillPixelDataBinaryMask;
@@ -1053,10 +1144,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): void;
+    fillBinaryMask(color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): boolean;
 };
 
-declare function invertPixelData(pixelData: IPixelData, opts?: PixelMutateOptions): void;
+declare function invertPixelData(pixelData: IPixelData, opts?: PixelMutateOptions): boolean;
 
 declare const defaults: {
     invertPixelData: typeof invertPixelData;
@@ -1066,7 +1157,7 @@ type Deps = Partial<typeof defaults>;
  * @param deps - @hidden
  */
 declare const mutatorInvert: (writer: PixelWriter<any>, deps?: Deps) => {
-    invert(opts?: PixelMutateOptions): void;
+    invert(opts?: PixelMutateOptions): boolean;
 };
 
 declare function copyImageData({ data, width, height }: ImageDataLike): ImageData;
@@ -1458,9 +1549,9 @@ declare function makeAlphaMask(w: number, h: number, data?: Uint8Array): AlphaMa
  */
 declare function makeBinaryMask(w: number, h: number, data?: Uint8Array): BinaryMask;
 
-declare function makeCircleBrushAlphaMask(size: number, fallOff?: (d: number) => number): CircleBrushAlphaMask;
+declare function makeCircleAlphaMask(size: number, fallOff?: (d: number) => number): CircleAlphaMask;
 
-declare function makeCircleBrushBinaryMask(size: number): CircleBrushBinaryMask;
+declare function makeCircleBinaryMask(size: number): CircleBinaryMask;
 
 declare function applyBinaryMaskToAlphaMask(alphaMaskDst: AlphaMask, binaryMaskSrc: BinaryMask, opts?: ApplyMaskToPixelDataOptions): void;
 
@@ -1530,12 +1621,25 @@ declare function mergeBinaryMasks(dst: BinaryMask, src: BinaryMask, opts: MergeA
 
 declare function setMaskData(mask: Mask, width: number, height: number, data: Uint8Array): void;
 
-declare function subtractBinaryMaskRects(current: NullableBinaryMaskRect[], subtracting: NullableBinaryMaskRect[]): NullableBinaryMaskRect[];
-
 declare function merge2BinaryMaskRects(a: NullableBinaryMaskRect, b: NullableBinaryMaskRect): NullableBinaryMaskRect;
 
 declare function mergeBinaryMaskRects(current: NullableBinaryMaskRect[], adding: NullableBinaryMaskRect[]): NullableBinaryMaskRect[];
 
+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;
+
 /**
  * Clears a region of the PixelData to transparent (0x00000000).
  * Internally uses the optimized fillPixelData.
@@ -1614,4 +1718,15 @@ declare function getRectsBounds<T extends Rect>(rects: T[]): T;
  */
 declare function trimRectBounds<T extends NullableMaskRect>(target: T, bounds: Rect): 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 CircleBrushAlphaMask, type CircleBrushBinaryMask, type CircleBrushMask, type Color32, type ColorBlendMaskOptions, type ColorBlendOptions, type FloodFillImageDataOptions, type FloodFillResult, type HistoryAction, HistoryManager, type HistoryMutator, type IPixelData, type ImageDataLike, type ImageDataLikeConstructor, IndexedImage, type InvertMask, type Mask, type MaskOffset, MaskType, type MergeAlphaMasksOptions, type NullableBinaryMaskRect, type NullableMaskRect, OFFSCREEN_CANVAS_CTX_FAILED, PixelAccumulator, type PixelBlendMaskOptions, type PixelBlendOptions, PixelBuffer32, type PixelCanvas, PixelData, PixelEngineConfig, type PixelMutateOptions, type PixelPatchTiles, type PixelRect, PixelTile, PixelWriter, type PixelWriterOptions, type RGBA, type Rect, type RequiredBlendModes, type ReusableCanvas, type ReusableImageData, type SerializedImageData, UnsupportedFormatError, applyAlphaMaskToPixelData, applyBinaryMaskToAlphaMask, applyBinaryMaskToPixelData, applyCircleBrushToPixelData, applyPatchTiles, applyRectBrushToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendColorPixelDataAlphaMask, blendColorPixelDataBinaryMask, blendPixelData, blendPixelDataAlphaMask, blendPixelDataBinaryMask, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataBuffer, extractMask, extractMaskBuffer, extractPixelData, extractPixelDataBuffer, fileInputChangeToImageData, fileToImageData, fillPixelData, fillPixelDataBinaryMask, 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, makeCircleBrushAlphaMask, makeCircleBrushBinaryMask, makeFastBlendModeRegistry, makeFullPixelMutator, makeImageDataLike, makePerfectBlendModeRegistry, makePixelCanvas, makeReusableCanvas, makeReusableImageData, merge2BinaryMaskRects, mergeAlphaMasks, mergeBinaryMaskRects, mergeBinaryMasks, multiplyFast, multiplyPerfect, mutatorApplyAlphaMask, mutatorApplyBinaryMask, mutatorApplyCircleBrush, mutatorApplyCircleBrushStroke, mutatorApplyCirclePencil, mutatorApplyCirclePencilStroke, mutatorApplyRectBrush, mutatorApplyRectBrushStroke, mutatorApplyRectPencil, mutatorApplyRectPencilStroke, mutatorBlendColor, mutatorBlendPixel, mutatorBlendPixelData, mutatorBlendPixelDataAlphaMask, mutatorBlendPixelDataBinaryMask, mutatorClear, mutatorFill, mutatorFillBinaryMask, 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 };
+type PaintBufferRenderer = ReturnType<typeof makePaintBufferRenderer>;
+/**
+ *
+ * @param paintBuffer
+ * @param offscreenCanvasClass - @internal
+ */
+declare function makePaintBufferRenderer(paintBuffer: PaintBuffer, offscreenCanvasClass?: {
+    new (width: number, height: number): OffscreenCanvas;
+    prototype: OffscreenCanvas;
+}): (target: CanvasRenderingContext2D) => 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 };