@pixerate/editor 0.209.0 → 0.211.0

package/dist/{chunk-USQCKRZG.js → chunk-ZGJGSCUW.js}

@@ -1,3 +1,11 @@
+import {
+  bestOffset,
+  contentAwareFill,
+  dilateMask,
+  maskBounds,
+  membraneFill,
+  seamlessClone
+} from "./chunk-XI2NV5U7.js";
 import {
   DabWalker,
   SmudgeTip,
@@ -16,444 +24,6 @@ import {
   tileKey
 } from "./chunk-HVVR5PZW.js";
 
-// 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;
-      }
-    }
-  }
-  w;
-  h;
-  s;
-  /** 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;
-}
-var PATCH_R = 3;
-function rng(seed) {
-  let a = seed >>> 0;
-  return () => {
-    a = a + 1831565813 >>> 0;
-    let t = a;
-    t = Math.imul(t ^ t >>> 15, t | 1);
-    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
-function downsample(l, ch) {
-  const w = Math.max(1, l.w >> 1);
-  const h = Math.max(1, l.h >> 1);
-  const img = new Float32Array(w * h * ch);
-  const hole = new Uint8Array(w * h);
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      let n = 0;
-      const o = (y * w + x) * ch;
-      for (let dy = 0; dy < 2; dy++) {
-        for (let dx = 0; dx < 2; dx++) {
-          const sx = Math.min(l.w - 1, 2 * x + dx);
-          const sy = Math.min(l.h - 1, 2 * y + dy);
-          const i = sy * l.w + sx;
-          if (l.hole[i]) {
-            hole[y * w + x] = 1;
-            continue;
-          }
-          for (let c = 0; c < ch; c++) img[o + c] += l.img[i * ch + c];
-          n++;
-        }
-      }
-      if (n) for (let c = 0; c < ch; c++) img[o + c] /= n;
-    }
-  }
-  return { w, h, img, hole };
-}
-function contentAwareFill(w, h, ch, img, hole, options = {}) {
-  const iters = options.iterations ?? 4;
-  const base = { w, h, img: Float32Array.from(img), hole: Uint8Array.from(hole, (v) => v ? 1 : 0) };
-  const levels = [base];
-  while (levels.length < 4) {
-    const top = levels[levels.length - 1];
-    const b = maskBounds(top.w, top.h, top.hole);
-    if (!b || Math.max(b[2] - b[0], b[3] - b[1]) < 4 * PATCH_R || top.w < 8 * PATCH_R || top.h < 8 * PATCH_R) break;
-    levels.push(downsample(top, ch));
-  }
-  const random = rng(options.seed ?? w * 73856093 + h * 19349663);
-  let prevFill = null;
-  let prevNnf = null;
-  let prevW = 0;
-  for (let li = levels.length - 1; li >= 0; li--) {
-    const { w: W, h: H, hole: holeL } = levels[li];
-    const cur = new Float32Array(levels[li].img);
-    if (prevFill) {
-      for (let i = 0; i < W * H; i++) {
-        if (!holeL[i]) continue;
-        const x = Math.min(prevW - 1, i % W >> 1);
-        const y = Math.min(Math.floor(prevFill.length / ch / prevW) - 1, Math.floor(i / W) >> 1);
-        for (let c = 0; c < ch; c++) cur[i * ch + c] = prevFill[(y * prevW + x) * ch + c];
-      }
-    } else cur.set(membraneFill(W, H, ch, cur, holeL));
-    const blocked = dilateMask(W, H, holeL, PATCH_R);
-    const valid = [];
-    for (let y = PATCH_R; y < H - PATCH_R; y++) for (let x = PATCH_R; x < W - PATCH_R; x++) if (!blocked[y * W + x]) valid.push(y * W + x);
-    if (!valid.length) {
-      prevFill = cur;
-      prevNnf = null;
-      prevW = W;
-      continue;
-    }
-    const targets = [];
-    for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) if (blocked[y * W + x]) targets.push(y * W + x);
-    const nnf = new Int32Array(W * H).fill(-1);
-    const cost = new Float64Array(W * H);
-    const clampC = (v, n) => Math.min(n - 1 - PATCH_R, Math.max(PATCH_R, v));
-    const dist = (t, s, limit) => {
-      const tx = clampC(t % W, W);
-      const ty = clampC(Math.floor(t / W), H);
-      const sx = s % W;
-      const sy = Math.floor(s / W);
-      let d = 0;
-      for (let dy = -PATCH_R; dy <= PATCH_R; dy++) {
-        const tr = (ty + dy) * W;
-        const sr = (sy + dy) * W;
-        for (let dx = -PATCH_R; dx <= PATCH_R; dx++) {
-          const a = (tr + tx + dx) * ch;
-          const b = (sr + sx + dx) * ch;
-          for (let c = 0; c < ch; c++) {
-            const e = cur[a + c] - cur[b + c];
-            d += e * e;
-          }
-        }
-        if (d >= limit) return d;
-      }
-      return d;
-    };
-    const isValid = (s) => {
-      const x = s % W;
-      const y = Math.floor(s / W);
-      return s >= 0 && x >= PATCH_R && y >= PATCH_R && x < W - PATCH_R && y < H - PATCH_R && !blocked[s];
-    };
-    for (const t of targets) {
-      let s = -1;
-      if (prevNnf) {
-        const px = Math.min(prevW - 1, t % W >> 1);
-        const py = Math.floor(t / W) >> 1;
-        const ps = prevNnf[py * prevW + px];
-        if (ps >= 0) {
-          const cand = (Math.floor(ps / prevW) * 2 + (Math.floor(t / W) & 1)) * W + ps % prevW * 2 + (t % W & 1);
-          if (isValid(cand)) s = cand;
-        }
-      }
-      if (s < 0) s = valid[Math.floor(random() * valid.length)];
-      nnf[t] = s;
-    }
-    for (let em = 0; em < iters; em++) {
-      for (const t of targets) cost[t] = dist(t, nnf[t], Infinity);
-      for (let pass = 0; pass < 4; pass++) {
-        const fwd = pass % 2 === 0;
-        const step = fwd ? 1 : -1;
-        for (let k = 0; k < targets.length; k++) {
-          const t = targets[fwd ? k : targets.length - 1 - k];
-          const tx = t % W;
-          const ty = Math.floor(t / W);
-          for (const [nx, ny] of [[tx - step, ty], [tx, ty - step]]) {
-            if (nx < 0 || ny < 0 || nx >= W || ny >= H) continue;
-            const ns = nnf[ny * W + nx];
-            if (ns < 0) continue;
-            const cand = ns + step * (nx === tx ? W : 1);
-            if (!isValid(cand) || cand === nnf[t]) continue;
-            const d = dist(t, cand, cost[t]);
-            if (d < cost[t]) {
-              cost[t] = d;
-              nnf[t] = cand;
-            }
-          }
-          const bx = nnf[t] % W;
-          const by = Math.floor(nnf[t] / W);
-          for (let r = Math.max(W, H); r >= 1; r >>= 1) {
-            const cx = Math.round(bx + (random() * 2 - 1) * r);
-            const cy = Math.round(by + (random() * 2 - 1) * r);
-            const cand = cy * W + cx;
-            if (cx < 0 || cy < 0 || cx >= W || cy >= H || !isValid(cand)) continue;
-            const d = dist(t, cand, cost[t]);
-            if (d < cost[t]) {
-              cost[t] = d;
-              nnf[t] = cand;
-            }
-          }
-        }
-      }
-      const acc = new Float64Array(W * H * ch);
-      const wsum = new Float64Array(W * H);
-      for (const t of targets) {
-        const tx = clampC(t % W, W);
-        const ty = clampC(Math.floor(t / W), H);
-        const s = nnf[t];
-        const sx = s % W;
-        const sy = Math.floor(s / W);
-        for (let dy = -PATCH_R; dy <= PATCH_R; dy++) {
-          for (let dx = -PATCH_R; dx <= PATCH_R; dx++) {
-            const q = (ty + dy) * W + tx + dx;
-            if (!holeL[q]) continue;
-            const src = ((sy + dy) * W + sx + dx) * ch;
-            for (let c = 0; c < ch; c++) acc[q * ch + c] += cur[src + c];
-            wsum[q] += 1;
-          }
-        }
-      }
-      for (let q = 0; q < W * H; q++) if (holeL[q] && wsum[q] > 0) for (let c = 0; c < ch; c++) cur[q * ch + c] = acc[q * ch + c] / wsum[q];
-    }
-    prevFill = cur;
-    prevNnf = nnf;
-    prevW = W;
-  }
-  const out = Float32Array.from(img);
-  for (let i = 0; i < w * h; i++) if (base.hole[i]) for (let c = 0; c < ch; c++) out[i * ch + c] = prevFill[i * ch + c];
-  return out;
-}
-
 // src/paint/retouch.ts
 var TONE_RANGES = ["shadows", "midtones", "highlights"];
 function luma(r, g, b) {
@@ -1097,13 +667,6 @@ function unionRect(a, b) {
 }
 
 export {
-  solveMembrane,
-  seamlessClone,
-  membraneFill,
-  dilateMask,
-  maskBounds,
-  bestOffset,
-  contentAwareFill,
   TONE_RANGES,
   luma,
   dodgeBurnCurve,

package/dist/image-editor/content-aware-fill-session.d.cts

@@ -0,0 +1,109 @@
+/**
+ * The Content-Aware Fill workspace without a UI, shared by the React and Svelte workspaces: the
+ * sampling area (where the fill may copy from) as a paintable mask over a window around the
+ * selection, its presets (Auto, Rectangular, Custom), a live preview of the fill, and OK, which
+ * applies it as one undo step through `contentAwareFillAsync` (the same fill the
+ * `content_aware_fill` tool makes, with a sampling area).
+ */
+import type { ImageEditorController } from './controller.cjs';
+import type { CropBox, ImagePoint } from './types.cjs';
+import { type SelectionMask } from './selection/mask.cjs';
+export type ContentAwareFillSampling = 'auto' | 'rectangular' | 'custom';
+export type ContentAwareFillTool = 'sampling-brush' | 'hand' | 'zoom';
+export declare const CONTENT_AWARE_FILL_TOOLS: readonly {
+    id: ContentAwareFillTool;
+    label: string;
+    key: string;
+}[];
+export declare const CONTENT_AWARE_FILL_SAMPLING: readonly {
+    id: ContentAwareFillSampling;
+    label: string;
+}[];
+export interface ContentAwareFillSettings {
+    sampling: ContentAwareFillSampling;
+    /** Show the sampling area as a green overlay on the source view. */
+    showSampling: boolean;
+    /** The overlay's opacity, 0..1. */
+    opacity: number;
+    tool: ContentAwareFillTool;
+    /** Sampling Brush diameter in natural pixels. */
+    brushSize: number;
+    /** The Sampling Brush adds to the area or takes away from it. */
+    brushMode: 'add' | 'subtract';
+    /** The fill's random seed; another gives another fill to choose from. */
+    seed: number;
+    output: 'current' | 'new-layer';
+    /** Update the preview as the area changes (otherwise with Preview). */
+    livePreview: boolean;
+}
+export declare const DEFAULT_CONTENT_AWARE_FILL_SETTINGS: ContentAwareFillSettings;
+export declare class ContentAwareFillSession {
+    readonly controller: ImageEditorController;
+    private settingsValue;
+    private plan;
+    /** The source view's window (document pixels): the selection with room around it to sample. */
+    private win;
+    private before;
+    private hole;
+    /** 1 where the fill may copy from, per window pixel. */
+    private area;
+    private after;
+    private lastPoint;
+    private readonly listeners;
+    private dirty;
+    /** Why the workspace can't fill (nothing selected, not a pixel layer), for the UI. */
+    error: string | null;
+    computing: boolean;
+    revision: number;
+    constructor(controller: ImageEditorController);
+    get settings(): ContentAwareFillSettings;
+    /** The source view's window in document pixels (`null` until opened). */
+    get window(): CropBox | null;
+    subscribe(listener: () => void): () => void;
+    private emit;
+    /**
+     * Reads the layer around the selection and makes the first preview. The window holds the
+     * selection and room around it to sample from (its larger side, at least 64 px, each way).
+     */
+    open(): Promise<boolean>;
+    /** Sets the area to a preset: Auto (a band around the selection), Rectangular (the whole window). */
+    private applySampling;
+    /** Changes settings; a sampling preset replaces the area, and the preview follows when live. */
+    update(changes: Partial<ContentAwareFillSettings>): void;
+    /** The sampling area as a selection of the whole image (what OK samples from). */
+    samplingMask(): SelectionMask | null;
+    /** Whether (x, y) in document pixels is in the sampling area. */
+    samplesAt(x: number, y: number): boolean;
+    /** Paints the sampling area with the brush along a stroke segment (document pixels). */
+    private paint;
+    /** Pointer down with the Sampling Brush (Alt flips add and subtract). Returns false for other tools. */
+    begin(point: ImagePoint, modifiers?: {
+        altKey?: boolean;
+    }): boolean;
+    private strokeAdds;
+    move(point: ImagePoint): void;
+    /** Pointer up: the preview follows the new area when live. */
+    end(): void;
+    /** Recomputes the preview: one at a time, the newest area following when one is running. */
+    refresh(): Promise<void>;
+    /** Resolves once no preview is being computed. */
+    idle(): Promise<void>;
+    /** The source view: the layer's pixels, the selection tinted red, the sampling area green. RGBA at the window's size. */
+    renderSource(): Uint8ClampedArray;
+    /** The preview: the window with the fill in place (the source until the first preview). */
+    renderPreview(): Uint8ClampedArray;
+    /** Clears painting and goes back to Auto. */
+    reset(): void;
+    /**
+     * Keys: B, H, Z for the tools, [ and ] for the brush size. Returns true when the key was used.
+     */
+    handleKey(key: string): boolean;
+    /** OK: fills with this sampling area, seed and output as one undo step. */
+    commit(options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        layerId: string;
+        bounds: CropBox;
+        output: 'current' | 'new-layer';
+    }>;
+}

package/dist/image-editor/content-aware-fill-session.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The Content-Aware Fill workspace without a UI, shared by the React and Svelte workspaces: the
+ * sampling area (where the fill may copy from) as a paintable mask over a window around the
+ * selection, its presets (Auto, Rectangular, Custom), a live preview of the fill, and OK, which
+ * applies it as one undo step through `contentAwareFillAsync` (the same fill the
+ * `content_aware_fill` tool makes, with a sampling area).
+ */
+import type { ImageEditorController } from './controller.js';
+import type { CropBox, ImagePoint } from './types.js';
+import { type SelectionMask } from './selection/mask.js';
+export type ContentAwareFillSampling = 'auto' | 'rectangular' | 'custom';
+export type ContentAwareFillTool = 'sampling-brush' | 'hand' | 'zoom';
+export declare const CONTENT_AWARE_FILL_TOOLS: readonly {
+    id: ContentAwareFillTool;
+    label: string;
+    key: string;
+}[];
+export declare const CONTENT_AWARE_FILL_SAMPLING: readonly {
+    id: ContentAwareFillSampling;
+    label: string;
+}[];
+export interface ContentAwareFillSettings {
+    sampling: ContentAwareFillSampling;
+    /** Show the sampling area as a green overlay on the source view. */
+    showSampling: boolean;
+    /** The overlay's opacity, 0..1. */
+    opacity: number;
+    tool: ContentAwareFillTool;
+    /** Sampling Brush diameter in natural pixels. */
+    brushSize: number;
+    /** The Sampling Brush adds to the area or takes away from it. */
+    brushMode: 'add' | 'subtract';
+    /** The fill's random seed; another gives another fill to choose from. */
+    seed: number;
+    output: 'current' | 'new-layer';
+    /** Update the preview as the area changes (otherwise with Preview). */
+    livePreview: boolean;
+}
+export declare const DEFAULT_CONTENT_AWARE_FILL_SETTINGS: ContentAwareFillSettings;
+export declare class ContentAwareFillSession {
+    readonly controller: ImageEditorController;
+    private settingsValue;
+    private plan;
+    /** The source view's window (document pixels): the selection with room around it to sample. */
+    private win;
+    private before;
+    private hole;
+    /** 1 where the fill may copy from, per window pixel. */
+    private area;
+    private after;
+    private lastPoint;
+    private readonly listeners;
+    private dirty;
+    /** Why the workspace can't fill (nothing selected, not a pixel layer), for the UI. */
+    error: string | null;
+    computing: boolean;
+    revision: number;
+    constructor(controller: ImageEditorController);
+    get settings(): ContentAwareFillSettings;
+    /** The source view's window in document pixels (`null` until opened). */
+    get window(): CropBox | null;
+    subscribe(listener: () => void): () => void;
+    private emit;
+    /**
+     * Reads the layer around the selection and makes the first preview. The window holds the
+     * selection and room around it to sample from (its larger side, at least 64 px, each way).
+     */
+    open(): Promise<boolean>;
+    /** Sets the area to a preset: Auto (a band around the selection), Rectangular (the whole window). */
+    private applySampling;
+    /** Changes settings; a sampling preset replaces the area, and the preview follows when live. */
+    update(changes: Partial<ContentAwareFillSettings>): void;
+    /** The sampling area as a selection of the whole image (what OK samples from). */
+    samplingMask(): SelectionMask | null;
+    /** Whether (x, y) in document pixels is in the sampling area. */
+    samplesAt(x: number, y: number): boolean;
+    /** Paints the sampling area with the brush along a stroke segment (document pixels). */
+    private paint;
+    /** Pointer down with the Sampling Brush (Alt flips add and subtract). Returns false for other tools. */
+    begin(point: ImagePoint, modifiers?: {
+        altKey?: boolean;
+    }): boolean;
+    private strokeAdds;
+    move(point: ImagePoint): void;
+    /** Pointer up: the preview follows the new area when live. */
+    end(): void;
+    /** Recomputes the preview: one at a time, the newest area following when one is running. */
+    refresh(): Promise<void>;
+    /** Resolves once no preview is being computed. */
+    idle(): Promise<void>;
+    /** The source view: the layer's pixels, the selection tinted red, the sampling area green. RGBA at the window's size. */
+    renderSource(): Uint8ClampedArray;
+    /** The preview: the window with the fill in place (the source until the first preview). */
+    renderPreview(): Uint8ClampedArray;
+    /** Clears painting and goes back to Auto. */
+    reset(): void;
+    /**
+     * Keys: B, H, Z for the tools, [ and ] for the brush size. Returns true when the key was used.
+     */
+    handleKey(key: string): boolean;
+    /** OK: fills with this sampling area, seed and output as one undo step. */
+    commit(options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        layerId: string;
+        bounds: CropBox;
+        output: 'current' | 'new-layer';
+    }>;
+}