pixel-data-js 0.20.0 → 0.22.2

package/dist/index.prod.d.ts

@@ -42,13 +42,6 @@ type Rect = {
     w: number;
     h: number;
 };
-type BinaryMaskRect = {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-    mask: BinaryMask;
-};
 /**
  * Defines how mask values should be interpreted during a draw operation.
  */
@@ -64,15 +57,30 @@ declare enum MaskType {
      */
     BINARY = 1
 }
+interface Mask {
+    readonly type: MaskType;
+    readonly data: Uint8Array;
+    readonly w: number;
+    readonly h: number;
+}
 /** Strictly 0 or 1 */
-type BinaryMask = Uint8Array & {
-    readonly __brand: 'Binary';
-};
+interface BinaryMask extends Mask {
+    readonly type: MaskType.BINARY;
+}
 /** Strictly 0-255 */
-type AlphaMask = Uint8Array & {
-    readonly __brand: 'Alpha';
-};
-type AnyMask = BinaryMask | AlphaMask;
+interface AlphaMask extends Mask {
+    readonly type: MaskType.ALPHA;
+}
+interface CircleBrush {
+    readonly size: number;
+    readonly radius: number;
+    readonly minOffset: number;
+}
+interface CircleBrushAlphaMask extends CircleBrush, AlphaMask {
+}
+interface CircleBrushBinaryMask extends CircleBrush, BinaryMask {
+}
+type CircleBrushMask = CircleBrushAlphaMask | CircleBrushBinaryMask;
 /**
  * Configuration for pixel manipulation operations.
  * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
@@ -111,13 +119,6 @@ interface MaskOffset {
      */
     my?: number;
 }
-interface MaskOffsetWidth {
-    /**
-     * Mask width.
-     * @default value of `w`
-     */
-    mw?: number;
-}
 interface InvertMask {
     /**
      * If true the inverse of the mask will be applied
@@ -132,11 +133,11 @@ interface Alpha {
      */
     alpha?: number;
 }
-interface ApplyMaskToPixelDataOptions extends PixelRect, Alpha, MaskOffsetWidth, MaskOffset, InvertMask {
+interface ApplyMaskToPixelDataOptions extends PixelRect, Alpha, MaskOffset, InvertMask {
 }
 interface MergeAlphaMasksOptions extends PixelRect, Alpha, MaskOffset, InvertMask {
 }
-interface PixelMutateOptions extends PixelRect, MaskOffset, MaskOffsetWidth, InvertMask {
+interface PixelMutateOptions extends PixelRect, MaskOffset, InvertMask {
     /** An optional mask to restrict where pixels are mutated. */
     mask?: BinaryMask | null;
 }
@@ -162,7 +163,7 @@ interface BasePixelBlendOptions {
 }
 interface PixelBlendOptions extends PixelRect, Alpha, BasePixelBlendOptions {
 }
-interface PixelBlendMaskOptions extends PixelRect, Alpha, MaskOffsetWidth, MaskOffset, InvertMask, BasePixelBlendOptions {
+interface PixelBlendMaskOptions extends PixelRect, Alpha, MaskOffset, InvertMask, BasePixelBlendOptions {
 }
 /**
  * Configuration for operations that require color blending.
@@ -174,15 +175,29 @@ interface ColorBlendOptions extends PixelRect, Alpha {
      */
     blendFn?: BlendColor32;
 }
-interface ColorBlendMaskOptions extends ColorBlendOptions, MaskOffset, MaskOffsetWidth, InvertMask {
+interface ColorBlendMaskOptions extends ColorBlendOptions, MaskOffset, InvertMask {
 }
-type SelectionRect = Rect & ({
-    mask: Uint8Array;
-    maskType: MaskType;
+type BinaryMaskRect = Rect & {
+    type: MaskType.BINARY;
+    data: Uint8Array;
+};
+type NullableBinaryMaskRect = Rect & ({
+    type: MaskType.BINARY;
+    data: Uint8Array;
+} | {
+    type?: null;
+    data?: null;
+});
+type NullableMaskRect = Rect & ({
+    type: MaskType;
+    data: Uint8Array;
 } | {
-    mask?: null;
-    maskType?: null;
+    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;
@@ -249,7 +264,7 @@ type FloodFillImageDataOptions = {
 type FloodFillResult = {
     startX: number;
     startY: number;
-    selectionRect: SelectionRect;
+    selectionRect: BinaryMaskRect;
     pixels: Uint8ClampedArray;
 };
 /**
@@ -262,9 +277,9 @@ type FloodFillResult = {
  * @param startX - The starting horizontal coordinate.
  * @param startY - The starting vertical coordinate.
  * @param options - Configuration for the fill operation.
- * @param options.contiguous - @default true. If true, only connected pixels are
+ * @param options.contiguous - If true, only connected pixels are
  * selected. If false, all pixels within tolerance are selected regardless of position.
- * @param options.tolerance - @default 0. The maximum allowed difference in color
+ * @param options.tolerance - The maximum allowed difference in color
  * distance (0-255) for a pixel to be included.
  * @param options.bounds - Optional bounding box to restrict the search area.
  *
@@ -577,7 +592,7 @@ declare function writeImageDataToClipboard(imageData: ImageData): Promise<void>;
 /**
  * Writes a {@link Blob} image to the system clipboard.
  *
- * @param blob - The image {@link Blob} (typically `image/png`) to copy.
+ * @param blob - The image blob (typically `image/png`) to copy.
  * @returns A promise that resolves when the clipboard has been updated.
  */
 declare function writeImgBlobToClipboard(blob: Blob): Promise<void>;
@@ -689,14 +704,14 @@ declare class PixelWriter<M> {
 }
 
 declare function makeFullPixelMutator(writer: PixelWriter<any>): {
-    clear(rect?: Partial<Rect>): void;
+    clear(rect?: Partial<BinaryMaskRect>): void;
     applyRectPencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
     applyRectPencil(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
     applyRectBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
     applyRectBrush(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
-    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushSize: number, alpha?: number, blendFn?: BlendColor32): void;
-    applyCircleBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
-    applyCircleBrush(color: Color32, centerX: number, centerY: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleBrushBinaryMask, 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;
     invert(opts?: PixelMutateOptions): void;
     fill(color: Color32, rect?: Partial<Rect>): void;
     blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): void;
@@ -706,13 +721,20 @@ declare function makeFullPixelMutator(writer: PixelWriter<any>): {
     applyAlphaMask: (mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions) => void;
 };
 
+/**
+ * Directly applies a mask to a region of PixelData,
+ * modifying the destination's alpha channel in-place.
+ */
 declare function applyAlphaMaskToPixelData(dst: IPixelData, mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions): void;
 
-declare const defaults$e: {
+declare const defaults$f: {
     applyAlphaMaskToPixelData: typeof applyAlphaMaskToPixelData;
 };
-type Deps$e = Partial<typeof defaults$e>;
-declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$e) => {
+type Deps$f = Partial<typeof defaults$f>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$f) => {
     applyAlphaMask: (mask: AlphaMask, opts?: ApplyMaskToPixelDataOptions) => void;
 };
 
@@ -722,40 +744,44 @@ declare const mutatorApplyAlphaMask: (writer: PixelWriter<any>, deps?: Deps$e) =
  */
 declare function applyBinaryMaskToPixelData(dst: IPixelData, mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions): void;
 
-declare const defaults$d: {
+declare const defaults$e: {
     applyBinaryMaskToPixelData: typeof applyBinaryMaskToPixelData;
 };
-type Deps$d = Partial<typeof defaults$d>;
-declare const mutatorApplyBinaryMask: (writer: PixelWriter<any>, deps?: Deps$d) => {
+type Deps$e = Partial<typeof defaults$e>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorApplyBinaryMask: (writer: PixelWriter<any>, deps?: Deps$e) => {
     applyBinaryMask: (mask: BinaryMask, opts?: ApplyMaskToPixelDataOptions) => void;
 };
 
 /**
- * Applies a circular brush to pixel data, blending a color with optional falloff.
+ * 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 brushSize The diameter of the brush.
+ * @param brush The pre-calculated CircleBrushAlphaMask.
  * @param alpha The overall opacity of the brush (0-255).
- * @default 255
- * @param fallOff A function that returns an alpha multiplier (0-1) based on the normalized distance (0-1) from the circle's center.
  * @param blendFn
+ * @param scratchOptions
  * @param bounds precalculated result from {@link getCircleBrushOrPencilBounds}
- * @default sourceOverPerfect
  */
-declare function applyCircleBrushToPixelData(target: IPixelData, color: Color32, centerX: number, centerY: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32, bounds?: Rect): void;
+declare function 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$c: {
+declare const defaults$d: {
     applyCircleBrushToPixelData: typeof applyCircleBrushToPixelData;
     getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
 };
-type Deps$c = Partial<typeof defaults$c>;
-declare const mutatorApplyCircleBrush: (writer: PixelWriter<any>, deps?: Deps$c) => {
-    applyCircleBrush(color: Color32, centerX: number, centerY: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+type Deps$d = Partial<typeof defaults$d>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorApplyCircleBrush: (writer: PixelWriter<any>, deps?: Deps$d) => {
+    applyCircleBrush(color: Color32, centerX: number, centerY: number, brush: CircleBrushAlphaMask, alpha?: number, blendFn?: BlendColor32): void;
 };
 
 /**
@@ -764,98 +790,145 @@ declare const mutatorApplyCircleBrush: (writer: PixelWriter<any>, deps?: Deps$c)
  */
 declare function forEachLinePoint(x0: number, y0: number, x1: number, y1: number, callback: (x: number, y: number) => void): void;
 
-declare function blendColorPixelDataAlphaMask(dst: IPixelData, color: Color32, mask: AlphaMask, opts: ColorBlendMaskOptions): void;
+/**
+ * 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.
+ */
+declare function blendColorPixelDataAlphaMask(dst: IPixelData, color: Color32, mask: AlphaMask, opts?: ColorBlendMaskOptions): void;
 
 declare function getCircleBrushOrPencilStrokeBounds(x0: number, y0: number, x1: number, y1: number, brushSize: number, result: Rect): Rect;
 
-declare const defaults$b: {
+declare const defaults$c: {
     forEachLinePoint: typeof forEachLinePoint;
     blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
     getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
     getCircleBrushOrPencilStrokeBounds: typeof getCircleBrushOrPencilStrokeBounds;
 };
-type Deps$b = Partial<typeof defaults$b>;
-declare const mutatorApplyCircleBrushStroke: (writer: PixelWriter<any>, deps?: Deps$b) => {
-    applyCircleBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushSize: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
+type Deps$c = Partial<typeof defaults$c>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorApplyCircleBrushStroke: (writer: PixelWriter<any>, deps?: Deps$c) => {
+    applyCircleBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleBrushAlphaMask, alpha?: number, blendFn?: BlendColor32): void;
 };
 
-declare const defaults$a: {
+declare const defaults$b: {
     applyCircleBrushToPixelData: typeof applyCircleBrushToPixelData;
     getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
-    fallOff: () => number;
 };
-type Deps$a = Partial<typeof defaults$a>;
-declare const mutatorApplyCirclePencil: (writer: PixelWriter<any>, deps?: Deps$a) => {
-    applyCirclePencil(color: Color32, centerX: number, centerY: number, brushSize: number, alpha?: number, blendFn?: BlendColor32): void;
+type Deps$b = Partial<typeof defaults$b>;
+/**
+ * @param deps - @hidden
+ **/
+declare const mutatorApplyCirclePencil: (writer: PixelWriter<any>, deps?: Deps$b) => {
+    applyCirclePencil(color: Color32, centerX: number, centerY: number, brush: CircleBrushMask, alpha?: number, blendFn?: BlendColor32): void;
 };
 
+/**
+ * Blends a solid color into a target pixel buffer using a binary 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.
+ */
 declare function blendColorPixelDataBinaryMask(dst: IPixelData, color: Color32, mask: BinaryMask, opts?: ColorBlendMaskOptions): void;
 
-declare const defaults$9: {
+declare const defaults$a: {
     forEachLinePoint: typeof forEachLinePoint;
     blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
     getCircleBrushOrPencilBounds: typeof getCircleBrushOrPencilBounds;
     getCircleBrushOrPencilStrokeBounds: typeof getCircleBrushOrPencilStrokeBounds;
 };
-type Deps$9 = Partial<typeof defaults$9>;
-declare const mutatorApplyCirclePencilStroke: (writer: PixelWriter<any>, deps?: Deps$9) => {
-    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushSize: number, alpha?: number, blendFn?: BlendColor32): void;
+type Deps$a = Partial<typeof defaults$a>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorApplyCirclePencilStroke: (writer: PixelWriter<any>, deps?: Deps$a) => {
+    applyCirclePencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brush: CircleBrushBinaryMask, alpha?: number, blendFn?: BlendColor32): void;
 };
 
 declare function applyRectBrushToPixelData(target: IPixelData, color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32, bounds?: Rect): void;
 
 declare function getRectBrushOrPencilBounds(centerX: number, centerY: number, brushWidth: number, brushHeight: number, targetWidth: number, targetHeight: number, out?: Rect): Rect;
 
-declare const defaults$8: {
+declare const defaults$9: {
     applyRectBrushToPixelData: typeof applyRectBrushToPixelData;
     getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
     fallOff: () => number;
 };
-type Deps$8 = Partial<typeof defaults$8>;
-declare const mutatorApplyRectPencil: (writer: PixelWriter<any>, deps?: Deps$8) => {
+type Deps$9 = Partial<typeof defaults$9>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorApplyRectPencil: (writer: PixelWriter<any>, deps?: Deps$9) => {
     applyRectPencil(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
 };
 
 declare function getRectBrushOrPencilStrokeBounds(x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, result: Rect): Rect;
 
-declare const defaults$7: {
+declare const defaults$8: {
     forEachLinePoint: typeof forEachLinePoint;
     getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
     getRectBrushOrPencilStrokeBounds: typeof getRectBrushOrPencilStrokeBounds;
     blendColorPixelDataBinaryMask: typeof blendColorPixelDataBinaryMask;
 };
-type Deps$7 = Partial<typeof defaults$7>;
-declare const mutatorApplyRectPencilStroke: (writer: PixelWriter<any>, deps?: Deps$7) => {
+type Deps$8 = Partial<typeof defaults$8>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorApplyRectPencilStroke: (writer: PixelWriter<any>, deps?: Deps$8) => {
     applyRectPencilStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, alpha?: number, blendFn?: BlendColor32): void;
 };
 
-declare const defaults$6: {
+declare const defaults$7: {
     applyRectBrushToPixelData: typeof applyRectBrushToPixelData;
     getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
 };
-type Deps$6 = Partial<typeof defaults$6>;
-declare const mutatorApplyRectBrush: (writer: PixelWriter<any>, deps?: Deps$6) => {
+type Deps$7 = Partial<typeof defaults$7>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorApplyRectBrush: (writer: PixelWriter<any>, deps?: Deps$7) => {
     applyRectBrush(color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
 };
 
-declare const defaults$5: {
+declare const defaults$6: {
     forEachLinePoint: typeof forEachLinePoint;
     blendColorPixelDataAlphaMask: typeof blendColorPixelDataAlphaMask;
     getRectBrushOrPencilBounds: typeof getRectBrushOrPencilBounds;
     getRectBrushOrPencilStrokeBounds: typeof getRectBrushOrPencilStrokeBounds;
 };
-type Deps$5 = Partial<typeof defaults$5>;
-declare const mutatorApplyRectBrushStroke: (writer: PixelWriter<any>, deps?: Deps$5) => {
+type Deps$6 = Partial<typeof defaults$6>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorApplyRectBrushStroke: (writer: PixelWriter<any>, deps?: Deps$6) => {
     applyRectBrushStroke(color: Color32, x0: number, y0: number, x1: number, y1: number, brushWidth: number, brushHeight: number, alpha: number | undefined, fallOff: (dist: number) => number, blendFn?: BlendColor32): void;
 };
 
 declare function blendColorPixelData(dst: IPixelData, color: Color32, opts?: ColorBlendOptions): void;
 
-declare const defaults$4: {
+declare const defaults$5: {
     blendColorPixelData: typeof blendColorPixelData;
 };
-type Deps$4 = Partial<typeof defaults$4>;
-declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$4) => {
+type Deps$5 = Partial<typeof defaults$5>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorBlendColor: (writer: PixelWriter<any>, deps?: Deps$5) => {
     blendColor(color: Color32, opts?: ColorBlendOptions): void;
 };
 
@@ -879,47 +952,78 @@ declare function mutatorBlendPixel(writer: PixelWriter<any>): {
  */
 declare function blendPixelData(dst: IPixelData, src: IPixelData, opts: PixelBlendOptions): void;
 
-declare const defaults$3: {
+declare const defaults$4: {
     blendPixelData: typeof blendPixelData;
 };
-type Deps$3 = Partial<typeof defaults$3>;
-declare const mutatorBlendPixelData: (writer: PixelWriter<any>, deps?: Partial<Deps$3>) => {
+type Deps$4 = Partial<typeof defaults$4>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorBlendPixelData: (writer: PixelWriter<any>, deps?: Partial<Deps$4>) => {
     blendPixelData(src: IPixelData, opts: PixelBlendOptions): void;
 };
 
 /**
- * Fills a region or the {@link PixelData} buffer with a solid color.
+ * Fills a region or the {@link IPixelData} buffer with a solid color.
  *
- * @param dst - The target {@link PixelData} to modify.
- * @param color - The {@link Color32} value to apply.
- * @param rect - A {@link BinaryMaskRect} defining the area to fill.
+ * @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<BinaryMaskRect>): void;
+declare function fillPixelData(dst: IPixelData, color: Color32, rect?: Partial<Rect>): void;
 /**
- * @param dst - The target {@link PixelData} to modify.
- * @param color - The {@link Color32} value to apply.
+ * @param 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.
- * @param mask - A {@link BinaryMaskRect} defining the area to fill
  */
-declare function fillPixelData(dst: IPixelData, color: Color32, x: number, y: number, w: number, h: number, mask?: BinaryMask): void;
+declare function fillPixelData(dst: IPixelData, color: Color32, x: number, y: number, w: number, h: number): void;
+
+declare const defaults$3: {
+    fillPixelData: typeof fillPixelData;
+};
+type Deps$3 = Partial<typeof defaults$3>;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorClear: (writer: PixelWriter<any>, deps?: Deps$3) => {
+    clear(rect?: Partial<BinaryMaskRect>): void;
+};
 
 declare const defaults$2: {
     fillPixelData: typeof fillPixelData;
 };
 type Deps$2 = Partial<typeof defaults$2>;
-declare const mutatorClear: (writer: PixelWriter<any>, deps?: Deps$2) => {
-    clear(rect?: Partial<Rect>): void;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorFill: (writer: PixelWriter<any>, deps?: Deps$2) => {
+    fill(color: Color32, rect?: Partial<Rect>): void;
 };
 
+/**
+ * Fills a region of the {@link IPixelData} 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.
+ * @param alpha - The overall opacity of the fill (0-255).
+ * @param x - Starting horizontal coordinate for the mask placement.
+ * @param y - Starting vertical coordinate for the mask placement.
+ */
+declare function fillPixelDataBinaryMask(dst: IPixelData, color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): void;
+
 declare const defaults$1: {
-    fillPixelData: typeof fillPixelData;
+    fillPixelDataBinaryMask: typeof fillPixelDataBinaryMask;
 };
 type Deps$1 = Partial<typeof defaults$1>;
-declare const mutatorFill: (writer: PixelWriter<any>, deps?: Deps$1) => {
-    fill(color: Color32, rect?: Partial<Rect>): void;
+/**
+ * @param deps - @hidden
+ */
+declare const mutatorFillBinaryMask: (writer: PixelWriter<any>, deps?: Deps$1) => {
+    fillBinaryMask(color: Color32, mask: BinaryMask, alpha?: number, x?: number, y?: number): void;
 };
 
 declare function invertPixelData(pixelData: IPixelData, opts?: PixelMutateOptions): void;
@@ -928,6 +1032,9 @@ declare const defaults: {
     invertPixelData: typeof invertPixelData;
 };
 type Deps = Partial<typeof defaults>;
+/**
+ * @param deps - @hidden
+ */
 declare const mutatorInvert: (writer: PixelWriter<any>, deps?: Deps) => {
     invert(opts?: PixelMutateOptions): void;
 };
@@ -942,8 +1049,8 @@ declare function copyImageDataLike({ data, width, height }: ImageDataLike): Imag
  * This is a "read-only" operation that returns a copy of the pixel data.
  *
  * @param imageData - The source image data to read from.
- * @param rect - A {@link Rect} object defining the region to extract.
- * @returns A {@link Uint8ClampedArray} containing the RGBA pixel data of the region.
+ * @param rect - A rect defining the region to extract.
+ * @returns A buffer containing the RGBA pixel data of the region.
  */
 declare function extractImageDataBuffer(imageData: ImageDataLike, rect: Rect): Uint8ClampedArray;
 /**
@@ -952,7 +1059,7 @@ declare function extractImageDataBuffer(imageData: ImageDataLike, rect: Rect): U
  * @param y - The starting vertical coordinate.
  * @param w - The width of the region to extract.
  * @param h - The height of the region to extract.
- * @returns A {@link Uint8ClampedArray} containing the RGBA pixel data of the region.
+ * @returns A buffer containing the RGBA pixel data of the region.
  */
 declare function extractImageDataBuffer(imageData: ImageDataLike, x: number, y: number, w: number, h: number): Uint8ClampedArray;
 
@@ -963,7 +1070,7 @@ declare function makeImageDataLike(width: number, height: number, data?: Buffer)
  * When possible use {@link pixelDataToAlphaMask} instead.
  * Repeat calls to the same data will use less memory.
  */
-declare function imageDataToAlphaMask(imageData: ImageData): AlphaMask;
+declare function imageDataToAlphaMaskBuffer(imageData: ImageData): Uint8Array;
 
 /**
  * Converts an {@link ImageData} object into a base64-encoded Data URL string.
@@ -1051,15 +1158,13 @@ declare function resampleImageData(source: ImageData, factor: number): ImageData
  * instead, it crops or pads the image based on the new dimensions and
  * provides an offset for repositioning.
  *
- * @param current The source {@link ImageDataLike} to resize.
+ * @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.
- * @default 0
  * @param offsetY The vertical offset for placing the
  * original image within the new buffer.
- * @default 0
  *
  * @returns A new {@link ImageData} instance with the specified dimensions.
  *
@@ -1075,7 +1180,7 @@ declare function resampleImageData(source: ImageData, factor: number): ImageData
  * );
  * ```
  */
-declare function resizeImageData(current: ImageDataLike, newWidth: number, newHeight: number, offsetX?: number, offsetY?: number): ImageData;
+declare function resizeImageData(target: ImageDataLike, newWidth: number, newHeight: number, offsetX?: number, offsetY?: number): ImageData;
 
 type ReusableImageData = ReturnType<typeof makeReusableImageData>;
 /**
@@ -1123,20 +1228,20 @@ declare function writeImageData(target: ImageData, source: ImageData, x: number,
  * into the target {@link ImageData} buffer. It supports both {@link Rect}
  * objects and discrete coordinates.
  *
- * @param imageData - The target {@link ImageData} to write into. Must match the rect width/height.
+ * @param target - The target to write into. Must match the rect width/height.
  * @param data - The source pixel data (RGBA).
- * @param rect - A {@link Rect} object defining the destination region.
+ * @param rect - A rect defining the destination region.
  */
-declare function writeImageDataBuffer(imageData: ImageData, data: Uint8ClampedArray, rect: Rect): void;
+declare function writeImageDataBuffer(target: ImageData, data: Uint8ClampedArray, rect: Rect): void;
 /**
- * @param imageData - The target {@link ImageData} to write into.
+ * @param target - The target to write into.
  * @param data - The source pixel data (RGBA). Must match the width/height.
  * @param x - The starting horizontal coordinate in the target.
  * @param y - The starting vertical coordinate in the target.
  * @param w - The width of the region to write.
  * @param h - The height of the region to write.
  */
-declare function writeImageDataBuffer(imageData: ImageData, data: Uint8ClampedArray, x: number, y: number, w: number, h: number): void;
+declare function writeImageDataBuffer(target: ImageData, data: Uint8ClampedArray, x: number, y: number, w: number, h: number): void;
 
 /**
  * Represents an image using a palette-based indexing system.
@@ -1307,27 +1412,67 @@ declare function fileToImageData(file: File | null | undefined): Promise<ImageDa
  */
 declare function getSupportedPixelFormats(rasterMimes?: string[]): Promise<string[]>;
 
-declare function applyBinaryMaskToAlphaMask(alphaMaskDst: AlphaMask, dstWidth: number, binaryMaskSrc: BinaryMask, srcWidth: number, opts?: ApplyMaskToPixelDataOptions): void;
+/**
+ * Creates an Alpha Mask
+ * @param w - width
+ * @param h - height
+ * @param data - values 0-255
+ */
+declare function makeAlphaMask(w: number, h: number, data?: Uint8Array): AlphaMask;
+
+/**
+ * Creates a Binary Mask
+ * @param w - width
+ * @param h - height
+ * @param data - values 0-1
+ */
+declare function makeBinaryMask(w: number, h: number, data?: Uint8Array): BinaryMask;
+
+declare function makeCircleBrushAlphaMask(size: number, fallOff?: (d: number) => number): CircleBrushAlphaMask;
+
+declare function makeCircleBrushBinaryMask(size: number): CircleBrushBinaryMask;
+
+declare function applyBinaryMaskToAlphaMask(alphaMaskDst: AlphaMask, binaryMaskSrc: BinaryMask, opts?: ApplyMaskToPixelDataOptions): void;
 
 /**
  * Creates a new copy of a mask.
  * Uses the underlying buffer's slice method for high-performance memory copying.
  */
-declare function copyMask<T extends Uint8Array>(src: T): T;
+declare function copyMask<T extends Mask>(src: T): T;
 
 /**
  * Extracts a rectangular region from a 1D {@link Uint8Array} mask.
  * This utility calculates the necessary offsets based on the `maskWidth` to
  * slice out a specific area.
  *
- * @param mask - The source 1D array representing the full 2D mask.
+ * @param mask - The target mask.
+ * @param rect - A rect defining the region to extract.
+ * @returns A new mask containing the extracted region.
+ */
+declare function extractMask<T extends Mask>(mask: T, rect: Rect): T;
+/**
+ * @param mask - The target mask.
+ * @param x - The starting horizontal coordinate.
+ * @param y - The starting vertical coordinate.
+ * @param w - The width of the region to extract.
+ * @param h - The height of the region to extract.
+ * @returns A new {@link Uint8Array} containing the extracted region.
+ */
+declare function extractMask<T extends Mask>(mask: T, x: number, y: number, w: number, h: number): T;
+
+/**
+ * Extracts a rectangular region from a 1D {@link Uint8Array} mask.
+ * This utility calculates the necessary offsets based on the `maskWidth` to
+ * slice out a specific area.
+ *
+ * @param maskBuffer - The source 1D array representing the full 2D mask.
  * @param maskWidth - The width of the original source mask (stride).
  * @param rect - A {@link Rect} object defining the region to extract.
  * @returns A new {@link Uint8Array} containing the extracted region.
  */
-declare function extractMask(mask: Uint8Array, maskWidth: number, rect: Rect): Uint8Array;
+declare function extractMaskBuffer(maskBuffer: Uint8Array, maskWidth: number, rect: Rect): Uint8Array;
 /**
- * @param mask - The source 1D array representing the full 2D mask.
+ * @param maskBuffer - The source 1D array representing the full 2D mask.
  * @param maskWidth - The width of the original source mask (stride).
  * @param x - The starting horizontal coordinate.
  * @param y - The starting vertical coordinate.
@@ -1335,7 +1480,7 @@ declare function extractMask(mask: Uint8Array, maskWidth: number, rect: Rect): U
  * @param h - The height of the region to extract.
  * @returns A new {@link Uint8Array} containing the extracted region.
  */
-declare function extractMask(mask: Uint8Array, maskWidth: number, x: number, y: number, w: number, h: number): Uint8Array;
+declare function extractMaskBuffer(maskBuffer: Uint8Array, maskWidth: number, x: number, y: number, w: number, h: number): Uint8Array;
 
 /**
  * Inverts a BinaryMask in-place.
@@ -1349,9 +1494,17 @@ declare function invertAlphaMask(dst: AlphaMask): void;
 /**
  * Merges 2 alpha masks values are 0-255
  */
-declare function mergeAlphaMasks(dst: AlphaMask, dstWidth: number, src: AlphaMask, srcWidth: number, opts: MergeAlphaMasksOptions): void;
+declare function mergeAlphaMasks(dst: AlphaMask, src: AlphaMask, opts: MergeAlphaMasksOptions): void;
+
+declare function mergeBinaryMasks(dst: BinaryMask, src: BinaryMask, opts: MergeAlphaMasksOptions): void;
 
-declare function mergeBinaryMasks(dst: BinaryMask, dstWidth: number, src: BinaryMask, srcWidth: number, opts: MergeAlphaMasksOptions): void;
+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 blendPixelDataAlphaMask(dst: IPixelData, src: IPixelData, alphaMask: AlphaMask, opts?: PixelBlendMaskOptions): void;
 
@@ -1361,7 +1514,7 @@ declare function blendPixelDataBinaryMask(dst: IPixelData, src: IPixelData, bina
  * Clears a region of the PixelData to transparent (0x00000000).
  * Internally uses the optimized fillPixelData.
  */
-declare function clearPixelData(dst: IPixelData, rect?: Partial<Rect>): void;
+declare function clearPixelData(dst: IPixelData, rect?: Partial<BinaryMaskRect>): void;
 
 /**
  * High-level extraction that returns a new PixelData instance.
@@ -1409,19 +1562,21 @@ 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 PixelData} object.
+ * Copies a pixel buffer into a specific region of a {@link IPixelData} object.
  *
  * This function performs a direct memory copy from a {@link Uint32Array}
- * into the target {@link PixelData} buffer.
+ * 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 getRectsBounds<T extends Rect>(rects: T[]): T;
+
 /**
  * Intersects a target rectangle with a boundary, trimming dimensions and masks in-place.
  * This utility calculates the axis-aligned intersection between the `target` and `bounds`.
- * If the `target` includes a `mask` (as in a {@link SelectionRect}), the mask is physically
- * cropped and re-aligned using `extractMask` to match the new dimensions.
+ * If the `target` includes a `mask` (as in a {@link NullableMaskRect}), the mask is physically
+ * cropped and re-aligned using `extractMaskBuffer` to match the new dimensions.
  * @param target - The rectangle or selection object to be trimmed. **Note:** This object is mutated in-place.
  * @param bounds - The boundary rectangle defining the maximum allowable area (e.g., canvas dimensions).
  * @example
@@ -1431,6 +1586,6 @@ declare function writePixelDataBuffer(target: IPixelData, data: Uint32Array, x:
  * // The mask is cropped by 10 px on the top and left.
  * trimRectBounds(selection, canvas);
  */
-declare function trimRectBounds<T extends Rect | SelectionRect>(target: T, bounds: Rect): void;
+declare function trimRectBounds<T extends NullableMaskRect>(target: T, bounds: Rect): void;
 
-export { type Alpha, type AlphaMask, type AnyMask, type ApplyMaskToPixelDataOptions, BASE_FAST_BLEND_MODE_FUNCTIONS, BASE_PERFECT_BLEND_MODE_FUNCTIONS, type Base64EncodedUInt8Array, BaseBlendMode, type BaseBlendModes, type BasePixelBlendOptions, type BinaryMask, type BinaryMaskRect, type BlendColor32, type BlendModeRegistry, CANVAS_CTX_FAILED, type Color32, type ColorBlendMaskOptions, type ColorBlendOptions, type FloodFillImageDataOptions, type FloodFillResult, type HistoryAction, HistoryManager, type HistoryMutator, type IPixelData, type ImageDataLike, type ImageDataLikeConstructor, IndexedImage, type InvertMask, type MaskOffset, type MaskOffsetWidth, MaskType, type MergeAlphaMasksOptions, OFFSCREEN_CANVAS_CTX_FAILED, PixelAccumulator, type PixelBlendMaskOptions, type PixelBlendOptions, PixelBuffer32, type PixelCanvas, PixelData, PixelEngineConfig, type PixelMutateOptions, type PixelPatchTiles, type PixelRect, PixelTile, PixelWriter, type PixelWriterOptions, type RGBA, type Rect, type RequiredBlendModes, type ReusableCanvas, type ReusableImageData, type SelectionRect, type SerializedImageData, UnsupportedFormatError, applyAlphaMaskToPixelData, applyBinaryMaskToAlphaMask, applyBinaryMaskToPixelData, applyCircleBrushToPixelData, applyPatchTiles, applyRectBrushToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendColorPixelDataAlphaMask, blendColorPixelDataBinaryMask, blendPixelData, blendPixelDataAlphaMask, blendPixelDataBinaryMask, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataBuffer, extractMask, extractPixelData, extractPixelDataBuffer, fileInputChangeToImageData, fileToImageData, fillPixelData, floodFillSelection, forEachLinePoint, getCircleBrushOrPencilBounds, getCircleBrushOrPencilStrokeBounds, getImageDataFromClipboard, getIndexedImageColorCounts, getRectBrushOrPencilBounds, getRectBrushOrPencilStrokeBounds, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMask, imageDataToDataUrl, imageDataToImgBlob, imageDataToUInt32Array, imgBlobToImageData, indexedImageToAverageColor, indexedImageToImageData, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeBlendModeRegistry, makeFastBlendModeRegistry, makeFullPixelMutator, makeImageDataLike, makePerfectBlendModeRegistry, makePixelCanvas, makeReusableCanvas, makeReusableImageData, mergeAlphaMasks, mergeBinaryMasks, multiplyFast, multiplyPerfect, mutatorApplyAlphaMask, mutatorApplyBinaryMask, mutatorApplyCircleBrush, mutatorApplyCircleBrushStroke, mutatorApplyCirclePencil, mutatorApplyCirclePencilStroke, mutatorApplyRectBrush, mutatorApplyRectBrushStroke, mutatorApplyRectPencil, mutatorApplyRectPencilStroke, mutatorBlendColor, mutatorBlendPixel, mutatorBlendPixelData, mutatorClear, mutatorFill, mutatorInvert, overlayFast, overlayPerfect, overwriteBase, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resampleImageData, resampleIndexedImage, resamplePixelData, resizeImageData, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractFast, subtractPerfect, toBlendModeIndexAndName, trimRectBounds, uInt32ArrayToImageData, uInt32ArrayToImageDataLike, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageData, writeImageDataBuffer, writeImageDataToClipboard, writeImgBlobToClipboard, writePixelDataBuffer };
+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, 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 };