@pixerate/editor 0.258.0 → 0.260.0

package/dist/{chunk-WQCNC4DK.js → chunk-XC6DPRYI.js}

@@ -1,6 +1,25 @@
 import {
+  bestOffset,
+  contentAwareFill,
+  dilateMask,
+  maskBounds,
+  membraneFill,
+  seamlessClone
+} from "./chunk-VWEWY4FY.js";
+import {
+  DabWalker,
+  SmudgeTip,
+  TileMedium,
+  dabRect,
+  put255,
+  rasterizeDab
+} from "./chunk-GCVFEPJG.js";
+import {
+  blendPixel,
   createPigment,
-  mixPigments
+  mixPigments,
+  srgbDecode,
+  srgbEncode
 } from "./chunk-IRSTHLQQ.js";
 import {
   TILE,
@@ -80,6 +99,648 @@ function createPigmentTools() {
   return [mixColors];
 }
 
+// src/paint/retouch.ts
+var TONE_RANGES = ["shadows", "midtones", "highlights"];
+function luma(r, g, b) {
+  return 0.299 * r + 0.587 * g + 0.114 * b;
+}
+function dodgeBurnCurve(v, e, range, burn) {
+  const x = Math.max(0, v);
+  const k = Math.min(1, Math.max(0, e));
+  const c = Math.min(1, x);
+  if (range === "midtones") {
+    const w2 = Math.min(1, Math.max(0, 4 * x * (1 - x)));
+    return x + w2 * (Math.pow(c, burn ? 1 + k : 1 / (1 + k)) - x);
+  }
+  const w = range === "shadows" ? (1 - c) * (1 - c) : c * c;
+  return burn ? x - k * w * x : x + k * w * (1 - c);
+}
+function compressGamut(c, l) {
+  const L = Math.min(1, Math.max(0, l));
+  const lo = Math.min(c[0], c[1], c[2]);
+  const hi = Math.max(c[0], c[1], c[2]);
+  let t = 1;
+  if (hi > 1 && hi - L > 1e-9) t = Math.min(t, (1 - L) / (hi - L));
+  if (lo < 0 && L - lo > 1e-9) t = Math.min(t, L / (L - lo));
+  for (let i = 0; i < 3; i++) c[i] = L + (c[i] - L) * t;
+}
+function dodgeBurn(c, e, range, burn, protectTones) {
+  if (!(e > 0)) return c;
+  if (protectTones) {
+    const l = luma(c[0], c[1], c[2]);
+    const nl = dodgeBurnCurve(l, e, range, burn);
+    if (l > 1e-6) for (let i = 0; i < 3; i++) c[i] *= nl / l;
+    else c[0] = c[1] = c[2] = nl;
+    compressGamut(c, nl);
+  } else for (let i = 0; i < 3; i++) c[i] = dodgeBurnCurve(c[i], e, range, burn);
+  return c;
+}
+function saturationOf(r, g, b) {
+  const lo = Math.min(r, g, b);
+  const hi = Math.max(r, g, b);
+  return hi <= 1e-6 ? 0 : Math.min(1, Math.max(0, (hi - lo) / hi));
+}
+function sponge(c, amount, saturate, vibrance) {
+  let a = Math.min(1, Math.max(0, amount));
+  if (!(a > 0)) return c;
+  if (vibrance) {
+    const s = saturationOf(c[0], c[1], c[2]);
+    a *= saturate ? 1 - s : 0.25 + 0.75 * s;
+  }
+  const l = luma(c[0], c[1], c[2]);
+  const k = saturate ? 1 + a : 1 - a;
+  for (let i = 0; i < 3; i++) c[i] = l + (c[i] - l) * k;
+  compressGamut(c, l);
+  return c;
+}
+function perDabStrength(e, spacing) {
+  return 1 - Math.pow(1 - Math.min(1, Math.max(0, e)), Math.min(1, Math.max(0.01, spacing)));
+}
+var RETOUCH_SAMPLES = ["current", "current-below", "all"];
+var SPOT_HEAL_TYPES = ["proximity-match", "content-aware", "smooth"];
+var DEFAULT_RETOUCH = {
+  aligned: true,
+  sample: "current",
+  spotType: "proximity-match",
+  range: "midtones",
+  exposure: 0.5,
+  protectTones: true,
+  spongeMode: "desaturate",
+  vibrance: true,
+  strength: 0.5,
+  historySteps: 0
+};
+function normalizeRetouch(raw = {}, base = DEFAULT_RETOUCH) {
+  const unit2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+  const bool = (v, d) => typeof v === "boolean" ? v : d;
+  const pick = (v, all, d) => all.includes(v) ? v : d;
+  return {
+    aligned: bool(raw.aligned, base.aligned),
+    sample: pick(raw.sample, RETOUCH_SAMPLES, base.sample),
+    spotType: pick(raw.spotType, SPOT_HEAL_TYPES, base.spotType),
+    range: pick(raw.range, TONE_RANGES, base.range),
+    exposure: unit2(raw.exposure, base.exposure),
+    protectTones: bool(raw.protectTones, base.protectTones),
+    spongeMode: pick(raw.spongeMode, ["desaturate", "saturate"], base.spongeMode),
+    vibrance: bool(raw.vibrance, base.vibrance),
+    strength: unit2(raw.strength, base.strength),
+    historySteps: typeof raw.historySteps === "number" && Number.isFinite(raw.historySteps) ? Math.min(1e3, Math.max(0, Math.round(raw.historySteps))) : base.historySteps
+  };
+}
+function boxBlurPixels(data, w, h, n, r) {
+  if (r < 1) return;
+  if (n === 4) for (let i = 0; i < data.length; i += 4) for (let c = 0; c < 3; c++) data[i + c] *= data[i + 3] / 255;
+  const tmp = new Float32Array(data.length);
+  const k = 1 / (2 * r + 1);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < n; c++) {
+        let s = 0;
+        for (let d = -r; d <= r; d++) s += data[(y * w + Math.min(w - 1, Math.max(0, x + d))) * n + c];
+        tmp[(y * w + x) * n + c] = s * k;
+      }
+    }
+  }
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < n; c++) {
+        let s = 0;
+        for (let d = -r; d <= r; d++) s += tmp[(Math.min(h - 1, Math.max(0, y + d)) * w + x) * n + c];
+        data[(y * w + x) * n + c] = s * k;
+      }
+    }
+  }
+  if (n === 4) {
+    for (let i = 0; i < data.length; i += 4) {
+      const a = data[i + 3] / 255;
+      for (let c = 0; c < 3; c++) data[i + c] = a > 0 ? data[i + c] / a : 0;
+    }
+  }
+}
+function retouchFilter(data, w, h, n, kind, radius = 2, amount = 1) {
+  if (kind === "blur") {
+    boxBlurPixels(data, w, h, n, radius);
+    boxBlurPixels(data, w, h, n, radius);
+    return;
+  }
+  const soft = data.slice();
+  boxBlurPixels(soft, w, h, n, 1);
+  for (let i = 0; i < data.length; i++) {
+    if (n === 4 && (i & 3) === 3) continue;
+    const v = data[i] + amount * (data[i] - soft[i]);
+    data[i] = v > 0 ? v : 0;
+  }
+}
+var IDENTITY_CLONE_TRANSFORM = { scaleX: 1, scaleY: 1, rotate: 0 };
+function isIdentityCloneTransform(t) {
+  return t.scaleX === 1 && t.scaleY === 1 && (t.rotate % 360 + 360) % 360 === 0;
+}
+function cloneSamplePoint(t, source, anchor, x, y) {
+  const a = -t.rotate * Math.PI / 180;
+  const c = Math.cos(a);
+  const s = Math.sin(a);
+  const dx = x - anchor.x;
+  const dy = y - anchor.y;
+  return [source.x + (c * dx - s * dy) / t.scaleX, source.y + (s * dx + c * dy) / t.scaleY];
+}
+var TransformedPixelSource = class {
+  constructor(inner, map) {
+    this.inner = inner;
+    this.map = map;
+  }
+  inner;
+  map;
+  px = [0, 0, 0, 0];
+  sample(x, y, out) {
+    const [u, v] = this.map(x, y);
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 0;
+    for (let k = 0; k < 4; k++) {
+      const w = (k & 1 ? fx : 1 - fx) * (k & 2 ? fy : 1 - fy);
+      if (w <= 0) continue;
+      if (!this.inner.sample(x0 + (k & 1), y0 + (k >> 1), this.px)) continue;
+      const pa = this.px[3] * w;
+      r += this.px[0] * pa;
+      g += this.px[1] * pa;
+      b += this.px[2] * pa;
+      a += pa;
+    }
+    if (!(a > 0)) {
+      out[0] = out[1] = out[2] = out[3] = 0;
+      return false;
+    }
+    out[0] = r / a;
+    out[1] = g / a;
+    out[2] = b / a;
+    out[3] = a;
+    return true;
+  }
+};
+var TilePixelSource = class {
+  constructor(readTile, channels, offset = { x: 0, y: 0 }) {
+    this.readTile = readTile;
+    this.channels = channels;
+    this.offset = offset;
+  }
+  readTile;
+  channels;
+  offset;
+  cache = /* @__PURE__ */ new Map();
+  lastKey = NaN;
+  last = null;
+  sample(x, y, out) {
+    const lx = x - this.offset.x;
+    const ly = y - this.offset.y;
+    const tx = Math.floor(lx / TILE);
+    const ty = Math.floor(ly / TILE);
+    const key = tileKey(tx, ty);
+    if (key !== this.lastKey) {
+      let t2 = this.cache.get(key);
+      if (t2 === void 0) {
+        t2 = this.readTile(tx, ty);
+        this.cache.set(key, t2);
+      }
+      this.last = t2;
+      this.lastKey = key;
+    }
+    const t = this.last;
+    if (!t) {
+      out[0] = out[1] = out[2] = out[3] = 0;
+      return false;
+    }
+    const p = (ly - ty * TILE) * TILE + (lx - tx * TILE);
+    if (this.channels === 1) {
+      out[0] = out[1] = out[2] = t[p];
+      out[3] = 255;
+      return true;
+    }
+    const i = p * 4;
+    out[0] = t[i];
+    out[1] = t[i + 1];
+    out[2] = t[i + 2];
+    out[3] = t[i + 3];
+    return out[3] > 0;
+  }
+};
+var RegionPixelSource = class {
+  constructor(rect, data) {
+    this.rect = rect;
+    this.data = data;
+  }
+  rect;
+  data;
+  sample(x, y, out) {
+    const r = this.rect;
+    const lx = x - r.x;
+    const ly = y - r.y;
+    if (lx < 0 || ly < 0 || lx >= r.width || ly >= r.height) {
+      out[0] = out[1] = out[2] = out[3] = 0;
+      return false;
+    }
+    const i = (ly * r.width + lx) * 4;
+    out[0] = this.data[i];
+    out[1] = this.data[i + 1];
+    out[2] = this.data[i + 2];
+    out[3] = this.data[i + 3];
+    return out[3] > 0;
+  }
+};
+function readSourceRegion(source, rect, dx = 0, dy = 0) {
+  const out = new Float32Array(rect.width * rect.height * 4);
+  const px = [0, 0, 0, 0];
+  for (let y = 0; y < rect.height; y++) {
+    for (let x = 0; x < rect.width; x++) {
+      source.sample(rect.x + x + dx, rect.y + y + dy, px);
+      const i = (y * rect.width + x) * 4;
+      out[i] = px[0];
+      out[i + 1] = px[1];
+      out[i + 2] = px[2];
+      out[i + 3] = px[3];
+    }
+  }
+  return out;
+}
+function applyRetouchToTile(coverage, tileData, channels, tx, ty, paint, s, options = {}) {
+  const out = (options.into ?? tileData).slice();
+  const ox = tx * TILE + s.offset.x;
+  const oy = ty * TILE + s.offset.y;
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = TILE;
+  let y1 = TILE;
+  if (options.region) {
+    const r = options.region;
+    x0 = Math.max(0, Math.floor(r.x) - ox);
+    y0 = Math.max(0, Math.floor(r.y) - oy);
+    x1 = Math.min(TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(TILE, Math.ceil(r.y + r.height) - oy);
+    if (x1 <= x0 || y1 <= y0) return out;
+    if (options.into) {
+      for (let y = y0; y < y1; y++) out.set(tileData.subarray((y * TILE + x0) * channels, (y * TILE + x1) * channels), (y * TILE + x0) * channels);
+    }
+  }
+  const sel = s.selection;
+  const blend = s.blend ?? "normal";
+  const src = [0, 0, 0, 0];
+  const rgb = [0, 0, 0];
+  const cb = [0, 0, 0, 0];
+  const cs = [0, 0, 0, 0];
+  let covKey = NaN;
+  let covTile;
+  for (let y = y0; y < y1; y++) {
+    const dy = oy + y;
+    const cty = Math.floor(dy / TILE);
+    for (let x = x0; x < x1; x++) {
+      const dx = ox + x;
+      const ctx = Math.floor(dx / TILE);
+      const key = tileKey(ctx, cty);
+      if (key !== covKey) {
+        covKey = key;
+        covTile = coverage.tiles.get(key);
+      }
+      if (!covTile) continue;
+      const c = covTile[(dy - cty * TILE) * TILE + (dx - ctx * TILE)];
+      if (c <= 0) continue;
+      let k = c * s.opacity;
+      if (sel) {
+        if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;
+        k *= sel.data[dy * sel.width + dx] / 255;
+      }
+      if (k > 1) k = 1;
+      if (k <= 0) continue;
+      const p = y * TILE + x;
+      if (channels === 1) {
+        const g = out[p];
+        let t;
+        if (paint.kind === "tone") {
+          rgb[0] = rgb[1] = rgb[2] = g / 255;
+          paint.tone(rgb);
+          t = luma(rgb[0], rgb[1], rgb[2]) * 255;
+        } else if (paint.kind === "color") t = paint.color[0];
+        else {
+          if (!paint.source.sample(dx + paint.dx, dy + paint.dy, src)) continue;
+          t = src[0];
+          k *= src[3] / 255;
+        }
+        out[p] = Math.round(g + (t - g) * k);
+        continue;
+      }
+      const i = p * 4;
+      const a = out[i + 3];
+      if (paint.kind === "tone") {
+        if (a === 0) continue;
+        rgb[0] = out[i] / 255;
+        rgb[1] = out[i + 1] / 255;
+        rgb[2] = out[i + 2] / 255;
+        const r0 = rgb[0];
+        const g0 = rgb[1];
+        const b0 = rgb[2];
+        paint.tone(rgb);
+        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;
+      if (paint.kind === "color") {
+        src[0] = paint.color[0];
+        src[1] = paint.color[1];
+        src[2] = paint.color[2];
+        src[3] = paint.color[3];
+      } else if (!paint.source.sample(dx + paint.dx, dy + paint.dy, src)) continue;
+      for (let ch = 0; ch < 4; ch++) {
+        cb[ch] = out[i + ch] / 255;
+        cs[ch] = src[ch] / 255;
+      }
+      const o = blendPixel(blend, cb, cs, k);
+      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;
+}
+function applyToneToDeepTile(coverage, samples, tx, ty, tone, s, options = {}) {
+  const linear = samples instanceof Float32Array;
+  const out = (options.into ?? samples).slice();
+  const ox = tx * TILE + s.offset.x;
+  const oy = ty * TILE + s.offset.y;
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = TILE;
+  let y1 = TILE;
+  if (options.region) {
+    const r = options.region;
+    x0 = Math.max(0, Math.floor(r.x) - ox);
+    y0 = Math.max(0, Math.floor(r.y) - oy);
+    x1 = Math.min(TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(TILE, Math.ceil(r.y + r.height) - oy);
+    if (x1 <= x0 || y1 <= y0) return out;
+    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);
+  }
+  const sel = s.selection;
+  const rgb = [0, 0, 0];
+  const before = [0, 0, 0];
+  const excess = [0, 0, 0];
+  let covKey = NaN;
+  let covTile;
+  for (let y = y0; y < y1; y++) {
+    const dy = oy + y;
+    const cty = Math.floor(dy / TILE);
+    for (let x = x0; x < x1; x++) {
+      const dx = ox + x;
+      const ctx = Math.floor(dx / TILE);
+      const key = tileKey(ctx, cty);
+      if (key !== covKey) {
+        covKey = key;
+        covTile = coverage.tiles.get(key);
+      }
+      if (!covTile) continue;
+      const c = covTile[(dy - cty * TILE) * TILE + (dx - ctx * TILE)];
+      if (c <= 0) continue;
+      let k = c * s.opacity;
+      if (sel) {
+        if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;
+        k *= sel.data[dy * sel.width + dx] / 255;
+      }
+      if (k > 1) k = 1;
+      if (k <= 0) continue;
+      const i = (y * TILE + x) * 4;
+      if (out[i + 3] === 0) continue;
+      for (let ch = 0; ch < 3; ch++) {
+        const v = out[i + ch];
+        if (linear) {
+          excess[ch] = v > 1 ? v - 1 : 0;
+          rgb[ch] = srgbEncode(v > 1 ? 1 : v < 0 ? 0 : v);
+        } else rgb[ch] = v / 65535;
+        before[ch] = rgb[ch];
+      }
+      tone(rgb);
+      for (let ch = 0; ch < 3; ch++) {
+        const e = before[ch] + (rgb[ch] - before[ch]) * k;
+        if (linear) out[i + ch] = srgbDecode(e) + excess[ch];
+        else out[i + ch] = e <= 0 ? 0 : e >= 1 ? 65535 : Math.round(e * 65535);
+      }
+    }
+  }
+  return out;
+}
+function toneOf(tool, settings) {
+  const burn = tool === "burn";
+  return (rgb) => {
+    dodgeBurn(rgb, settings.exposure, settings.range, burn, settings.protectTones);
+  };
+}
+function healPixels(w, h, src, dst, mask) {
+  const out = new Float32Array(dst);
+  const bb = maskBounds(w, h, mask);
+  if (!bb) return out;
+  const x0 = Math.max(0, bb[0] - 1);
+  const y0 = Math.max(0, bb[1] - 1);
+  const x1 = Math.min(w, bb[2] + 1);
+  const y1 = Math.min(h, bb[3] + 1);
+  const rw = x1 - x0;
+  const rh = y1 - y0;
+  const s = new Float32Array(rw * rh * 4);
+  const d = new Float32Array(rw * rh * 4);
+  const m = new Uint8Array(rw * rh);
+  for (let y = 0; y < rh; y++) {
+    for (let x = 0; x < rw; x++) {
+      const gi = (y + y0) * w + x + x0;
+      const li = y * rw + x;
+      m[li] = mask[gi] ? 1 : 0;
+      for (let c = 0; c < 4; c++) {
+        s[li * 4 + c] = src[gi * 4 + c];
+        d[li * 4 + c] = dst[gi * 4 + c];
+      }
+    }
+  }
+  const healed = seamlessClone(rw, rh, 4, s, d, m);
+  for (let y = 0; y < rh; y++) {
+    for (let x = 0; x < rw; x++) {
+      const gi = ((y + y0) * w + x + x0) * 4;
+      const li = (y * rw + x) * 4;
+      for (let c = 0; c < 4; c++) out[gi + c] = Math.min(255, Math.max(0, healed[li + c]));
+    }
+  }
+  return out;
+}
+function spotHealPixels(w, h, img, hole, size, type, onOffset) {
+  const domain = dilateMask(w, h, hole, 2);
+  const healMask = dilateMask(w, h, hole, 1);
+  let filled = null;
+  let bestFound = null;
+  if (type === "proximity-match") {
+    const ring = Math.min(16, Math.max(3, Math.floor(size / 8)));
+    const off2 = bestOffset(w, h, 4, img, domain, ring, Math.floor(Math.max(w, h) / 2));
+    if (off2) {
+      bestFound = off2;
+      filled = new Float32Array(img);
+      const [ddx, ddy] = off2;
+      for (let i = 0; i < w * h; i++) {
+        if (!domain[i]) continue;
+        const x = i % w + ddx;
+        const y = Math.floor(i / w) + ddy;
+        const j = (y * w + x) * 4;
+        for (let c = 0; c < 4; c++) filled[i * 4 + c] = img[j + c];
+      }
+    }
+  }
+  onOffset?.(filled ? bestFound : null);
+  if (!filled && type === "content-aware") filled = contentAwareFill(w, h, 4, img, domain);
+  if (!filled) filled = membraneFill(w, h, 4, img, domain);
+  return healPixels(w, h, filled, img, healMask);
+}
+function spotHealWindow(bounds, canvas) {
+  const g = Math.max(8, Math.ceil(Math.max(bounds.width, bounds.height)));
+  const x0 = Math.max(0, bounds.x - g);
+  const y0 = Math.max(0, bounds.y - g);
+  const x1 = Math.min(canvas.width, bounds.x + bounds.width + g);
+  const y1 = Math.min(canvas.height, bounds.y + bounds.height + g);
+  return { x: x0, y: y0, width: Math.max(0, x1 - x0), height: Math.max(0, y1 - y0) };
+}
+var RetouchDabStroke = class {
+  constructor(brush, target, effect) {
+    this.brush = brush;
+    this.effect = effect;
+    this.walker = new DabWalker(brush);
+    this.medium = new TileMedium(target);
+  }
+  brush;
+  effect;
+  dabCount = 0;
+  bounds = null;
+  walker;
+  medium;
+  smoothPos = null;
+  buf = new Float32Array(0);
+  push(points) {
+    const dabs = [];
+    for (const p of points) this.walker.push(this.smooth(p), dabs);
+    return this.paint(dabs);
+  }
+  finish(last) {
+    const dabs = [];
+    if (last && this.smoothPos && (this.smoothPos.x !== last.x || this.smoothPos.y !== last.y)) this.walker.push(last, dabs);
+    this.walker.finish(dabs);
+    return this.paint(dabs);
+  }
+  smooth(p) {
+    const a = 1 - Math.min(0.95, Math.max(0, this.brush.smoothing));
+    const cur = this.smoothPos;
+    const n = cur && a < 1 ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;
+    this.smoothPos = n;
+    return n;
+  }
+  paint(dabs) {
+    const rects = [];
+    for (const d of dabs) {
+      const rect = dabRect(d, this.brush.hardness);
+      const n = rect.width * rect.height;
+      if (this.buf.length < n) this.buf = new Float32Array(n);
+      const cov = this.buf.subarray(0, n);
+      rasterizeDab({ ...d, alpha: 1 }, this.brush.hardness, rect, cov);
+      this.medium.reset();
+      this.effect(this.medium, d, rect, cov);
+      rects.push(rect);
+      this.bounds = unionRect(this.bounds, rect);
+      this.dabCount++;
+    }
+    return rects;
+  }
+};
+function smudgeEffect(brush, strength, mixing = "rgb") {
+  const s = Math.min(1, Math.max(0, strength));
+  const tip = new SmudgeTip({ strength: s, length: s, mixing }, brush.size);
+  return (medium, d, rect, cov) => tip.dab(medium, { x: d.x, y: d.y, radius: d.radius, opacity: d.opacity * d.alpha }, rect, cov);
+}
+function spongeEffect(brush, saturate, vibrance) {
+  const rgb = [0, 0, 0];
+  return (medium, d, rect, cov) => {
+    const w = rect.width;
+    for (let yy = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < w; xx++) {
+        const cv = cov[yy * w + xx];
+        if (cv <= 0) continue;
+        const dx = rect.x + xx;
+        const dy = rect.y + yy;
+        const k = perDabStrength(cv * d.alpha * d.opacity * 0.5, brush.spacing) * medium.selectionAt(dx, dy);
+        if (k <= 0) continue;
+        const ri = medium.locate(dx, dy, false);
+        if (ri < 0 || medium.pixels[ri + 3] === 0) continue;
+        const i = medium.locate(dx, dy, true);
+        const px = medium.pixels;
+        rgb[0] = px[i] / 255;
+        rgb[1] = px[i + 1] / 255;
+        rgb[2] = px[i + 2] / 255;
+        sponge(rgb, k, saturate, vibrance);
+        put255(px, i, rgb[0]);
+        put255(px, i + 1, rgb[1]);
+        put255(px, i + 2, rgb[2]);
+      }
+    }
+  };
+}
+function rgbaViewOfGrey(target) {
+  const views = /* @__PURE__ */ new Map();
+  const dirty = /* @__PURE__ */ new Map();
+  const expand = (g) => {
+    const out = new Uint8ClampedArray(g.length * 4);
+    for (let i = 0; i < g.length; i++) {
+      out[i * 4] = out[i * 4 + 1] = out[i * 4 + 2] = g[i];
+      out[i * 4 + 3] = 255;
+    }
+    return out;
+  };
+  const view = {
+    offset: target.offset,
+    lockTransparency: true,
+    selection: target.selection,
+    readTile: (tx, ty) => {
+      const key = tileKey(tx, ty);
+      let v = views.get(key);
+      if (!v) {
+        v = expand(target.readTile(tx, ty) ?? new Uint8ClampedArray(TILE * TILE));
+        views.set(key, v);
+      }
+      return v;
+    },
+    writeTile: (tx, ty) => {
+      const key = tileKey(tx, ty);
+      let v = views.get(key);
+      if (!v) {
+        v = expand(target.readTile(tx, ty) ?? new Uint8ClampedArray(TILE * TILE));
+        views.set(key, v);
+      }
+      dirty.set(key, { tx, ty, data: v });
+      return v;
+    }
+  };
+  return {
+    target: view,
+    flush: () => {
+      for (const { tx, ty, data } of dirty.values()) {
+        const g = target.writeTile(tx, ty);
+        for (let i = 0; i < g.length; i++) g[i] = data[i * 4];
+      }
+      dirty.clear();
+    }
+  };
+}
+function unionRect(a, b) {
+  if (!a) return { ...b };
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  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 };
+}
+
 // src/paint/wet/model.ts
 var WET_TILE = 256;
 var SLOT_SIDE = 258;
@@ -1849,7 +2510,7 @@ var WetWorld = class {
       if (x1 <= x0 || y1 <= y0) continue;
       const whole = x0 === tr.x && y0 === tr.y && x1 >= Math.min(tr.x + WET_TILE, this.width) && y1 >= Math.min(tr.y + WET_TILE, this.height);
       if (whole) {
-        if (this.bakeKey(key, true)) bounds = unionRect(bounds, { x: tr.x, y: tr.y, width: Math.min(WET_TILE, this.width - tr.x), height: Math.min(WET_TILE, this.height - tr.y) });
+        if (this.bakeKey(key, true)) bounds = unionRect2(bounds, { x: tr.x, y: tr.y, width: Math.min(WET_TILE, this.width - tr.x), height: Math.min(WET_TILE, this.height - tr.y) });
         this.free(key);
         continue;
       }
@@ -1869,7 +2530,7 @@ var WetWorld = class {
           f[c + P_SW * PLANE] = 0;
         }
       }
-      bounds = unionRect(bounds, { x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
+      bounds = unionRect2(bounds, { x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
       this.markEdited(lane, x0, y0, x1, y1);
     }
     this.syncList();
@@ -2439,7 +3100,7 @@ function moveWetSnapshot(snap, from, to, dx, dy, lane = () => ({})) {
   });
   return { clock: snap.clock, tilt: { ...snap.tilt }, lanes, slots, bytes };
 }
-function unionRect(a, b) {
+function unionRect2(a, b) {
   if (!a) return { ...b };
   const x = Math.min(a.x, b.x);
   const y = Math.min(a.y, b.y);
@@ -3326,6 +3987,36 @@ function pointerStrokeSamples(e, toPoint) {
 
 export {
   createPigmentTools,
+  TONE_RANGES,
+  luma,
+  dodgeBurnCurve,
+  dodgeBurn,
+  saturationOf,
+  sponge,
+  perDabStrength,
+  RETOUCH_SAMPLES,
+  SPOT_HEAL_TYPES,
+  DEFAULT_RETOUCH,
+  normalizeRetouch,
+  boxBlurPixels,
+  retouchFilter,
+  IDENTITY_CLONE_TRANSFORM,
+  isIdentityCloneTransform,
+  cloneSamplePoint,
+  TransformedPixelSource,
+  TilePixelSource,
+  RegionPixelSource,
+  readSourceRegion,
+  applyRetouchToTile,
+  applyToneToDeepTile,
+  toneOf,
+  healPixels,
+  spotHealPixels,
+  spotHealWindow,
+  RetouchDabStroke,
+  smudgeEffect,
+  spongeEffect,
+  rgbaViewOfGrey,
   WET_TILE,
   SLOT_SIDE,
   PLANE,