pixel-data-js 0.18.0 → 0.19.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pixel-data-js",
   "type": "module",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "packageManager": "pnpm@10.30.0",
   "description": "JS Pixel and ImageData operations",
   "author": {
@@ -49,32 +49,47 @@
   "scripts": {
     "build": "tsup",
     "test": "vitest --coverage --project unit",
+    "test:build": "pnpm build && vitest run --project dist",
     "test:mutation": "stryker run",
-    "docs": "npx typedoc --entryPointStrategy Expand src",
+    "docs": "npx typedoc",
     "typecheck": "tsc --noEmit",
-    "check-exports": "tsx bin/check-exports.ts -- .test.ts .d.ts",
-    "bench": "npx vitest --project browser"
+    "check-exports": "tsx _scripts/check-exports.ts",
+    "sort": "tsx _scripts/apply-sorting.ts",
+    "bench": "tsx ./benchmark/run.ts",
+    "bench:all": "tsx ./benchmark/run-all.ts",
+    "bench:compare": "tsx ./benchmark/compare.ts"
   },
   "devDependencies": {
+    "@clack/prompts": "^1.1.0",
+    "@mitata/counters": "^0.0.8",
     "@napi-rs/canvas": "^0.1.93",
     "@stryker-mutator/core": "^9.5.1",
     "@stryker-mutator/typescript-checker": "^9.5.1",
     "@stryker-mutator/vitest-runner": "^9.5.1",
+    "@types/cli-progress": "^3.11.6",
     "@types/node": "^25.2.3",
     "@vitest/browser": "3.2.4",
     "@vitest/coverage-v8": "3.2.4",
+    "cli-progress": "^3.12.0",
+    "cmd-ts": "^0.15.0",
     "console-table-printer": "^2.15.0",
     "esbuild": "^0.27.3",
+    "execa": "^9.6.1",
+    "fast-glob": "^3.3.3",
     "jsdom": "^28.1.0",
-    "playwright": "^1.58.2",
-    "pretty-ms": "^9.3.0",
-    "tinybench": "^6.0.0",
+    "mitata-ts": "^1.0.4",
+    "picocolors": "^1.1.1",
+    "sanitize-filename": "^1.6.3",
+    "sharp": "^0.34.5",
+    "simple-git": "^3.33.0",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typedoc": "^0.28.17",
     "typedoc-plugin-mdn-links": "^5.1.1",
     "typedoc-rhineai-theme": "^1.2.0",
     "typescript": "^5.9.3",
+    "unplugin-inline": "^1.8.0",
+    "vite-tsconfig-paths": "^6.1.1",
     "vitest": "3.2.4"
   },
   "repository": {

package/src/Algorithm/forEachLinePoint.ts

@@ -0,0 +1,36 @@
+/**
+ * Iterates through a line with sub-pixel precision.
+ * Guarantees that the first and last points are exactly (x0, y0) and (x1, y1).
+ */
+export function forEachLinePoint(
+  x0: number,
+  y0: number,
+  x1: number,
+  y1: number,
+  callback: (x: number, y: number) => void,
+): void {
+  const dx = x1 - x0
+  const dy = y1 - y0
+
+  // Determine the number of steps based on the longest axis
+  const steps = Math.max(Math.abs(dx), Math.abs(dy))
+
+  // Handle the zero-length line (Single Stamp Case)
+  if (steps === 0) {
+    callback(x0, y0)
+    return
+  }
+
+  const xInc = dx / steps
+  const yInc = dy / steps
+
+  let curX = x0
+  let curY = y0
+
+  // We add +1 to the loop to ensure we reach the final (x1, y1)
+  for (let i = 0; i <= steps; i++) {
+    callback(curX, curY)
+    curX += xInc
+    curY += yInc
+  }
+}

package/src/BlendModes/BlendModeRegistry.ts

@@ -15,6 +15,7 @@ export function makeBlendModeRegistry<
 >(
   blendModes: BlendModes,
   initialEntries: Record<Index, BlendColor32>,
+  registryName = 'anonymous',
 ) {
 
   const blendToName = new Map<BlendColor32, Name>()
@@ -47,6 +48,7 @@ export function makeBlendModeRegistry<
   }
 
   return {
+    registryName,
     nameToBlend,
     nameToIndex,
 

package/src/BlendModes/blend-modes-fast.ts

@@ -604,6 +604,6 @@ export const BASE_FAST_BLEND_MODE_FUNCTIONS: Record<number, BlendColor32> = {
   [BaseBlendMode.divide]: divideFast,
 }
 
-export function makeFastBlendModeRegistry() {
-  return makeBlendModeRegistry(BaseBlendMode, BASE_FAST_BLEND_MODE_FUNCTIONS)
+export function makeFastBlendModeRegistry(name = 'fast') {
+  return makeBlendModeRegistry(BaseBlendMode, BASE_FAST_BLEND_MODE_FUNCTIONS, name)
 }

package/src/BlendModes/blend-modes-perfect.ts

@@ -9,12 +9,13 @@ export const sourceOverPerfect: BlendColor32 = (src, dst) => {
   if (sa === 255) return src
   if (sa === 0) return dst
 
-  const invA = 255 - sa
+  const da = (dst >>> 24) & 0xFF
+  if (da === 0) return src
 
   const sr = src & 0xFF, sg = (src >>> 8) & 0xFF, sb = (src >>> 16) & 0xFF
   const dr = dst & 0xFF, dg = (dst >>> 8) & 0xFF, db = (dst >>> 16) & 0xFF
-  const da = (dst >>> 24) & 0xFF
 
+  const invA = 255 - sa
   // Exact division by 255 using bit-shifts
   // Formula: (v + 1 + (v >> 8)) >> 8
   const tR = (sr * sa + dr * invA)
@@ -774,6 +775,6 @@ export const BASE_PERFECT_BLEND_MODE_FUNCTIONS: Record<number, BlendColor32> = {
   [BaseBlendMode.divide]: dividePerfect,
 }
 
-export function makePerfectBlendModeRegistry() {
-  return makeBlendModeRegistry(BaseBlendMode, BASE_PERFECT_BLEND_MODE_FUNCTIONS)
+export function makePerfectBlendModeRegistry(name = 'perfect') {
+  return makeBlendModeRegistry(BaseBlendMode, BASE_PERFECT_BLEND_MODE_FUNCTIONS, name)
 }

package/src/BlendModes/toBlendModeIndexAndName.ts

@@ -0,0 +1,41 @@
+import { BaseBlendMode } from './blend-modes'
+
+export function toBlendModeIndexAndName(input: string | number) {
+  if (typeof input === 'number') {
+    const name = getKeyByValue(BaseBlendMode, input)
+    if (name === undefined) throw new Error(`Invalid index: ${input}`)
+    return { blendIndex: input, blendName: name }
+  }
+
+  const trimmed = input.trim()
+  const num = Number(trimmed)
+  const isNumeric = trimmed !== '' && !Number.isNaN(num)
+
+  if (isNumeric && Number.isInteger(num)) {
+    console.log({
+      trimmed,
+      num,
+      isNumeric,
+      isInt: Number.isInteger(num),
+    })
+    const name = getKeyByValue(BaseBlendMode, num)
+    console.log({name})
+    if (name === undefined) throw new Error(`Invalid index: ${num}`)
+    return { blendIndex: num, blendName: name }
+  }
+
+  if (trimmed in BaseBlendMode) {
+    return {
+      blendIndex: BaseBlendMode[trimmed as keyof typeof BaseBlendMode],
+      blendName: trimmed as keyof typeof BaseBlendMode,
+    }
+  }
+
+  throw new Error(`Invalid blend mode: ${JSON.stringify(input)}`)
+}
+
+const getKeyByValue = (obj: any, value: any) => {
+  for (const key in obj) {
+    if (obj[key] === value) return key
+  }
+}

package/src/History/PixelAccumulator.ts

@@ -1,4 +1,4 @@
-import type { PixelData } from '../PixelData/PixelData'
+import type { IPixelData } from '../_types'
 import type { PixelEngineConfig } from './PixelEngineConfig'
 import { type PixelPatchTiles, PixelTile } from './PixelPatchTiles'
 
@@ -8,7 +8,7 @@ export class PixelAccumulator {
   public pool: PixelTile[]
 
   constructor(
-    public target: PixelData,
+    public target: IPixelData,
     readonly config: PixelEngineConfig,
   ) {
     this.lookup = []

package/src/History/PixelMutator/mutatorApplyAlphaMask.ts

@@ -0,0 +1,30 @@
+import { type AlphaMask, type ApplyMaskToPixelDataOptions, type HistoryMutator } from '../../_types'
+import { applyAlphaMaskToPixelData } from '../../PixelData/applyAlphaMaskToPixelData'
+import { PixelWriter } from '../PixelWriter'
+
+const defaults = {
+  applyAlphaMaskToPixelData,
+}
+
+type Deps = Partial<typeof defaults>
+
+export const mutatorApplyAlphaMask = ((writer: PixelWriter<any>, deps: Deps = defaults) => {
+  const {
+    applyAlphaMaskToPixelData = defaults.applyAlphaMaskToPixelData,
+  } = deps
+
+  return {
+    applyAlphaMask: (mask: AlphaMask, opts: ApplyMaskToPixelDataOptions = {}) => {
+      let target = writer.target
+      const {
+        x = 0,
+        y = 0,
+        w = writer.target.width,
+        h = writer.target.height,
+      } = opts
+
+      writer.accumulator.storeRegionBeforeState(x, y, w, h)
+      applyAlphaMaskToPixelData(target, mask, opts)
+    },
+  }
+}) satisfies HistoryMutator<any, Deps>

package/src/History/PixelMutator/mutatorApplyBinaryMask.ts

@@ -0,0 +1,30 @@
+import { type ApplyMaskToPixelDataOptions, type BinaryMask, type HistoryMutator } from '../../_types'
+import { applyBinaryMaskToPixelData } from '../../PixelData/applyBinaryMaskToPixelData'
+import { PixelWriter } from '../PixelWriter'
+
+const defaults = {
+  applyBinaryMaskToPixelData,
+}
+
+type Deps = Partial<typeof defaults>
+
+export const mutatorApplyBinaryMask = ((writer: PixelWriter<any>, deps: Deps = defaults) => {
+  const {
+    applyBinaryMaskToPixelData = defaults.applyBinaryMaskToPixelData,
+  } = deps
+
+  return {
+    applyBinaryMask: (mask: BinaryMask, opts: ApplyMaskToPixelDataOptions = {}) => {
+      let target = writer.target
+      const {
+        x = 0,
+        y = 0,
+        w = writer.target.width,
+        h = writer.target.height,
+      } = opts
+
+      writer.accumulator.storeRegionBeforeState(x, y, w, h)
+      applyBinaryMaskToPixelData(target, mask, opts)
+    },
+  }
+}) satisfies HistoryMutator<any, Deps>

package/src/History/PixelMutator/mutatorApplyCircleBrush.ts

@@ -1,10 +1,24 @@
-import type { BlendColor32, Color32, Rect } from '../../_types'
-import { applyCircleBrushToPixelData, getCircleBrushBounds } from '../../PixelData/applyCircleBrushToPixelData'
+import type { BlendColor32, Color32, HistoryMutator, Rect } from '../../_types'
+import { applyCircleBrushToPixelData } from '../../PixelData/applyCircleBrushToPixelData'
+import { getCircleBrushOrPencilBounds } from '../../Rect/getCircleBrushOrPencilBounds'
 import { PixelWriter } from '../PixelWriter'
 
-const boundsOut: Rect = { x: 0, y: 0, w: 0, h: 0 }
+const defaults = {
+  applyCircleBrushToPixelData,
+  getCircleBrushOrPencilBounds,
+}
+
+type Deps = Partial<typeof defaults>
+
+export const mutatorApplyCircleBrush = ((writer: PixelWriter<any>, deps: Deps = defaults) => {
+  const {
+    applyCircleBrushToPixelData = defaults.applyCircleBrushToPixelData,
+    getCircleBrushOrPencilBounds = defaults.getCircleBrushOrPencilBounds,
+
+  } = deps
+
+  const boundsOut: Rect = { x: 0, y: 0, w: 0, h: 0 }
 
-export function mutatorApplyCircleBrush(writer: PixelWriter<any>) {
   return {
     applyCircleBrush(
       color: Color32,
@@ -12,11 +26,11 @@ export function mutatorApplyCircleBrush(writer: PixelWriter<any>) {
       centerY: number,
       brushSize: number,
       alpha = 255,
-      fallOff?: (dist: number) => number,
+      fallOff: (dist: number) => number,
       blendFn?: BlendColor32,
     ) {
 
-      const circleBounds = getCircleBrushBounds(
+      const bounds = getCircleBrushOrPencilBounds(
         centerX,
         centerY,
         brushSize,
@@ -25,7 +39,7 @@ export function mutatorApplyCircleBrush(writer: PixelWriter<any>) {
         boundsOut,
       )
 
-      const { x, y, w, h } = circleBounds
+      const { x, y, w, h } = bounds
 
       writer.accumulator.storeRegionBeforeState(x, y, w, h)
 
@@ -38,8 +52,8 @@ export function mutatorApplyCircleBrush(writer: PixelWriter<any>) {
         alpha,
         fallOff,
         blendFn,
-        circleBounds,
+        bounds,
       )
     },
   }
-}
+}) satisfies HistoryMutator<any, Deps>

package/src/History/PixelMutator/mutatorApplyCircleBrushStroke.ts

@@ -0,0 +1,138 @@
+import {
+  type AlphaMask,
+  type BlendColor32,
+  type Color32,
+  type ColorBlendMaskOptions,
+  type HistoryMutator,
+  type Rect,
+} from '../../_types'
+import { forEachLinePoint } from '../../Algorithm/forEachLinePoint'
+import { sourceOverPerfect } from '../../BlendModes/blend-modes-perfect'
+import { blendColorPixelDataAlphaMask } from '../../PixelData/blendColorPixelDataAlphaMask'
+import { getCircleBrushOrPencilBounds } from '../../Rect/getCircleBrushOrPencilBounds'
+import { getCircleBrushOrPencilStrokeBounds } from '../../Rect/getCircleBrushOrPencilStrokeBounds'
+import { PixelWriter } from '../PixelWriter'
+
+const defaults = {
+  forEachLinePoint,
+  blendColorPixelDataAlphaMask,
+  getCircleBrushOrPencilBounds,
+  getCircleBrushOrPencilStrokeBounds,
+}
+
+type Deps = Partial<typeof defaults>
+
+export const mutatorApplyCircleBrushStroke = ((writer: PixelWriter<any>, deps: Deps = defaults) => {
+  const {
+    forEachLinePoint = defaults.forEachLinePoint,
+    blendColorPixelDataAlphaMask = defaults.blendColorPixelDataAlphaMask,
+    getCircleBrushOrPencilBounds = defaults.getCircleBrushOrPencilBounds,
+    getCircleBrushOrPencilStrokeBounds = defaults.getCircleBrushOrPencilStrokeBounds,
+  } = deps
+
+  const strokeBoundsOut: Rect = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0,
+  }
+
+  const circleBrushBounds: Rect = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0,
+  }
+
+  const blendColorPixelOptions: ColorBlendMaskOptions = {
+    alpha: 255,
+    blendFn: sourceOverPerfect,
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0,
+  }
+
+  return {
+    applyCircleBrushStroke(
+      color: Color32,
+      x0: number,
+      y0: number,
+      x1: number,
+      y1: number,
+      brushSize: number,
+      alpha = 255,
+      fallOff: (dist: number) => number,
+      blendFn: BlendColor32 = sourceOverPerfect,
+    ) {
+      const {
+        x: bx,
+        y: by,
+        w: bw,
+        h: bh,
+      } = getCircleBrushOrPencilStrokeBounds(x0, y0, x1, y1, brushSize, strokeBoundsOut)
+
+      if (bw <= 0 || bh <= 0) return
+
+      const mask = new Uint8Array(bw * bh) as AlphaMask
+
+      const r = brushSize / 2
+      const rSqr = r * r
+      const invR = 1 / r
+      const centerOffset = (brushSize % 2 === 0) ? 0.5 : 0
+
+      const targetWidth = writer.target.width
+      const targetHeight = writer.target.height
+
+      forEachLinePoint(x0, y0, x1, y1, (px, py) => {
+        // 2. Calculate bounds for this specific stamp
+        const {
+          x: cbx,
+          y: cby,
+          w: cbw,
+          h: cbh,
+        } = getCircleBrushOrPencilBounds(px, py, brushSize, targetWidth, targetHeight, circleBrushBounds)
+
+        writer.accumulator.storeRegionBeforeState(cbx, cby, cbw, cbh)
+
+        const startX = Math.max(bx, cbx)
+        const startY = Math.max(by, cby)
+        const endX = Math.min(bx + bw, cbx + cbw)
+        const endY = Math.min(by + bh, cby + cbh)
+
+        const fPx = Math.floor(px)
+        const fPy = Math.floor(py)
+
+        for (let my = startY; my < endY; my++) {
+          const dy = (my - fPy) + centerOffset
+          const dySqr = dy * dy
+          const maskRowOffset = (my - by) * bw
+
+          for (let mx = startX; mx < endX; mx++) {
+            const dx = (mx - fPx) + centerOffset
+            const dSqr = dx * dx + dySqr
+
+            if (dSqr <= rSqr) {
+              const maskIdx = maskRowOffset + (mx - bx)
+
+              const dist = Math.sqrt(dSqr) * invR
+              const intensity = (fallOff(1 - dist) * 255) | 0
+              if (intensity > mask[maskIdx]) {
+                mask[maskIdx] = intensity
+              }
+            }
+          }
+        }
+      })
+
+      blendColorPixelOptions.blendFn = blendFn
+      blendColorPixelOptions.alpha = alpha
+      blendColorPixelOptions.x = bx
+      blendColorPixelOptions.y = by
+      blendColorPixelOptions.w = bw
+      blendColorPixelOptions.h = bh
+
+      blendColorPixelDataAlphaMask(writer.target, color, mask, blendColorPixelOptions)
+    },
+  }
+}) satisfies HistoryMutator<any, Deps>

package/src/History/PixelMutator/mutatorApplyCirclePencil.ts

@@ -0,0 +1,59 @@
+import type { BlendColor32, Color32, HistoryMutator, Rect } from '../../_types'
+import { applyCircleBrushToPixelData } from '../../PixelData/applyCircleBrushToPixelData'
+import { getCircleBrushOrPencilBounds } from '../../Rect/getCircleBrushOrPencilBounds'
+import { PixelWriter } from '../PixelWriter'
+
+const defaults = {
+  applyCircleBrushToPixelData,
+  getCircleBrushOrPencilBounds,
+  fallOff: () => 1,
+}
+
+type Deps = Partial<typeof defaults>
+
+export const mutatorApplyCirclePencil = ((writer: PixelWriter<any>, deps: Deps = defaults) => {
+  const {
+    applyCircleBrushToPixelData = defaults.applyCircleBrushToPixelData,
+    getCircleBrushOrPencilBounds = defaults.getCircleBrushOrPencilBounds,
+    fallOff = defaults.fallOff,
+  } = deps
+
+  const boundsOut: Rect = { x: 0, y: 0, w: 0, h: 0 }
+
+  return {
+    applyCirclePencil(
+      color: Color32,
+      centerX: number,
+      centerY: number,
+      brushSize: number,
+      alpha = 255,
+      blendFn?: BlendColor32,
+    ) {
+
+      const bounds = getCircleBrushOrPencilBounds(
+        centerX,
+        centerY,
+        brushSize,
+        writer.target.width,
+        writer.target.height,
+        boundsOut,
+      )
+
+      const { x, y, w, h } = bounds
+
+      writer.accumulator.storeRegionBeforeState(x, y, w, h)
+
+      applyCircleBrushToPixelData(
+        writer.target,
+        color,
+        centerX,
+        centerY,
+        brushSize,
+        alpha,
+        fallOff,
+        blendFn,
+        bounds,
+      )
+    },
+  }
+}) satisfies HistoryMutator<any, Deps>

package/src/History/PixelMutator/mutatorApplyCirclePencilStroke.ts

@@ -0,0 +1,131 @@
+import {
+  type BinaryMask,
+  type BlendColor32,
+  type Color32,
+  type ColorBlendMaskOptions,
+  type HistoryMutator,
+  type Rect,
+} from '../../_types'
+import { forEachLinePoint } from '../../Algorithm/forEachLinePoint'
+import { sourceOverPerfect } from '../../BlendModes/blend-modes-perfect'
+import { blendColorPixelDataBinaryMask } from '../../PixelData/blendColorPixelDataBinaryMask'
+import { getCircleBrushOrPencilBounds } from '../../Rect/getCircleBrushOrPencilBounds'
+import { getCircleBrushOrPencilStrokeBounds } from '../../Rect/getCircleBrushOrPencilStrokeBounds'
+import { PixelWriter } from '../PixelWriter'
+
+const defaults = {
+  forEachLinePoint,
+  blendColorPixelDataBinaryMask,
+  getCircleBrushOrPencilBounds,
+  getCircleBrushOrPencilStrokeBounds,
+}
+
+type Deps = Partial<typeof defaults>
+
+export const mutatorApplyCirclePencilStroke = ((writer: PixelWriter<any>, deps: Deps = defaults) => {
+  const {
+    forEachLinePoint = defaults.forEachLinePoint,
+    blendColorPixelDataBinaryMask = defaults.blendColorPixelDataBinaryMask,
+    getCircleBrushOrPencilStrokeBounds = defaults.getCircleBrushOrPencilStrokeBounds,
+    getCircleBrushOrPencilBounds = defaults.getCircleBrushOrPencilBounds,
+  } = deps
+
+  const strokeBoundsOut: Rect = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0,
+  }
+
+  const circlePencilBounds: Rect = {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0,
+  }
+
+  const blendColorPixelOptions: ColorBlendMaskOptions = {
+    alpha: 255,
+    blendFn: sourceOverPerfect,
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0,
+  }
+
+  return {
+    applyCirclePencilStroke(
+      color: Color32,
+      x0: number,
+      y0: number,
+      x1: number,
+      y1: number,
+      brushSize: number,
+      alpha = 255,
+      blendFn: BlendColor32 = sourceOverPerfect,
+    ) {
+      const {
+        x: bx,
+        y: by,
+        w: bw,
+        h: bh,
+      } = getCircleBrushOrPencilStrokeBounds(x0, y0, x1, y1, brushSize, strokeBoundsOut)
+
+      if (bw <= 0 || bh <= 0) return
+
+      const mask = new Uint8Array(bw * bh) as BinaryMask
+
+      const r = brushSize / 2
+      const rSqr = r * r
+      const centerOffset = (brushSize % 2 === 0) ? 0.5 : 0
+
+      const targetWidth = writer.target.width
+      const targetHeight = writer.target.height
+
+      forEachLinePoint(x0, y0, x1, y1, (px, py) => {
+        // 2. Calculate bounds for this specific stamp
+        const {
+          x: cbx,
+          y: cby,
+          w: cbw,
+          h: cbh,
+        } = getCircleBrushOrPencilBounds(px, py, brushSize, targetWidth, targetHeight, circlePencilBounds)
+
+        writer.accumulator.storeRegionBeforeState(cbx, cby, cbw, cbh)
+
+        const startX = Math.max(bx, cbx)
+        const startY = Math.max(by, cby)
+        const endX = Math.min(bx + bw, cbx + cbw)
+        const endY = Math.min(by + bh, cby + cbh)
+
+        const fPx = Math.floor(px)
+        const fPy = Math.floor(py)
+
+        for (let my = startY; my < endY; my++) {
+          const dy = (my - fPy) + centerOffset
+          const dySqr = dy * dy
+          const maskRowOffset = (my - by) * bw
+
+          for (let mx = startX; mx < endX; mx++) {
+            const dx = (mx - fPx) + centerOffset
+            const dSqr = dx * dx + dySqr
+
+            if (dSqr <= rSqr) {
+              const maskIdx = maskRowOffset + (mx - bx)
+              mask[maskIdx] = 1
+            }
+          }
+        }
+      })
+
+      blendColorPixelOptions.blendFn = blendFn
+      blendColorPixelOptions.alpha = alpha
+      blendColorPixelOptions.x = bx
+      blendColorPixelOptions.y = by
+      blendColorPixelOptions.w = bw
+      blendColorPixelOptions.h = bh
+
+      blendColorPixelDataBinaryMask(writer.target, color, mask, blendColorPixelOptions)
+    },
+  }
+}) satisfies HistoryMutator<any, Deps>