@pixerate/editor 0.258.0 → 0.260.0

package/dist/{chunk-SSFMWJDK.js → chunk-D4TE5JNW.js}

@@ -1,16 +1,18 @@
 import {
   boxMean,
+  combineSelections,
   createSelectionMask,
   decodeSelectionRle,
   decontaminateColors,
+  ellipsePoints,
   encodeSelectionRle,
   guidedFilterColor,
   hashMaskContent,
-  resizeSelection
-} from "./chunk-ZNA3IQZF.js";
-import {
-  parseCssColor
-} from "./chunk-3CI7FRMK.js";
+  normalizeRect,
+  resizeSelection,
+  selectionArea,
+  serializeMask
+} from "./chunk-WJ4WQJCC.js";
 import {
   DEFAULT_GLOBAL_LIGHT,
   DeepCompositor,
@@ -48,7 +50,7 @@ import {
   validateEffectGradient,
   validateLayerEffects,
   warpSurface
-} from "./chunk-3PPJRMIG.js";
+} from "./chunk-3O47TPGX.js";
 import {
   affineFromHomography,
   applyHomography,
@@ -106,7 +108,7 @@ import {
   transformTextRect,
   translateMatrix,
   warpPresetMesh
-} from "./chunk-YQ4PQTBB.js";
+} from "./chunk-6NZL24W4.js";
 import {
   bezierPathBounds,
   outlineStroke,
@@ -115,6 +117,12 @@ import {
   strokeOutlineRings,
   transformBezierPath
 } from "./chunk-WEIK3UYB.js";
+import {
+  parseCssColor
+} from "./chunk-3CI7FRMK.js";
+import {
+  MAX_BRUSH_SIZE
+} from "./chunk-GCVFEPJG.js";
 import {
   base64ToBytes,
   bytesToBase64,
@@ -4547,6 +4555,312 @@ function isLegacyShape(stack) {
   return true;
 }
 
+// src/image-editor/selection/magnetic.ts
+var BLOCK = 64;
+var W_ZERO = 0.3;
+var W_GRADIENT = 0.4;
+var W_DIRECTION = 0.3;
+var EdgeMap = class {
+  width;
+  height;
+  contrast;
+  luma;
+  blocks = /* @__PURE__ */ new Map();
+  constructor(pixels, options = {}) {
+    const { width, height, data } = pixels;
+    if (!(width >= 1 && height >= 1) || data.length < width * height * 4) throw new Error("Invalid pixel buffer for edge detection.");
+    this.width = width;
+    this.height = height;
+    this.contrast = Math.min(1, Math.max(0, options.contrast ?? 0.1));
+    const luma = new Uint8Array(width * height);
+    for (let i = 0, p = 0; i < luma.length; i++, p += 4) {
+      const a = data[p + 3] / 255;
+      const y = 0.299 * data[p] + 0.587 * data[p + 1] + 0.114 * data[p + 2];
+      luma[i] = Math.round(y * a + 255 * (1 - a));
+    }
+    this.luma = luma;
+  }
+  /** Edge strength at (x, y) in whole pixels, 0..1 (0 outside the image or below the contrast). */
+  strength(x, y) {
+    if (x < 0 || y < 0 || x >= this.width || y >= this.height) return 0;
+    const b = this.block(x, y);
+    return b.strength[y % BLOCK * BLOCK + x % BLOCK];
+  }
+  block(x, y) {
+    const bx = Math.floor(x / BLOCK);
+    const by = Math.floor(y / BLOCK);
+    const key = by * 65536 + bx;
+    let b = this.blocks.get(key);
+    if (!b) {
+      b = this.computeBlock(bx * BLOCK, by * BLOCK);
+      this.blocks.set(key, b);
+    }
+    return b;
+  }
+  computeBlock(x0, y0) {
+    const { width: W, height: H, luma } = this;
+    const M = 2;
+    const S = BLOCK + 2 * M;
+    const smooth = new Float32Array(S * S);
+    const at = (x, y) => luma[Math.min(H - 1, Math.max(0, y)) * W + Math.min(W - 1, Math.max(0, x))];
+    for (let j = 0; j < S; j++) {
+      const y = y0 - M + j;
+      for (let i = 0; i < S; i++) {
+        const x = x0 - M + i;
+        const v = at(x - 1, y - 1) + 2 * at(x, y - 1) + at(x + 1, y - 1) + 2 * at(x - 1, y) + 4 * at(x, y) + 2 * at(x + 1, y) + at(x - 1, y + 1) + 2 * at(x, y + 1) + at(x + 1, y + 1);
+        smooth[j * S + i] = v / (16 * 255);
+      }
+    }
+    const lap = new Float32Array(S * S);
+    for (let j = 1; j < S - 1; j++) {
+      for (let i = 1; i < S - 1; i++) {
+        const k = j * S + i;
+        lap[k] = smooth[k - 1] + smooth[k + 1] + smooth[k - S] + smooth[k + S] - 4 * smooth[k];
+      }
+    }
+    const n = BLOCK * BLOCK;
+    const strength = new Float32Array(n);
+    const dirX = new Float32Array(n);
+    const dirY = new Float32Array(n);
+    const zero = new Uint8Array(n);
+    const c = this.contrast;
+    for (let j = 0; j < BLOCK; j++) {
+      if (y0 + j >= H) break;
+      for (let i = 0; i < BLOCK; i++) {
+        if (x0 + i >= W) break;
+        const k = (j + M) * S + (i + M);
+        const gx = (smooth[k + 1] - smooth[k - 1]) / 2;
+        const gy = (smooth[k + S] - smooth[k - S]) / 2;
+        const g = Math.hypot(gx, gy);
+        const e = Math.min(1, 2 * g);
+        if (e < c || g === 0) continue;
+        const o = j * BLOCK + i;
+        strength[o] = e;
+        dirX[o] = gy / g;
+        dirY[o] = -gx / g;
+        const l = lap[k];
+        for (const d of [1, -1, S, -S]) {
+          const m = lap[k + d];
+          if (l > 0 && m < 0 || l < 0 && m > 0 || l === 0) {
+            if (Math.abs(l) <= Math.abs(m)) {
+              zero[o] = 1;
+              break;
+            }
+          }
+        }
+      }
+    }
+    return { strength, dirX, dirY, zero };
+  }
+  /** Features of the pixel at (x, y), which must be inside the image. */
+  features(x, y) {
+    const b = this.block(x, y);
+    const o = y % BLOCK * BLOCK + x % BLOCK;
+    return { strength: b.strength[o], dirX: b.dirX[o], dirY: b.dirY[o], zero: b.zero[o] };
+  }
+};
+var clampPixel = (v, max) => Math.min(max - 1, Math.max(0, Math.floor(v)));
+function snapToEdge(map, point2, width = 10) {
+  const cx = clampPixel(point2.x, map.width);
+  const cy = clampPixel(point2.y, map.height);
+  const r = Math.max(0, Math.round(width));
+  let best = 0;
+  let bestD = Infinity;
+  let bx = cx;
+  let by = cy;
+  for (let y = Math.max(0, cy - r); y <= Math.min(map.height - 1, cy + r); y++) {
+    for (let x = Math.max(0, cx - r); x <= Math.min(map.width - 1, cx + r); x++) {
+      const d = (x - cx) ** 2 + (y - cy) ** 2;
+      if (d > r * r) continue;
+      const s = map.strength(x, y);
+      if (s > best + 0.02 || s > 0 && Math.abs(s - best) <= 0.02 && d < bestD) {
+        if (s > best) best = s;
+        bestD = d;
+        bx = x;
+        by = y;
+      }
+    }
+  }
+  return best > 0 ? { x: bx + 0.5, y: by + 0.5 } : point2;
+}
+var Heap = class {
+  ids = new Int32Array(256);
+  keys = new Float64Array(256);
+  size = 0;
+  push(id, key) {
+    if (this.size === this.ids.length) {
+      const ids = new Int32Array(this.size * 2);
+      ids.set(this.ids);
+      const keys = new Float64Array(this.size * 2);
+      keys.set(this.keys);
+      this.ids = ids;
+      this.keys = keys;
+    }
+    let i = this.size++;
+    while (i > 0) {
+      const p = i - 1 >> 1;
+      if (this.keys[p] <= key) break;
+      this.ids[i] = this.ids[p];
+      this.keys[i] = this.keys[p];
+      i = p;
+    }
+    this.ids[i] = id;
+    this.keys[i] = key;
+  }
+  /** Removes the cheapest entry; read it from `topId` / `topKey` first. */
+  pop() {
+    const n = --this.size;
+    const id = this.ids[n];
+    const key = this.keys[n];
+    let i = 0;
+    for (; ; ) {
+      let c = 2 * i + 1;
+      if (c >= n) break;
+      if (c + 1 < n && this.keys[c + 1] < this.keys[c]) c++;
+      if (this.keys[c] >= key) break;
+      this.ids[i] = this.ids[c];
+      this.keys[i] = this.keys[c];
+      i = c;
+    }
+    this.ids[i] = id;
+    this.keys[i] = key;
+  }
+  get topId() {
+    return this.ids[0];
+  }
+  get topKey() {
+    return this.keys[0];
+  }
+};
+var NEIGHBOURS = [
+  [1, 0],
+  [-1, 0],
+  [0, 1],
+  [0, -1],
+  [1, 1],
+  [1, -1],
+  [-1, 1],
+  [-1, -1]
+];
+function liveWire(map, from, to, band) {
+  const ax = clampPixel(from.x, map.width);
+  const ay = clampPixel(from.y, map.height);
+  const bx = clampPixel(to.x, map.width);
+  const by = clampPixel(to.y, map.height);
+  if (ax === bx && ay === by) return [{ x: ax + 0.5, y: ay + 0.5 }];
+  const len = Math.hypot(bx - ax, by - ay);
+  const half = Math.max(2, band ?? Math.max(16, len / 4));
+  const rx0 = Math.max(0, Math.floor(Math.min(ax, bx) - half));
+  const ry0 = Math.max(0, Math.floor(Math.min(ay, by) - half));
+  const rx1 = Math.min(map.width - 1, Math.ceil(Math.max(ax, bx) + half));
+  const ry1 = Math.min(map.height - 1, Math.ceil(Math.max(ay, by) + half));
+  const w = rx1 - rx0 + 1;
+  const h = ry1 - ry0 + 1;
+  const n = w * h;
+  const strength = new Float32Array(n);
+  const dirX = new Float32Array(n);
+  const dirY = new Float32Array(n);
+  const zero = new Uint8Array(n);
+  const inside = new Uint8Array(n);
+  let maxStrength = 0;
+  const ux = (bx - ax) / len;
+  const uy = (by - ay) / len;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const px2 = rx0 + x - ax;
+      const py = ry0 + y - ay;
+      const t = Math.min(len, Math.max(0, px2 * ux + py * uy));
+      if (Math.hypot(px2 - t * ux, py - t * uy) > half) continue;
+      const i = y * w + x;
+      inside[i] = 1;
+      const f = map.features(rx0 + x, ry0 + y);
+      strength[i] = f.strength;
+      dirX[i] = f.dirX;
+      dirY[i] = f.dirY;
+      zero[i] = f.zero;
+      if (f.strength > maxStrength) maxStrength = f.strength;
+    }
+  }
+  const scale = maxStrength > 0 ? 1 / maxStrength : 0;
+  const dist = new Float64Array(n).fill(Infinity);
+  const prev = new Int32Array(n).fill(-1);
+  const done = new Uint8Array(n);
+  const start = (ay - ry0) * w + (ax - rx0);
+  const goal = (by - ry0) * w + (bx - rx0);
+  dist[start] = 0;
+  const heap = new Heap();
+  heap.push(start, 0);
+  while (heap.size) {
+    const p = heap.topId;
+    const d = heap.topKey;
+    heap.pop();
+    if (done[p] || d > dist[p]) continue;
+    done[p] = 1;
+    if (p === goal) break;
+    const x = p % w;
+    const y = (p - x) / w;
+    for (const [dx, dy] of NEIGHBOURS) {
+      const qx = x + dx;
+      const qy = y + dy;
+      if (qx < 0 || qy < 0 || qx >= w || qy >= h) continue;
+      const q2 = qy * w + qx;
+      if (!inside[q2] || done[q2]) continue;
+      const step = dx && dy ? Math.SQRT2 : 1;
+      const lx = dx / step;
+      const ly = dy / step;
+      const dp = Math.min(1, Math.abs(dirX[p] * lx + dirY[p] * ly));
+      const dq = Math.min(1, Math.abs(dirX[q2] * lx + dirY[q2] * ly));
+      const fD = (Math.acos(dp) + Math.acos(dq)) / Math.PI;
+      const fG = 1 - strength[q2] * scale;
+      const fZ = 1 - zero[q2];
+      const cost = (W_ZERO * fZ + W_GRADIENT * fG + W_DIRECTION * fD + 0.01) * step;
+      const nd = d + cost;
+      if (nd < dist[q2]) {
+        dist[q2] = nd;
+        prev[q2] = p;
+        heap.push(q2, nd);
+      }
+    }
+  }
+  if (prev[goal] < 0) return [{ x: ax + 0.5, y: ay + 0.5 }, { x: bx + 0.5, y: by + 0.5 }];
+  const path = [];
+  for (let p = goal; p >= 0; p = prev[p]) {
+    const x = p % w;
+    path.push({ x: rx0 + x + 0.5, y: ry0 + (p - x) / w + 0.5 });
+  }
+  return path.reverse();
+}
+function simplifyPixelPath(points) {
+  if (points.length < 3) return points.slice();
+  const out = [points[0]];
+  for (let i = 1; i < points.length - 1; i++) {
+    const a = out[out.length - 1];
+    const b = points[i];
+    const c = points[i + 1];
+    const cross = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+    if (Math.abs(cross) > 1e-9) out.push(b);
+  }
+  out.push(points[points.length - 1]);
+  return out;
+}
+function snapPolygonToEdges(pixels, points, options = {}) {
+  const map = pixels instanceof EdgeMap ? pixels : new EdgeMap(pixels, options);
+  const width = options.width ?? 10;
+  const snapped = points.map((p) => snapToEdge(map, p, width));
+  const out = [];
+  for (let i = 0; i < snapped.length; i++) {
+    const a = snapped[i];
+    const b = snapped[(i + 1) % snapped.length];
+    const seg = liveWire(map, a, b, Math.max(2 * width, 16, Math.hypot(b.x - a.x, b.y - a.y) / 4));
+    out.push(...seg.slice(0, -1));
+  }
+  return simplifyPixelPath(out);
+}
+function magneticAnchorSpacing(frequency = 57) {
+  const f = Math.min(100, Math.max(0, frequency));
+  return 8 + (100 - f);
+}
+
 // src/image-editor/transform.ts
 var FREE_TRANSFORM_MODES = ["scale", "rotate", "skew", "distort", "perspective", "warp"];
 var TRANSFORM_ANCHORS = ["top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right"];
@@ -5473,7 +5787,7 @@ function baseFields(layer, ctx) {
     blend: layer.blend
   };
   if (layer.clipped) out.clipped = true;
-  if (layer.mask) out.mask = serializeMask(layer.mask, `${layer.id}-mask`, ctx);
+  if (layer.mask) out.mask = serializeMask2(layer.mask, `${layer.id}-mask`, ctx);
   if (layer.vectorMask) out.vectorMask = serializeVectorMask(layer.vectorMask);
   if (layer.locks && Object.values(layer.locks).some(Boolean)) out.locks = { ...layer.locks };
   if (layer.effects) out.effects = serializeEffects(layer.effects);
@@ -5558,7 +5872,7 @@ function readVectorMask(r) {
   }
   return vm;
 }
-function serializeMask(mask, hint, ctx) {
+function serializeMask2(mask, hint, ctx) {
   const out = { defaultValue: mask.defaultValue };
   if (!mask.source) {
     const enc = encodeSurface(mask.surface);
@@ -5757,7 +6071,7 @@ function serializeSmartFilters(stack, layerId, ctx) {
     enabled: stack.enabled,
     filters: stack.filters.map((f) => f.kind === "psd" ? { ...f, data: bytesToBase64(f.data) } : JSON.parse(JSON.stringify(f)))
   };
-  if (stack.mask) out.mask = serializeMask(stack.mask, `${layerId}-filter-mask`, ctx);
+  if (stack.mask) out.mask = serializeMask2(stack.mask, `${layerId}-filter-mask`, ctx);
   return out;
 }
 function serializeSmartObject(layer, base, ctx) {
@@ -6105,7 +6419,7 @@ function readSmartFilters(raw, ctx, what) {
   const r = raw;
   const filters = [];
   const list2 = Array.isArray(r.filters) ? r.filters : [];
-  const plain = readFilters(list2.filter((f) => f && f.kind !== "psd")) ?? [];
+  const plain2 = readFilters(list2.filter((f) => f && f.kind !== "psd")) ?? [];
   let k = 0;
   for (const f of list2) {
     if (!f || typeof f !== "object") continue;
@@ -6118,7 +6432,7 @@ function readSmartFilters(raw, ctx, what) {
         ctx.problems.push(`${what}: a Photoshop smart filter could not be read`);
       }
     } else if (f.kind === "develop" || f.kind === "blur") {
-      const base = plain[k++];
+      const base = plain2[k++];
       if (base) filters.push({ ...base, blend, opacity });
     } else if (f.kind === "effect") {
       const ref = readEffectRef(f);
@@ -11332,12 +11646,12 @@ function prepareNestedLayers(layers) {
         const b = l.surface.bounds;
         if (b) {
           const r = { x: b.x + l.offset.x - 64, y: b.y + l.offset.y - 64, width: b.width + 128, height: b.height + 128 };
-          const plain = { ...l, visible: true, opacity: 1, blend: "normal" };
-          delete plain.mask;
-          delete plain.clipped;
-          delete plain.effects;
-          delete plain.fillOpacity;
-          const data = new LayerCompositor().composite([plain], r, { width: r.x + r.width, height: r.y + r.height });
+          const plain2 = { ...l, visible: true, opacity: 1, blend: "normal" };
+          delete plain2.mask;
+          delete plain2.clipped;
+          delete plain2.effects;
+          delete plain2.fillOpacity;
+          const data = new LayerCompositor().composite([plain2], r, { width: r.x + r.width, height: r.y + r.height });
           p.surface = surfaceFromPixels({ width: r.width, height: r.height, data }, 4, r.x - l.offset.x, r.y - l.offset.y);
         }
       }
@@ -11728,6 +12042,95 @@ function exportPsd(input) {
   return { bytes, psb, records: records.length, warnings };
 }
 
+// src/image-editor/selection/tool-options.ts
+var SELECTION_TOOLS = [
+  { id: "wand", label: "Magic Wand" },
+  { id: "rect", label: "Rectangle" },
+  { id: "ellipse", label: "Ellipse" },
+  { id: "row", label: "Single Row" },
+  { id: "column", label: "Single Column" },
+  { id: "lasso", label: "Lasso" },
+  { id: "polygon", label: "Polygonal Lasso" },
+  { id: "magnetic", label: "Magnetic Lasso" },
+  { id: "quick", label: "Quick Selection" },
+  { id: "object", label: "Object Selection" },
+  { id: "range", label: "Color Range" },
+  { id: "type", label: "Type Mask" },
+  { id: "type-vertical", label: "Vertical Type Mask" }
+];
+var COLOR_RANGE_PRESET_LABELS = {
+  reds: "Reds",
+  yellows: "Yellows",
+  greens: "Greens",
+  cyans: "Cyans",
+  blues: "Blues",
+  magentas: "Magentas",
+  highlights: "Highlights",
+  midtones: "Midtones",
+  shadows: "Shadows",
+  skinTones: "Skin Tones"
+};
+var SELECTION_MODE_LABELS = {
+  replace: "New",
+  add: "Add",
+  subtract: "Subtract",
+  intersect: "Intersect"
+};
+var DEFAULT_SELECTION_TOOL_OPTIONS = {
+  tool: "wand",
+  mode: "replace",
+  tolerance: 32,
+  contiguous: true,
+  antiAlias: true,
+  sampleMerged: false,
+  distance: "rgb",
+  feather: 0,
+  fuzziness: 40,
+  localized: 0,
+  rangeInvert: false,
+  magneticWidth: 10,
+  magneticContrast: 10,
+  magneticFrequency: 57,
+  quickSize: 30,
+  quickSampleAll: true,
+  quickEnhance: false,
+  objectSampleAll: true,
+  objectEnhance: false,
+  focusRange: 50,
+  focusNoise: 0,
+  focusSoftness: 4,
+  typeText: "Type",
+  typeSize: 72,
+  typeFamily: "sans-serif"
+};
+function selectionModeFromModifiers(modifiers, fallback) {
+  if (modifiers.shiftKey && modifiers.altKey) return "intersect";
+  if (modifiers.shiftKey) return "add";
+  if (modifiers.altKey) return "subtract";
+  return fallback;
+}
+var REFINE_EDGE_CONTROLS = [
+  { id: "radius", label: "Radius", min: 0, max: 64, step: 1, unit: "px" },
+  { id: "smooth", label: "Smooth", min: 0, max: 100, step: 1, unit: "" },
+  { id: "feather", label: "Feather", min: 0, max: 50, step: 0.5, unit: "px" },
+  { id: "contrast", label: "Contrast", min: 0, max: 100, step: 1, unit: "%" },
+  { id: "shiftEdge", label: "Shift Edge", min: -100, max: 100, step: 1, unit: "%" }
+];
+var REFINE_OUTPUTS = [
+  { id: "selection", label: "Selection" },
+  { id: "layer-mask", label: "Layer Mask" },
+  { id: "new-layer", label: "New Layer" },
+  { id: "new-layer-with-mask", label: "New Layer with Layer Mask" },
+  { id: "new-document", label: "New Document", needsDocuments: true },
+  { id: "new-document-with-mask", label: "New Document with Layer Mask", needsDocuments: true }
+];
+function describeSelection(mask) {
+  if (!mask || !mask.bounds) return "No selection";
+  const pct2 = selectionArea(mask) / (mask.width * mask.height) * 100;
+  const shown = pct2 >= 10 ? Math.round(pct2) : Math.round(pct2 * 10) / 10;
+  return `${mask.bounds.width} \xD7 ${mask.bounds.height} px selected (${shown}% of the image)`;
+}
+
 // src/image-editor/effect-tools.ts
 var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
@@ -12077,6 +12480,740 @@ function createLayerEffectTools(host, options) {
   return host.setGlobalLight ? [list2, add, update, remove, setEnabled, light] : [list2, add, update, remove, setEnabled];
 }
 
+// src/image-editor/selection/gesture.ts
+function snapTo45(from, point2) {
+  const dx = point2.x - from.x;
+  const dy = point2.y - from.y;
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return point2;
+  const a = Math.round(Math.atan2(dy, dx) / (Math.PI / 4)) * (Math.PI / 4);
+  return { x: from.x + Math.cos(a) * len, y: from.y + Math.sin(a) * len };
+}
+var SelectionGesture = class {
+  constructor(controller, getOptions) {
+    this.controller = controller;
+    this.getOptions = getOptions;
+  }
+  controller;
+  getOptions;
+  start = null;
+  points = [];
+  current = null;
+  modifiers = {};
+  /** Polygonal lasso corners while one is being drawn. */
+  polygon = null;
+  pressedAt = null;
+  freehand = false;
+  magnetic = null;
+  /** A click this close to the first corner (natural pixels) closes a polygonal lasso. */
+  closeRadius = 8;
+  /** The last error (e.g. pixels unavailable for the wand), for the UI to show. */
+  error = null;
+  pending = Promise.resolve();
+  /** Quick Selection while dragging: the selection before the stroke, how the stroke combines, the pixels. */
+  quick = null;
+  livePreviews = Promise.resolve();
+  get active() {
+    return this.start !== null || this.polygon !== null || this.magnetic !== null;
+  }
+  /** Resolves once a Quick Selection stroke or an Object Selection has been applied. */
+  get settled() {
+    return this.pending;
+  }
+  /** Resolves once no live Quick Selection preview is being computed. */
+  get previewed() {
+    return this.livePreviews;
+  }
+  /** Grows the Quick Selection preview to the stroke so far: one at a time, the newest points following. */
+  growPreview() {
+    const q2 = this.quick;
+    if (!q2) return;
+    if (q2.running) {
+      q2.dirty = true;
+      return;
+    }
+    q2.running = true;
+    this.livePreviews = (async () => {
+      do {
+        q2.dirty = false;
+        const stroke = this.points.slice();
+        const options = this.getOptions();
+        try {
+          const pixels = await q2.pixels;
+          if (!pixels || this.quick !== q2) break;
+          const { mask } = await this.controller.runSelectionJob(
+            {
+              op: "quick",
+              stroke,
+              size: options.quickSize ?? 30,
+              grow: q2.mode === "add",
+              enhanceEdge: options.quickEnhance ?? false,
+              selection: q2.mode === "add" && q2.base?.bounds ? serializeMask(q2.base) : null
+            },
+            pixels
+          );
+          if (this.quick === q2) this.controller.setSelectionPreview(combineSelections(q2.base, mask, q2.mode));
+        } catch {
+          break;
+        }
+      } while (q2.dirty && this.quick === q2);
+      q2.running = false;
+    })();
+  }
+  /** The anchors of a Magnetic Lasso being drawn (empty otherwise). */
+  get magneticAnchors() {
+    const m = this.magnetic;
+    return m ? m.anchors.map((i) => m.fixed[i]) : [];
+  }
+  /** The outline of the shape being drawn, or `null`. */
+  get draftPath() {
+    if (this.magnetic) return [...this.magnetic.fixed, ...this.magnetic.live.slice(1)];
+    if (this.polygon) return this.current ? [...this.polygon, this.current] : this.polygon.slice();
+    if (!this.start || !this.current) return null;
+    const { tool } = this.getOptions();
+    if (tool === "quick") return null;
+    if (tool === "lasso") return this.points.length > 1 ? this.points.slice() : null;
+    const rect = normalizeRect({
+      x: this.start.x,
+      y: this.start.y,
+      width: this.current.x - this.start.x,
+      height: this.current.y - this.start.y
+    });
+    if (rect.width < 1 && rect.height < 1) return null;
+    if (tool === "ellipse") return ellipsePoints(rect);
+    return [
+      { x: rect.x, y: rect.y },
+      { x: rect.x + rect.width, y: rect.y },
+      { x: rect.x + rect.width, y: rect.y + rect.height },
+      { x: rect.x, y: rect.y + rect.height }
+    ];
+  }
+  /** Pointer down. Resolves once a wand click has been applied. */
+  async begin(point2, modifiers = {}) {
+    const options = this.getOptions();
+    this.error = null;
+    if (this.polygon && options.tool !== "polygon" || this.magnetic && options.tool !== "magnetic") this.cancel();
+    if (options.tool === "magnetic") return this.magneticClick(point2, modifiers, options);
+    if (options.tool === "polygon") {
+      this.pressedAt = point2;
+      this.freehand = false;
+      if (!this.polygon) {
+        this.modifiers = modifiers;
+        this.polygon = [point2];
+        this.current = point2;
+        return;
+      }
+      const last = this.polygon[this.polygon.length - 1];
+      const p = modifiers.shiftKey ? snapTo45(last, point2) : point2;
+      const first = this.polygon[0];
+      if (this.polygon.length >= 3 && Math.hypot(p.x - first.x, p.y - first.y) <= this.closeRadius) {
+        this.close();
+        return;
+      }
+      if (Math.hypot(p.x - last.x, p.y - last.y) >= 0.5) this.polygon.push(p);
+      this.current = p;
+      if ((modifiers.detail ?? 1) >= 2) this.close();
+      return;
+    }
+    this.modifiers = modifiers;
+    if (options.tool === "row" || options.tool === "column") {
+      this.start = null;
+      try {
+        this.controller.selectLine(options.tool, options.tool === "row" ? point2.y : point2.x, {
+          mode: selectionModeFromModifiers(modifiers, options.mode),
+          feather: options.feather ?? 0
+        });
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+      return;
+    }
+    if (options.tool === "type" || options.tool === "type-vertical") {
+      this.start = null;
+      try {
+        this.controller.selectTextShape({
+          text: options.typeText || "Type",
+          x: point2.x,
+          y: point2.y,
+          orientation: options.tool === "type-vertical" ? "vertical" : "horizontal",
+          style: { fontSize: options.typeSize ?? 72, fontFamily: options.typeFamily || "sans-serif" },
+          mode: selectionModeFromModifiers(modifiers, options.mode),
+          feather: options.feather ?? 0,
+          antiAlias: options.antiAlias
+        });
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+      return;
+    }
+    if (options.tool === "wand" || options.tool === "range") {
+      this.start = null;
+      const common2 = {
+        sampleMerged: options.sampleMerged,
+        sample: options.sample,
+        feather: options.feather ?? 0,
+        mode: selectionModeFromModifiers(modifiers, options.mode)
+      };
+      try {
+        if (options.tool === "range") {
+          const pixels = await this.controller.getSamplePixels(common2);
+          if (!pixels) throw new Error("The image pixels are not available to sample.");
+          const x = Math.min(pixels.width - 1, Math.max(0, Math.floor(point2.x)));
+          const y = Math.min(pixels.height - 1, Math.max(0, Math.floor(point2.y)));
+          const p = (y * pixels.width + x) * 4;
+          const color = [pixels.data[p], pixels.data[p + 1], pixels.data[p + 2]];
+          await this.controller.selectColorRange([{ color, at: point2 }], {
+            ...common2,
+            fuzziness: options.fuzziness ?? 40,
+            localized: options.localized ? options.localized : void 0,
+            invert: options.rangeInvert ?? false
+          });
+          return;
+        }
+        await this.controller.magicWand(point2, {
+          ...common2,
+          tolerance: options.tolerance,
+          contiguous: options.contiguous,
+          antiAlias: options.antiAlias,
+          distance: options.distance
+        });
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+      return;
+    }
+    this.start = point2;
+    this.current = point2;
+    this.points = [point2];
+    if (options.tool === "quick") {
+      const picked = selectionModeFromModifiers(modifiers, options.mode);
+      const base = this.controller.getSelection();
+      this.quick = {
+        base,
+        mode: picked === "replace" && base ? "add" : picked,
+        pixels: this.controller.getSamplePixels({ sample: options.quickSampleAll === false ? "active-layer" : "composite" }).catch(() => null),
+        running: false,
+        dirty: false
+      };
+      this.growPreview();
+    }
+  }
+  /** Pointer move; returns true when the draft changed (re-render). */
+  move(point2, modifiers = {}) {
+    if (this.magnetic) {
+      this.current = point2;
+      this.followEdges(point2);
+      return true;
+    }
+    if (this.polygon) {
+      const last = this.polygon[this.polygon.length - 1];
+      if (this.pressedAt && (this.freehand || Math.hypot(point2.x - this.pressedAt.x, point2.y - this.pressedAt.y) >= 3)) {
+        this.freehand = true;
+        if (Math.hypot(point2.x - last.x, point2.y - last.y) >= 0.5) this.polygon.push(point2);
+        this.current = null;
+        return true;
+      }
+      this.current = modifiers.shiftKey ? snapTo45(last, point2) : point2;
+      return true;
+    }
+    if (!this.start) return false;
+    this.current = point2;
+    const drawn = this.getOptions().tool;
+    if (drawn === "lasso" || drawn === "quick") {
+      const last = this.points[this.points.length - 1];
+      if (Math.hypot(point2.x - last.x, point2.y - last.y) < 0.5) return false;
+      this.points.push(point2);
+      if (drawn === "quick") this.growPreview();
+    }
+    return true;
+  }
+  /** Pointer up: commits the shape. Returns true when the selection changed. */
+  end(point2, modifiers) {
+    if (this.magnetic) return false;
+    if (this.polygon) {
+      if (point2 && this.freehand) this.move(point2);
+      this.pressedAt = null;
+      this.freehand = false;
+      return false;
+    }
+    if (!this.start) return false;
+    if (point2) this.move(point2);
+    const options = this.getOptions();
+    const mode = selectionModeFromModifiers(modifiers ?? this.modifiers, options.mode);
+    if (options.tool === "object") {
+      const rect2 = normalizeRect({ x: this.start.x, y: this.start.y, width: this.current.x - this.start.x, height: this.current.y - this.start.y });
+      this.start = null;
+      this.current = null;
+      this.points = [];
+      const target = rect2.width >= 4 && rect2.height >= 4 ? { rect: rect2 } : { point: { x: rect2.x + rect2.width / 2, y: rect2.y + rect2.height / 2 } };
+      this.pending = this.controller.selectObject(target, { mode, sampleAllLayers: options.objectSampleAll ?? true, enhanceEdge: options.objectEnhance ?? false }).then(
+        () => void 0,
+        (err) => {
+          this.error = err instanceof Error ? err.message : String(err);
+        }
+      );
+      return false;
+    }
+    if (options.tool === "quick") {
+      const stroke = this.points;
+      this.start = null;
+      this.current = null;
+      this.points = [];
+      const strokeMode = this.quick?.mode ?? (mode === "replace" && this.controller.getSelection() ? "add" : mode);
+      this.quick = null;
+      this.pending = this.controller.quickSelect([stroke], {
+        size: options.quickSize ?? 30,
+        mode: strokeMode,
+        sampleAllLayers: options.quickSampleAll ?? true,
+        enhanceEdge: options.quickEnhance ?? false
+      }).then(
+        () => void 0,
+        (err) => {
+          this.error = err instanceof Error ? err.message : String(err);
+        }
+      ).finally(() => this.controller.setSelectionPreview(void 0));
+      return false;
+    }
+    const path = this.draftPath;
+    const rect = normalizeRect({
+      x: this.start.x,
+      y: this.start.y,
+      width: this.current.x - this.start.x,
+      height: this.current.y - this.start.y
+    });
+    this.start = null;
+    this.current = null;
+    this.points = [];
+    if (!path) return mode === "replace" ? this.controller.deselect() : false;
+    const opts = { mode, antiAlias: options.antiAlias, feather: options.feather ?? 0 };
+    if (options.tool === "lasso") return path.length >= 3 ? this.controller.selectPolygon(path, opts) : false;
+    return options.tool === "ellipse" ? this.controller.selectEllipse(rect, opts) : this.controller.selectRect(rect, opts);
+  }
+  /** Closes a polygonal lasso and selects it. Returns true when the selection changed. */
+  close() {
+    let polygon2 = this.polygon;
+    const m = this.magnetic;
+    if (m) {
+      const tail = m.edges && m.fixed.length > 1 ? liveWire(m.edges, m.fixed[m.fixed.length - 1], m.fixed[0], this.corridor(m.fixed[m.fixed.length - 1], m.fixed[0])) : [];
+      polygon2 = simplifyPixelPath([...m.fixed, ...tail.slice(1, -1)]);
+    }
+    if (!polygon2) return false;
+    const options = this.getOptions();
+    this.cancel();
+    if (polygon2.length < 3) return false;
+    return this.controller.selectPolygon(polygon2, {
+      mode: selectionModeFromModifiers(this.modifiers, options.mode),
+      antiAlias: options.antiAlias,
+      feather: options.feather ?? 0
+    });
+  }
+  /**
+   * Keys for a polygonal lasso being drawn: Enter closes it, Escape cancels, Backspace / Delete
+   * removes the last corner. Returns true when the key was used (the host prevents its default).
+   */
+  key(key) {
+    if (!this.polygon && !this.magnetic) return false;
+    if (key === "Enter") this.close();
+    else if (key === "Escape") this.cancel();
+    else if (key === "Backspace" || key === "Delete") {
+      const m = this.magnetic;
+      if (m) {
+        m.anchors.pop();
+        if (!m.anchors.length) this.cancel();
+        else {
+          m.fixed.length = m.anchors[m.anchors.length - 1] + 1;
+          m.live = [];
+          if (this.current) this.followEdges(this.current, false);
+        }
+      } else {
+        this.polygon.pop();
+        if (!this.polygon.length) this.cancel();
+      }
+    } else return false;
+    return true;
+  }
+  /** Corridor half-width for a live-wire between two points. */
+  corridor(a, b) {
+    return Math.max(2 * (this.getOptions().magneticWidth ?? 10), 16, Math.hypot(b.x - a.x, b.y - a.y) / 4);
+  }
+  async magneticClick(point2, modifiers, options) {
+    const m = this.magnetic;
+    if (!m) {
+      this.modifiers = modifiers;
+      const draft = { fixed: [point2], anchors: [0], live: [], edges: null };
+      this.magnetic = draft;
+      this.current = point2;
+      try {
+        const pixels = await this.controller.getSamplePixels({ sampleMerged: options.sampleMerged, sample: options.sample });
+        if (!pixels) throw new Error("The image pixels are not available to find edges in.");
+        if (this.magnetic !== draft) return;
+        draft.edges = new EdgeMap(pixels, { contrast: (options.magneticContrast ?? 10) / 100 });
+        draft.fixed = [snapToEdge(draft.edges, point2, options.magneticWidth ?? 10)];
+        if (this.current) this.followEdges(this.current);
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+        if (this.magnetic === draft) this.cancel();
+      }
+      return;
+    }
+    const first = m.fixed[0];
+    if (m.anchors.length >= 2 && Math.hypot(point2.x - first.x, point2.y - first.y) <= this.closeRadius) {
+      this.close();
+      return;
+    }
+    this.current = point2;
+    this.followEdges(point2);
+    if (m.live.length > 1) {
+      m.fixed.push(...m.live.slice(1));
+      m.anchors.push(m.fixed.length - 1);
+      m.live = [];
+    }
+    if ((modifiers.detail ?? 1) >= 2) this.close();
+  }
+  /** Updates the live path to `point`, fixing anchors along it every `frequency` px (with `place`). */
+  followEdges(point2, place = true) {
+    const m = this.magnetic;
+    const last = () => m.fixed[m.fixed.length - 1];
+    if (!m.edges) {
+      m.live = [last(), point2];
+      return;
+    }
+    const options = this.getOptions();
+    const target = snapToEdge(m.edges, point2, options.magneticWidth ?? 10);
+    const spacing = magneticAnchorSpacing(options.magneticFrequency ?? 57);
+    for (let guard2 = 0; guard2 < 64; guard2++) {
+      const path = liveWire(m.edges, last(), target, this.corridor(last(), target));
+      let length = 0;
+      let k = 0;
+      for (k = 1; k < path.length; k++) {
+        length += Math.hypot(path[k].x - path[k - 1].x, path[k].y - path[k - 1].y);
+        if (length >= spacing) break;
+      }
+      if (!place || k >= path.length - 1) {
+        m.live = path;
+        return;
+      }
+      m.fixed.push(...path.slice(1, k + 1));
+      m.anchors.push(m.fixed.length - 1);
+    }
+    m.live = [last(), target];
+  }
+  /** Abandons a drag (or a polygonal lasso) without changing the selection. */
+  cancel() {
+    if (this.quick) {
+      this.quick = null;
+      this.controller.setSelectionPreview(void 0);
+    }
+    this.start = null;
+    this.current = null;
+    this.points = [];
+    this.polygon = null;
+    this.magnetic = null;
+    this.pressedAt = null;
+    this.freehand = false;
+  }
+};
+function handleSelectionShortcut(controller, e, onError) {
+  if (!(e.ctrlKey || e.metaKey)) return false;
+  const key = e.key.toLowerCase();
+  const run = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      onError?.(err instanceof Error ? err.message : String(err));
+    }
+    return true;
+  };
+  if (key === "c") return run(() => controller.copyPixels({ merged: Boolean(e.shiftKey) }));
+  if (key === "x" && !e.shiftKey) return run(() => controller.cutPixels());
+  if (key === "v") return run(() => controller.pastePixels(e.shiftKey && e.altKey ? "into" : e.shiftKey ? "in-place" : "new-layer"));
+  if (key === "d") return run(() => e.shiftKey ? controller.reselect() : controller.deselect());
+  if (key === "i" && e.shiftKey) return run(() => controller.invertSelection());
+  return false;
+}
+function handleMaskViewKey(controller, e) {
+  if (e.ctrlKey || e.metaKey || e.altKey || e.key !== "\\") return false;
+  const id = controller.getState().activeLayerId;
+  const layer = id ? controller.getLayer(id) : null;
+  if (!layer?.mask || layer.mask.source) return false;
+  const view = controller.getMaskView();
+  controller.setMaskView(view?.layerId === layer.id && view.mode === "overlay" ? "off" : "overlay", layer.id);
+  return true;
+}
+function handleQuickMaskKey(controller, e) {
+  if (e.ctrlKey || e.metaKey || e.altKey || e.key.toLowerCase() !== "q") return false;
+  controller.setQuickMaskMode(!controller.quickMaskEditing);
+  return true;
+}
+
+// src/image-editor/layers/paint-ui.ts
+var plain = { kind: "plain" };
+var BRUSH_OPTION_CONTROLS = [
+  { id: "size", label: "Size", section: "layer", min: 1, max: 500, step: 1, default: 20, decimals: 0, track: plain, unit: "px" },
+  { id: "hardness", label: "Hardness", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain, displayScale: 100, unit: "%" },
+  { id: "opacity", label: "Opacity", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain, displayScale: 100, unit: "%" },
+  { id: "flow", label: "Flow", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain, displayScale: 100, unit: "%" },
+  { id: "smoothing", label: "Smoothing", section: "layer", min: 0, max: 0.95, step: 0.01, default: 0, decimals: 0, track: plain, displayScale: 100, unit: "%" }
+];
+var MIXER_OPTION_CONTROLS = [
+  { id: "wet", label: "Wet", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain, displayScale: 100, unit: "%" },
+  { id: "load", label: "Load", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain, displayScale: 100, unit: "%" },
+  { id: "mix", label: "Mix", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain, displayScale: 100, unit: "%" }
+];
+var MIXER_MIXING_OPTIONS = [
+  { id: "rgb", label: "RGB", title: "Mix colours as RGB averages" },
+  { id: "pigment", label: "Pigment", title: "Mix colours like paint: blue and yellow make green" }
+];
+var PAINT_TOOLS = [
+  { id: "move", label: "Move", shortcut: "V" },
+  { id: "brush", label: "Brush", shortcut: "B" },
+  { id: "mixer", label: "Mixer", shortcut: "Shift+B" },
+  { id: "eraser", label: "Eraser", shortcut: "E" },
+  { id: "clone", label: "Clone", shortcut: "S" },
+  { id: "heal", label: "Heal", shortcut: "Shift+J" },
+  { id: "spot-heal", label: "Spot Heal", shortcut: "J" },
+  { id: "smudge", label: "Smudge", shortcut: "" },
+  { id: "dodge", label: "Dodge", shortcut: "O" },
+  { id: "burn", label: "Burn", shortcut: "Shift+O" },
+  { id: "sponge", label: "Sponge", shortcut: "Shift+O" },
+  { id: "blur", label: "Blur", shortcut: "" },
+  { id: "sharpen", label: "Sharpen", shortcut: "" },
+  { id: "history", label: "History", shortcut: "Y" }
+];
+var isPaintTool = (tool) => PAINT_TOOLS.some((t) => t.id === tool);
+var isRetouchPaintTool = (tool) => tool === "clone" || tool === "heal" || tool === "spot-heal" || tool === "smudge" || tool === "dodge" || tool === "burn" || tool === "sponge" || tool === "blur" || tool === "sharpen" || tool === "history";
+var RETOUCH_OPTION_CONTROLS = [
+  { id: "exposure", label: "Exposure", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain, displayScale: 100, unit: "%", tools: ["dodge", "burn"] },
+  { id: "strength", label: "Strength", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain, displayScale: 100, unit: "%", tools: ["smudge", "blur", "sharpen"] },
+  { id: "historySteps", label: "Steps back", section: "layer", min: 0, max: 50, step: 1, default: 0, decimals: 0, track: plain, unit: "", tools: ["history"] }
+];
+var CLONE_TRANSFORM_CONTROLS = [
+  { id: "width", label: "Source W", section: "layer", min: 1, max: 400, step: 1, default: 100, decimals: 0, track: plain, unit: "%" },
+  { id: "height", label: "Source H", section: "layer", min: 1, max: 400, step: 1, default: 100, decimals: 0, track: plain, unit: "%" },
+  { id: "angle", label: "Source angle", section: "layer", min: -180, max: 180, step: 1, default: 0, decimals: 0, track: plain, unit: "\xB0" }
+];
+function cloneTransformView(controller) {
+  const t = controller.getState().paint.cloneTransform;
+  return {
+    width: Math.round(Math.abs(t.scaleX) * 100),
+    height: Math.round(Math.abs(t.scaleY) * 100),
+    angle: t.rotate,
+    flipH: t.scaleX < 0,
+    flipV: t.scaleY < 0,
+    identity: t.scaleX === 1 && t.scaleY === 1 && t.rotate === 0
+  };
+}
+function setCloneTransformValue(controller, id, value) {
+  const t = controller.getState().paint.cloneTransform;
+  if (id === "width") controller.setCloneTransform({ scaleX: Math.sign(t.scaleX) * (value ?? 100) / 100 });
+  else if (id === "height") controller.setCloneTransform({ scaleY: Math.sign(t.scaleY) * (value ?? 100) / 100 });
+  else if (id === "angle") controller.setCloneTransform({ rotate: value ?? 0 });
+  else if (id === "flipH") controller.setCloneTransform({ scaleX: -t.scaleX });
+  else controller.setCloneTransform({ scaleY: -t.scaleY });
+}
+var RETOUCH_CHOICES = [
+  {
+    id: "sample",
+    label: "Sample",
+    tools: ["clone", "heal", "spot-heal"],
+    options: [
+      { id: "current", label: "Current", title: "Sample the layer being retouched" },
+      { id: "current-below", label: "Current & Below", title: "Sample this layer and the layers under it" },
+      { id: "all", label: "All", title: "Sample every layer (retouch onto an empty layer)" }
+    ]
+  },
+  {
+    id: "spotType",
+    label: "Type",
+    tools: ["spot-heal"],
+    options: [
+      { id: "proximity-match", label: "Proximity Match", title: "Copy the best matching patch nearby" },
+      { id: "content-aware", label: "Content-Aware", title: "Synthesise texture and edges from patches around the spot" },
+      { id: "smooth", label: "Smooth", title: "Fill smoothly from the edges" }
+    ]
+  },
+  {
+    id: "range",
+    label: "Range",
+    tools: ["dodge", "burn"],
+    options: [
+      { id: "shadows", label: "Shadows", title: "Change the dark tones most" },
+      { id: "midtones", label: "Midtones", title: "Change the middle tones most" },
+      { id: "highlights", label: "Highlights", title: "Change the light tones most" }
+    ]
+  },
+  {
+    id: "spongeMode",
+    label: "Mode",
+    tools: ["sponge"],
+    options: [
+      { id: "desaturate", label: "Desaturate", title: "Take colour out" },
+      { id: "saturate", label: "Saturate", title: "Add colour" }
+    ]
+  }
+];
+var RETOUCH_TOGGLES = [
+  { id: "aligned", label: "Aligned", tools: ["clone", "heal"] },
+  { id: "protectTones", label: "Protect tones", tools: ["dodge", "burn"] },
+  { id: "vibrance", label: "Vibrance", tools: ["sponge"] }
+];
+function setRetouchChoice(controller, id, value) {
+  controller.setPaintOptions({ retouch: { [id]: value } });
+}
+function cloneSourceLabel(controller) {
+  const cs = controller.getState().paint.cloneSource;
+  return cs ? `Source ${cs.x}, ${cs.y}${cs.offset ? ` (offset ${cs.offset.x}, ${cs.offset.y})` : ""}` : "Alt-click to set the source";
+}
+function rgbUnitToHex(c) {
+  return `#${c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("")}`;
+}
+function sizeStep(size) {
+  return size < 10 ? 1 : size < 50 ? 5 : size < 100 ? 10 : size < 200 ? 25 : size < 500 ? 50 : 100;
+}
+var isTyping = (t) => {
+  const el = t;
+  return Boolean(el && (el.isContentEditable || el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT"));
+};
+function handlePaintShortcut(controller, e) {
+  if (e.ctrlKey || e.metaKey || e.altKey || isTyping(e.target)) return false;
+  const brush = controller.getState().paint.brush;
+  const set = (b) => controller.setPaintOptions({ brush: b });
+  const key = e.key;
+  if (handleMaskViewKey(controller, e)) return true;
+  switch (key.toLowerCase()) {
+    case "q":
+      controller.setQuickMaskMode(!controller.quickMaskEditing);
+      return true;
+    case "b":
+      controller.setTool(e.shiftKey || key === "B" ? "mixer" : "brush");
+      return true;
+    case "e":
+      controller.setTool("eraser");
+      return true;
+    case "v":
+      controller.setTool("move");
+      return true;
+    case "s":
+      controller.setTool("clone");
+      return true;
+    case "j":
+      controller.setTool(e.shiftKey || key === "J" ? controller.getState().activeTool === "heal" ? "spot-heal" : "heal" : "spot-heal");
+      return true;
+    case "o": {
+      const cur = controller.getState().activeTool;
+      const next = e.shiftKey || key === "O" ? cur === "dodge" ? "burn" : cur === "burn" ? "sponge" : "dodge" : "dodge";
+      controller.setTool(next);
+      return true;
+    }
+    case "y":
+      controller.setTool("history");
+      return true;
+    case "d":
+      controller.resetPaintColors();
+      return true;
+    case "x":
+      controller.swapPaintColors();
+      return true;
+  }
+  if (key === "[" || key === "{") {
+    if (e.shiftKey || key === "{") set({ hardness: Math.max(0, Math.round((brush.hardness - 0.25) * 4) / 4) });
+    else set({ size: Math.max(1, brush.size - sizeStep(brush.size - 1)) });
+    return true;
+  }
+  if (key === "]" || key === "}") {
+    if (e.shiftKey || key === "}") set({ hardness: Math.min(1, Math.round((brush.hardness + 0.25) * 4) / 4) });
+    else set({ size: Math.min(MAX_BRUSH_SIZE, brush.size + sizeStep(brush.size)) });
+    return true;
+  }
+  if (/^[0-9]$/.test(key) && isPaintTool(controller.getState().activeTool)) {
+    set({ opacity: key === "0" ? 1 : Number(key) / 10 });
+    return true;
+  }
+  return false;
+}
+var PaintGesture = class {
+  constructor(controller) {
+    this.controller = controller;
+  }
+  controller;
+  stroke = null;
+  move = null;
+  /** The last refusal (e.g. "layer is locked"), for the editor to show. */
+  error = null;
+  get active() {
+    return Boolean(this.stroke || this.move);
+  }
+  down(sample) {
+    this.error = null;
+    const tool = this.controller.getState().activeTool;
+    try {
+      if (tool === "move") {
+        const layer = this.controller.getActiveLayer();
+        if (!layer) throw new Error("Select a layer to move in the Layers panel.");
+        if (layer.type !== "pixel" && layer.type !== "shape" && layer.type !== "smart") throw new Error(`Only pixel, shape and smart object layers move; "${layer.name}" is a ${layer.type} layer.`);
+        if (layer.locks?.all || layer.locks?.position) throw new Error(`Layer "${layer.name}" has its position locked.`);
+        const origin = layer.type === "pixel" ? { ...layer.offset } : layer.type === "smart" ? { ...layer.placement.corners[0] } : (() => {
+          const b = shapeGeometryBounds(layer);
+          return b ? { x: b.x, y: b.y } : { x: 0, y: 0 };
+        })();
+        this.move = { id: layer.id, start: { x: sample.x, y: sample.y }, origin, moved: false };
+        return null;
+      }
+      if ((tool === "clone" || tool === "heal") && sample.altKey) {
+        this.controller.setCloneSource({ x: sample.x, y: sample.y });
+        return null;
+      }
+      if (isPaintTool(tool)) {
+        this.stroke = this.controller.beginStroke({ tool });
+        this.stroke.push([{ x: sample.x, y: sample.y, pressure: sample.pressure }]);
+        return null;
+      }
+    } catch (err) {
+      this.error = userErrorMessage(err);
+      this.stroke = null;
+      this.move = null;
+    }
+    return this.error;
+  }
+  /** Feeds pointer samples (all coalesced events of one move, in order). */
+  moveTo(samples) {
+    if (!samples.length) return;
+    if (this.stroke) {
+      this.stroke.push(samples);
+      return;
+    }
+    const m = this.move;
+    if (m) {
+      const last = samples[samples.length - 1];
+      const x = m.origin.x + Math.round(last.x - m.start.x);
+      const y = m.origin.y + Math.round(last.y - m.start.y);
+      try {
+        this.controller.offsetLayer(m.id, { x, y }, !m.moved);
+        m.moved = true;
+      } catch (err) {
+        this.error = userErrorMessage(err);
+        this.move = null;
+      }
+    }
+  }
+  up() {
+    if (this.stroke) {
+      try {
+        this.stroke.end();
+      } catch (err) {
+        this.error = userErrorMessage(err);
+      }
+    }
+    this.stroke = null;
+    this.move = null;
+  }
+  cancel() {
+    this.stroke?.cancel();
+    this.stroke = null;
+    this.move = null;
+  }
+};
+
 export {
   LEGACY_PROCESS_VERSION,
   LATEST_PROCESS_VERSION,
@@ -12334,6 +13471,12 @@ export {
   developTarget,
   legacyView,
   isLegacyShape,
+  EdgeMap,
+  snapToEdge,
+  liveWire,
+  simplifyPixelPath,
+  snapPolygonToEdges,
+  magneticAnchorSpacing,
   FREE_TRANSFORM_MODES,
   TRANSFORM_ANCHORS,
   ANCHOR_FRACTION,
@@ -12439,7 +13582,37 @@ export {
   importPsd,
   smartContentsFile,
   exportPsd,
+  SELECTION_TOOLS,
+  COLOR_RANGE_PRESET_LABELS,
+  SELECTION_MODE_LABELS,
+  DEFAULT_SELECTION_TOOL_OPTIONS,
+  selectionModeFromModifiers,
+  REFINE_EDGE_CONTROLS,
+  REFINE_OUTPUTS,
+  describeSelection,
   describeLayerEffects,
   createImageEffectTools,
-  createLayerEffectTools
+  createLayerEffectTools,
+  snapTo45,
+  SelectionGesture,
+  handleSelectionShortcut,
+  handleMaskViewKey,
+  handleQuickMaskKey,
+  BRUSH_OPTION_CONTROLS,
+  MIXER_OPTION_CONTROLS,
+  MIXER_MIXING_OPTIONS,
+  PAINT_TOOLS,
+  isPaintTool,
+  isRetouchPaintTool,
+  RETOUCH_OPTION_CONTROLS,
+  CLONE_TRANSFORM_CONTROLS,
+  cloneTransformView,
+  setCloneTransformValue,
+  RETOUCH_CHOICES,
+  RETOUCH_TOGGLES,
+  setRetouchChoice,
+  cloneSourceLabel,
+  rgbUnitToHex,
+  handlePaintShortcut,
+  PaintGesture
 };