@pixerate/editor 0.259.0 → 0.261.0

package/dist/image-editor/index.js

@@ -8,46 +8,7 @@ import {
   parseOpenTypeFont,
   removeAnchorsKeepingShape,
   traceField
-} from "../chunk-4M4E3N6X.js";
-import {
-  ColorGmm,
-  GAMMA,
-  GridGraph,
-  REFINE_EDIT_KINDS,
-  SelectionWorkerClient,
-  UNITS,
-  WORK_SIZE,
-  applyRefineEdits,
-  boxBlur,
-  brushStrokeMask,
-  deserializeMask,
-  ellipsePoints,
-  ellipseSelection,
-  findSky,
-  findSubject,
-  focusArea,
-  grabCutLabels,
-  keepMainPieces,
-  normalizeRect,
-  otsuThreshold,
-  polygonCoverage,
-  polygonCoverageBox,
-  polygonSelection,
-  quickSelectStroke,
-  rectSelection,
-  runSelectionJob,
-  selectObjectIn,
-  serializeMask,
-  slicSuperpixels,
-  smoothnessWeights,
-  softMaskToSelection,
-  startSelectionWorker,
-  superpixelSaliency,
-  upscaleRegion,
-  workImage,
-  workLuma,
-  workPlanes
-} from "../chunk-A7GJ6BXI.js";
+} from "../chunk-CQVTGBQI.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -58,14 +19,19 @@ import {
   BACKGROUND_LAYER_NAME,
   BLUR_FILTER_ID,
   BROWSER_IMAGE_TYPES,
+  BRUSH_OPTION_CONTROLS,
+  CLONE_TRANSFORM_CONTROLS,
+  COLOR_RANGE_PRESET_LABELS,
   D50,
   D65,
   DEFAULT_ADJUSTMENTS_VALUES,
   DEFAULT_DEPTH_MASK_VALUES,
   DEFAULT_MITER_LIMIT,
+  DEFAULT_SELECTION_TOOL_OPTIONS,
   DEFAULT_TRANSFORM_VALUES,
   DEVELOP_FILTER_ID,
   EDGE_COLOR_RADIUS,
+  EdgeMap,
   FREE_TRANSFORM_MODES,
   HUE_RANGE_LABELS,
   IDENTITY_MATRIX3,
@@ -81,14 +47,26 @@ import {
   MAX_KELVIN,
   MIN_KELVIN,
   MIRED_PER_TEMPERATURE_UNIT,
+  MIXER_MIXING_OPTIONS,
+  MIXER_OPTION_CONTROLS,
+  PAINT_TOOLS,
   PARAGRAPH_STYLE_FIELDS,
   PATTERN_BLOCK_KEYS,
   PSD_BLEND_KEYS,
+  PaintGesture,
   PsdError,
+  REFINE_EDGE_CONTROLS,
+  REFINE_OUTPUTS,
+  RETOUCH_CHOICES,
+  RETOUCH_OPTION_CONTROLS,
+  RETOUCH_TOGGLES,
+  SELECTION_MODE_LABELS,
+  SELECTION_TOOLS,
   SHAPE_OPERATIONS,
   SHAPE_RENDER_MARGIN,
   SMART_RENDER_MARGIN,
   SUPPORTED_ADJUSTMENT_KEYS,
+  SelectionGesture,
   TEXT_ALIGNS,
   TEXT_ORIENTATIONS,
   TEXT_RENDER_MARGIN,
@@ -142,6 +120,8 @@ import {
   calculateCropDrag,
   canvasToImagePoint,
   clampCropToImage,
+  cloneSourceLabel,
+  cloneTransformView,
   colorBalanceChannel,
   compileAdjustmentLayer,
   componentPath,
@@ -170,6 +150,7 @@ import {
   depthMaskAlpha,
   depthRasterMask,
   describeLayerEffects,
+  describeSelection,
   describeTransform,
   deserializeEffects,
   deserializeLayer,
@@ -198,6 +179,10 @@ import {
   getViewportMetrics,
   getViewportProjection,
   groupLayers,
+  handleMaskViewKey,
+  handlePaintShortcut,
+  handleQuickMaskKey,
+  handleSelectionShortcut,
   hasEdgeUnmix,
   hasResampledLegacyMask,
   hasSoftBand,
@@ -225,9 +210,11 @@ import {
   isDefaultDepthMask,
   isIdentityTransform,
   isLegacyShape,
+  isPaintTool,
   isPaintableLayer,
   isQuarterTurnSwapped,
   isRenderedLayer,
+  isRetouchPaintTool,
   isSmartSurfaceIncomplete,
   isSpatialFilter,
   isTransformAnchor,
@@ -251,6 +238,8 @@ import {
   linearToSrgb as linearToSrgb2,
   liveComponent,
   liveShapeSubpaths,
+  liveWire,
+  magneticAnchorSpacing,
   mapCropHandle,
   mapSubpaths,
   maskCoverageOverCanvas,
@@ -336,20 +325,24 @@ import {
   resolveVectorMasks,
   rgbToGray,
   rgbToHsl,
+  rgbUnitToHex,
   runLayerFilters,
   runLayerFiltersFloat,
   sampleLut,
   sampleToneLut,
+  selectionModeFromModifiers,
   serializeContents,
   serializeEffects,
   serializeLayer,
   serializeLayers,
   serializeLayersExternal,
   serializePatterns,
+  setCloneTransformValue,
   setLayerEffects,
   setLayerEffectsEnabled,
   setLayerMask,
   setLayerProperties,
+  setRetouchChoice,
   setSmartFilterMask,
   setSmartFiltersEnabled,
   setSmartPlacement,
@@ -359,8 +352,12 @@ import {
   shapeLayers,
   shapeOutline,
   shapeRenderClip,
+  simplifyPixelPath,
   smartContentsFile,
   smartObjectLayers,
+  snapPolygonToEdges,
+  snapTo45,
+  snapToEdge,
   srgbToLinear,
   tempTintToXy,
   temperatureToKelvin,
@@ -413,15 +410,25 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-SSFMWJDK.js";
+} from "../chunk-D4TE5JNW.js";
 import {
+  ColorGmm,
   DEFAULT_REFINE_EDGE_PARAMS,
   EMPTY_DISTANCE,
+  GAMMA,
   GUIDED_FILTER_EPS,
+  GridGraph,
+  REFINE_EDIT_KINDS,
   SELECTION_MODES,
   SELECTION_MODIFY_OPS,
+  SelectionWorkerClient,
+  UNITS,
+  WORK_SIZE,
+  applyRefineEdits,
   borderCoverage,
+  boxBlur,
   boxMean,
+  brushStrokeMask,
   combineSelections,
   computeSelectionBounds,
   contractCoverage,
@@ -429,13 +436,20 @@ import {
   createSelectionMask,
   decodeSelectionRle,
   decontaminateColors,
+  deserializeMask,
   deserializeSelection,
   distanceTransform,
   edgeWidth,
+  ellipsePoints,
+  ellipseSelection,
   encodeSelectionRle,
   expandCoverage,
   featherCoverage,
+  findSky,
+  findSubject,
+  focusArea,
   fullSelection,
+  grabCutLabels,
   greyMorphology,
   guidePlanes,
   guidedFilterColor,
@@ -443,13 +457,23 @@ import {
   invertSelection,
   isSelectionEmpty,
   isSelectionMode,
+  keepMainPieces,
   modifySelection,
+  normalizeRect,
   normalizeRefineEdgeParams,
+  otsuThreshold,
   parseSelectionMode,
+  polygonCoverage,
+  polygonCoverageBox,
+  polygonSelection,
+  quickSelectStroke,
+  rectSelection,
   refineCoverage,
   refineEdgeHalo,
   refineSelection,
   resizeSelection,
+  runSelectionJob,
+  selectObjectIn,
   selectionArea,
   selectionFromCoverage,
   selectionFromPixels,
@@ -458,30 +482,28 @@ import {
   selectionToCoverage,
   selectionToPixels,
   selectionValueAt,
+  serializeMask,
   serializeSelection,
   shiftCoverage,
-  smoothCoverage
-} from "../chunk-ZNA3IQZF.js";
-import {
-  brushColourHex
-} from "../chunk-FJBQTZS4.js";
-import {
-  parseCssColor
-} from "../chunk-3CI7FRMK.js";
+  slicSuperpixels,
+  smoothCoverage,
+  smoothnessWeights,
+  softMaskToSelection,
+  startSelectionWorker,
+  superpixelSaliency,
+  upscaleRegion,
+  workImage,
+  workLuma,
+  workPlanes
+} from "../chunk-WJ4WQJCC.js";
 import {
   createCaptureTool
 } from "../chunk-5ED73EC6.js";
-import {
-  LAYER_EFFECT_MENU,
-  effectControlChange,
-  layerEffectControls,
-  layerEffectsBadge,
-  layerEffectsPanel
-} from "../chunk-2VJAVXLI.js";
 import {
   DEFAULT_GLOBAL_LIGHT,
   INTERPOLATIONS,
   LAYER_EFFECT_KINDS,
+  LAYER_EFFECT_MENU,
   LayerEffectError,
   MAX_EFFECT_REACH,
   MAX_TRANSFORM_PIXELS,
@@ -497,6 +519,7 @@ import {
   defaultEffectGradient,
   defaultLayerEffect,
   effectColorHex,
+  effectControlChange,
   effectReach,
   effectsFingerprint,
   effectsMargin,
@@ -510,8 +533,11 @@ import {
   isLayerEffectKind,
   isLayerLocked,
   keysWeight,
+  layerEffectControls,
   layerEffectFields,
   layerEffectLabel,
+  layerEffectsBadge,
+  layerEffectsPanel,
   mapLayer,
   mergeLayerEffect,
   newEffectId,
@@ -527,7 +553,7 @@ import {
   validateLayerEffects,
   warpSurface,
   workingToSamples
-} from "../chunk-3PPJRMIG.js";
+} from "../chunk-3O47TPGX.js";
 import {
   applyHomography,
   boxQuad,
@@ -541,50 +567,10 @@ import {
   DIRECT_GAUSSIAN_MAX_SIGMA,
   gaussianBlur
 } from "../chunk-ZIF4UJJ6.js";
-import {
-  DEFAULT_RETOUCH,
-  IDENTITY_CLONE_TRANSFORM,
-  RETOUCH_SAMPLES,
-  RegionPixelSource,
-  RetouchDabStroke,
-  SPOT_HEAL_TYPES,
-  TONE_RANGES,
-  TilePixelSource,
-  TransformedPixelSource,
-  applyRetouchToTile,
-  applyToneToDeepTile,
-  boxBlurPixels,
-  cloneSamplePoint,
-  dodgeBurn,
-  dodgeBurnCurve,
-  healPixels,
-  isIdentityCloneTransform,
-  luma,
-  normalizeRetouch,
-  perDabStrength,
-  readSourceRegion,
-  retouchFilter,
-  rgbaViewOfGrey,
-  saturationOf,
-  smudgeEffect,
-  sponge,
-  spongeEffect,
-  spotHealPixels,
-  spotHealWindow,
-  toneOf
-} from "../chunk-62Z5WLRA.js";
-import {
-  bestOffset,
-  contentAwareFill,
-  dilateMask,
-  maskBounds,
-  membraneFill,
-  seamlessClone,
-  solveMembrane
-} from "../chunk-VWEWY4FY.js";
 import {
   BODY_SCATTER,
   DEFAULT_FLOW,
+  DEFAULT_RETOUCH,
   DEFAULT_WET_PAPER,
   DEFAULT_WET_PARAMS,
   DRY_EPS,
@@ -599,6 +585,7 @@ import {
   FLAT,
   FREE_INTERVAL,
   HIDE,
+  IDENTITY_CLONE_TRANSFORM,
   MASS_CHANNELS,
   MAX_BATCH,
   MAX_TILT_ACCEL,
@@ -624,12 +611,19 @@ import {
   P_SW,
   P_UX,
   P_UY,
+  RETOUCH_SAMPLES,
+  RegionPixelSource,
+  RetouchDabStroke,
   SET_PLANES,
   SLOT_BYTES,
   SLOT_PLANES,
   SLOT_SIDE,
+  SPOT_HEAL_TYPES,
   SRGB_TO_LINEAR,
   STRIP,
+  TONE_RANGES,
+  TilePixelSource,
+  TransformedPixelSource,
   U_MAX,
   W9,
   WET_FLOW_KINDS,
@@ -643,11 +637,17 @@ import {
   WetWorkerPool,
   WetWorld,
   WetWorldError,
+  applyRetouchToTile,
+  applyToneToDeepTile,
+  boxBlurPixels,
   canShareMemory,
+  cloneSamplePoint,
   createPigmentTools,
   createWetGpuEngine,
   dexp,
   dlog,
+  dodgeBurn,
+  dodgeBurnCurve,
   dpow,
   dsincos,
   edgeBits,
@@ -656,28 +656,52 @@ import {
   filmReflectance,
   findWebGpu,
   flowField,
+  healPixels,
+  isIdentityCloneTransform,
   latticeViscosity,
   linearToSrgb8,
   loadWetKernel,
+  luma,
   moveWetSnapshot,
   normalizeFlow,
+  normalizeRetouch,
   normalizeTilt,
   normalizeWetParams,
   packWetParams,
+  perDabStrength,
   pigmentColor,
   pigmentOf,
   pixelPigment,
   pointerPressure,
   pointerStrokeSample,
   pointerStrokeSamples,
+  readSourceRegion,
+  retouchFilter,
+  rgbaViewOfGrey,
+  saturationOf,
   shadeLightTile,
   shadeTile,
+  smudgeEffect,
+  sponge,
+  spongeEffect,
+  spotHealPixels,
+  spotHealWindow,
   srgbByteToLinear,
   stepSlotTs,
+  toneOf,
   wetGpuSupport,
   wetSimdSupported,
   wetSupport
-} from "../chunk-WQCNC4DK.js";
+} from "../chunk-XC6DPRYI.js";
+import {
+  bestOffset,
+  contentAwareFill,
+  dilateMask,
+  maskBounds,
+  membraneFill,
+  seamlessClone,
+  solveMembrane
+} from "../chunk-VWEWY4FY.js";
 import {
   BUILTIN_PROFILES,
   CmsError,
@@ -746,14 +770,14 @@ import {
   warpMeshParamAt,
   warpMeshRows,
   warpPresetMesh
-} from "../chunk-YQ4PQTBB.js";
+} from "../chunk-6NZL24W4.js";
 import {
   IMAGE_PROFILE,
   checkBrush,
   closest,
   createBrushLibrary,
   resolveBrush
-} from "../chunk-SMTUQWGY.js";
+} from "../chunk-5IW65VQ6.js";
 import "../chunk-APX63ILU.js";
 import "../chunk-M6DNZNVY.js";
 import {
@@ -762,6 +786,12 @@ import {
   segmentNearest
 } from "../chunk-WEIK3UYB.js";
 import "../chunk-PWBZH3FK.js";
+import {
+  brushColourHex
+} from "../chunk-FJBQTZS4.js";
+import {
+  parseCssColor
+} from "../chunk-3CI7FRMK.js";
 import "../chunk-SZTI6EER.js";
 import {
   EffectRendererPool
@@ -3935,312 +3965,6 @@ function pathToSelection(components, width, height, options = {}) {
   return feather > 0 && mask.bounds ? modifySelection(mask, "feather", feather) : mask;
 }
 
-// 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 luma2 = new Uint8Array(width * height);
-    for (let i = 0, p = 0; i < luma2.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];
-      luma2[i] = Math.round(y * a + 255 * (1 - a));
-    }
-    this.luma = luma2;
-  }
-  /** 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 key2 = by * 65536 + bx;
-    let b = this.blocks.get(key2);
-    if (!b) {
-      b = this.computeBlock(bx * BLOCK, by * BLOCK);
-      this.blocks.set(key2, b);
-    }
-    return b;
-  }
-  computeBlock(x0, y0) {
-    const { width: W, height: H, luma: luma2 } = this;
-    const M = 2;
-    const S = BLOCK + 2 * M;
-    const smooth = new Float32Array(S * S);
-    const at = (x, y) => luma2[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, key2) {
-    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] <= key2) break;
-      this.ids[i] = this.ids[p];
-      this.keys[i] = this.keys[p];
-      i = p;
-    }
-    this.ids[i] = id;
-    this.keys[i] = key2;
-  }
-  /** Removes the cheapest entry; read it from `topId` / `topKey` first. */
-  pop() {
-    const n = --this.size;
-    const id = this.ids[n];
-    const key2 = 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] >= key2) break;
-      this.ids[i] = this.ids[c];
-      this.keys[i] = this.keys[c];
-      i = c;
-    }
-    this.ids[i] = id;
-    this.keys[i] = key2;
-  }
-  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 px = rx0 + x - ax;
-      const py = ry0 + y - ay;
-      const t = Math.min(len, Math.max(0, px * ux + py * uy));
-      if (Math.hypot(px - 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 dist2 = 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);
-  dist2[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 > dist2[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 q = qy * w + qx;
-      if (!inside[q] || done[q]) 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[q] * lx + dirY[q] * ly));
-      const fD = (Math.acos(dp) + Math.acos(dq)) / Math.PI;
-      const fG = 1 - strength[q] * scale;
-      const fZ = 1 - zero[q];
-      const cost = (W_ZERO * fZ + W_GRADIENT * fG + W_DIRECTION * fD + 0.01) * step;
-      const nd = d + cost;
-      if (nd < dist2[q]) {
-        dist2[q] = nd;
-        prev[q] = p;
-        heap.push(q, 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/paths.ts
 var WORK_PATH_NAME = "Work Path";
 var counter = 0;
@@ -8066,8 +7790,8 @@ var ImageEditorController = class {
     const { layer } = this.requireVectorMask(id);
     const { width, height } = this.canvasSize;
     const raster = layer.mask;
-    const plain3 = { ...layer, vectorMask: { ...layer.vectorMask, enabled: true }, mask: raster ? { surface: raster.surface, defaultValue: raster.defaultValue } : void 0 };
-    const baked = effectiveLayerMask(plain3, width, height, this.guideSurfaceOf);
+    const plain2 = { ...layer, vectorMask: { ...layer.vectorMask, enabled: true }, mask: raster ? { surface: raster.surface, defaultValue: raster.defaultValue } : void 0 };
+    const baked = effectiveLayerMask(plain2, width, height, this.guideSurfaceOf);
     const mask = raster ? { ...raster, surface: baked.surface, defaultValue: baked.defaultValue } : baked;
     this.commitLayers(
       mapLayer(this.state.layers, id, (l) => {
@@ -8762,8 +8486,8 @@ var ImageEditorController = class {
       const old = layer?.contents;
       const { width, height } = edited.imageDimensions;
       const only = edited.layers.length === 1 ? edited.layers[0] : null;
-      const plain3 = only?.type === "pixel" && only.visible && only.opacity === 1 && only.blend === "normal" && !only.mask && !only.effects && !only.filters?.length && !only.clipped && (only.fillOpacity ?? 1) === 1 && only.source !== "document";
-      if (old?.kind === "raster" && plain3) {
+      const plain2 = only?.type === "pixel" && only.visible && only.opacity === 1 && only.blend === "normal" && !only.mask && !only.effects && !only.filters?.length && !only.clipped && (only.fillOpacity ?? 1) === 1 && only.source !== "document";
+      if (old?.kind === "raster" && plain2) {
         const px = readRegion(only.surface, { x: -only.offset.x, y: -only.offset.y, width, height });
         next = rasterContents({ width, height, data: px }, old.name, old.id);
       } else {
@@ -10698,8 +10422,8 @@ var ImageEditorController = class {
       return { output, layerId, refineMode, ...documentId ? { documentId } : {} };
     }
     return this.asOneStep(() => {
-      const plain3 = output === "selection" && !edits.length && !regions2 && refineMode === "color";
-      if (plain3) this.withRecipeStep({ op: "refine", params: { ...params }, ...samplingFields(options) }, () => this.setSelection(refined));
+      const plain2 = output === "selection" && !edits.length && !regions2 && refineMode === "color";
+      if (plain2) this.withRecipeStep({ op: "refine", params: { ...params }, ...samplingFields(options) }, () => this.setSelection(refined));
       else this.setSelection(refined);
       if (output === "selection") return { output, refineMode };
       if (output === "layer-mask") {
@@ -12459,10 +12183,10 @@ var ImageEditorController = class {
       const mask = layer.mask;
       if (!mask?.source) return mask;
       add2("Parametric (depth) masks were baked into pixel masks", layer.name);
-      const plain3 = { ...layer, mask: { ...mask, density: 1, feather: 0, enabled: true } };
+      const plain2 = { ...layer, mask: { ...mask, density: 1, feather: 0, enabled: true } };
       const ox = layer.type === "pixel" ? layer.offset.x : 0;
       const oy = layer.type === "pixel" ? layer.offset.y : 0;
-      const coverage = compositor.maskCoverage(plain3, canvas, sources);
+      const coverage = compositor.maskCoverage(plain2, canvas, sources);
       const bytes = new Uint8ClampedArray(width * height);
       if (coverage) for (let i = 0; i < bytes.length; i++) bytes[i] = Math.round(coverage[i] * 255);
       else bytes.fill(255);
@@ -13809,95 +13533,6 @@ function agentDragDraft(mode, box, image) {
   };
 }
 
-// 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 pct = selectionArea(mask) / (mask.width * mask.height) * 100;
-  const shown = pct >= 10 ? Math.round(pct) : Math.round(pct * 10) / 10;
-  return `${mask.bounds.width} \xD7 ${mask.bounds.height} px selected (${shown}% of the image)`;
-}
-
 // src/image-editor/selection-tools.ts
 var modeSchema = {
   type: "string",
@@ -16339,740 +15974,6 @@ function createImageLayerTools(controller) {
   ];
 }
 
-// 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 q = this.quick;
-    if (!q) return;
-    if (q.running) {
-      q.dirty = true;
-      return;
-    }
-    q.running = true;
-    this.livePreviews = (async () => {
-      do {
-        q.dirty = false;
-        const stroke = this.points.slice();
-        const options = this.getOptions();
-        try {
-          const pixels = await q.pixels;
-          if (!pixels || this.quick !== q) break;
-          const { mask } = await this.controller.runSelectionJob(
-            {
-              op: "quick",
-              stroke,
-              size: options.quickSize ?? 30,
-              grow: q.mode === "add",
-              enhanceEdge: options.quickEnhance ?? false,
-              selection: q.mode === "add" && q.base?.bounds ? serializeMask(q.base) : null
-            },
-            pixels
-          );
-          if (this.quick === q) this.controller.setSelectionPreview(combineSelections(q.base, mask, q.mode));
-        } catch {
-          break;
-        }
-      } while (q.dirty && this.quick === q);
-      q.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 rect3 = normalizeRect({
-      x: this.start.x,
-      y: this.start.y,
-      width: this.current.x - this.start.x,
-      height: this.current.y - this.start.y
-    });
-    if (rect3.width < 1 && rect3.height < 1) return null;
-    if (tool === "ellipse") return ellipsePoints(rect3);
-    return [
-      { x: rect3.x, y: rect3.y },
-      { x: rect3.x + rect3.width, y: rect3.y },
-      { x: rect3.x + rect3.width, y: rect3.y + rect3.height },
-      { x: rect3.x, y: rect3.y + rect3.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 common = {
-        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(common);
-          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 }], {
-            ...common,
-            fuzziness: options.fuzziness ?? 40,
-            localized: options.localized ? options.localized : void 0,
-            invert: options.rangeInvert ?? false
-          });
-          return;
-        }
-        await this.controller.magicWand(point2, {
-          ...common,
-          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 rect4 = 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 = rect4.width >= 4 && rect4.height >= 4 ? { rect: rect4 } : { point: { x: rect4.x + rect4.width / 2, y: rect4.y + rect4.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 rect3 = 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(rect3, opts) : this.controller.selectRect(rect3, opts);
-  }
-  /** Closes a polygonal lasso and selects it. Returns true when the selection changed. */
-  close() {
-    let polygon = 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])) : [];
-      polygon = simplifyPixelPath([...m.fixed, ...tail.slice(1, -1)]);
-    }
-    if (!polygon) return false;
-    const options = this.getOptions();
-    this.cancel();
-    if (polygon.length < 3) return false;
-    return this.controller.selectPolygon(polygon, {
-      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(key2) {
-    if (!this.polygon && !this.magnetic) return false;
-    if (key2 === "Enter") this.close();
-    else if (key2 === "Escape") this.cancel();
-    else if (key2 === "Backspace" || key2 === "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 guard = 0; guard < 64; guard++) {
-      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 key2 = e.key.toLowerCase();
-  const run = (fn) => {
-    try {
-      fn();
-    } catch (err) {
-      onError?.(err instanceof Error ? err.message : String(err));
-    }
-    return true;
-  };
-  if (key2 === "c") return run(() => controller.copyPixels({ merged: Boolean(e.shiftKey) }));
-  if (key2 === "x" && !e.shiftKey) return run(() => controller.cutPixels());
-  if (key2 === "v") return run(() => controller.pastePixels(e.shiftKey && e.altKey ? "into" : e.shiftKey ? "in-place" : "new-layer"));
-  if (key2 === "d") return run(() => e.shiftKey ? controller.reselect() : controller.deselect());
-  if (key2 === "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 plain2 = { kind: "plain" };
-var BRUSH_OPTION_CONTROLS = [
-  { id: "size", label: "Size", section: "layer", min: 1, max: 500, step: 1, default: 20, decimals: 0, track: plain2, unit: "px" },
-  { id: "hardness", label: "Hardness", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "opacity", label: "Opacity", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "flow", label: "Flow", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "smoothing", label: "Smoothing", section: "layer", min: 0, max: 0.95, step: 0.01, default: 0, decimals: 0, track: plain2, 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: plain2, displayScale: 100, unit: "%" },
-  { id: "load", label: "Load", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "mix", label: "Mix", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, 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: plain2, 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: plain2, 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: plain2, 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: plain2, unit: "%" },
-  { id: "height", label: "Source H", section: "layer", min: 1, max: 400, step: 1, default: 100, decimals: 0, track: plain2, unit: "%" },
-  { id: "angle", label: "Source angle", section: "layer", min: -180, max: 180, step: 1, default: 0, decimals: 0, track: plain2, 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 key2 = e.key;
-  if (handleMaskViewKey(controller, e)) return true;
-  switch (key2.toLowerCase()) {
-    case "q":
-      controller.setQuickMaskMode(!controller.quickMaskEditing);
-      return true;
-    case "b":
-      controller.setTool(e.shiftKey || key2 === "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 || key2 === "J" ? controller.getState().activeTool === "heal" ? "spot-heal" : "heal" : "spot-heal");
-      return true;
-    case "o": {
-      const cur = controller.getState().activeTool;
-      const next = e.shiftKey || key2 === "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 (key2 === "[" || key2 === "{") {
-    if (e.shiftKey || key2 === "{") 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 (key2 === "]" || key2 === "}") {
-    if (e.shiftKey || key2 === "}") 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(key2) && isPaintTool(controller.getState().activeTool)) {
-    set({ opacity: key2 === "0" ? 1 : Number(key2) / 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;
-  }
-};
-
 // src/image-editor/paint-tools.ts
 var READ3 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var WRITE3 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };