pixel-data-js 0.15.1 → 0.17.0

package/dist/index.prod.d.ts

@@ -67,7 +67,7 @@ type AnyMask = BinaryMask | AlphaMask;
  * Configuration for pixel manipulation operations.
  * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
  */
-interface PixelOptions {
+interface PixelRectOptions {
     /**
      * The starting X coordinate in the destination buffer.
      * @default 0
@@ -88,11 +88,8 @@ interface PixelOptions {
      * @default Source height.
      */
     h?: number;
-    /**
-     * Overall layer opacity 0-255.
-     * @default 255
-     */
-    alpha?: number;
+}
+interface PixelMaskRectOptions {
     /**
      * Mask width.
      * @default value of `w`
@@ -108,17 +105,34 @@ interface PixelOptions {
      * @default 0
      */
     my?: number;
+}
+interface PixelMaskInvertOptions {
+    /**
+     * If true the inverse of the mask will be applied
+     * @default false
+     */
+    invertMask?: boolean;
+}
+/**
+ * Configuration for pixel manipulation operations.
+ * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
+ */
+interface PixelOptions extends PixelRectOptions, PixelMaskRectOptions, PixelMaskInvertOptions {
+    /**
+     * Overall layer opacity 0-255.
+     * @default 255
+     */
+    alpha?: number;
     /** An optional mask to restrict where pixels are written. */
     mask?: AnyMask | null;
     /** The interpretation logic for the provided mask.
      * @default {@link MaskType.ALPHA}
      */
     maskType?: MaskType;
-    /**
-     * If true the inverse of the mask will be applied
-     * @default false
-     */
-    invertMask?: boolean;
+}
+interface PixelMutateOptions extends PixelRectOptions, PixelMaskRectOptions, PixelMaskInvertOptions {
+    /** An optional mask to restrict where pixels are mutated. */
+    mask?: BinaryMask | null;
 }
 /**
  * Configuration for blitting (copying/blending) one image into another.
@@ -262,32 +276,48 @@ type FloodFillResult = {
  */
 declare function floodFillSelection(img: ImageDataLike | PixelData, startX: number, startY: number, { contiguous, tolerance, bounds, }?: FloodFillImageDataOptions): FloodFillResult | null;
 
-declare enum BlendMode {
-    overwrite = 0,
-    sourceOver = 1,
-    darken = 2,
-    multiply = 3,
-    colorBurn = 4,
-    linearBurn = 5,
-    darkerColor = 6,
-    lighten = 7,
-    screen = 8,
-    colorDodge = 9,
-    linearDodge = 10,
-    lighterColor = 11,
-    overlay = 12,
-    softLight = 13,
-    hardLight = 14,
-    vividLight = 15,
-    linearLight = 16,
-    pinLight = 17,
-    hardMix = 18,
-    difference = 19,
-    exclusion = 20,
-    subtract = 21,
-    divide = 22
+declare const BaseBlendMode: {
+    readonly overwrite: 0;
+    readonly sourceOver: 1;
+    readonly darken: 2;
+    readonly multiply: 3;
+    readonly colorBurn: 4;
+    readonly linearBurn: 5;
+    readonly darkerColor: 6;
+    readonly lighten: 7;
+    readonly screen: 8;
+    readonly colorDodge: 9;
+    readonly linearDodge: 10;
+    readonly lighterColor: 11;
+    readonly overlay: 12;
+    readonly softLight: 13;
+    readonly hardLight: 14;
+    readonly vividLight: 15;
+    readonly linearLight: 16;
+    readonly pinLight: 17;
+    readonly hardMix: 18;
+    readonly difference: 19;
+    readonly exclusion: 20;
+    readonly subtract: 21;
+    readonly divide: 22;
+};
+interface RequiredBlendModes {
+    overwrite: 0;
 }
-type BlendModeIndex = typeof BlendMode[keyof typeof BlendMode];
+type BaseBlendModes = RequiredBlendModes & Record<string, number>;
+declare const overwriteBase: BlendColor32;
+
+type BlendModeRegistry<BlendModes extends BaseBlendModes = BaseBlendModes, Name extends keyof BlendModes = keyof BlendModes, Index extends BlendModes[Name] = BlendModes[Name]> = ReturnType<typeof makeBlendModeRegistry<BlendModes, Name, Index>>;
+declare function makeBlendModeRegistry<BlendModes extends BaseBlendModes, Name extends keyof BlendModes = keyof BlendModes, Index extends BlendModes[Name] = BlendModes[Name]>(blendModes: BlendModes, initialEntries: Record<Index, BlendColor32>): {
+    nameToBlend: { [K in keyof BlendModes]: BlendColor32; };
+    nameToIndex: Record<Name, Index>;
+    blendToIndex: Map<BlendColor32, Index>;
+    blendToName: Map<BlendColor32, Name>;
+    indexToBlend: BlendColor32[];
+    indexToName: Name[];
+    indexType: Index;
+    nameType: Name;
+};
 
 declare const overwriteFast: BlendColor32;
 declare const sourceOverFast: BlendColor32;
@@ -335,15 +365,41 @@ declare const exclusionFast: BlendColor32;
 declare const subtractFast: BlendColor32;
 /** sr === 0 ? 255 : Math.min(255, (dr << 8) / sr) */
 declare const divideFast: BlendColor32;
-declare const FAST_BLENDER_REGISTRY: readonly [readonly [BlendMode.overwrite, BlendColor32], readonly [BlendMode.sourceOver, BlendColor32], readonly [BlendMode.darken, BlendColor32], readonly [BlendMode.multiply, BlendColor32], readonly [BlendMode.colorBurn, BlendColor32], readonly [BlendMode.linearBurn, BlendColor32], readonly [BlendMode.darkerColor, BlendColor32], readonly [BlendMode.lighten, BlendColor32], readonly [BlendMode.screen, BlendColor32], readonly [BlendMode.colorDodge, BlendColor32], readonly [BlendMode.linearDodge, BlendColor32], readonly [BlendMode.lighterColor, BlendColor32], readonly [BlendMode.overlay, BlendColor32], readonly [BlendMode.softLight, BlendColor32], readonly [BlendMode.hardLight, BlendColor32], readonly [BlendMode.vividLight, BlendColor32], readonly [BlendMode.linearLight, BlendColor32], readonly [BlendMode.pinLight, BlendColor32], readonly [BlendMode.hardMix, BlendColor32], readonly [BlendMode.difference, BlendColor32], readonly [BlendMode.exclusion, BlendColor32], readonly [BlendMode.subtract, BlendColor32], readonly [BlendMode.divide, BlendColor32]];
-type RegisteredFastBlender = typeof FAST_BLENDER_REGISTRY[number][1];
-declare const FAST_BLEND_MODES: BlendColor32[];
-declare const FAST_BLEND_TO_INDEX: BaseBlendToIndexGetter<RegisteredFastBlender>;
-declare const INDEX_TO_FAST_BLEND: BaseIndexToBlendGetter<RegisteredFastBlender>;
-type FastBlendModes = {
-    [K in keyof typeof BlendMode]: RegisteredFastBlender;
+declare const BASE_FAST_BLEND_MODE_FUNCTIONS: Record<number, BlendColor32>;
+declare function makeFastBlendModeRegistry(): {
+    nameToBlend: {
+        readonly overwrite: BlendColor32;
+        readonly sourceOver: BlendColor32;
+        readonly darken: BlendColor32;
+        readonly multiply: BlendColor32;
+        readonly colorBurn: BlendColor32;
+        readonly linearBurn: BlendColor32;
+        readonly darkerColor: BlendColor32;
+        readonly lighten: BlendColor32;
+        readonly screen: BlendColor32;
+        readonly colorDodge: BlendColor32;
+        readonly linearDodge: BlendColor32;
+        readonly lighterColor: BlendColor32;
+        readonly overlay: BlendColor32;
+        readonly softLight: BlendColor32;
+        readonly hardLight: BlendColor32;
+        readonly vividLight: BlendColor32;
+        readonly linearLight: BlendColor32;
+        readonly pinLight: BlendColor32;
+        readonly hardMix: BlendColor32;
+        readonly difference: BlendColor32;
+        readonly exclusion: BlendColor32;
+        readonly subtract: BlendColor32;
+        readonly divide: BlendColor32;
+    };
+    nameToIndex: Record<"overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide", 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22>;
+    blendToIndex: Map<BlendColor32, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22>;
+    blendToName: Map<BlendColor32, "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide">;
+    indexToBlend: BlendColor32[];
+    indexToName: ("overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide")[];
+    indexType: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22;
+    nameType: "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide";
 };
-declare const FAST_BLEND_MODE_BY_NAME: FastBlendModes;
 
 declare const overwritePerfect: BlendColor32;
 declare const sourceOverPerfect: BlendColor32;
@@ -391,24 +447,41 @@ declare const exclusionPerfect: BlendColor32;
 declare const subtractPerfect: BlendColor32;
 /** sr === 0 ? 255 : Math.min(255, (dr << 8) / sr) */
 declare const dividePerfect: BlendColor32;
-declare const PERFECT_BLENDER_REGISTRY: readonly [readonly [BlendMode.overwrite, BlendColor32], readonly [BlendMode.sourceOver, BlendColor32], readonly [BlendMode.darken, BlendColor32], readonly [BlendMode.multiply, BlendColor32], readonly [BlendMode.colorBurn, BlendColor32], readonly [BlendMode.linearBurn, BlendColor32], readonly [BlendMode.darkerColor, BlendColor32], readonly [BlendMode.lighten, BlendColor32], readonly [BlendMode.screen, BlendColor32], readonly [BlendMode.colorDodge, BlendColor32], readonly [BlendMode.linearDodge, BlendColor32], readonly [BlendMode.lighterColor, BlendColor32], readonly [BlendMode.overlay, BlendColor32], readonly [BlendMode.softLight, BlendColor32], readonly [BlendMode.hardLight, BlendColor32], readonly [BlendMode.vividLight, BlendColor32], readonly [BlendMode.linearLight, BlendColor32], readonly [BlendMode.pinLight, BlendColor32], readonly [BlendMode.hardMix, BlendColor32], readonly [BlendMode.difference, BlendColor32], readonly [BlendMode.exclusion, BlendColor32], readonly [BlendMode.subtract, BlendColor32], readonly [BlendMode.divide, BlendColor32]];
-type RegisteredPerfectBlender = typeof PERFECT_BLENDER_REGISTRY[number][1];
-declare const PERFECT_BLEND_MODES: BlendColor32[];
-declare const PERFECT_BLEND_TO_INDEX: BaseBlendToIndexGetter<RegisteredPerfectBlender>;
-declare const INDEX_TO_PERFECT_BLEND: BaseIndexToBlendGetter<RegisteredPerfectBlender>;
-type PerfectBlendModes = {
-    [K in keyof typeof BlendMode]: RegisteredPerfectBlender;
+declare const BASE_PERFECT_BLEND_MODE_FUNCTIONS: Record<number, BlendColor32>;
+declare function makePerfectBlendModeRegistry(): {
+    nameToBlend: {
+        readonly overwrite: BlendColor32;
+        readonly sourceOver: BlendColor32;
+        readonly darken: BlendColor32;
+        readonly multiply: BlendColor32;
+        readonly colorBurn: BlendColor32;
+        readonly linearBurn: BlendColor32;
+        readonly darkerColor: BlendColor32;
+        readonly lighten: BlendColor32;
+        readonly screen: BlendColor32;
+        readonly colorDodge: BlendColor32;
+        readonly linearDodge: BlendColor32;
+        readonly lighterColor: BlendColor32;
+        readonly overlay: BlendColor32;
+        readonly softLight: BlendColor32;
+        readonly hardLight: BlendColor32;
+        readonly vividLight: BlendColor32;
+        readonly linearLight: BlendColor32;
+        readonly pinLight: BlendColor32;
+        readonly hardMix: BlendColor32;
+        readonly difference: BlendColor32;
+        readonly exclusion: BlendColor32;
+        readonly subtract: BlendColor32;
+        readonly divide: BlendColor32;
+    };
+    nameToIndex: Record<"overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide", 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22>;
+    blendToIndex: Map<BlendColor32, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22>;
+    blendToName: Map<BlendColor32, "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide">;
+    indexToBlend: BlendColor32[];
+    indexToName: ("overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide")[];
+    indexType: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22;
+    nameType: "overwrite" | "sourceOver" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "subtract" | "divide";
 };
-declare const PERFECT_BLEND_MODE_BY_NAME: PerfectBlendModes;
-
-type BaseIndexToBlendGetter<B extends BlendColor32> = {
-    get: (index: BlendModeIndex) => B;
-};
-type IndexToBlendGetter = typeof INDEX_TO_FAST_BLEND | typeof INDEX_TO_PERFECT_BLEND;
-type BaseBlendToIndexGetter<B extends BlendColor32> = {
-    get: (blend: B) => BlendModeIndex;
-};
-type BlendToIndexGetter = typeof FAST_BLEND_TO_INDEX | typeof PERFECT_BLEND_TO_INDEX;
 
 type PixelCanvas = {
     readonly canvas: HTMLCanvasElement;
@@ -488,6 +561,144 @@ declare function writeImageDataToClipboard(imageData: ImageData): Promise<void>;
  */
 declare function writeImgBlobToClipboard(blob: Blob): Promise<void>;
 
+declare class PixelEngineConfig {
+    readonly tileSize: number;
+    readonly tileShift: number;
+    readonly tileMask: number;
+    readonly tileArea: number;
+    constructor(tileSize?: number);
+}
+
+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 function applyPatchTiles(target: PixelData, tiles: PixelTile[], tileSize?: number): void;
+
+declare class PixelAccumulator {
+    target: PixelData;
+    readonly config: PixelEngineConfig;
+    lookup: (PixelTile | undefined)[];
+    beforeTiles: PixelTile[];
+    pool: PixelTile[];
+    constructor(target: PixelData, config: PixelEngineConfig);
+    getTile(id: number, tx: number, ty: number): PixelTile;
+    recyclePatch(patch: PixelPatchTiles): void;
+    /**
+     * @param x pixel x coordinate
+     * @param y pixel y coordinate
+     */
+    storeTileBeforeState(x: number, y: number): void;
+    /**
+     *
+     * @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;
+    extractState(tile: PixelTile): void;
+    extractAfterTiles(): PixelTile[];
+    reset(): void;
+}
+
+interface HistoryAction {
+    undo: () => void;
+    redo: () => void;
+    dispose?: () => void;
+}
+declare class HistoryManager {
+    maxSteps: number;
+    undoStack: HistoryAction[];
+    redoStack: HistoryAction[];
+    listeners: Set<() => void>;
+    constructor(maxSteps?: number);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    subscribe(fn: () => void): () => boolean;
+    notify(): void;
+    commit(action: HistoryAction): void;
+    undo(): void;
+    redo(): void;
+    clearRedoStack(): void;
+}
+
+interface PixelWriterOptions {
+    maxHistorySteps?: number;
+    tileSize?: number;
+    historyManager?: HistoryManager;
+}
+/**
+ * @example
+ * const targ = new PixelData(new ImageData(10, 10))
+ * const writer = new PixelWriter(targ, (writer) => {
+ *   return {
+ *     ...mutatorApplyMask(writer),
+ *     ...mutatorBlendPixelData(writer),
+ *     ...mutatorBlendColor(writer),
+ *     ...mutatorBlendPixel(writer),
+ *     ...mutatorFill(writer),
+ *   }
+ * })
+ *
+ * // to import all mutator functions
+ * const writer = new PixelWriter(targ, makeFullPixelMutator)
+ *
+ * writer.withHistory((mutator) => {
+ *   mutator.applyMask()
+ *   mutator.blendPixelData()
+ * })
+ */
+declare class PixelWriter<M> {
+    target: PixelData;
+    historyManager: HistoryManager;
+    accumulator: PixelAccumulator;
+    protected config: PixelEngineConfig;
+    private mutator;
+    constructor(target: PixelData, mutatorFactory: (writer: PixelWriter<any>) => M, { tileSize, maxHistorySteps, historyManager, }?: PixelWriterOptions);
+    withHistory(cb: (mutator: M) => void): void;
+}
+
+declare function makeFullPixelMutator(writer: PixelWriter<any>): {
+    invert(opts?: PixelMutateOptions): void;
+    fill(color: Color32, rect?: Partial<Rect>): void;
+    blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): void;
+    blendColor(color: Color32, opts?: ColorBlendOptions): void;
+    blendPixelData(src: PixelData, opts: PixelBlendOptions): void;
+    applyMask: (mask: AnyMask, opts?: ApplyMaskOptions) => void;
+};
+
+declare function mutatorApplyMask(writer: PixelWriter<any>): {
+    applyMask: (mask: AnyMask, opts?: ApplyMaskOptions) => void;
+};
+
+declare function mutatorBlendColor(writer: PixelWriter<any>): {
+    blendColor(color: Color32, opts?: ColorBlendOptions): void;
+};
+
+declare function mutatorBlendPixel(writer: PixelWriter<any>): {
+    blendPixel(x: number, y: number, color: Color32, alpha?: number, blendFn?: BlendColor32): void;
+};
+
+declare function mutatorBlendPixelData(writer: PixelWriter<any>): {
+    blendPixelData(src: PixelData, opts: PixelBlendOptions): void;
+};
+
+declare function mutatorFill(writer: PixelWriter<any>): {
+    fill(color: Color32, rect?: Partial<Rect>): void;
+};
+
+declare function mutatorInvert(writer: PixelWriter<any>): {
+    invert(opts?: PixelMutateOptions): void;
+};
+
 type ReusableImageData = ReturnType<typeof makeReusableImageData>;
 /**
  * Creates a factory function that manages a single, reusable ImageData instance.
@@ -678,7 +889,7 @@ declare function writeImageData(target: ImageData, source: ImageData, x: number,
  * @param data - The source pixel data (RGBA).
  * @param rect - A {@link Rect} object defining the destination region.
  */
-declare function writeImageDataPixels(imageData: ImageData, data: Uint8ClampedArray, rect: Rect): void;
+declare function writeImageDataBuffer(imageData: ImageData, data: Uint8ClampedArray, rect: Rect): void;
 /**
  * @param imageData - The target {@link ImageData} to write into.
  * @param data - The source pixel data (RGBA). Must match the width/height.
@@ -687,7 +898,7 @@ declare function writeImageDataPixels(imageData: ImageData, data: Uint8ClampedAr
  * @param w - The width of the region to write.
  * @param h - The height of the region to write.
  */
-declare function writeImageDataPixels(imageData: ImageData, data: Uint8ClampedArray, x: number, y: number, w: number, h: number): void;
+declare function writeImageDataBuffer(imageData: ImageData, data: Uint8ClampedArray, x: number, y: number, w: number, h: number): void;
 
 /**
  * Represents an image using a palette-based indexing system.
@@ -900,11 +1111,45 @@ declare function invertAlphaMask(dst: AlphaMask): void;
  */
 declare function mergeMasks(dst: AlphaMask, dstWidth: number, src: AnyMask, opts: ApplyMaskOptions): void;
 
+/**
+ * Applies a circular brush to pixel data, blending a color with optional falloff.
+ *
+ * @param target The PixelData to modify.
+ * @param color The brush color.
+ * @param centerX The center x-coordinate of the brush.
+ * @param centerY The center y-coordinate of the brush.
+ * @param brushSize The diameter of the brush.
+ * @param alpha The overall opacity of the brush (0-255).
+ * @default 255
+ * @param fallOff A function that returns an alpha multiplier (0-1) based on the normalized distance (0-1) from the circle's center.
+ * @param blendFn
+ * @default sourceOverPerfect
+ */
+declare function applyCircleBrushToPixelData(target: PixelData, color: Color32, centerX: number, centerY: number, brushSize: number, alpha?: number, fallOff?: (dist: number) => number, blendFn?: BlendColor32): void;
+
 /**
  * Directly applies a mask to a region of PixelData,
  * modifying the destination's alpha channel in-place.
  */
-declare function applyMaskToPixelData(dst: PixelData, mask: AnyMask, opts: ApplyMaskOptions): void;
+declare function applyMaskToPixelData(dst: PixelData, mask: AnyMask, opts?: ApplyMaskOptions): void;
+
+/**
+ * Applies a rectangular brush to pixel data, blending a color with optional falloff.
+ *
+ * @param target The PixelData to modify.
+ * @param color The brush color.
+ * @param centerX The center x-coordinate of the brush.
+ * @param centerY The center y-coordinate of the brush.
+ * @param brushWidth
+ * @param brushHeight
+ * @param alpha The overall opacity of the brush (0-255).
+ * @default 255
+ * @param fallOff A function that returns an alpha multiplier (0-1) based on the normalized distance (0-1) from the circle's center.
+ * @param blendFn
+ * @default sourceOverPerfect
+ */
+declare function applyRectBrushToPixelData(target: PixelData, color: Color32, centerX: number, centerY: number, brushWidth: number, brushHeight: number, alpha?: number, fallOff?: (dist: number) => number, blendFn?: BlendColor32): void;
+declare function getRectBrushBounds(centerX: number, centerY: number, brushWidth: number, brushHeight: number, targetWidth?: number, targetHeight?: number): Rect;
 
 /**
  * Fills a rectangle in the destination PixelData with a single color,
@@ -967,7 +1212,7 @@ declare function fillPixelData(dst: PixelData, color: Color32, rect?: Partial<Re
  */
 declare function fillPixelData(dst: PixelData, color: Color32, x: number, y: number, w: number, h: number): void;
 
-declare function invertPixelData(pixelData: PixelData): PixelData;
+declare function invertPixelData(pixelData: PixelData, opts?: PixelMutateOptions): void;
 
 /**
  * Extracts the alpha channel from PixelData into a single-channel mask.
@@ -996,6 +1241,15 @@ declare function resamplePixelData(pixelData: PixelData, factor: number): PixelD
  */
 declare function rotatePixelData(pixelData: PixelData): void;
 
+/**
+ * Copies a pixel buffer into a specific region of a {@link PixelData} object.
+ *
+ * This function performs a direct memory copy from a {@link Uint32Array}
+ * into the target {@link PixelData} buffer.
+ */
+declare function writePixelDataBuffer(target: PixelData, data: Uint32Array, rect: Rect): void;
+declare function writePixelDataBuffer(target: PixelData, data: Uint32Array, x: number, y: number, w: number, h: number): void;
+
 /**
  * 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`.
@@ -1012,4 +1266,4 @@ declare function rotatePixelData(pixelData: PixelData): void;
  */
 declare function trimRectBounds<T extends Rect | SelectionRect>(target: T, bounds: Rect): void;
 
-export { type AlphaMask, type AnyMask, type ApplyMaskOptions, type Base64EncodedUInt8Array, type BinaryMask, type BlendColor32, BlendMode, type BlendModeIndex, type BlendToIndexGetter, type Color32, type ColorBlendOptions, FAST_BLENDER_REGISTRY, FAST_BLEND_MODES, FAST_BLEND_MODE_BY_NAME, FAST_BLEND_TO_INDEX, type FastBlendModes, type FloodFillImageDataOptions, type FloodFillResult, INDEX_TO_FAST_BLEND, INDEX_TO_PERFECT_BLEND, type ImageDataLike, type IndexToBlendGetter, IndexedImage, MaskType, PERFECT_BLENDER_REGISTRY, PERFECT_BLEND_MODES, PERFECT_BLEND_MODE_BY_NAME, PERFECT_BLEND_TO_INDEX, type PerfectBlendModes, type PixelBlendOptions, type PixelCanvas, PixelData, type PixelOptions, type Point, type RGBA, type Rect, type RegisteredFastBlender, type RegisteredPerfectBlender, type ReusableCanvas, type ReusableImageData, type SelectionRect, type SerializedImageData, UnsupportedFormatError, applyMaskToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendPixelData, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataBuffer, extractMask, extractPixelData, extractPixelDataBuffer, fileInputChangeToImageData, fileToImageData, fillPixelData, floodFillSelection, getImageDataFromClipboard, getIndexedImageColorCounts, 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, makePixelCanvas, makeReusableCanvas, makeReusableImageData, mergeMasks, multiplyFast, multiplyPerfect, overlayFast, overlayPerfect, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resampleImageData, resampleIndexedImage, resamplePixelData, resizeImageData, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractFast, subtractPerfect, trimRectBounds, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageData, writeImageDataPixels, writeImageDataToClipboard, writeImgBlobToClipboard };
+export { type AlphaMask, type AnyMask, type ApplyMaskOptions, BASE_FAST_BLEND_MODE_FUNCTIONS, BASE_PERFECT_BLEND_MODE_FUNCTIONS, type Base64EncodedUInt8Array, BaseBlendMode, type BaseBlendModes, type BinaryMask, type BlendColor32, type BlendModeRegistry, type Color32, type ColorBlendOptions, type FloodFillImageDataOptions, type FloodFillResult, type HistoryAction, HistoryManager, type ImageDataLike, IndexedImage, MaskType, PixelAccumulator, type PixelBlendOptions, type PixelCanvas, PixelData, PixelEngineConfig, type PixelMaskInvertOptions, type PixelMaskRectOptions, type PixelMutateOptions, type PixelOptions, type PixelPatchTiles, type PixelRectOptions, PixelTile, PixelWriter, type PixelWriterOptions, type Point, type RGBA, type Rect, type RequiredBlendModes, type ReusableCanvas, type ReusableImageData, type SelectionRect, type SerializedImageData, UnsupportedFormatError, applyCircleBrushToPixelData, applyMaskToPixelData, applyPatchTiles, applyRectBrushToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendPixelData, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataBuffer, extractMask, extractPixelData, extractPixelDataBuffer, fileInputChangeToImageData, fileToImageData, fillPixelData, floodFillSelection, getImageDataFromClipboard, getIndexedImageColorCounts, getRectBrushBounds, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMask, imageDataToDataUrl, imageDataToImgBlob, imageDataToUInt32Array, imgBlobToImageData, indexedImageToAverageColor, indexedImageToImageData, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeBlendModeRegistry, makeFastBlendModeRegistry, makeFullPixelMutator, makePerfectBlendModeRegistry, makePixelCanvas, makeReusableCanvas, makeReusableImageData, mergeMasks, multiplyFast, multiplyPerfect, mutatorApplyMask, mutatorBlendColor, mutatorBlendPixel, mutatorBlendPixelData, mutatorFill, mutatorInvert, overlayFast, overlayPerfect, overwriteBase, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resampleImageData, resampleIndexedImage, resamplePixelData, resizeImageData, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractFast, subtractPerfect, trimRectBounds, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageData, writeImageDataBuffer, writeImageDataToClipboard, writeImgBlobToClipboard, writePixelDataBuffer };