@pixerate/editor 0.207.0 → 0.208.0

package/dist/chunk-DWYQPL2A.js

@@ -0,0 +1,2010 @@
+import {
+  combineSelections,
+  coverageToByte,
+  createSelectionMask,
+  distanceTransform,
+  greyMorphology,
+  selectionFromRegion,
+  selectionValueAt,
+  shiftCoverage
+} from "./chunk-L3G23N5Y.js";
+import {
+  gaussianBlur
+} from "./chunk-ZIF4UJJ6.js";
+
+// src/image-editor/selection/refine.ts
+var DEFAULT_REFINE_EDGE_PARAMS = {
+  radius: 0,
+  smartRadius: false,
+  smooth: 0,
+  feather: 0,
+  contrast: 0,
+  shiftEdge: 0
+};
+var GUIDED_FILTER_EPS = 1e-4;
+var fin = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+function normalizeRefineEdgeParams(p = {}) {
+  return {
+    radius: Math.min(250, Math.max(0, fin(p.radius, 0))),
+    smartRadius: p.smartRadius === true,
+    smooth: Math.min(100, Math.max(0, fin(p.smooth, 0))),
+    feather: Math.min(1e3, Math.max(0, fin(p.feather, 0))),
+    contrast: Math.min(100, Math.max(0, fin(p.contrast, 0))),
+    shiftEdge: Math.min(100, Math.max(-100, fin(p.shiftEdge, 0)))
+  };
+}
+var gfRadius = (p) => Math.min(64, Math.max(1, Math.ceil(p.radius)));
+var smoothSigma = (p) => p.smooth / 100 * 4;
+var featherSigma = (p) => p.feather / 2;
+function shiftAmount(p) {
+  const px = p.shiftEdge / 100 * Math.max(p.radius, 4);
+  return Number.isFinite(px) ? Math.min(64, Math.max(-64, px)) : 0;
+}
+function refineEdgeHalo(params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  const g = gfRadius(p);
+  const edge = p.radius > 0 ? Math.max(Math.ceil(p.radius), 2 * g + (p.smartRadius ? g + 1 : 0)) : 0;
+  return edge + Math.ceil(3 * smoothSigma(p)) + Math.ceil(3 * featherSigma(p)) + Math.ceil(Math.abs(shiftAmount(p))) + 2;
+}
+function boxMean(src, w, h, r) {
+  const tmp = new Float32Array(w * h);
+  const pre = new Float64Array(Math.max(w, h) + 1);
+  for (let y = 0; y < h; y++) {
+    const row = y * w;
+    for (let x = 0; x < w; x++) pre[x + 1] = pre[x] + src[row + x];
+    for (let x = 0; x < w; x++) {
+      const lo = Math.max(0, x - r);
+      const hi = Math.min(w, x + r + 1);
+      tmp[row + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  const out = new Float32Array(w * h);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) pre[y + 1] = pre[y] + tmp[y * w + x];
+    for (let y = 0; y < h; y++) {
+      const lo = Math.max(0, y - r);
+      const hi = Math.min(h, y + r + 1);
+      out[y * w + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  return out;
+}
+function guidedFilterColor(guide, p, w, h, r, eps = GUIDED_FILTER_EPS) {
+  const n = w * h;
+  const [c0, c1, c2] = guide;
+  const prod = (a, b2) => {
+    const o = new Float32Array(n);
+    for (let i = 0; i < n; i++) o[i] = a[i] * b2[i];
+    return o;
+  };
+  const m0 = boxMean(c0, w, h, r);
+  const m1 = boxMean(c1, w, h, r);
+  const m2 = boxMean(c2, w, h, r);
+  const mp = boxMean(p, w, h, r);
+  const mip0 = boxMean(prod(c0, p), w, h, r);
+  const mip1 = boxMean(prod(c1, p), w, h, r);
+  const mip2 = boxMean(prod(c2, p), w, h, r);
+  const s00 = boxMean(prod(c0, c0), w, h, r);
+  const s01 = boxMean(prod(c0, c1), w, h, r);
+  const s02 = boxMean(prod(c0, c2), w, h, r);
+  const s11 = boxMean(prod(c1, c1), w, h, r);
+  const s12 = boxMean(prod(c1, c2), w, h, r);
+  const s22 = boxMean(prod(c2, c2), w, h, r);
+  const a0 = new Float32Array(n);
+  const a1 = new Float32Array(n);
+  const a2 = new Float32Array(n);
+  const b = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const u0 = m0[i], u1 = m1[i], u2 = m2[i], up = mp[i];
+    const rr = s00[i] - u0 * u0 + eps;
+    const rg = s01[i] - u0 * u1;
+    const rb = s02[i] - u0 * u2;
+    const gg = s11[i] - u1 * u1 + eps;
+    const gb = s12[i] - u1 * u2;
+    const bb = s22[i] - u2 * u2 + eps;
+    const v0 = mip0[i] - u0 * up;
+    const v1 = mip1[i] - u1 * up;
+    const v2 = mip2[i] - u2 * up;
+    const i00 = gg * bb - gb * gb;
+    const i01 = gb * rb - rg * bb;
+    const i02 = rg * gb - gg * rb;
+    const i11 = rr * bb - rb * rb;
+    const i12 = rb * rg - rr * gb;
+    const i22 = rr * gg - rg * rg;
+    const det = rr * i00 + rg * i01 + rb * i02;
+    let x0 = 0, x1 = 0, x2 = 0;
+    if (Math.abs(det) >= 1e-30) {
+      x0 = (i00 * v0 + i01 * v1 + i02 * v2) / det;
+      x1 = (i01 * v0 + i11 * v1 + i12 * v2) / det;
+      x2 = (i02 * v0 + i12 * v1 + i22 * v2) / det;
+    }
+    a0[i] = x0;
+    a1[i] = x1;
+    a2[i] = x2;
+    b[i] = up - x0 * u0 - x1 * u1 - x2 * u2;
+  }
+  const ma0 = boxMean(a0, w, h, r);
+  const ma1 = boxMean(a1, w, h, r);
+  const ma2 = boxMean(a2, w, h, r);
+  const mb = boxMean(b, w, h, r);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = ma0[i] * c0[i] + ma1[i] * c1[i] + ma2[i] * c2[i] + mb[i];
+  return out;
+}
+function edgeWidth(guide, w, h, r) {
+  const n = w * h;
+  const y = new Float32Array(n);
+  for (let i = 0; i < n; i++) y[i] = 0.299 * guide[0][i] + 0.587 * guide[1][i] + 0.114 * guide[2][i];
+  const g = new Float32Array(n);
+  for (let yy = 0; yy < h; yy++) {
+    for (let xx = 0; xx < w; xx++) {
+      const gx = (y[yy * w + Math.min(w - 1, xx + 1)] - y[yy * w + Math.max(0, xx - 1)]) / 2;
+      const gy = (y[Math.min(h - 1, yy + 1) * w + xx] - y[Math.max(0, yy - 1) * w + xx]) / 2;
+      g[yy * w + xx] = Math.sqrt(gx * gx + gy * gy);
+    }
+  }
+  const gm = greyMorphology(g, w, h, r, true);
+  const hi = greyMorphology(y, w, h, r, true);
+  const lo = greyMorphology(y, w, h, r, false);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = (hi[i] - lo[i]) / Math.max(gm[i], 1e-4);
+  return out;
+}
+function refineCoverage(guide, m, w, h, params = {}, band = null) {
+  const p = normalizeRefineEdgeParams(params);
+  let a = Float32Array.from(m);
+  if ((p.radius > 0 || band) && guide) {
+    const n = w * h;
+    const boundary = new Uint8Array(n);
+    let any = false;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const i = y * w + x;
+        const v = m[i] >= 0.5;
+        const diff = x > 0 && m[i - 1] >= 0.5 !== v || x + 1 < w && m[i + 1] >= 0.5 !== v || y > 0 && m[i - w] >= 0.5 !== v || y + 1 < h && m[i + w] >= 0.5 !== v;
+        if (diff) {
+          boundary[i] = 1;
+          any = true;
+        }
+      }
+    }
+    if (any || band) {
+      const dist = distanceTransform(boundary, w, h);
+      const r = band ? Math.max(4, gfRadius(p)) : gfRadius(p);
+      const q = guidedFilterColor(guide, m, w, h, r);
+      const widths = p.smartRadius ? edgeWidth(guide, w, h, r) : null;
+      for (let i = 0; i < n; i++) {
+        const reff = widths ? Math.min(Math.max(p.radius, 1.5), Math.max(1.5, widths[i])) : p.radius;
+        const edge = p.radius > 0 ? Math.min(1, Math.max(0, reff + 1 - dist[i])) : 0;
+        const wgt = band ? Math.max(edge, Math.min(1, Math.max(0, band[i]))) : edge;
+        if (wgt > 0) {
+          const qi = Math.min(1, Math.max(0, q[i]));
+          a[i] = m[i] + (qi - m[i]) * wgt;
+        }
+      }
+    }
+  }
+  const ss = smoothSigma(p);
+  if (ss >= 0.3) {
+    a = gaussianBlur(a, w, h, ss, "clamp");
+    const gain = 1 + ss;
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  a = gaussianBlur(a, w, h, featherSigma(p), "clamp");
+  if (p.contrast > 0) {
+    const gain = 1 / (1 - 0.99 * p.contrast / 100);
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  const amount = shiftAmount(p);
+  if (Math.abs(amount) >= 1e-4) a = shiftCoverage(a, w, h, amount);
+  return a;
+}
+function guidePlanes(pixels, win) {
+  const box = win ?? { x: 0, y: 0, width: pixels.width, height: pixels.height };
+  const n = box.width * box.height;
+  const r = new Float32Array(n);
+  const g = new Float32Array(n);
+  const b = new Float32Array(n);
+  const d = pixels.data;
+  for (let y = 0; y < box.height; y++) {
+    for (let x = 0; x < box.width; x++) {
+      const i = y * box.width + x;
+      const p = ((box.y + y) * pixels.width + box.x + x) * 4;
+      r[i] = d[p] / 255;
+      g[i] = d[p + 1] / 255;
+      b[i] = d[p + 2] / 255;
+    }
+  }
+  return [r, g, b];
+}
+function refineSelection(pixels, mask, params = {}, refineBrush = null) {
+  const p = normalizeRefineEdgeParams(params);
+  if (pixels && (pixels.width !== mask.width || pixels.height !== mask.height)) {
+    throw new Error("Refine Edge needs pixels the size of the selection");
+  }
+  if (!mask.bounds) return mask;
+  const brush = refineBrush?.bounds ? refineBrush : null;
+  const halo = refineEdgeHalo(p) + (brush ? 2 * Math.max(4, gfRadius(p)) : 0);
+  const b = brush ? {
+    x: Math.min(mask.bounds.x, brush.bounds.x),
+    y: Math.min(mask.bounds.y, brush.bounds.y),
+    r: Math.max(mask.bounds.x + mask.bounds.width, brush.bounds.x + brush.bounds.width),
+    btm: Math.max(mask.bounds.y + mask.bounds.height, brush.bounds.y + brush.bounds.height)
+  } : { x: mask.bounds.x, y: mask.bounds.y, r: mask.bounds.x + mask.bounds.width, btm: mask.bounds.y + mask.bounds.height };
+  const x0 = Math.max(0, b.x - halo);
+  const y0 = Math.max(0, b.y - halo);
+  const x1 = Math.min(mask.width, b.r + halo);
+  const y1 = Math.min(mask.height, b.btm + halo);
+  const ww = x1 - x0;
+  const wh = y1 - y0;
+  const m = new Float32Array(ww * wh);
+  for (let y = 0; y < wh; y++) {
+    const src = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) m[y * ww + x] = mask.data[src + x] / 255;
+  }
+  const guide = pixels && (p.radius > 0 || brush) ? guidePlanes(pixels, { x: x0, y: y0, width: ww, height: wh }) : null;
+  let band = null;
+  if (brush) {
+    band = new Float32Array(ww * wh);
+    const bd = brush.data;
+    for (let y = 0; y < wh; y++) {
+      const src = (y0 + y) * mask.width + x0;
+      for (let x = 0; x < ww; x++) band[y * ww + x] = bd[src + x] / 255;
+    }
+  }
+  const refined = refineCoverage(guide, m, ww, wh, p, band);
+  const out = new Uint8Array(mask.width * mask.height);
+  for (let y = 0; y < wh; y++) {
+    const dst = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) out[dst + x] = coverageToByte(refined[y * ww + x]);
+  }
+  return createSelectionMask(mask.width, mask.height, out);
+}
+function decontaminateColors(rgba, coverage, w, h, amount, radius = 8) {
+  const out = Uint8ClampedArray.from(rgba);
+  const n = w * h;
+  const k = Math.min(1, Math.max(0, amount));
+  if (k === 0) return out;
+  const r = Math.max(2, Math.round(radius));
+  const fgW = new Float32Array(n);
+  const bgW = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    fgW[i] = coverage[i] >= 250 ? 1 : 0;
+    bgW[i] = coverage[i] <= 5 ? 1 : 0;
+  }
+  const meanOf = (weights, radiusPx) => {
+    const wm = boxMean(weights, w, h, radiusPx);
+    const planes = [0, 1, 2].map((c) => {
+      const v = new Float32Array(n);
+      for (let i = 0; i < n; i++) v[i] = rgba[i * 4 + c] * weights[i];
+      const m = boxMean(v, w, h, radiusPx);
+      for (let i = 0; i < n; i++) m[i] = wm[i] > 1e-6 ? m[i] / wm[i] : NaN;
+      return m;
+    });
+    return { weight: wm, planes };
+  };
+  const fg = meanOf(fgW, r);
+  const fgWide = meanOf(fgW, r * 3);
+  const bg = meanOf(bgW, r);
+  for (let i = 0; i < n; i++) {
+    const c = coverage[i];
+    if (c <= 5 || c >= 250) continue;
+    const a = c / 255;
+    for (let ch = 0; ch < 3; ch++) {
+      const C = rgba[i * 4 + ch];
+      const B = bg.planes[ch][i];
+      const Fm = Number.isNaN(fg.planes[ch][i]) ? fgWide.planes[ch][i] : fg.planes[ch][i];
+      let F;
+      if (a >= 0.5 && !Number.isNaN(B)) F = (C - (1 - a) * B) / a;
+      else if (!Number.isNaN(Fm)) F = Fm;
+      else F = C;
+      out[i * 4 + ch] = Math.round(C + k * (Math.min(255, Math.max(0, F)) - C));
+    }
+  }
+  return out;
+}
+
+// src/image-editor/selection/shapes.ts
+function polygonCoverage(points, width, height, antiAlias = true) {
+  const { box, coverage } = polygonCoverageBox(points, width, height, antiAlias);
+  if (!box || box.width === width && box.height === height) return box ? coverage : new Float32Array(width * height);
+  const m = new Float32Array(width * height);
+  for (let y = 0; y < box.height; y++) m.set(coverage.subarray(y * box.width, (y + 1) * box.width), (box.y + y) * width + box.x);
+  return m;
+}
+function polygonCoverageBox(points, width, height, antiAlias = true) {
+  const none = { box: null, coverage: new Float32Array(0) };
+  if (points.length < 3 || width <= 0 || height <= 0) return none;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of points) {
+    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) continue;
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x);
+    maxY = Math.max(maxY, p.y);
+  }
+  const bx0 = Math.max(0, Math.floor(minX));
+  const by0 = Math.max(0, Math.floor(minY));
+  const bx1 = Math.min(width, Math.ceil(maxX));
+  const by1 = Math.min(height, Math.ceil(maxY));
+  if (!(bx1 > bx0 && by1 > by0)) return none;
+  const bw = bx1 - bx0;
+  const m = new Float32Array(bw * (by1 - by0));
+  const sub = antiAlias ? 4 : 1;
+  const edges = [];
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    if (![a.x, a.y, b.x, b.y].every(Number.isFinite)) continue;
+    if (a.y < b.y) edges.push({ top: a.y, bottom: b.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
+    else if (b.y < a.y) edges.push({ top: b.y, bottom: a.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
+  }
+  edges.sort((p, q) => p.top - q.top);
+  let next = 0;
+  let active = [];
+  const xs = [];
+  for (let py = by0; py < by1; py++) {
+    const row = (py - by0) * bw - bx0;
+    for (let s = 0; s < sub; s++) {
+      const y = py + (s + 0.5) / sub;
+      while (next < edges.length && edges[next].top <= y) active.push(edges[next++]);
+      if (active.length) active = active.filter((e) => e.bottom > y);
+      if (!active.length) continue;
+      xs.length = 0;
+      for (const e of active) {
+        if (e.top <= y) xs.push(e.ax + (y - e.ay) / (e.by - e.ay) * (e.bx - e.ax));
+      }
+      xs.sort((a, b) => a - b);
+      for (let k = 0; k + 1 < xs.length; k += 2) {
+        const x0 = Math.max(0, xs[k]);
+        const x1 = Math.min(width, xs[k + 1]);
+        if (x1 <= x0) continue;
+        const c0 = Math.floor(x0);
+        const c1 = Math.min(width, Math.ceil(x1));
+        for (let cx = c0; cx < c1; cx++) {
+          let cov;
+          if (antiAlias) cov = Math.min(cx + 1, x1) - Math.max(cx, x0);
+          else {
+            const c = cx + 0.5;
+            cov = c >= x0 && c < x1 ? 1 : 0;
+          }
+          if (cov > 0) m[row + cx] += cov / sub;
+        }
+      }
+    }
+  }
+  for (let i = 0; i < m.length; i++) if (m[i] > 1) m[i] = 1;
+  return { box: { x: bx0, y: by0, width: bw, height: by1 - by0 }, coverage: m };
+}
+function polygonSelection(width, height, points, options = {}) {
+  const { box, coverage } = polygonCoverageBox(points, width, height, options.antiAlias ?? true);
+  if (!box) return createSelectionMask(width, height);
+  const out = new Uint8Array(coverage.length);
+  for (let i = 0; i < out.length; i++) out[i] = coverageToByte(coverage[i]);
+  return selectionFromRegion(width, height, box, out);
+}
+function normalizeRect(rect) {
+  const x = rect.width < 0 ? rect.x + rect.width : rect.x;
+  const y = rect.height < 0 ? rect.y + rect.height : rect.y;
+  return { x, y, width: Math.abs(rect.width), height: Math.abs(rect.height) };
+}
+function rectSelection(width, height, rect, options = {}) {
+  const r = normalizeRect(rect);
+  const pts = [
+    { x: r.x, y: r.y },
+    { x: r.x + r.width, y: r.y },
+    { x: r.x + r.width, y: r.y + r.height },
+    { x: r.x, y: r.y + r.height }
+  ];
+  return polygonSelection(width, height, pts, options);
+}
+function ellipsePoints(rect) {
+  const r = normalizeRect(rect);
+  const rx = r.width / 2;
+  const ry = r.height / 2;
+  const cx = r.x + rx;
+  const cy = r.y + ry;
+  const rmax = Math.max(rx, ry, 0.5);
+  const step = Math.sqrt(0.4 / rmax);
+  const n = Math.min(4096, Math.max(16, Math.ceil(2 * Math.PI / step)));
+  const pts = [];
+  for (let i = 0; i < n; i++) {
+    const t = i / n * 2 * Math.PI;
+    pts.push({ x: cx + rx * Math.cos(t), y: cy + ry * Math.sin(t) });
+  }
+  return pts;
+}
+function ellipseSelection(width, height, rect, options = {}) {
+  return polygonSelection(width, height, ellipsePoints(rect), options);
+}
+
+// src/image-editor/selection/segment/maxflow.ts
+var TERMINAL = -2;
+var NONE = -1;
+var FREE = 0;
+var SOURCE = 1;
+var SINK = 2;
+var GridGraph = class {
+  width;
+  height;
+  /** Residual capacity of the edge leaving node `p` in direction `d`, at `p * 4 + d`. */
+  cap;
+  /** Net terminal capacity: above 0 to the source, below 0 to the sink. */
+  tr;
+  tree;
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    const n = width * height;
+    this.cap = new Float64Array(n * 4);
+    this.tr = new Float64Array(n);
+    this.tree = new Uint8Array(n);
+  }
+  /** Sets the capacity of the edge between `p` and its neighbour in direction `d`, both ways. */
+  setEdge(p, d, capacity) {
+    const q = d === 0 ? p + 1 : p + this.width;
+    this.cap[p * 4 + d] = capacity;
+    this.cap[q * 4 + (d ^ 2)] = capacity;
+  }
+  /** Adds `source` (cost of putting `p` on the sink side) and `sink` (the other way) to `p`. */
+  addTerminal(p, source, sink) {
+    this.tr[p] += source - sink;
+  }
+  /** Whether `p` is on the source side of the minimum cut (after {@link maxflow}). */
+  inSource(p) {
+    return this.tree[p] === SOURCE;
+  }
+  /** Runs max-flow and returns the flow (the cut's cost, less the constant terminal parts). */
+  maxflow() {
+    const { width: w, height: h, cap, tr, tree } = this;
+    const n = w * h;
+    const nb = (p, d) => {
+      const x = p % w;
+      if (d === 0) return x < w - 1 ? p + 1 : -1;
+      if (d === 1) return p + w < n ? p + w : -1;
+      if (d === 2) return x > 0 ? p - 1 : -1;
+      return p - w >= 0 ? p - w : -1;
+    };
+    const parent = new Int8Array(n).fill(NONE);
+    const ts = new Int32Array(n);
+    const dist = new Int32Array(n);
+    const queue = new Int32Array(n + 1);
+    const queued = new Uint8Array(n);
+    let qHead = 0;
+    let qTail = 0;
+    const activate = (p) => {
+      if (queued[p]) return;
+      queued[p] = 1;
+      queue[qTail] = p;
+      qTail = qTail === n ? 0 : qTail + 1;
+    };
+    const nextActive = () => {
+      while (qHead !== qTail) {
+        const p = queue[qHead];
+        qHead = qHead === n ? 0 : qHead + 1;
+        queued[p] = 0;
+        if (tree[p] !== FREE) return p;
+      }
+      return -1;
+    };
+    let orphans = new Int32Array(64);
+    let orphanCount = 0;
+    const orphan = (p) => {
+      parent[p] = NONE;
+      if (orphanCount === orphans.length) {
+        const grown = new Int32Array(orphans.length * 2);
+        grown.set(orphans);
+        orphans = grown;
+      }
+      orphans[orphanCount++] = p;
+    };
+    tree.fill(FREE);
+    for (let p = 0; p < n; p++) {
+      if (tr[p] > 0) tree[p] = SOURCE;
+      else if (tr[p] < 0) tree[p] = SINK;
+      else continue;
+      parent[p] = TERMINAL;
+      dist[p] = 1;
+      activate(p);
+    }
+    let flow = 0;
+    let time = 0;
+    let current = -1;
+    for (; ; ) {
+      if (current < 0 || tree[current] === FREE) {
+        current = nextActive();
+        if (current < 0) break;
+      }
+      const p = current;
+      const side = tree[p];
+      let s = -1;
+      let t = -1;
+      let dir = 0;
+      for (let d = 0; d < 4; d++) {
+        const q = nb(p, d);
+        if (q < 0) continue;
+        if (side === SOURCE ? cap[p * 4 + d] <= 0 : cap[q * 4 + (d ^ 2)] <= 0) continue;
+        if (tree[q] === FREE) {
+          tree[q] = side;
+          parent[q] = d ^ 2;
+          ts[q] = ts[p];
+          dist[q] = dist[p] + 1;
+          activate(q);
+        } else if (tree[q] !== side) {
+          if (side === SOURCE) {
+            s = p;
+            t = q;
+            dir = d;
+          } else {
+            s = q;
+            t = p;
+            dir = d ^ 2;
+          }
+          break;
+        } else if (ts[q] <= ts[p] && dist[q] > dist[p]) {
+          parent[q] = d ^ 2;
+          ts[q] = ts[p];
+          dist[q] = dist[p] + 1;
+        }
+      }
+      if (s < 0) {
+        current = -1;
+        continue;
+      }
+      time++;
+      let f = cap[s * 4 + dir];
+      for (let x = s; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          f = Math.min(f, tr[x]);
+          break;
+        }
+        const up = nb(x, a);
+        f = Math.min(f, cap[up * 4 + (a ^ 2)]);
+        x = up;
+      }
+      for (let x = t; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          f = Math.min(f, -tr[x]);
+          break;
+        }
+        f = Math.min(f, cap[x * 4 + a]);
+        x = nb(x, a);
+      }
+      cap[s * 4 + dir] -= f;
+      cap[t * 4 + (dir ^ 2)] += f;
+      for (let x = s; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          tr[x] -= f;
+          if (tr[x] <= 0) orphan(x);
+          break;
+        }
+        const up = nb(x, a);
+        cap[up * 4 + (a ^ 2)] -= f;
+        cap[x * 4 + a] += f;
+        if (cap[up * 4 + (a ^ 2)] <= 0) orphan(x);
+        x = up;
+      }
+      for (let x = t; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          tr[x] += f;
+          if (tr[x] >= 0) orphan(x);
+          break;
+        }
+        const up = nb(x, a);
+        cap[x * 4 + a] -= f;
+        cap[up * 4 + (a ^ 2)] += f;
+        if (cap[x * 4 + a] <= 0) orphan(x);
+        x = up;
+      }
+      flow += f;
+      while (orphanCount) {
+        const o = orphans[--orphanCount];
+        const oSide = tree[o];
+        let best = NONE;
+        let bestDist = Infinity;
+        for (let d = 0; d < 4; d++) {
+          const q = nb(o, d);
+          if (q < 0 || tree[q] !== oSide) continue;
+          if (oSide === SOURCE ? cap[q * 4 + (d ^ 2)] <= 0 : cap[o * 4 + d] <= 0) continue;
+          let k = 0;
+          let x = q;
+          for (; ; ) {
+            if (ts[x] === time) {
+              k += dist[x];
+              break;
+            }
+            const a = parent[x];
+            k++;
+            if (a === TERMINAL) {
+              ts[x] = time;
+              dist[x] = 1;
+              break;
+            }
+            if (a === NONE) {
+              k = Infinity;
+              break;
+            }
+            x = nb(x, a);
+          }
+          if (k === Infinity) continue;
+          if (k < bestDist) {
+            bestDist = k;
+            best = d;
+          }
+          for (let y = q, dd = k; ts[y] !== time; y = nb(y, parent[y]), dd--) {
+            ts[y] = time;
+            dist[y] = dd;
+          }
+        }
+        if (best !== NONE) {
+          parent[o] = best;
+          ts[o] = time;
+          dist[o] = bestDist + 1;
+          continue;
+        }
+        for (let d = 0; d < 4; d++) {
+          const q = nb(o, d);
+          if (q < 0 || tree[q] !== oSide) continue;
+          if (oSide === SOURCE ? cap[q * 4 + (d ^ 2)] > 0 : cap[o * 4 + d] > 0) activate(q);
+          const a = parent[q];
+          if (a !== TERMINAL && a !== NONE && nb(q, a) === o) orphan(q);
+        }
+        tree[o] = FREE;
+      }
+    }
+    return flow;
+  }
+};
+
+// src/image-editor/selection/segment/work.ts
+var WORK_SIZE = 512;
+var workCache = /* @__PURE__ */ new WeakMap();
+function workImage(pixels, maxSide = WORK_SIZE) {
+  const sizes = workCache.get(pixels.data);
+  const cached = sizes?.get(maxSide);
+  if (cached && cached.sourceWidth === pixels.width && cached.sourceHeight === pixels.height) return cached;
+  const { width: W, height: H, data } = pixels;
+  const scale = Math.min(1, maxSide / Math.max(W, H));
+  const w = Math.max(1, Math.round(W * scale));
+  const h = Math.max(1, Math.round(H * scale));
+  const sum = new Float64Array(w * h * 3);
+  const count = new Float64Array(w * h);
+  const xs = new Int32Array(W);
+  for (let x = 0; x < W; x++) xs[x] = Math.min(w - 1, Math.floor(x * w / W));
+  for (let y = 0; y < H; y++) {
+    const row = Math.min(h - 1, Math.floor(y * h / H)) * w;
+    for (let x = 0, p = y * W * 4; x < W; x++, p += 4) {
+      const o = row + xs[x];
+      const a = data[p + 3] / 255;
+      const k = o * 3;
+      sum[k] += data[p] * a + 255 * (1 - a);
+      sum[k + 1] += data[p + 1] * a + 255 * (1 - a);
+      sum[k + 2] += data[p + 2] * a + 255 * (1 - a);
+      count[o]++;
+    }
+  }
+  const rgb = new Float32Array(w * h * 3);
+  for (let i = 0; i < w * h; i++) {
+    const c = count[i] || 1;
+    rgb[i * 3] = sum[i * 3] / c;
+    rgb[i * 3 + 1] = sum[i * 3 + 1] / c;
+    rgb[i * 3 + 2] = sum[i * 3 + 2] / c;
+  }
+  const work = { sourceWidth: W, sourceHeight: H, width: w, height: h, scale: w / W, rgb };
+  if (sizes) sizes.set(maxSide, work);
+  else workCache.set(pixels.data, /* @__PURE__ */ new Map([[maxSide, work]]));
+  return work;
+}
+var GAMMA = 50;
+var UNITS = 64;
+function smoothnessWeights(work, roi) {
+  const { width: w, rgb } = work;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  const right = new Float64Array(rw * rh);
+  const down = new Float64Array(rw * rh);
+  let sumSq = 0;
+  let pairs = 0;
+  for (let y = 0; y < rh; y++) {
+    for (let x = 0; x < rw; x++) {
+      const p = y * rw + x;
+      const c = ((ry + y) * w + rx + x) * 3;
+      if (x + 1 < rw) {
+        right[p] = (rgb[c] - rgb[c + 3]) ** 2 + (rgb[c + 1] - rgb[c + 4]) ** 2 + (rgb[c + 2] - rgb[c + 5]) ** 2;
+        sumSq += right[p];
+        pairs++;
+      }
+      if (y + 1 < rh) {
+        const k = c + w * 3;
+        down[p] = (rgb[c] - rgb[k]) ** 2 + (rgb[c + 1] - rgb[k + 1]) ** 2 + (rgb[c + 2] - rgb[k + 2]) ** 2;
+        sumSq += down[p];
+        pairs++;
+      }
+    }
+  }
+  const beta = 1 / (2 * Math.max(1e-6, sumSq / Math.max(1, pairs)));
+  for (let p = 0; p < right.length; p++) {
+    right[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * right[p]));
+    down[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * down[p]));
+  }
+  return { right, down };
+}
+function boxBlur(src, w, h, passes) {
+  let a = src;
+  for (let k = 0; k < passes; k++) {
+    const b = new Float32Array(a.length);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        let s = 0;
+        let c = 0;
+        for (let j = Math.max(0, y - 1); j <= Math.min(h - 1, y + 1); j++) {
+          for (let i = Math.max(0, x - 1); i <= Math.min(w - 1, x + 1); i++) {
+            s += a[j * w + i];
+            c++;
+          }
+        }
+        b[y * w + x] = s / c;
+      }
+    }
+    a = b;
+  }
+  return a;
+}
+function upscaleRegion(work, pixels, roi, label, enhance) {
+  const { sourceWidth: W, sourceHeight: H, scale, rgb, width: ww } = work;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  let soft = Float32Array.from(label);
+  if (enhance) {
+    soft = boxBlur(soft, rw, rh, 2);
+    for (let i = 0; i < soft.length; i++) soft[i] = Math.min(1, Math.max(0, (soft[i] - 0.5) * 3 + 0.5));
+  }
+  const X0 = Math.max(0, Math.floor(rx / scale));
+  const Y0 = Math.max(0, Math.floor(ry / scale));
+  const X1 = Math.min(W, Math.ceil((rx + rw) / scale));
+  const Y1 = Math.min(H, Math.ceil((ry + rh) / scale));
+  const RW = X1 - X0;
+  const RH = Y1 - Y0;
+  const out = new Uint8Array(RW * RH);
+  const at = (x, y) => soft[Math.min(rh - 1, Math.max(0, y)) * rw + Math.min(rw - 1, Math.max(0, x))];
+  const data = pixels.data;
+  const colOf = new Int32Array(RW);
+  const fxOf = new Float32Array(RW);
+  for (let X = 0; X < RW; X++) {
+    const u = (X0 + X + 0.5) * scale - 0.5 - rx;
+    colOf[X] = Math.floor(u);
+    fxOf[X] = u - colOf[X];
+  }
+  const cellState = (i, j) => {
+    const a = at(i, j), b = at(i + 1, j), c = at(i, j + 1), d = at(i + 1, j + 1);
+    if (a === 1 && b === 1 && c === 1 && d === 1) return 1;
+    if (a === 0 && b === 0 && c === 0 && d === 0) return 0;
+    return 2;
+  };
+  for (let Y = 0; Y < RH; Y++) {
+    const v = (Y0 + Y + 0.5) * scale - 0.5 - ry;
+    const j = Math.floor(v);
+    const fy = v - j;
+    for (let X = 0; X < RW; X++) {
+      const i = colOf[X];
+      const state = cellState(i, j);
+      if (state !== 2) {
+        let end = X + 1;
+        while (end < RW && colOf[end] === i) end++;
+        if (state === 1) out.fill(255, Y * RW + X, Y * RW + end);
+        X = end - 1;
+        continue;
+      }
+      const fx = fxOf[X];
+      const m = (at(i, j) * (1 - fx) + at(i + 1, j) * fx) * (1 - fy) + (at(i, j + 1) * (1 - fx) + at(i + 1, j + 1) * fx) * fy;
+      if (m <= 1e-3 || m >= 0.999) {
+        out[Y * RW + X] = m >= 0.999 ? 255 : 0;
+        continue;
+      }
+      let fr = 0, fg = 0, fb = 0, fn = 0, br = 0, bg = 0, bb = 0, bn = 0;
+      for (let jj = j - 1; jj <= j + 2; jj++) {
+        for (let ii = i - 1; ii <= i + 2; ii++) {
+          if (ii < 0 || jj < 0 || ii >= rw || jj >= rh) continue;
+          const k = ((ry + jj) * ww + rx + ii) * 3;
+          if (soft[jj * rw + ii] >= 0.5) {
+            fr += rgb[k];
+            fg += rgb[k + 1];
+            fb += rgb[k + 2];
+            fn++;
+          } else {
+            br += rgb[k];
+            bg += rgb[k + 1];
+            bb += rgb[k + 2];
+            bn++;
+          }
+        }
+      }
+      let alpha = m;
+      if (fn && bn) {
+        fr /= fn;
+        fg /= fn;
+        fb /= fn;
+        br /= bn;
+        bg /= bn;
+        bb /= bn;
+        const dr = fr - br, dg = fg - bg, db = fb - bb;
+        const len2 = dr * dr + dg * dg + db * db;
+        if (len2 > 400) {
+          const p = ((Y0 + Y) * W + X0 + X) * 4;
+          const a = data[p + 3] / 255;
+          const cr = data[p] * a + 255 * (1 - a) - br;
+          const cg = data[p + 1] * a + 255 * (1 - a) - bg;
+          const cb = data[p + 2] * a + 255 * (1 - a) - bb;
+          const proj = Math.min(1, Math.max(0, (cr * dr + cg * dg + cb * db) / len2));
+          alpha = Math.min(1, Math.max(0, proj * 0.75 + m * 0.25));
+        } else alpha = Math.min(1, Math.max(0, (m - 0.5) * 2 + 0.5));
+      }
+      out[Y * RW + X] = Math.round(alpha * 255);
+    }
+  }
+  return selectionFromRegion(W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
+}
+
+// src/image-editor/selection/segment/grabcut.ts
+var K = 5;
+var ColorGmm = class {
+  logWeight = new Float64Array(K);
+  mean = new Float64Array(K * 3);
+  /** Inverse covariances, row-major 3 × 3. */
+  inv = new Float64Array(K * 9);
+  /** ln(weight) − ½ ln((2π)³ |Σ|) per component; −∞ for an empty one. */
+  logNorm = new Float64Array(K).fill(-Infinity);
+  /** Fits the components to the pixels `ids` of `rgb`, each in component `comp[id]`. */
+  fit(rgb, ids, comp) {
+    const n = new Float64Array(K);
+    const sum = new Float64Array(K * 3);
+    const prod = new Float64Array(K * 9);
+    for (let t = 0; t < ids.length; t++) {
+      const i = ids[t];
+      const k = comp[i];
+      const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
+      n[k]++;
+      for (let a = 0; a < 3; a++) {
+        sum[k * 3 + a] += c[a];
+        for (let b = 0; b < 3; b++) prod[k * 9 + a * 3 + b] += c[a] * c[b];
+      }
+    }
+    const total = ids.length || 1;
+    for (let k = 0; k < K; k++) {
+      if (!n[k]) {
+        this.logNorm[k] = -Infinity;
+        continue;
+      }
+      const m = [sum[k * 3] / n[k], sum[k * 3 + 1] / n[k], sum[k * 3 + 2] / n[k]];
+      const cov = new Float64Array(9);
+      for (let a = 0; a < 3; a++) {
+        for (let b = 0; b < 3; b++) cov[a * 3 + b] = prod[k * 9 + a * 3 + b] / n[k] - m[a] * m[b];
+        cov[a * 4] += 4;
+      }
+      const det = cov[0] * (cov[4] * cov[8] - cov[5] * cov[7]) - cov[1] * (cov[3] * cov[8] - cov[5] * cov[6]) + cov[2] * (cov[3] * cov[7] - cov[4] * cov[6]);
+      const d = Math.max(det, 1e-6);
+      const inv = [
+        (cov[4] * cov[8] - cov[5] * cov[7]) / d,
+        (cov[2] * cov[7] - cov[1] * cov[8]) / d,
+        (cov[1] * cov[5] - cov[2] * cov[4]) / d,
+        (cov[5] * cov[6] - cov[3] * cov[8]) / d,
+        (cov[0] * cov[8] - cov[2] * cov[6]) / d,
+        (cov[2] * cov[3] - cov[0] * cov[5]) / d,
+        (cov[3] * cov[7] - cov[4] * cov[6]) / d,
+        (cov[1] * cov[6] - cov[0] * cov[7]) / d,
+        (cov[0] * cov[4] - cov[1] * cov[3]) / d
+      ];
+      this.mean.set(m, k * 3);
+      this.inv.set(inv, k * 9);
+      this.logWeight[k] = Math.log(n[k] / total);
+      this.logNorm[k] = this.logWeight[k] - 0.5 * Math.log(Math.pow(2 * Math.PI, 3) * d);
+    }
+  }
+  /** ln p(colour | component k), up to the shared constant. */
+  componentLog(k, r, g, b) {
+    const ln = this.logNorm[k];
+    if (ln === -Infinity) return -Infinity;
+    const dr = r - this.mean[k * 3];
+    const dg = g - this.mean[k * 3 + 1];
+    const db = b - this.mean[k * 3 + 2];
+    const v = this.inv;
+    const o = k * 9;
+    const q = dr * (v[o] * dr + v[o + 1] * dg + v[o + 2] * db) + dg * (v[o + 3] * dr + v[o + 4] * dg + v[o + 5] * db) + db * (v[o + 6] * dr + v[o + 7] * dg + v[o + 8] * db);
+    return ln - 0.5 * q;
+  }
+  /** −ln p(colour) under the mixture (large for colours the model hasn't seen). */
+  cost(r, g, b) {
+    let best = -Infinity;
+    const logs = new Array(K);
+    for (let k = 0; k < K; k++) {
+      logs[k] = this.componentLog(k, r, g, b);
+      if (logs[k] > best) best = logs[k];
+    }
+    if (best === -Infinity) return 50;
+    let s = 0;
+    for (let k = 0; k < K; k++) if (logs[k] > -Infinity) s += Math.exp(logs[k] - best);
+    return Math.min(50, -(best + Math.log(s)));
+  }
+  /** The component most likely to have produced the colour. */
+  nearest(r, g, b) {
+    let best = 0;
+    let bestLog = -Infinity;
+    for (let k = 0; k < K; k++) {
+      const l = this.componentLog(k, r, g, b);
+      if (l > bestLog) {
+        bestLog = l;
+        best = k;
+      }
+    }
+    return best;
+  }
+};
+function initialComponents(rgb, ids, comp) {
+  if (!ids.length) return;
+  const step = Math.max(1, Math.floor(ids.length / 6e3));
+  const sample = [];
+  for (let t = 0; t < ids.length; t += step) sample.push(ids[t]);
+  const centres = [];
+  const dist2 = (i, c) => (rgb[i * 3] - c[0]) ** 2 + (rgb[i * 3 + 1] - c[1]) ** 2 + (rgb[i * 3 + 2] - c[2]) ** 2;
+  centres.push([rgb[sample[0] * 3], rgb[sample[0] * 3 + 1], rgb[sample[0] * 3 + 2]]);
+  const near = sample.map((i) => dist2(i, centres[0]));
+  while (centres.length < K) {
+    let far = 0;
+    for (let t = 1; t < sample.length; t++) if (near[t] > near[far]) far = t;
+    const i = sample[far];
+    const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
+    centres.push(c);
+    for (let t = 0; t < sample.length; t++) near[t] = Math.min(near[t], dist2(sample[t], c));
+  }
+  const closest = (i) => {
+    let best = 0;
+    for (let k = 1; k < K; k++) if (dist2(i, centres[k]) < dist2(i, centres[best])) best = k;
+    return best;
+  };
+  for (let round = 0; round < 6; round++) {
+    const sum = Array.from({ length: K }, () => [0, 0, 0, 0]);
+    for (const i of sample) {
+      const s = sum[closest(i)];
+      s[0] += rgb[i * 3];
+      s[1] += rgb[i * 3 + 1];
+      s[2] += rgb[i * 3 + 2];
+      s[3]++;
+    }
+    for (let k = 0; k < K; k++) if (sum[k][3]) centres[k] = [sum[k][0] / sum[k][3], sum[k][1] / sum[k][3], sum[k][2] / sum[k][3]];
+  }
+  for (const i of ids) comp[i] = closest(i);
+}
+function grabCutLabels(work, setup, iterations, onRound) {
+  const { width: w, rgb } = work;
+  const { roi, hardBg, hardFg } = setup;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  const n = rw * rh;
+  const label = setup.initial.slice();
+  const global = new Int32Array(n);
+  for (let y = 0; y < rh; y++) for (let x = 0; x < rw; x++) global[y * rw + x] = (ry + y) * w + rx + x;
+  const comp = new Uint8Array(w * work.height);
+  const fg = new ColorGmm();
+  const bg = new ColorGmm();
+  const { right, down } = smoothnessWeights(work, roi);
+  const HARD = 1e9;
+  for (let iter = 0; iter < iterations; iter++) {
+    const fgIds = [];
+    const bgIds = [];
+    for (let p = 0; p < n; p++) (label[p] ? fgIds : bgIds).push(global[p]);
+    if (!fgIds.length) return label;
+    if (iter === 0) {
+      initialComponents(rgb, fgIds, comp);
+      initialComponents(rgb, bgIds, comp);
+    } else {
+      for (const i of fgIds) comp[i] = fg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+      for (const i of bgIds) comp[i] = bg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+    }
+    fg.fit(rgb, fgIds, comp);
+    bg.fit(rgb, bgIds, comp);
+    const graph = new GridGraph(rw, rh);
+    for (let p = 0; p < n; p++) {
+      if (hardBg[p]) graph.addTerminal(p, 0, HARD);
+      else if (hardFg?.[p]) graph.addTerminal(p, HARD, 0);
+      else {
+        const i = global[p] * 3;
+        graph.addTerminal(p, Math.round(bg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS), Math.round(fg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS));
+      }
+      if (p % rw + 1 < rw) graph.setEdge(p, 0, right[p]);
+      if (p + rw < n) graph.setEdge(p, 1, down[p]);
+    }
+    graph.maxflow();
+    let changed = 0;
+    for (let p = 0; p < n; p++) {
+      const v = graph.inSource(p) ? 1 : 0;
+      if (v !== label[p]) changed++;
+      label[p] = v;
+    }
+    onRound?.((iter + 1) / iterations);
+    if (changed <= n * 1e-3) break;
+  }
+  return label;
+}
+function keepMainPieces(label, rw, rh, seed) {
+  const n = rw * rh;
+  const piece = new Int32Array(n).fill(-1);
+  const sizes = [];
+  const stack = [];
+  for (let s = 0; s < n; s++) {
+    if (!label[s] || piece[s] >= 0) continue;
+    const id = sizes.length;
+    let size = 0;
+    piece[s] = id;
+    stack.push(s);
+    while (stack.length) {
+      const p = stack.pop();
+      size++;
+      const x = p % rw;
+      for (const q of [x + 1 < rw ? p + 1 : -1, x > 0 ? p - 1 : -1, p + rw < n ? p + rw : -1, p - rw]) {
+        if (q >= 0 && label[q] && piece[q] < 0) {
+          piece[q] = id;
+          stack.push(q);
+        }
+      }
+    }
+    sizes.push(size);
+  }
+  if (!sizes.length) return;
+  const largest = Math.max(...sizes);
+  const keep = (id) => seed !== null && piece[seed] >= 0 ? id === piece[seed] : sizes[id] * 5 >= largest;
+  for (let p = 0; p < n; p++) if (label[p] && !keep(piece[p])) label[p] = 0;
+}
+function selectObjectIn(pixels, target, options = {}) {
+  const report = options.onProgress;
+  report?.(0, "Reducing the image");
+  const work = workImage(pixels);
+  report?.(0.1, "Finding the object");
+  const round = (fraction) => report?.(0.1 + 0.8 * fraction, "Finding the object");
+  const { width: w, height: h, scale } = work;
+  const iterations = Math.max(1, Math.round(options.iterations ?? 5));
+  const enhance = options.enhanceEdge ?? false;
+  if ("rect" in target) {
+    const r = target.rect;
+    const bx0 = Math.max(0, Math.floor(r.x * scale));
+    const by0 = Math.max(0, Math.floor(r.y * scale));
+    const bx1 = Math.min(w, Math.ceil((r.x + r.width) * scale));
+    const by1 = Math.min(h, Math.ceil((r.y + r.height) * scale));
+    if (bx1 - bx0 < 2 || by1 - by0 < 2) return createSelectionMask(pixels.width, pixels.height);
+    const m = Math.max(8, Math.round(0.25 * Math.max(bx1 - bx0, by1 - by0)));
+    const rx = Math.max(0, bx0 - m);
+    const ry = Math.max(0, by0 - m);
+    const roi = { x: rx, y: ry, width: Math.min(w, bx1 + m) - rx, height: Math.min(h, by1 + m) - ry };
+    const n = roi.width * roi.height;
+    const initial = new Uint8Array(n);
+    const hardBg = new Uint8Array(n);
+    for (let y = 0; y < roi.height; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        const gx = rx + x;
+        const gy = ry + y;
+        const inside = gx >= bx0 && gx < bx1 && gy >= by0 && gy < by1;
+        initial[y * roi.width + x] = inside ? 1 : 0;
+        hardBg[y * roi.width + x] = inside ? 0 : 1;
+      }
+    }
+    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg: null }, iterations, round);
+    keepMainPieces(label, roi.width, roi.height, null);
+    report?.(0.9, "Scaling up");
+    const out = upscaleRegion(work, pixels, roi, label, enhance);
+    report?.(1, "Done");
+    return out;
+  }
+  const px = Math.min(w - 1, Math.max(0, Math.floor(target.point.x * scale)));
+  const py = Math.min(h - 1, Math.max(0, Math.floor(target.point.y * scale)));
+  let half = Math.max(24, Math.round(0.3 * Math.max(w, h)));
+  for (; ; ) {
+    const rx = Math.max(0, px - half);
+    const ry = Math.max(0, py - half);
+    const roi = { x: rx, y: ry, width: Math.min(w, px + half + 1) - rx, height: Math.min(h, py + half + 1) - ry };
+    const whole = roi.width === w && roi.height === h;
+    const band = Math.max(4, Math.round(0.15 * half));
+    const n = roi.width * roi.height;
+    const initial = new Uint8Array(n);
+    const hardBg = new Uint8Array(n);
+    const hardFg = new Uint8Array(n);
+    const inBand = (x, y) => rx > 0 && x < band || ry > 0 && y < band || rx + roi.width < w && x >= roi.width - band || ry + roi.height < h && y >= roi.height - band;
+    for (let y = 0; y < roi.height; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        const p = y * roi.width + x;
+        if (inBand(x, y)) hardBg[p] = 1;
+        else initial[p] = 1;
+        if (Math.hypot(rx + x - px, ry + y - py) <= 1.5) hardFg[p] = 1;
+      }
+    }
+    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, iterations, round);
+    keepMainPieces(label, roi.width, roi.height, (py - ry) * roi.width + (px - rx));
+    let touches = false;
+    for (let y = 0; y < roi.height && !touches; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        if (label[y * roi.width + x] && (inBand(x - 1, y) || inBand(x + 1, y) || inBand(x, y - 1) || inBand(x, y + 1))) {
+          touches = true;
+          break;
+        }
+      }
+    }
+    if (!touches || whole) {
+      report?.(0.9, "Scaling up");
+      const out = upscaleRegion(work, pixels, roi, label, enhance);
+      report?.(1, "Done");
+      return out;
+    }
+    half = Math.round(half * 1.6);
+  }
+}
+
+// src/image-editor/selection/segment/quick.ts
+var BINS = 16;
+var binOf = (rgb, i) => (Math.min(BINS - 1, rgb[i * 3] >> 4) * BINS + Math.min(BINS - 1, rgb[i * 3 + 1] >> 4)) * BINS + Math.min(BINS - 1, rgb[i * 3 + 2] >> 4);
+function costTable(hist, total) {
+  let a = hist;
+  for (const stride of [1, BINS, BINS * BINS]) {
+    const b = new Float64Array(a.length);
+    for (let i = 0; i < a.length; i++) {
+      const pos = Math.floor(i / stride) % BINS;
+      const lo = pos > 0 ? a[i - stride] : a[i];
+      const hi = pos < BINS - 1 ? a[i + stride] : a[i];
+      b[i] = (lo + 2 * a[i] + hi) / 4;
+    }
+    a = b;
+  }
+  const out = new Float64Array(a.length);
+  const floor = 1e-4;
+  const denom = Math.max(1, total) * (1 + floor * a.length);
+  for (let i = 0; i < a.length; i++) out[i] = -Math.log((a[i] + floor * Math.max(1, total)) / denom);
+  return out;
+}
+function strokePixels(points, r, w, h) {
+  const mask = new Uint8Array(w * h);
+  const list = [];
+  const add = (g) => {
+    if (!mask[g]) {
+      mask[g] = 1;
+      list.push(g);
+    }
+  };
+  const segs = points.length === 1 ? [[points[0], points[0]]] : points.slice(1).map((p, i) => [points[i], p]);
+  for (const [a, b] of segs) {
+    const x0 = Math.max(0, Math.floor(Math.min(a.x, b.x) - r));
+    const x1 = Math.min(w - 1, Math.ceil(Math.max(a.x, b.x) + r));
+    const y0 = Math.max(0, Math.floor(Math.min(a.y, b.y) - r));
+    const y1 = Math.min(h - 1, Math.ceil(Math.max(a.y, b.y) + r));
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len2 = dx * dx + dy * dy;
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) {
+        const px = x + 0.5 - a.x;
+        const py = y + 0.5 - a.y;
+        const t = len2 > 0 ? Math.min(1, Math.max(0, (px * dx + py * dy) / len2)) : 0;
+        if ((px - t * dx) ** 2 + (py - t * dy) ** 2 <= r * r) add(y * w + x);
+      }
+    }
+  }
+  if (!list.length) {
+    for (const p of points) add(Math.min(h - 1, Math.max(0, Math.floor(p.y))) * w + Math.min(w - 1, Math.max(0, Math.floor(p.x))));
+  }
+  return { mask, list };
+}
+function segmentStroke(work, stroke, grown, start) {
+  const { width: w, height: h, rgb } = work;
+  let roi = start;
+  for (; ; ) {
+    const { x: rx, y: ry, width: rw, height: rh } = roi;
+    const n = rw * rh;
+    const fgHist = new Float64Array(BINS ** 3);
+    const bgHist = new Float64Array(BINS ** 3);
+    let fgN = 0;
+    let bgN = 0;
+    const atImageEdge = { l: rx === 0, t: ry === 0, r: rx + rw === w, b: ry + rh === h };
+    for (let y = 0; y < rh; y++) {
+      for (let x = 0; x < rw; x++) {
+        const g = (ry + y) * w + (rx + x);
+        const bin = binOf(rgb, g);
+        bgHist[bin]++;
+        bgN++;
+        if (stroke.mask[g] || grown?.[g]) {
+          fgHist[bin]++;
+          fgN++;
+        }
+      }
+    }
+    const fgCost = costTable(fgHist, fgN);
+    const bgCost = costTable(bgHist, bgN);
+    const { right, down } = smoothnessWeights(work, roi);
+    const graph = new GridGraph(rw, rh);
+    const HARD = 1e9;
+    for (let y = 0; y < rh; y++) {
+      for (let x = 0; x < rw; x++) {
+        const p = y * rw + x;
+        const g = (ry + y) * w + rx + x;
+        if (stroke.mask[g]) graph.addTerminal(p, HARD, 0);
+        else {
+          const bin = binOf(rgb, g);
+          graph.addTerminal(p, Math.round(bgCost[bin] * UNITS), Math.round(fgCost[bin] * UNITS));
+        }
+        if (x + 1 < rw) graph.setEdge(p, 0, right[p]);
+        if (y + 1 < rh) graph.setEdge(p, 1, down[p]);
+      }
+    }
+    graph.maxflow();
+    const label = new Uint8Array(n);
+    const stack = [];
+    for (const g of stroke.list) {
+      const x = g % w - rx;
+      const y = Math.floor(g / w) - ry;
+      if (x < 0 || y < 0 || x >= rw || y >= rh) continue;
+      const p = y * rw + x;
+      if (!label[p]) {
+        label[p] = 1;
+        stack.push(p);
+      }
+    }
+    while (stack.length) {
+      const p = stack.pop();
+      const x = p % rw;
+      for (const q of [x + 1 < rw ? p + 1 : -1, x > 0 ? p - 1 : -1, p + rw < n ? p + rw : -1, p - rw]) {
+        if (q >= 0 && !label[q] && graph.inSource(q)) {
+          label[q] = 1;
+          stack.push(q);
+        }
+      }
+    }
+    let touches = false;
+    for (let y = 0; y < rh; y++) {
+      for (let x = 0; x < rw; x++) {
+        const p = y * rw + x;
+        if (!label[p]) continue;
+        if (!atImageEdge.l && x === 0 || !atImageEdge.t && y === 0 || !atImageEdge.r && x === rw - 1 || !atImageEdge.b && y === rh - 1) touches = true;
+      }
+    }
+    if (!touches || atImageEdge.l && atImageEdge.t && atImageEdge.r && atImageEdge.b) return { roi, label };
+    const nx = Math.max(0, rx - Math.ceil(rw / 2));
+    const ny = Math.max(0, ry - Math.ceil(rh / 2));
+    roi = { x: nx, y: ny, width: Math.min(w, rx + rw + Math.ceil(rw / 2)) - nx, height: Math.min(h, ry + rh + Math.ceil(rh / 2)) - ny };
+    if (roi.width * roi.height * 2.5 > w * h) roi = { x: 0, y: 0, width: w, height: h };
+  }
+}
+function quickSelectStroke(pixels, stroke, options = {}) {
+  if (!stroke.length) throw new Error("A stroke needs at least one point.");
+  const work = workImage(pixels);
+  const { width: w, height: h, scale } = work;
+  const r = Math.max(0.5, (options.size ?? 30) / 2 * scale);
+  const pts = stroke.map((p) => ({ x: p.x * scale, y: p.y * scale }));
+  const seeds = strokePixels(pts, r, w, h);
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const p of pts) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
+  const margin = Math.max(24, 4 * r);
+  const rx = Math.max(0, Math.floor(x0 - margin));
+  const ry = Math.max(0, Math.floor(y0 - margin));
+  const roi = { x: rx, y: ry, width: Math.min(w, Math.ceil(x1 + margin)) - rx, height: Math.min(h, Math.ceil(y1 + margin)) - ry };
+  let grown = null;
+  const sel = options.grow ? options.selection : null;
+  if (sel?.bounds) {
+    grown = new Uint8Array(w * h);
+    const b = sel.bounds;
+    for (let y = Math.max(0, Math.floor(b.y * scale)); y < Math.min(h, Math.ceil((b.y + b.height) * scale)); y++) {
+      for (let x = Math.max(0, Math.floor(b.x * scale)); x < Math.min(w, Math.ceil((b.x + b.width) * scale)); x++) {
+        if (selectionValueAt(sel, Math.min(sel.width - 1, Math.floor((x + 0.5) / scale)), Math.min(sel.height - 1, Math.floor((y + 0.5) / scale))) >= 0.5) grown[y * w + x] = 1;
+      }
+    }
+  }
+  const { roi: done, label } = segmentStroke(work, seeds, grown, roi);
+  return upscaleRegion(work, pixels, done, label, options.enhanceEdge ?? false);
+}
+
+// src/image-editor/selection/refine-edits.ts
+var REFINE_EDIT_KINDS = ["quick-select", "brush", "refine-brush", "lasso", "object"];
+function brushStrokeMask(width, height, points, size, hardness = 1) {
+  const r = Math.max(0.5, size / 2);
+  const solid = r * Math.min(1, Math.max(0, hardness));
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const p of points) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
+  const bx = Math.max(0, Math.floor(x0 - r - 1));
+  const by = Math.max(0, Math.floor(y0 - r - 1));
+  const bw = Math.min(width, Math.ceil(x1 + r + 1)) - bx;
+  const bh = Math.min(height, Math.ceil(y1 + r + 1)) - by;
+  if (!(bw > 0 && bh > 0)) return createSelectionMask(width, height);
+  const out = new Uint8Array(bw * bh);
+  const segs = points.length === 1 ? [[points[0], points[0]]] : points.slice(1).map((p, i) => [points[i], p]);
+  for (let y = 0; y < bh; y++) {
+    for (let x = 0; x < bw; x++) {
+      const px = bx + x + 0.5;
+      const py = by + y + 0.5;
+      let d = Infinity;
+      for (const [a, b] of segs) {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const len2 = dx * dx + dy * dy;
+        const t = len2 > 0 ? Math.min(1, Math.max(0, ((px - a.x) * dx + (py - a.y) * dy) / len2)) : 0;
+        d = Math.min(d, Math.hypot(px - a.x - t * dx, py - a.y - t * dy));
+      }
+      let v = d <= solid ? 1 : solid >= r ? 0 : 1 - (d - solid) / (r - solid);
+      v = Math.min(v, Math.min(1, Math.max(0, r + 0.5 - d)));
+      out[y * bw + x] = Math.round(Math.max(0, v) * 255);
+    }
+  }
+  return selectionFromRegion(width, height, { x: bx, y: by, width: bw, height: bh }, out);
+}
+function applyRefineEdits(pixels, selection, edits, width, height) {
+  let sel = selection?.bounds ? selection : null;
+  let band = null;
+  for (const e of edits) {
+    if (e.kind === "object") {
+      if (!pixels) throw new Error("Object Selection needs the image pixels.");
+      if (!e.rect === !e.point) throw new Error("An object edit takes rect (a box around the object) or point (on it), not both.");
+      const region2 = selectObjectIn(pixels, e.rect ? { rect: e.rect } : { point: e.point });
+      sel = combineSelections(sel, region2, e.mode ?? "add");
+      continue;
+    }
+    if (!e.points.length) throw new Error(`A ${e.kind} stroke needs at least one point.`);
+    if (e.kind === "lasso") {
+      if (e.points.length < 3) throw new Error("A lasso edit needs at least 3 points.");
+      sel = combineSelections(sel, polygonSelection(width, height, e.points, {}), e.mode ?? "add");
+      continue;
+    }
+    if (e.kind === "refine-brush") {
+      band = combineSelections(band, brushStrokeMask(width, height, e.points, e.size ?? 40), "add");
+      continue;
+    }
+    const mode = e.mode ?? "add";
+    let region;
+    if (e.kind === "quick-select") {
+      if (!pixels) throw new Error("Quick Selection strokes need the image pixels.");
+      region = quickSelectStroke(pixels, e.points, { size: e.size, selection: sel, grow: mode === "add" });
+    } else {
+      region = brushStrokeMask(width, height, e.points, e.size ?? 20, e.hardness ?? 1);
+    }
+    sel = combineSelections(sel, region, mode);
+  }
+  return { selection: sel, refineBrush: band };
+}
+
+// src/image-editor/selection/segment/guided.ts
+function workPlanes(work) {
+  const n = work.width * work.height;
+  const planes = [new Float32Array(n), new Float32Array(n), new Float32Array(n)];
+  for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) planes[c][i] = work.rgb[i * 3 + c] / 255;
+  return planes;
+}
+function workLuma(work) {
+  const n = work.width * work.height;
+  const out = new Float32Array(n);
+  const { rgb } = work;
+  for (let i = 0; i < n; i++) out[i] = (0.299 * rgb[i * 3] + 0.587 * rgb[i * 3 + 1] + 0.114 * rgb[i * 3 + 2]) / 255;
+  return out;
+}
+function softMaskToSelection(work, mask) {
+  const { sourceWidth: W, sourceHeight: H, width: w, height: h, scale } = work;
+  const out = new Uint8Array(W * H);
+  const col = new Int32Array(W);
+  const fx = new Float32Array(W);
+  for (let X = 0; X < W; X++) {
+    const u = Math.min(w - 1, Math.max(0, (X + 0.5) * scale - 0.5));
+    col[X] = Math.min(w - 2, Math.floor(u));
+    fx[X] = u - col[X];
+    if (w === 1) {
+      col[X] = 0;
+      fx[X] = 0;
+    }
+  }
+  for (let Y = 0; Y < H; Y++) {
+    const v = Math.min(h - 1, Math.max(0, (Y + 0.5) * scale - 0.5));
+    const j = h === 1 ? 0 : Math.min(h - 2, Math.floor(v));
+    const fy = h === 1 ? 0 : v - j;
+    const r0 = j * w;
+    const r1 = h === 1 ? r0 : r0 + w;
+    for (let X = 0; X < W; X++) {
+      const i = col[X];
+      const i1 = w === 1 ? i : i + 1;
+      const t = fx[X];
+      const m = (mask[r0 + i] * (1 - t) + mask[r0 + i1] * t) * (1 - fy) + (mask[r1 + i] * (1 - t) + mask[r1 + i1] * t) * fy;
+      out[Y * W + X] = Math.round(Math.min(1, Math.max(0, m)) * 255);
+    }
+  }
+  return selectionFromRegion(W, H, { x: 0, y: 0, width: W, height: H }, out);
+}
+
+// src/image-editor/selection/segment/subject.ts
+function toLab(r, g, b) {
+  const lin = (v) => {
+    v /= 255;
+    return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+  };
+  const R = lin(r);
+  const G = lin(g);
+  const B = lin(b);
+  const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
+  const x = f((0.4124 * R + 0.3576 * G + 0.1805 * B) / 0.95047);
+  const y = f(0.2126 * R + 0.7152 * G + 0.0722 * B);
+  const z = f((0.0193 * R + 0.1192 * G + 0.9505 * B) / 1.08883);
+  return [116 * y - 16, 500 * (x - y), 200 * (y - z)];
+}
+function slicSuperpixels(work, target = 400, compactness = 10, rounds = 5) {
+  const { width: w, height: h, rgb } = work;
+  const n = w * h;
+  const lab2 = new Float32Array(n * 3);
+  for (let i = 0; i < n; i++) lab2.set(toLab(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]), i * 3);
+  const S = Math.max(2, Math.round(Math.sqrt(n / target)));
+  const seeds = [];
+  for (let y = Math.floor(S / 2); y < h; y += S) {
+    for (let x = Math.floor(S / 2); x < w; x += S) {
+      const i = y * w + x;
+      seeds.push([lab2[i * 3], lab2[i * 3 + 1], lab2[i * 3 + 2], x, y]);
+    }
+  }
+  const k = seeds.length;
+  const label = new Int32Array(n).fill(-1);
+  const best = new Float64Array(n);
+  const m2 = (compactness / S) ** 2;
+  for (let round = 0; round < rounds; round++) {
+    best.fill(Infinity);
+    for (let c = 0; c < k; c++) {
+      const [L, A, B, cx, cy] = seeds[c];
+      const x0 = Math.max(0, Math.floor(cx - S));
+      const x1 = Math.min(w - 1, Math.ceil(cx + S));
+      const y0 = Math.max(0, Math.floor(cy - S));
+      const y1 = Math.min(h - 1, Math.ceil(cy + S));
+      for (let y = y0; y <= y1; y++) {
+        for (let x = x0; x <= x1; x++) {
+          const i = y * w + x;
+          const d = (lab2[i * 3] - L) ** 2 + (lab2[i * 3 + 1] - A) ** 2 + (lab2[i * 3 + 2] - B) ** 2 + m2 * ((x - cx) ** 2 + (y - cy) ** 2);
+          if (d < best[i]) {
+            best[i] = d;
+            label[i] = c;
+          }
+        }
+      }
+    }
+    const sum = new Float64Array(k * 6);
+    for (let i = 0; i < n; i++) {
+      const c = label[i];
+      sum[c * 6] += lab2[i * 3];
+      sum[c * 6 + 1] += lab2[i * 3 + 1];
+      sum[c * 6 + 2] += lab2[i * 3 + 2];
+      sum[c * 6 + 3] += i % w;
+      sum[c * 6 + 4] += Math.floor(i / w);
+      sum[c * 6 + 5]++;
+    }
+    for (let c = 0; c < k; c++) {
+      const s = sum[c * 6 + 5];
+      if (s) seeds[c] = [sum[c * 6] / s, sum[c * 6 + 1] / s, sum[c * 6 + 2] / s, sum[c * 6 + 3] / s, sum[c * 6 + 4] / s];
+    }
+  }
+  const remap = new Int32Array(k).fill(-1);
+  let count = 0;
+  for (let i = 0; i < n; i++) if (remap[label[i]] < 0) remap[label[i]] = count++;
+  const meanLab = new Float64Array(count * 3);
+  const centre = new Float64Array(count * 2);
+  const size = new Int32Array(count);
+  for (let i = 0; i < n; i++) {
+    const c = label[i] = remap[label[i]];
+    meanLab[c * 3] += lab2[i * 3];
+    meanLab[c * 3 + 1] += lab2[i * 3 + 1];
+    meanLab[c * 3 + 2] += lab2[i * 3 + 2];
+    centre[c * 2] += i % w;
+    centre[c * 2 + 1] += Math.floor(i / w);
+    size[c]++;
+  }
+  for (let c = 0; c < count; c++) {
+    for (let j = 0; j < 3; j++) meanLab[c * 3 + j] /= size[c];
+    centre[c * 2] /= size[c];
+    centre[c * 2 + 1] /= size[c];
+  }
+  return { label, count, lab: meanLab, centre, size };
+}
+function superpixelSaliency(sp, width, height) {
+  const { count, lab: lab2, centre, size, label } = sp;
+  const dist = (a, b) => Math.hypot(lab2[a * 3] - lab2[b * 3], lab2[a * 3 + 1] - lab2[b * 3 + 1], lab2[a * 3 + 2] - lab2[b * 3 + 2]);
+  const onBorder = new Uint8Array(count);
+  for (let x = 0; x < width; x++) {
+    onBorder[label[x]] = 1;
+    onBorder[label[(height - 1) * width + x]] = 1;
+  }
+  for (let y = 0; y < height; y++) {
+    onBorder[label[y * width]] = 1;
+    onBorder[label[y * width + width - 1]] = 1;
+  }
+  const border = [];
+  for (let c = 0; c < count; c++) if (onBorder[c]) border.push(c);
+  const diag = Math.hypot(width, height);
+  const unlikeBorder = new Float64Array(count);
+  const contrast = new Float64Array(count);
+  const centreBias = new Float64Array(count);
+  for (let i = 0; i < count; i++) {
+    const ds = border.map((j) => dist(i, j)).sort((a, b) => a - b);
+    unlikeBorder[i] = ds.length ? ds[Math.floor(ds.length * 0.25)] : 0;
+    let s = 0;
+    let wsum = 0;
+    for (let j = 0; j < count; j++) {
+      if (j === i) continue;
+      const dx = (centre[i * 2] - centre[j * 2]) / diag;
+      const dy = (centre[i * 2 + 1] - centre[j * 2 + 1]) / diag;
+      const wgt = size[j] * Math.exp(-(dx * dx + dy * dy) / (2 * 0.25 * 0.25));
+      s += wgt * dist(i, j);
+      wsum += wgt;
+    }
+    contrast[i] = wsum ? s / wsum : 0;
+    const cx = centre[i * 2] / width - 0.5;
+    const cy = centre[i * 2 + 1] / height - 0.5;
+    centreBias[i] = 0.4 + 0.6 * Math.exp(-(cx * cx + cy * cy) / (2 * 0.3 * 0.3));
+  }
+  let farthest = 0;
+  for (const v of unlikeBorder) farthest = Math.max(farthest, v);
+  if (farthest < 6) return new Float64Array(count);
+  const norm = (a) => {
+    let max = 0;
+    for (const v of a) max = Math.max(max, v);
+    if (max > 0) for (let i = 0; i < a.length; i++) a[i] /= max;
+  };
+  norm(unlikeBorder);
+  norm(contrast);
+  const out = new Float64Array(count);
+  for (let i = 0; i < count; i++) out[i] = unlikeBorder[i] * (0.3 + 0.7 * contrast[i]) * centreBias[i];
+  norm(out);
+  return out;
+}
+function otsuThreshold(values, weights) {
+  const BINS2 = 64;
+  const hist = new Float64Array(BINS2);
+  let total = 0;
+  for (let i = 0; i < values.length; i++) {
+    hist[Math.min(BINS2 - 1, Math.floor(values[i] * BINS2))] += weights[i];
+    total += weights[i];
+  }
+  let sumAll = 0;
+  for (let b = 0; b < BINS2; b++) sumAll += b * hist[b];
+  let wB = 0;
+  let sumB = 0;
+  let best = 0;
+  let bestT = 0.5;
+  for (let b = 0; b < BINS2 - 1; b++) {
+    wB += hist[b];
+    if (!wB) continue;
+    const wF = total - wB;
+    if (!wF) break;
+    sumB += b * hist[b];
+    const between = wB * wF * (sumB / wB - (sumAll - sumB) / wF) ** 2;
+    if (between > best) {
+      best = between;
+      bestT = (b + 1) / BINS2;
+    }
+  }
+  return bestT;
+}
+function findSubject(pixels, options = {}) {
+  const report = options.onProgress;
+  report?.(0, "Reducing the image");
+  const work = workImage(pixels);
+  const { width: w, height: h } = work;
+  report?.(0.1, "Grouping into superpixels");
+  const sp = slicSuperpixels(work);
+  report?.(0.3, "Measuring what stands out");
+  const sal = superpixelSaliency(sp, w, h);
+  report?.(0.4, "Finding the subject");
+  const t = otsuThreshold(sal, sp.size);
+  const n = w * h;
+  const initial = new Uint8Array(n);
+  const hardBg = new Uint8Array(n);
+  const hardFg = new Uint8Array(n);
+  const strong = t + 0.6 * (1 - t);
+  for (let i = 0; i < n; i++) {
+    const s = sal[sp.label[i]];
+    if (s >= t) initial[i] = 1;
+    if (s >= strong) hardFg[i] = 1;
+  }
+  for (let x = 0; x < w; x++) {
+    for (const y of [0, h - 1]) if (sal[sp.label[y * w + x]] < t * 0.5) hardBg[y * w + x] = 1;
+  }
+  for (let y = 0; y < h; y++) {
+    for (const x of [0, w - 1]) if (sal[sp.label[y * w + x]] < t * 0.5) hardBg[y * w + x] = 1;
+  }
+  const empty = (reason) => ({ selection: createSelectionMask(pixels.width, pixels.height), reason });
+  let guessed = 0;
+  for (let i = 0; i < n; i++) guessed += initial[i];
+  if (!guessed || guessed > n * 0.95) return empty("Nothing stands out from the background.");
+  const roi = { x: 0, y: 0, width: w, height: h };
+  const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, 5, (f) => report?.(0.4 + 0.5 * f, "Finding the subject"));
+  keepMainPieces(label, w, h, null);
+  let kept = 0;
+  for (let i = 0; i < n; i++) kept += label[i];
+  if (kept < n * 2e-3) return empty("Nothing stands out from the background.");
+  if (kept > n * 0.97) return empty("The whole image looks like one subject; select it with select_all instead.");
+  report?.(0.9, "Scaling up");
+  const selection = upscaleRegion(work, pixels, roi, label, options.enhanceEdge ?? false);
+  report?.(1, "Done");
+  return { selection };
+}
+
+// src/image-editor/selection/segment/focus.ts
+var FOCUS_SIZE = 1024;
+function estimateNoise(luma, w, h) {
+  if (w < 3 || h < 3) return 0;
+  let sum = 0;
+  for (let y = 1; y < h - 1; y++) {
+    for (let x = 1; x < w - 1; x++) {
+      const i = y * w + x;
+      const v = luma[i - w - 1] - 2 * luma[i - w] + luma[i - w + 1] - 2 * luma[i - 1] + 4 * luma[i] - 2 * luma[i + 1] + luma[i + w - 1] - 2 * luma[i + w] + luma[i + w + 1];
+      sum += Math.abs(v);
+    }
+  }
+  return Math.sqrt(Math.PI / 2) * sum / (6 * (w - 2) * (h - 2));
+}
+function focusArea(pixels, options = {}) {
+  const report = options.onProgress;
+  report?.(0, "Reducing the image");
+  const work = workImage(pixels, FOCUS_SIZE);
+  report?.(0.2, "Measuring sharpness");
+  const { width: w, height: h, scale } = work;
+  const n = w * h;
+  const luma = workLuma(work);
+  const sigma = estimateNoise(luma, w, h);
+  const noise = Math.min(100, Math.max(0, options.noise ?? 0));
+  const floor = 2 * sigma * (1 + noise / 25);
+  const detail = new Float32Array(n);
+  for (let y = 1; y < h - 1; y++) {
+    for (let x = 1; x < w - 1; x++) {
+      const i = y * w + x;
+      const lap = Math.abs(4 * luma[i] - luma[i - 1] - luma[i + 1] - luma[i - w] - luma[i + w]);
+      const d = Math.max(0, lap - floor);
+      detail[i] = d * d;
+    }
+  }
+  const r = Math.max(2, Math.round(0.012 * Math.max(w, h)));
+  const energy = boxMean(detail, w, h, r);
+  const sharp = new Float32Array(n);
+  for (let i = 0; i < n; i++) sharp[i] = Math.log1p(Math.sqrt(energy[i]) * 400);
+  report?.(0.5, "Separating what is in focus");
+  const sorted = Float32Array.from(sharp).sort();
+  const top = sorted[Math.floor(n * 0.995)] || 1;
+  for (let i = 0; i < n; i++) sharp[i] = Math.min(1, sharp[i] / top);
+  const ones = new Float32Array(n).fill(1);
+  const otsu = otsuThreshold(sharp, ones);
+  const range = Math.min(100, Math.max(0, options.range ?? 50));
+  const t = Math.min(0.98, otsu * Math.pow(2, (50 - range) / 25));
+  let mask = new Float32Array(n);
+  for (let i = 0; i < n; i++) mask[i] = sharp[i] >= t ? 1 : 0;
+  const c = 2 * r;
+  const grown = boxMean(mask, w, h, c);
+  for (let i = 0; i < n; i++) grown[i] = grown[i] > 1e-3 ? 1 : 0;
+  const shrunk = boxMean(grown, w, h, c);
+  for (let i = 0; i < n; i++) mask[i] = shrunk[i] >= 0.999 ? 1 : 0;
+  const pulled = boxMean(mask, w, h, Math.max(1, Math.round(r / 2)));
+  for (let i = 0; i < n; i++) mask[i] = pulled[i] >= 0.999 ? 1 : 0;
+  report?.(0.7, "Fitting the edge");
+  const softness = Math.max(0, options.softness ?? 4) * scale;
+  if (softness > 0) {
+    const fitted = guidedFilterColor(workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
+    for (let i = 0; i < n; i++) mask[i] = Math.min(1, Math.max(0, fitted[i]));
+  }
+  const selection = softMaskToSelection(work, mask);
+  report?.(1, "Done");
+  return { selection, noiseLevel: Math.round(sigma * 255 * 10) / 10 };
+}
+
+// src/image-editor/selection/segment/sky.ts
+var SKY_SIZE = 768;
+function lab(r, g, b) {
+  const lin = (v) => {
+    v /= 255;
+    return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+  };
+  const R = lin(r);
+  const G = lin(g);
+  const B = lin(b);
+  const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
+  const x = f((0.4124 * R + 0.3576 * G + 0.1805 * B) / 0.95047);
+  const y = f(0.2126 * R + 0.7152 * G + 0.0722 * B);
+  const z = f((0.0193 * R + 0.1192 * G + 0.9505 * B) / 1.08883);
+  return [116 * y - 16, 500 * (x - y), 200 * (y - z)];
+}
+var sigmoid = (v) => 1 / (1 + Math.exp(-v));
+function findSky(pixels, options = {}) {
+  const report = options.onProgress;
+  report?.(0, "Reducing the image");
+  const work = workImage(pixels, SKY_SIZE);
+  report?.(0.2, "Scoring the sky");
+  const { width: w, height: h, rgb, scale } = work;
+  const n = w * h;
+  const L = new Float32Array(n);
+  const A = new Float32Array(n);
+  const B = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const [l, a, b] = lab(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+    L[i] = l;
+    A[i] = a;
+    B[i] = b;
+  }
+  const luma = boxMean(workLuma(work), w, h, 1);
+  const grad = new Float32Array(n);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = y * w + x;
+      const gx = x + 1 < w ? luma[i + 1] - luma[i] : 0;
+      const gy = y + 1 < h ? luma[i + w] - luma[i] : 0;
+      grad[i] = Math.hypot(gx, gy);
+    }
+  }
+  const roughR = Math.max(1, Math.round(6e-3 * Math.max(w, h)));
+  const rough = boxMean(grad, w, h, roughR);
+  const score = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const chroma = Math.hypot(A[i], B[i]);
+    const blue = sigmoid((-B[i] - 6) / 4) * sigmoid((L[i] - 35) / 6);
+    const grey = sigmoid((L[i] - 68) / 5) * sigmoid((18 - chroma) / 4);
+    const smooth = Math.exp(-rough[i] / 0.02);
+    const y = Math.floor(i / w) / h;
+    const high = 1 - 0.35 * y;
+    score[i] = Math.max(blue, grey) * smooth * high;
+  }
+  const threshold = Math.min(100, Math.max(0, options.threshold ?? 50));
+  const t = 0.55 - (threshold - 50) * 6e-3;
+  report?.(0.5, "Growing the sky");
+  const sky = new Uint8Array(n);
+  const stack = [];
+  const seedRows = Math.max(1, Math.round(h * 0.04));
+  for (let y = 0; y < seedRows; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = y * w + x;
+      if (score[i] >= t) {
+        sky[i] = 1;
+        stack.push(i);
+      }
+    }
+  }
+  if (!stack.length) return { selection: createSelectionMask(pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
+  const low = t * 0.7;
+  while (stack.length) {
+    const p = stack.pop();
+    const x = p % w;
+    for (const q of [x + 1 < w ? p + 1 : -1, x > 0 ? p - 1 : -1, p + w < n ? p + w : -1, p - w]) {
+      if (q < 0 || sky[q] || score[q] < low) continue;
+      if (Math.hypot(L[q] - L[p], A[q] - A[p], B[q] - B[p]) > 6) continue;
+      sky[q] = 1;
+      stack.push(q);
+    }
+  }
+  let count = 0;
+  const mean = [0, 0, 0];
+  for (let i = 0; i < n; i++) {
+    if (!sky[i]) continue;
+    mean[0] += L[i];
+    mean[1] += A[i];
+    mean[2] += B[i];
+    count++;
+  }
+  for (let k = 0; k < 3; k++) mean[k] /= count;
+  let spread = 0;
+  for (let i = 0; i < n; i++) if (sky[i]) spread += (L[i] - mean[0]) ** 2 + (A[i] - mean[1]) ** 2 + (B[i] - mean[2]) ** 2;
+  const limit = Math.max(8, 2.5 * Math.sqrt(spread / count));
+  for (let i = 0; i < n; i++) {
+    if (sky[i] || score[i] < t) continue;
+    if (Math.hypot(L[i] - mean[0], A[i] - mean[1], B[i] - mean[2]) <= limit) sky[i] = 1;
+  }
+  let front = [];
+  for (let i = 0; i < n; i++) if (sky[i]) front.push(i);
+  for (let step = 0; step <= roughR + 1 && front.length; step++) {
+    const next = [];
+    for (const p of front) {
+      const x = p % w;
+      for (const q of [x + 1 < w ? p + 1 : -1, x > 0 ? p - 1 : -1, p + w < n ? p + w : -1, p - w]) {
+        if (q < 0 || sky[q]) continue;
+        if (Math.hypot(L[q] - mean[0], A[q] - mean[1], B[q] - mean[2]) > limit) continue;
+        sky[q] = 1;
+        next.push(q);
+      }
+    }
+    front = next;
+  }
+  if (count < n * 5e-3) return { selection: createSelectionMask(pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
+  report?.(0.7, "Fitting the edge");
+  let mask = Float32Array.from(sky);
+  const softness = Math.max(0, options.softness ?? 4) * scale;
+  if (softness > 0) {
+    const fitted = guidedFilterColor(workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
+    mask = new Float32Array(n);
+    for (let i = 0; i < n; i++) mask[i] = Math.min(1, Math.max(0, fitted[i]));
+  }
+  const selection = softMaskToSelection(work, mask);
+  report?.(1, "Done");
+  return { selection };
+}
+
+// src/image-editor/selection/worker.ts
+function serializeMask(mask) {
+  const b = mask.bounds;
+  if (!b) return { width: mask.width, height: mask.height, bounds: null, bytes: new Uint8Array(0) };
+  const bytes = new Uint8Array(b.width * b.height);
+  const data = mask.data;
+  for (let y = 0; y < b.height; y++) bytes.set(data.subarray((b.y + y) * mask.width + b.x, (b.y + y) * mask.width + b.x + b.width), y * b.width);
+  return { width: mask.width, height: mask.height, bounds: { ...b }, bytes };
+}
+function deserializeMask(s) {
+  return s.bounds ? selectionFromRegion(s.width, s.height, s.bounds, s.bytes) : createSelectionMask(s.width, s.height);
+}
+function runSelectionJob(job, pixels, onProgress) {
+  switch (job.op) {
+    case "subject": {
+      const { selection, reason } = findSubject(pixels, { enhanceEdge: job.enhanceEdge, onProgress });
+      return { mask: selection, reason };
+    }
+    case "object":
+      return { mask: selectObjectIn(pixels, job.target, { enhanceEdge: job.enhanceEdge, onProgress }) };
+    case "focus": {
+      const { selection, noiseLevel } = focusArea(pixels, { ...job.options, onProgress });
+      return { mask: selection, noiseLevel };
+    }
+    case "sky": {
+      const { selection, reason } = findSky(pixels, { ...job.options, onProgress });
+      return { mask: selection, reason };
+    }
+    case "quick":
+      return {
+        mask: quickSelectStroke(pixels, job.stroke, {
+          size: job.size,
+          grow: job.grow,
+          enhanceEdge: job.enhanceEdge,
+          selection: job.selection ? deserializeMask(job.selection) : null
+        })
+      };
+    case "refine-preview": {
+      onProgress?.(0, "Refining");
+      const base = job.base ? deserializeMask(job.base) : null;
+      const { selection, refineBrush } = applyRefineEdits(pixels, base, job.edits, pixels.width, pixels.height);
+      const mask = selection?.bounds ? refineSelection(pixels, selection, job.params, refineBrush) : createSelectionMask(pixels.width, pixels.height);
+      onProgress?.(1, "Done");
+      return { mask };
+    }
+  }
+}
+function startSelectionWorker(scope) {
+  const images = /* @__PURE__ */ new Map();
+  scope.onmessage = (event) => {
+    const msg = event.data;
+    if (msg.type === "pixels") {
+      images.set(msg.key, msg.pixels);
+      while (images.size > 2) images.delete(images.keys().next().value);
+      return;
+    }
+    const pixels = images.get(msg.key);
+    try {
+      if (!pixels) throw new Error("The selection worker has no image for this job; send the pixels first.");
+      const result = runSelectionJob(msg.job, pixels, (fraction, stage) => scope.postMessage({ type: "progress", id: msg.id, fraction, stage }));
+      const mask = serializeMask(result.mask);
+      scope.postMessage({ type: "done", id: msg.id, mask, reason: result.reason, noiseLevel: result.noiseLevel }, [mask.bytes.buffer]);
+    } catch (err) {
+      scope.postMessage({ type: "error", id: msg.id, message: err instanceof Error ? err.message : String(err) });
+    }
+  };
+}
+var abortError = () => typeof DOMException === "function" ? new DOMException("The selection was cancelled.", "AbortError") : Object.assign(new Error("The selection was cancelled."), { name: "AbortError" });
+var SelectionWorkerClient = class {
+  constructor(factory) {
+    this.factory = factory;
+  }
+  factory;
+  worker = null;
+  /** Pixel buffers this worker already has, by their data array. */
+  sent = /* @__PURE__ */ new WeakMap();
+  nextKey = 1;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  /** Runs `job` on `pixels` in the worker. Aborting `signal` terminates the worker and rejects with an `AbortError`. */
+  run(job, pixels, options = {}) {
+    if (options.signal?.aborted) return Promise.reject(abortError());
+    const worker = this.ensure();
+    let key = this.sent.get(pixels.data);
+    if (key === void 0) {
+      key = this.nextKey++;
+      this.sent.set(pixels.data, key);
+      worker.postMessage({ type: "pixels", key, pixels: { width: pixels.width, height: pixels.height, data: pixels.data } });
+    }
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, onProgress: options.onProgress });
+      options.signal?.addEventListener(
+        "abort",
+        () => {
+          if (this.pending.has(id)) this.terminate(abortError());
+        },
+        { once: true }
+      );
+      worker.postMessage({ type: "job", id, key, job });
+    });
+  }
+  /** Stops the worker; jobs still running reject with `reason` (default an `AbortError`). */
+  terminate(reason = abortError()) {
+    this.worker?.terminate?.();
+    this.worker = null;
+    this.sent = /* @__PURE__ */ new WeakMap();
+    const pending = [...this.pending.values()];
+    this.pending.clear();
+    for (const p of pending) p.reject(reason);
+  }
+  ensure() {
+    if (this.worker) return this.worker;
+    const worker = this.factory();
+    worker.onmessage = (event) => {
+      const msg = event.data;
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      if (msg.type === "progress") p.onProgress?.(msg.fraction, msg.stage);
+      else {
+        this.pending.delete(msg.id);
+        if (msg.type === "error") p.reject(new Error(msg.message));
+        else p.resolve({ mask: deserializeMask(msg.mask), reason: msg.reason, noiseLevel: msg.noiseLevel });
+      }
+    };
+    worker.onerror = (event) => this.terminate(new Error(event?.message || "The selection worker failed."));
+    this.worker = worker;
+    return worker;
+  }
+};
+
+export {
+  DEFAULT_REFINE_EDGE_PARAMS,
+  GUIDED_FILTER_EPS,
+  normalizeRefineEdgeParams,
+  refineEdgeHalo,
+  boxMean,
+  guidedFilterColor,
+  edgeWidth,
+  refineCoverage,
+  guidePlanes,
+  refineSelection,
+  decontaminateColors,
+  polygonCoverage,
+  polygonCoverageBox,
+  polygonSelection,
+  normalizeRect,
+  rectSelection,
+  ellipsePoints,
+  ellipseSelection,
+  GridGraph,
+  WORK_SIZE,
+  workImage,
+  GAMMA,
+  UNITS,
+  smoothnessWeights,
+  boxBlur,
+  upscaleRegion,
+  ColorGmm,
+  grabCutLabels,
+  keepMainPieces,
+  selectObjectIn,
+  quickSelectStroke,
+  REFINE_EDIT_KINDS,
+  brushStrokeMask,
+  applyRefineEdits,
+  workPlanes,
+  workLuma,
+  softMaskToSelection,
+  slicSuperpixels,
+  superpixelSaliency,
+  otsuThreshold,
+  findSubject,
+  focusArea,
+  findSky,
+  serializeMask,
+  deserializeMask,
+  runSelectionJob,
+  startSelectionWorker,
+  SelectionWorkerClient
+};