pixel-data-js 0.0.3 → 0.2.0

package/src/ImageData/blend-modes.ts

@@ -0,0 +1,228 @@
+import type { BlendColor32, Color32 } from '../_types'
+
+export const sourceOverColor32: BlendColor32 = (src, dst) => {
+  const a = (src >>> 24) & 0xFF
+  if (a === 255) return src
+  if (a === 0) return dst
+
+  // Pattern: (src * a + dst * (255 - a)) >> 8
+  // We process RB and G separately so they don't overflow into each other
+  const rbMask = 0xFF00FF
+  const gMask = 0x00FF00
+
+  const sRB = src & rbMask
+  const sG = src & gMask
+  const dRB = dst & rbMask
+  const dG = dst & gMask
+
+  const invA = 255 - a
+
+  const outRB = ((sRB * a + dRB * invA) >> 8) & rbMask
+  const outG = ((sG * a + dG * invA) >> 8) & gMask
+
+  // Re-pack with opaque alpha (or calculate combined alpha if needed)
+  const outA = (a + (((dst >>> 24) & 0xFF) * invA >> 8))
+  return ((outA << 24) | outRB | outG) >>> 0 as Color32
+}
+
+/**
+ * Screen: Lightens the destination (inverse of Multiply).
+ * Result = 1 - ((1 - Src) * (1 - Dst))
+ */
+export const screenColor32: BlendColor32 = (src, dst) => {
+  const sa = (src >>> 24) & 0xFF
+  if (sa === 0) return dst
+
+  const dr = dst & 0xFF, dg = (dst >> 8) & 0xFF, db = (dst >> 16) & 0xFF
+
+  // 1. Core Math
+  const br = 255 - (((255 - (src & 0xFF)) * (255 - dr)) >> 8)
+  const bg = 255 - (((255 - ((src >> 8) & 0xFF)) * (255 - dg)) >> 8)
+  const bb = 255 - (((255 - ((src >> 16) & 0xFF)) * (255 - db)) >> 8)
+
+  if (sa === 255) return (0xFF000000 | (bb << 16) | (bg << 8) | br) >>> 0 as Color32
+
+  // 2. Alpha Lerp inlined
+  const invA = 255 - sa
+  const r = (br * sa + dr * invA) >> 8
+  const g = (bg * sa + dg * invA) >> 8
+  const b = (bb * sa + db * invA) >> 8
+  const a = (255 * sa + ((dst >>> 24) & 0xFF) * invA) >> 8
+
+  return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0 as Color32
+}
+
+/**
+ * Linear Dodge (Additive): Simply adds the source to the destination.
+ * Clamps at 255.
+ */
+export const linearDodgeColor32: BlendColor32 = (src, dst) => {
+  const sa = (src >>> 24) & 0xFF
+  if (sa === 0) return dst
+
+  const dr = dst & 0xFF, dg = (dst >> 8) & 0xFF, db = (dst >> 16) & 0xFF
+
+  // 1. Core Math (Additive with clamping)
+  const br = Math.min(255, (src & 0xFF) + dr)
+  const bg = Math.min(255, ((src >> 8) & 0xFF) + dg)
+  const bb = Math.min(255, ((src >> 16) & 0xFF) + db)
+
+  if (sa === 255) return (0xFF000000 | (bb << 16) | (bg << 8) | br) >>> 0 as Color32
+
+  // 2. Alpha Lerp inlined
+  const invA = 255 - sa
+  const r = (br * sa + dr * invA) >> 8
+  const g = (bg * sa + dg * invA) >> 8
+  const b = (bb * sa + db * invA) >> 8
+  const a = (255 * sa + ((dst >>> 24) & 0xFF) * invA) >> 8
+
+  return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0 as Color32
+}
+
+/**
+ * Multiply: Darkens the destination based on the source color.
+ * Result = (Src * Dst) / 255
+ */
+export const multiplyColor32: BlendColor32 = (src, dst) => {
+  const sa = (src >>> 24) & 0xFF
+  if (sa === 0) return dst
+
+  const dr = dst & 0xFF, dg = (dst >> 8) & 0xFF, db = (dst >> 16) & 0xFF
+
+  // 1. Core Math
+  const br = ((src & 0xFF) * dr) >> 8
+  const bg = (((src >> 8) & 0xFF) * dg) >> 8
+  const bb = (((src >> 16) & 0xFF) * db) >> 8
+
+  if (sa === 255) return (0xFF000000 | (bb << 16) | (bg << 8) | br) >>> 0 as Color32
+
+  // 2. Alpha Lerp inlined
+  const invA = 255 - sa
+  const r = (br * sa + dr * invA) >> 8
+  const g = (bg * sa + dg * invA) >> 8
+  const b = (bb * sa + db * invA) >> 8
+  const a = (255 * sa + ((dst >>> 24) & 0xFF) * invA) >> 8
+
+  return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0 as Color32
+}
+
+/**
+ * Difference: Subtracts the darker color from the lighter color.
+ * Result = |Src - Dst|
+ */
+export const differenceColor32: BlendColor32 = (src, dst) => {
+  const sa = (src >>> 24) & 0xFF
+  if (sa === 0) return dst
+
+  const dr = dst & 0xFF, dg = (dst >> 8) & 0xFF, db = (dst >> 16) & 0xFF
+
+  // 1. Core Math
+  const br = Math.abs((src & 0xFF) - dr)
+  const bg = Math.abs(((src >> 8) & 0xFF) - dg)
+  const bb = Math.abs(((src >> 16) & 0xFF) - db)
+
+  if (sa === 255) return (0xFF000000 | (bb << 16) | (bg << 8) | br) >>> 0 as Color32
+
+  // 2. Alpha Lerp inlined
+  const invA = 255 - sa
+  const r = (br * sa + dr * invA) >> 8
+  const g = (bg * sa + dg * invA) >> 8
+  const b = (bb * sa + db * invA) >> 8
+  const a = (255 * sa + ((dst >>> 24) & 0xFF) * invA) >> 8
+
+  return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0 as Color32
+}
+
+/**
+ * Hard Light: Decides Multiply vs Screen based on SOURCE brightness.
+ * Acts like a harsh spotlight.
+ */
+export const hardLightColor32: BlendColor32 = (src, dst) => {
+  const sa = (src >>> 24) & 0xFF
+  if (sa === 0) return dst
+
+  const sr = src & 0xFF, sg = (src >> 8) & 0xFF, sb = (src >> 16) & 0xFF
+  const dr = dst & 0xFF, dg = (dst >> 8) & 0xFF, db = (dst >> 16) & 0xFF
+
+  // 1. Core Math
+  const br = sr < 128 ? (2 * sr * dr) >> 8 : 255 - (2 * (255 - sr) * (255 - dr) >> 8)
+  const bg = sg < 128 ? (2 * sg * dg) >> 8 : 255 - (2 * (255 - sg) * (255 - dg) >> 8)
+  const bb = sb < 128 ? (2 * sb * db) >> 8 : 255 - (2 * (255 - sb) * (255 - db) >> 8)
+
+  if (sa === 255) return (0xFF000000 | (bb << 16) | (bg << 8) | br) >>> 0 as Color32
+
+  // 2. Alpha Lerp inlined
+  const invA = 255 - sa
+  const r = (br * sa + dr * invA) >> 8
+  const g = (bg * sa + dg * invA) >> 8
+  const b = (bb * sa + db * invA) >> 8
+  const a = (255 * sa + ((dst >>> 24) & 0xFF) * invA) >> 8
+
+  return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0 as Color32
+}
+
+/**
+ * Color Burn: Darkens the destination to reflect the source color.
+ * Intense saturation in the darks.
+ */
+export const colorBurnColor32: BlendColor32 = (src, dst) => {
+  const sa = (src >>> 24) & 0xFF
+  if (sa === 0) return dst
+
+  const sr = src & 0xFF, sg = (src >> 8) & 0xFF, sb = (src >> 16) & 0xFF
+  const dr = dst & 0xFF, dg = (dst >> 8) & 0xFF, db = (dst >> 16) & 0xFF
+
+  // 1. Core Math (Avoid division by zero)
+  const br = dr === 255 ? 255 : Math.max(0, 255 - ((255 - dr) << 8) / (sr || 1))
+  const bg = dg === 255 ? 255 : Math.max(0, 255 - ((255 - dg) << 8) / (sg || 1))
+  const bb = db === 255 ? 255 : Math.max(0, 255 - ((255 - db) << 8) / (sb || 1))
+
+  if (sa === 255) return (0xFF000000 | (bb << 16) | (bg << 8) | br) >>> 0 as Color32
+
+  // 2. Alpha Lerp inlined
+  const invA = 255 - sa
+  const r = (br * sa + dr * invA) >> 8
+  const g = (bg * sa + dg * invA) >> 8
+  const b = (bb * sa + db * invA) >> 8
+  const a = (255 * sa + ((dst >>> 24) & 0xFF) * invA) >> 8
+
+  return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0 as Color32
+}
+/**
+ * Overlay: The classic "Contrast" mode.
+ * Decides Multiply vs Screen based on DESTINATION brightness.
+ */
+export const overlayColor32: BlendColor32 = (src, dst) => {
+  const sa = (src >>> 24) & 0xFF
+  if (sa === 0) return dst
+
+  const sr = src & 0xFF, sg = (src >> 8) & 0xFF, sb = (src >> 16) & 0xFF
+  const dr = dst & 0xFF, dg = (dst >> 8) & 0xFF, db = (dst >> 16) & 0xFF
+
+  // 1. Core Math
+  const br = dr < 128 ? (2 * sr * dr) >> 8 : 255 - (2 * (255 - sr) * (255 - dr) >> 8)
+  const bg = dg < 128 ? (2 * sg * dg) >> 8 : 255 - (2 * (255 - sg) * (255 - dg) >> 8)
+  const bb = db < 128 ? (2 * sb * db) >> 8 : 255 - (2 * (255 - sb) * (255 - db) >> 8)
+
+  if (sa === 255) return (0xFF000000 | (bb << 16) | (bg << 8) | br) >>> 0 as Color32
+
+  // 2. Alpha Lerp inlined
+  const invA = 255 - sa
+  const r = (br * sa + dr * invA) >> 8
+  const g = (bg * sa + dg * invA) >> 8
+  const b = (bb * sa + db * invA) >> 8
+  const a = (255 * sa + ((dst >>> 24) & 0xFF) * invA) >> 8
+
+  return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0 as Color32
+}
+
+export const COLOR_32_BLEND_MODES = {
+  sourceOver: sourceOverColor32,
+  screen: screenColor32,
+  linearDodge: linearDodgeColor32,
+  multiply: multiplyColor32,
+  difference: differenceColor32,
+  overlay: overlayColor32,
+  hardLight: hardLightColor32,
+  colorBurn: colorBurnColor32,
+}

package/src/ImageData/blit.ts

@@ -0,0 +1,177 @@
+import { type AnyMask, type BlendColor32, type Color32, type ImageDataLike, MaskType } from '../_types'
+import { sourceOverColor32 } from './blend-modes'
+
+export type BlendImageDataOptions = {
+  /**
+   * The x-coordinate in the destination image where the blend begins.
+   * @default 0
+   */
+  dx?: number
+
+  /**
+   * The y-coordinate in the destination image where the blend begins.
+   * @default 0
+   */
+  dy?: number
+
+  /**
+   * The x-coordinate of the top-left corner of the sub-rectangle
+   * of the source image to extract.
+   * @default 0
+   */
+  sx?: number
+
+  /**
+   * The y-coordinate of the top-left corner of the sub-rectangle
+   * of the source image to extract.
+   * @default 0
+   */
+  sy?: number
+
+  /**
+   * The width of the sub-rectangle of the source image to extract.
+   * Defaults to the full remaining width of the source.
+   */
+  sw?: number
+
+  /**
+   * The height of the sub-rectangle of the source image to extract.
+   * Defaults to the full remaining height of the source.
+   */
+  sh?: number
+
+  /**
+   * Overall layer opacity, typically ranging from 0.0 (transparent) to 1.0 (opaque).
+   * @default 1.0
+   */
+  opacity?: number
+
+  /**
+   * Same as opacity but is 0-255 and faster when processing. If Present opacity is ignored.
+   * @default undefined
+   */
+  alpha?: number
+
+  /**
+   * An optional alpha mask buffer.
+   * The values in this array (0-255) determine the intensity of the blend
+   * at each corresponding pixel.
+   */
+  mask?: AnyMask | null
+
+  /**
+   * The specific blending function/algorithm to use for pixel math
+   * (e.g., Multiply, Screen, Overlay).
+   */
+  blendFn?: BlendColor32
+};
+
+/**
+ * Blits source ImageData into a destination ImageData using 32-bit integer bitwise blending.
+ * This function bypasses standard Canvas API limitations by operating directly on
+ * Uint32Array views. It supports various blend modes, binary/alpha masking, and
+ * automatic clipping of both source and destination bounds.
+ * @example
+ * blendImageData32(ctx.getImageData(0,0,100,100), sprite, {
+ *   blendFn: COLOR_32_BLEND_MODES.multiply,
+ *   mask: brushMask,
+ *   maskMode: MaskMode.ALPHA
+ * });
+ */
+export function blendImageData(
+  dst: ImageDataLike,
+  src: ImageDataLike,
+  opts: BlendImageDataOptions,
+) {
+  let {
+    dx = 0,
+    dy = 0,
+    sx = 0,
+    sy = 0,
+    sw = src.width,
+    sh = src.height,
+    opacity = 1,
+    alpha,
+    blendFn = sourceOverColor32,
+    mask,
+  } = opts
+
+  // 1. Clip Source Area
+  if (sx < 0) {
+    dx -= sx
+    sw += sx
+    sx = 0
+  }
+  if (sy < 0) {
+    dy -= sy
+    sh += sy
+    sy = 0
+  }
+  sw = Math.min(sw, src.width - sx)
+  sh = Math.min(sh, src.height - sy)
+
+  // 2. Clip Destination Area
+  if (dx < 0) {
+    sx -= dx
+    sw += dx
+    dx = 0
+  }
+  if (dy < 0) {
+    sy -= dy
+    sh += dy
+    dy = 0
+  }
+  const actualW = Math.min(sw, dst.width - dx)
+  const actualH = Math.min(sh, dst.height - dy)
+
+  if (actualW <= 0 || actualH <= 0) return
+
+  // 32-bit views of the same memory
+  const dst32 = new Uint32Array(dst.data.buffer)
+  const src32 = new Uint32Array(src.data.buffer)
+
+  const dw = dst.width
+  const sw_orig = src.width
+
+  const gAlpha = alpha !== undefined
+    ? (alpha | 0)
+    : Math.round(opacity * 255)
+
+  const maskIsAlpha = mask?.type === MaskType.ALPHA
+
+  for (let iy = 0; iy < actualH; iy++) {
+    const dRow = (iy + dy) * dw
+    const sRow = (iy + sy) * sw_orig
+
+    for (let ix = 0; ix < actualW; ix++) {
+      const di = dRow + (ix + dx)
+      const si = sRow + (ix + sx)
+
+      let s = src32[si] as Color32
+      let sa = (s >>> 24) & 0xFF
+
+      // skip fully transparent pixel
+      if (sa === 0) continue
+
+      let activeWeight = gAlpha
+
+      if (mask) {
+        const m = mask.data[si]
+        if (m === 0) continue
+        activeWeight = maskIsAlpha ? (m * activeWeight + 128) >> 8 : activeWeight
+      }
+
+      if (activeWeight < 255) {
+        sa = (sa * activeWeight + 128) >> 8
+      }
+
+      // If combined alpha is 0 after masking/opacity, skip the blend math
+      if (sa === 0) continue
+
+      // Re-pack source with final calculated alpha
+      s = ((s & 0x00FFFFFF) | (sa << 24)) >>> 0 as Color32
+
+      dst32[di] = blendFn(s, dst32[di] as Color32)
+    }
+  }
+}

package/src/ImageData/mask.ts

@@ -0,0 +1,150 @@
+import type { AlphaMask, BinaryMask, ImageDataLike } from '../_types'
+
+export type ApplyMaskOptions = {
+  /**
+   * The x-coordinate in the destination image where the mask begins.
+   * @default 0
+   */
+  dx?: number
+
+  /**
+   * The y-coordinate in the destination image where the mask begins.
+   * @default 0
+   */
+  dy?: number
+
+  /**
+   * The x-coordinate of the top-left corner of the sub-rectangle
+   * of the source image to extract.
+   * @default 0
+   */
+  sx?: number
+
+  /**
+   * The y-coordinate of the top-left corner of the sub-rectangle
+   * of the source image to extract.
+   * @default 0
+   */
+  sy?: number
+
+  /**
+   * The width of the sub-rectangle of the source image to extract.
+   * Defaults to the full remaining width of the source.
+   */
+  sw?: number
+
+  /**
+   * The height of the sub-rectangle of the source image to extract.
+   * Defaults to the full remaining height of the source.
+   */
+  sh?: number;
+}
+
+/**
+ * Applies a binary (on/off) mask to an RGBA buffer.
+ * If mask value is 0, pixel becomes transparent.
+ */
+export function applyBinaryMask(
+  dst: ImageDataLike,
+  mask: BinaryMask,
+  opts: ApplyMaskOptions = {},
+) {
+  const { width: maskWidth, height: maskHeight } = mask
+
+  const { dx = 0, dy = 0, sx = 0, sy = 0, sw = maskWidth, sh = maskHeight } = opts
+
+  // 1. Calculate intersection boundaries
+  const x0 = Math.max(0, dx, dx + (0 - sx))
+  const y0 = Math.max(0, dy, dy + (0 - sy))
+  const x1 = Math.min(dst.width, dx + sw, dx + (maskWidth - sx))
+  const y1 = Math.min(dst.height, dy + sh, dy + (maskHeight - sy))
+
+  if (x1 <= x0 || y1 <= y0) return
+
+  const { data: dstData, width: dstW } = dst
+
+  for (let y = y0; y < y1; y++) {
+    const maskY = y - dy + sy
+    const dstRowOffset = y * dstW * 4
+    const maskRowOffset = maskY * maskWidth
+
+    for (let x = x0; x < x1; x++) {
+      const maskX = x - dx + sx
+      const mIdx = maskRowOffset + maskX
+
+      // Binary check: If mask is 0, kill the alpha
+      if (mask.data[mIdx] === 0) {
+        const aIdx = dstRowOffset + (x * 4) + 3
+        dstData[aIdx] = 0
+      }
+    }
+  }
+
+  return dst
+}
+
+/**
+ * Applies a smooth alpha mask to an RGBA buffer.
+ * Multiplies existing Alpha by (maskValue / 255).
+ */
+export function applyAlphaMask(
+  dst: ImageData,
+  mask: AlphaMask,
+  opts: ApplyMaskOptions = {},
+): void {
+  let { dx = 0, dy = 0, sx = 0, sy = 0, sw = mask.width, sh = mask.height } = opts
+
+  // 1. Clipping Logic
+  if (dx < 0) {
+    sx -= dx
+    sw += dx
+    dx = 0
+  }
+  if (dy < 0) {
+    sy -= dy
+    sh += dy
+    dy = 0
+  }
+  if (sx < 0) {
+    dx -= sx
+    sw += sx
+    sx = 0
+  }
+  if (sy < 0) {
+    dy -= sy
+    sh += sy
+    sy = 0
+  }
+  const actualW = Math.min(sw, dst.width - dx, mask.width - sx)
+  const actualH = Math.min(sh, dst.height - dy, mask.height - sy)
+
+  if (actualW <= 0 || actualH <= 0) return
+
+  const dData = dst.data
+  const mData = mask.data
+  const dW = dst.width
+  const mW = mask.width
+
+  for (let y = 0; y < actualH; y++) {
+    const dOffset = ((dy + y) * dW + dx) << 2
+    const mOffset = (sy + y) * mW + sx
+
+    for (let x = 0; x < actualW; x++) {
+      const mVal = mData[mOffset + x]
+
+      if (mVal === 255) continue
+
+      const aIdx = dOffset + (x << 2) + 3
+
+      // --- BRANCH: Zero Alpha ---
+      if (mVal === 0) {
+        dData[aIdx] = 0
+        continue
+      }
+
+      // To get 101 from 200 * 128, we use the bias (a * m + 257) >> 8
+      // 25600 + 257 = 25857. 25857 >> 8 = 101.
+      dData[aIdx] = (dData[aIdx] * mVal + 257) >> 8
+    }
+  }
+}

package/src/ImageData/read-write-pixels.ts

@@ -1,4 +1,4 @@
-import type { Color32, ImageDataLike } from '../_types'
+import type { Color32, ImageDataLike, Rect } from '../_types'
 
 export function makeImageDataColor32Adapter(imageData: ImageDataLike) {
   const data32 = new Uint32Array(imageData.data.buffer)
@@ -34,3 +34,68 @@ export function makeImageDataColor32Adapter(imageData: ImageDataLike) {
   }
 }
 
+export function extractPixelData(
+  imageData: ImageDataLike,
+  rect: Rect,
+): Uint8ClampedArray
+
+export function extractPixelData(
+  imageData: ImageDataLike,
+  x: number,
+  y: number,
+  w: number,
+  h: number,
+): Uint8ClampedArray
+export function extractPixelData(
+  imageData: ImageDataLike,
+  _x: Rect | number,
+  _y?: number,
+  _w?: number,
+  _h?: number,
+): Uint8ClampedArray {
+  const { x, y, w, h } = typeof _x === 'object'
+    ? _x
+    : { x: _x, y: _y!, w: _w!, h: _h! }
+
+  const { width: srcW, height: srcH, data: src } = imageData
+  // Safety check for invalid dimensions
+  if (w <= 0 || h <= 0) return new Uint8ClampedArray(0)
+  const out = new Uint8ClampedArray(w * h * 4)
+
+  const x0 = Math.max(0, x)
+  const y0 = Math.max(0, y)
+  const x1 = Math.min(srcW, x + w)
+  const y1 = Math.min(srcH, y + h)
+
+  // If no intersection, return the empty
+  if (x1 <= x0 || y1 <= y0) return out
+
+  for (let row = 0; row < (y1 - y0); row++) {
+    // Where to read from the source canvas
+    const srcRow = y0 + row
+    const srcStart = (srcRow * srcW + x0) * 4
+    const rowLen = (x1 - x0) * 4
+
+    // Where to write into the 'out' patch
+    const dstRow = (y0 - y) + row
+    const dstCol = (x0 - x)
+    const dstStart = (dstRow * w + dstCol) * 4
+
+    // Perform the high-speed bulk copy
+    out.set(src.subarray(srcStart, srcStart + rowLen), dstStart)
+  }
+
+  return out
+}
+
+export function copyImageData({ data, width, height }: ImageDataLike): ImageData {
+  return new ImageData(data.slice(), width, height)
+}
+
+export function copyImageDataLike({ data, width, height }: ImageDataLike): ImageDataLike {
+  return {
+    data: data.slice(),
+    width,
+    height,
+  }
+}

package/src/ImageData/serialization.ts

@@ -5,7 +5,7 @@ export function base64EncodeArrayBuffer(buffer: ArrayBufferLike): Base64EncodedU
   return btoa(binary) as Base64EncodedUInt8Array
 }
 
-export function base64DecodeArrayBuffer(encoded: Base64EncodedUInt8Array): Uint8ClampedArray {
+export function base64DecodeArrayBuffer(encoded: Base64EncodedUInt8Array): Uint8ClampedArray<ArrayBuffer> {
   const binary = atob(encoded)
   const bytes = new Uint8ClampedArray(binary.length)
   for (let i = 0; i < binary.length; i++) {

package/src/_types.ts

@@ -2,21 +2,43 @@
 export type RGBA = { r: number, g: number, b: number, a: number }
 
 // A 32-bit integer containing r,g,b,a data
-export type Color32 = number & { readonly __brandColor32: unique symbol };
+export type Color32 = number & { readonly __brandColor32: unique symbol }
 
-// ALL values are floats from 0-1
-export type RGBAFloat = RGBA & { readonly __brandRGBAFloat: unique symbol }
+export type BlendColor32 = (src: Color32, dst: Color32) => Color32
 
 export type ImageDataLike = {
   width: number
   height: number
-  data: Uint8ClampedArray
+  data: Uint8ClampedArray<ArrayBuffer>
 }
 
 export type SerializedImageData = {
-  width: number,
-  height: number,
-  data: string,
+  width: number
+  height: number
+  data: string
 }
 
 export type Base64EncodedUInt8Array = string & { readonly __brandBase64UInt8Array: unique symbol }
+
+export type Rect = { x: number; y: number; w: number; h: number }
+
+export enum MaskType {
+  ALPHA,
+  BINARY
+}
+
+interface BaseMaskData {
+  readonly width: number
+  readonly height: number
+  readonly data: Uint8Array
+}
+
+export interface AlphaMask extends BaseMaskData {
+  readonly type: MaskType.ALPHA
+}
+
+export interface BinaryMask extends BaseMaskData {
+  readonly type: MaskType.BINARY
+}
+
+export type AnyMask = AlphaMask | BinaryMask