@pixerate/editor 0.115.0 → 0.117.0

package/dist/chunk-TCKIXI46.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/chunk-TCKIXI46.cjs","../src/paint/brush.ts","../src/paint/exchange.ts","../src/paint/mixer.ts","../src/paint/blending.ts","../src/paint/pigment-tools.ts"],"names":["unit","i","rgb"],"mappings":"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","file":"/home/runner/work/editor/editor/packages/core/dist/chunk-TCKIXI46.cjs","sourcesContent":[null,"// Portions ported from photocraft/crates/paint/src/lib.rs, dynamics.rs and render.rs (MIT OR Apache-2.0, © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.\n\n/**\n * The brush engine (a subset of photocraft's `crates/paint`): a computed round tip with size,\n * hardness, angle, roundness and spacing; pressure to size and opacity; smoothing; and Photoshop's\n * opacity-versus-flow build-up. Strokes are data, so one replays the same way for undo, agents\n * and tests.\n *\n * - Points are walked into dabs at `spacing × diameter` (`walkDabs`).\n * - Each dab's coverage (`dabCoverage`, photocraft's measured Photoshop profile) builds up in a\n *   stroke coverage map with flow towards the dab's opacity ceiling: `c ← c + v·(ceil − c)`.\n * - The stroke composites once at the stroke opacity over the layer as it was before the stroke,\n *   so overlapping dabs never exceed the opacity.\n */\n\nimport { blendPixel, mixPigment8, type BlendMode } from '../raster/blend';\nimport type { RasterRect as CropBox } from '../raster/surface';\nimport { TILE, tileKey, tileCoord, type TileKey } from '../raster/surface';\n\n/** One input sample. Missing pressure is a mouse (1). */\nexport interface StrokePoint {\n  x: number;\n  y: number;\n  /** 0..1 (default 1). */\n  pressure?: number;\n  /** Milliseconds (optional; kept for replays). */\n  t?: number;\n}\n\nexport interface BrushSettings {\n  /** Diameter in pixels (1..2500, default 20). */\n  size: number;\n  /** 0 (soft) .. 1 (hard, default). */\n  hardness: number;\n  /** Dab spacing as a fraction of the diameter (0.01..10, default 0.1). */\n  spacing: number;\n  /** Tip angle in degrees (default 0). */\n  angle: number;\n  /** Tip roundness 0.01..1 (default 1). */\n  roundness: number;\n  /** Stroke opacity ceiling 0..1 (default 1). */\n  opacity: number;\n  /** Build-up per dab 0..1 (default 1). */\n  flow: number;\n  /** Input smoothing 0..0.95 (default 0). */\n  smoothing: number;\n  /** Pressure controls size (default true). */\n  pressureSize: boolean;\n  /** Pressure controls opacity (default false). */\n  pressureOpacity: boolean;\n  /** How the stroke paints onto the layer (default normal). */\n  blend: BlendMode;\n}\n\nexport const DEFAULT_BRUSH: Readonly<BrushSettings> = {\n  size: 20,\n  hardness: 1,\n  spacing: 0.1,\n  angle: 0,\n  roundness: 1,\n  opacity: 1,\n  flow: 1,\n  smoothing: 0,\n  pressureSize: true,\n  pressureOpacity: false,\n  blend: 'normal',\n};\n\nexport const MAX_BRUSH_SIZE = 2500;\n\n/** A brush with every field in range (missing fields from `DEFAULT_BRUSH`). */\nexport function normalizeBrush(raw: Partial<BrushSettings> = {}): BrushSettings {\n  const num = (v: unknown, lo: number, hi: number, d: number) => (typeof v === 'number' && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : d);\n  return {\n    size: num(raw.size, 1, MAX_BRUSH_SIZE, DEFAULT_BRUSH.size),\n    hardness: num(raw.hardness, 0, 1, DEFAULT_BRUSH.hardness),\n    spacing: num(raw.spacing, 0.01, 10, DEFAULT_BRUSH.spacing),\n    angle: num(raw.angle, -360, 360, DEFAULT_BRUSH.angle),\n    roundness: num(raw.roundness, 0.01, 1, DEFAULT_BRUSH.roundness),\n    opacity: num(raw.opacity, 0, 1, DEFAULT_BRUSH.opacity),\n    flow: num(raw.flow, 0, 1, DEFAULT_BRUSH.flow),\n    smoothing: num(raw.smoothing, 0, 0.95, DEFAULT_BRUSH.smoothing),\n    pressureSize: typeof raw.pressureSize === 'boolean' ? raw.pressureSize : DEFAULT_BRUSH.pressureSize,\n    pressureOpacity: typeof raw.pressureOpacity === 'boolean' ? raw.pressureOpacity : DEFAULT_BRUSH.pressureOpacity,\n    blend: raw.blend ?? 'normal',\n  };\n}\n\n// ---------------------------------------------------------------------------\n// The round tip (photocraft's measured Photoshop profile)\n// ---------------------------------------------------------------------------\n\n/**\n * Photoshop's round tip, measured by photocraft: a solid core of radius `r0 · R`, then a Gaussian\n * shoulder `exp(-((d − r0) / s)²)` of width `s · R`, both by hardness (0, 0.1, … 1).\n */\nconst TIP_SHAPE: ReadonlyArray<[number, number]> = [\n  [0.0, 0.664], [0.14, 0.58], [0.28, 0.5], [0.4, 0.44], [0.52, 0.36], [0.63, 0.29],\n  [0.7, 0.24], [0.78, 0.19], [0.84, 0.15], [0.89, 0.11], [1.0, 0.0],\n];\n/** The anti-aliased edge: the shoulder never narrows below this many pixels. */\nconst TIP_EDGE_PX = 1.2;\nconst SMALL_TIP_RADIUS = 3;\nconst SUBPIXEL = [-0.375, -0.125, 0.125, 0.375];\n\n/** The core radius and shoulder width (pixels) of a round tip of `radius` and `hardness`. */\nexport function tipShape(radius: number, hardness: number): [number, number] {\n  const h = (Number.isNaN(hardness) ? 0 : Math.min(1, Math.max(0, hardness))) * 10;\n  const i = Math.min(9, Math.floor(h));\n  const t = h - i;\n  const a = TIP_SHAPE[i];\n  const b = TIP_SHAPE[i + 1];\n  const r0 = a[0] + (b[0] - a[0]) * t;\n  const s = a[1] + (b[1] - a[1]) * t;\n  const r = Number.isFinite(radius) ? Math.max(0, radius) : 0;\n  const edge = Math.max(0.25, Math.min(TIP_EDGE_PX, 0.3 * r));\n  return [Math.max(0, Math.min(r0 * r, r - edge)), Math.max(1e-3, s * r, edge)];\n}\n\n/** `exp(-u)` as `(1 − u/64)^64` by six squarings: exactly 0 from u = 64. */\nfunction softExp(u: number): number {\n  let g = Math.min(1, Math.max(0, 1 - u / 64));\n  for (let k = 0; k < 6; k++) g *= g;\n  return g;\n}\n\n/** Opacity of a round tip at distance `d` from its centre. */\nexport function tipFalloff(d: number, radius: number, hardness: number): number {\n  const [r0, s] = tipShape(radius, hardness);\n  if (d <= r0) return 1;\n  const x = (d - r0) / s;\n  return softExp(x * x);\n}\n\n/** How far from its centre a round tip still paints. */\nexport function tipReach(radius: number, hardness: number): number {\n  const [r0, s] = tipShape(radius, hardness);\n  return r0 + 2.6 * s;\n}\n\n/** Coverage of a round dab at distance `d` from its centre. */\nexport function dabCoverage(d: number, radius: number, hardness: number): number {\n  if (Number.isNaN(d) || d >= tipReach(radius, hardness) + 0.5) return 0;\n  return tipFalloff(d, radius, hardness);\n}\n\n// ---------------------------------------------------------------------------\n// Points → dabs\n// ---------------------------------------------------------------------------\n\nexport interface Dab {\n  x: number;\n  y: number;\n  radius: number;\n  /** Flow (per-dab build-up). */\n  alpha: number;\n  /** Opacity ceiling this dab builds up to. */\n  opacity: number;\n  /** Radians. */\n  angle: number;\n  roundness: number;\n}\n\n/** Exponential smoothing of input points; the first and last point are kept. */\nexport function smoothPoints(points: readonly StrokePoint[], amount: number): StrokePoint[] {\n  const a = 1 - Math.min(0.95, Math.max(0, amount));\n  if (a >= 1 || points.length < 3) return points.slice();\n  const out: StrokePoint[] = [];\n  let cur: StrokePoint | null = null;\n  for (const p of points) {\n    const n: StrokePoint = cur ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;\n    out.push(n);\n    cur = n;\n  }\n  out[out.length - 1] = points[points.length - 1];\n  return out;\n}\n\nconst pressureOf = (p: StrokePoint) => (typeof p.pressure === 'number' && Number.isFinite(p.pressure) ? Math.min(1, Math.max(0, p.pressure)) : 1);\n\n/**\n * Walks points into dabs (incrementally: feed points in any chunks and get the same dabs). The\n * first point is a dab; then one every `spacing × diameter` along the path.\n */\nexport class DabWalker {\n  private last: StrokePoint | null = null;\n  private nextAt = 0;\n  private pendingFirst: StrokePoint | null = null;\n\n  constructor(readonly brush: BrushSettings) {}\n\n  private diameter(p: StrokePoint): number {\n    return this.brush.pressureSize ? this.brush.size * pressureOf(p) : this.brush.size;\n  }\n\n  private stepLen(p: StrokePoint): number {\n    return Math.max(0.5, Math.max(1, this.diameter(p)) * Math.max(0.01, this.brush.spacing));\n  }\n\n  private dab(p: StrokePoint): Dab {\n    const b = this.brush;\n    return {\n      x: p.x,\n      y: p.y,\n      radius: Math.max(0.5, this.diameter(p) / 2),\n      alpha: Math.min(1, Math.max(0, b.flow)),\n      opacity: b.pressureOpacity ? pressureOf(p) : 1,\n      angle: (b.angle * Math.PI) / 180,\n      roundness: Math.min(1, Math.max(0.01, b.roundness)),\n    };\n  }\n\n  push(p: StrokePoint, out: Dab[]): void {\n    const a = this.last;\n    if (!a) {\n      this.last = p;\n      this.pendingFirst = p;\n      this.nextAt = this.stepLen(p);\n      return;\n    }\n    if (this.pendingFirst) {\n      out.push(this.dab(this.pendingFirst));\n      this.pendingFirst = null;\n    }\n    const dx = p.x - a.x;\n    const dy = p.y - a.y;\n    const len = Math.hypot(dx, dy);\n    if (len > 1e-9) {\n      while (this.nextAt <= len + 1e-9) {\n        const f = Math.min(1, this.nextAt / len);\n        const q: StrokePoint = {\n          x: a.x + dx * f,\n          y: a.y + dy * f,\n          pressure: pressureOf(a) + (pressureOf(p) - pressureOf(a)) * f,\n        };\n        out.push(this.dab(q));\n        this.nextAt += this.stepLen(q);\n      }\n      this.nextAt -= len;\n    }\n    this.last = p;\n  }\n\n  finish(out: Dab[]): void {\n    if (this.pendingFirst) {\n      out.push(this.dab(this.pendingFirst));\n      this.pendingFirst = null;\n    }\n  }\n}\n\n/** All dabs of a point list (smoothing applied). */\nexport function walkDabs(points: readonly StrokePoint[], brush: BrushSettings): Dab[] {\n  const w = new DabWalker(brush);\n  const out: Dab[] = [];\n  for (const p of smoothPoints(points, brush.smoothing)) w.push(p, out);\n  w.finish(out);\n  return out;\n}\n\n/** The pixel rectangle a dab can touch. */\nexport function dabRect(d: Dab, hardness: number): CropBox {\n  // As `rasterizeDab`: the tip reaches `reach` across its minor axis and `reach / roundness` along it.\n  const ro = Math.min(1, Math.max(0.5 / d.radius, d.roundness));\n  const rm = Math.max(0.5, d.radius * ro);\n  const r = Math.max(rm, tipReach(rm, hardness)) / ro + 1.5;\n  const x0 = Math.floor(d.x - r);\n  const y0 = Math.floor(d.y - r);\n  return { x: x0, y: y0, width: Math.ceil(d.x + r) - x0, height: Math.ceil(d.y + r) - y0 };\n}\n\n/**\n * Rasterizes one dab over `rect` into `out` (rect.width × rect.height values, coverage × flow).\n * Small tips (radius below 3 px) take each pixel's covered area from a 4×4 grid.\n */\nexport function rasterizeDab(d: Dab, hardness: number, rect: CropBox, out: Float32Array): void {\n  const w = rect.width;\n  const h = rect.height;\n  out.fill(0, 0, w * h);\n  const r = d.radius;\n  const ro = Math.min(1, Math.max(0.5 / r, d.roundness));\n  const rm = Math.max(0.5, r * ro);\n  const reach = Math.max(rm, tipReach(rm, hardness));\n  const sn = Math.sin(d.angle);\n  const cs = Math.cos(d.angle);\n  const toTip = (dx: number, dy: number): [number, number] => {\n    const ux = dx;\n    const uy = -dy;\n    return [ux * cs + uy * sn, -ux * sn + uy * cs];\n  };\n  const small = rm < SMALL_TIP_RADIUS;\n  const reach2 = (reach + (small ? 0.75 : 0.5)) ** 2;\n  for (let yy = 0; yy < h; yy++) {\n    const dy = rect.y + yy + 0.5 - d.y;\n    for (let xx = 0; xx < w; xx++) {\n      const dx = rect.x + xx + 0.5 - d.x;\n      const [u, v] = toTip(dx, dy);\n      const d2 = (u * ro) ** 2 + v * v;\n      if (d2 >= reach2) continue;\n      let val: number;\n      if (small) {\n        let sum = 0;\n        for (const sy of SUBPIXEL) {\n          for (const sx of SUBPIXEL) {\n            const [su, sv] = toTip(dx + sx, dy + sy);\n            sum += tipFalloff(Math.sqrt((su * ro) ** 2 + sv * sv), rm, hardness);\n          }\n        }\n        val = sum / 16;\n      } else {\n        val = dabCoverage(Math.sqrt(d2), rm, hardness);\n      }\n      if (val > 0) out[yy * w + xx] = val * d.alpha;\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Stroke coverage\n// ---------------------------------------------------------------------------\n\nconst TILE_PIXELS = TILE * TILE;\n\n/** A stroke's accumulated coverage, in 256 px tiles over document space. */\nexport class CoverageMap {\n  readonly tiles = new Map<TileKey, Float32Array>();\n  bounds: CropBox | null = null;\n  private dirty = new Set<TileKey>();\n\n  get(x: number, y: number): number {\n    const tx = Math.floor(x / TILE);\n    const ty = Math.floor(y / TILE);\n    const t = this.tiles.get(tileKey(tx, ty));\n    return t ? t[(y - ty * TILE) * TILE + (x - tx * TILE)] : 0;\n  }\n\n  /** Builds up `vals` (over `rect`) with flow towards `ceil`: `c ← c + v·(ceil − c)`. */\n  accumulate(rect: CropBox, vals: Float32Array, ceil: number): void {\n    if (rect.width <= 0 || rect.height <= 0) return;\n    const w = rect.width;\n    const tx0 = Math.floor(rect.x / TILE);\n    const ty0 = Math.floor(rect.y / TILE);\n    const tx1 = Math.floor((rect.x + rect.width - 1) / TILE);\n    const ty1 = Math.floor((rect.y + rect.height - 1) / TILE);\n    let touched = false;\n    for (let ty = ty0; ty <= ty1; ty++) {\n      for (let tx = tx0; tx <= tx1; tx++) {\n        const x0 = Math.max(rect.x, tx * TILE);\n        const y0 = Math.max(rect.y, ty * TILE);\n        const x1 = Math.min(rect.x + rect.width, tx * TILE + TILE);\n        const y1 = Math.min(rect.y + rect.height, ty * TILE + TILE);\n        let tile: Float32Array | undefined;\n        for (let y = y0; y < y1; y++) {\n          const row = (y - rect.y) * w;\n          const trow = (y - ty * TILE) * TILE;\n          for (let x = x0; x < x1; x++) {\n            const v = vals[row + (x - rect.x)];\n            if (v <= 0) continue;\n            if (!tile) {\n              const key = tileKey(tx, ty);\n              tile = this.tiles.get(key);\n              if (!tile) {\n                tile = new Float32Array(TILE_PIXELS);\n                this.tiles.set(key, tile);\n              }\n              this.dirty.add(key);\n              touched = true;\n            }\n            const ti = trow + (x - tx * TILE);\n            const c = tile[ti];\n            if (ceil > c) tile[ti] = c + v * (ceil - c);\n          }\n        }\n      }\n    }\n    if (touched) this.bounds = unionRect(this.bounds, rect);\n  }\n\n  /** Tiles changed since the last call. */\n  takeDirty(): TileKey[] {\n    const out = [...this.dirty];\n    this.dirty.clear();\n    return out;\n  }\n}\n\nfunction unionRect(a: CropBox | null, b: CropBox): CropBox {\n  if (!a) return { ...b };\n  const x = Math.min(a.x, b.x);\n  const y = Math.min(a.y, b.y);\n  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };\n}\n\n/** Paints a stroke's dabs into a coverage map, incrementally. */\nexport class StrokeCoverage {\n  readonly coverage = new CoverageMap();\n  private walker: DabWalker;\n  private smoothing: number;\n  private smoothPos: StrokePoint | null = null;\n  private buf = new Float32Array(0);\n  dabCount = 0;\n\n  constructor(readonly brush: BrushSettings) {\n    this.walker = new DabWalker(brush);\n    this.smoothing = brush.smoothing;\n  }\n\n  /** Feeds input points; returns the document rectangles the new dabs touched. */\n  push(points: readonly StrokePoint[]): CropBox[] {\n    const dabs: Dab[] = [];\n    for (const p of points) this.walker.push(this.smooth(p), dabs);\n    return this.paint(dabs);\n  }\n\n  /** Ends the stroke (a single click still paints one dab). */\n  finish(last?: StrokePoint): CropBox[] {\n    const dabs: Dab[] = [];\n    if (last && this.smoothPos && (this.smoothPos.x !== last.x || this.smoothPos.y !== last.y)) this.walker.push(last, dabs);\n    this.walker.finish(dabs);\n    return this.paint(dabs);\n  }\n\n  private smooth(p: StrokePoint): StrokePoint {\n    const a = 1 - Math.min(0.95, Math.max(0, this.smoothing));\n    const cur = this.smoothPos;\n    const n = cur && a < 1 ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;\n    this.smoothPos = n;\n    return n;\n  }\n\n  private paint(dabs: Dab[]): CropBox[] {\n    const rects: CropBox[] = [];\n    for (const d of dabs) {\n      const rect = dabRect(d, this.brush.hardness);\n      const n = rect.width * rect.height;\n      if (this.buf.length < n) this.buf = new Float32Array(n);\n      const vals = this.buf.subarray(0, n);\n      rasterizeDab(d, this.brush.hardness, rect, vals);\n      this.coverage.accumulate(rect, vals, d.opacity);\n      rects.push(rect);\n      this.dabCount++;\n    }\n    return rects;\n  }\n}\n\n/** How a stroke changes pixels. */\nexport interface StrokeApply {\n  /** `paint` puts colour down; `erase` removes alpha (or, with transparency locked, paints `background`). */\n  mode: 'paint' | 'erase';\n  /** RGBA 0..255 (paint colour, or the mask grey in `r`). */\n  color: readonly [number, number, number, number];\n  /** RGBA 0..255 the eraser paints on a transparency-locked layer (and on masks). */\n  background: readonly [number, number, number, number];\n  opacity: number;\n  blend: BlendMode;\n  lockTransparency: boolean;\n  /** Selection coverage (document space, canvas-sized), or `null`. */\n  selection: { width: number; height: number; data: ArrayLike<number> } | null;\n  /** Layer offset (target pixels are in layer space). */\n  offset: { x: number; y: number };\n}\n\n/**\n * Composites the stroke's coverage over `tileData` (the target's tile (tx, ty) as it was before\n * the stroke, in layer space; RGBA or one byte for masks) and returns the new tile data. With\n * `into` (the tile's previous result) and `region` (document space), only `region` is recomputed\n * and the rest of `into` is kept.\n */\nexport function applyStrokeToTile(\n  coverage: CoverageMap,\n  tileData: Uint8ClampedArray,\n  channels: 1 | 4,\n  tx: number,\n  ty: number,\n  s: StrokeApply,\n  options: { into?: Uint8ClampedArray; region?: CropBox } = {}\n): Uint8ClampedArray {\n  const out = options.into ? new Uint8ClampedArray(options.into) : new Uint8ClampedArray(tileData);\n  const ox = tx * TILE + s.offset.x;\n  const oy = ty * TILE + s.offset.y;\n  let x0 = 0;\n  let y0 = 0;\n  let x1 = TILE;\n  let y1 = TILE;\n  if (options.region) {\n    const r = options.region;\n    x0 = Math.max(0, Math.floor(r.x) - ox);\n    y0 = Math.max(0, Math.floor(r.y) - oy);\n    x1 = Math.min(TILE, Math.ceil(r.x + r.width) - ox);\n    y1 = Math.min(TILE, Math.ceil(r.y + r.height) - oy);\n    if (x1 <= x0 || y1 <= y0) return out;\n    // Start the region from the pre-stroke pixels: coverage is cumulative.\n    if (options.into) {\n      for (let y = y0; y < y1; y++) out.set(tileData.subarray((y * TILE + x0) * channels, (y * TILE + x1) * channels), (y * TILE + x0) * channels);\n    }\n  }\n  const sel = s.selection;\n  const cb = [0, 0, 0, 0];\n  const cs = [s.color[0] / 255, s.color[1] / 255, s.color[2] / 255, s.color[3] / 255];\n  const bg = [s.background[0] / 255, s.background[1] / 255, s.background[2] / 255, s.background[3] / 255];\n  // With a tile-aligned offset the layer tile is one coverage tile: read it directly.\n  const aligned = s.offset.x % TILE === 0 && s.offset.y % TILE === 0;\n  const covTile = aligned ? coverage.tiles.get(tileKey(Math.floor(ox / TILE), Math.floor(oy / TILE))) : undefined;\n  if (aligned && !covTile) return out;\n  for (let y = y0; y < y1; y++) {\n    const dy = oy + y;\n    for (let x = x0; x < x1; x++) {\n      const dx = ox + x;\n      const c = covTile ? covTile[y * TILE + x] : coverage.get(dx, dy);\n      if (c <= 0) continue;\n      let k = c * s.opacity;\n      if (sel) {\n        if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;\n        k *= sel.data[dy * sel.width + dx] / 255;\n      }\n      if (k > 1) k = 1;\n      if (k <= 0) continue;\n      const p = y * TILE + x;\n      if (channels === 1) {\n        const target = s.mode === 'erase' ? s.background[0] : s.color[0];\n        out[p] = Math.round(out[p] + (target - out[p]) * k);\n        continue;\n      }\n      const i = p * 4;\n      if (s.mode === 'erase' && !s.lockTransparency) {\n        out[i + 3] = Math.round(out[i + 3] * (1 - k));\n        continue;\n      }\n      if (s.lockTransparency && out[i + 3] === 0) continue;\n      const src = s.mode === 'erase' ? bg : cs;\n      if (s.blend === 'pigment') {\n        // `blendPixel`'s paint mix on the 8-bit colours, with their spectra cached.\n        const bytes = s.mode === 'erase' ? s.background : s.color;\n        const as = src[3] * k;\n        if (!(as > 0)) continue;\n        const ao = as + (out[i + 3] / 255) * (1 - as);\n        mixPigment8(out[i], out[i + 1], out[i + 2], bytes[0], bytes[1], bytes[2], as / ao, cb);\n        out[i] = Math.round(cb[0] * 255);\n        out[i + 1] = Math.round(cb[1] * 255);\n        out[i + 2] = Math.round(cb[2] * 255);\n        if (!s.lockTransparency) out[i + 3] = Math.round(ao * 255);\n        continue;\n      }\n      for (let ch = 0; ch < 4; ch++) cb[ch] = out[i + ch] / 255;\n      const o = blendPixel(s.blend, cb, src, k);\n      out[i] = Math.round(o[0] * 255);\n      out[i + 1] = Math.round(o[1] * 255);\n      out[i + 2] = Math.round(o[2] * 255);\n      if (!s.lockTransparency) out[i + 3] = Math.round(o[3] * 255);\n    }\n  }\n  return out;\n}\n\n/** Tile coordinates of coverage tile keys (for callers that track dirty tiles). */\nexport function coverageTileCoord(key: TileKey): { tx: number; ty: number } {\n  return tileCoord(key);\n}\n","// Portions ported from photocraft/crates/paint/src/mixer.rs (MIT OR Apache-2.0, © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.\n\n/**\n * The pick-up / mix exchange between a loaded brush and the paint under it: the one mechanism\n * every wet-capable brush shares. The Mixer Brush (`MixerStroke`) and the paint editor's\n * wet-capable brushes run on it now; the wet layer (phase 3) plugs in as another `PaintMedium`.\n *\n * Two halves:\n *\n * - `PaintExchange` is what the brush carries: a **reservoir** of loaded paint (with an amount\n *   that drains per dab) and a **well** of paint picked up from the canvas. Per dab it\n *   1. picks up: the well moves towards the colour under the dab by the pick-up rate times how\n *      much of the footprint holds paint (`pickUp`);\n *   2. mixes the dab's paint: reservoir weight `amount × (1 − mix)`, well weight `mix`\n *      (`paint`);\n *   3. drains the reservoir (`drain`).\n *   Every mix is RGB or Kubelka-Munk pigment (`mixing`), so a blue brush through yellow goes\n *   green.\n * - `PaintMedium` is what the brush touches: `sample` (the colour and contact under a footprint)\n *   and `deposit` (lay paint at per-pixel amounts). `TileMedium` is the raster layer's pixels.\n *   A wet layer implements the same two calls over its wet pigment and water (sampling only wet\n *   paint, so pick-up lifts what is still wet), and nothing in `PaintExchange` changes.\n *\n * The ratios a user sets are `pickup` (pick-up ratio, 0..1) and `mix` (mix ratio, 0..1);\n * `exchangeRates` turns them into per-dab rates with the Mixer Brush's constants, so a Mixer\n * Brush's `wet` and `mix` are exactly these two ratios. Everything is data in, pixels out.\n */\n\nimport { blendPixel, mixPigment8, type BlendMode } from '../raster/blend';\nimport type { RasterRect } from '../raster/surface';\nimport { TILE } from '../raster/surface';\nimport { createPigment, lerpPigmentInto, setPigmentColor, type Pigment } from './pigment';\n\n/** How colours mix: straight sRGB averages, or like paint (Kubelka-Munk). */\nexport type MixingModel = 'rgb' | 'pigment';\n\nexport const MIXING_MODELS: readonly MixingModel[] = ['rgb', 'pigment'];\n\n/** An sRGB colour, 0..1 per channel. */\nexport type RgbTriple = [number, number, number];\n\n/** What a brush carries between dabs and strokes. Colours are straight sRGB, 0..1. */\nexport interface MixerLoad {\n  /** Loaded paint, or `null` when the brush is unloaded. */\n  readonly reservoir: readonly [number, number, number] | null;\n  /** Reservoir left, 0..1. */\n  readonly amount: number;\n  /** Colour picked up from the canvas (the well), or `null` when the brush is clean. */\n  readonly pickup: readonly [number, number, number] | null;\n}\n\nexport const EMPTY_MIXER_LOAD: MixerLoad = { reservoir: null, amount: 0, pickup: null };\n\n/** Fraction of the way the well moves towards the canvas colour per dab at a pick-up ratio of 1. */\nexport const MIXER_PICKUP_RATE = 0.25;\n/** Fraction of the reservoir that drains per dab at a load of 0. */\nexport const MIXER_DRAIN = 0.08;\n\n/** Per-dab rates of an exchange. */\nexport interface ExchangeRates {\n  /** How far the well moves towards the canvas colour per dab at full contact (0: lifts nothing). */\n  pickup: number;\n  /** The well's weight in each dab's paint; the reservoir gets `amount × (1 − mix)`. */\n  mix: number;\n  /** Fraction of the reservoir lost per dab. */\n  drain: number;\n  mixing: MixingModel;\n}\n\n/**\n * Per-dab rates from the ratios a user sets: pick-up ratio `pickup` (0 dry .. 1), mix ratio\n * `mix` (0 .. 1, scaled by the pick-up ratio: a brush that lifts nothing has nothing to mix) and\n * `load` (1 never drains). The Mixer Brush passes its `wet`, `mix` and `load`.\n */\nexport function exchangeRates(pickup: number, mix: number, load: number, mixing: MixingModel): ExchangeRates {\n  return { pickup: MIXER_PICKUP_RATE * pickup, mix: mix * pickup, drain: MIXER_DRAIN * (1 - load), mixing };\n}\n\n/** What a footprint holds: its average paint colour and how much of it holds paint (0..1). */\nexport interface PaintSample {\n  rgb: RgbTriple;\n  /** Paint-weighted share of the footprint (alpha × coverage over coverage). */\n  contact: number;\n}\n\n/** The brush side of the exchange: reservoir, amount and well, mixed per dab. */\nexport class PaintExchange {\n  private reservoir: RgbTriple | null;\n  private amount: number;\n  private well: RgbTriple | null;\n  private readonly pig: { res: Pigment; well: Pigment; paint: Pigment; canvas: Pigment } | null;\n  private readonly out: RgbTriple = [0, 0, 0];\n\n  constructor(\n    readonly rates: ExchangeRates,\n    load: MixerLoad\n  ) {\n    this.reservoir = load.reservoir ? [load.reservoir[0], load.reservoir[1], load.reservoir[2]] : null;\n    this.amount = this.reservoir ? Math.min(1, Math.max(0, load.amount)) : 0;\n    this.well = load.pickup ? [load.pickup[0], load.pickup[1], load.pickup[2]] : null;\n    this.pig =\n      rates.mixing === 'pigment'\n        ? { res: createPigment(this.reservoir ?? [0, 0, 0]), well: createPigment(this.well ?? [0, 0, 0]), paint: createPigment([0, 0, 0]), canvas: createPigment([0, 0, 0]) }\n        : null;\n  }\n\n  /** What the brush carries now. */\n  get load(): MixerLoad {\n    return { reservoir: this.reservoir ? [...this.reservoir] : null, amount: this.amount, pickup: this.well ? [...this.well] : null };\n  }\n\n  /** The colour picked up so far, or `null`. */\n  get pickup(): Readonly<RgbTriple> | null {\n    return this.well;\n  }\n\n  /** The prepared pigment of the last `paint` colour (pigment mixing only), for `deposit`. */\n  get paintPigment(): Pigment | null {\n    return this.pig?.paint ?? null;\n  }\n\n  /** Recolours the reservoir without refilling it (a multi-coloured brush, per dab). */\n  setReservoirColor(r: number, g: number, b: number): void {\n    if (!this.reservoir) {\n      this.reservoir = [r, g, b];\n      this.amount = 1;\n    } else {\n      this.reservoir[0] = r;\n      this.reservoir[1] = g;\n      this.reservoir[2] = b;\n    }\n    if (this.pig) setPigmentColor(this.pig.res, r, g, b);\n  }\n\n  /** `a` mixed `t` of the way to `b` into `this.out`, by the mixing model. */\n  private mix(a: RgbTriple, pa: Pigment | null, b: RgbTriple, pb: Pigment | null, t: number): RgbTriple {\n    const o = this.out;\n    if (pa && pb) lerpPigmentInto(pa, pb, t, o, 0);\n    else for (let c = 0; c < 3; c++) o[c] = a[c] + (b[c] - a[c]) * t;\n    return o;\n  }\n\n  /** `a` mixed `t` of the way to `b` (sRGB 0..1) by the mixing model, into `out`. */\n  mixColors(a: readonly number[], b: readonly number[], t: number, out: number[]): number[] {\n    if (this.pig) {\n      setPigmentColor(this.pig.canvas, a[0], a[1], a[2]);\n      setPigmentColor(this.pig.paint, b[0], b[1], b[2]);\n      lerpPigmentInto(this.pig.canvas, this.pig.paint, t, out, 0);\n    } else for (let c = 0; c < 3; c++) out[c] = a[c] + (b[c] - a[c]) * t;\n    return out;\n  }\n\n  /** 1. Pick-up: the well moves towards the sampled colour (or takes it, when clean). */\n  pickUp(sample: PaintSample | null): void {\n    if (!sample || !(this.rates.pickup > 0)) return;\n    const pig = this.pig;\n    if (!this.well) this.well = [sample.rgb[0], sample.rgb[1], sample.rgb[2]];\n    else {\n      if (pig) setPigmentColor(pig.canvas, sample.rgb[0], sample.rgb[1], sample.rgb[2]);\n      const o = this.mix(this.well, pig?.well ?? null, sample.rgb, pig?.canvas ?? null, this.rates.pickup * sample.contact);\n      this.well = [o[0], o[1], o[2]];\n    }\n    if (pig) setPigmentColor(pig.well, this.well[0], this.well[1], this.well[2]);\n  }\n\n  /**\n   * 2. The dab's paint: the reservoir mixed with the well, written to `out`. Returns the total\n   * weight (≤ 0: nothing to lay down); deposit `min(1, weight)` of it. With pigment mixing,\n   * `paintPigment` is the result's pigment afterwards.\n   */\n  paint(out: RgbTriple): number {\n    const res = this.reservoir;\n    const wr = res ? this.amount * (1 - this.rates.mix) : 0;\n    const wp = this.well ? this.rates.mix : 0;\n    const total = wr + wp;\n    if (!(total > 1e-6)) return 0;\n    const pig = this.pig;\n    if (res && this.well) {\n      const m = this.mix(res, pig?.res ?? null, this.well, pig?.well ?? null, wp / total);\n      out[0] = m[0];\n      out[1] = m[1];\n      out[2] = m[2];\n    } else {\n      const c = res ?? this.well!;\n      out[0] = c[0];\n      out[1] = c[1];\n      out[2] = c[2];\n    }\n    if (pig) setPigmentColor(pig.paint, out[0], out[1], out[2]);\n    return total;\n  }\n\n  /** 3. The reservoir drains. */\n  drain(): void {\n    this.amount *= 1 - this.rates.drain;\n  }\n}\n\n/** The pixels a brush reads and writes (RGBA tiles in layer space). */\nexport interface PaintTileTarget {\n  /** The tile (TILE × TILE × 4) at (tx, ty) as it is now, or `null` when it is fully transparent. */\n  readTile(tx: number, ty: number): Uint8ClampedArray | null;\n  /** A writable tile at (tx, ty), returned by `readTile` from then on. */\n  writeTile(tx: number, ty: number): Uint8ClampedArray;\n  /** Layer offset: layer pixel = document pixel − offset. */\n  offset: { x: number; y: number };\n  /** Keep alpha and paint only where the layer has pixels. */\n  lockTransparency: boolean;\n  /** Selection coverage (document space, canvas-sized), or `null`. */\n  selection: { width: number; height: number; data: ArrayLike<number> } | null;\n}\n\n/** The canvas side of the exchange: where a brush picks paint up and lays it down. */\nexport interface PaintMedium {\n  /** The paint under a footprint (`cov` over `rect`, document space), or `null` where there is none. */\n  sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null;\n  /**\n   * Lays paint over the footprint at `dep × cov` per pixel. The colour is `paint` (with its\n   * prepared pigment for pigment mixing), or per pixel from `field` (3 floats per pixel of\n   * `rect`, sRGB 0..1) when given.\n   */\n  deposit(rect: RasterRect, cov: ArrayLike<number>, dep: number, paint: Readonly<RgbTriple>, paintPigment: Pigment | null, field?: Float32Array | null): void;\n}\n\nexport interface TileMediumOptions {\n  /**\n   * How deposits combine with the pixels. Missing: the exchange's mixing (source-over, or a\n   * pigment mix with pigment mixing), as the Mixer Brush paints. Otherwise any blend mode, as a\n   * brush tip's `blend`.\n   */\n  blend?: BlendMode;\n}\n\n/** A raster layer's pixels as a `PaintMedium` (through live tiles). */\nexport class TileMedium implements PaintMedium {\n  // The tile last looked up by `locate` (and whether it came from `writeTile`).\n  private tx = NaN;\n  private ty = NaN;\n  private tile: Uint8ClampedArray | null = null;\n  private writable = false;\n  private readonly canvasPig = createPigment([0, 0, 0]);\n  private readonly paintPig = createPigment([0, 0, 0]);\n  private paintKey = -1;\n  private readonly cb = [0, 0, 0, 0];\n  private readonly src = [0, 0, 0, 1];\n  private readonly o: number[] = [0, 0, 0];\n\n  constructor(\n    readonly target: PaintTileTarget,\n    private readonly options: TileMediumOptions = {}\n  ) {}\n\n  /** Forgets the cached tile (call when another writer may have replaced tiles). */\n  reset(): void {\n    this.tx = NaN;\n  }\n\n  /**\n   * The tile holding document pixel (dx, dy) (`pixels`) and the pixel's byte index in it, or -1\n   * when reading an empty tile.\n   */\n  locate(dx: number, dy: number, write: boolean): number {\n    const t = this.target;\n    const lx = dx - t.offset.x;\n    const ly = dy - t.offset.y;\n    const tx = Math.floor(lx / TILE);\n    const ty = Math.floor(ly / TILE);\n    if (tx !== this.tx || ty !== this.ty || (write && !this.writable)) {\n      this.tx = tx;\n      this.ty = ty;\n      this.tile = write ? t.writeTile(tx, ty) : t.readTile(tx, ty);\n      this.writable = write;\n    }\n    return this.tile ? ((ly - ty * TILE) * TILE + (lx - tx * TILE)) * 4 : -1;\n  }\n\n  /** The tile `locate` last found. */\n  get pixels(): Uint8ClampedArray {\n    return this.tile!;\n  }\n\n  /** Selection coverage at a document pixel, 0..1 (1 without a selection). */\n  selectionAt(dx: number, dy: number): number {\n    const sel = this.target.selection;\n    if (!sel) return 1;\n    if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) return 0;\n    return sel.data[dy * sel.width + dx] / 255;\n  }\n\n  sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null {\n    const w = rect.width;\n    this.tx = NaN;\n    let ar = 0;\n    let ag = 0;\n    let ab = 0;\n    let wsum = 0;\n    let asum = 0;\n    for (let yy = 0; yy < rect.height; yy++) {\n      for (let xx = 0; xx < w; xx++) {\n        const k = cov[yy * w + xx];\n        if (k <= 0) continue;\n        wsum += k;\n        const i = this.locate(rect.x + xx, rect.y + yy, false);\n        if (i < 0) continue;\n        const px = this.tile!;\n        const al = px[i + 3] / 255;\n        if (al <= 0) continue;\n        const ka = k * al;\n        ar += (px[i] / 255) * ka;\n        ag += (px[i + 1] / 255) * ka;\n        ab += (px[i + 2] / 255) * ka;\n        asum += ka;\n      }\n    }\n    if (!(asum > 1e-6)) return null;\n    return { rgb: [ar / asum, ag / asum, ab / asum], contact: asum / Math.max(1e-6, wsum) };\n  }\n\n  deposit(rect: RasterRect, cov: ArrayLike<number>, dep: number, paint: Readonly<RgbTriple>, paintPigment: Pigment | null, field: Float32Array | null = null): void {\n    const t = this.target;\n    const sel = t.selection;\n    const w = rect.width;\n    const o = this.o;\n    const blend = this.options.blend;\n    // Pigment where the exchange mixes pigment (no blend given) or the blend is `pigment`.\n    const pigment = blend === undefined ? paintPigment !== null : blend === 'pigment';\n    const general = blend !== undefined && blend !== 'normal' && blend !== 'pigment';\n    // Pigment mode keeps the last canvas colour's spectrum: runs of equal pixels are common.\n    let lastKey = -1;\n    this.tx = NaN;\n    for (let yy = 0; yy < rect.height; yy++) {\n      const dy = rect.y + yy;\n      for (let xx = 0; xx < w; xx++) {\n        const p = yy * w + xx;\n        let k = cov[p] * dep;\n        if (k <= 0) continue;\n        const dx = rect.x + xx;\n        if (sel) {\n          if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;\n          k *= sel.data[dy * sel.width + dx] / 255;\n          if (k <= 0) continue;\n        }\n        if (k > 1) k = 1;\n        // A locked layer keeps its transparent pixels (and leaves their tiles unwritten).\n        if (t.lockTransparency) {\n          const ri = this.locate(dx, dy, false);\n          if (ri < 0 || this.tile![ri + 3] === 0) continue;\n        }\n        const i = this.locate(dx, dy, true);\n        const px = this.tile!;\n        const pr = field ? field[p * 3] : paint[0];\n        const pg = field ? field[p * 3 + 1] : paint[1];\n        const pb = field ? field[p * 3 + 2] : paint[2];\n        if (general) {\n          const cb = this.cb;\n          for (let c = 0; c < 4; c++) cb[c] = px[i + c] / 255;\n          const src = this.src;\n          src[0] = pr;\n          src[1] = pg;\n          src[2] = pb;\n          const r = blendPixel(blend!, cb, src, k);\n          px[i] = Math.round(r[0] * 255);\n          px[i + 1] = Math.round(r[1] * 255);\n          px[i + 2] = Math.round(r[2] * 255);\n          if (!t.lockTransparency) px[i + 3] = Math.round(r[3] * 255);\n          continue;\n        }\n        const a = px[i + 3] / 255;\n        const na = t.lockTransparency ? a : a + (1 - a) * k;\n        // The new paint's share of the result (source-over); a locked layer mixes by `k` alone.\n        const share = t.lockTransparency ? k : na > 0 ? k / na : 1;\n        if (a <= 0 || share >= 1) {\n          o[0] = pr;\n          o[1] = pg;\n          o[2] = pb;\n        } else if (pigment && field) {\n          mixPigment8(px[i], px[i + 1], px[i + 2], Math.round(pr * 255), Math.round(pg * 255), Math.round(pb * 255), share, o);\n        } else if (pigment) {\n          const key = (px[i] << 16) | (px[i + 1] << 8) | px[i + 2];\n          if (key !== lastKey) {\n            setPigmentColor(this.canvasPig, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);\n            lastKey = key;\n          }\n          let pp = paintPigment;\n          if (!pp) {\n            // A pigment-blend tip over an RGB exchange: prepare the paint colour once per colour.\n            const pkey = (Math.round(pr * 255) << 16) | (Math.round(pg * 255) << 8) | Math.round(pb * 255);\n            if (pkey !== this.paintKey) {\n              setPigmentColor(this.paintPig, pr, pg, pb);\n              this.paintKey = pkey;\n            }\n            pp = this.paintPig;\n          }\n          lerpPigmentInto(this.canvasPig, pp, share, o, 0);\n        } else {\n          o[0] = px[i] / 255 + (pr - px[i] / 255) * share;\n          o[1] = px[i + 1] / 255 + (pg - px[i + 1] / 255) * share;\n          o[2] = px[i + 2] / 255 + (pb - px[i + 2] / 255) * share;\n        }\n        px[i] = Math.round(o[0] * 255);\n        px[i + 1] = Math.round(o[1] * 255);\n        px[i + 2] = Math.round(o[2] * 255);\n        px[i + 3] = Math.round(na * 255);\n      }\n    }\n  }\n}\n","// Portions ported from photocraft/crates/paint/src/mixer.rs (MIT OR Apache-2.0, © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.\n\n/**\n * The Mixer Brush: a reservoir of loaded paint plus a pickup well that takes up colour from the\n * canvas under each dab (photocraft's behavioural model):\n *\n * - Each dab samples the canvas under its footprint (coverage- and alpha-weighted). The pickup\n *   colour `P` moves towards that sample by `PICKUP_RATE × wet` (scaled by the sample's coverage).\n * - The dab's paint mixes the reservoir `R` (weight `amount × (1 − mix·wet)`) with the pickup\n *   (weight `mix·wet`) and lands at `flow × opacity` times the total weight, over the pixels as\n *   they are now, so earlier dabs of the same stroke are picked up again (smearing).\n * - The reservoir drains per dab unless `load` is 1, so low-load strokes run dry. A dry brush\n *   (`wet` 0) paints only reservoir colour; an empty, wet brush smears canvas colour.\n *\n * `mixing: 'pigment'` does all three mixes (pickup, paint and deposit) with the Kubelka-Munk model\n * of `./pigment`, so a blue brush dragged through yellow makes green instead of grey. Everything\n * is data in, pixels out: the same canvas, points, settings and load replay identically.\n */\n\nimport { DabWalker, dabRect, rasterizeDab, type BrushSettings, type Dab, type StrokePoint } from './brush';\nimport {\n  EMPTY_MIXER_LOAD,\n  exchangeRates,\n  MIXER_DRAIN,\n  MIXER_PICKUP_RATE,\n  MIXING_MODELS,\n  PaintExchange,\n  TileMedium,\n  type ExchangeRates,\n  type MixerLoad,\n  type MixingModel,\n  type PaintTileTarget,\n  type RgbTriple,\n} from './exchange';\nimport type { RasterRect as CropBox } from '../raster/surface';\n\n\nexport { EMPTY_MIXER_LOAD, MIXER_DRAIN, MIXER_PICKUP_RATE, MIXING_MODELS, type MixerLoad, type MixingModel };\n\n/** Mixer Brush options. */\nexport interface MixerSettings {\n  /** How much colour the brush picks up from the canvas (the pick-up ratio), 0 (dry) .. 1 (default 0.5). */\n  wet: number;\n  /** How much paint the reservoir holds, 0 .. 1 (default 0.5): below 1 it drains per dab and the stroke runs dry. */\n  load: number;\n  /** How far each dab's paint moves from the reservoir towards the picked-up colour (the mix ratio), 0 .. 1 (default 0.5). */\n  mix: number;\n  /** Refill the reservoir with the paint colour at the start of each stroke (default true). */\n  loadEachStroke: boolean;\n  /** Empty the pickup well after each stroke (default true); off keeps the brush dirty for the next stroke. */\n  cleanEachStroke: boolean;\n  /** `rgb` (default) or `pigment` (blue and yellow make green). */\n  mixing: MixingModel;\n}\n\nexport const DEFAULT_MIXER: Readonly<MixerSettings> = {\n  wet: 0.5,\n  load: 0.5,\n  mix: 0.5,\n  loadEachStroke: true,\n  cleanEachStroke: true,\n  mixing: 'rgb',\n};\n\n/** Mixer settings with every field in range (missing fields from `DEFAULT_MIXER`). */\nexport function normalizeMixer(raw: Partial<MixerSettings> = {}): MixerSettings {\n  const unit = (v: unknown, d: number) => (typeof v === 'number' && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d);\n  const bool = (v: unknown, d: boolean) => (typeof v === 'boolean' ? v : d);\n  return {\n    wet: unit(raw.wet, DEFAULT_MIXER.wet),\n    load: unit(raw.load, DEFAULT_MIXER.load),\n    mix: unit(raw.mix, DEFAULT_MIXER.mix),\n    loadEachStroke: bool(raw.loadEachStroke, DEFAULT_MIXER.loadEachStroke),\n    cleanEachStroke: bool(raw.cleanEachStroke, DEFAULT_MIXER.cleanEachStroke),\n    mixing: raw.mixing === 'pigment' ? 'pigment' : 'rgb',\n  };\n}\n\n/** The per-dab exchange rates of Mixer Brush settings (`wet` is the pick-up ratio, `mix` the mix ratio). */\nexport function mixerRates(settings: MixerSettings): ExchangeRates {\n  return exchangeRates(settings.wet, settings.mix, settings.load, settings.mixing);\n}\n\n/** The brush loaded full with `color` (sRGB 0..1); the pickup well is kept. */\nexport function loadMixer(load: MixerLoad, color: readonly [number, number, number]): MixerLoad {\n  const c = (v: number) => Math.min(1, Math.max(0, Number.isFinite(v) ? v : 0));\n  return { reservoir: [c(color[0]), c(color[1]), c(color[2])], amount: 1, pickup: load.pickup };\n}\n\n/** The brush with its pickup well emptied; the reservoir is kept. */\nexport function cleanMixer(load: MixerLoad): MixerLoad {\n  return { reservoir: load.reservoir, amount: load.amount, pickup: null };\n}\n\n/** The pixels a mixer stroke reads and writes (RGBA tiles in layer space). */\nexport type MixerTarget = PaintTileTarget;\n\n/**\n * One Mixer Brush stroke. Feed points with `push` (any chunks give the same dabs), end with\n * `finish`; `load` is the brush load after the dabs so far. Each call returns the document\n * rectangles it touched. Runs on the shared pick-up / mix exchange (`./exchange`).\n */\nexport class MixerStroke {\n  dabCount = 0;\n  bounds: CropBox | null = null;\n  private walker: DabWalker;\n  private smoothPos: StrokePoint | null = null;\n  private buf = new Float32Array(0);\n  private readonly exchange: PaintExchange;\n  private readonly medium: TileMedium;\n  private readonly paintColor: RgbTriple = [0, 0, 0];\n\n  constructor(\n    readonly brush: BrushSettings,\n    settings: Partial<MixerSettings>,\n    load: MixerLoad,\n    target: MixerTarget\n  ) {\n    this.walker = new DabWalker(brush);\n    this.exchange = new PaintExchange(mixerRates(normalizeMixer(settings)), load);\n    this.medium = new TileMedium(target);\n  }\n\n  /** The brush load after the dabs so far. */\n  get load(): MixerLoad {\n    return this.exchange.load;\n  }\n\n  push(points: readonly StrokePoint[]): CropBox[] {\n    const dabs: Dab[] = [];\n    for (const p of points) this.walker.push(this.smooth(p), dabs);\n    return this.paint(dabs);\n  }\n\n  finish(last?: StrokePoint): CropBox[] {\n    const dabs: Dab[] = [];\n    if (last && this.smoothPos && (this.smoothPos.x !== last.x || this.smoothPos.y !== last.y)) this.walker.push(last, dabs);\n    this.walker.finish(dabs);\n    return this.paint(dabs);\n  }\n\n  private smooth(p: StrokePoint): StrokePoint {\n    const a = 1 - Math.min(0.95, Math.max(0, this.brush.smoothing));\n    const cur = this.smoothPos;\n    const n = cur && a < 1 ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;\n    this.smoothPos = n;\n    return n;\n  }\n\n  private paint(dabs: Dab[]): CropBox[] {\n    const rects: CropBox[] = [];\n    for (const d of dabs) {\n      const rect = dabRect(d, this.brush.hardness);\n      const n = rect.width * rect.height;\n      if (this.buf.length < n) this.buf = new Float32Array(n);\n      const cov = this.buf.subarray(0, n);\n      // Pure tip coverage: flow scales the deposit, not the sampling weights.\n      rasterizeDab({ ...d, alpha: 1 }, this.brush.hardness, rect, cov);\n      this.dab(d, rect, cov);\n      rects.push(rect);\n      this.bounds = union(this.bounds, rect);\n      this.dabCount++;\n    }\n    return rects;\n  }\n\n  private dab(d: Dab, rect: CropBox, cov: Float32Array): void {\n    const ex = this.exchange;\n    // 1. Pick up from the canvas under the dab; 2. mix the dab's paint and lay it; 3. drain.\n    ex.pickUp(this.medium.sample(rect, cov));\n    const total = ex.paint(this.paintColor);\n    if (total > 0) {\n      const dep = Math.min(1, total) * this.brush.flow * this.brush.opacity * d.opacity;\n      if (dep > 0) this.medium.deposit(rect, cov, dep, this.paintColor, ex.paintPigment);\n    }\n    ex.drain();\n  }\n}\n\nfunction union(a: CropBox | null, b: CropBox): CropBox {\n  if (!a) return { ...b };\n  const x = Math.min(a.x, b.x);\n  const y = Math.min(a.y, b.y);\n  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };\n}\n","/**\n * Blending tools on raster tiles, dab by dab (any dab walker can drive them):\n *\n * - **Blender** (`blenderDab`): every pixel under the tip moves towards the mix of the paint\n *   within `distance` of it, so neighbouring colours run together. The mix is taken through the\n *   pigment model: the neighbourhood's K/S spectra are averaged with Kubelka-Munk weights\n *   (alpha × scattering), so blue next to yellow blends into green, not grey. `rgb` averages\n *   straight colours instead.\n * - **Smudge** (`SmudgeTip`): a finger that carries a patch of paint. Each dab lays the patch it\n *   carries over the pixels under the tip (`strength`) and picks up some of the paint that was\n *   there (`1 − length`), so the paint's pattern is dragged along the stroke and fades with distance.\n *   Optional pigment mixing for both steps.\n *\n * Both blend alpha too: blending next to bare canvas softens an edge, smudging drags paint out\n * into it. A transparency-locked layer keeps its alpha. Pure data in, pixels out.\n */\n\nimport { mixPigment8, pigment8 } from '../raster/blend';\nimport { PIGMENT_BANDS, lerpPigmentInto, type Pigment } from '../raster/pigment';\nimport type { RasterRect } from '../raster/surface';\nimport type { MixingModel, TileMedium } from './exchange';\n\n/** Blender options. */\nexport interface BlenderSettings {\n  /** How far each pixel moves towards the neighbourhood mix per dab at full coverage, 0..1 (default 0.5). */\n  strength: number;\n  /** Blend distance: the neighbourhood's radius as a fraction of the tip diameter, 0..1 (default 0.35). */\n  distance: number;\n  /** `pigment` (default: Kubelka-Munk, blue next to yellow blends green) or `rgb`. */\n  mixing: MixingModel;\n}\n\nexport const DEFAULT_BLENDER: Readonly<BlenderSettings> = { strength: 0.5, distance: 0.35, mixing: 'pigment' };\n\n/** Smudge options. */\nexport interface SmudgeSettings {\n  /** How strongly the carried paint covers the pixels under the tip per dab, 0..1 (default 0.7). */\n  strength: number;\n  /** How far paint is dragged: the share of the carried patch kept per dab, 0..1 (default 0.85). */\n  length: number;\n  /** `rgb` (default) or `pigment` (smeared colours mix like paint). */\n  mixing: MixingModel;\n}\n\nexport const DEFAULT_SMUDGE: Readonly<SmudgeSettings> = { strength: 0.7, length: 0.85, mixing: 'rgb' };\n\nconst unit = (v: unknown, d: number) => (typeof v === 'number' && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d);\n\nexport function normalizeBlender(raw: Partial<BlenderSettings> = {}, base: BlenderSettings = DEFAULT_BLENDER): BlenderSettings {\n  return { strength: unit(raw.strength, base.strength), distance: unit(raw.distance, base.distance), mixing: raw.mixing === 'rgb' || raw.mixing === 'pigment' ? raw.mixing : base.mixing };\n}\n\nexport function normalizeSmudge(raw: Partial<SmudgeSettings> = {}, base: SmudgeSettings = DEFAULT_SMUDGE): SmudgeSettings {\n  return { strength: unit(raw.strength, base.strength), length: unit(raw.length, base.length), mixing: raw.mixing === 'rgb' || raw.mixing === 'pigment' ? raw.mixing : base.mixing };\n}\n\n/** The neighbourhood radius in pixels of a blender dab of `radius`. */\nexport function blendRadius(settings: BlenderSettings, radius: number): number {\n  return Math.max(1, Math.round(settings.distance * 2 * radius));\n}\n\n/** Reusable buffers for `blenderDab` (one per stroke). */\nexport interface BlenderScratch {\n  sums: Float64Array;\n  mix: Pigment;\n  out: number[];\n}\n\nexport function createBlenderScratch(): BlenderScratch {\n  return { sums: new Float64Array(0), mix: { rgb: [0, 0, 0], strength: 1, ks: new Float32Array(PIGMENT_BANDS), scatter: 1 }, out: [0, 0, 0] };\n}\n\nconst N = PIGMENT_BANDS;\n\n/**\n * One blender dab: `cov` is the tip's coverage over `rect` (document space, 0..1), `opacity` the\n * dab's (pressure) opacity, `radius` its radius in pixels. Reads the neighbourhood as it was\n * before the dab, then writes every covered pixel.\n */\nexport function blenderDab(medium: TileMedium, rect: RasterRect, cov: ArrayLike<number>, opacity: number, radius: number, settings: BlenderSettings, scratch: BlenderScratch): void {\n  const R = blendRadius(settings, radius);\n  const W = rect.width + 2 * R;\n  const H = rect.height + 2 * R;\n  const pigment = settings.mixing === 'pigment';\n  // Channels per pixel: pigment: S·a·K/S per band, S·a, a, r·a, g·a, b·a; rgb: r·a, g·a, b·a, a.\n  const C = pigment ? N + 2 : 4;\n  const stride = (W + 1) * C;\n  const size = stride * (H + 1);\n  if (scratch.sums.length < size) scratch.sums = new Float64Array(size);\n  const I = scratch.sums;\n  I.fill(0, 0, size);\n  medium.reset();\n  // Summed-area table over the region (row 0 and column 0 stay zero).\n  const row = new Float64Array(C);\n  for (let y = 0; y < H; y++) {\n    row.fill(0);\n    const dy = rect.y - R + y;\n    for (let x = 0; x < W; x++) {\n      const dx = rect.x - R + x;\n      const i = medium.locate(dx, dy, false);\n      if (i >= 0) {\n        const px = medium.pixels;\n        const a = px[i + 3] / 255;\n        if (a > 0) {\n          if (pigment) {\n            const p = pigment8(px[i], px[i + 1], px[i + 2]);\n            const sa = p.scatter * p.strength * a;\n            for (let k = 0; k < N; k++) row[k] += sa * p.ks[k];\n            row[N] += sa;\n            row[N + 1] += a;\n          } else {\n            row[0] += (px[i] / 255) * a;\n            row[1] += (px[i + 1] / 255) * a;\n            row[2] += (px[i + 2] / 255) * a;\n            row[3] += a;\n          }\n        }\n      }\n      const o = (y + 1) * stride + (x + 1) * C;\n      const up = y * stride + (x + 1) * C;\n      for (let c = 0; c < C; c++) I[o + c] = I[up + c] + row[c];\n    }\n  }\n  const area = (2 * R + 1) * (2 * R + 1);\n  const strength = settings.strength * opacity;\n  const lock = medium.target.lockTransparency;\n  const mixPig = scratch.mix;\n  const out = scratch.out;\n  const sum = (c: number, x1: number, y1: number, x2: number, y2: number) => I[y2 * stride + x2 * C + c] - I[y1 * stride + x2 * C + c] - I[y2 * stride + x1 * C + c] + I[y1 * stride + x1 * C + c];\n  const w = rect.width;\n  medium.reset();\n  for (let yy = 0; yy < rect.height; yy++) {\n    for (let xx = 0; xx < w; xx++) {\n      const k = cov[yy * w + xx];\n      if (k <= 0) continue;\n      const dx = rect.x + xx;\n      const dy = rect.y + yy;\n      let t = strength * k * medium.selectionAt(dx, dy);\n      if (t <= 0) continue;\n      if (t > 1) t = 1;\n      // The window [x − R, x + R] in region coordinates, as summed-area bounds.\n      const x1 = xx;\n      const y1 = yy;\n      const x2 = xx + 2 * R + 1;\n      const y2 = yy + 2 * R + 1;\n      const asum = sum(pigment ? N + 1 : 3, x1, y1, x2, y2);\n      const ri = medium.locate(dx, dy, false);\n      const a = ri < 0 ? 0 : medium.pixels[ri + 3] / 255;\n      if (lock && a <= 0) continue;\n      const avgA = asum / area;\n      const na = lock ? a : (1 - t) * a + t * avgA;\n      if (asum <= 1e-9) {\n        // Only bare canvas nearby: the paint thins out (edges soften).\n        if (lock || a <= 0) continue;\n        const i = medium.locate(dx, dy, true);\n        medium.pixels[i + 3] = Math.round(na * 255);\n        continue;\n      }\n      // The neighbourhood's share of the paint in the result.\n      const share = lock ? t : na > 0 ? (t * avgA) / na : 1;\n      const i = medium.locate(dx, dy, true);\n      const px = medium.pixels;\n      if (pigment) {\n        const sa = sum(N, x1, y1, x2, y2);\n        for (let c = 0; c < N; c++) mixPig.ks[c] = sum(c, x1, y1, x2, y2) / sa;\n        mixPig.scatter = sa / asum;\n        if (a <= 0 || share >= 1) lerpPigmentInto(mixPig, mixPig, 0, out, 0);\n        else lerpPigmentInto(pigment8(px[i], px[i + 1], px[i + 2]), mixPig, share, out, 0);\n      } else {\n        for (let c = 0; c < 3; c++) {\n          const m = sum(c, x1, y1, x2, y2) / asum;\n          out[c] = a <= 0 || share >= 1 ? m : px[i + c] / 255 + (m - px[i + c] / 255) * share;\n        }\n      }\n      px[i] = Math.round(out[0] * 255);\n      px[i + 1] = Math.round(out[1] * 255);\n      px[i + 2] = Math.round(out[2] * 255);\n      if (!lock) px[i + 3] = Math.round(na * 255);\n    }\n  }\n}\n\n/** A dab as the smudge needs it: centre, radius (px) and pressure opacity. */\nexport interface SmudgeDab {\n  x: number;\n  y: number;\n  radius: number;\n  opacity: number;\n}\n\n/**\n * A smudging finger: carries a patch of paint (straight RGBA, `size × size` cells over the tip,\n * in canvas orientation) from dab to dab. The first dab only picks the patch up.\n */\nexport class SmudgeTip {\n  private readonly size: number;\n  private readonly patch: Float32Array;\n  private loaded = false;\n  private readonly out = [0, 0, 0];\n\n  constructor(\n    readonly settings: SmudgeSettings,\n    /** The largest tip diameter of the stroke, in pixels (the patch resolution). */\n    diameter: number\n  ) {\n    this.size = Math.max(2, Math.min(512, Math.ceil(diameter)));\n    this.patch = new Float32Array(this.size * this.size * 4);\n  }\n\n  private cell(d: SmudgeDab, px: number, py: number): number {\n    const s = this.size;\n    const r = Math.max(0.5, d.radius);\n    const bx = Math.min(s - 1, Math.max(0, Math.floor((((px - d.x) / r + 1) / 2) * s)));\n    const by = Math.min(s - 1, Math.max(0, Math.floor((((py - d.y) / r + 1) / 2) * s)));\n    return (by * s + bx) * 4;\n  }\n\n  /** Fills the patch from the pixels under the dab. */\n  private load(medium: TileMedium, d: SmudgeDab): void {\n    const s = this.size;\n    const r = Math.max(0.5, d.radius);\n    medium.reset();\n    for (let by = 0; by < s; by++) {\n      for (let bx = 0; bx < s; bx++) {\n        const dx = Math.floor(d.x + (((bx + 0.5) / s) * 2 - 1) * r);\n        const dy = Math.floor(d.y + (((by + 0.5) / s) * 2 - 1) * r);\n        const i = medium.locate(dx, dy, false);\n        const c = (by * s + bx) * 4;\n        if (i < 0) {\n          this.patch.fill(0, c, c + 4);\n          continue;\n        }\n        const px = medium.pixels;\n        this.patch[c] = px[i] / 255;\n        this.patch[c + 1] = px[i + 1] / 255;\n        this.patch[c + 2] = px[i + 2] / 255;\n        this.patch[c + 3] = px[i + 3] / 255;\n      }\n    }\n    this.loaded = true;\n  }\n\n  /** `a` mixed `t` of the way to `b` (both 0..1) into `out`. */\n  private mix(a0: number, a1: number, a2: number, b0: number, b1: number, b2: number, t: number): number[] {\n    const o = this.out;\n    if (this.settings.mixing === 'pigment') {\n      mixPigment8(Math.round(a0 * 255), Math.round(a1 * 255), Math.round(a2 * 255), Math.round(b0 * 255), Math.round(b1 * 255), Math.round(b2 * 255), t, o);\n    } else {\n      o[0] = a0 + (b0 - a0) * t;\n      o[1] = a1 + (b1 - a1) * t;\n      o[2] = a2 + (b2 - a2) * t;\n    }\n    return o;\n  }\n\n  /** One dab: lays the carried patch over the tip's footprint (`cov` over `rect`), then picks up. */\n  dab(medium: TileMedium, d: SmudgeDab, rect: RasterRect, cov: ArrayLike<number>): void {\n    if (!this.loaded) {\n      this.load(medium, d);\n      return;\n    }\n    const { strength, length } = this.settings;\n    const lock = medium.target.lockTransparency;\n    const patch = this.patch;\n    const w = rect.width;\n    medium.reset();\n    for (let yy = 0; yy < rect.height; yy++) {\n      for (let xx = 0; xx < w; xx++) {\n        const cv = cov[yy * w + xx];\n        if (cv <= 0) continue;\n        const dx = rect.x + xx;\n        const dy = rect.y + yy;\n        let k = strength * cv * d.opacity * medium.selectionAt(dx, dy);\n        if (k <= 0) continue;\n        if (k > 1) k = 1;\n        const c = this.cell(d, dx + 0.5, dy + 0.5);\n        const ba = patch[c + 3];\n        const ri = medium.locate(dx, dy, false);\n        const a = ri < 0 ? 0 : medium.pixels[ri + 3] / 255;\n        if (lock && a <= 0) continue;\n        // The pixel as it was: what the finger lays paint over, and what it picks up afterwards.\n        const px0 = ri >= 0 ? medium.pixels : null;\n        const o0 = px0 ? px0[ri] / 255 : 0;\n        const o1 = px0 ? px0[ri + 1] / 255 : 0;\n        const o2 = px0 ? px0[ri + 2] / 255 : 0;\n        if (a > 0 || ba > 0) {\n          const na = lock ? a : a + (ba - a) * k;\n          const share = lock ? k * ba : na > 0 ? (k * ba) / na : 0;\n          let r = o0;\n          let g = o1;\n          let b = o2;\n          if (a <= 0 || share >= 1) {\n            r = patch[c];\n            g = patch[c + 1];\n            b = patch[c + 2];\n          } else if (share > 0) {\n            const m = this.mix(o0, o1, o2, patch[c], patch[c + 1], patch[c + 2], share);\n            r = m[0];\n            g = m[1];\n            b = m[2];\n          }\n          const i = medium.locate(dx, dy, true);\n          const out = medium.pixels;\n          out[i] = Math.round(r * 255);\n          out[i + 1] = Math.round(g * 255);\n          out[i + 2] = Math.round(b * 255);\n          out[i + 3] = Math.round(na * 255);\n        }\n        // Pick up: the patch takes `1 − length` of the paint that was under it (alpha-weighted).\n        const pick = (1 - length) * Math.min(1, cv * d.opacity);\n        if (pick > 0) {\n          const pa = ba + (a - ba) * pick;\n          const s = pa > 0 ? (a * pick) / pa : 0;\n          if (s > 0) {\n            const m = ba <= 0 || s >= 1 ? [o0, o1, o2] : this.mix(patch[c], patch[c + 1], patch[c + 2], o0, o1, o2, s);\n            patch[c] = m[0];\n            patch[c + 1] = m[1];\n            patch[c + 2] = m[2];\n          }\n          patch[c + 3] = pa;\n        }\n      }\n    }\n  }\n}\n","import type { AgentTool } from '../tools/registry.js';\nimport { createPigment, mixPigments, type Pigment } from './pigment';\n\nconst HEX = /^#?([0-9a-f]{6})$/i;\n\nfunction parseHex(value: unknown, index: number): [number, number, number] {\n  const m = typeof value === 'string' ? HEX.exec(value.trim()) : null;\n  if (!m) throw new Error(`colors[${index}].color is ${JSON.stringify(value)}; use #rrggbb, e.g. \"#1e40af\".`);\n  const n = parseInt(m[1], 16);\n  return [((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255];\n}\n\nfunction toHex(rgb: readonly number[]): string {\n  return '#' + rgb.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, '0')).join('');\n}\n\n/**\n * Agent tools for pigment mixing (`@pixerate/editor/paint`). `mix_colors` is read-only: it\n * predicts what paints mixed in given amounts look like, for choosing a brush or fill colour.\n */\nexport function createPigmentTools(): AgentTool[] {\n  const mixColors: AgentTool = {\n    name: 'mix_colors',\n    title: 'Mix colours like paint',\n    description:\n      'Mixes colours as paint would (model pigment, the default: Kubelka-Munk mixing over reflectance spectra, so blue and yellow make green and white lightens a colour into a tint instead of greying it), or as light on screen (model rgb: the weighted RGB average). Changes nothing. Returns mixed (#rrggbb, by the chosen model), the other model\\'s result for comparison (rgbLerp and pigment), the normalised weights and the model.',\n    inputSchema: {\n      type: 'object',\n      properties: {\n        colors: {\n          type: 'array',\n          minItems: 1,\n          maxItems: 16,\n          description: 'The paints to mix (1 to 16).',\n          items: {\n            type: 'object',\n            properties: {\n              color: { type: 'string', description: 'Paint colour #rrggbb.' },\n              weight: { type: 'number', minimum: 0, description: 'Parts of this paint, any scale (e.g. 1 and 3 for a 1:3 mix). At least one weight must be above 0.' },\n              strength: {\n                type: 'number',\n                exclusiveMinimum: 0,\n                maximum: 100,\n                description: 'Tinting strength (default 1): each part counts as this many, so a strong dark paint (e.g. 4) tints a lot of white.',\n              },\n            },\n            required: ['color', 'weight'],\n            additionalProperties: false,\n          },\n        },\n        model: {\n          type: 'string',\n          enum: ['pigment', 'rgb'],\n          description: 'pigment (default): mix like paint (Kubelka-Munk), as the pigment blend mode, Mixer Brush and mixing pad do; rgb: average the RGB values, as normal blending and rgb mixing brushes do (strength is ignored).',\n        },\n      },\n      required: ['colors'],\n      additionalProperties: false,\n    },\n    annotations: { title: 'Mix colours like paint', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },\n    handler: (args) => {\n      const items = args.colors as { color: string; weight: number; strength?: number }[];\n      const rgbs = items.map((item, i) => parseHex(item.color, i));\n      const total = items.reduce((sum, item) => sum + item.weight, 0);\n      if (!(total > 0)) throw new Error('Every weight is 0; give at least one colour a weight above 0.');\n      const pigments: Pigment[] = rgbs.map((rgb, i) => createPigment(rgb, { strength: items[i].strength }));\n      const mixed = mixPigments(pigments, items.map((item) => item.weight));\n      const lerp = [0, 1, 2].map((c) => rgbs.reduce((sum, rgb, i) => sum + rgb[c] * items[i].weight, 0) / total);\n      const rgb = args.model === 'rgb';\n      return {\n        mixed: toHex(rgb ? lerp : mixed),\n        rgbLerp: toHex(lerp),\n        pigment: toHex(mixed),\n        weights: items.map((item) => item.weight / total),\n        model: rgb ? 'rgb' : 'kubelka-munk',\n      };\n    },\n  };\n  return [mixColors];\n}\n"]}

package/dist/chunk-TFOPHZ3U.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/chunk-TFOPHZ3U.cjs","../src/raster/surface.ts","../src/raster/pigment.ts","../src/raster/blend.ts"],"names":["lin","weights","clamp01"],"mappings":"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ACA,EAAA;AACD,IAAA;AACC,IAAA;AACD,IAAA;AACC,IAAA;AACD,IAAA;AACD,IAAA;AACD,IAAA;AACA,IAAA;AACC,IAAA;AACD,MAAA;AACG,MAAA;AACD,QAAA;AACF,QAAA;AACA,QAAA;AACA,QAAA;AACN,MAAA;AACF,IAAA;AACF,EAAA;AACS,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACX,EAAA;AACY,EAAA;AACd;AAGS;AACI,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACC,EAAA;AACD,EAAA;AACA,EAAA;AACJ,EAAA;AACM,IAAA;AACJ,IAAA;AACA,IAAA;AACT,EAAA;AACF;AAEM;AAQG;AACI,EAAA;AACC,EAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACD,IAAA;AACI,IAAA;AACb,EAAA;AACY,EAAA;AACA,EAAA;AACA,EAAA;AACF,EAAA;AACJ,EAAA;AACO,EAAA;AACL,IAAA;AACA,IAAA;AACR,EAAA;AACU,EAAA;AACZ;AAES;AACM,EAAA;AACD,IAAA;AACC,IAAA;AACP,IAAA;AACN,EAAA;AACF;AAO4B;AACK;AAOxB;AACI,EAAA;AACD,EAAA;AACA,EAAA;AACE,EAAA;AACN,EAAA;AACO,EAAA;AACF,IAAA;AAEA,MAAA;AACE,MAAA;AACP,QAAA;AACI,QAAA;AACJ,QAAA;AACF,MAAA;AACF,IAAA;AACF,EAAA;AACQ,EAAA;AACV;AAGiB;AACA;AACF;AAGN;AACG,EAAA;AACA,EAAA;AACC,EAAA;AACC,EAAA;AACDA,EAAAA;AACC,EAAA;AACA,EAAA;AACL,EAAA;AACT;AAMgB;AACJ,EAAA;AACA,EAAA;AACC,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACD,EAAA;AACD,EAAA;AACI,IAAA;AACC,IAAA;AACD,IAAA;AACL,IAAA;AACF,IAAA;AACE,IAAA;AACG,IAAA;AACX,EAAA;AACO,EAAA;AACT;AAGgB;AACJ,EAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACK,EAAA;AACD,IAAA;AACF,IAAA;AACG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,IAAA;AACU,IAAA;AACZ,EAAA;AACY,EAAA;AACd;AAOyC;AAMzB;AACL,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACF,IAAA;AACT,EAAA;AACU,EAAA;AACC,IAAA;AACA,IAAA;AACA,IAAA;AACF,IAAA;AACT,EAAA;AACa,EAAA;AACF,EAAA;AACX,EAAA;AACA,EAAA;AACA,EAAA;AACO,EAAA;AACT;AAGM;AAEA;AAMU;AACP,EAAA;AACT;AAES;AACM,EAAA;AACL,EAAA;AACA,EAAA;AACF,IAAA;AACA,IAAA;AACJ,IAAA;AACF,EAAA;AACO,EAAA;AACT;AAMgB;AACL,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACT,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAUgB;AACH,EAAA;AACC,EAAA;AACD,EAAA;AACA,EAAA;AACE,EAAA;AACM,EAAA;AACN,EAAA;AACX,IAAA;AACO,IAAA;AACT,EAAA;AACU,EAAA;AACG,EAAA;AACA,IAAA;AACb,EAAA;AACO,EAAA;AACT;AAMgB;AACJ,EAAA;AACA,EAAA;AACE,EAAA;AACA,EAAA;AACA,EAAA;AACN,EAAA;AACO,EAAA;AACA,IAAA;AACP,IAAA;AACI,MAAA;AACA,MAAA;AACA,MAAA;AACN,MAAA;AACO,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACP,MAAA;AACF,IAAA;AACS,IAAA;AACC,MAAA;AACA,MAAA;AACV,IAAA;AACU,IAAA;AACH,IAAA;AACI,IAAA;AACA,IAAA;AACA,IAAA;AACb,EAAA;AACF;AH6Ze;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/editor/editor/packages/core/dist/chunk-TFOPHZ3U.cjs","sourcesContent":[null,"// Portions ported from photocraft/crates/raster/src/lib.rs (MIT OR Apache-2.0, © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.\n\n/**\n * Tiled, sparse, copy-on-write pixel storage (photocraft's `Surface`): 256 px square tiles in a\n * map keyed by tile coordinate, a default value for every missing tile, and shared tiles.\n *\n * - Pixels are 8-bit, straight alpha: RGBA for layers (4 channels, the same as `ImageData`), one\n *   byte for masks.\n * - A surface is never mutated. A write returns a new surface that shares every tile it did not\n *   touch, so undo history and caches can keep old surfaces by reference.\n * - A tile whose pixels all hold one value is a *uniform* tile; one instance per value is shared,\n *   so a solid fill or a \"hide all\" mask costs one tile however large it is.\n * - Coordinates are document pixels and may be negative or past the canvas (layers can extend\n *   beyond it, as PSD layer rects do).\n *\n * The module has no DOM dependency, so it runs in Node, tests and workers.\n */\n\n/** A pixel rectangle (`x`, `y` of the top-left corner, `width`, `height`). */\nexport interface RasterRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\ntype CropBox = RasterRect;\n\nexport const TILE = 256;\nexport const TILE_SHIFT = 8;\nconst TILE_PIXELS = TILE * TILE;\nconst KEY_OFFSET = 1 << 15;\nconst KEY_SPAN = 1 << 16;\n\n/** A tile coordinate packed into one number (tx, ty in −32768..32767). */\nexport type TileKey = number;\n\nexport function tileKey(tx: number, ty: number): TileKey {\n  return (ty + KEY_OFFSET) * KEY_SPAN + (tx + KEY_OFFSET);\n}\n\nexport function tileCoord(key: TileKey): { tx: number; ty: number } {\n  return { tx: (key % KEY_SPAN) - KEY_OFFSET, ty: Math.floor(key / KEY_SPAN) - KEY_OFFSET };\n}\n\n/** A tile's pixel rectangle in document space. */\nexport function tileRect(tx: number, ty: number): CropBox {\n  return { x: tx * TILE, y: ty * TILE, width: TILE, height: TILE };\n}\n\n/** One tile: TILE × TILE pixels of `channels` bytes. Never mutate `data` after it is shared. */\nexport interface Tile {\n  readonly data: Uint8ClampedArray;\n  /** The packed value of every pixel when the tile is uniform, else `null`. */\n  readonly uniform: number | null;\n  /**\n   * High bit depth samples (see `./deep`): 16-bit sRGB-encoded or 32-bit linear float, of which\n   * `data` is the 8-bit rendering. Missing: the tile is 8-bit.\n   */\n  readonly deep?: Uint16Array | Float32Array;\n}\n\nlet nextSurfaceId = 1;\n\n/**\n * An immutable tiled surface. `channels` is 4 (RGBA) for layers and 1 for masks. Missing tiles\n * hold `defaultValue` in every byte (0: transparent black for layers; 0 or 255 for masks).\n */\nexport class TiledSurface {\n  /** Unique per instance: a cache key that changes whenever the pixels can have changed. */\n  readonly id = nextSurfaceId++;\n  private boundsCache: CropBox | null | undefined;\n\n  constructor(\n    readonly channels: 1 | 4,\n    readonly tiles: ReadonlyMap<TileKey, Tile>,\n    readonly defaultValue = 0\n  ) {}\n\n  /** Bounds of the stored (non-default) tiles, tile-aligned; `null` when there are none. */\n  get bounds(): CropBox | null {\n    if (this.boundsCache === undefined) this.boundsCache = tileUnion(this.tiles.keys());\n    return this.boundsCache;\n  }\n\n  get tileCount(): number {\n    return this.tiles.size;\n  }\n\n  getTile(tx: number, ty: number): Tile | undefined {\n    return this.tiles.get(tileKey(tx, ty));\n  }\n}\n\nexport type PixelSurface = TiledSurface;\nexport type MaskSurface = TiledSurface;\n\nfunction tileUnion(keys: Iterable<TileKey>): CropBox | null {\n  let x0 = Infinity;\n  let y0 = Infinity;\n  let x1 = -Infinity;\n  let y1 = -Infinity;\n  for (const key of keys) {\n    const { tx, ty } = tileCoord(key);\n    if (tx < x0) x0 = tx;\n    if (ty < y0) y0 = ty;\n    if (tx > x1) x1 = tx;\n    if (ty > y1) y1 = ty;\n  }\n  if (x0 === Infinity) return null;\n  return { x: x0 * TILE, y: y0 * TILE, width: (x1 - x0 + 1) * TILE, height: (y1 - y0 + 1) * TILE };\n}\n\n// ---------------------------------------------------------------------------\n// Uniform tiles\n// ---------------------------------------------------------------------------\n\nconst uniformTiles = new Map<string, Tile>();\nconst UNIFORM_LIMIT = 64;\n\n/** Packs one pixel (`channels` bytes from `data` at `offset`) into a number. */\nfunction packPixel(data: ArrayLike<number>, offset: number, channels: number): number {\n  return channels === 1\n    ? data[offset]\n    : ((data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3]) >>> 0;\n}\n\n/** The shared tile whose every pixel is `value` (packed RGBA, or one byte for masks). */\nexport function uniformTile(channels: 1 | 4, value: number): Tile {\n  const key = `${channels}:${value}`;\n  let tile = uniformTiles.get(key);\n  if (tile) return tile;\n  const data = new Uint8ClampedArray(TILE_PIXELS * channels);\n  if (channels === 1) data.fill(value);\n  else if (value !== 0) {\n    const r = value >>> 24;\n    const g = (value >>> 16) & 255;\n    const b = (value >>> 8) & 255;\n    const a = value & 255;\n    for (let i = 0; i < data.length; i += 4) {\n      data[i] = r;\n      data[i + 1] = g;\n      data[i + 2] = b;\n      data[i + 3] = a;\n    }\n  }\n  tile = { data, uniform: value };\n  if (uniformTiles.size >= UNIFORM_LIMIT) uniformTiles.delete(uniformTiles.keys().next().value as string);\n  uniformTiles.set(key, tile);\n  return tile;\n}\n\n/** Packs an RGBA colour (0..255 each) the way uniform tiles store it. */\nexport function packRgba(r: number, g: number, b: number, a: number): number {\n  return ((r << 24) | (g << 16) | (b << 8) | a) >>> 0;\n}\n\nfunction defaultPacked(channels: 1 | 4, defaultValue: number): number {\n  return channels === 1 ? defaultValue : packRgba(defaultValue, defaultValue, defaultValue, defaultValue);\n}\n\n/** The packed value when every pixel of `data` is the same, else `null`. */\nfunction uniformValue(data: Uint8ClampedArray, channels: 1 | 4): number | null {\n  if (channels === 1) {\n    const v = data[0];\n    for (let i = 1; i < data.length; i++) if (data[i] !== v) return null;\n    return v;\n  }\n  const words = new Uint32Array(data.buffer, data.byteOffset, data.length >> 2);\n  const w = words[0];\n  for (let i = 1; i < words.length; i++) if (words[i] !== w) return null;\n  return packPixel(data, 0, 4);\n}\n\n/**\n * Turns freshly written tile data into a stored tile: `null` when it equals the surface default\n * (the tile is dropped), the shared uniform tile when it is uniform, else a tile owning `data`.\n */\nexport function finishTile(data: Uint8ClampedArray, channels: 1 | 4, defaultValue: number): Tile | null {\n  const u = uniformValue(data, channels);\n  if (u === null) return { data, uniform: null };\n  if (u === defaultPacked(channels, defaultValue)) return null;\n  return uniformTile(channels, u);\n}\n\n// ---------------------------------------------------------------------------\n// Construction\n// ---------------------------------------------------------------------------\n\n/** An empty surface (every pixel is `defaultValue`). */\nexport function emptySurface(channels: 1 | 4 = 4, defaultValue = 0): TiledSurface {\n  return new TiledSurface(channels, new Map(), defaultValue);\n}\n\n/** A surface filled with one value over `rect` (packed RGBA for layers, a byte for masks). */\nexport function solidSurface(channels: 1 | 4, rect: CropBox, value: number, defaultValue = 0): TiledSurface {\n  const bytes = new Uint8ClampedArray(channels);\n  if (channels === 1) bytes[0] = value;\n  else {\n    bytes[0] = value >>> 24;\n    bytes[1] = (value >>> 16) & 255;\n    bytes[2] = (value >>> 8) & 255;\n    bytes[3] = value & 255;\n  }\n  return fillRect(emptySurface(channels, defaultValue), rect, bytes);\n}\n\n/**\n * A surface holding `width × height` interleaved pixels placed at (`x`, `y`) in document space.\n * Tiles equal to the default are left out; uniform tiles are shared.\n */\nexport function surfaceFromPixels(\n  pixels: { width: number; height: number; data: ArrayLike<number> },\n  channels: 1 | 4 = 4,\n  x = 0,\n  y = 0,\n  defaultValue = 0\n): TiledSurface {\n  return writeRegion(emptySurface(channels, defaultValue), { x, y, width: pixels.width, height: pixels.height }, pixels.data);\n}\n\n// ---------------------------------------------------------------------------\n// Reading\n// ---------------------------------------------------------------------------\n\n/** Tile coordinates covering `rect`, row by row. */\nexport function tilesInRect(rect: CropBox): Array<{ tx: number; ty: number }> {\n  const out: Array<{ tx: number; ty: number }> = [];\n  if (rect.width <= 0 || rect.height <= 0) return out;\n  const tx0 = Math.floor(rect.x / TILE);\n  const ty0 = Math.floor(rect.y / TILE);\n  const tx1 = Math.floor((rect.x + rect.width - 1) / TILE);\n  const ty1 = Math.floor((rect.y + rect.height - 1) / TILE);\n  for (let ty = ty0; ty <= ty1; ty++) for (let tx = tx0; tx <= tx1; tx++) out.push({ tx, ty });\n  return out;\n}\n\n/**\n * Copies `rect` of the surface into `out` (or a new buffer), `rect.width × rect.height`\n * interleaved pixels; missing tiles read as the default.\n */\nexport function readRegion(surface: TiledSurface, rect: CropBox, out?: Uint8ClampedArray): Uint8ClampedArray {\n  const ch = surface.channels;\n  const w = rect.width;\n  const h = rect.height;\n  const dst = out ?? new Uint8ClampedArray(w * h * ch);\n  if (surface.defaultValue !== 0) dst.fill(surface.defaultValue);\n  else if (out) dst.fill(0);\n  for (const { tx, ty } of tilesInRect(rect)) {\n    const tile = surface.getTile(tx, ty);\n    if (!tile) continue;\n    const ox = tx * TILE;\n    const oy = ty * TILE;\n    const x0 = Math.max(rect.x, ox);\n    const y0 = Math.max(rect.y, oy);\n    const x1 = Math.min(rect.x + w, ox + TILE);\n    const y1 = Math.min(rect.y + h, oy + TILE);\n    const span = (x1 - x0) * ch;\n    for (let yy = y0; yy < y1; yy++) {\n      const s = ((yy - oy) * TILE + (x0 - ox)) * ch;\n      const d = ((yy - rect.y) * w + (x0 - rect.x)) * ch;\n      dst.set(tile.data.subarray(s, s + span), d);\n    }\n  }\n  return dst;\n}\n\n/** One pixel's bytes (RGBA or the mask byte). */\nexport function readPixel(surface: TiledSurface, x: number, y: number): number[] {\n  const tile = surface.getTile(Math.floor(x / TILE), Math.floor(y / TILE));\n  const ch = surface.channels;\n  if (!tile) return new Array(ch).fill(surface.defaultValue);\n  const i = (((y & (TILE - 1)) * TILE) + (x & (TILE - 1))) * ch;\n  return Array.from(tile.data.subarray(i, i + ch));\n}\n\n/**\n * Exact bounds of the pixels that differ from the default (for a layer: non-transparent), or\n * `null`. Scans the stored tiles; uniform tiles count whole.\n */\nexport function contentBounds(surface: TiledSurface): CropBox | null {\n  const ch = surface.channels;\n  const def = surface.defaultValue;\n  let x0 = Infinity;\n  let y0 = Infinity;\n  let x1 = -Infinity;\n  let y1 = -Infinity;\n  for (const [key, tile] of surface.tiles) {\n    const { tx, ty } = tileCoord(key);\n    const ox = tx * TILE;\n    const oy = ty * TILE;\n    if (tile.uniform !== null) {\n      if (ox < x0) x0 = ox;\n      if (oy < y0) y0 = oy;\n      if (ox + TILE - 1 > x1) x1 = ox + TILE - 1;\n      if (oy + TILE - 1 > y1) y1 = oy + TILE - 1;\n      continue;\n    }\n    const d = tile.data;\n    for (let y = 0; y < TILE; y++) {\n      let first = -1;\n      let last = -1;\n      const row = y * TILE * ch;\n      for (let x = 0; x < TILE; x++) {\n        const i = row + x * ch;\n        let differs = false;\n        for (let c = 0; c < ch; c++) if (d[i + c] !== def) differs = true;\n        if (differs) {\n          if (first < 0) first = x;\n          last = x;\n        }\n      }\n      if (first < 0) continue;\n      if (ox + first < x0) x0 = ox + first;\n      if (ox + last > x1) x1 = ox + last;\n      if (oy + y < y0) y0 = oy + y;\n      if (oy + y > y1) y1 = oy + y;\n    }\n  }\n  if (x0 === Infinity) return null;\n  return { x: x0, y: y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };\n}\n\n// ---------------------------------------------------------------------------\n// Writing (copy-on-write)\n// ---------------------------------------------------------------------------\n\n/**\n * A private, mutable copy of the tiles a write touches. `tile(tx, ty)` copies the tile on first\n * use; `commit()` returns a new surface sharing every untouched tile. Use it for strokes:\n * edit through the draft while the pointer moves and commit once at pointer-up.\n */\nexport class SurfaceDraft {\n  private readonly copies = new Map<TileKey, Uint8ClampedArray>();\n\n  constructor(readonly base: TiledSurface) {}\n\n  get channels(): 1 | 4 {\n    return this.base.channels;\n  }\n\n  /** The writable data of tile (tx, ty), copied from the base on first use. */\n  tile(tx: number, ty: number): Uint8ClampedArray {\n    const key = tileKey(tx, ty);\n    let data = this.copies.get(key);\n    if (data) return data;\n    const src = this.base.tiles.get(key);\n    if (src) data = new Uint8ClampedArray(src.data);\n    else {\n      data = new Uint8ClampedArray(TILE_PIXELS * this.base.channels);\n      if (this.base.defaultValue !== 0) data.fill(this.base.defaultValue);\n    }\n    this.copies.set(key, data);\n    return data;\n  }\n\n  /** Replaces a whole tile with `data` (owned by the draft from now on). */\n  replace(tx: number, ty: number, data: Uint8ClampedArray): void {\n    this.copies.set(tileKey(tx, ty), data);\n  }\n\n  /** The current data of a tile without copying it (base tile, draft copy or `null` for default). */\n  peek(tx: number, ty: number): Uint8ClampedArray | null {\n    const key = tileKey(tx, ty);\n    return this.copies.get(key) ?? this.base.tiles.get(key)?.data ?? null;\n  }\n\n  /** Keys of the tiles changed so far. */\n  get touched(): TileKey[] {\n    return [...this.copies.keys()];\n  }\n\n  /** A new surface with the draft's tiles; the draft must not be used afterwards. */\n  commit(): TiledSurface {\n    if (!this.copies.size) return this.base;\n    const tiles = new Map(this.base.tiles);\n    const { channels, defaultValue } = this.base;\n    for (const [key, data] of this.copies) {\n      const tile = finishTile(data, channels, defaultValue);\n      if (tile) tiles.set(key, tile);\n      else tiles.delete(key);\n    }\n    return new TiledSurface(channels, tiles, defaultValue);\n  }\n}\n\n/** Writes `rect.width × rect.height` interleaved pixels at `rect`; returns the new surface. */\nexport function writeRegion(surface: TiledSurface, rect: CropBox, data: ArrayLike<number>): TiledSurface {\n  const ch = surface.channels;\n  const w = rect.width;\n  const h = rect.height;\n  if (w <= 0 || h <= 0) return surface;\n  if (data.length < w * h * ch) throw new Error(`writeRegion: expected ${w * h * ch} bytes, got ${data.length}`);\n  const draft = new SurfaceDraft(surface);\n  const src = data as Uint8ClampedArray;\n  const canSubarray = typeof (src as Uint8ClampedArray).subarray === 'function';\n  for (const { tx, ty } of tilesInRect(rect)) {\n    const ox = tx * TILE;\n    const oy = ty * TILE;\n    const x0 = Math.max(rect.x, ox);\n    const y0 = Math.max(rect.y, oy);\n    const x1 = Math.min(rect.x + w, ox + TILE);\n    const y1 = Math.min(rect.y + h, oy + TILE);\n    const full = x0 === ox && y0 === oy && x1 === ox + TILE && y1 === oy + TILE;\n    const t = full ? new Uint8ClampedArray(TILE_PIXELS * ch) : draft.tile(tx, ty);\n    const span = (x1 - x0) * ch;\n    for (let yy = y0; yy < y1; yy++) {\n      const s = ((yy - rect.y) * w + (x0 - rect.x)) * ch;\n      const d = ((yy - oy) * TILE + (x0 - ox)) * ch;\n      if (canSubarray) t.set(src.subarray(s, s + span), d);\n      else for (let k = 0; k < span; k++) t[d + k] = src[s + k];\n    }\n    if (full) draft.replace(tx, ty, t);\n  }\n  return draft.commit();\n}\n\n/** Fills `rect` with one pixel value (`bytes`, `channels` long). */\nexport function fillRect(surface: TiledSurface, rect: CropBox, bytes: ArrayLike<number>): TiledSurface {\n  const ch = surface.channels;\n  if (rect.width <= 0 || rect.height <= 0) return surface;\n  const tiles = new Map(surface.tiles);\n  const draft = new SurfaceDraft(surface);\n  const value = packPixel(bytes, 0, ch);\n  const isDefault = value === defaultPacked(ch, surface.defaultValue);\n  for (const { tx, ty } of tilesInRect(rect)) {\n    const ox = tx * TILE;\n    const oy = ty * TILE;\n    const x0 = Math.max(rect.x, ox);\n    const y0 = Math.max(rect.y, oy);\n    const x1 = Math.min(rect.x + rect.width, ox + TILE);\n    const y1 = Math.min(rect.y + rect.height, oy + TILE);\n    const key = tileKey(tx, ty);\n    if (x0 === ox && y0 === oy && x1 === ox + TILE && y1 === oy + TILE) {\n      if (isDefault) tiles.delete(key);\n      else tiles.set(key, uniformTile(ch, value));\n      continue;\n    }\n    const t = draft.tile(tx, ty);\n    for (let yy = y0; yy < y1; yy++) {\n      let d = ((yy - oy) * TILE + (x0 - ox)) * ch;\n      for (let xx = x0; xx < x1; xx++, d += ch) for (let c = 0; c < ch; c++) t[d + c] = bytes[c];\n    }\n    const tile = finishTile(t, ch, surface.defaultValue);\n    if (tile) tiles.set(key, tile);\n    else tiles.delete(key);\n  }\n  return new TiledSurface(ch, tiles, surface.defaultValue);\n}\n\n/** A copy of the surface moved by an integer offset (re-tiles; layers normally move by `offset`). */\nexport function translateSurface(surface: TiledSurface, dx: number, dy: number): TiledSurface {\n  dx = Math.round(dx);\n  dy = Math.round(dy);\n  if (!dx && !dy) return surface;\n  if (dx % TILE === 0 && dy % TILE === 0) {\n    const tiles = new Map<TileKey, Tile>();\n    for (const [key, tile] of surface.tiles) {\n      const { tx, ty } = tileCoord(key);\n      tiles.set(tileKey(tx + dx / TILE, ty + dy / TILE), tile);\n    }\n    return new TiledSurface(surface.channels, tiles, surface.defaultValue);\n  }\n  const b = surface.bounds;\n  if (!b) return surface;\n  const data = readRegion(surface, b);\n  return writeRegion(emptySurface(surface.channels, surface.defaultValue), { ...b, x: b.x + dx, y: b.y + dy }, data);\n}\n\n// ---------------------------------------------------------------------------\n// Memory\n// ---------------------------------------------------------------------------\n\n/** Bytes held by a surface's non-uniform tiles (uniform tiles are shared and nearly free). */\nexport function surfaceBytes(surface: TiledSurface): number {\n  let n = 0;\n  for (const tile of surface.tiles.values()) if (tile.uniform === null) n += tile.data.byteLength;\n  return n;\n}\n\n/** Adds every non-uniform tile of `surface` to `into` (for counting bytes shared across states). */\nexport function collectTiles(surface: TiledSurface, into: Set<Tile>): void {\n  for (const tile of surface.tiles.values()) if (tile.uniform === null) into.add(tile);\n}\n\n/** True when two surfaces hold the same pixels (cheap when they share tiles). */\nexport function surfacesEqual(a: TiledSurface, b: TiledSurface): boolean {\n  if (a === b) return true;\n  if (a.channels !== b.channels || a.defaultValue !== b.defaultValue || a.tiles.size !== b.tiles.size) return false;\n  for (const [key, ta] of a.tiles) {\n    const tb = b.tiles.get(key);\n    if (!tb) return false;\n    if (ta === tb) continue;\n    if (ta.uniform !== null || tb.uniform !== null) {\n      if (ta.uniform !== tb.uniform) return false;\n      continue;\n    }\n    const x = ta.data;\n    const y = tb.data;\n    for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) return false;\n  }\n  return true;\n}\n","/**\n * Pigment-like colour mixing: blue and yellow make green, red and white make pink, as paint does.\n *\n * Each sRGB colour is lifted to a smooth reflectance spectrum, the spectra are mixed with the\n * Kubelka-Munk two-flux model, and the mixed spectrum is turned back into sRGB. Written from the\n * published literature; no third-party code or data:\n *\n * 1. **Spectral uplift.** A colour's reflectance is a sigmoid of a quadratic in wavelength,\n *    `R(λ) = s(c₀λ² + c₁λ + c₂)` with `s(z) = ½ + z / 2√(1 + z²)` (Jakob & Hanika, \"A\n *    Low-Dimensional Function Space for Efficient Spectral Upsampling\", Eurographics 2019). The\n *    three coefficients are solved per colour with Newton's method so the spectrum reproduces the\n *    colour. Spectra are precomputed lazily on a 17³ lattice over sRGB and interpolated\n *    trilinearly in *linear* RGB: colour is linear in reflectance, so an interpolated spectrum\n *    still reproduces its colour exactly while staying smooth and inside 0..1.\n * 2. **Mixing.** Each spectrum becomes `K/S = (1 − R)² / 2R` per band. Colours mix with the\n *    two-constant form `K/S = Σ cᵢSᵢ(K/S)ᵢ / Σ cᵢSᵢ`, where `cᵢ` is the weight times the colour's\n *    tinting strength and `Sᵢ` its scattering, taken from its luminance (light paints such as\n *    titanium white scatter strongly, dark ones barely). Back to reflectance with\n *    `R = 1 + K/S − √((K/S)² + 2·K/S)`.\n * 3. **Back to sRGB.** The spectrum is weighted by the CIE 1931 2° colour-matching functions\n *    (the analytic multi-lobe fit of Wyman, Sloan & Shirley, JCGT 2013) under a 6504 K Planckian\n *    illuminant, converted to linear sRGB and normalised so a perfect white reflector is exactly\n *    white. Analytic curves keep the CIE's own (CC BY-SA) tables out of the package.\n *\n * Everything is plain TypeScript on typed arrays with no DOM: it runs in Node and Workers and is\n * deterministic. Colours are straight sRGB triples in 0..1, as in `@pixerate/editor/raster`.\n */\n\n/** An sRGB colour, each channel 0..1 (gamma-encoded, as in CSS). */\nexport type PigmentRgb = readonly [number, number, number];\n\n/** Number of spectral bands. */\nexport const PIGMENT_BANDS = 36;\n/** First band's wavelength in nm; bands are 10 nm apart (380..730 nm). */\nexport const PIGMENT_LAMBDA_MIN = 380;\nexport const PIGMENT_LAMBDA_STEP = 10;\n\n/** Band centre wavelengths in nm. */\nexport const PIGMENT_WAVELENGTHS: Float32Array = Float32Array.from({ length: PIGMENT_BANDS }, (_, i) => PIGMENT_LAMBDA_MIN + i * PIGMENT_LAMBDA_STEP);\n\nconst N = PIGMENT_BANDS;\n/** Lattice nodes per axis of the spectrum table. */\nconst LUT_NODES = 17;\n/** Reflectance floor for K/S, so a black's K/S stays finite (≈ 5000). */\nconst R_MIN = 1e-4;\n/** Scattering floor, so a black still counts in a mix. */\nconst SCATTER_MIN = 0.01;\n\n// ---------------------------------------------------------------------------\n// sRGB\n// ---------------------------------------------------------------------------\n\nfunction toLinear(v: number): number {\n  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);\n}\n\nfunction toEncoded(v: number): number {\n  if (!(v > 0)) return 0;\n  if (v >= 1) return 1;\n  return v <= 0.0031308 ? 12.92 * v : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;\n}\n\nfunction clamp01(v: number): number {\n  return v > 0 ? (v < 1 ? v : 1) : 0;\n}\n\n// ---------------------------------------------------------------------------\n// Reflectance → linear sRGB weights\n// ---------------------------------------------------------------------------\n\n/** Asymmetric Gaussian lobe of the Wyman et al. fit. */\nfunction lobe(l: number, mu: number, s1: number, s2: number): number {\n  const t = (l - mu) / (l < mu ? s1 : s2);\n  return Math.exp(-0.5 * t * t);\n}\n\n/** Relative spectral power of a black body (Planck's law; the constant factor cancels). */\nfunction planck(nm: number, kelvin: number): number {\n  const m = nm * 1e-9;\n  return 1 / (m ** 5 * (Math.exp(1.438776877e-2 / (m * kelvin)) - 1));\n}\n\nlet weights: Float64Array | null = null;\n\n/**\n * Row-major 3 × N matrix taking a reflectance spectrum to linear sRGB. Each row sums to 1, so a\n * flat reflectance `r` gives the grey `(r, r, r)`.\n */\nfunction rgbWeights(): Float64Array {\n  if (weights) return weights;\n  const w = new Float64Array(3 * N);\n  // XYZ (D65 white) → linear sRGB, IEC 61966-2-1.\n  const m = [3.2404542, -1.5371385, -0.4985314, -0.969266, 1.8760108, 0.041556, 0.0556434, -0.2040259, 1.0572252];\n  for (let b = 0; b < N; b++) {\n    const l = PIGMENT_LAMBDA_MIN + b * PIGMENT_LAMBDA_STEP;\n    const e = planck(l, 6504);\n    const x = e * (1.056 * lobe(l, 599.8, 37.9, 31.0) + 0.362 * lobe(l, 442.0, 16.0, 26.7) - 0.065 * lobe(l, 501.1, 20.4, 26.2));\n    const y = e * (0.821 * lobe(l, 568.8, 46.9, 40.5) + 0.286 * lobe(l, 530.9, 16.3, 31.1));\n    const z = e * (1.217 * lobe(l, 437.0, 11.8, 36.0) + 0.681 * lobe(l, 459.0, 26.0, 13.8));\n    for (let c = 0; c < 3; c++) w[c * N + b] = m[c * 3] * x + m[c * 3 + 1] * y + m[c * 3 + 2] * z;\n  }\n  for (let c = 0; c < 3; c++) {\n    let sum = 0;\n    for (let b = 0; b < N; b++) sum += w[c * N + b];\n    for (let b = 0; b < N; b++) w[c * N + b] /= sum;\n  }\n  return (weights = w);\n}\n\n// ---------------------------------------------------------------------------\n// Sigmoid-polynomial uplift\n// ---------------------------------------------------------------------------\n\n/**\n * Solves the sigmoid-polynomial coefficients whose spectrum has the linear sRGB colour\n * `(r, g, b)`, starting from `coeffs` (updated in place). Wavelength is normalised to 0..1 over\n * the bands. Damped Newton: a step is halved until the residual drops.\n */\nfunction fitCoefficients(r: number, g: number, b: number, coeffs: Float64Array): number {\n  const w = rgbWeights();\n  const target = [r, g, b];\n  const res = new Float64Array(3);\n  const jac = new Float64Array(9);\n  const trial = new Float64Array(3);\n  let err = residual(coeffs, target, w, res, jac);\n  for (let it = 0; it < 60 && err > 1e-10; it++) {\n    const step = solve3(jac, res);\n    if (!step) break;\n    let scale = 1;\n    let next = Infinity;\n    for (let k = 0; k < 12; k++) {\n      for (let i = 0; i < 3; i++) trial[i] = coeffs[i] - scale * step[i];\n      next = residual(trial, target, w, null, null);\n      if (next < err) break;\n      scale *= 0.5;\n    }\n    if (!(next < err)) break;\n    coeffs.set(trial);\n    err = residual(coeffs, target, w, res, jac);\n  }\n  return err;\n}\n\n/** Squared colour error of a coefficient set; fills the residual and Jacobian when asked. */\nfunction residual(c: Float64Array, target: number[], w: Float64Array, res: Float64Array | null, jac: Float64Array | null): number {\n  let r0 = -target[0];\n  let r1 = -target[1];\n  let r2 = -target[2];\n  if (jac) jac.fill(0);\n  for (let b = 0; b < N; b++) {\n    const x = b / (N - 1);\n    const z = (c[0] * x + c[1]) * x + c[2];\n    const q = 1 + z * z;\n    const sq = Math.sqrt(q);\n    const s = 0.5 + z / (2 * sq);\n    r0 += w[b] * s;\n    r1 += w[N + b] * s;\n    r2 += w[2 * N + b] * s;\n    if (jac) {\n      const ds = 1 / (2 * q * sq);\n      for (let k = 0; k < 3; k++) {\n        const wd = w[k * N + b] * ds;\n        jac[k * 3] += wd * x * x;\n        jac[k * 3 + 1] += wd * x;\n        jac[k * 3 + 2] += wd;\n      }\n    }\n  }\n  if (res) {\n    res[0] = r0;\n    res[1] = r1;\n    res[2] = r2;\n  }\n  return r0 * r0 + r1 * r1 + r2 * r2;\n}\n\n/** Solves the 3 × 3 system `a·x = v` (Cramer's rule), or null when singular. */\nfunction solve3(a: Float64Array, v: Float64Array): number[] | null {\n  const [a0, a1, a2, a3, a4, a5, a6, a7, a8] = a;\n  const c0 = a4 * a8 - a5 * a7;\n  const c1 = a5 * a6 - a3 * a8;\n  const c2 = a3 * a7 - a4 * a6;\n  const det = a0 * c0 + a1 * c1 + a2 * c2;\n  if (!(Math.abs(det) > 1e-300)) return null;\n  const [v0, v1, v2] = v;\n  return [\n    (v0 * c0 + a1 * (a5 * v2 - v1 * a8) + a2 * (v1 * a7 - a4 * v2)) / det,\n    (a0 * (v1 * a8 - a5 * v2) + v0 * c1 + a2 * (a3 * v2 - v1 * a6)) / det,\n    (a0 * (a4 * v2 - v1 * a7) + a1 * (v1 * a6 - a3 * v2) + v0 * c2) / det,\n  ];\n}\n\nconst candidate = new Float64Array(3);\n\n/**\n * Fits a lattice node, starting from `coeffs` (its neighbour's solution). Where that stalls, as it\n * can next to very saturated or very dark nodes, it also tries a flat grey start and a dimming\n * continuation (solve the colour brighter, then dim it in small steps, each starting from the last,\n * as Jakob & Hanika do along their brightness axis), and keeps the closest fit.\n */\nfunction fitNode(r: number, g: number, b: number, coeffs: Float64Array): void {\n  let best = fitCoefficients(r, g, b, coeffs);\n  if (best <= 1e-12) return;\n  candidate.fill(0);\n  let err = fitCoefficients(r, g, b, candidate);\n  if (err < best) {\n    best = err;\n    coeffs.set(candidate);\n  }\n  if (best <= 1e-12) return;\n  const max = Math.max(r, g, b);\n  if (!(max > 0) || max >= 0.5) return;\n  candidate.fill(0);\n  const steps = 32;\n  for (let i = 0; i <= steps; i++) {\n    const scale = (0.5 * Math.pow(max / 0.5, i / steps)) / max;\n    err = fitCoefficients(r * scale, g * scale, b * scale, candidate);\n  }\n  if (err < best) coeffs.set(candidate);\n}\n\nfunction sigmoidSpectrum(c: Float64Array, out: Float32Array, offset: number): void {\n  for (let b = 0; b < N; b++) {\n    const x = b / (N - 1);\n    const z = (c[0] * x + c[1]) * x + c[2];\n    out[offset + b] = 0.5 + z / (2 * Math.sqrt(1 + z * z));\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Spectrum table\n// ---------------------------------------------------------------------------\n\n/** Linear value of each lattice node: evenly spaced in encoded sRGB, so darks get more nodes. */\nconst NODES: Float64Array = Float64Array.from({ length: LUT_NODES }, (_, i) => toLinear(i / (LUT_NODES - 1)));\nlet table: Float32Array | null = null;\n\n/**\n * The spectrum of every lattice node, `[(r·n + g)·n + b]·N`, solved on first use (a few tens of\n * milliseconds). Each node starts from its neighbour's solution, so Newton converges in a few\n * steps.\n */\nfunction spectrumTable(): Float32Array {\n  if (table) return table;\n  const n = LUT_NODES;\n  const t = new Float32Array(n * n * n * N);\n  const row = new Float64Array(3);\n  const coeffs = new Float64Array(3);\n  for (let r = 0; r < n; r++) {\n    for (let g = 0; g < n; g++) {\n      // Warm start each row from the first node of the previous row.\n      coeffs.set(row);\n      for (let b = 0; b < n; b++) {\n        fitNode(NODES[r], NODES[g], NODES[b], coeffs);\n        if (b === 0) row.set(coeffs);\n        sigmoidSpectrum(coeffs, t, ((r * n + g) * n + b) * N);\n      }\n    }\n  }\n  return (table = t);\n}\n\n/** Lattice cell, fraction and linear value per channel from the last `locate` calls. */\nconst cell = new Int32Array(3);\nconst frac = new Float64Array(3);\nconst linear = new Float64Array(3);\n\n/** Finds an encoded channel's lattice cell; the fraction is linear in linear RGB. */\nfunction locate(channel: number, encoded: number): void {\n  const v = clamp01(encoded);\n  const i = Math.min(LUT_NODES - 2, Math.floor(v * (LUT_NODES - 1)));\n  const lo = NODES[i];\n  const lin = toLinear(v);\n  const f = (lin - lo) / (NODES[i + 1] - lo);\n  cell[channel] = i;\n  frac[channel] = f < 0 ? 0 : f > 1 ? 1 : f;\n  linear[channel] = lin;\n}\n\n/**\n * The smooth reflectance spectrum (0..1 per band, `PIGMENT_BANDS` bands from 380 nm in 10 nm\n * steps) of an sRGB colour. `reflectanceToRgb` of the result gives the colour back.\n */\nexport function rgbToReflectance(r: number, g: number, b: number, out: Float32Array = new Float32Array(N)): Float32Array {\n  const t = spectrumTable();\n  const n = LUT_NODES;\n  locate(0, r);\n  locate(1, g);\n  locate(2, b);\n  const [ri, gi, bi] = cell;\n  const [rf, gf, bf] = frac;\n  out.fill(0);\n  for (let corner = 0; corner < 8; corner++) {\n    const dr = corner >> 2;\n    const dg = (corner >> 1) & 1;\n    const db = corner & 1;\n    const weight = (dr ? rf : 1 - rf) * (dg ? gf : 1 - gf) * (db ? bf : 1 - bf);\n    if (weight === 0) continue;\n    const base = (((ri + dr) * n + gi + dg) * n + bi + db) * N;\n    for (let k = 0; k < N; k++) out[k] += weight * t[base + k];\n  }\n  return out;\n}\n\n/** The sRGB colour (0..1, clipped to the gamut) of a reflectance spectrum. */\nexport function reflectanceToRgb(reflectance: ArrayLike<number>, out: number[] = [0, 0, 0]): number[] {\n  const w = rgbWeights();\n  let r = 0;\n  let g = 0;\n  let b = 0;\n  for (let k = 0; k < N; k++) {\n    const v = reflectance[k];\n    r += w[k] * v;\n    g += w[N + k] * v;\n    b += w[2 * N + k] * v;\n  }\n  out[0] = toEncoded(r);\n  out[1] = toEncoded(g);\n  out[2] = toEncoded(b);\n  return out;\n}\n\n// ---------------------------------------------------------------------------\n// Pigments and mixing\n// ---------------------------------------------------------------------------\n\n/**\n * A colour prepared for mixing: its K/S spectrum and its weight in a mix. Make one per brush or\n * palette colour with `createPigment` and reuse it (`setPigmentColor`) on hot paths.\n */\nexport interface Pigment {\n  /** The sRGB colour it was made from (0..1). */\n  readonly rgb: [number, number, number];\n  /** Tinting strength (default 1): how strongly it colours a mix, relative to its weight. */\n  strength: number;\n  /** K/S per band. */\n  readonly ks: Float32Array;\n  /** Scattering from the colour's luminance (floored), before strength. */\n  scatter: number;\n}\n\nexport interface PigmentOptions {\n  /**\n   * Tinting strength, > 0 (default 1). A strength of 4 counts each part as four, so a little of\n   * a strong dark pigment tints a lot of white. A colour mixed only with itself is unchanged\n   * whatever its strength.\n   */\n  strength?: number;\n}\n\nconst spectrumScratch = new Float32Array(N);\n\n/** Prepares a colour for mixing. */\nexport function createPigment(color: PigmentRgb, options: PigmentOptions = {}): Pigment {\n  const pigment: Pigment = { rgb: [0, 0, 0], strength: 1, ks: new Float32Array(N), scatter: 1 };\n  return setPigmentColor(pigment, color[0], color[1], color[2], options.strength);\n}\n\n/** Re-targets a pigment to another colour without allocating (the per-pixel fast path). */\nexport function setPigmentColor(pigment: Pigment, r: number, g: number, b: number, strength = pigment.strength): Pigment {\n  const R = rgbToReflectance(r, g, b, spectrumScratch);\n  const ks = pigment.ks;\n  for (let k = 0; k < N; k++) {\n    const v = R[k] > R_MIN ? R[k] : R_MIN;\n    ks[k] = ((1 - v) * (1 - v)) / (2 * v);\n  }\n  pigment.rgb[0] = clamp01(r);\n  pigment.rgb[1] = clamp01(g);\n  pigment.rgb[2] = clamp01(b);\n  pigment.strength = Number.isFinite(strength) && strength > 0 ? strength : 1;\n  // `rgbToReflectance` left each channel's linear value in `linear`.\n  const y = 0.2126 * linear[0] + 0.7152 * linear[1] + 0.0722 * linear[2];\n  pigment.scatter = y > SCATTER_MIN ? y : SCATTER_MIN;\n  return pigment;\n}\n\n/** Mixed K/S → reflectance → sRGB, written to `out[offset..offset + 2]`. */\nfunction ksToRgb(ks: Float32Array | Float64Array, out: { [i: number]: number }, offset: number): void {\n  const w = rgbWeights();\n  let r = 0;\n  let g = 0;\n  let b = 0;\n  for (let k = 0; k < N; k++) {\n    const q = ks[k];\n    const v = 1 + q - Math.sqrt(q * q + 2 * q);\n    r += w[k] * v;\n    g += w[N + k] * v;\n    b += w[2 * N + k] * v;\n  }\n  out[offset] = toEncoded(r);\n  out[offset + 1] = toEncoded(g);\n  out[offset + 2] = toEncoded(b);\n}\n\nconst mixScratch = new Float64Array(N);\n\n/**\n * Mixes colours like paint. `weights` are parts by amount (any non-negative scale; at least one\n * positive). Colours may be sRGB triples (0..1) or prepared pigments (which carry a tinting\n * strength). Returns the mixed sRGB colour (0..1).\n */\nexport function mixPigments(colors: readonly (PigmentRgb | Pigment)[], weights: readonly number[]): [number, number, number] {\n  if (colors.length === 0) throw new Error('mixPigments needs at least one colour.');\n  if (weights.length !== colors.length) throw new Error(`mixPigments got ${colors.length} colours but ${weights.length} weights; pass one weight per colour.`);\n  const pigments = colors.map((c) => ('ks' in c ? c : createPigment(c)));\n  let total = 0;\n  for (let i = 0; i < pigments.length; i++) {\n    const w = weights[i];\n    if (!(Number.isFinite(w) && w >= 0)) throw new Error(`Weight ${i} is ${w}; weights must be finite and ≥ 0.`);\n    total += w * pigments[i].strength * pigments[i].scatter;\n  }\n  if (!(total > 0)) throw new Error('mixPigments needs at least one positive weight.');\n  mixScratch.fill(0);\n  for (let i = 0; i < pigments.length; i++) {\n    const p = pigments[i];\n    const c = (weights[i] * p.strength * p.scatter) / total;\n    if (c === 0) continue;\n    for (let k = 0; k < N; k++) mixScratch[k] += c * p.ks[k];\n  }\n  const out: [number, number, number] = [0, 0, 0];\n  ksToRgb(mixScratch, out, 0);\n  return out;\n}\n\n/** Mixes `a` towards `b` like paint: `t = 0` is `a`, `t = 1` is `b`. */\nexport function lerpPigment(a: PigmentRgb | Pigment, b: PigmentRgb | Pigment, t: number): [number, number, number] {\n  const u = clamp01(t);\n  return mixPigments([a, b], [1 - u, u]);\n}\n\n/**\n * The per-dab fast path: mixes two prepared pigments (`t` of `b` into `a`) and writes the sRGB\n * result to `out[offset..offset + 2]`, without allocating. Pair it with `setPigmentColor` for the\n * colour under the brush.\n */\nexport function lerpPigmentInto(a: Pigment, b: Pigment, t: number, out: { [i: number]: number }, offset = 0): void {\n  const u = t > 0 ? (t < 1 ? t : 1) : 0;\n  const wa = (1 - u) * a.strength * a.scatter;\n  const wb = u * b.strength * b.scatter;\n  const ca = wa / (wa + wb);\n  const cb = 1 - ca;\n  const ka = a.ks;\n  const kb = b.ks;\n  for (let k = 0; k < N; k++) mixScratch[k] = ca * ka[k] + cb * kb[k];\n  ksToRgb(mixScratch, out, offset);\n}\n","// Portions ported from photocraft-main/crates/color/src/blend.rs (MIT OR Apache-2.0, © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.\n\n/**\n * Photoshop blend modes on straight (non-premultiplied) 0..1 colours.\n *\n * Formulas follow the W3C Compositing / ISO 32000 definitions, with Photoshop's variants where\n * they differ (Soft Light, Vivid / Linear / Pin Light, Hard Mix, Linear Burn / Dodge, Subtract,\n * Divide, Darker / Lighter Color), and the hardened `ClipColor` for the non-separable modes.\n *\n * Plus `pigment`, which is not a `B(Cb, Cs)` mode: it replaces the alpha interpolation\n * `(1 − α)·Cb + α·B` with a Kubelka-Munk paint mix of the two colours (see `lerpPigment`).\n *\n * Plus four painterly modes of our own design, which are ordinary `B(Cb, Cs)` modes, so every\n * caller of `blendRgb` / `blendChannel` (the compositor, adjustment layers, effects, brushes) gets\n * them for free: `watercolor` (transparent washes, multiplied per wavelength), `tint` (the source's\n * colour on the backdrop's lightness, gently at the extremes), `highlight` (light added with a\n * soft shoulder) and `shadow` (light taken away, with ambient fill). See `painterlyRgb`.\n */\n\nimport { createPigment, lerpPigmentInto, reflectanceToRgb, rgbToReflectance, setPigmentColor, type Pigment } from './pigment';\n\nexport type BlendMode =\n  | 'normal'\n  | 'darken'\n  | 'multiply'\n  | 'color-burn'\n  | 'linear-burn'\n  | 'darker-color'\n  | 'lighten'\n  | 'screen'\n  | 'color-dodge'\n  | 'linear-dodge'\n  | 'lighter-color'\n  | 'overlay'\n  | 'soft-light'\n  | 'hard-light'\n  | 'vivid-light'\n  | 'linear-light'\n  | 'pin-light'\n  | 'hard-mix'\n  | 'difference'\n  | 'exclusion'\n  | 'subtract'\n  | 'divide'\n  | 'hue'\n  | 'saturation'\n  | 'color'\n  | 'luminosity'\n  | 'pigment'\n  | 'watercolor'\n  | 'tint'\n  | 'highlight'\n  | 'shadow';\n\nexport interface BlendModeInfo {\n  id: BlendMode;\n  label: string;\n  /** Canvas `globalCompositeOperation` with the same maths, when there is one. */\n  canvas: GlobalCompositeOperation | null;\n  /** True for the painterly modes (`watercolor`, `tint`, `highlight`, `shadow`), which no other app has. */\n  painterly?: boolean;\n  /** The nearest standard (Photoshop) mode, for formats that lack this one (PSD). Missing: it is standard. */\n  standard?: BlendMode;\n  /** One sentence on what the mode does (painterly and pigment modes). */\n  description?: string;\n}\n\n/** Every blend mode, in Photoshop's menu order. */\nexport const BLEND_MODES: readonly BlendModeInfo[] = [\n  { id: 'normal', label: 'Normal', canvas: 'source-over' },\n  { id: 'darken', label: 'Darken', canvas: 'darken' },\n  { id: 'multiply', label: 'Multiply', canvas: 'multiply' },\n  { id: 'color-burn', label: 'Color Burn', canvas: 'color-burn' },\n  { id: 'linear-burn', label: 'Linear Burn', canvas: null },\n  { id: 'darker-color', label: 'Darker Color', canvas: null },\n  { id: 'lighten', label: 'Lighten', canvas: 'lighten' },\n  { id: 'screen', label: 'Screen', canvas: 'screen' },\n  { id: 'color-dodge', label: 'Color Dodge', canvas: 'color-dodge' },\n  { id: 'linear-dodge', label: 'Linear Dodge (Add)', canvas: null },\n  { id: 'lighter-color', label: 'Lighter Color', canvas: null },\n  { id: 'overlay', label: 'Overlay', canvas: 'overlay' },\n  // Canvas soft-light is the W3C formula, not Photoshop's: use the scalar path.\n  { id: 'soft-light', label: 'Soft Light', canvas: null },\n  { id: 'hard-light', label: 'Hard Light', canvas: 'hard-light' },\n  { id: 'vivid-light', label: 'Vivid Light', canvas: null },\n  { id: 'linear-light', label: 'Linear Light', canvas: null },\n  { id: 'pin-light', label: 'Pin Light', canvas: null },\n  { id: 'hard-mix', label: 'Hard Mix', canvas: null },\n  { id: 'difference', label: 'Difference', canvas: 'difference' },\n  { id: 'exclusion', label: 'Exclusion', canvas: 'exclusion' },\n  { id: 'subtract', label: 'Subtract', canvas: null },\n  { id: 'divide', label: 'Divide', canvas: null },\n  { id: 'hue', label: 'Hue', canvas: 'hue' },\n  { id: 'saturation', label: 'Saturation', canvas: 'saturation' },\n  { id: 'color', label: 'Color', canvas: 'color' },\n  { id: 'luminosity', label: 'Luminosity', canvas: 'luminosity' },\n  // Not in Photoshop: mixes like paint (blue + yellow = green). No canvas or PSD equivalent.\n  {\n    id: 'pigment',\n    label: 'Pigment',\n    canvas: null,\n    standard: 'normal',\n    description: 'Mixes the layer into what is below like paint, by its opacity: blue and yellow make green.',\n  },\n  // Painterly modes (ours; see `painterlyRgb`). No canvas equivalent; PSD gets `standard`.\n  {\n    id: 'watercolor',\n    label: 'Watercolor',\n    canvas: null,\n    painterly: true,\n    standard: 'multiply',\n    description: 'A transparent wash: the colours filter each other wavelength by wavelength, so layers darken like glazes and blue over yellow gives green. White is clear.',\n  },\n  {\n    id: 'tint',\n    label: 'Tint',\n    canvas: null,\n    painterly: true,\n    standard: 'color',\n    description: \"Tints what is below with the layer's colour and keeps its lightness; mid-tones take the full tint, highlights and darks stay clean.\",\n  },\n  {\n    id: 'highlight',\n    label: 'Highlight',\n    canvas: null,\n    painterly: true,\n    standard: 'screen',\n    description: 'Adds the layer as coloured light that rolls off softly towards white instead of clipping. Black adds nothing.',\n  },\n  {\n    id: 'shadow',\n    label: 'Shadow',\n    canvas: null,\n    painterly: true,\n    standard: 'multiply',\n    description: \"Shades what is below as if the layer blocked the light, coloured by the layer, with ambient light so it never crushes to black. White does nothing.\",\n  },\n];\n\nconst BLEND_INFO = new Map<string, BlendModeInfo>(BLEND_MODES.map((m) => [m.id, m]));\n\nexport function isBlendMode(value: unknown): value is BlendMode {\n  return typeof value === 'string' && BLEND_INFO.has(value);\n}\n\n/** The painterly modes, in menu order. */\nexport const PAINTERLY_BLEND_MODES: readonly BlendMode[] = BLEND_MODES.filter((m) => m.painterly).map((m) => m.id);\n\n/** Whether a mode is one of the painterly modes (`watercolor`, `tint`, `highlight`, `shadow`). */\nexport function isPainterlyBlendMode(mode: unknown): boolean {\n  return typeof mode === 'string' && Boolean(BLEND_INFO.get(mode)?.painterly);\n}\n\n/**\n * The nearest standard (Photoshop) mode: the mode itself when it is standard, `normal` for\n * `pigment`, and each painterly mode's closest relative (watercolour and shadow → multiply,\n * tint → color, highlight → screen). For writing formats that lack our modes, such as PSD.\n */\nexport function standardBlendMode(mode: BlendMode): BlendMode {\n  return BLEND_INFO.get(mode)?.standard ?? mode;\n}\n\n/** A stored blend mode, or `normal` for a missing / unknown value. */\nexport function normalizeBlendMode(value: unknown): BlendMode {\n  return isBlendMode(value) ? value : 'normal';\n}\n\n/**\n * The canvas composite operation that implements `mode` exactly, or `null` when the canvas has\n * none (draw through {@link blendImageData} instead).\n */\nexport function canvasCompositeOperation(mode: BlendMode | undefined): GlobalCompositeOperation | null {\n  return BLEND_INFO.get(mode ?? 'normal')?.canvas ?? null;\n}\n\n/**\n * Whether a mode works channel by channel. The non-separable ones work on whole colours (hue,\n * saturation, colour, luminosity, darker / lighter colour, pigment).\n */\nexport function isSeparableBlendMode(mode: BlendMode): boolean {\n  return !(\n    mode === 'pigment' ||\n    mode === 'watercolor' ||\n    mode === 'tint' ||\n    mode === 'hue' ||\n    mode === 'saturation' ||\n    mode === 'color' ||\n    mode === 'luminosity' ||\n    mode === 'darker-color' ||\n    mode === 'lighter-color'\n  );\n}\n\nfunction colorBurn(cb: number, cs: number): number {\n  if (cb >= 1) return 1;\n  if (cs <= 0) return 0;\n  return 1 - Math.min(1, (1 - cb) / cs);\n}\n\nfunction colorDodge(cb: number, cs: number): number {\n  if (cb <= 0) return 0;\n  if (cs >= 1) return 1;\n  return Math.min(1, cb / (1 - cs));\n}\n\nfunction hardLight(cb: number, cs: number): number {\n  if (cs <= 0.5) return cb * 2 * cs;\n  const s = 2 * cs - 1;\n  return cb + s - cb * s;\n}\n\n/** Photoshop's Soft Light (differs from W3C in the upper half). */\nfunction softLight(cb: number, cs: number): number {\n  return cs <= 0.5\n    ? 2 * cb * cs + cb * cb * (1 - 2 * cs)\n    : 2 * cb * (1 - cs) + Math.sqrt(Math.max(0, cb)) * (2 * cs - 1);\n}\n\nfunction vividLightHardMix(cb: number, cs: number): number {\n  const EDGE = 1e-4;\n  if (cs <= 0.5) {\n    if (cb >= 1 - EDGE) return 1;\n    if (cs <= 0) return 0;\n    return 1 - Math.min(1, (1 - cb) / (2 * cs));\n  }\n  if (cb <= EDGE) return 0;\n  if (cs >= 1) return 1;\n  return Math.min(1, cb / (2 * (1 - cs)));\n}\n\n/** Separable blend function `B(cb, cs)` of one channel. Non-separable modes return `cs`. */\nexport function blendChannel(mode: BlendMode, cb: number, cs: number): number {\n  switch (mode) {\n    case 'normal':\n      return cs;\n    case 'darken':\n      return Math.min(cb, cs);\n    case 'multiply':\n      return cb * cs;\n    case 'color-burn':\n      return colorBurn(cb, cs);\n    case 'linear-burn':\n      return Math.max(0, cb + cs - 1);\n    case 'lighten':\n      return Math.max(cb, cs);\n    case 'screen':\n      return cb + cs - cb * cs;\n    case 'color-dodge':\n      return colorDodge(cb, cs);\n    case 'linear-dodge':\n      return Math.min(1, cb + cs);\n    case 'overlay':\n      return hardLight(cs, cb);\n    case 'soft-light':\n      return softLight(cb, cs);\n    case 'hard-light':\n      return hardLight(cb, cs);\n    case 'vivid-light':\n      if (cs <= 0) return 0;\n      if (cs >= 1) return 1;\n      return cs <= 0.5 ? colorBurn(cb, 2 * cs) : colorDodge(cb, 2 * (cs - 0.5));\n    case 'linear-light':\n      return Math.min(1, Math.max(0, cb + 2 * cs - 1));\n    case 'pin-light':\n      return cs <= 0.5 ? Math.min(cb, 2 * cs) : Math.max(cb, 2 * cs - 1);\n    case 'hard-mix':\n      return vividLightHardMix(cb, cs) >= 0.5 - 1e-6 ? 1 : 0;\n    case 'difference':\n      return Math.abs(cb - cs);\n    case 'exclusion':\n      return cb + cs - 2 * cb * cs;\n    case 'subtract':\n      return Math.max(0, cb - cs);\n    case 'divide':\n      if (cs <= 0) return cb <= 0 ? 0 : 1;\n      return Math.min(1, cb / cs);\n    case 'highlight':\n      return highlight(cb, cs);\n    case 'shadow':\n      return shadow(cb, cs);\n    default:\n      return cs;\n  }\n}\n\nexport type Rgb = [number, number, number];\nexport type Rgba = [number, number, number, number];\n\n/** Luminosity of the non-separable modes (W3C / ISO 32000 weights). */\nexport function blendLum(c: readonly number[]): number {\n  return 0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2];\n}\n\n/**\n * ClipColor, hardened: when the luminosity itself is out of range no colour of that luminosity\n * is in gamut, so the result is its grey (the spec formula turned such colours inside out and,\n * for greys, divided by rounding noise).\n */\nfunction clipColor(c: Rgb): Rgb {\n  const l = blendLum(c);\n  const n = Math.min(c[0], c[1], c[2]);\n  const x = Math.max(c[0], c[1], c[2]);\n  let out: Rgb = [c[0], c[1], c[2]];\n  if (n < 0) {\n    const d = l - n;\n    out = out.map((v) => (l > 0 && d > 0 ? l + ((v - l) * l) / d : l)) as Rgb;\n  }\n  if (x > 1) {\n    const d = x - l;\n    out = out.map((v) => (l < 1 && d > 0 ? l + ((v - l) * (1 - l)) / d : l)) as Rgb;\n  }\n  return out;\n}\n\n/** `c` with its luminosity moved to `l`, clipped back into gamut towards grey (SetLum + ClipColor). */\nexport function setLum(c: readonly number[], l: number): Rgb {\n  const d = l - blendLum(c);\n  return clipColor([c[0] + d, c[1] + d, c[2] + d]);\n}\n\nfunction sat(c: readonly number[]): number {\n  return Math.max(c[0], c[1], c[2]) - Math.min(c[0], c[1], c[2]);\n}\n\nfunction setSat(c: readonly number[], s: number): Rgb {\n  const idx = [0, 1, 2].sort((a, b) => c[a] - c[b]);\n  const [imin, imid, imax] = idx;\n  const out: Rgb = [0, 0, 0];\n  if (c[imax] > c[imin]) {\n    out[imid] = ((c[imid] - c[imin]) * s) / (c[imax] - c[imin]);\n    out[imax] = s;\n  }\n  out[imin] = 0;\n  return out;\n}\n\n/**\n * `B(Cb, Cs)` of a whole colour, including the non-separable modes. `pigment` has no `B` and\n * returns `Cs`; composite it with {@link blendPixel} or {@link mixPigmentRgb}.\n */\nexport function blendRgb(mode: BlendMode, cb: readonly number[], cs: readonly number[]): Rgb {\n  switch (mode) {\n    case 'hue':\n      return setLum(setSat(cs, sat(cb)), blendLum(cb));\n    case 'saturation':\n      return setLum(setSat(cb, sat(cs)), blendLum(cb));\n    case 'color':\n      return setLum(cs, blendLum(cb));\n    case 'luminosity':\n      return setLum(cb, blendLum(cs));\n    case 'darker-color':\n      return blendLum(cs) < blendLum(cb) ? [cs[0], cs[1], cs[2]] : [cb[0], cb[1], cb[2]];\n    case 'lighter-color':\n      return blendLum(cs) > blendLum(cb) ? [cs[0], cs[1], cs[2]] : [cb[0], cb[1], cb[2]];\n    case 'watercolor':\n      return watercolor(cb, cs);\n    case 'tint':\n      return tint(cb, cs);\n    default:\n      return [blendChannel(mode, cb[0], cs[0]), blendChannel(mode, cb[1], cs[1]), blendChannel(mode, cb[2], cs[2])];\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Painterly modes\n// ---------------------------------------------------------------------------\n//\n// Our own designs, written from how each effect should look. All four are true `B(Cb, Cs)`\n// functions (colours 0..1, gamma-encoded), so the W3C general formula composites them like any\n// other mode, opacity and alpha included. Light is added or removed in *linear* light, where it\n// adds up physically; `lin` / `enc` are the sRGB transfer functions.\n//\n// - watercolor: R(λ) = Rb(λ)·Rs(λ) over the pigment model's reflectance spectra (non-separable).\n// - tint:       Oklab: L = Lb, ab = ab_s·√(4·Lb·(1 − Lb)), chroma cut to the gamut.\n// - highlight:  per channel, x = lb + (1 − lb)·(1 − e^(−ls / (1 − lb))) (separable).\n// - shadow:     per channel, x = lb·(A + (1 − A)·ls), with ambient A = 0.2 (separable).\n\nconst clamp01 = (v: number): number => (v > 0 ? (v < 1 ? v : 1) : 0);\n\nfunction lin(v: number): number {\n  const c = clamp01(v);\n  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);\n}\n\nfunction enc(v: number): number {\n  if (!(v > 0)) return 0;\n  if (v >= 1) return 1;\n  return v <= 0.0031308 ? 12.92 * v : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;\n}\n\n/**\n * Highlight: the source is coloured light added to the backdrop in linear light. Plain addition\n * (linear dodge) clips to flat white; here the added light `ls` fills the headroom `1 − lb`\n * exponentially, `x = lb + (1 − lb)·(1 − e^(−ls / (1 − lb)))`. A little light adds almost exactly\n * `ls`, a lot approaches white without ever clipping, black adds nothing, and the backdrop's\n * gradations survive inside the highlight.\n */\nfunction highlight(cb: number, cs: number): number {\n  const lb = lin(cb);\n  const ls = lin(cs);\n  if (ls <= 0) return clamp01(cb);\n  const room = 1 - lb;\n  if (room <= 1e-9) return 1;\n  return enc(lb + room * (1 - Math.exp(-ls / room)));\n}\n\n/** Shadow's ambient light: the share of light that still reaches a fully shaded area. */\nexport const SHADOW_AMBIENT = 0.2;\n\n/**\n * Shadow: the source says how much light still reaches each channel (white: all of it, black:\n * none), in linear light, plus ambient light `A` that fills every shadow:\n * `x = lb·(A + (1 − A)·ls)`. A black shadow keeps a fifth of the light, so stacked shading\n * deepens gradually and darks never crush to black; a coloured source tints the shade (a blue\n * one cools it, as painters shade). White changes nothing.\n */\nfunction shadow(cb: number, cs: number): number {\n  if (cs >= 1) return clamp01(cb);\n  return enc(lin(cb) * (SHADOW_AMBIENT + (1 - SHADOW_AMBIENT) * lin(cs)));\n}\n\n/** Reflectance spectra of 8-bit colours (key `r << 16 | g << 8 | b`), for `watercolor`. */\nconst spectrumCache = new Map<number, Float32Array>();\n/** About 2.4 MB of spectra; the cache starts over when it fills. */\nconst SPECTRUM_CACHE_MAX = 16384;\nconst washScratch = new Float32Array(64);\n\nfunction spectrum8(r: number, g: number, b: number): Float32Array {\n  const key = (r << 16) | (g << 8) | b;\n  let s = spectrumCache.get(key);\n  if (!s) {\n    if (spectrumCache.size >= SPECTRUM_CACHE_MAX) spectrumCache.clear();\n    s = rgbToReflectance(r / 255, g / 255, b / 255);\n    spectrumCache.set(key, s);\n  }\n  return s;\n}\n\n/**\n * Watercolor: the source is a transparent wash over the backdrop. A wash absorbs light by\n * wavelength and the paper (or paint) under it reflects what passes, so the reflectances multiply\n * band by band, `R(λ) = Rb(λ)·Rs(λ)` (Beer–Lambert through the wash), using each colour's smooth\n * reflectance spectrum from the pigment model, then back to sRGB. Multiply in RGB treats the three\n * channels as the only wavelengths, so a blue glaze over yellow goes black; spectra overlap in\n * the greens, so here it gives the deep green a real glaze does. White is clear (exactly: it\n * returns the backdrop) and each wash darkens a little more, as glazes do. Colours are quantised\n * to 8 bits and their spectra cached.\n */\nfunction watercolor(cb: readonly number[], cs: readonly number[]): Rgb {\n  const q = (v: number) => Math.round(clamp01(v) * 255);\n  const b0 = q(cb[0]), b1 = q(cb[1]), b2 = q(cb[2]);\n  const s0 = q(cs[0]), s1 = q(cs[1]), s2 = q(cs[2]);\n  if (s0 === 255 && s1 === 255 && s2 === 255) return [clamp01(cb[0]), clamp01(cb[1]), clamp01(cb[2])];\n  if (b0 === 255 && b1 === 255 && b2 === 255) return [clamp01(cs[0]), clamp01(cs[1]), clamp01(cs[2])];\n  if ((b0 | b1 | b2) === 0 || (s0 | s1 | s2) === 0) return [0, 0, 0];\n  const rb = spectrum8(b0, b1, b2);\n  const rs = spectrum8(s0, s1, s2);\n  const n = rb.length;\n  for (let k = 0; k < n; k++) washScratch[k] = rb[k] * rs[k];\n  const out = reflectanceToRgb(washScratch.subarray(0, n), [0, 0, 0]);\n  return [out[0], out[1], out[2]];\n}\n\n/** Linear sRGB → Oklab (Björn Ottosson, 2020), written to `out`. */\nfunction toOklab(r: number, g: number, b: number, out: number[]): void {\n  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);\n  const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);\n  const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);\n  out[0] = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s;\n  out[1] = 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s;\n  out[2] = 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s;\n}\n\n/** Oklab → linear sRGB (unclipped), written to `out`. */\nfunction fromOklab(L: number, a: number, b: number, out: number[]): void {\n  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;\n  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;\n  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;\n  out[0] = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  out[1] = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  out[2] = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n}\n\nconst labB = [0, 0, 0];\nconst labS = [0, 0, 0];\nconst rgbScratch = [0, 0, 0];\n\nconst inGamut = (c: number[]) => c[0] >= -1e-6 && c[0] <= 1 + 1e-6 && c[1] >= -1e-6 && c[1] <= 1 + 1e-6 && c[2] >= -1e-6 && c[2] <= 1 + 1e-6;\n\n/**\n * Tint: the backdrop takes the source's colour and keeps its own lightness, in Oklab (a\n * perceptual space, so the lightness really stays put, unlike `color`'s RGB-weighted luminosity):\n * `L = Lb` and `ab = ab_s·w` with `w = √(4·Lb·(1 − Lb))`. Mid-tones take the source's full\n * colour; towards white and black less of it, so a tint over a drawing leaves the paper white\n * and the blacks black. The backdrop's own hue is replaced, not averaged (averaging opposite hues\n * would grey them). Out-of-gamut results lose chroma (bisection at constant L and hue), not\n * lightness. A grey source neutralises.\n */\nfunction tint(cb: readonly number[], cs: readonly number[]): Rgb {\n  toOklab(lin(cb[0]), lin(cb[1]), lin(cb[2]), labB);\n  toOklab(lin(cs[0]), lin(cs[1]), lin(cs[2]), labS);\n  const L = labB[0];\n  const w = Math.sqrt(Math.min(1, Math.max(0, 4 * L * (1 - L))));\n  const a = labS[1] * w;\n  const b = labS[2] * w;\n  fromOklab(L, a, b, rgbScratch);\n  if (!inGamut(rgbScratch)) {\n    let lo = 0;\n    let hi = 1;\n    for (let i = 0; i < 14; i++) {\n      const mid = (lo + hi) / 2;\n      fromOklab(L, a * mid, b * mid, rgbScratch);\n      if (inGamut(rgbScratch)) lo = mid;\n      else hi = mid;\n    }\n    fromOklab(L, a * lo, b * lo, rgbScratch);\n  }\n  return [enc(rgbScratch[0]), enc(rgbScratch[1]), enc(rgbScratch[2])];\n}\n\n// ---------------------------------------------------------------------------\n// Pigment\n// ---------------------------------------------------------------------------\n\n/** Scratch pigments, made on first use (building one solves the spectrum table). */\nlet scratch: [Pigment, Pigment] | null = null;\n\n/**\n * The `pigment` mode's colour: `t` of `cs` mixed into `cb` like paint (`lerpPigment`), written to\n * `out[0..2]`. `t ≥ 1` (or equal colours) is `cs` exactly. Colours are 0..1.\n */\nexport function mixPigmentRgb(cb: readonly number[], cs: readonly number[], t: number, out: number[] = [0, 0, 0]): number[] {\n  if (t >= 1 || (cb[0] === cs[0] && cb[1] === cs[1] && cb[2] === cs[2])) {\n    out[0] = cs[0];\n    out[1] = cs[1];\n    out[2] = cs[2];\n    return out;\n  }\n  if (!(t > 0)) {\n    out[0] = cb[0];\n    out[1] = cb[1];\n    out[2] = cb[2];\n    return out;\n  }\n  scratch ??= [createPigment([0, 0, 0]), createPigment([0, 0, 0])];\n  const [a, b] = scratch;\n  setPigmentColor(a, cb[0], cb[1], cb[2], 1);\n  setPigmentColor(b, cs[0], cs[1], cs[2], 1);\n  lerpPigmentInto(a, b, t, out, 0);\n  return out;\n}\n\n/** K/S of 8-bit colours (key `r << 16 | g << 8 | b`), shared by every 8-bit pigment composite. */\nconst pigmentCache = new Map<number, Pigment>();\n/** About 3 MB of spectra; the cache starts over when it fills (a photo can hold millions of colours). */\nconst PIGMENT_CACHE_MAX = 16384;\n\n/**\n * The prepared pigment (K/S spectrum) of an 8-bit colour, from the cache every 8-bit pigment\n * composite shares. Read-only: do not retarget it with `setPigmentColor`.\n */\nexport function pigment8(r: number, g: number, b: number): Pigment {\n  return cachedPigment(r, g, b);\n}\n\nfunction cachedPigment(r: number, g: number, b: number): Pigment {\n  const key = (r << 16) | (g << 8) | b;\n  let p = pigmentCache.get(key);\n  if (!p) {\n    if (pigmentCache.size >= PIGMENT_CACHE_MAX) pigmentCache.clear();\n    p = createPigment([r / 255, g / 255, b / 255]);\n    pigmentCache.set(key, p);\n  }\n  return p;\n}\n\n/**\n * {@link mixPigmentRgb} on 8-bit channels, with each colour's spectrum cached: writes the 0..1\n * result to `out[0..2]`. The compositor's and {@link blendImageData}'s per-pixel path.\n */\nexport function mixPigment8(b0: number, b1: number, b2: number, s0: number, s1: number, s2: number, t: number, out: number[]): void {\n  if (t >= 1 || (b0 === s0 && b1 === s1 && b2 === s2)) {\n    out[0] = s0 / 255;\n    out[1] = s1 / 255;\n    out[2] = s2 / 255;\n    return;\n  }\n  lerpPigmentInto(cachedPigment(b0, b1, b2), cachedPigment(s0, s1, s2), t, out, 0);\n}\n\n/**\n * Composites a straight-alpha `source` over a straight-alpha `backdrop` (both RGBA in 0..1) with a\n * blend mode and an extra `alpha` (opacity), using the W3C general formula:\n * `αo = αs + αb(1 − αs)`, `αo·Co = (1 − αs)·αb·Cb + (1 − αb)·αs·Cs + αs·αb·B(Cb, Cs)`.\n *\n * `pigment` mixes the colours like paint instead, by amount: `Co = lerpPigment(Cb, Cs, αs / αo)`\n * (over an opaque backdrop that is `lerpPigment(Cb, Cs, αs)`), with the same `αo`.\n */\nexport function blendPixel(mode: BlendMode, backdrop: readonly number[], source: readonly number[], alpha = 1): Rgba {\n  const ab = backdrop[3] ?? 1;\n  const as = (source[3] ?? 1) * alpha;\n  if (!(as > 0)) return [backdrop[0], backdrop[1], backdrop[2], ab];\n  const ao = as + ab * (1 - as);\n  if (ao <= 0) return [0, 0, 0, 0];\n  const out: Rgba = [0, 0, 0, ao];\n  if (mode === 'pigment') {\n    mixPigmentRgb(backdrop, source, as / ao, out);\n    return out;\n  }\n  const b = blendRgb(mode, backdrop, source);\n  for (let i = 0; i < 3; i++) {\n    out[i] = ((1 - as) * ab * backdrop[i] + (1 - ab) * as * source[i] + as * ab * b[i]) / ao;\n  }\n  return out;\n}\n\n/**\n * Blends `source` into `backdrop` in place (8-bit straight RGBA of the same size) with\n * {@link blendPixel}. The scalar fallback for modes the canvas cannot composite.\n */\nexport function blendImageData(backdrop: ImageData, source: ImageData, mode: BlendMode, alpha = 1): void {\n  const d = backdrop.data;\n  const s = source.data;\n  const len = Math.min(d.length, s.length);\n  const cb = [0, 0, 0, 0];\n  const cs = [0, 0, 0, 0];\n  const pigment = mode === 'pigment';\n  for (let i = 0; i < len; i += 4) {\n    if (s[i + 3] === 0) continue;\n    if (pigment) {\n      const as = (s[i + 3] / 255) * alpha;\n      if (!(as > 0)) continue;\n      const ao = as + (d[i + 3] / 255) * (1 - as);\n      mixPigment8(d[i], d[i + 1], d[i + 2], s[i], s[i + 1], s[i + 2], as / ao, cb);\n      d[i] = Math.round(cb[0] * 255);\n      d[i + 1] = Math.round(cb[1] * 255);\n      d[i + 2] = Math.round(cb[2] * 255);\n      d[i + 3] = Math.round(ao * 255);\n      continue;\n    }\n    for (let k = 0; k < 4; k++) {\n      cb[k] = d[i + k] / 255;\n      cs[k] = s[i + k] / 255;\n    }\n    const o = blendPixel(mode, cb, cs, alpha);\n    d[i] = Math.round(o[0] * 255);\n    d[i + 1] = Math.round(o[1] * 255);\n    d[i + 2] = Math.round(o[2] * 255);\n    d[i + 3] = Math.round(o[3] * 255);\n  }\n}\n"]}