@pixerate/editor 0.112.0 → 0.114.0

package/dist/chunk-DFQEX3AM.cjs

@@ -0,0 +1,781 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkTCKIXI46cjs = require('./chunk-TCKIXI46.cjs');
+
+
+
+
+var _chunkTFOPHZ3Ucjs = require('./chunk-TFOPHZ3U.cjs');
+
+// src/paint/heal.ts
+var TOL = 2e-3;
+var FINE_ITERS = 30;
+var FINE_OMEGA = 1.7;
+function solveMembrane(w, h, unknown, v) {
+  if (unknown.length !== w * h || v.length !== w * h) throw new RangeError(`solveMembrane: expected ${w * h} cells, got ${unknown.length} and ${v.length}.`);
+  const u = new Uint8Array(w * h);
+  for (let i = 0; i < u.length; i++) u[i] = unknown[i] ? 1 : 0;
+  solveLevel(w, h, u, v, 0);
+}
+function solveLevel(w, h, unknown, v, depth) {
+  let nUnknown = 0;
+  let knownSum = 0;
+  let nKnown = 0;
+  for (let i = 0; i < unknown.length; i++) {
+    if (unknown[i]) nUnknown++;
+    else {
+      knownSum += v[i];
+      nKnown++;
+    }
+  }
+  if (nUnknown === 0 || nKnown === 0) return;
+  if (w >= 8 && h >= 8 && nUnknown > 64 && depth < 16) {
+    const cw = Math.ceil(w / 2);
+    const chh = Math.ceil(h / 2);
+    const cu = new Uint8Array(cw * chh).fill(1);
+    const cv = new Float32Array(cw * chh);
+    for (let cy = 0; cy < chh; cy++) {
+      for (let cx = 0; cx < cw; cx++) {
+        let s = 0;
+        let n = 0;
+        for (let k = 0; k < 4; k++) {
+          const x = cx * 2 + (k & 1);
+          const y = cy * 2 + (k >> 1);
+          if (x < w && y < h && !unknown[y * w + x]) {
+            s += v[y * w + x];
+            n++;
+          }
+        }
+        if (n > 0) {
+          cu[cy * cw + cx] = 0;
+          cv[cy * cw + cx] = s / n;
+        }
+      }
+    }
+    solveLevel(cw, chh, cu, cv, depth + 1);
+    for (let y = 0; y < h; y++) {
+      const fy = Math.min(chh - 1, Math.max(0, (y + 0.5) / 2 - 0.5));
+      const y0 = Math.floor(fy);
+      const y1 = Math.min(chh - 1, y0 + 1);
+      const ty = fy - y0;
+      for (let x = 0; x < w; x++) {
+        if (!unknown[y * w + x]) continue;
+        const fx = Math.min(cw - 1, Math.max(0, (x + 0.5) / 2 - 0.5));
+        const x0 = Math.floor(fx);
+        const x1 = Math.min(cw - 1, x0 + 1);
+        const tx = fx - x0;
+        const a = cv[y0 * cw + x0] + (cv[y0 * cw + x1] - cv[y0 * cw + x0]) * tx;
+        const b = cv[y1 * cw + x0] + (cv[y1 * cw + x1] - cv[y1 * cw + x0]) * tx;
+        v[y * w + x] = a + (b - a) * ty;
+      }
+    }
+    sor(w, h, unknown, v, FINE_ITERS, FINE_OMEGA);
+  } else {
+    const mean = knownSum / nKnown;
+    for (let i = 0; i < v.length; i++) if (unknown[i]) v[i] = mean;
+    sor(w, h, unknown, v, 2e3, 1.85);
+  }
+}
+function sor(w, h, unknown, v, maxIter, omega) {
+  let n = 0;
+  for (let i = 0; i < unknown.length; i++) if (unknown[i]) n++;
+  const cells = new Uint32Array(n);
+  const masks = new Uint8Array(n);
+  for (let i = 0, k = 0; i < unknown.length; i++) {
+    if (!unknown[i]) continue;
+    const x = i % w;
+    const y = (i - x) / w;
+    cells[k] = i;
+    masks[k++] = (x > 0 ? 1 : 0) | (x + 1 < w ? 2 : 0) | (y > 0 ? 4 : 0) | (y + 1 < h ? 8 : 0);
+  }
+  for (let it = 0; it < maxIter; it++) {
+    let maxD = 0;
+    for (let k = 0; k < n; k++) {
+      const i = cells[k];
+      const m = masks[k];
+      let s;
+      let c;
+      if (m === 15) {
+        s = v[i - 1] + v[i + 1] + v[i - w] + v[i + w];
+        c = 4;
+      } else {
+        s = 0;
+        c = 0;
+        if (m & 1) s += v[i - 1], c++;
+        if (m & 2) s += v[i + 1], c++;
+        if (m & 4) s += v[i - w], c++;
+        if (m & 8) s += v[i + w], c++;
+        if (c === 0) continue;
+      }
+      const d = omega * (s / c - v[i]);
+      v[i] += d;
+      const ad = d < 0 ? -d : d;
+      if (ad > maxD) maxD = ad;
+    }
+    if (maxD < TOL) break;
+  }
+}
+function seamlessClone(w, h, ch, src, dst, mask) {
+  const n = w * h;
+  if (src.length !== n * ch || dst.length !== n * ch || mask.length !== n) throw new RangeError("seamlessClone: src, dst and mask must cover w \xD7 h pixels.");
+  const out = new Float32Array(n * ch);
+  const hv = new Float32Array(n);
+  for (let c = 0; c < ch; c++) {
+    for (let i = 0; i < n; i++) hv[i] = mask[i] ? 0 : dst[i * ch + c] - src[i * ch + c];
+    solveMembrane(w, h, mask, hv);
+    for (let i = 0; i < n; i++) out[i * ch + c] = mask[i] ? src[i * ch + c] + hv[i] : dst[i * ch + c];
+  }
+  return out;
+}
+function membraneFill(w, h, ch, img, hole) {
+  const n = w * h;
+  const out = new Float32Array(n * ch);
+  const v = new Float32Array(n);
+  for (let c = 0; c < ch; c++) {
+    for (let i = 0; i < n; i++) v[i] = hole[i] ? 0 : img[i * ch + c];
+    solveMembrane(w, h, hole, v);
+    for (let i = 0; i < n; i++) out[i * ch + c] = v[i];
+  }
+  return out;
+}
+function dilateMask(w, h, mask, r) {
+  const tmp = new Uint8Array(w * h);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (!mask[y * w + x]) continue;
+      for (let xx = Math.max(0, x - r); xx <= Math.min(w - 1, x + r); xx++) tmp[y * w + xx] = 1;
+    }
+  }
+  const out = new Uint8Array(w * h);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (!tmp[y * w + x]) continue;
+      for (let yy = Math.max(0, y - r); yy <= Math.min(h - 1, y + r); yy++) out[yy * w + x] = 1;
+    }
+  }
+  return out;
+}
+var MaskIntegral = class {
+  constructor(w, h, mask) {
+    this.w = w;
+    this.h = h;
+    const W = w + 1;
+    this.s = new Uint32Array(W * (h + 1));
+    for (let y = 0; y < h; y++) {
+      let row = 0;
+      for (let x = 0; x < w; x++) {
+        row += mask[y * w + x] ? 1 : 0;
+        this.s[(y + 1) * W + x + 1] = this.s[y * W + x + 1] + row;
+      }
+    }
+  }
+  
+  
+  
+  /** Masked cells in [x0, x1) × [y0, y1) (clipped to the grid). */
+  count(x0, y0, x1, y1) {
+    const W = this.w + 1;
+    const a = Math.max(0, Math.min(this.w, x0));
+    const b = Math.max(0, Math.min(this.h, y0));
+    const c = Math.max(0, Math.min(this.w, x1));
+    const d = Math.max(0, Math.min(this.h, y1));
+    if (c <= a || d <= b) return 0;
+    return this.s[d * W + c] - this.s[b * W + c] - this.s[d * W + a] + this.s[b * W + a];
+  }
+};
+function maskBounds(w, h, mask) {
+  let x0 = w;
+  let y0 = h;
+  let x1 = -1;
+  let y1 = -1;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (!mask[y * w + x]) continue;
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+    }
+  }
+  return x1 < 0 ? null : [x0, y0, x1 + 1, y1 + 1];
+}
+function bestOffset(w, h, ch, img, hole, ring, maxRadius) {
+  const bb = maskBounds(w, h, hole);
+  if (!bb) return null;
+  const extent = Math.max(w, h);
+  const R = Math.max(0, Math.min(extent, Math.floor(maxRadius)));
+  if (R === 0) return null;
+  const rg = Math.max(1, Math.min(extent, Math.floor(ring)));
+  const hs = new MaskIntegral(w, h, hole);
+  const x0 = bb[0] - rg;
+  const y0 = bb[1] - rg;
+  const x1 = bb[2] + rg;
+  const y1 = bb[3] + rg;
+  const pts = [];
+  for (let y = Math.max(0, y0); y < Math.min(h, y1); y++) {
+    for (let x = Math.max(0, x0); x < Math.min(w, x1); x++) {
+      if (hole[y * w + x]) continue;
+      if (hs.count(x - rg, y - rg, x + rg + 1, y + rg + 1) > 0) pts.push(x, y);
+    }
+  }
+  const stride = Math.max(1, Math.floor(pts.length / 2 / 2e3));
+  const sx = [];
+  const sy = [];
+  for (let i = 0; i < pts.length; i += 2 * stride) {
+    sx.push(pts[i]);
+    sy.push(pts[i + 1]);
+  }
+  const n = Math.max(1, sx.length);
+  const evalAt = (dx, dy, cutoff) => {
+    if (dx === 0 && dy === 0) return null;
+    const hx0 = x0 + dx;
+    const hy0 = y0 + dy;
+    const hx1 = x1 + dx;
+    const hy1 = y1 + dy;
+    if (hx0 < 0 || hy0 < 0 || hx1 > w || hy1 > h) return null;
+    if (hs.count(hx0, hy0, hx1, hy1) !== 0) return null;
+    const penalty = 1 + 1e-3 * (Math.hypot(dx, dy) / R);
+    let e = 0;
+    for (let i = 0; i < sx.length; i++) {
+      const a = (sy[i] * w + sx[i]) * ch;
+      const b = ((sy[i] + dy) * w + sx[i] + dx) * ch;
+      for (let c = 0; c < ch; c++) {
+        const d = img[a + c] - img[b + c];
+        e += d * d;
+      }
+      if ((i & 31) === 31 && e / n * penalty >= cutoff) return null;
+    }
+    return e / n * penalty;
+  };
+  const found = { best: null, e: Infinity };
+  const consider = (dx, dy) => {
+    const e = evalAt(dx, dy, found.e);
+    if (e !== null && e < found.e) {
+      found.e = e;
+      found.best = [dx, dy];
+    }
+  };
+  const step = Math.max(1, Math.floor(R / 24));
+  for (let dy = -R; dy <= R; dy += step) for (let dx = -R; dx <= R; dx += step) consider(dx, dy);
+  if (step > 1 && found.best) {
+    const [bx, by] = found.best;
+    for (let dy = by - step; dy <= by + step; dy++) for (let dx = bx - step; dx <= bx + step; dx++) consider(dx, dy);
+  }
+  return found.best;
+}
+
+// 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", "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
+};
+function normalizeRetouch(raw = {}, base = DEFAULT_RETOUCH) {
+  const unit = (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: unit(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: unit(raw.strength, base.strength)
+  };
+}
+var TilePixelSource = (_class = class {
+  constructor(readTile, channels, offset = { x: 0, y: 0 }) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    this.readTile = readTile;
+    this.channels = channels;
+    this.offset = offset;
+  }
+  
+  
+  
+  __init() {this.cache = /* @__PURE__ */ new Map()}
+  __init2() {this.lastKey = NaN}
+  __init3() {this.last = null}
+  sample(x, y, out) {
+    const lx = x - this.offset.x;
+    const ly = y - this.offset.y;
+    const tx = Math.floor(lx / _chunkTFOPHZ3Ucjs.TILE);
+    const ty = Math.floor(ly / _chunkTFOPHZ3Ucjs.TILE);
+    const key = _chunkTFOPHZ3Ucjs.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 * _chunkTFOPHZ3Ucjs.TILE) * _chunkTFOPHZ3Ucjs.TILE + (lx - tx * _chunkTFOPHZ3Ucjs.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;
+  }
+}, _class);
+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 = options.into ? new Uint8ClampedArray(options.into) : new Uint8ClampedArray(tileData);
+  const ox = tx * _chunkTFOPHZ3Ucjs.TILE + s.offset.x;
+  const oy = ty * _chunkTFOPHZ3Ucjs.TILE + s.offset.y;
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = _chunkTFOPHZ3Ucjs.TILE;
+  let y1 = _chunkTFOPHZ3Ucjs.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(_chunkTFOPHZ3Ucjs.TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(_chunkTFOPHZ3Ucjs.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 * _chunkTFOPHZ3Ucjs.TILE + x0) * channels, (y * _chunkTFOPHZ3Ucjs.TILE + x1) * channels), (y * _chunkTFOPHZ3Ucjs.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 / _chunkTFOPHZ3Ucjs.TILE);
+    for (let x = x0; x < x1; x++) {
+      const dx = ox + x;
+      const ctx = Math.floor(dx / _chunkTFOPHZ3Ucjs.TILE);
+      const key = _chunkTFOPHZ3Ucjs.tileKey.call(void 0, ctx, cty);
+      if (key !== covKey) {
+        covKey = key;
+        covTile = coverage.tiles.get(key);
+      }
+      if (!covTile) continue;
+      const c = covTile[(dy - cty * _chunkTFOPHZ3Ucjs.TILE) * _chunkTFOPHZ3Ucjs.TILE + (dx - ctx * _chunkTFOPHZ3Ucjs.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 * _chunkTFOPHZ3Ucjs.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);
+        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);
+        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 = _chunkTFOPHZ3Ucjs.blendPixel.call(void 0, 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);
+    }
+  }
+  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 off = bestOffset(w, h, 4, img, domain, ring, Math.floor(Math.max(w, h) / 2));
+    if (off) {
+      bestFound = off;
+      filled = new Float32Array(img);
+      const [ddx, ddy] = off;
+      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) 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 = (_class2 = class {
+  constructor(brush, target, effect) {;_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);
+    this.brush = brush;
+    this.effect = effect;
+    this.walker = new (0, _chunkTCKIXI46cjs.DabWalker)(brush);
+    this.medium = new (0, _chunkTCKIXI46cjs.TileMedium)(target);
+  }
+  
+  
+  __init4() {this.dabCount = 0}
+  __init5() {this.bounds = null}
+  
+  
+  __init6() {this.smoothPos = null}
+  __init7() {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 = _chunkTCKIXI46cjs.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);
+      _chunkTCKIXI46cjs.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;
+  }
+}, _class2);
+function smudgeEffect(brush, strength, mixing = "rgb") {
+  const s = Math.min(1, Math.max(0, strength));
+  const tip = new (0, _chunkTCKIXI46cjs.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);
+        px[i] = Math.round(rgb[0] * 255);
+        px[i + 1] = Math.round(rgb[1] * 255);
+        px[i + 2] = Math.round(rgb[2] * 255);
+      }
+    }
+  };
+}
+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 = _chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty);
+      let v = views.get(key);
+      if (!v) {
+        v = expand(_nullishCoalesce(target.readTile(tx, ty), () => ( new Uint8ClampedArray(_chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.TILE))));
+        views.set(key, v);
+      }
+      return v;
+    },
+    writeTile: (tx, ty) => {
+      const key = _chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty);
+      let v = views.get(key);
+      if (!v) {
+        v = expand(_nullishCoalesce(target.readTile(tx, ty), () => ( new Uint8ClampedArray(_chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.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 };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.solveMembrane = solveMembrane; exports.seamlessClone = seamlessClone; exports.membraneFill = membraneFill; exports.dilateMask = dilateMask; exports.maskBounds = maskBounds; exports.bestOffset = bestOffset; 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.TilePixelSource = TilePixelSource; exports.RegionPixelSource = RegionPixelSource; exports.readSourceRegion = readSourceRegion; exports.applyRetouchToTile = applyRetouchToTile; exports.toneOf = toneOf; exports.healPixels = healPixels; exports.spotHealPixels = spotHealPixels; exports.spotHealWindow = spotHealWindow; exports.RetouchDabStroke = RetouchDabStroke; exports.smudgeEffect = smudgeEffect; exports.spongeEffect = spongeEffect; exports.rgbaViewOfGrey = rgbaViewOfGrey;
+//# sourceMappingURL=chunk-DFQEX3AM.cjs.map