@pixerate/editor 0.117.0 → 0.119.0

package/dist/{chunk-JHXMNOMF.js → chunk-YHW26LS2.js}

@@ -6,8 +6,9 @@ import {
   applyStrokeToTile,
   dabRect,
   normalizeBrush,
+  put255,
   rasterizeDab
-} from "./chunk-IVSNUXW7.js";
+} from "./chunk-T7IZDNSL.js";
 import {
   TILE,
   TiledSurface,
@@ -447,7 +448,7 @@ function readSourceRegion(source, rect, dx = 0, dy = 0) {
   return out;
 }
 function applyRetouchToTile(coverage, tileData, channels, tx, ty, paint, s, options = {}) {
-  const out = options.into ? new Uint8ClampedArray(options.into) : new Uint8ClampedArray(tileData);
+  const out = (options.into ?? tileData).slice();
   const ox = tx * TILE + s.offset.x;
   const oy = ty * TILE + s.offset.y;
   let x0 = 0;
@@ -522,9 +523,9 @@ function applyRetouchToTile(coverage, tileData, channels, tx, ty, paint, s, opti
         const g0 = rgb[1];
         const b0 = rgb[2];
         paint.tone(rgb);
-        out[i] = Math.round((r0 + (rgb[0] - r0) * k) * 255);
-        out[i + 1] = Math.round((g0 + (rgb[1] - g0) * k) * 255);
-        out[i + 2] = Math.round((b0 + (rgb[2] - b0) * k) * 255);
+        put255(out, i, r0 + (rgb[0] - r0) * k);
+        put255(out, i + 1, g0 + (rgb[1] - g0) * k);
+        put255(out, i + 2, b0 + (rgb[2] - b0) * k);
         continue;
       }
       if (s.lockTransparency && a === 0) continue;
@@ -539,10 +540,10 @@ function applyRetouchToTile(coverage, tileData, channels, tx, ty, paint, s, opti
         cs[ch] = src[ch] / 255;
       }
       const o = blendPixel(blend, cb, cs, k);
-      out[i] = Math.round(o[0] * 255);
-      out[i + 1] = Math.round(o[1] * 255);
-      out[i + 2] = Math.round(o[2] * 255);
-      if (!s.lockTransparency) out[i + 3] = Math.round(o[3] * 255);
+      put255(out, i, o[0]);
+      put255(out, i + 1, o[1]);
+      put255(out, i + 2, o[2]);
+      if (!s.lockTransparency) put255(out, i + 3, o[3]);
     }
   }
   return out;
@@ -760,9 +761,9 @@ function spongeEffect(brush, saturate, vibrance) {
         rgb[1] = px[i + 1] / 255;
         rgb[2] = px[i + 2] / 255;
         sponge(rgb, k, saturate, vibrance);
-        px[i] = Math.round(rgb[0] * 255);
-        px[i + 1] = Math.round(rgb[1] * 255);
-        px[i + 2] = Math.round(rgb[2] * 255);
+        put255(px, i, rgb[0]);
+        put255(px, i + 1, rgb[1]);
+        put255(px, i + 2, rgb[2]);
       }
     }
   };
@@ -971,4 +972,4 @@ export {
   pathStrokeCoverage,
   paintPathStroke
 };
-//# sourceMappingURL=chunk-JHXMNOMF.js.map
+//# sourceMappingURL=chunk-YHW26LS2.js.map

package/dist/chunk-YHW26LS2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/paint/heal.ts","../src/paint/retouch.ts","../src/paint/path-stroke.ts"],"sourcesContent":["// Portions ported from photocraft/crates/algo/src/poisson.rs and inpaint.rs (MIT OR Apache-2.0, © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.\n\n/**\n * Gradient-domain (\"Poisson\") blending for the Healing Brush and the Spot Healing Brush.\n *\n * Method: P. Pérez, M. Gangnet, A. Blake, *Poisson Image Editing*, SIGGRAPH 2003. Seamless cloning\n * looks for `f` over a region Ω with `f = f*` (the destination) on its boundary and `∇f` as close\n * as possible to the source's `∇g`. The answer is `f = g + h`, where `h` is the membrane: the\n * harmonic function (`Δh = 0`) that equals `f* − g` on the boundary. So healed pixels keep the\n * source's texture while their colour and lighting are pulled to the pixels around the stroke.\n *\n * The Laplace equation is solved on the 4-connected grid by successive over-relaxation, started\n * from a recursively solved half-resolution grid (cascadic multigrid). Harmonic functions are\n * smooth, so the coarse guess is close and a few sweeps per level remove the rest.\n *\n * Buffers are interleaved `w × h × ch` floats in any units (the callers use 0..255). Pure maths:\n * no DOM, no framework.\n */\n\n/** Largest per-sweep update below which a solve has converged. */\nconst TOL = 2e-3;\n/** Sweeps (cap) and relaxation on every level above the coarsest. */\nconst FINE_ITERS = 30;\nconst FINE_OMEGA = 1.7;\n\n/**\n * Solves `Δv = 0` on the `unknown` pixels, with the known pixels of `v` as Dirichlet values\n * (neighbours off the grid are ignored: a free boundary). `v` holds the known values on entry and\n * the solution on exit.\n */\nexport function solveMembrane(w: number, h: number, unknown: ArrayLike<boolean | number>, v: Float32Array): void {\n  if (unknown.length !== w * h || v.length !== w * h) throw new RangeError(`solveMembrane: expected ${w * h} cells, got ${unknown.length} and ${v.length}.`);\n  const u = new Uint8Array(w * h);\n  for (let i = 0; i < u.length; i++) u[i] = unknown[i] ? 1 : 0;\n  solveLevel(w, h, u, v, 0);\n}\n\nfunction solveLevel(w: number, h: number, unknown: Uint8Array, v: Float32Array, depth: number): void {\n  let nUnknown = 0;\n  let knownSum = 0;\n  let nKnown = 0;\n  for (let i = 0; i < unknown.length; i++) {\n    if (unknown[i]) nUnknown++;\n    else {\n      knownSum += v[i];\n      nKnown++;\n    }\n  }\n  if (nUnknown === 0 || nKnown === 0) return;\n  if (w >= 8 && h >= 8 && nUnknown > 64 && depth < 16) {\n    // Restrict: a coarse cell is known when any of its children is (the mean of those).\n    const cw = Math.ceil(w / 2);\n    const chh = Math.ceil(h / 2);\n    const cu = new Uint8Array(cw * chh).fill(1);\n    const cv = new Float32Array(cw * chh);\n    for (let cy = 0; cy < chh; cy++) {\n      for (let cx = 0; cx < cw; cx++) {\n        let s = 0;\n        let n = 0;\n        for (let k = 0; k < 4; k++) {\n          const x = cx * 2 + (k & 1);\n          const y = cy * 2 + (k >> 1);\n          if (x < w && y < h && !unknown[y * w + x]) {\n            s += v[y * w + x];\n            n++;\n          }\n        }\n        if (n > 0) {\n          cu[cy * cw + cx] = 0;\n          cv[cy * cw + cx] = s / n;\n        }\n      }\n    }\n    solveLevel(cw, chh, cu, cv, depth + 1);\n    // Prolong: a bilinear sample of the coarse solution is the starting guess.\n    for (let y = 0; y < h; y++) {\n      const fy = Math.min(chh - 1, Math.max(0, (y + 0.5) / 2 - 0.5));\n      const y0 = Math.floor(fy);\n      const y1 = Math.min(chh - 1, y0 + 1);\n      const ty = fy - y0;\n      for (let x = 0; x < w; x++) {\n        if (!unknown[y * w + x]) continue;\n        const fx = Math.min(cw - 1, Math.max(0, (x + 0.5) / 2 - 0.5));\n        const x0 = Math.floor(fx);\n        const x1 = Math.min(cw - 1, x0 + 1);\n        const tx = fx - x0;\n        const a = cv[y0 * cw + x0] + (cv[y0 * cw + x1] - cv[y0 * cw + x0]) * tx;\n        const b = cv[y1 * cw + x0] + (cv[y1 * cw + x1] - cv[y1 * cw + x0]) * tx;\n        v[y * w + x] = a + (b - a) * ty;\n      }\n    }\n    sor(w, h, unknown, v, FINE_ITERS, FINE_OMEGA);\n  } else {\n    const mean = knownSum / nKnown;\n    for (let i = 0; i < v.length; i++) if (unknown[i]) v[i] = mean;\n    sor(w, h, unknown, v, 2000, 1.85);\n  }\n}\n\n/** Over-relaxed Gauss-Seidel sweeps over the unknown cells until the largest update is below `TOL`. */\nfunction sor(w: number, h: number, unknown: Uint8Array, v: Float32Array, maxIter: number, omega: number): void {\n  let n = 0;\n  for (let i = 0; i < unknown.length; i++) if (unknown[i]) n++;\n  const cells = new Uint32Array(n);\n  const masks = new Uint8Array(n);\n  for (let i = 0, k = 0; i < unknown.length; i++) {\n    if (!unknown[i]) continue;\n    const x = i % w;\n    const y = (i - x) / w;\n    cells[k] = i;\n    masks[k++] = (x > 0 ? 1 : 0) | (x + 1 < w ? 2 : 0) | (y > 0 ? 4 : 0) | (y + 1 < h ? 8 : 0);\n  }\n  for (let it = 0; it < maxIter; it++) {\n    let maxD = 0;\n    for (let k = 0; k < n; k++) {\n      const i = cells[k];\n      const m = masks[k];\n      let s: number;\n      let c: number;\n      if (m === 15) {\n        s = v[i - 1] + v[i + 1] + v[i - w] + v[i + w];\n        c = 4;\n      } else {\n        s = 0;\n        c = 0;\n        if (m & 1) (s += v[i - 1]), c++;\n        if (m & 2) (s += v[i + 1]), c++;\n        if (m & 4) (s += v[i - w]), c++;\n        if (m & 8) (s += v[i + w]), c++;\n        if (c === 0) continue;\n      }\n      const d = omega * (s / c - v[i]);\n      v[i] += d;\n      const ad = d < 0 ? -d : d;\n      if (ad > maxD) maxD = ad;\n    }\n    if (maxD < TOL) break;\n  }\n}\n\n/**\n * Seamless cloning: `dst` outside `mask`; inside, `src` plus the membrane that removes the\n * mismatch at the mask's edge. So the result keeps the source's texture and takes the\n * destination's colour and light. `src` and `dst` are interleaved `w × h × ch`; leave a one-pixel\n * unmasked margin for a fully fixed boundary.\n */\nexport function seamlessClone(w: number, h: number, ch: number, src: ArrayLike<number>, dst: ArrayLike<number>, mask: ArrayLike<boolean | number>): Float32Array {\n  const n = w * h;\n  if (src.length !== n * ch || dst.length !== n * ch || mask.length !== n) throw new RangeError('seamlessClone: src, dst and mask must cover w × h pixels.');\n  const out = new Float32Array(n * ch);\n  const hv = new Float32Array(n);\n  for (let c = 0; c < ch; c++) {\n    for (let i = 0; i < n; i++) hv[i] = mask[i] ? 0 : dst[i * ch + c] - src[i * ch + c];\n    solveMembrane(w, h, mask, hv);\n    for (let i = 0; i < n; i++) out[i * ch + c] = mask[i] ? src[i * ch + c] + hv[i] : dst[i * ch + c];\n  }\n  return out;\n}\n\n/** Membrane fill (no source texture): the known pixels interpolated smoothly into `hole`. */\nexport function membraneFill(w: number, h: number, ch: number, img: ArrayLike<number>, hole: ArrayLike<boolean | number>): Float32Array {\n  const n = w * h;\n  const out = new Float32Array(n * ch);\n  const v = new Float32Array(n);\n  for (let c = 0; c < ch; c++) {\n    for (let i = 0; i < n; i++) v[i] = hole[i] ? 0 : img[i * ch + c];\n    solveMembrane(w, h, hole, v);\n    for (let i = 0; i < n; i++) out[i * ch + c] = v[i];\n  }\n  return out;\n}\n\n/** A mask grown by `r` pixels (square structuring element). */\nexport function dilateMask(w: number, h: number, mask: ArrayLike<boolean | number>, r: number): Uint8Array {\n  const tmp = new Uint8Array(w * h);\n  for (let y = 0; y < h; y++) {\n    for (let x = 0; x < w; x++) {\n      if (!mask[y * w + x]) continue;\n      for (let xx = Math.max(0, x - r); xx <= Math.min(w - 1, x + r); xx++) tmp[y * w + xx] = 1;\n    }\n  }\n  const out = new Uint8Array(w * h);\n  for (let y = 0; y < h; y++) {\n    for (let x = 0; x < w; x++) {\n      if (!tmp[y * w + x]) continue;\n      for (let yy = Math.max(0, y - r); yy <= Math.min(h - 1, y + r); yy++) out[yy * w + x] = 1;\n    }\n  }\n  return out;\n}\n\n/** A summed-area table over a mask, for \"how many masked cells in this window\". */\nclass MaskIntegral {\n  private readonly s: Uint32Array;\n  constructor(\n    private readonly w: number,\n    private readonly h: number,\n    mask: ArrayLike<boolean | number>\n  ) {\n    const W = w + 1;\n    this.s = new Uint32Array(W * (h + 1));\n    for (let y = 0; y < h; y++) {\n      let row = 0;\n      for (let x = 0; x < w; x++) {\n        row += mask[y * w + x] ? 1 : 0;\n        this.s[(y + 1) * W + x + 1] = this.s[y * W + x + 1] + row;\n      }\n    }\n  }\n  /** Masked cells in [x0, x1) × [y0, y1) (clipped to the grid). */\n  count(x0: number, y0: number, x1: number, y1: number): number {\n    const W = this.w + 1;\n    const a = Math.max(0, Math.min(this.w, x0));\n    const b = Math.max(0, Math.min(this.h, y0));\n    const c = Math.max(0, Math.min(this.w, x1));\n    const d = Math.max(0, Math.min(this.h, y1));\n    if (c <= a || d <= b) return 0;\n    return this.s[d * W + c] - this.s[b * W + c] - this.s[d * W + a] + this.s[b * W + a];\n  }\n}\n\n/** Bounding box [x0, y0, x1, y1) of the set cells, or null. */\nexport function maskBounds(w: number, h: number, mask: ArrayLike<boolean | number>): [number, number, number, number] | null {\n  let x0 = w;\n  let y0 = h;\n  let x1 = -1;\n  let y1 = -1;\n  for (let y = 0; y < h; y++) {\n    for (let x = 0; x < w; x++) {\n      if (!mask[y * w + x]) continue;\n      if (x < x0) x0 = x;\n      if (x > x1) x1 = x;\n      if (y < y0) y0 = y;\n      if (y > y1) y1 = y;\n    }\n  }\n  return x1 < 0 ? null : [x0, y0, x1 + 1, y1 + 1];\n}\n\n/**\n * Proximity match: the translation `(dx, dy)` (within `maxRadius`) whose pixels best match the\n * ring of `ring` pixels around the hole (sum of squared differences), so `img[p + (dx, dy)]` can\n * fill `p` in the hole. The source window must lie on the grid and hold no hole pixels. Nearer\n * sources win ties. Returns null when no translation fits.\n */\nexport function bestOffset(w: number, h: number, ch: number, img: ArrayLike<number>, hole: ArrayLike<boolean | number>, ring: number, maxRadius: number): [number, number] | null {\n  const bb = maskBounds(w, h, hole);\n  if (!bb) return null;\n  const extent = Math.max(w, h);\n  const R = Math.max(0, Math.min(extent, Math.floor(maxRadius)));\n  if (R === 0) return null;\n  const rg = Math.max(1, Math.min(extent, Math.floor(ring)));\n  const hs = new MaskIntegral(w, h, hole);\n  const x0 = bb[0] - rg;\n  const y0 = bb[1] - rg;\n  const x1 = bb[2] + rg;\n  const y1 = bb[3] + rg;\n  // Sample points: the ring around the hole, subsampled to about 2000.\n  const pts: number[] = [];\n  for (let y = Math.max(0, y0); y < Math.min(h, y1); y++) {\n    for (let x = Math.max(0, x0); x < Math.min(w, x1); x++) {\n      if (hole[y * w + x]) continue;\n      if (hs.count(x - rg, y - rg, x + rg + 1, y + rg + 1) > 0) pts.push(x, y);\n    }\n  }\n  const stride = Math.max(1, Math.floor(pts.length / 2 / 2000));\n  const sx: number[] = [];\n  const sy: number[] = [];\n  for (let i = 0; i < pts.length; i += 2 * stride) {\n    sx.push(pts[i]);\n    sy.push(pts[i + 1]);\n  }\n  const n = Math.max(1, sx.length);\n  const evalAt = (dx: number, dy: number, cutoff: number): number | null => {\n    if (dx === 0 && dy === 0) return null;\n    const hx0 = x0 + dx;\n    const hy0 = y0 + dy;\n    const hx1 = x1 + dx;\n    const hy1 = y1 + dy;\n    if (hx0 < 0 || hy0 < 0 || hx1 > w || hy1 > h) return null;\n    if (hs.count(hx0, hy0, hx1, hy1) !== 0) return null;\n    const penalty = 1 + 1e-3 * (Math.hypot(dx, dy) / R);\n    let e = 0;\n    for (let i = 0; i < sx.length; i++) {\n      const a = (sy[i] * w + sx[i]) * ch;\n      const b = ((sy[i] + dy) * w + sx[i] + dx) * ch;\n      for (let c = 0; c < ch; c++) {\n        const d = img[a + c] - img[b + c];\n        e += d * d;\n      }\n      if ((i & 31) === 31 && (e / n) * penalty >= cutoff) return null;\n    }\n    return (e / n) * penalty;\n  };\n  const found: { best: [number, number] | null; e: number } = { best: null, e: Infinity };\n  const consider = (dx: number, dy: number) => {\n    const e = evalAt(dx, dy, found.e);\n    if (e !== null && e < found.e) {\n      found.e = e;\n      found.best = [dx, dy];\n    }\n  };\n  // A coarse grid over the search window, then every offset around the winner.\n  const step = Math.max(1, Math.floor(R / 24));\n  for (let dy = -R; dy <= R; dy += step) for (let dx = -R; dx <= R; dx += step) consider(dx, dy);\n  if (step > 1 && found.best) {\n    const [bx, by] = found.best;\n    for (let dy = by - step; dy <= by + step; dy++) for (let dx = bx - step; dx <= bx + step; dx++) consider(dx, dy);\n  }\n  return found.best;\n}\n","// Portions ported from photocraft/crates/paint/src/retouch.rs, crates/algo/src/retouch.rs and crates/engine/src/retouch_cmds.rs (MIT OR Apache-2.0, © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.\n\n/**\n * The retouching tools on the shared brush engine: Clone Stamp, Healing Brush, Spot Healing\n * Brush, Smudge, Dodge, Burn and Sponge. Two stroke shapes cover them all:\n *\n * - **Accumulate, then composite** (Clone Stamp, Dodge, Burn; the Healing tools' result): the\n *   stroke's dabs build up one `CoverageMap` (flow builds towards the dab's opacity ceiling), and\n *   per-pixel paint taken from the pre-stroke state (a cloned source, a toned copy of the pixel,\n *   a healed patch) is composited through it with `applyRetouchToTile`. Pixels painted earlier in\n *   the stroke are never sampled again, and overlapping dabs never exceed the stroke's opacity.\n * - **Sequential dabs** (Smudge, Sponge): `RetouchDabStroke` runs each dab in order over live\n *   tiles, so dab n sees what dab n − 1 did.\n *\n * The Healing Brush clones while it is drawn and, when the stroke ends, replaces the clone with a\n * seamless clone (`healPixels`, Poisson blending): the source's texture with the colour and light\n * of the pixels around the stroke. The Spot Healing Brush finds its own source (`spotHealPixels`).\n *\n * Tone curves (`dodgeBurnCurve`, `dodgeBurn`, `sponge`) are photocraft's, made to behave like\n * Photoshop's tools: the chosen range moves most, black and white stay put for midtones, and\n * Protect Tones works on luma so hue and saturation are kept. Data in, pixels out; no DOM.\n */\n\nimport { blendPixel, type BlendMode } from '../raster/blend';\nimport type { RasterRect } from '../raster/surface';\nimport { TILE, tileKey } from '../raster/surface';\nimport { srgbDecode, srgbEncode } from '../raster/deep';\nimport { DabWalker, dabRect, rasterizeDab, type BrushSettings, type CoverageMap, type Dab, type StrokePoint } from './brush';\nimport { SmudgeTip, type SmudgeSettings } from './blending';\nimport { TileMedium, put255, type PaintPixels, type PaintTileTarget } from './exchange';\nimport { bestOffset, dilateMask, maskBounds, membraneFill, seamlessClone } from './heal';\n\n// ---------------------------------------------------------------------------\n// Tone kernels\n// ---------------------------------------------------------------------------\n\n/** The tonal range Dodge and Burn work on most. */\nexport type ToneRange = 'shadows' | 'midtones' | 'highlights';\n\nexport const TONE_RANGES: readonly ToneRange[] = ['shadows', 'midtones', 'highlights'];\n\n/** Rec. 601 luma of straight RGB (0..1). */\nexport function luma(r: number, g: number, b: number): number {\n  return 0.299 * r + 0.587 * g + 0.114 * b;\n}\n\n/** The dodge (or burn) transfer of one value `v` (0..1) at exposure `e` (0..1). */\nexport function dodgeBurnCurve(v: number, e: number, range: ToneRange, burn: boolean): number {\n  const x = Math.max(0, v);\n  const k = Math.min(1, Math.max(0, e));\n  const c = Math.min(1, x);\n  if (range === 'midtones') {\n    // A gamma bend weighted to peak at mid-grey: 0 and 1 stay where they are.\n    const w = Math.min(1, Math.max(0, 4 * x * (1 - x)));\n    return x + w * (Math.pow(c, burn ? 1 + k : 1 / (1 + k)) - x);\n  }\n  // Shadows / highlights: `v + e·w·(target − v)`, weighted (1 − v)² or v², so that end moves most.\n  const w = range === 'shadows' ? (1 - c) * (1 - c) : c * c;\n  return burn ? x - k * w * x : x + k * w * (1 - c);\n}\n\n/** Brings RGB back into 0..1 keeping its luma (mixing towards grey) rather than clipping each channel. */\nfunction compressGamut(c: number[], l: number): void {\n  const L = Math.min(1, Math.max(0, l));\n  const lo = Math.min(c[0], c[1], c[2]);\n  const hi = Math.max(c[0], c[1], c[2]);\n  let t = 1;\n  if (hi > 1 && hi - L > 1e-9) t = Math.min(t, (1 - L) / (hi - L));\n  if (lo < 0 && L - lo > 1e-9) t = Math.min(t, L / (L - lo));\n  for (let i = 0; i < 3; i++) c[i] = L + (c[i] - L) * t;\n}\n\n/**\n * Dodge (or burn) straight RGB `c` (0..1, written in place) at exposure `e`. With `protectTones`\n * the curve moves luma and the colour is scaled to it (hue and saturation kept); otherwise each\n * channel goes through the curve.\n */\nexport function dodgeBurn(c: number[], e: number, range: ToneRange, burn: boolean, protectTones: boolean): number[] {\n  if (!(e > 0)) return c;\n  if (protectTones) {\n    const l = luma(c[0], c[1], c[2]);\n    const nl = dodgeBurnCurve(l, e, range, burn);\n    if (l > 1e-6) for (let i = 0; i < 3; i++) c[i] *= nl / l;\n    else c[0] = c[1] = c[2] = nl;\n    compressGamut(c, nl);\n  } else for (let i = 0; i < 3; i++) c[i] = dodgeBurnCurve(c[i], e, range, burn);\n  return c;\n}\n\n/** HSV saturation (chroma / max) of straight RGB. */\nexport function saturationOf(r: number, g: number, b: number): number {\n  const lo = Math.min(r, g, b);\n  const hi = Math.max(r, g, b);\n  return hi <= 1e-6 ? 0 : Math.min(1, Math.max(0, (hi - lo) / hi));\n}\n\n/**\n * Sponge: moves straight RGB `c` (written in place) away from (`saturate`) or towards its luma\n * grey by `amount` (0..1). `vibrance` damps it where it would clip: saturating touches already\n * saturated colours less, desaturating touches near-greys less. Gamut-compressed, never clipped.\n */\nexport function sponge(c: number[], amount: number, saturate: boolean, vibrance: boolean): number[] {\n  let a = Math.min(1, Math.max(0, amount));\n  if (!(a > 0)) return c;\n  if (vibrance) {\n    const s = saturationOf(c[0], c[1], c[2]);\n    a *= saturate ? 1 - s : 0.25 + 0.75 * s;\n  }\n  const l = luma(c[0], c[1], c[2]);\n  const k = saturate ? 1 + a : 1 - a;\n  for (let i = 0; i < 3; i++) c[i] = l + (c[i] - l) * k;\n  compressGamut(c, l);\n  return c;\n}\n\n/** Per-dab strength so that one pass over a point totals about `e`, whatever the spacing. */\nexport function perDabStrength(e: number, spacing: number): number {\n  return 1 - Math.pow(1 - Math.min(1, Math.max(0, e)), Math.min(1, Math.max(0.01, spacing)));\n}\n\n// ---------------------------------------------------------------------------\n// Settings\n// ---------------------------------------------------------------------------\n\n/** Which pixels the Clone Stamp and the Healing tools sample. */\nexport type RetouchSample = 'current' | 'current-below' | 'all';\n\nexport const RETOUCH_SAMPLES: readonly RetouchSample[] = ['current', 'current-below', 'all'];\n\n/** How the Spot Healing Brush finds its source. */\nexport type SpotHealType = 'proximity-match' | 'smooth';\n\nexport const SPOT_HEAL_TYPES: readonly SpotHealType[] = ['proximity-match', 'smooth'];\n\n/** The retouching tools' options. */\nexport interface RetouchSettings {\n  /** Clone / heal: keep the source offset from stroke to stroke (default true); off, every stroke starts at the source point. */\n  aligned: boolean;\n  /** Clone / heal / spot heal: what is sampled (default `current`: the target layer). */\n  sample: RetouchSample;\n  /** Spot heal: `proximity-match` (default: the best matching patch nearby) or `smooth` (a smooth fill from the edges). */\n  spotType: SpotHealType;\n  /** Dodge / burn: the tonal range (default `midtones`). */\n  range: ToneRange;\n  /** Dodge / burn: exposure 0..1 (default 0.5). */\n  exposure: number;\n  /** Dodge / burn: tone luma only, keeping hue and saturation (default true). */\n  protectTones: boolean;\n  /** Sponge: `desaturate` (default) or `saturate`. */\n  spongeMode: 'desaturate' | 'saturate';\n  /** Sponge: damp the change where colours would clip (default true). */\n  vibrance: boolean;\n  /** Smudge: how strongly the finger carries and lays paint, 0..1 (default 0.5). */\n  strength: number;\n}\n\nexport const DEFAULT_RETOUCH: Readonly<RetouchSettings> = {\n  aligned: true,\n  sample: 'current',\n  spotType: 'proximity-match',\n  range: 'midtones',\n  exposure: 0.5,\n  protectTones: true,\n  spongeMode: 'desaturate',\n  vibrance: true,\n  strength: 0.5,\n};\n\n/** Retouch settings with every field valid (missing or invalid fields from `base`). */\nexport function normalizeRetouch(raw: Partial<RetouchSettings> = {}, base: RetouchSettings = DEFAULT_RETOUCH): RetouchSettings {\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  const pick = <T extends string>(v: unknown, all: readonly T[], d: T): T => (all.includes(v as T) ? (v as T) : d);\n  return {\n    aligned: bool(raw.aligned, base.aligned),\n    sample: pick(raw.sample, RETOUCH_SAMPLES, base.sample),\n    spotType: pick(raw.spotType, SPOT_HEAL_TYPES, base.spotType),\n    range: pick(raw.range, TONE_RANGES, base.range),\n    exposure: unit(raw.exposure, base.exposure),\n    protectTones: bool(raw.protectTones, base.protectTones),\n    spongeMode: pick(raw.spongeMode, ['desaturate', 'saturate'] as const, base.spongeMode),\n    vibrance: bool(raw.vibrance, base.vibrance),\n    strength: unit(raw.strength, base.strength),\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Pixel sources\n// ---------------------------------------------------------------------------\n\n/** Pixels a retouching stroke samples, by document pixel. */\nexport interface PixelSource {\n  /** Straight RGBA 0..255 of document pixel (x, y) into `out`; false (and `out` zeroed) where there is nothing. */\n  sample(x: number, y: number, out: number[]): boolean;\n}\n\n/**\n * A source over raster tiles (layer pixels, a mask, or composite tiles): `readTile` gives tile\n * (tx, ty) in source space or `null` when it is empty; source pixel = document pixel − `offset`.\n * One-channel tiles read as grey (alpha 255). Tiles are cached, so make one per stroke.\n */\nexport class TilePixelSource implements PixelSource {\n  private readonly cache = new Map<number, PaintPixels | null>();\n  private lastKey = NaN;\n  private last: PaintPixels | null = null;\n\n  constructor(\n    /** A tile's bytes, or a float working tile on the same 0..255 scale (16 / 32 bits). */\n    private readonly readTile: (tx: number, ty: number) => PaintPixels | null,\n    readonly channels: 1 | 4,\n    readonly offset: { x: number; y: number } = { x: 0, y: 0 }\n  ) {}\n\n  sample(x: number, y: number, out: number[]): boolean {\n    const lx = x - this.offset.x;\n    const ly = y - this.offset.y;\n    const tx = Math.floor(lx / TILE);\n    const ty = Math.floor(ly / TILE);\n    const key = tileKey(tx, ty);\n    if (key !== this.lastKey) {\n      let t = this.cache.get(key);\n      if (t === undefined) {\n        t = this.readTile(tx, ty);\n        this.cache.set(key, t);\n      }\n      this.last = t;\n      this.lastKey = key;\n    }\n    const t = this.last;\n    if (!t) {\n      out[0] = out[1] = out[2] = out[3] = 0;\n      return false;\n    }\n    const p = (ly - ty * TILE) * TILE + (lx - tx * TILE);\n    if (this.channels === 1) {\n      out[0] = out[1] = out[2] = t[p];\n      out[3] = 255;\n      return true;\n    }\n    const i = p * 4;\n    out[0] = t[i];\n    out[1] = t[i + 1];\n    out[2] = t[i + 2];\n    out[3] = t[i + 3];\n    return out[3] > 0;\n  }\n}\n\n/** A source over a region of float RGBA pixels (0..255), e.g. a healed patch. */\nexport class RegionPixelSource implements PixelSource {\n  constructor(\n    readonly rect: RasterRect,\n    readonly data: Float32Array\n  ) {}\n\n  sample(x: number, y: number, out: number[]): boolean {\n    const r = this.rect;\n    const lx = x - r.x;\n    const ly = y - r.y;\n    if (lx < 0 || ly < 0 || lx >= r.width || ly >= r.height) {\n      out[0] = out[1] = out[2] = out[3] = 0;\n      return false;\n    }\n    const i = (ly * r.width + lx) * 4;\n    out[0] = this.data[i];\n    out[1] = this.data[i + 1];\n    out[2] = this.data[i + 2];\n    out[3] = this.data[i + 3];\n    return out[3] > 0;\n  }\n}\n\n/** `rect` of a source, shifted by (dx, dy), as float RGBA 0..255 (`rect.width × rect.height × 4`). */\nexport function readSourceRegion(source: PixelSource, rect: RasterRect, dx = 0, dy = 0): Float32Array {\n  const out = new Float32Array(rect.width * rect.height * 4);\n  const px = [0, 0, 0, 0];\n  for (let y = 0; y < rect.height; y++) {\n    for (let x = 0; x < rect.width; x++) {\n      source.sample(rect.x + x + dx, rect.y + y + dy, px);\n      const i = (y * rect.width + x) * 4;\n      out[i] = px[0];\n      out[i + 1] = px[1];\n      out[i + 2] = px[2];\n      out[i + 3] = px[3];\n    }\n  }\n  return out;\n}\n\n// ---------------------------------------------------------------------------\n// Accumulate, then composite\n// ---------------------------------------------------------------------------\n\n/** What a coverage-based retouching stroke lays through its coverage. */\nexport type RetouchPaint =\n  /** Source pixels at document pixel + (dx, dy) (Clone Stamp, a healed patch). */\n  | { kind: 'source'; source: PixelSource; dx: number; dy: number }\n  /** The target pixel itself, toned (Dodge, Burn): `tone` edits straight RGB 0..1 in place. */\n  | { kind: 'tone'; tone: (rgb: number[]) => void }\n  /** A flat colour (the Spot Healing Brush's trail while it is drawn), RGBA 0..255. */\n  | { kind: 'color'; color: readonly [number, number, number, number] };\n\n/** How a coverage-based retouching stroke composites. */\nexport interface RetouchApply {\n  /** Stroke opacity 0..1. */\n  opacity: number;\n  /** Blend mode for source paint (default normal). */\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 `paint` through the stroke's coverage over `tileData` (target tile (tx, ty) as it was\n * before the stroke, layer space; RGBA, or one byte per pixel for masks) and returns the new tile.\n * With `into` (the previous result) and `region` (document space), only `region` is recomputed.\n * Tone paint keeps alpha; source and colour paint composite with `blend` (source-over by\n * default), keeping alpha on a locked layer.\n */\nexport function applyRetouchToTile<T extends PaintPixels>(\n  coverage: CoverageMap,\n  tileData: T,\n  channels: 1 | 4,\n  tx: number,\n  ty: number,\n  paint: RetouchPaint,\n  s: RetouchApply,\n  options: { into?: T; region?: RasterRect } = {}\n): T {\n  // A float working tile (16 / 32 bits) stays float and keeps fractions; bytes round as ever.\n  const out = (options.into ?? tileData).slice() as T;\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    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 blend = s.blend ?? 'normal';\n  const src = [0, 0, 0, 0];\n  const rgb = [0, 0, 0];\n  const cb = [0, 0, 0, 0];\n  const cs = [0, 0, 0, 0];\n  // The coverage tile under the pixel, looked up once per tile it crosses.\n  let covKey = NaN;\n  let covTile: Float32Array | undefined;\n  for (let y = y0; y < y1; y++) {\n    const dy = oy + y;\n    const cty = Math.floor(dy / TILE);\n    for (let x = x0; x < x1; x++) {\n      const dx = ox + x;\n      const ctx = Math.floor(dx / TILE);\n      const key = tileKey(ctx, cty);\n      if (key !== covKey) {\n        covKey = key;\n        covTile = coverage.tiles.get(key);\n      }\n      if (!covTile) continue;\n      const c = covTile[(dy - cty * TILE) * TILE + (dx - ctx * TILE)];\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        // Masks: grey values; the source's grey is its red channel.\n        const g = out[p];\n        let t: number;\n        if (paint.kind === 'tone') {\n          rgb[0] = rgb[1] = rgb[2] = g / 255;\n          paint.tone(rgb);\n          t = luma(rgb[0], rgb[1], rgb[2]) * 255;\n        } else if (paint.kind === 'color') t = paint.color[0];\n        else {\n          if (!paint.source.sample(dx + paint.dx, dy + paint.dy, src)) continue;\n          t = src[0];\n          k *= src[3] / 255;\n        }\n        out[p] = Math.round(g + (t - g) * k);\n        continue;\n      }\n      const i = p * 4;\n      const a = out[i + 3];\n      if (paint.kind === 'tone') {\n        if (a === 0) continue;\n        rgb[0] = out[i] / 255;\n        rgb[1] = out[i + 1] / 255;\n        rgb[2] = out[i + 2] / 255;\n        const r0 = rgb[0];\n        const g0 = rgb[1];\n        const b0 = rgb[2];\n        paint.tone(rgb);\n        put255(out, i, r0 + (rgb[0] - r0) * k);\n        put255(out, i + 1, g0 + (rgb[1] - g0) * k);\n        put255(out, i + 2, b0 + (rgb[2] - b0) * k);\n        continue;\n      }\n      if (s.lockTransparency && a === 0) continue;\n      if (paint.kind === 'color') {\n        src[0] = paint.color[0];\n        src[1] = paint.color[1];\n        src[2] = paint.color[2];\n        src[3] = paint.color[3];\n      } else if (!paint.source.sample(dx + paint.dx, dy + paint.dy, src)) continue;\n      for (let ch = 0; ch < 4; ch++) {\n        cb[ch] = out[i + ch] / 255;\n        cs[ch] = src[ch] / 255;\n      }\n      // Source-over, as a brush lays paint: cloning transparency paints nothing.\n      const o = blendPixel(blend, cb, cs, k);\n      put255(out, i, o[0]);\n      put255(out, i + 1, o[1]);\n      put255(out, i + 2, o[2]);\n      if (!s.lockTransparency) put255(out, i + 3, o[3]);\n    }\n  }\n  return out;\n}\n\n/**\n * Dodge / Burn at 16 or 32 bits: `applyRetouchToTile`'s tone paint on a layer tile's deep samples\n * (`Uint16Array` sRGB-encoded, or `Float32Array` linear light, RGBA). The tone curves work on\n * encoded values as at 8 bits, so 32-bit samples are encoded, toned and decoded (colour above 1 is\n * toned at 1 and keeps its excess). Returns the new samples.\n */\nexport function applyToneToDeepTile(\n  coverage: CoverageMap,\n  samples: Uint16Array | Float32Array,\n  tx: number,\n  ty: number,\n  tone: (rgb: number[]) => void,\n  s: RetouchApply,\n  options: { into?: Uint16Array | Float32Array; region?: RasterRect } = {}\n): Uint16Array | Float32Array {\n  const linear = samples instanceof Float32Array;\n  const out = (options.into ?? samples).slice() as Uint16Array | Float32Array;\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    if (options.into) for (let y = y0; y < y1; y++) out.set(samples.subarray((y * TILE + x0) * 4, (y * TILE + x1) * 4), (y * TILE + x0) * 4);\n  }\n  const sel = s.selection;\n  const rgb = [0, 0, 0];\n  const before = [0, 0, 0];\n  const excess = [0, 0, 0];\n  let covKey = NaN;\n  let covTile: Float32Array | undefined;\n  for (let y = y0; y < y1; y++) {\n    const dy = oy + y;\n    const cty = Math.floor(dy / TILE);\n    for (let x = x0; x < x1; x++) {\n      const dx = ox + x;\n      const ctx = Math.floor(dx / TILE);\n      const key = tileKey(ctx, cty);\n      if (key !== covKey) {\n        covKey = key;\n        covTile = coverage.tiles.get(key);\n      }\n      if (!covTile) continue;\n      const c = covTile[(dy - cty * TILE) * TILE + (dx - ctx * TILE)];\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 i = (y * TILE + x) * 4;\n      if (out[i + 3] === 0) continue;\n      for (let ch = 0; ch < 3; ch++) {\n        const v = out[i + ch];\n        if (linear) {\n          excess[ch] = v > 1 ? v - 1 : 0;\n          rgb[ch] = srgbEncode(v > 1 ? 1 : v < 0 ? 0 : v);\n        } else rgb[ch] = v / 65535;\n        before[ch] = rgb[ch];\n      }\n      tone(rgb);\n      for (let ch = 0; ch < 3; ch++) {\n        const e = before[ch] + (rgb[ch] - before[ch]) * k;\n        if (linear) out[i + ch] = srgbDecode(e) + excess[ch];\n        else out[i + ch] = e <= 0 ? 0 : e >= 1 ? 65535 : Math.round(e * 65535);\n      }\n    }\n  }\n  return out;\n}\n\n/** The tone function of a Dodge or Burn stroke. */\nexport function toneOf(tool: 'dodge' | 'burn', settings: Pick<RetouchSettings, 'exposure' | 'range' | 'protectTones'>): (rgb: number[]) => void {\n  const burn = tool === 'burn';\n  return (rgb) => {\n    dodgeBurn(rgb, settings.exposure, settings.range, burn, settings.protectTones);\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Healing\n// ---------------------------------------------------------------------------\n\n/**\n * Heals `src` into `dst` over `mask` (all `w × h`, RGBA floats 0..255): a seamless clone solved\n * only over the mask's bounds plus a one-pixel fixed ring; elsewhere the result is `dst`.\n */\nexport function healPixels(w: number, h: number, src: Float32Array, dst: Float32Array, mask: ArrayLike<boolean | number>): Float32Array {\n  const out = new Float32Array(dst);\n  const bb = maskBounds(w, h, mask);\n  if (!bb) return out;\n  const x0 = Math.max(0, bb[0] - 1);\n  const y0 = Math.max(0, bb[1] - 1);\n  const x1 = Math.min(w, bb[2] + 1);\n  const y1 = Math.min(h, bb[3] + 1);\n  const rw = x1 - x0;\n  const rh = y1 - y0;\n  const s = new Float32Array(rw * rh * 4);\n  const d = new Float32Array(rw * rh * 4);\n  const m = new Uint8Array(rw * rh);\n  for (let y = 0; y < rh; y++) {\n    for (let x = 0; x < rw; x++) {\n      const gi = (y + y0) * w + x + x0;\n      const li = y * rw + x;\n      m[li] = mask[gi] ? 1 : 0;\n      for (let c = 0; c < 4; c++) {\n        s[li * 4 + c] = src[gi * 4 + c];\n        d[li * 4 + c] = dst[gi * 4 + c];\n      }\n    }\n  }\n  const healed = seamlessClone(rw, rh, 4, s, d, m);\n  for (let y = 0; y < rh; y++) {\n    for (let x = 0; x < rw; x++) {\n      const gi = ((y + y0) * w + x + x0) * 4;\n      const li = (y * rw + x) * 4;\n      for (let c = 0; c < 4; c++) out[gi + c] = Math.min(255, Math.max(0, healed[li + c]));\n    }\n  }\n  return out;\n}\n\n/**\n * Spot healing: fills `hole` (`w × h`) of `img` (RGBA floats 0..255) with no given source, then\n * heals the fill into its surroundings. `proximity-match` copies the best matching nearby patch\n * (falling back to `smooth` when none fits); `smooth` interpolates the edges inwards. `size` is\n * the brush diameter in pixels. Returns the healed pixels over the whole grid.\n */\nexport function spotHealPixels(\n  w: number,\n  h: number,\n  img: Float32Array,\n  hole: ArrayLike<boolean | number>,\n  size: number,\n  type: SpotHealType,\n  /** Told the patch offset it copied (`null`: a smooth fill). */\n  onOffset?: (offset: [number, number] | null) => void\n): Float32Array {\n  // Fill a slightly larger domain than the healed area, so the solve's boundary sees filled values\n  // that differ from the untouched pixels: that mismatch is what the membrane corrects.\n  const domain = dilateMask(w, h, hole, 2);\n  const healMask = dilateMask(w, h, hole, 1);\n  let filled: Float32Array | null = null;\n  let bestFound: [number, number] | null = null;\n  if (type === 'proximity-match') {\n    const ring = Math.min(16, Math.max(3, Math.floor(size / 8)));\n    const off = bestOffset(w, h, 4, img, domain, ring, Math.floor(Math.max(w, h) / 2));\n    if (off) {\n      bestFound = off;\n      // Copy from the pre-healing pixels, never from what this loop already wrote.\n      filled = new Float32Array(img);\n      const [ddx, ddy] = off;\n      for (let i = 0; i < w * h; i++) {\n        if (!domain[i]) continue;\n        const x = (i % w) + ddx;\n        const y = Math.floor(i / w) + ddy;\n        const j = (y * w + x) * 4;\n        for (let c = 0; c < 4; c++) filled[i * 4 + c] = img[j + c];\n      }\n    }\n  }\n  onOffset?.(filled ? (bestFound as [number, number]) : null);\n  if (!filled) filled = membraneFill(w, h, 4, img, domain);\n  return healPixels(w, h, filled, img, healMask);\n}\n\n/** The window a Spot Healing stroke over `bounds` looks for texture in: the bounds grown by their size, on the canvas. */\nexport function spotHealWindow(bounds: RasterRect, canvas: { width: number; height: number }): RasterRect {\n  const g = Math.max(8, Math.ceil(Math.max(bounds.width, bounds.height)));\n  const x0 = Math.max(0, bounds.x - g);\n  const y0 = Math.max(0, bounds.y - g);\n  const x1 = Math.min(canvas.width, bounds.x + bounds.width + g);\n  const y1 = Math.min(canvas.height, bounds.y + bounds.height + g);\n  return { x: x0, y: y0, width: Math.max(0, x1 - x0), height: Math.max(0, y1 - y0) };\n}\n\n// ---------------------------------------------------------------------------\n// Sequential dabs\n// ---------------------------------------------------------------------------\n\n/**\n * One dab of a sequential retouching stroke: `cov` is the tip's pure coverage over `rect`\n * (document space, 0..1); `d.alpha` is the flow and `d.opacity` the pressure opacity.\n */\nexport type RetouchDabEffect = (medium: TileMedium, d: Dab, rect: RasterRect, cov: Float32Array) => void;\n\n/**\n * A stroke whose dabs edit live tiles in order (Smudge, Sponge). Feed points with `push` (any\n * chunks give the same dabs), end with `finish`; each returns the document rectangles it touched.\n */\nexport class RetouchDabStroke {\n  dabCount = 0;\n  bounds: RasterRect | null = null;\n  private readonly walker: DabWalker;\n  private readonly medium: TileMedium;\n  private smoothPos: StrokePoint | null = null;\n  private buf = new Float32Array(0);\n\n  constructor(\n    readonly brush: BrushSettings,\n    target: PaintTileTarget,\n    private readonly effect: RetouchDabEffect\n  ) {\n    this.walker = new DabWalker(brush);\n    this.medium = new TileMedium(target);\n  }\n\n  push(points: readonly StrokePoint[]): RasterRect[] {\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): RasterRect[] {\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[]): RasterRect[] {\n    const rects: RasterRect[] = [];\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      rasterizeDab({ ...d, alpha: 1 }, this.brush.hardness, rect, cov);\n      this.medium.reset();\n      this.effect(this.medium, d, rect, cov);\n      rects.push(rect);\n      this.bounds = unionRect(this.bounds, rect);\n      this.dabCount++;\n    }\n    return rects;\n  }\n}\n\n/** The Smudge's per-dab effect: a `SmudgeTip` whose strength carries and lays the paint. */\nexport function smudgeEffect(brush: BrushSettings, strength: number, mixing: SmudgeSettings['mixing'] = 'rgb'): RetouchDabEffect {\n  const s = Math.min(1, Math.max(0, strength));\n  const tip = new SmudgeTip({ strength: s, length: s, mixing }, brush.size);\n  return (medium, d, rect, cov) => tip.dab(medium, { x: d.x, y: d.y, radius: d.radius, opacity: d.opacity * d.alpha }, rect, cov);\n}\n\n/** The Sponge's per-dab effect: each dab moves saturation by about half its flow, compounding over passes. */\nexport function spongeEffect(brush: BrushSettings, saturate: boolean, vibrance: boolean): RetouchDabEffect {\n  const rgb = [0, 0, 0];\n  return (medium, d, rect, cov) => {\n    const w = rect.width;\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        const k = perDabStrength(cv * d.alpha * d.opacity * 0.5, brush.spacing) * medium.selectionAt(dx, dy);\n        if (k <= 0) continue;\n        const ri = medium.locate(dx, dy, false);\n        if (ri < 0 || medium.pixels[ri + 3] === 0) continue;\n        const i = medium.locate(dx, dy, true);\n        const px = medium.pixels;\n        rgb[0] = px[i] / 255;\n        rgb[1] = px[i + 1] / 255;\n        rgb[2] = px[i + 2] / 255;\n        sponge(rgb, k, saturate, vibrance);\n        put255(px, i, rgb[0]);\n        put255(px, i + 1, rgb[1]);\n        put255(px, i + 2, rgb[2]);\n      }\n    }\n  };\n}\n\n/**\n * An RGBA view of one-channel tiles (masks), for the sequential-dab tools: reads expand grey to\n * opaque RGB, writes land in RGBA copies, and `flush` writes their red channel back through\n * `target.writeTile`. Alpha is locked, so a mask's values are all a dab changes.\n */\nexport function rgbaViewOfGrey(target: PaintTileTarget): { target: PaintTileTarget; flush(): void } {\n  const views = new Map<number, Uint8ClampedArray>();\n  const dirty = new Map<number, { tx: number; ty: number; data: Uint8ClampedArray }>();\n  const expand = (g: Uint8ClampedArray) => {\n    const out = new Uint8ClampedArray(g.length * 4);\n    for (let i = 0; i < g.length; i++) {\n      out[i * 4] = out[i * 4 + 1] = out[i * 4 + 2] = g[i];\n      out[i * 4 + 3] = 255;\n    }\n    return out;\n  };\n  const view: PaintTileTarget = {\n    offset: target.offset,\n    lockTransparency: true,\n    selection: target.selection,\n    readTile: (tx, ty) => {\n      const key = tileKey(tx, ty);\n      let v = views.get(key);\n      if (!v) {\n        // An empty mask tile is still values (0), not transparency: always give a tile.\n        v = expand((target.readTile(tx, ty) as Uint8ClampedArray | null) ?? new Uint8ClampedArray(TILE * TILE));\n        views.set(key, v);\n      }\n      return v;\n    },\n    writeTile: (tx, ty) => {\n      const key = tileKey(tx, ty);\n      let v = views.get(key);\n      if (!v) {\n        v = expand((target.readTile(tx, ty) as Uint8ClampedArray | null) ?? new Uint8ClampedArray(TILE * TILE));\n        views.set(key, v);\n      }\n      dirty.set(key, { tx, ty, data: v });\n      return v;\n    },\n  };\n  return {\n    target: view,\n    flush: () => {\n      for (const { tx, ty, data } of dirty.values()) {\n        const g = target.writeTile(tx, ty);\n        for (let i = 0; i < g.length; i++) g[i] = data[i * 4];\n      }\n      dirty.clear();\n    },\n  };\n}\n\nfunction unionRect(a: RasterRect | null, b: RasterRect): RasterRect {\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 * A brush stroke along a path: polyline samples, each with an optional pressure and pen tilt, are\n * walked at the brush's spacing (pressure and tilt interpolated between samples) into dabs, built\n * up in a coverage map and composited onto a layer. This is what a vector editor calls to draw a\n * path with a natural-media brush (\"brushstrokes on vector paths\"): the path is the data, the\n * pixels are rendered from it.\n *\n * - Pressure scales size and / or opacity as the brush says.\n * - Tilt (`tiltX` / `tiltY` in degrees, or `altitude` / `azimuth` in radians, as Pointer Events give\n *   them) widens the tip (`tilt.size`), flattens it along the lean (`tilt.roundness`), and with\n *   `tilt.followAzimuth` turns the tip to the lean, as a pen laid on its side does.\n * - With `followPath` the tip turns with the path (a calligraphic nib along a curve).\n *\n * Deterministic and DOM-free: the same samples and brush give the same pixels everywhere.\n */\n\nimport { applyStrokeToTile, CoverageMap, dabRect, normalizeBrush, rasterizeDab, type BrushSettings, type Dab } from './brush';\nimport { TiledSurface, finishTile, tileKey, tilesInRect, TILE, type RasterRect } from '../raster/surface';\nimport type { BlendMode } from '../raster/blend';\n\n/** One sample of the path (document pixels). */\nexport interface PathSample {\n  x: number;\n  y: number;\n  /** 0..1 (default 1). */\n  pressure?: number;\n  /** Pointer Events tilt in degrees (−90..90). */\n  tiltX?: number;\n  tiltY?: number;\n  /** Radians above the surface (π/2 upright); overrides tiltX / tiltY. */\n  altitude?: number;\n  /** Radians clockwise from +x: where the pen leans (with altitude). */\n  azimuth?: number;\n}\n\nexport interface PathStrokeOptions {\n  brush: Partial<BrushSettings>;\n  /** How tilt shapes the tip (each 0..1; default none). */\n  tilt?: { size?: number; roundness?: number; followAzimuth?: boolean };\n  /** Turn the tip with the direction of the path (added to the brush angle). */\n  followPath?: boolean;\n  /** Size at zero pressure as a fraction of the full size, when pressure controls size (default 0). */\n  minSize?: number;\n  /** Join the last sample back to the first. */\n  closed?: boolean;\n}\n\n/** A pen's lean from a sample: 0 upright .. 1 flat, and the direction it leans (radians, clockwise from +x). */\nfunction lean(s: PathSample): { amount: number; azimuth: number } | null {\n  if (typeof s.altitude === 'number' && Number.isFinite(s.altitude)) {\n    return { amount: 1 - Math.min(1, Math.max(0, s.altitude / (Math.PI / 2))), azimuth: s.azimuth ?? 0 };\n  }\n  if (typeof s.tiltX === 'number' || typeof s.tiltY === 'number') {\n    const tx = ((s.tiltX ?? 0) * Math.PI) / 180;\n    const ty = ((s.tiltY ?? 0) * Math.PI) / 180;\n    if (tx === 0 && ty === 0) return { amount: 0, azimuth: 0 };\n    const az = Math.atan2(Math.tan(ty), Math.tan(tx));\n    const alt = Math.atan(1 / Math.hypot(Math.tan(tx), Math.tan(ty)));\n    return { amount: 1 - alt / (Math.PI / 2), azimuth: az };\n  }\n  return null;\n}\n\n/** The dabs of a brush stroke along `samples`, with pressure and tilt interpolated between them. */\nexport function pathStrokeDabs(samples: readonly PathSample[], options: PathStrokeOptions): Dab[] {\n  const brush = normalizeBrush(options.brush);\n  const pts = options.closed && samples.length > 2 ? [...samples, samples[0]] : [...samples];\n  if (!pts.length) return [];\n  const tilt = options.tilt ?? {};\n  const minSize = Math.min(1, Math.max(0, options.minSize ?? 0));\n  const dab = (x: number, y: number, p: number, l: { amount: number; azimuth: number } | null, dir: number): Dab => {\n    const pr = Math.min(1, Math.max(0, p));\n    const lean0 = l?.amount ?? 0;\n    const size = brush.size * (brush.pressureSize ? minSize + (1 - minSize) * pr : 1) * (1 + 1.5 * (tilt.size ?? 0) * lean0);\n    let angle = (brush.angle * Math.PI) / 180;\n    if (options.followPath) angle += dir;\n    if (tilt.followAzimuth && l) angle = -l.azimuth;\n    const roundness = Math.max(0.05, brush.roundness * (1 - 0.85 * (tilt.roundness ?? 0) * lean0));\n    const op = brush.pressureOpacity ? pr : 1;\n    return { x, y, radius: Math.max(0.5, size / 2), alpha: brush.flow, opacity: brush.opacity * op, angle, roundness };\n  };\n  const out: Dab[] = [];\n  const pressure = (s: PathSample) => (typeof s.pressure === 'number' && Number.isFinite(s.pressure) ? s.pressure : 1);\n  if (pts.length === 1) {\n    out.push(dab(pts[0].x, pts[0].y, pressure(pts[0]), lean(pts[0]), 0));\n    return out;\n  }\n  let carry = 0;\n  out.push(dab(pts[0].x, pts[0].y, pressure(pts[0]), lean(pts[0]), Math.atan2(-(pts[1].y - pts[0].y), pts[1].x - pts[0].x)));\n  for (let i = 0; i + 1 < pts.length; i++) {\n    const a = pts[i];\n    const b = pts[i + 1];\n    const dx = b.x - a.x;\n    const dy = b.y - a.y;\n    const len = Math.hypot(dx, dy);\n    if (len === 0) continue;\n    // Dab angles are counter-clockwise with y up, as the shared rasterizer reads them.\n    const dir = Math.atan2(-dy, dx);\n    const la = lean(a);\n    const lb = lean(b);\n    let t = carry;\n    for (;;) {\n      const f = t / len;\n      if (f > 1) break;\n      const p = pressure(a) + (pressure(b) - pressure(a)) * f;\n      const l = la && lb ? { amount: la.amount + (lb.amount - la.amount) * f, azimuth: la.azimuth + (lb.azimuth - la.azimuth) * f } : (la ?? lb);\n      const size = brush.size * (brush.pressureSize ? minSize + (1 - minSize) * p : 1);\n      const step = Math.max(0.5, size * brush.spacing);\n      if (t > 0 || i > 0) out.push(dab(a.x + dx * f, a.y + dy * f, p, l, dir));\n      t += step;\n    }\n    carry = t - len;\n  }\n  return out;\n}\n\n/** The coverage of a brush stroke along `samples` (build-up towards each dab's opacity) and its bounds. */\nexport function pathStrokeCoverage(samples: readonly PathSample[], options: PathStrokeOptions): { coverage: CoverageMap; bounds: RasterRect | null; dabs: number } {\n  const brush = normalizeBrush(options.brush);\n  const coverage = new CoverageMap();\n  const dabs = pathStrokeDabs(samples, options);\n  let buf = new Float32Array(0);\n  let bounds: RasterRect | null = null;\n  for (const d of dabs) {\n    const rect = dabRect(d, brush.hardness);\n    const n = rect.width * rect.height;\n    if (n <= 0) continue;\n    if (buf.length < n) buf = new Float32Array(n);\n    const vals = buf.subarray(0, n);\n    rasterizeDab(d, brush.hardness, rect, vals);\n    coverage.accumulate(rect, vals, d.opacity);\n    if (!bounds) bounds = { ...rect };\n    else {\n      const x = Math.min(bounds.x, rect.x);\n      const y = Math.min(bounds.y, rect.y);\n      bounds = { x, y, width: Math.max(bounds.x + bounds.width, rect.x + rect.width) - x, height: Math.max(bounds.y + bounds.height, rect.y + rect.height) - y };\n    }\n  }\n  return { coverage, bounds, dabs: dabs.length };\n}\n\nexport interface PaintPathOptions extends PathStrokeOptions {\n  /** RGBA 0..255 of the paint. */\n  color: readonly [number, number, number, number];\n  /** `erase` removes paint instead (default `paint`). */\n  mode?: 'paint' | 'erase';\n  /** Blend mode (default the brush's). */\n  blend?: BlendMode;\n  /** Layer offset: layer pixel = document pixel − offset (default 0, 0). */\n  offset?: { x: number; y: number };\n  lockTransparency?: boolean;\n  /** Where paint may land (canvas-sized coverage 0..255), or none. */\n  selection?: { width: number; height: number; data: ArrayLike<number> } | null;\n}\n\n/**\n * Paints a brush stroke along `samples` onto an RGBA layer surface and returns the new surface\n * (the input is not changed; untouched tiles are shared) with the bounds it touched.\n */\nexport function paintPathStroke(surface: TiledSurface, samples: readonly PathSample[], options: PaintPathOptions): { surface: TiledSurface; bounds: RasterRect | null; dabs: number } {\n  if (surface.channels !== 4) throw new Error('paintPathStroke paints RGBA surfaces (4 channels).');\n  const brush = normalizeBrush(options.brush);\n  const { coverage, bounds, dabs } = pathStrokeCoverage(samples, options);\n  if (!bounds) return { surface, bounds: null, dabs };\n  const offset = options.offset ?? { x: 0, y: 0 };\n  const apply = {\n    mode: options.mode ?? 'paint',\n    color: options.color,\n    background: [0, 0, 0, 0] as const,\n    opacity: brush.opacity,\n    blend: options.blend ?? brush.blend,\n    lockTransparency: options.lockTransparency ?? false,\n    selection: options.selection ?? null,\n    offset,\n  };\n  const tiles = new Map(surface.tiles);\n  for (const { tx, ty } of tilesInRect({ x: bounds.x - offset.x, y: bounds.y - offset.y, width: bounds.width, height: bounds.height })) {\n    const key = tileKey(tx, ty);\n    const src = surface.tiles.get(key)?.data;\n    const base = src && src.length === TILE * TILE * 4 ? src : new Uint8ClampedArray(TILE * TILE * 4);\n    const t = finishTile(applyStrokeToTile(coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);\n    if (t) tiles.set(key, t);\n    else tiles.delete(key);\n  }\n  return { surface: new TiledSurface(4, tiles, surface.defaultValue), bounds, dabs };\n}\n"],"mappings":"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","names":["w","t"]}

package/dist/{export-DMOuzgZZ.d.cts → export-B_jO2PrH.d.cts}

@@ -4,8 +4,8 @@ import { b as BuiltinProfileId, j as Intent, P as Profile, T as Transform, d as
 import { A as AffineMatrix, Q as Quad, a as WarpMesh, V as Vec2$1, H as Homography } from './types-CwMPoRMU.cjs';
 import { B as BezierPath } from './bezier-BfwIbVTl.cjs';
 import { b as TextRun, P as ParagraphRun, T as TextShaper, c as ParagraphStyle, d as TextStyle, L as LaidFragment, W as WarpPreset, e as TextLayout } from './warp-B39VsOtd.cjs';
-import { w as VectorSubpath, o as Vec2 } from './types-Tfly4Aya.cjs';
-import { B as BrushSettings, M as MixerSettings, a as MixerLoad, R as RetouchSettings, S as StrokeCoverage, b as MixerTarget, c as MixerStroke, d as RetouchApply, e as StrokePoint, f as RetouchPaint, C as CoverageMap, P as PaintTileTarget, g as StrokeApply } from './flow-4-OC-UkQ.cjs';
+import { w as VectorSubpath, o as Vec2 } from './types-Dq-8qgoo.cjs';
+import { B as BrushSettings, M as MixerSettings, a as MixerLoad, R as RetouchSettings, S as StrokeCoverage, b as MixerTarget, c as MixerStroke, d as RetouchApply, e as StrokePoint, f as RetouchPaint, C as CoverageMap, P as PaintTileTarget, g as StrokeApply } from './flow-A2Dj-69w.cjs';
 
 /**
  * A selection: one 8-bit coverage value per image pixel (0 = not selected, 255 = fully
@@ -750,6 +750,8 @@ interface SerializedRasterMask {
     /** `false`: unlinked from the layer's pixels. */
     linked?: boolean;
     source?: DepthMaskOptions;
+    /** 16- or 32-bit coverage (one sample per pixel; the PNG asset is its 8-bit rendering). */
+    deep?: SerializedDeepPixels;
 }
 interface SerializedLayerBase {
     id: string;
@@ -790,8 +792,9 @@ interface SerializedPixelLayer extends SerializedLayerBase {
     deep?: SerializedDeepPixels;
 }
 /**
- * High bit depth pixels: `width × height` interleaved RGBA samples at (`x`, `y`) in layer space,
- * little-endian (`Uint16` for 16-bit, `Float32` linear light for 32-bit), deflated and base64.
+ * High bit depth pixels: `width × height` interleaved RGBA samples at (`x`, `y`) in layer space
+ * (one coverage sample per pixel for a mask), little-endian (`Uint16` for 16-bit, `Float32`
+ * linear light for 32-bit; coverage 0..1 for a mask), deflated and base64.
  */
 interface SerializedDeepPixels {
     depth: 16 | 32;
@@ -2740,6 +2743,13 @@ declare class PaintStrokeSession {
     /** Brush and eraser strokes on a 16- or 32-bit document: the deep samples of each touched tile. */
     private readonly deep;
     private readonly liveDeep;
+    /**
+     * Mixer Brush, Smudge and Sponge on a 16- or 32-bit layer: they read and write float working
+     * tiles on the 8-bit 0..255 sRGB-encoded scale, which keep the fractions bytes would round away.
+     */
+    private readonly dabDeep;
+    private readonly work;
+    private readonly workRead;
     constructor(controller: ImageEditorController, target: {
         id: string;
         channel: LayerTarget;
@@ -2747,6 +2757,10 @@ declare class PaintStrokeSession {
     }, stroke: StrokeCoverage | MixerStrokeInit | RetouchStrokeInit, apply: StrokeApply, 
     /** Composite brush / eraser strokes at this bit depth (layers only); `null` for 8 bits. */
     depth?: 16 | 32 | null);
+    /** The pre-stroke tile as a float working tile (cached; `null`: transparent). */
+    private readWork;
+    /** Clone, healing and the spot-heal trail at depth: `paint` through the coverage on the float working tile. */
+    private retouchDeepTile;
     /** The new tile of a coverage stroke over the pre-stroke tile `src`. */
     private compositeTile;
     /** The live pixels a mixer stroke reads and writes; base tiles are copied on first write. */

package/dist/{export-Dul1SbPv.d.ts → export-Ds8Ccw0K.d.ts}

@@ -4,8 +4,8 @@ import { b as BuiltinProfileId, j as Intent, P as Profile, T as Transform, d as
 import { A as AffineMatrix, Q as Quad, a as WarpMesh, V as Vec2$1, H as Homography } from './types-CwMPoRMU.js';
 import { B as BezierPath } from './bezier-DYBvLgUH.js';
 import { b as TextRun, P as ParagraphRun, T as TextShaper, c as ParagraphStyle, d as TextStyle, L as LaidFragment, W as WarpPreset, e as TextLayout } from './warp-DMN30aY6.js';
-import { w as VectorSubpath, o as Vec2 } from './types-CDLGhAZp.js';
-import { B as BrushSettings, M as MixerSettings, a as MixerLoad, R as RetouchSettings, S as StrokeCoverage, b as MixerTarget, c as MixerStroke, d as RetouchApply, e as StrokePoint, f as RetouchPaint, C as CoverageMap, P as PaintTileTarget, g as StrokeApply } from './flow-Cb7lkPm8.js';
+import { w as VectorSubpath, o as Vec2 } from './types-TrSSh_RB.js';
+import { B as BrushSettings, M as MixerSettings, a as MixerLoad, R as RetouchSettings, S as StrokeCoverage, b as MixerTarget, c as MixerStroke, d as RetouchApply, e as StrokePoint, f as RetouchPaint, C as CoverageMap, P as PaintTileTarget, g as StrokeApply } from './flow-C95atNoQ.js';
 
 /**
  * A selection: one 8-bit coverage value per image pixel (0 = not selected, 255 = fully
@@ -750,6 +750,8 @@ interface SerializedRasterMask {
     /** `false`: unlinked from the layer's pixels. */
     linked?: boolean;
     source?: DepthMaskOptions;
+    /** 16- or 32-bit coverage (one sample per pixel; the PNG asset is its 8-bit rendering). */
+    deep?: SerializedDeepPixels;
 }
 interface SerializedLayerBase {
     id: string;
@@ -790,8 +792,9 @@ interface SerializedPixelLayer extends SerializedLayerBase {
     deep?: SerializedDeepPixels;
 }
 /**
- * High bit depth pixels: `width × height` interleaved RGBA samples at (`x`, `y`) in layer space,
- * little-endian (`Uint16` for 16-bit, `Float32` linear light for 32-bit), deflated and base64.
+ * High bit depth pixels: `width × height` interleaved RGBA samples at (`x`, `y`) in layer space
+ * (one coverage sample per pixel for a mask), little-endian (`Uint16` for 16-bit, `Float32`
+ * linear light for 32-bit; coverage 0..1 for a mask), deflated and base64.
  */
 interface SerializedDeepPixels {
     depth: 16 | 32;
@@ -2740,6 +2743,13 @@ declare class PaintStrokeSession {
     /** Brush and eraser strokes on a 16- or 32-bit document: the deep samples of each touched tile. */
     private readonly deep;
     private readonly liveDeep;
+    /**
+     * Mixer Brush, Smudge and Sponge on a 16- or 32-bit layer: they read and write float working
+     * tiles on the 8-bit 0..255 sRGB-encoded scale, which keep the fractions bytes would round away.
+     */
+    private readonly dabDeep;
+    private readonly work;
+    private readonly workRead;
     constructor(controller: ImageEditorController, target: {
         id: string;
         channel: LayerTarget;
@@ -2747,6 +2757,10 @@ declare class PaintStrokeSession {
     }, stroke: StrokeCoverage | MixerStrokeInit | RetouchStrokeInit, apply: StrokeApply, 
     /** Composite brush / eraser strokes at this bit depth (layers only); `null` for 8 bits. */
     depth?: 16 | 32 | null);
+    /** The pre-stroke tile as a float working tile (cached; `null`: transparent). */
+    private readWork;
+    /** Clone, healing and the spot-heal trail at depth: `paint` through the coverage on the float working tile. */
+    private retouchDeepTile;
     /** The new tile of a coverage stroke over the pre-stroke tile `src`. */
     private compositeTile;
     /** The live pixels a mixer stroke reads and writes; base tiles are copied on first write. */

package/dist/{flow-4-OC-UkQ.d.cts → flow-A2Dj-69w.d.cts}

@@ -163,11 +163,13 @@ declare function applyStrokeToTile(coverage: CoverageMap, tileData: Uint8Clamped
  * samples (`Uint16Array` sRGB or `Float32Array` linear light, see `raster/deep`) of the target's
  * tile (tx, ty) as it was before the stroke, and returns new samples of the same type. Blending
  * runs in float in the samples' own space (sRGB at 16 bits, linear light at 32 bits); the paint
- * colours are 8-bit sRGB and converted. Layers only (masks stay 8-bit).
+ * colours are 8-bit sRGB and converted. With `options.channels` 1, a mask's coverage samples
+ * (16-bit, or float 0..1) move towards the paint's grey, as `applyStrokeToTile` does at 8 bits.
  */
 declare function applyStrokeToDeepTile(coverage: CoverageMap, samples: Uint16Array | Float32Array, tx: number, ty: number, s: StrokeApply, options?: {
     into?: Uint16Array | Float32Array;
     region?: RasterRect;
+    channels?: 1 | 4;
 }): Uint16Array | Float32Array;
 /** Tile coordinates of coverage tile keys (for callers that track dirty tiles). */
 declare function coverageTileCoord(key: TileKey): {
@@ -274,12 +276,19 @@ declare class PaintExchange {
     /** 3. The reservoir drains. */
     drain(): void;
 }
+/**
+ * A brush's working tile: 8-bit bytes, or (on a 16- or 32-bit document) floats on the same
+ * 0..255 sRGB-encoded scale, which keep the fractions an 8-bit tile would round away.
+ */
+type PaintPixels = Uint8ClampedArray | Float32Array;
+/** Writes `v` (0..1) into a working tile: rounded for bytes, kept exact (not below 0) for floats. */
+declare function put255(px: PaintPixels, i: number, v: number): void;
 /** The pixels a brush reads and writes (RGBA tiles in layer space). */
 interface PaintTileTarget {
     /** The tile (TILE × TILE × 4) at (tx, ty) as it is now, or `null` when it is fully transparent. */
-    readTile(tx: number, ty: number): Uint8ClampedArray | null;
+    readTile(tx: number, ty: number): PaintPixels | null;
     /** A writable tile at (tx, ty), returned by `readTile` from then on. */
-    writeTile(tx: number, ty: number): Uint8ClampedArray;
+    writeTile(tx: number, ty: number): PaintPixels;
     /** Layer offset: layer pixel = document pixel − offset. */
     offset: {
         x: number;
@@ -336,7 +345,7 @@ declare class TileMedium implements PaintMedium {
      */
     locate(dx: number, dy: number, write: boolean): number;
     /** The tile `locate` last found. */
-    get pixels(): Uint8ClampedArray;
+    get pixels(): PaintPixels;
     /** Selection coverage at a document pixel, 0..1 (1 without a selection). */
     selectionAt(dx: number, dy: number): number;
     sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null;
@@ -579,6 +588,7 @@ interface PixelSource {
  * One-channel tiles read as grey (alpha 255). Tiles are cached, so make one per stroke.
  */
 declare class TilePixelSource implements PixelSource {
+    /** A tile's bytes, or a float working tile on the same 0..255 scale (16 / 32 bits). */
     private readonly readTile;
     readonly channels: 1 | 4;
     readonly offset: {
@@ -588,7 +598,9 @@ declare class TilePixelSource implements PixelSource {
     private readonly cache;
     private lastKey;
     private last;
-    constructor(readTile: (tx: number, ty: number) => Uint8ClampedArray | null, channels: 1 | 4, offset?: {
+    constructor(
+    /** A tile's bytes, or a float working tile on the same 0..255 scale (16 / 32 bits). */
+    readTile: (tx: number, ty: number) => PaintPixels | null, channels: 1 | 4, offset?: {
         x: number;
         y: number;
     });
@@ -648,10 +660,10 @@ interface RetouchApply {
  * Tone paint keeps alpha; source and colour paint composite with `blend` (source-over by
  * default), keeping alpha on a locked layer.
  */
-declare function applyRetouchToTile(coverage: CoverageMap, tileData: Uint8ClampedArray, channels: 1 | 4, tx: number, ty: number, paint: RetouchPaint, s: RetouchApply, options?: {
-    into?: Uint8ClampedArray;
+declare function applyRetouchToTile<T extends PaintPixels>(coverage: CoverageMap, tileData: T, channels: 1 | 4, tx: number, ty: number, paint: RetouchPaint, s: RetouchApply, options?: {
+    into?: T;
     region?: RasterRect;
-}): Uint8ClampedArray;
+}): T;
 /**
  * Dodge / Burn at 16 or 32 bits: `applyRetouchToTile`'s tone paint on a layer tile's deep samples
  * (`Uint16Array` sRGB-encoded, or `Float32Array` linear light, RGBA). The tone curves work on
@@ -1280,4 +1292,4 @@ declare function normalizeFlow(raw?: Partial<WetFlowSpec>, base?: WetFlowSpec):
 /** The flow field of a spec on a canvas, or `null` for `none` (strength is applied by the world). */
 declare function flowField(spec: WetFlowSpec, width: number, height: number): WetFlowField | null;
 
-export { FLAG_RIGHT as $, normalizeWetParams as A, type BrushSettings as B, CoverageMap as C, type Dab as D, wetSupport as E, type BlenderScratch as F, DEFAULT_BLENDER as G, DEFAULT_BRUSH as H, DEFAULT_MIXER as I, DEFAULT_RETOUCH as J, DEFAULT_SMUDGE as K, DEFAULT_WET_PAPER as L, type MixerSettings as M, DRY_EPS as N, DabWalker as O, type PaintTileTarget as P, EMPTY_MIXER_LOAD as Q, type RetouchSettings as R, StrokeCoverage as S, TileMedium as T, EX as U, EY as V, WetWorld as W, type ExchangeRates as X, FLAG_ALIVE as Y, FLAG_BOTTOM as Z, FLAG_LEFT as _, type MixerLoad as a, applyStrokeToTile as a$, FLAG_TOP as a0, FLAG_WET as a1, FLAT as a2, FREE_INTERVAL as a3, MAX_BATCH as a4, MAX_TILT_ACCEL as a5, MAX_WET_LANES as a6, MAX_WET_SLOTS as a7, MIXER_DRAIN as a8, MIXER_PICKUP_RATE as a9, type RetouchSample as aA, SET_PLANES as aB, SLOT_BYTES as aC, SLOT_PLANES as aD, SLOT_SIDE as aE, SPOT_HEAL_TYPES as aF, STRIP as aG, type SmudgeDab as aH, SmudgeTip as aI, type SpotHealType as aJ, TONE_RANGES as aK, type TileMediumOptions as aL, TilePixelSource as aM, type ToneRange as aN, U_MAX as aO, W9 as aP, WET_TILE as aQ, type WetFlowField as aR, type WetKernelKind as aS, type WetLaneOptions as aT, type WetLaneStats as aU, type WetPaper as aV, type WetWorkerLayout as aW, WetWorkerPool as aX, WetWorldError as aY, applyRetouchToTile as aZ, applyStrokeToDeepTile as a_, MIXING_MODELS as aa, OPP as ab, PAPER_CAPACITY as ac, PARAM as ad, PARAM_FLOATS as ae, PIGMENT_CHANNELS as af, PLANE as ag, PLANE_BYTES as ah, P_D0 as ai, P_EDGE as aj, P_FX as ak, P_FY as al, P_H as am, P_P0 as an, P_RHO as ao, P_SW as ap, P_UX as aq, P_UY as ar, PaintExchange as as, type PaintMedium as at, type PaintSample as au, type PixelSource as av, RETOUCH_SAMPLES as aw, RegionPixelSource as ax, type RetouchDabEffect as ay, RetouchDabStroke as az, type MixerTarget as b, applyToneToDeepTile as b0, blendRadius as b1, blenderDab as b2, canShareMemory as b3, cleanMixer as b4, coverageTileCoord as b5, createBlenderScratch as b6, dabCoverage as b7, dabRect as b8, dodgeBurn as b9, spongeEffect as bA, spotHealPixels as bB, spotHealWindow as bC, tipFalloff as bD, tipReach as bE, tipShape as bF, toneOf as bG, walkDabs as bH, wetSimdSupported as bI, dodgeBurnCurve as ba, dsincos as bb, edgeBits as bc, exchangeRates as bd, flowField as be, healPixels as bf, latticeViscosity as bg, loadMixer as bh, loadWetKernel as bi, luma as bj, mixerRates as bk, normalizeBlender as bl, normalizeBrush as bm, normalizeMixer as bn, normalizeRetouch as bo, normalizeSmudge as bp, normalizeTilt as bq, packWetParams as br, perDabStrength as bs, rasterizeDab as bt, readSourceRegion as bu, rgbaViewOfGrey as bv, saturationOf as bw, smoothPoints as bx, smudgeEffect as by, sponge as bz, MixerStroke as c, type RetouchApply as d, type StrokePoint as e, type RetouchPaint as f, type StrokeApply as g, type MixingModel as h, type BlenderSettings as i, type SmudgeSettings as j, type WetTilt as k, type WetParams as l, type WetFlowSpec as m, type RgbTriple as n, type WetWorldOptions as o, type WetBackendInfo as p, type WetSnapshot as q, type WetPaperInput as r, DEFAULT_FLOW as s, DEFAULT_WET_PARAMS as t, MAX_BRUSH_SIZE as u, WET_FLOW_KINDS as v, WET_PARAM_KEYS as w, type WetFlowKind as x, type WetSupport as y, normalizeFlow as z };
+export { FLAG_RIGHT as $, normalizeWetParams as A, type BrushSettings as B, CoverageMap as C, type Dab as D, wetSupport as E, type BlenderScratch as F, DEFAULT_BLENDER as G, DEFAULT_BRUSH as H, DEFAULT_MIXER as I, DEFAULT_RETOUCH as J, DEFAULT_SMUDGE as K, DEFAULT_WET_PAPER as L, type MixerSettings as M, DRY_EPS as N, DabWalker as O, type PaintTileTarget as P, EMPTY_MIXER_LOAD as Q, type RetouchSettings as R, StrokeCoverage as S, TileMedium as T, EX as U, EY as V, WetWorld as W, type ExchangeRates as X, FLAG_ALIVE as Y, FLAG_BOTTOM as Z, FLAG_LEFT as _, type MixerLoad as a, applyStrokeToDeepTile as a$, FLAG_TOP as a0, FLAG_WET as a1, FLAT as a2, FREE_INTERVAL as a3, MAX_BATCH as a4, MAX_TILT_ACCEL as a5, MAX_WET_LANES as a6, MAX_WET_SLOTS as a7, MIXER_DRAIN as a8, MIXER_PICKUP_RATE as a9, RetouchDabStroke as aA, type RetouchSample as aB, SET_PLANES as aC, SLOT_BYTES as aD, SLOT_PLANES as aE, SLOT_SIDE as aF, SPOT_HEAL_TYPES as aG, STRIP as aH, type SmudgeDab as aI, SmudgeTip as aJ, type SpotHealType as aK, TONE_RANGES as aL, type TileMediumOptions as aM, TilePixelSource as aN, type ToneRange as aO, U_MAX as aP, W9 as aQ, WET_TILE as aR, type WetFlowField as aS, type WetKernelKind as aT, type WetLaneOptions as aU, type WetLaneStats as aV, type WetPaper as aW, type WetWorkerLayout as aX, WetWorkerPool as aY, WetWorldError as aZ, applyRetouchToTile as a_, MIXING_MODELS as aa, OPP as ab, PAPER_CAPACITY as ac, PARAM as ad, PARAM_FLOATS as ae, PIGMENT_CHANNELS as af, PLANE as ag, PLANE_BYTES as ah, P_D0 as ai, P_EDGE as aj, P_FX as ak, P_FY as al, P_H as am, P_P0 as an, P_RHO as ao, P_SW as ap, P_UX as aq, P_UY as ar, PaintExchange as as, type PaintMedium as at, type PaintPixels as au, type PaintSample as av, type PixelSource as aw, RETOUCH_SAMPLES as ax, RegionPixelSource as ay, type RetouchDabEffect as az, type MixerTarget as b, applyStrokeToTile as b0, applyToneToDeepTile as b1, blendRadius as b2, blenderDab as b3, canShareMemory as b4, cleanMixer as b5, coverageTileCoord as b6, createBlenderScratch as b7, dabCoverage as b8, dabRect as b9, smudgeEffect as bA, sponge as bB, spongeEffect as bC, spotHealPixels as bD, spotHealWindow as bE, tipFalloff as bF, tipReach as bG, tipShape as bH, toneOf as bI, walkDabs as bJ, wetSimdSupported as bK, dodgeBurn as ba, dodgeBurnCurve as bb, dsincos as bc, edgeBits as bd, exchangeRates as be, flowField as bf, healPixels as bg, latticeViscosity as bh, loadMixer as bi, loadWetKernel as bj, luma as bk, mixerRates as bl, normalizeBlender as bm, normalizeBrush as bn, normalizeMixer as bo, normalizeRetouch as bp, normalizeSmudge as bq, normalizeTilt as br, packWetParams as bs, perDabStrength as bt, put255 as bu, rasterizeDab as bv, readSourceRegion as bw, rgbaViewOfGrey as bx, saturationOf as by, smoothPoints as bz, MixerStroke as c, type RetouchApply as d, type StrokePoint as e, type RetouchPaint as f, type StrokeApply as g, type MixingModel as h, type BlenderSettings as i, type SmudgeSettings as j, type WetTilt as k, type WetParams as l, type WetFlowSpec as m, type RgbTriple as n, type WetWorldOptions as o, type WetBackendInfo as p, type WetSnapshot as q, type WetPaperInput as r, DEFAULT_FLOW as s, DEFAULT_WET_PARAMS as t, MAX_BRUSH_SIZE as u, WET_FLOW_KINDS as v, WET_PARAM_KEYS as w, type WetFlowKind as x, type WetSupport as y, normalizeFlow as z };

package/dist/{flow-Cb7lkPm8.d.ts → flow-C95atNoQ.d.ts}

@@ -163,11 +163,13 @@ declare function applyStrokeToTile(coverage: CoverageMap, tileData: Uint8Clamped
  * samples (`Uint16Array` sRGB or `Float32Array` linear light, see `raster/deep`) of the target's
  * tile (tx, ty) as it was before the stroke, and returns new samples of the same type. Blending
  * runs in float in the samples' own space (sRGB at 16 bits, linear light at 32 bits); the paint
- * colours are 8-bit sRGB and converted. Layers only (masks stay 8-bit).
+ * colours are 8-bit sRGB and converted. With `options.channels` 1, a mask's coverage samples
+ * (16-bit, or float 0..1) move towards the paint's grey, as `applyStrokeToTile` does at 8 bits.
  */
 declare function applyStrokeToDeepTile(coverage: CoverageMap, samples: Uint16Array | Float32Array, tx: number, ty: number, s: StrokeApply, options?: {
     into?: Uint16Array | Float32Array;
     region?: RasterRect;
+    channels?: 1 | 4;
 }): Uint16Array | Float32Array;
 /** Tile coordinates of coverage tile keys (for callers that track dirty tiles). */
 declare function coverageTileCoord(key: TileKey): {
@@ -274,12 +276,19 @@ declare class PaintExchange {
     /** 3. The reservoir drains. */
     drain(): void;
 }
+/**
+ * A brush's working tile: 8-bit bytes, or (on a 16- or 32-bit document) floats on the same
+ * 0..255 sRGB-encoded scale, which keep the fractions an 8-bit tile would round away.
+ */
+type PaintPixels = Uint8ClampedArray | Float32Array;
+/** Writes `v` (0..1) into a working tile: rounded for bytes, kept exact (not below 0) for floats. */
+declare function put255(px: PaintPixels, i: number, v: number): void;
 /** The pixels a brush reads and writes (RGBA tiles in layer space). */
 interface PaintTileTarget {
     /** The tile (TILE × TILE × 4) at (tx, ty) as it is now, or `null` when it is fully transparent. */
-    readTile(tx: number, ty: number): Uint8ClampedArray | null;
+    readTile(tx: number, ty: number): PaintPixels | null;
     /** A writable tile at (tx, ty), returned by `readTile` from then on. */
-    writeTile(tx: number, ty: number): Uint8ClampedArray;
+    writeTile(tx: number, ty: number): PaintPixels;
     /** Layer offset: layer pixel = document pixel − offset. */
     offset: {
         x: number;
@@ -336,7 +345,7 @@ declare class TileMedium implements PaintMedium {
      */
     locate(dx: number, dy: number, write: boolean): number;
     /** The tile `locate` last found. */
-    get pixels(): Uint8ClampedArray;
+    get pixels(): PaintPixels;
     /** Selection coverage at a document pixel, 0..1 (1 without a selection). */
     selectionAt(dx: number, dy: number): number;
     sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null;
@@ -579,6 +588,7 @@ interface PixelSource {
  * One-channel tiles read as grey (alpha 255). Tiles are cached, so make one per stroke.
  */
 declare class TilePixelSource implements PixelSource {
+    /** A tile's bytes, or a float working tile on the same 0..255 scale (16 / 32 bits). */
     private readonly readTile;
     readonly channels: 1 | 4;
     readonly offset: {
@@ -588,7 +598,9 @@ declare class TilePixelSource implements PixelSource {
     private readonly cache;
     private lastKey;
     private last;
-    constructor(readTile: (tx: number, ty: number) => Uint8ClampedArray | null, channels: 1 | 4, offset?: {
+    constructor(
+    /** A tile's bytes, or a float working tile on the same 0..255 scale (16 / 32 bits). */
+    readTile: (tx: number, ty: number) => PaintPixels | null, channels: 1 | 4, offset?: {
         x: number;
         y: number;
     });
@@ -648,10 +660,10 @@ interface RetouchApply {
  * Tone paint keeps alpha; source and colour paint composite with `blend` (source-over by
  * default), keeping alpha on a locked layer.
  */
-declare function applyRetouchToTile(coverage: CoverageMap, tileData: Uint8ClampedArray, channels: 1 | 4, tx: number, ty: number, paint: RetouchPaint, s: RetouchApply, options?: {
-    into?: Uint8ClampedArray;
+declare function applyRetouchToTile<T extends PaintPixels>(coverage: CoverageMap, tileData: T, channels: 1 | 4, tx: number, ty: number, paint: RetouchPaint, s: RetouchApply, options?: {
+    into?: T;
     region?: RasterRect;
-}): Uint8ClampedArray;
+}): T;
 /**
  * Dodge / Burn at 16 or 32 bits: `applyRetouchToTile`'s tone paint on a layer tile's deep samples
  * (`Uint16Array` sRGB-encoded, or `Float32Array` linear light, RGBA). The tone curves work on
@@ -1280,4 +1292,4 @@ declare function normalizeFlow(raw?: Partial<WetFlowSpec>, base?: WetFlowSpec):
 /** The flow field of a spec on a canvas, or `null` for `none` (strength is applied by the world). */
 declare function flowField(spec: WetFlowSpec, width: number, height: number): WetFlowField | null;
 
-export { FLAG_RIGHT as $, normalizeWetParams as A, type BrushSettings as B, CoverageMap as C, type Dab as D, wetSupport as E, type BlenderScratch as F, DEFAULT_BLENDER as G, DEFAULT_BRUSH as H, DEFAULT_MIXER as I, DEFAULT_RETOUCH as J, DEFAULT_SMUDGE as K, DEFAULT_WET_PAPER as L, type MixerSettings as M, DRY_EPS as N, DabWalker as O, type PaintTileTarget as P, EMPTY_MIXER_LOAD as Q, type RetouchSettings as R, StrokeCoverage as S, TileMedium as T, EX as U, EY as V, WetWorld as W, type ExchangeRates as X, FLAG_ALIVE as Y, FLAG_BOTTOM as Z, FLAG_LEFT as _, type MixerLoad as a, applyStrokeToTile as a$, FLAG_TOP as a0, FLAG_WET as a1, FLAT as a2, FREE_INTERVAL as a3, MAX_BATCH as a4, MAX_TILT_ACCEL as a5, MAX_WET_LANES as a6, MAX_WET_SLOTS as a7, MIXER_DRAIN as a8, MIXER_PICKUP_RATE as a9, type RetouchSample as aA, SET_PLANES as aB, SLOT_BYTES as aC, SLOT_PLANES as aD, SLOT_SIDE as aE, SPOT_HEAL_TYPES as aF, STRIP as aG, type SmudgeDab as aH, SmudgeTip as aI, type SpotHealType as aJ, TONE_RANGES as aK, type TileMediumOptions as aL, TilePixelSource as aM, type ToneRange as aN, U_MAX as aO, W9 as aP, WET_TILE as aQ, type WetFlowField as aR, type WetKernelKind as aS, type WetLaneOptions as aT, type WetLaneStats as aU, type WetPaper as aV, type WetWorkerLayout as aW, WetWorkerPool as aX, WetWorldError as aY, applyRetouchToTile as aZ, applyStrokeToDeepTile as a_, MIXING_MODELS as aa, OPP as ab, PAPER_CAPACITY as ac, PARAM as ad, PARAM_FLOATS as ae, PIGMENT_CHANNELS as af, PLANE as ag, PLANE_BYTES as ah, P_D0 as ai, P_EDGE as aj, P_FX as ak, P_FY as al, P_H as am, P_P0 as an, P_RHO as ao, P_SW as ap, P_UX as aq, P_UY as ar, PaintExchange as as, type PaintMedium as at, type PaintSample as au, type PixelSource as av, RETOUCH_SAMPLES as aw, RegionPixelSource as ax, type RetouchDabEffect as ay, RetouchDabStroke as az, type MixerTarget as b, applyToneToDeepTile as b0, blendRadius as b1, blenderDab as b2, canShareMemory as b3, cleanMixer as b4, coverageTileCoord as b5, createBlenderScratch as b6, dabCoverage as b7, dabRect as b8, dodgeBurn as b9, spongeEffect as bA, spotHealPixels as bB, spotHealWindow as bC, tipFalloff as bD, tipReach as bE, tipShape as bF, toneOf as bG, walkDabs as bH, wetSimdSupported as bI, dodgeBurnCurve as ba, dsincos as bb, edgeBits as bc, exchangeRates as bd, flowField as be, healPixels as bf, latticeViscosity as bg, loadMixer as bh, loadWetKernel as bi, luma as bj, mixerRates as bk, normalizeBlender as bl, normalizeBrush as bm, normalizeMixer as bn, normalizeRetouch as bo, normalizeSmudge as bp, normalizeTilt as bq, packWetParams as br, perDabStrength as bs, rasterizeDab as bt, readSourceRegion as bu, rgbaViewOfGrey as bv, saturationOf as bw, smoothPoints as bx, smudgeEffect as by, sponge as bz, MixerStroke as c, type RetouchApply as d, type StrokePoint as e, type RetouchPaint as f, type StrokeApply as g, type MixingModel as h, type BlenderSettings as i, type SmudgeSettings as j, type WetTilt as k, type WetParams as l, type WetFlowSpec as m, type RgbTriple as n, type WetWorldOptions as o, type WetBackendInfo as p, type WetSnapshot as q, type WetPaperInput as r, DEFAULT_FLOW as s, DEFAULT_WET_PARAMS as t, MAX_BRUSH_SIZE as u, WET_FLOW_KINDS as v, WET_PARAM_KEYS as w, type WetFlowKind as x, type WetSupport as y, normalizeFlow as z };
+export { FLAG_RIGHT as $, normalizeWetParams as A, type BrushSettings as B, CoverageMap as C, type Dab as D, wetSupport as E, type BlenderScratch as F, DEFAULT_BLENDER as G, DEFAULT_BRUSH as H, DEFAULT_MIXER as I, DEFAULT_RETOUCH as J, DEFAULT_SMUDGE as K, DEFAULT_WET_PAPER as L, type MixerSettings as M, DRY_EPS as N, DabWalker as O, type PaintTileTarget as P, EMPTY_MIXER_LOAD as Q, type RetouchSettings as R, StrokeCoverage as S, TileMedium as T, EX as U, EY as V, WetWorld as W, type ExchangeRates as X, FLAG_ALIVE as Y, FLAG_BOTTOM as Z, FLAG_LEFT as _, type MixerLoad as a, applyStrokeToDeepTile as a$, FLAG_TOP as a0, FLAG_WET as a1, FLAT as a2, FREE_INTERVAL as a3, MAX_BATCH as a4, MAX_TILT_ACCEL as a5, MAX_WET_LANES as a6, MAX_WET_SLOTS as a7, MIXER_DRAIN as a8, MIXER_PICKUP_RATE as a9, RetouchDabStroke as aA, type RetouchSample as aB, SET_PLANES as aC, SLOT_BYTES as aD, SLOT_PLANES as aE, SLOT_SIDE as aF, SPOT_HEAL_TYPES as aG, STRIP as aH, type SmudgeDab as aI, SmudgeTip as aJ, type SpotHealType as aK, TONE_RANGES as aL, type TileMediumOptions as aM, TilePixelSource as aN, type ToneRange as aO, U_MAX as aP, W9 as aQ, WET_TILE as aR, type WetFlowField as aS, type WetKernelKind as aT, type WetLaneOptions as aU, type WetLaneStats as aV, type WetPaper as aW, type WetWorkerLayout as aX, WetWorkerPool as aY, WetWorldError as aZ, applyRetouchToTile as a_, MIXING_MODELS as aa, OPP as ab, PAPER_CAPACITY as ac, PARAM as ad, PARAM_FLOATS as ae, PIGMENT_CHANNELS as af, PLANE as ag, PLANE_BYTES as ah, P_D0 as ai, P_EDGE as aj, P_FX as ak, P_FY as al, P_H as am, P_P0 as an, P_RHO as ao, P_SW as ap, P_UX as aq, P_UY as ar, PaintExchange as as, type PaintMedium as at, type PaintPixels as au, type PaintSample as av, type PixelSource as aw, RETOUCH_SAMPLES as ax, RegionPixelSource as ay, type RetouchDabEffect as az, type MixerTarget as b, applyStrokeToTile as b0, applyToneToDeepTile as b1, blendRadius as b2, blenderDab as b3, canShareMemory as b4, cleanMixer as b5, coverageTileCoord as b6, createBlenderScratch as b7, dabCoverage as b8, dabRect as b9, smudgeEffect as bA, sponge as bB, spongeEffect as bC, spotHealPixels as bD, spotHealWindow as bE, tipFalloff as bF, tipReach as bG, tipShape as bH, toneOf as bI, walkDabs as bJ, wetSimdSupported as bK, dodgeBurn as ba, dodgeBurnCurve as bb, dsincos as bc, edgeBits as bd, exchangeRates as be, flowField as bf, healPixels as bg, latticeViscosity as bh, loadMixer as bi, loadWetKernel as bj, luma as bk, mixerRates as bl, normalizeBlender as bm, normalizeBrush as bn, normalizeMixer as bo, normalizeRetouch as bp, normalizeSmudge as bq, normalizeTilt as br, packWetParams as bs, perDabStrength as bt, put255 as bu, rasterizeDab as bv, readSourceRegion as bw, rgbaViewOfGrey as bx, saturationOf as by, smoothPoints as bz, MixerStroke as c, type RetouchApply as d, type StrokePoint as e, type RetouchPaint as f, type StrokeApply as g, type MixingModel as h, type BlenderSettings as i, type SmudgeSettings as j, type WetTilt as k, type WetParams as l, type WetFlowSpec as m, type RgbTriple as n, type WetWorldOptions as o, type WetBackendInfo as p, type WetSnapshot as q, type WetPaperInput as r, DEFAULT_FLOW as s, DEFAULT_WET_PARAMS as t, MAX_BRUSH_SIZE as u, WET_FLOW_KINDS as v, WET_PARAM_KEYS as w, type WetFlowKind as x, type WetSupport as y, normalizeFlow as z };