@pixerate/editor 0.258.0 → 0.260.0

package/dist/{chunk-KBYB7OWB.cjs → chunk-YHDHFJUC.cjs}

@@ -1,4 +1,23 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;
+
+
+
+
+
+
+var _chunkBB6TR422cjs = require('./chunk-BB6TR422.cjs');
+
+
+
+
+
+
+
+var _chunkFQPUF2W2cjs = require('./chunk-FQPUF2W2.cjs');
+
+
+
+
 
 
 var _chunk2VX55NFMcjs = require('./chunk-2VX55NFM.cjs');
@@ -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 = class {
+  constructor(inner, map) {;_class.prototype.__init.call(this);
+    this.inner = inner;
+    this.map = map;
+  }
+  
+  
+  __init() {this.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;
+  }
+}, _class);
+var TilePixelSource = (_class2 = class {
+  constructor(readTile, channels, offset = { x: 0, y: 0 }) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
+    this.readTile = readTile;
+    this.channels = channels;
+    this.offset = offset;
+  }
+  
+  
+  
+  __init2() {this.cache = /* @__PURE__ */ new Map()}
+  __init3() {this.lastKey = NaN}
+  __init4() {this.last = null}
+  sample(x, y, out) {
+    const lx = x - this.offset.x;
+    const ly = y - this.offset.y;
+    const tx = Math.floor(lx / _chunk474IQG74cjs.TILE);
+    const ty = Math.floor(ly / _chunk474IQG74cjs.TILE);
+    const key = _chunk474IQG74cjs.tileKey.call(void 0, 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 * _chunk474IQG74cjs.TILE) * _chunk474IQG74cjs.TILE + (lx - tx * _chunk474IQG74cjs.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;
+  }
+}, _class2);
+var RegionPixelSource = class {
+  constructor(rect, data) {
+    this.rect = rect;
+    this.data = 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 = (_nullishCoalesce(options.into, () => ( tileData))).slice();
+  const ox = tx * _chunk474IQG74cjs.TILE + s.offset.x;
+  const oy = ty * _chunk474IQG74cjs.TILE + s.offset.y;
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = _chunk474IQG74cjs.TILE;
+  let y1 = _chunk474IQG74cjs.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(_chunk474IQG74cjs.TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(_chunk474IQG74cjs.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 * _chunk474IQG74cjs.TILE + x0) * channels, (y * _chunk474IQG74cjs.TILE + x1) * channels), (y * _chunk474IQG74cjs.TILE + x0) * channels);
+    }
+  }
+  const sel = s.selection;
+  const blend = _nullishCoalesce(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 / _chunk474IQG74cjs.TILE);
+    for (let x = x0; x < x1; x++) {
+      const dx = ox + x;
+      const ctx = Math.floor(dx / _chunk474IQG74cjs.TILE);
+      const key = _chunk474IQG74cjs.tileKey.call(void 0, ctx, cty);
+      if (key !== covKey) {
+        covKey = key;
+        covTile = coverage.tiles.get(key);
+      }
+      if (!covTile) continue;
+      const c = covTile[(dy - cty * _chunk474IQG74cjs.TILE) * _chunk474IQG74cjs.TILE + (dx - ctx * _chunk474IQG74cjs.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 * _chunk474IQG74cjs.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);
+        _chunkFQPUF2W2cjs.put255.call(void 0, out, i, r0 + (rgb[0] - r0) * k);
+        _chunkFQPUF2W2cjs.put255.call(void 0, out, i + 1, g0 + (rgb[1] - g0) * k);
+        _chunkFQPUF2W2cjs.put255.call(void 0, 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 = _chunk2VX55NFMcjs.blendPixel.call(void 0, blend, cb, cs, k);
+      _chunkFQPUF2W2cjs.put255.call(void 0, out, i, o[0]);
+      _chunkFQPUF2W2cjs.put255.call(void 0, out, i + 1, o[1]);
+      _chunkFQPUF2W2cjs.put255.call(void 0, out, i + 2, o[2]);
+      if (!s.lockTransparency) _chunkFQPUF2W2cjs.put255.call(void 0, out, i + 3, o[3]);
+    }
+  }
+  return out;
+}
+function applyToneToDeepTile(coverage, samples, tx, ty, tone, s, options = {}) {
+  const linear = samples instanceof Float32Array;
+  const out = (_nullishCoalesce(options.into, () => ( samples))).slice();
+  const ox = tx * _chunk474IQG74cjs.TILE + s.offset.x;
+  const oy = ty * _chunk474IQG74cjs.TILE + s.offset.y;
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = _chunk474IQG74cjs.TILE;
+  let y1 = _chunk474IQG74cjs.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(_chunk474IQG74cjs.TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(_chunk474IQG74cjs.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 * _chunk474IQG74cjs.TILE + x0) * 4, (y * _chunk474IQG74cjs.TILE + x1) * 4), (y * _chunk474IQG74cjs.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 / _chunk474IQG74cjs.TILE);
+    for (let x = x0; x < x1; x++) {
+      const dx = ox + x;
+      const ctx = Math.floor(dx / _chunk474IQG74cjs.TILE);
+      const key = _chunk474IQG74cjs.tileKey.call(void 0, ctx, cty);
+      if (key !== covKey) {
+        covKey = key;
+        covTile = coverage.tiles.get(key);
+      }
+      if (!covTile) continue;
+      const c = covTile[(dy - cty * _chunk474IQG74cjs.TILE) * _chunk474IQG74cjs.TILE + (dx - ctx * _chunk474IQG74cjs.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 * _chunk474IQG74cjs.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] = _chunk2VX55NFMcjs.srgbEncode.call(void 0, 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] = _chunk2VX55NFMcjs.srgbDecode.call(void 0, 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 = _chunkBB6TR422cjs.maskBounds.call(void 0, 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 = _chunkBB6TR422cjs.seamlessClone.call(void 0, 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 = _chunkBB6TR422cjs.dilateMask.call(void 0, w, h, hole, 2);
+  const healMask = _chunkBB6TR422cjs.dilateMask.call(void 0, 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 = _chunkBB6TR422cjs.bestOffset.call(void 0, 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];
+      }
+    }
+  }
+  _optionalChain([onOffset, 'optionalCall', _ => _(filled ? bestFound : null)]);
+  if (!filled && type === "content-aware") filled = _chunkBB6TR422cjs.contentAwareFill.call(void 0, w, h, 4, img, domain);
+  if (!filled) filled = _chunkBB6TR422cjs.membraneFill.call(void 0, 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 = (_class3 = class {
+  constructor(brush, target, effect) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);
+    this.brush = brush;
+    this.effect = effect;
+    this.walker = new (0, _chunkFQPUF2W2cjs.DabWalker)(brush);
+    this.medium = new (0, _chunkFQPUF2W2cjs.TileMedium)(target);
+  }
+  
+  
+  __init5() {this.dabCount = 0}
+  __init6() {this.bounds = null}
+  
+  
+  __init7() {this.smoothPos = null}
+  __init8() {this.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 = _chunkFQPUF2W2cjs.dabRect.call(void 0, 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);
+      _chunkFQPUF2W2cjs.rasterizeDab.call(void 0, { ...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;
+  }
+}, _class3);
+function smudgeEffect(brush, strength, mixing = "rgb") {
+  const s = Math.min(1, Math.max(0, strength));
+  const tip = new (0, _chunkFQPUF2W2cjs.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);
+        _chunkFQPUF2W2cjs.put255.call(void 0, px, i, rgb[0]);
+        _chunkFQPUF2W2cjs.put255.call(void 0, px, i + 1, rgb[1]);
+        _chunkFQPUF2W2cjs.put255.call(void 0, 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 = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
+      let v = views.get(key);
+      if (!v) {
+        v = expand(_nullishCoalesce(target.readTile(tx, ty), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE))));
+        views.set(key, v);
+      }
+      return v;
+    },
+    writeTile: (tx, ty) => {
+      const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
+      let v = views.get(key);
+      if (!v) {
+        v = expand(_nullishCoalesce(target.readTile(tx, ty), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.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;
@@ -776,7 +1437,7 @@ function wetSupport(simd = _nullishCoalesce(simdCache, () => ( typeof WebAssembl
   const g = globalThis;
   const sharedMemory = canShareMemory();
   const workers = typeof g.Worker === "function" && typeof Blob === "function" && typeof URL !== "undefined" && typeof URL.createObjectURL === "function";
-  const cores = Math.max(1, Math.floor(_nullishCoalesce(_optionalChain([g, 'access', _ => _.navigator, 'optionalAccess', _2 => _2.hardwareConcurrency]), () => ( 1))));
+  const cores = Math.max(1, Math.floor(_nullishCoalesce(_optionalChain([g, 'access', _2 => _2.navigator, 'optionalAccess', _3 => _3.hardwareConcurrency]), () => ( 1))));
   let message = null;
   if (!simd) message = "This browser has no WebAssembly SIMD, so wet paint runs in plain JavaScript: it flows much more slowly (the results are the same).";
   else if (workers && !sharedMemory)
@@ -880,8 +1541,8 @@ var WetWorkerPool = class _WetWorkerPool {
         ready.push(
           new Promise((resolve, reject) => {
             w.onmessage = (e) => {
-              if (_optionalChain([e, 'access', _3 => _3.data, 'optionalAccess', _4 => _4.type]) === "ready") resolve();
-              else if (_optionalChain([e, 'access', _5 => _5.data, 'optionalAccess', _6 => _6.type]) === "error") reject(new Error(e.data.message));
+              if (_optionalChain([e, 'access', _4 => _4.data, 'optionalAccess', _5 => _5.type]) === "ready") resolve();
+              else if (_optionalChain([e, 'access', _6 => _6.data, 'optionalAccess', _7 => _7.type]) === "error") reject(new Error(e.data.message));
             };
             w.onerror = (e) => reject(new Error(e.message || "The wet-media worker failed to start."));
           })
@@ -903,8 +1564,8 @@ var WetWorkerPool = class _WetWorkerPool {
       this.workers.map(
         (w, i) => new Promise((resolve, reject) => {
           w.onmessage = (e) => {
-            if (_optionalChain([e, 'access', _7 => _7.data, 'optionalAccess', _8 => _8.type]) === "done") resolve();
-            else if (_optionalChain([e, 'access', _9 => _9.data, 'optionalAccess', _10 => _10.type]) === "error") reject(new Error(e.data.message));
+            if (_optionalChain([e, 'access', _8 => _8.data, 'optionalAccess', _9 => _9.type]) === "done") resolve();
+            else if (_optionalChain([e, 'access', _10 => _10.data, 'optionalAccess', _11 => _11.type]) === "error") reject(new Error(e.data.message));
           };
           w.postMessage({ type: "run", steps, workers: n, id: i });
         })
@@ -951,53 +1612,53 @@ function makeLayout(width, height) {
 function quantizeHeight(v) {
   return Math.round(Math.min(1, Math.max(0, v)) * 65536) / 65536;
 }
-var WetWorld = (_class = class {
+var WetWorld = (_class4 = class {
   
   
   
   /** Steps simulated so far. */
-  __init() {this.clock = 0}
+  __init9() {this.clock = 0}
   /** Messages for the user (slots ran out, a backend failed). */
-  __init2() {this.warnings = []}
+  __init10() {this.warnings = []}
   
   
   
   
   
-  __init3() {this.slotCount = 0}
-  __init4() {this.freeSlots = []}
-  __init5() {this.active = []}
-  __init6() {this.parity = 0}
-  __init7() {this.lanes = new Array(MAX_WET_LANES).fill(null)}
-  __init8() {this.tilt = { ...FLAT }}
+  __init11() {this.slotCount = 0}
+  __init12() {this.freeSlots = []}
+  __init13() {this.active = []}
+  __init14() {this.parity = 0}
+  __init15() {this.lanes = new Array(MAX_WET_LANES).fill(null)}
+  __init16() {this.tilt = { ...FLAT }}
   
-  __init9() {this.paperBytes = new Uint8Array(3)}
-  __init10() {this.kind = "typescript"}
-  __init11() {this.wasm = null}
-  __init12() {this.pool = null}
-  __init13() {this.busyFlag = false}
-  __init14() {this.destroyed = false}
+  __init17() {this.paperBytes = new Uint8Array(3)}
+  __init18() {this.kind = "typescript"}
+  __init19() {this.wasm = null}
+  __init20() {this.pool = null}
+  __init21() {this.busyFlag = false}
+  __init22() {this.destroyed = false}
   
-  __init15() {this.prm = new Float32Array(PARAM_FLOATS)}
+  __init23() {this.prm = new Float32Array(PARAM_FLOATS)}
   // Engine B: the GPU mirror (see `attachGpu`).
-  __init16() {this.gpu = null}
+  __init24() {this.gpu = null}
   /** Live tiles at which the GPU takes over the display (default 16: a fully wet 1024² canvas). */
-  __init17() {this.gpuMinTiles = 16}
-  __init18() {this.gpuLive = false}
-  __init19() {this.gpuFailure = null}
+  __init25() {this.gpuMinTiles = 16}
+  __init26() {this.gpuLive = false}
+  __init27() {this.gpuFailure = null}
   /** Slot → rows (1..256, inclusive) to upload; `[0, 257]` means the whole slot. */
-  __init20() {this.gpuDirty = /* @__PURE__ */ new Map()}
-  __init21() {this.gpuParamsDirty = true}
+  __init28() {this.gpuDirty = /* @__PURE__ */ new Map()}
+  __init29() {this.gpuParamsDirty = true}
   /**
    * Lead mode (between strokes): a batch is not sent to the GPU all at once; `gpuLead` steps it
    * frame by frame while the CPU works through it, so the display moves on before the CPU is done.
    */
-  __init22() {this.gpuLeadMode = false}
+  __init30() {this.gpuLeadMode = false}
   /** The batch the GPU is working through in lead mode. */
-  __init23() {this.gpuPlan = null}
+  __init31() {this.gpuPlan = null}
   /** Resolves when the fastest available kernel is running (it may stay `typescript`). */
   
-  constructor(width, height, paper, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);_class.prototype.__init12.call(this);_class.prototype.__init13.call(this);_class.prototype.__init14.call(this);_class.prototype.__init15.call(this);_class.prototype.__init16.call(this);_class.prototype.__init17.call(this);_class.prototype.__init18.call(this);_class.prototype.__init19.call(this);_class.prototype.__init20.call(this);_class.prototype.__init21.call(this);_class.prototype.__init22.call(this);_class.prototype.__init23.call(this);
+  constructor(width, height, paper, options = {}) {;_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);_class4.prototype.__init11.call(this);_class4.prototype.__init12.call(this);_class4.prototype.__init13.call(this);_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);_class4.prototype.__init16.call(this);_class4.prototype.__init17.call(this);_class4.prototype.__init18.call(this);_class4.prototype.__init19.call(this);_class4.prototype.__init20.call(this);_class4.prototype.__init21.call(this);_class4.prototype.__init22.call(this);_class4.prototype.__init23.call(this);_class4.prototype.__init24.call(this);_class4.prototype.__init25.call(this);_class4.prototype.__init26.call(this);_class4.prototype.__init27.call(this);_class4.prototype.__init28.call(this);_class4.prototype.__init29.call(this);_class4.prototype.__init30.call(this);_class4.prototype.__init31.call(this);
     if (!(width >= 1 && height >= 1 && width <= 16384 && height <= 16384)) throw new WetWorldError(`A wet canvas must be 1..16384 pixels per side, not ${width}\xD7${height}.`);
     this.width = Math.round(width);
     this.height = Math.round(height);
@@ -1052,7 +1713,7 @@ var WetWorld = (_class = class {
   }
   /** The kernel in use and why it is not faster. */
   backend() {
-    const threads = _nullishCoalesce(_optionalChain([this, 'access', _11 => _11.pool, 'optionalAccess', _12 => _12.size]), () => ( 1));
+    const threads = _nullishCoalesce(_optionalChain([this, 'access', _12 => _12.pool, 'optionalAccess', _13 => _13.size]), () => ( 1));
     let message = this.support.message;
     if (this.kind === "typescript" && !message) message = this.wasm ? null : "Wet paint runs in plain JavaScript until the WebAssembly kernel has loaded.";
     if (this.kind === "wasm-threads") message = null;
@@ -1064,17 +1725,17 @@ var WetWorld = (_class = class {
   }
   destroy() {
     this.destroyed = true;
-    _optionalChain([this, 'access', _13 => _13.pool, 'optionalAccess', _14 => _14.destroy, 'call', _15 => _15()]);
+    _optionalChain([this, 'access', _14 => _14.pool, 'optionalAccess', _15 => _15.destroy, 'call', _16 => _16()]);
     this.pool = null;
   }
   // --- Lanes ---------------------------------------------------------------------
   laneOf(id) {
-    const l = this.lanes.find((x) => _optionalChain([x, 'optionalAccess', _16 => _16.id]) === id);
+    const l = this.lanes.find((x) => _optionalChain([x, 'optionalAccess', _17 => _17.id]) === id);
     if (!l) throw new WetWorldError(`There is no wet layer "${id}".`);
     return l;
   }
   hasLane(id) {
-    return this.lanes.some((x) => _optionalChain([x, 'optionalAccess', _17 => _17.id]) === id);
+    return this.lanes.some((x) => _optionalChain([x, 'optionalAccess', _18 => _18.id]) === id);
   }
   laneIds() {
     return this.lanes.filter((l) => Boolean(l)).map((l) => l.id);
@@ -1082,7 +1743,7 @@ var WetWorld = (_class = class {
   /** Adds a wet layer (or returns it). Throws when `MAX_WET_LANES` are in use. */
   ensureLane(id, options = {}) {
     this.requireIdle();
-    const existing = this.lanes.find((x) => _optionalChain([x, 'optionalAccess', _18 => _18.id]) === id);
+    const existing = this.lanes.find((x) => _optionalChain([x, 'optionalAccess', _19 => _19.id]) === id);
     if (existing) {
       if (options.params) this.setParams(id, options.params);
       if (options.base) this.setBase(id, options.base);
@@ -1776,7 +2437,7 @@ var WetWorld = (_class = class {
         if (!(a > 0)) return;
         const key = _chunk474IQG74cjs.tileKey.call(void 0, x >> 8, y >> 8);
         const li = (y & 255) * _chunk474IQG74cjs.TILE + (x & 255);
-        let lt = _optionalChain([lightTiles, 'optionalAccess', _19 => _19.get, 'call', _20 => _20(key)]);
+        let lt = _optionalChain([lightTiles, 'optionalAccess', _20 => _20.get, 'call', _21 => _21(key)]);
         if (lt && (_nullishCoalesce(lt.uniform, () => ( 1))) !== 0) {
           if (!lightWritten.has(key)) {
             const data = lt.data.length ? new Uint8ClampedArray(lt.data) : new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE).fill(_nullishCoalesce(lt.uniform, () => ( 0)));
@@ -1849,7 +2510,7 @@ var WetWorld = (_class = 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 = 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();
@@ -1897,7 +2558,7 @@ var WetWorld = (_class = class {
         lightChanged = true;
       }
     }
-    const src = _nullishCoalesce(_optionalChain([lane, 'access', _21 => _21.base, 'access', _22 => _22.tiles, 'access', _23 => _23.get, 'call', _24 => _24(tk), 'optionalAccess', _25 => _25.data]), () => ( null));
+    const src = _nullishCoalesce(_optionalChain([lane, 'access', _22 => _22.base, 'access', _23 => _23.tiles, 'access', _24 => _24.get, 'call', _25 => _25(tk), 'optionalAccess', _26 => _26.data]), () => ( null));
     const out = this.shadeSlot(key, src, all ? "bake-all" : "bake");
     if (!out) return lightChanged;
     const tiles = new Map(lane.base.tiles);
@@ -1960,7 +2621,7 @@ var WetWorld = (_class = class {
     for (const key of this.active) {
       if (this.laneIndexOf(key) !== lane.index) continue;
       const tk = this.tileKeyOf(key);
-      const out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _26 => _26.base, 'access', _27 => _27.tiles, 'access', _28 => _28.get, 'call', _29 => _29(tk), 'optionalAccess', _30 => _30.data]), () => ( null)), "bake-all");
+      const out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _27 => _27.base, 'access', _28 => _28.tiles, 'access', _29 => _29.get, 'call', _30 => _30(tk), 'optionalAccess', _31 => _31.data]), () => ( null)), "bake-all");
       if (!out) continue;
       const t = _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0);
       if (t) tiles.set(tk, t);
@@ -2083,14 +2744,14 @@ var WetWorld = (_class = class {
   display(id, maxTiles = Infinity) {
     const lane = this.laneOf(id);
     const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
-    const stale = keys.filter((k) => _optionalChain([lane, 'access', _31 => _31.shaded, 'access', _32 => _32.get, 'call', _33 => _33(this.tileKeyOf(k)), 'optionalAccess', _34 => _34.stamp]) !== lane.stamp);
-    stale.sort((a, b) => Number(lane.urgent.has(this.tileKeyOf(b))) - Number(lane.urgent.has(this.tileKeyOf(a))) || (_nullishCoalesce(_optionalChain([lane, 'access', _35 => _35.shaded, 'access', _36 => _36.get, 'call', _37 => _37(this.tileKeyOf(a)), 'optionalAccess', _38 => _38.stamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([lane, 'access', _39 => _39.shaded, 'access', _40 => _40.get, 'call', _41 => _41(this.tileKeyOf(b)), 'optionalAccess', _42 => _42.stamp]), () => ( 0))));
+    const stale = keys.filter((k) => _optionalChain([lane, 'access', _32 => _32.shaded, 'access', _33 => _33.get, 'call', _34 => _34(this.tileKeyOf(k)), 'optionalAccess', _35 => _35.stamp]) !== lane.stamp);
+    stale.sort((a, b) => Number(lane.urgent.has(this.tileKeyOf(b))) - Number(lane.urgent.has(this.tileKeyOf(a))) || (_nullishCoalesce(_optionalChain([lane, 'access', _36 => _36.shaded, 'access', _37 => _37.get, 'call', _38 => _38(this.tileKeyOf(a)), 'optionalAccess', _39 => _39.stamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([lane, 'access', _40 => _40.shaded, 'access', _41 => _41.get, 'call', _42 => _42(this.tileKeyOf(b)), 'optionalAccess', _43 => _43.stamp]), () => ( 0))));
     const changed = [];
     let done = 0;
     for (const key of stale) {
       if (done >= maxTiles) break;
       const tk = this.tileKeyOf(key);
-      const src = _nullishCoalesce(_optionalChain([lane, 'access', _43 => _43.base, 'access', _44 => _44.tiles, 'access', _45 => _45.get, 'call', _46 => _46(tk), 'optionalAccess', _47 => _47.data]), () => ( null));
+      const src = _nullishCoalesce(_optionalChain([lane, 'access', _44 => _44.base, 'access', _45 => _45.tiles, 'access', _46 => _46.get, 'call', _47 => _47(tk), 'optionalAccess', _48 => _48.data]), () => ( null));
       const out = this.shadeSlot(key, src, "display");
       const tile = out ? _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0) : _nullishCoalesce(lane.base.tiles.get(tk), () => ( null));
       lane.shaded.set(tk, { stamp: lane.stamp, tile: _nullishCoalesce(tile, () => ( { data: new Uint8ClampedArray(0), uniform: 0 })) });
@@ -2127,7 +2788,7 @@ var WetWorld = (_class = class {
     for (const key2 of keys) {
       const tk = this.tileKeyOf(key2);
       live.add(tk);
-      if (_optionalChain([lane, 'access', _48 => _48.lightShaded, 'access', _49 => _49.get, 'call', _50 => _50(tk), 'optionalAccess', _51 => _51.stamp]) === lane.stamp) continue;
+      if (_optionalChain([lane, 'access', _49 => _49.lightShaded, 'access', _50 => _50.get, 'call', _51 => _51(tk), 'optionalAccess', _52 => _52.stamp]) === lane.stamp) continue;
       const src = _nullishCoalesce(lane.light.tiles.get(tk), () => ( null));
       const out = this.shadeLightSlot(key2, src, "display");
       lane.lightShaded.set(tk, { stamp: lane.stamp, tile: out ? _chunk474IQG74cjs.finishTile.call(void 0, out, 1, 0) : src });
@@ -2325,7 +2986,7 @@ var WetWorld = (_class = class {
     if (!this.gpu || this.busyFlag && !plan || !plan && !this.gpuDecide()) return { ...this.display(id, maxCpuTiles), gpu: false };
     const lane = this.laneOf(id);
     const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
-    const stale = plan ? keys : keys.filter((k) => _optionalChain([lane, 'access', _52 => _52.shaded, 'access', _53 => _53.get, 'call', _54 => _54(this.tileKeyOf(k)), 'optionalAccess', _55 => _55.stamp]) !== lane.stamp);
+    const stale = plan ? keys : keys.filter((k) => _optionalChain([lane, 'access', _53 => _53.shaded, 'access', _54 => _54.get, 'call', _55 => _55(this.tileKeyOf(k)), 'optionalAccess', _56 => _56.stamp]) !== lane.stamp);
     if (!stale.length) return { ...this.display(id, 0), gpu: true };
     let tiles;
     const stamp = lane.stamp;
@@ -2333,7 +2994,7 @@ var WetWorld = (_class = class {
     try {
       if (!plan) this.gpuSync();
       const parity = plan ? plan.parity + plan.done & 1 : this.parity;
-      tiles = await this.gpu.shade(this.gpuJobs(stale), parity, stale.map((k) => _nullishCoalesce(_optionalChain([base, 'access', _56 => _56.tiles, 'access', _57 => _57.get, 'call', _58 => _58(this.tileKeyOf(k)), 'optionalAccess', _59 => _59.data]), () => ( null))), [this.paperBytes[0], this.paperBytes[1], this.paperBytes[2]]);
+      tiles = await this.gpu.shade(this.gpuJobs(stale), parity, stale.map((k) => _nullishCoalesce(_optionalChain([base, 'access', _57 => _57.tiles, 'access', _58 => _58.get, 'call', _59 => _59(this.tileKeyOf(k)), 'optionalAccess', _60 => _60.data]), () => ( null))), [this.paperBytes[0], this.paperBytes[1], this.paperBytes[2]]);
     } catch (e) {
       this.gpuStop(`Wet paint stopped using the GPU (${e.message}).`);
       return { ...this.display(id, maxCpuTiles), gpu: false };
@@ -2415,7 +3076,7 @@ var WetWorld = (_class = class {
     const slot = this.slotOf(lane.index * this.layout.perLane + ty * this.layout.tilesX + tx);
     return slot < 0 ? -1 : this.slotBase(slot);
   }
-}, _class);
+}, _class4);
 function moveWetSnapshot(snap, from, to, dx, dy, lane = () => ({})) {
   if (!Number.isInteger(dx / WET_TILE) || !Number.isInteger(dy / WET_TILE)) throw new WetWorldError(`Wet paint moves by whole ${WET_TILE} px tiles, not (${dx}, ${dy}).`);
   const a = makeLayout(from.width, from.height);
@@ -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);
@@ -2512,8 +3173,8 @@ function normalizeFlow(raw = {}, base = DEFAULT_FLOW) {
 }
 function flowField(spec, width, height) {
   const k = FLOW_ACCEL;
-  const cx = _nullishCoalesce(_optionalChain([spec, 'access', _60 => _60.center, 'optionalAccess', _61 => _61.x]), () => ( width / 2));
-  const cy = _nullishCoalesce(_optionalChain([spec, 'access', _62 => _62.center, 'optionalAccess', _63 => _63.y]), () => ( height / 2));
+  const cx = _nullishCoalesce(_optionalChain([spec, 'access', _61 => _61.center, 'optionalAccess', _62 => _62.x]), () => ( width / 2));
+  const cy = _nullishCoalesce(_optionalChain([spec, 'access', _63 => _63.center, 'optionalAccess', _64 => _64.y]), () => ( height / 2));
   const r0 = Math.max(width, height) / 2;
   switch (spec.kind) {
     case "none":
@@ -2545,8 +3206,8 @@ function flowField(spec, width, height) {
 
 // src/paint/wet/medium.ts
 var SAMPLE_K = 3;
-var WetMedium = (_class2 = class {
-  constructor(world, laneId, options) {;_class2.prototype.__init24.call(this);
+var WetMedium = (_class5 = class {
+  constructor(world, laneId, options) {;_class5.prototype.__init32.call(this);
     this.world = world;
     this.laneId = laneId;
     this.options = options;
@@ -2554,7 +3215,7 @@ var WetMedium = (_class2 = class {
   
   
   
-  __init24() {this.pig = new Float64Array(4)}
+  __init32() {this.pig = new Float64Array(4)}
   sample(rect, cov) {
     const s = this.world.sample(this.laneId, rect, cov);
     if (!(s.wet > 0) || !(s.weight > 0)) return null;
@@ -2587,7 +3248,7 @@ var WetMedium = (_class2 = class {
     const pig = [0, 1, 2, 3].map((q) => this.pig[q] * mass * dep);
     this.world.paint(this.laneId, rect, cov, water * dep, mass > 0 ? pig : null, null, light);
   }
-}, _class2);
+}, _class5);
 
 // src/paint/wet/gpu-kernels.ts
 var GPU_JOB_WORDS = 16;
@@ -2976,7 +3637,7 @@ var UNIFORM = 64;
 var STORAGE = 128;
 function findWebGpu() {
   const nav = globalThis.navigator;
-  return _nullishCoalesce(_optionalChain([nav, 'optionalAccess', _64 => _64.gpu]), () => ( null));
+  return _nullishCoalesce(_optionalChain([nav, 'optionalAccess', _65 => _65.gpu]), () => ( null));
 }
 async function createWetGpuEngine(gpu = findWebGpu()) {
   const no = (reason, adapter2 = null) => ({ engine: null, support: { supported: false, reason, adapter: adapter2, maxSlots: 0 } });
@@ -2988,7 +3649,7 @@ async function createWetGpuEngine(gpu = findWebGpu()) {
     return no(`WebGPU gave no adapter (${e.message}); wet paint runs on the CPU.`);
   }
   if (!adapter) return no("WebGPU gave no adapter (the GPU may be blocklisted); wet paint runs on the CPU.");
-  const name = [_optionalChain([adapter, 'access', _65 => _65.info, 'optionalAccess', _66 => _66.vendor]), _optionalChain([adapter, 'access', _67 => _67.info, 'optionalAccess', _68 => _68.architecture])].filter(Boolean).join(" ") || null;
+  const name = [_optionalChain([adapter, 'access', _66 => _66.info, 'optionalAccess', _67 => _67.vendor]), _optionalChain([adapter, 'access', _68 => _68.info, 'optionalAccess', _69 => _69.architecture])].filter(Boolean).join(" ") || null;
   const binding = Math.min(_nullishCoalesce(adapter.limits.maxStorageBufferBindingSize, () => ( 0)), _nullishCoalesce(adapter.limits.maxBufferSize, () => ( 0)));
   const maxSlots = Math.min(MAX_WET_SLOTS, Math.floor(binding / SLOT_BYTES));
   if (maxSlots < 4) return no(`The GPU's storage buffers hold ${Math.max(0, maxSlots)} wet tiles; at least 4 are needed. Wet paint runs on the CPU.`, name);
@@ -3008,32 +3669,32 @@ async function createWetGpuEngine(gpu = findWebGpu()) {
     const engine = await WetGpuEngine.start(device, maxSlots, name);
     return { engine, support: { supported: true, reason: null, adapter: name, maxSlots } };
   } catch (e) {
-    _optionalChain([device, 'access', _69 => _69.destroy, 'optionalCall', _70 => _70()]);
+    _optionalChain([device, 'access', _70 => _70.destroy, 'optionalCall', _71 => _71()]);
     return no(`The wet-media shaders did not compile on this GPU (${e.message}); wet paint runs on the CPU.`, name);
   }
 }
 async function wetGpuSupport(gpu = findWebGpu()) {
   const { engine, support } = await createWetGpuEngine(gpu);
-  _optionalChain([engine, 'optionalAccess', _71 => _71.destroy, 'call', _72 => _72()]);
+  _optionalChain([engine, 'optionalAccess', _72 => _72.destroy, 'call', _73 => _73()]);
   return support;
 }
 async function pipeline(device, code, label) {
-  _optionalChain([device, 'access', _73 => _73.pushErrorScope, 'optionalCall', _74 => _74("validation")]);
+  _optionalChain([device, 'access', _74 => _74.pushErrorScope, 'optionalCall', _75 => _75("validation")]);
   const module = device.createShaderModule({ code, label });
-  const info = await _optionalChain([module, 'access', _75 => _75.getCompilationInfo, 'optionalCall', _76 => _76()]);
-  const errors = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _77 => _77.messages, 'access', _78 => _78.filter, 'call', _79 => _79((m) => m.type === "error")]), () => ( []));
+  const info = await _optionalChain([module, 'access', _76 => _76.getCompilationInfo, 'optionalCall', _77 => _77()]);
+  const errors = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _78 => _78.messages, 'access', _79 => _79.filter, 'call', _80 => _80((m) => m.type === "error")]), () => ( []));
   if (errors.length) {
-    await _optionalChain([device, 'access', _80 => _80.popErrorScope, 'optionalCall', _81 => _81()]);
+    await _optionalChain([device, 'access', _81 => _81.popErrorScope, 'optionalCall', _82 => _82()]);
     throw new Error(`${label}: ${errors.map((m) => `line ${m.lineNum}: ${m.message}`).join("; ")}`);
   }
   const desc = { layout: "auto", compute: { module, entryPoint: "main" }, label };
   const p = device.createComputePipelineAsync ? await device.createComputePipelineAsync(desc) : device.createComputePipeline(desc);
-  const err = await _optionalChain([device, 'access', _82 => _82.popErrorScope, 'optionalCall', _83 => _83()]);
+  const err = await _optionalChain([device, 'access', _83 => _83.popErrorScope, 'optionalCall', _84 => _84()]);
   if (err) throw new Error(`${label}: ${err.message}`);
   return p;
 }
-var WetGpuEngine = (_class3 = class _WetGpuEngine {
-  constructor(device, maxSlots, adapter, stepPipe, haloPipe, shadePipe) {;_class3.prototype.__init25.call(this);_class3.prototype.__init26.call(this);_class3.prototype.__init27.call(this);_class3.prototype.__init28.call(this);_class3.prototype.__init29.call(this);_class3.prototype.__init30.call(this);_class3.prototype.__init31.call(this);_class3.prototype.__init32.call(this);_class3.prototype.__init33.call(this);
+var WetGpuEngine = (_class6 = class _WetGpuEngine {
+  constructor(device, maxSlots, adapter, stepPipe, haloPipe, shadePipe) {;_class6.prototype.__init33.call(this);_class6.prototype.__init34.call(this);_class6.prototype.__init35.call(this);_class6.prototype.__init36.call(this);_class6.prototype.__init37.call(this);_class6.prototype.__init38.call(this);_class6.prototype.__init39.call(this);_class6.prototype.__init40.call(this);_class6.prototype.__init41.call(this);
     this.device = device;
     this.maxSlots = maxSlots;
     this.adapter = adapter;
@@ -3054,8 +3715,8 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
       return b;
     });
     this.shadeUni = d.createBuffer({ size: 16, usage: UNIFORM | COPY_DST, label: "wet shade" });
-    void _optionalChain([device, 'access', _84 => _84.lost, 'optionalAccess', _85 => _85.then, 'call', _86 => _86((info) => {
-      this.lostReason = _optionalChain([info, 'optionalAccess', _87 => _87.message]) || _optionalChain([info, 'optionalAccess', _88 => _88.reason]) || "the GPU device was lost";
+    void _optionalChain([device, 'access', _85 => _85.lost, 'optionalAccess', _86 => _86.then, 'call', _87 => _87((info) => {
+      this.lostReason = _optionalChain([info, 'optionalAccess', _88 => _88.message]) || _optionalChain([info, 'optionalAccess', _89 => _89.reason]) || "the GPU device was lost";
     })]);
   }
   
@@ -3065,23 +3726,23 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
   
   
   /** Steps run on the GPU so far (for stats). */
-  __init25() {this.steps = 0}
+  __init33() {this.steps = 0}
   /** Set once the device is lost; the engine does nothing after that. */
-  __init26() {this.lostReason = null}
+  __init34() {this.lostReason = null}
   
-  __init27() {this.slots = 0}
+  __init35() {this.slots = 0}
   
   
-  __init28() {this.jobCap = 0}
+  __init36() {this.jobCap = 0}
   
   
   
   
-  __init29() {this.srcTiles = null}
-  __init30() {this.outTiles = null}
-  __init31() {this.outRead = null}
-  __init32() {this.tileCap = 0}
-  __init33() {this.groups = null}
+  __init37() {this.srcTiles = null}
+  __init38() {this.outTiles = null}
+  __init39() {this.outRead = null}
+  __init40() {this.tileCap = 0}
+  __init41() {this.groups = null}
   /** @internal Compiles the kernels; use `createWetGpuEngine`. */
   static async start(device, maxSlots, adapter) {
     const [step, halo, shade] = await Promise.all([pipeline(device, WGSL_STEP, "wet step"), pipeline(device, WGSL_HALO, "wet halo"), pipeline(device, WGSL_SHADE, "wet shade")]);
@@ -3089,7 +3750,7 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
   }
   /** Bytes of GPU memory in use. */
   memoryBytes() {
-    return this.state.size + this.jobs.size + (_nullishCoalesce(_optionalChain([this, 'access', _89 => _89.srcTiles, 'optionalAccess', _90 => _90.size]), () => ( 0))) + (_nullishCoalesce(_optionalChain([this, 'access', _91 => _91.outTiles, 'optionalAccess', _92 => _92.size]), () => ( 0))) * 2;
+    return this.state.size + this.jobs.size + (_nullishCoalesce(_optionalChain([this, 'access', _90 => _90.srcTiles, 'optionalAccess', _91 => _91.size]), () => ( 0))) + (_nullishCoalesce(_optionalChain([this, 'access', _92 => _92.outTiles, 'optionalAccess', _93 => _93.size]), () => ( 0))) * 2;
   }
   /** Slots the state buffer holds now. */
   get capacity() {
@@ -3238,9 +3899,9 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
     const d = this.device;
     const tileBytes = TILE_WORDS * 4;
     if (n > this.tileCap || !this.outTiles || !this.outRead || !this.srcTiles) {
-      _optionalChain([this, 'access', _93 => _93.srcTiles, 'optionalAccess', _94 => _94.destroy, 'call', _95 => _95()]);
-      _optionalChain([this, 'access', _96 => _96.outTiles, 'optionalAccess', _97 => _97.destroy, 'call', _98 => _98()]);
-      _optionalChain([this, 'access', _99 => _99.outRead, 'optionalAccess', _100 => _100.destroy, 'call', _101 => _101()]);
+      _optionalChain([this, 'access', _94 => _94.srcTiles, 'optionalAccess', _95 => _95.destroy, 'call', _96 => _96()]);
+      _optionalChain([this, 'access', _97 => _97.outTiles, 'optionalAccess', _98 => _98.destroy, 'call', _99 => _99()]);
+      _optionalChain([this, 'access', _100 => _100.outRead, 'optionalAccess', _101 => _101.destroy, 'call', _102 => _102()]);
       this.tileCap = Math.max(n, this.tileCap * 2, 4);
       this.srcTiles = d.createBuffer({ size: this.tileCap * tileBytes, usage: STORAGE | COPY_DST, label: "wet base tiles" });
       this.outTiles = d.createBuffer({ size: this.tileCap * tileBytes, usage: STORAGE | COPY_SRC, label: "wet shaded tiles" });
@@ -3294,10 +3955,10 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
     return this.device.queue.onSubmittedWorkDone();
   }
   destroy() {
-    for (const b of [this.state, this.params, this.jobs, this.flags, this.flagsRead, ...this.uni, this.shadeUni, this.srcTiles, this.outTiles, this.outRead]) _optionalChain([b, 'optionalAccess', _102 => _102.destroy, 'call', _103 => _103()]);
+    for (const b of [this.state, this.params, this.jobs, this.flags, this.flagsRead, ...this.uni, this.shadeUni, this.srcTiles, this.outTiles, this.outRead]) _optionalChain([b, 'optionalAccess', _103 => _103.destroy, 'call', _104 => _104()]);
     this.device.destroy();
   }
-}, _class3);
+}, _class6);
 
 // src/paint/pointer.ts
 function pointerPressure(e) {
@@ -3320,7 +3981,7 @@ function pointerStrokeSample(e, toPoint) {
   return s;
 }
 function pointerStrokeSamples(e, toPoint) {
-  const events = _nullishCoalesce(_optionalChain([e, 'access', _104 => _104.getCoalescedEvents, 'optionalCall', _105 => _105()]), () => ( []));
+  const events = _nullishCoalesce(_optionalChain([e, 'access', _105 => _105.getCoalescedEvents, 'optionalCall', _106 => _106()]), () => ( []));
   return (events.length ? events : [e]).map((ev) => pointerStrokeSample(ev, toPoint));
 }
 
@@ -3419,4 +4080,34 @@ function pointerStrokeSamples(e, toPoint) {
 
 
 
-exports.createPigmentTools = createPigmentTools; exports.WET_TILE = WET_TILE; exports.SLOT_SIDE = SLOT_SIDE; exports.PLANE = PLANE; exports.PLANE_BYTES = PLANE_BYTES; exports.SET_PLANES = SET_PLANES; exports.P_RHO = P_RHO; exports.P_UX = P_UX; exports.P_UY = P_UY; exports.P_SW = P_SW; exports.P_P0 = P_P0; exports.P_L = P_L; exports.P_EDGE = P_EDGE; exports.P_D0 = P_D0; exports.P_DL = P_DL; exports.P_H = P_H; exports.P_FX = P_FX; exports.P_FY = P_FY; exports.SLOT_PLANES = SLOT_PLANES; exports.SLOT_BYTES = SLOT_BYTES; exports.PIGMENT_CHANNELS = PIGMENT_CHANNELS; exports.MASS_CHANNELS = MASS_CHANNELS; exports.EX = EX; exports.EY = EY; exports.OPP = OPP; exports.W9 = W9; exports.DRY_EPS = DRY_EPS; exports.U_MAX = U_MAX; exports.STRIP = STRIP; exports.MAX_BATCH = MAX_BATCH; exports.FREE_INTERVAL = FREE_INTERVAL; exports.FLAG_ALIVE = FLAG_ALIVE; exports.FLAG_LEFT = FLAG_LEFT; exports.FLAG_RIGHT = FLAG_RIGHT; exports.FLAG_TOP = FLAG_TOP; exports.FLAG_BOTTOM = FLAG_BOTTOM; exports.FLAG_WET = FLAG_WET; exports.PARAM_FLOATS = PARAM_FLOATS; exports.PARAM = PARAM; exports.DEFAULT_WET_PARAMS = DEFAULT_WET_PARAMS; exports.WET_PARAM_KEYS = WET_PARAM_KEYS; exports.DEFAULT_WET_PAPER = DEFAULT_WET_PAPER; exports.FLAT = FLAT; exports.normalizeWetParams = normalizeWetParams; exports.normalizeTilt = normalizeTilt; exports.latticeViscosity = latticeViscosity; exports.PAPER_CAPACITY = PAPER_CAPACITY; exports.MAX_TILT_ACCEL = MAX_TILT_ACCEL; exports.packWetParams = packWetParams; exports.edgeBits = edgeBits; exports.PIGMENT_UNIT = PIGMENT_UNIT; exports.HIDE = HIDE; exports.BODY_SCATTER = BODY_SCATTER; exports.dexp = dexp; exports.dlog = dlog; exports.dpow = dpow; exports.SRGB_TO_LINEAR = SRGB_TO_LINEAR; exports.srgbByteToLinear = srgbByteToLinear; exports.linearToSrgb8 = linearToSrgb8; exports.pigmentOf = pigmentOf; exports.expNeg = expNeg; exports.filmReflectance = filmReflectance; exports.pigmentColor = pigmentColor; exports.filmPixel = filmPixel; exports.pixelPigment = pixelPigment; exports.shadeTile = shadeTile; exports.shadeLightTile = shadeLightTile; exports.stepSlotTs = stepSlotTs; exports.loadWetKernel = loadWetKernel; exports.canShareMemory = canShareMemory; exports.wetSimdSupported = wetSimdSupported; exports.wetSupport = wetSupport; exports.WetWorkerPool = WetWorkerPool; exports.MAX_WET_LANES = MAX_WET_LANES; exports.MAX_WET_SLOTS = MAX_WET_SLOTS; exports.WetWorldError = WetWorldError; exports.WetWorld = WetWorld; exports.moveWetSnapshot = moveWetSnapshot; exports.WET_FLOW_KINDS = WET_FLOW_KINDS; exports.DEFAULT_FLOW = DEFAULT_FLOW; exports.dsincos = dsincos; exports.normalizeFlow = normalizeFlow; exports.flowField = flowField; exports.WetMedium = WetMedium; exports.WGSL_STEP = WGSL_STEP; exports.WGSL_HALO = WGSL_HALO; exports.WGSL_SHADE = WGSL_SHADE; exports.findWebGpu = findWebGpu; exports.createWetGpuEngine = createWetGpuEngine; exports.wetGpuSupport = wetGpuSupport; exports.WetGpuEngine = WetGpuEngine; exports.pointerPressure = pointerPressure; exports.pointerStrokeSample = pointerStrokeSample; exports.pointerStrokeSamples = pointerStrokeSamples;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.createPigmentTools = createPigmentTools; exports.TONE_RANGES = TONE_RANGES; exports.luma = luma; exports.dodgeBurnCurve = dodgeBurnCurve; exports.dodgeBurn = dodgeBurn; exports.saturationOf = saturationOf; exports.sponge = sponge; exports.perDabStrength = perDabStrength; exports.RETOUCH_SAMPLES = RETOUCH_SAMPLES; exports.SPOT_HEAL_TYPES = SPOT_HEAL_TYPES; exports.DEFAULT_RETOUCH = DEFAULT_RETOUCH; exports.normalizeRetouch = normalizeRetouch; exports.boxBlurPixels = boxBlurPixels; exports.retouchFilter = retouchFilter; exports.IDENTITY_CLONE_TRANSFORM = IDENTITY_CLONE_TRANSFORM; exports.isIdentityCloneTransform = isIdentityCloneTransform; exports.cloneSamplePoint = cloneSamplePoint; exports.TransformedPixelSource = TransformedPixelSource; exports.TilePixelSource = TilePixelSource; exports.RegionPixelSource = RegionPixelSource; exports.readSourceRegion = readSourceRegion; exports.applyRetouchToTile = applyRetouchToTile; exports.applyToneToDeepTile = applyToneToDeepTile; exports.toneOf = toneOf; exports.healPixels = healPixels; exports.spotHealPixels = spotHealPixels; exports.spotHealWindow = spotHealWindow; exports.RetouchDabStroke = RetouchDabStroke; exports.smudgeEffect = smudgeEffect; exports.spongeEffect = spongeEffect; exports.rgbaViewOfGrey = rgbaViewOfGrey; exports.WET_TILE = WET_TILE; exports.SLOT_SIDE = SLOT_SIDE; exports.PLANE = PLANE; exports.PLANE_BYTES = PLANE_BYTES; exports.SET_PLANES = SET_PLANES; exports.P_RHO = P_RHO; exports.P_UX = P_UX; exports.P_UY = P_UY; exports.P_SW = P_SW; exports.P_P0 = P_P0; exports.P_L = P_L; exports.P_EDGE = P_EDGE; exports.P_D0 = P_D0; exports.P_DL = P_DL; exports.P_H = P_H; exports.P_FX = P_FX; exports.P_FY = P_FY; exports.SLOT_PLANES = SLOT_PLANES; exports.SLOT_BYTES = SLOT_BYTES; exports.PIGMENT_CHANNELS = PIGMENT_CHANNELS; exports.MASS_CHANNELS = MASS_CHANNELS; exports.EX = EX; exports.EY = EY; exports.OPP = OPP; exports.W9 = W9; exports.DRY_EPS = DRY_EPS; exports.U_MAX = U_MAX; exports.STRIP = STRIP; exports.MAX_BATCH = MAX_BATCH; exports.FREE_INTERVAL = FREE_INTERVAL; exports.FLAG_ALIVE = FLAG_ALIVE; exports.FLAG_LEFT = FLAG_LEFT; exports.FLAG_RIGHT = FLAG_RIGHT; exports.FLAG_TOP = FLAG_TOP; exports.FLAG_BOTTOM = FLAG_BOTTOM; exports.FLAG_WET = FLAG_WET; exports.PARAM_FLOATS = PARAM_FLOATS; exports.PARAM = PARAM; exports.DEFAULT_WET_PARAMS = DEFAULT_WET_PARAMS; exports.WET_PARAM_KEYS = WET_PARAM_KEYS; exports.DEFAULT_WET_PAPER = DEFAULT_WET_PAPER; exports.FLAT = FLAT; exports.normalizeWetParams = normalizeWetParams; exports.normalizeTilt = normalizeTilt; exports.latticeViscosity = latticeViscosity; exports.PAPER_CAPACITY = PAPER_CAPACITY; exports.MAX_TILT_ACCEL = MAX_TILT_ACCEL; exports.packWetParams = packWetParams; exports.edgeBits = edgeBits; exports.PIGMENT_UNIT = PIGMENT_UNIT; exports.HIDE = HIDE; exports.BODY_SCATTER = BODY_SCATTER; exports.dexp = dexp; exports.dlog = dlog; exports.dpow = dpow; exports.SRGB_TO_LINEAR = SRGB_TO_LINEAR; exports.srgbByteToLinear = srgbByteToLinear; exports.linearToSrgb8 = linearToSrgb8; exports.pigmentOf = pigmentOf; exports.expNeg = expNeg; exports.filmReflectance = filmReflectance; exports.pigmentColor = pigmentColor; exports.filmPixel = filmPixel; exports.pixelPigment = pixelPigment; exports.shadeTile = shadeTile; exports.shadeLightTile = shadeLightTile; exports.stepSlotTs = stepSlotTs; exports.loadWetKernel = loadWetKernel; exports.canShareMemory = canShareMemory; exports.wetSimdSupported = wetSimdSupported; exports.wetSupport = wetSupport; exports.WetWorkerPool = WetWorkerPool; exports.MAX_WET_LANES = MAX_WET_LANES; exports.MAX_WET_SLOTS = MAX_WET_SLOTS; exports.WetWorldError = WetWorldError; exports.WetWorld = WetWorld; exports.moveWetSnapshot = moveWetSnapshot; exports.WET_FLOW_KINDS = WET_FLOW_KINDS; exports.DEFAULT_FLOW = DEFAULT_FLOW; exports.dsincos = dsincos; exports.normalizeFlow = normalizeFlow; exports.flowField = flowField; exports.WetMedium = WetMedium; exports.WGSL_STEP = WGSL_STEP; exports.WGSL_HALO = WGSL_HALO; exports.WGSL_SHADE = WGSL_SHADE; exports.findWebGpu = findWebGpu; exports.createWetGpuEngine = createWetGpuEngine; exports.wetGpuSupport = wetGpuSupport; exports.WetGpuEngine = WetGpuEngine; exports.pointerPressure = pointerPressure; exports.pointerStrokeSample = pointerStrokeSample; exports.pointerStrokeSamples = pointerStrokeSamples;