@pixerate/editor 0.197.0 → 0.198.0

package/dist/image-editor/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16;
 
 
 
@@ -3045,7 +3045,7 @@ var GridGraph = class {
   }
 };
 
-// src/image-editor/selection/segment/quick.ts
+// src/image-editor/selection/segment/work.ts
 var WORK_SIZE = 512;
 var workCache = /* @__PURE__ */ new WeakMap();
 function workImage(pixels, maxSide = WORK_SIZE) {
@@ -3082,6 +3082,155 @@ function workImage(pixels, maxSide = WORK_SIZE) {
   workCache.set(pixels.data, { maxSide, work });
   return work;
 }
+var GAMMA = 50;
+var UNITS = 64;
+function smoothnessWeights(work, roi) {
+  const { width: w, rgb } = work;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  const right = new Float64Array(rw * rh);
+  const down = new Float64Array(rw * rh);
+  let sumSq = 0;
+  let pairs = 0;
+  for (let y = 0; y < rh; y++) {
+    for (let x = 0; x < rw; x++) {
+      const p = y * rw + x;
+      const c = ((ry + y) * w + rx + x) * 3;
+      if (x + 1 < rw) {
+        right[p] = (rgb[c] - rgb[c + 3]) ** 2 + (rgb[c + 1] - rgb[c + 4]) ** 2 + (rgb[c + 2] - rgb[c + 5]) ** 2;
+        sumSq += right[p];
+        pairs++;
+      }
+      if (y + 1 < rh) {
+        const k = c + w * 3;
+        down[p] = (rgb[c] - rgb[k]) ** 2 + (rgb[c + 1] - rgb[k + 1]) ** 2 + (rgb[c + 2] - rgb[k + 2]) ** 2;
+        sumSq += down[p];
+        pairs++;
+      }
+    }
+  }
+  const beta = 1 / (2 * Math.max(1e-6, sumSq / Math.max(1, pairs)));
+  for (let p = 0; p < right.length; p++) {
+    right[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * right[p]));
+    down[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * down[p]));
+  }
+  return { right, down };
+}
+function boxBlur(src, w, h, passes) {
+  let a = src;
+  for (let k = 0; k < passes; k++) {
+    const b = new Float32Array(a.length);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        let s = 0;
+        let c = 0;
+        for (let j = Math.max(0, y - 1); j <= Math.min(h - 1, y + 1); j++) {
+          for (let i = Math.max(0, x - 1); i <= Math.min(w - 1, x + 1); i++) {
+            s += a[j * w + i];
+            c++;
+          }
+        }
+        b[y * w + x] = s / c;
+      }
+    }
+    a = b;
+  }
+  return a;
+}
+function upscaleRegion(work, pixels, roi, label, enhance) {
+  const { sourceWidth: W, sourceHeight: H, scale, rgb, width: ww } = work;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  let soft = Float32Array.from(label);
+  if (enhance) {
+    soft = boxBlur(soft, rw, rh, 2);
+    for (let i = 0; i < soft.length; i++) soft[i] = Math.min(1, Math.max(0, (soft[i] - 0.5) * 3 + 0.5));
+  }
+  const X0 = Math.max(0, Math.floor(rx / scale));
+  const Y0 = Math.max(0, Math.floor(ry / scale));
+  const X1 = Math.min(W, Math.ceil((rx + rw) / scale));
+  const Y1 = Math.min(H, Math.ceil((ry + rh) / scale));
+  const RW = X1 - X0;
+  const RH = Y1 - Y0;
+  const out = new Uint8Array(RW * RH);
+  const at = (x, y) => soft[Math.min(rh - 1, Math.max(0, y)) * rw + Math.min(rw - 1, Math.max(0, x))];
+  const data = pixels.data;
+  const colOf = new Int32Array(RW);
+  const fxOf = new Float32Array(RW);
+  for (let X = 0; X < RW; X++) {
+    const u = (X0 + X + 0.5) * scale - 0.5 - rx;
+    colOf[X] = Math.floor(u);
+    fxOf[X] = u - colOf[X];
+  }
+  const cellState = (i, j) => {
+    const a = at(i, j), b = at(i + 1, j), c = at(i, j + 1), d = at(i + 1, j + 1);
+    if (a === 1 && b === 1 && c === 1 && d === 1) return 1;
+    if (a === 0 && b === 0 && c === 0 && d === 0) return 0;
+    return 2;
+  };
+  for (let Y = 0; Y < RH; Y++) {
+    const v = (Y0 + Y + 0.5) * scale - 0.5 - ry;
+    const j = Math.floor(v);
+    const fy = v - j;
+    for (let X = 0; X < RW; X++) {
+      const i = colOf[X];
+      const state = cellState(i, j);
+      if (state !== 2) {
+        let end = X + 1;
+        while (end < RW && colOf[end] === i) end++;
+        if (state === 1) out.fill(255, Y * RW + X, Y * RW + end);
+        X = end - 1;
+        continue;
+      }
+      const fx = fxOf[X];
+      const m = (at(i, j) * (1 - fx) + at(i + 1, j) * fx) * (1 - fy) + (at(i, j + 1) * (1 - fx) + at(i + 1, j + 1) * fx) * fy;
+      if (m <= 1e-3 || m >= 0.999) {
+        out[Y * RW + X] = m >= 0.999 ? 255 : 0;
+        continue;
+      }
+      let fr = 0, fg = 0, fb = 0, fn = 0, br = 0, bg = 0, bb = 0, bn = 0;
+      for (let jj = j - 1; jj <= j + 2; jj++) {
+        for (let ii = i - 1; ii <= i + 2; ii++) {
+          if (ii < 0 || jj < 0 || ii >= rw || jj >= rh) continue;
+          const k = ((ry + jj) * ww + rx + ii) * 3;
+          if (soft[jj * rw + ii] >= 0.5) {
+            fr += rgb[k];
+            fg += rgb[k + 1];
+            fb += rgb[k + 2];
+            fn++;
+          } else {
+            br += rgb[k];
+            bg += rgb[k + 1];
+            bb += rgb[k + 2];
+            bn++;
+          }
+        }
+      }
+      let alpha = m;
+      if (fn && bn) {
+        fr /= fn;
+        fg /= fn;
+        fb /= fn;
+        br /= bn;
+        bg /= bn;
+        bb /= bn;
+        const dr = fr - br, dg = fg - bg, db = fb - bb;
+        const len2 = dr * dr + dg * dg + db * db;
+        if (len2 > 400) {
+          const p = ((Y0 + Y) * W + X0 + X) * 4;
+          const a = data[p + 3] / 255;
+          const cr = data[p] * a + 255 * (1 - a) - br;
+          const cg = data[p + 1] * a + 255 * (1 - a) - bg;
+          const cb = data[p + 2] * a + 255 * (1 - a) - bb;
+          const proj = Math.min(1, Math.max(0, (cr * dr + cg * dg + cb * db) / len2));
+          alpha = Math.min(1, Math.max(0, proj * 0.75 + m * 0.25));
+        } else alpha = Math.min(1, Math.max(0, (m - 0.5) * 2 + 0.5));
+      }
+      out[Y * RW + X] = Math.round(alpha * 255);
+    }
+  }
+  return _chunkUYXL6ZWQcjs.selectionFromRegion.call(void 0, W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
+}
+
+// src/image-editor/selection/segment/quick.ts
 var BINS = 16;
 var binOf = (rgb, i) => (Math.min(BINS - 1, rgb[i * 3] >> 4) * BINS + Math.min(BINS - 1, rgb[i * 3 + 1] >> 4)) * BINS + Math.min(BINS - 1, rgb[i * 3 + 2] >> 4);
 function costTable(hist, total) {
@@ -3102,8 +3251,6 @@ function costTable(hist, total) {
   for (let i = 0; i < a.length; i++) out[i] = -Math.log((a[i] + floor * Math.max(1, total)) / denom);
   return out;
 }
-var GAMMA = 50;
-var UNITS = 64;
 function strokePixels(points, r, w, h) {
   const mask = new Uint8Array(w * h);
   const list = [];
@@ -3161,23 +3308,7 @@ function segmentStroke(work, stroke, grown, start) {
     }
     const fgCost = costTable(fgHist, fgN);
     const bgCost = costTable(bgHist, bgN);
-    let sumSq = 0;
-    let pairs = 0;
-    for (let y = 0; y < rh; y++) {
-      for (let x = 0; x < rw; x++) {
-        const g = ((ry + y) * w + rx + x) * 3;
-        if (x + 1 < rw) {
-          sumSq += (rgb[g] - rgb[g + 3]) ** 2 + (rgb[g + 1] - rgb[g + 4]) ** 2 + (rgb[g + 2] - rgb[g + 5]) ** 2;
-          pairs++;
-        }
-        if (y + 1 < rh) {
-          const k = g + w * 3;
-          sumSq += (rgb[g] - rgb[k]) ** 2 + (rgb[g + 1] - rgb[k + 1]) ** 2 + (rgb[g + 2] - rgb[k + 2]) ** 2;
-          pairs++;
-        }
-      }
-    }
-    const beta = 1 / (2 * Math.max(1e-6, sumSq / Math.max(1, pairs)));
+    const { right, down } = smoothnessWeights(work, roi);
     const graph = new GridGraph(rw, rh);
     const HARD = 1e9;
     for (let y = 0; y < rh; y++) {
@@ -3189,16 +3320,8 @@ function segmentStroke(work, stroke, grown, start) {
           const bin = binOf(rgb, g);
           graph.addTerminal(p, Math.round(bgCost[bin] * UNITS), Math.round(fgCost[bin] * UNITS));
         }
-        const c = g * 3;
-        if (x + 1 < rw) {
-          const d = (rgb[c] - rgb[c + 3]) ** 2 + (rgb[c + 1] - rgb[c + 4]) ** 2 + (rgb[c + 2] - rgb[c + 5]) ** 2;
-          graph.setEdge(p, 0, Math.round(GAMMA * UNITS * Math.exp(-beta * d)));
-        }
-        if (y + 1 < rh) {
-          const k = c + w * 3;
-          const d = (rgb[c] - rgb[k]) ** 2 + (rgb[c + 1] - rgb[k + 1]) ** 2 + (rgb[c + 2] - rgb[k + 2]) ** 2;
-          graph.setEdge(p, 1, Math.round(GAMMA * UNITS * Math.exp(-beta * d)));
-        }
+        if (x + 1 < rw) graph.setEdge(p, 0, right[p]);
+        if (y + 1 < rh) graph.setEdge(p, 1, down[p]);
       }
     }
     graph.maxflow();
@@ -3239,120 +3362,6 @@ function segmentStroke(work, stroke, grown, start) {
     if (roi.width * roi.height * 2.5 > w * h) roi = { x: 0, y: 0, width: w, height: h };
   }
 }
-function boxBlur(src, w, h, passes) {
-  let a = src;
-  for (let k = 0; k < passes; k++) {
-    const b = new Float32Array(a.length);
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        let s = 0;
-        let c = 0;
-        for (let j = Math.max(0, y - 1); j <= Math.min(h - 1, y + 1); j++) {
-          for (let i = Math.max(0, x - 1); i <= Math.min(w - 1, x + 1); i++) {
-            s += a[j * w + i];
-            c++;
-          }
-        }
-        b[y * w + x] = s / c;
-      }
-    }
-    a = b;
-  }
-  return a;
-}
-function upscaleRegion(work, pixels, roi, label, enhance) {
-  const { sourceWidth: W, sourceHeight: H, scale, rgb, width: ww } = work;
-  const { x: rx, y: ry, width: rw, height: rh } = roi;
-  let soft = Float32Array.from(label);
-  if (enhance) {
-    soft = boxBlur(soft, rw, rh, 2);
-    for (let i = 0; i < soft.length; i++) soft[i] = Math.min(1, Math.max(0, (soft[i] - 0.5) * 3 + 0.5));
-  }
-  const X0 = Math.max(0, Math.floor(rx / scale));
-  const Y0 = Math.max(0, Math.floor(ry / scale));
-  const X1 = Math.min(W, Math.ceil((rx + rw) / scale));
-  const Y1 = Math.min(H, Math.ceil((ry + rh) / scale));
-  const RW = X1 - X0;
-  const RH = Y1 - Y0;
-  const out = new Uint8Array(RW * RH);
-  const at = (x, y) => soft[Math.min(rh - 1, Math.max(0, y)) * rw + Math.min(rw - 1, Math.max(0, x))];
-  const data = pixels.data;
-  const colOf = new Int32Array(RW);
-  const fxOf = new Float32Array(RW);
-  for (let X = 0; X < RW; X++) {
-    const u = (X0 + X + 0.5) * scale - 0.5 - rx;
-    colOf[X] = Math.floor(u);
-    fxOf[X] = u - colOf[X];
-  }
-  const cellState = (i, j) => {
-    const a = at(i, j), b = at(i + 1, j), c = at(i, j + 1), d = at(i + 1, j + 1);
-    if (a === 1 && b === 1 && c === 1 && d === 1) return 1;
-    if (a === 0 && b === 0 && c === 0 && d === 0) return 0;
-    return 2;
-  };
-  for (let Y = 0; Y < RH; Y++) {
-    const v = (Y0 + Y + 0.5) * scale - 0.5 - ry;
-    const j = Math.floor(v);
-    const fy = v - j;
-    for (let X = 0; X < RW; X++) {
-      const i = colOf[X];
-      const state = cellState(i, j);
-      if (state !== 2) {
-        let end = X + 1;
-        while (end < RW && colOf[end] === i) end++;
-        if (state === 1) out.fill(255, Y * RW + X, Y * RW + end);
-        X = end - 1;
-        continue;
-      }
-      const fx = fxOf[X];
-      const m = (at(i, j) * (1 - fx) + at(i + 1, j) * fx) * (1 - fy) + (at(i, j + 1) * (1 - fx) + at(i + 1, j + 1) * fx) * fy;
-      if (m <= 1e-3 || m >= 0.999) {
-        out[Y * RW + X] = m >= 0.999 ? 255 : 0;
-        continue;
-      }
-      let fr = 0, fg = 0, fb = 0, fn = 0, br = 0, bg = 0, bb = 0, bn = 0;
-      for (let jj = j - 1; jj <= j + 2; jj++) {
-        for (let ii = i - 1; ii <= i + 2; ii++) {
-          if (ii < 0 || jj < 0 || ii >= rw || jj >= rh) continue;
-          const k = ((ry + jj) * ww + rx + ii) * 3;
-          if (soft[jj * rw + ii] >= 0.5) {
-            fr += rgb[k];
-            fg += rgb[k + 1];
-            fb += rgb[k + 2];
-            fn++;
-          } else {
-            br += rgb[k];
-            bg += rgb[k + 1];
-            bb += rgb[k + 2];
-            bn++;
-          }
-        }
-      }
-      let alpha = m;
-      if (fn && bn) {
-        fr /= fn;
-        fg /= fn;
-        fb /= fn;
-        br /= bn;
-        bg /= bn;
-        bb /= bn;
-        const dr = fr - br, dg = fg - bg, db = fb - bb;
-        const len2 = dr * dr + dg * dg + db * db;
-        if (len2 > 400) {
-          const p = ((Y0 + Y) * W + X0 + X) * 4;
-          const a = data[p + 3] / 255;
-          const cr = data[p] * a + 255 * (1 - a) - br;
-          const cg = data[p + 1] * a + 255 * (1 - a) - bg;
-          const cb = data[p + 2] * a + 255 * (1 - a) - bb;
-          const proj = Math.min(1, Math.max(0, (cr * dr + cg * dg + cb * db) / len2));
-          alpha = Math.min(1, Math.max(0, proj * 0.75 + m * 0.25));
-        } else alpha = Math.min(1, Math.max(0, (m - 0.5) * 2 + 0.5));
-      }
-      out[Y * RW + X] = Math.round(alpha * 255);
-    }
-  }
-  return _chunkUYXL6ZWQcjs.selectionFromRegion.call(void 0, W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
-}
 function quickSelectStroke(pixels, stroke, options = {}) {
   if (!stroke.length) throw new Error("A stroke needs at least one point.");
   const work = workImage(pixels);
@@ -3386,6 +3395,283 @@ function quickSelectStroke(pixels, stroke, options = {}) {
   return upscaleRegion(work, pixels, done, label, _nullishCoalesce(options.enhanceEdge, () => ( false)));
 }
 
+// src/image-editor/selection/segment/grabcut.ts
+var K = 5;
+var ColorGmm = (_class6 = class {constructor() { _class6.prototype.__init34.call(this);_class6.prototype.__init35.call(this);_class6.prototype.__init36.call(this);_class6.prototype.__init37.call(this); }
+  __init34() {this.logWeight = new Float64Array(K)}
+  __init35() {this.mean = new Float64Array(K * 3)}
+  /** Inverse covariances, row-major 3 × 3. */
+  __init36() {this.inv = new Float64Array(K * 9)}
+  /** ln(weight) − ½ ln((2π)³ |Σ|) per component; −∞ for an empty one. */
+  __init37() {this.logNorm = new Float64Array(K).fill(-Infinity)}
+  /** Fits the components to the pixels `ids` of `rgb`, each in component `comp[id]`. */
+  fit(rgb, ids, comp) {
+    const n = new Float64Array(K);
+    const sum = new Float64Array(K * 3);
+    const prod = new Float64Array(K * 9);
+    for (let t = 0; t < ids.length; t++) {
+      const i = ids[t];
+      const k = comp[i];
+      const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
+      n[k]++;
+      for (let a = 0; a < 3; a++) {
+        sum[k * 3 + a] += c[a];
+        for (let b = 0; b < 3; b++) prod[k * 9 + a * 3 + b] += c[a] * c[b];
+      }
+    }
+    const total = ids.length || 1;
+    for (let k = 0; k < K; k++) {
+      if (!n[k]) {
+        this.logNorm[k] = -Infinity;
+        continue;
+      }
+      const m = [sum[k * 3] / n[k], sum[k * 3 + 1] / n[k], sum[k * 3 + 2] / n[k]];
+      const cov = new Float64Array(9);
+      for (let a = 0; a < 3; a++) {
+        for (let b = 0; b < 3; b++) cov[a * 3 + b] = prod[k * 9 + a * 3 + b] / n[k] - m[a] * m[b];
+        cov[a * 4] += 4;
+      }
+      const det = cov[0] * (cov[4] * cov[8] - cov[5] * cov[7]) - cov[1] * (cov[3] * cov[8] - cov[5] * cov[6]) + cov[2] * (cov[3] * cov[7] - cov[4] * cov[6]);
+      const d = Math.max(det, 1e-6);
+      const inv = [
+        (cov[4] * cov[8] - cov[5] * cov[7]) / d,
+        (cov[2] * cov[7] - cov[1] * cov[8]) / d,
+        (cov[1] * cov[5] - cov[2] * cov[4]) / d,
+        (cov[5] * cov[6] - cov[3] * cov[8]) / d,
+        (cov[0] * cov[8] - cov[2] * cov[6]) / d,
+        (cov[2] * cov[3] - cov[0] * cov[5]) / d,
+        (cov[3] * cov[7] - cov[4] * cov[6]) / d,
+        (cov[1] * cov[6] - cov[0] * cov[7]) / d,
+        (cov[0] * cov[4] - cov[1] * cov[3]) / d
+      ];
+      this.mean.set(m, k * 3);
+      this.inv.set(inv, k * 9);
+      this.logWeight[k] = Math.log(n[k] / total);
+      this.logNorm[k] = this.logWeight[k] - 0.5 * Math.log(Math.pow(2 * Math.PI, 3) * d);
+    }
+  }
+  /** ln p(colour | component k), up to the shared constant. */
+  componentLog(k, r, g, b) {
+    const ln = this.logNorm[k];
+    if (ln === -Infinity) return -Infinity;
+    const dr = r - this.mean[k * 3];
+    const dg = g - this.mean[k * 3 + 1];
+    const db = b - this.mean[k * 3 + 2];
+    const v = this.inv;
+    const o = k * 9;
+    const q = dr * (v[o] * dr + v[o + 1] * dg + v[o + 2] * db) + dg * (v[o + 3] * dr + v[o + 4] * dg + v[o + 5] * db) + db * (v[o + 6] * dr + v[o + 7] * dg + v[o + 8] * db);
+    return ln - 0.5 * q;
+  }
+  /** −ln p(colour) under the mixture (large for colours the model hasn't seen). */
+  cost(r, g, b) {
+    let best = -Infinity;
+    const logs = new Array(K);
+    for (let k = 0; k < K; k++) {
+      logs[k] = this.componentLog(k, r, g, b);
+      if (logs[k] > best) best = logs[k];
+    }
+    if (best === -Infinity) return 50;
+    let s = 0;
+    for (let k = 0; k < K; k++) if (logs[k] > -Infinity) s += Math.exp(logs[k] - best);
+    return Math.min(50, -(best + Math.log(s)));
+  }
+  /** The component most likely to have produced the colour. */
+  nearest(r, g, b) {
+    let best = 0;
+    let bestLog = -Infinity;
+    for (let k = 0; k < K; k++) {
+      const l = this.componentLog(k, r, g, b);
+      if (l > bestLog) {
+        bestLog = l;
+        best = k;
+      }
+    }
+    return best;
+  }
+}, _class6);
+function initialComponents(rgb, ids, comp) {
+  if (!ids.length) return;
+  const step = Math.max(1, Math.floor(ids.length / 6e3));
+  const sample = [];
+  for (let t = 0; t < ids.length; t += step) sample.push(ids[t]);
+  const centres = [];
+  const dist2 = (i, c) => (rgb[i * 3] - c[0]) ** 2 + (rgb[i * 3 + 1] - c[1]) ** 2 + (rgb[i * 3 + 2] - c[2]) ** 2;
+  centres.push([rgb[sample[0] * 3], rgb[sample[0] * 3 + 1], rgb[sample[0] * 3 + 2]]);
+  const near = sample.map((i) => dist2(i, centres[0]));
+  while (centres.length < K) {
+    let far = 0;
+    for (let t = 1; t < sample.length; t++) if (near[t] > near[far]) far = t;
+    const i = sample[far];
+    const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
+    centres.push(c);
+    for (let t = 0; t < sample.length; t++) near[t] = Math.min(near[t], dist2(sample[t], c));
+  }
+  const closest = (i) => {
+    let best = 0;
+    for (let k = 1; k < K; k++) if (dist2(i, centres[k]) < dist2(i, centres[best])) best = k;
+    return best;
+  };
+  for (let round6 = 0; round6 < 6; round6++) {
+    const sum = Array.from({ length: K }, () => [0, 0, 0, 0]);
+    for (const i of sample) {
+      const s = sum[closest(i)];
+      s[0] += rgb[i * 3];
+      s[1] += rgb[i * 3 + 1];
+      s[2] += rgb[i * 3 + 2];
+      s[3]++;
+    }
+    for (let k = 0; k < K; k++) if (sum[k][3]) centres[k] = [sum[k][0] / sum[k][3], sum[k][1] / sum[k][3], sum[k][2] / sum[k][3]];
+  }
+  for (const i of ids) comp[i] = closest(i);
+}
+function grabCutLabels(work, setup, iterations) {
+  const { width: w, rgb } = work;
+  const { roi, hardBg, hardFg } = setup;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  const n = rw * rh;
+  const label = setup.initial.slice();
+  const global = new Int32Array(n);
+  for (let y = 0; y < rh; y++) for (let x = 0; x < rw; x++) global[y * rw + x] = (ry + y) * w + rx + x;
+  const comp = new Uint8Array(w * work.height);
+  const fg = new ColorGmm();
+  const bg = new ColorGmm();
+  const { right, down } = smoothnessWeights(work, roi);
+  const HARD = 1e9;
+  for (let iter = 0; iter < iterations; iter++) {
+    const fgIds = [];
+    const bgIds = [];
+    for (let p = 0; p < n; p++) (label[p] ? fgIds : bgIds).push(global[p]);
+    if (!fgIds.length) return label;
+    if (iter === 0) {
+      initialComponents(rgb, fgIds, comp);
+      initialComponents(rgb, bgIds, comp);
+    } else {
+      for (const i of fgIds) comp[i] = fg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+      for (const i of bgIds) comp[i] = bg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+    }
+    fg.fit(rgb, fgIds, comp);
+    bg.fit(rgb, bgIds, comp);
+    const graph = new GridGraph(rw, rh);
+    for (let p = 0; p < n; p++) {
+      if (hardBg[p]) graph.addTerminal(p, 0, HARD);
+      else if (_optionalChain([hardFg, 'optionalAccess', _66 => _66[p]])) graph.addTerminal(p, HARD, 0);
+      else {
+        const i = global[p] * 3;
+        graph.addTerminal(p, Math.round(bg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS), Math.round(fg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS));
+      }
+      if (p % rw + 1 < rw) graph.setEdge(p, 0, right[p]);
+      if (p + rw < n) graph.setEdge(p, 1, down[p]);
+    }
+    graph.maxflow();
+    let changed = 0;
+    for (let p = 0; p < n; p++) {
+      const v = graph.inSource(p) ? 1 : 0;
+      if (v !== label[p]) changed++;
+      label[p] = v;
+    }
+    if (changed <= n * 1e-3) break;
+  }
+  return label;
+}
+function keepMainPieces(label, rw, rh, seed) {
+  const n = rw * rh;
+  const piece = new Int32Array(n).fill(-1);
+  const sizes = [];
+  const stack = [];
+  for (let s = 0; s < n; s++) {
+    if (!label[s] || piece[s] >= 0) continue;
+    const id = sizes.length;
+    let size = 0;
+    piece[s] = id;
+    stack.push(s);
+    while (stack.length) {
+      const p = stack.pop();
+      size++;
+      const x = p % rw;
+      for (const q of [x + 1 < rw ? p + 1 : -1, x > 0 ? p - 1 : -1, p + rw < n ? p + rw : -1, p - rw]) {
+        if (q >= 0 && label[q] && piece[q] < 0) {
+          piece[q] = id;
+          stack.push(q);
+        }
+      }
+    }
+    sizes.push(size);
+  }
+  if (!sizes.length) return;
+  const largest = Math.max(...sizes);
+  const keep = (id) => seed !== null && piece[seed] >= 0 ? id === piece[seed] : sizes[id] * 5 >= largest;
+  for (let p = 0; p < n; p++) if (label[p] && !keep(piece[p])) label[p] = 0;
+}
+function selectObjectIn(pixels, target, options = {}) {
+  const work = workImage(pixels);
+  const { width: w, height: h, scale } = work;
+  const iterations = Math.max(1, Math.round(_nullishCoalesce(options.iterations, () => ( 5))));
+  const enhance = _nullishCoalesce(options.enhanceEdge, () => ( false));
+  if ("rect" in target) {
+    const r = target.rect;
+    const bx0 = Math.max(0, Math.floor(r.x * scale));
+    const by0 = Math.max(0, Math.floor(r.y * scale));
+    const bx1 = Math.min(w, Math.ceil((r.x + r.width) * scale));
+    const by1 = Math.min(h, Math.ceil((r.y + r.height) * scale));
+    if (bx1 - bx0 < 2 || by1 - by0 < 2) return _chunkUYXL6ZWQcjs.createSelectionMask.call(void 0, pixels.width, pixels.height);
+    const m = Math.max(8, Math.round(0.25 * Math.max(bx1 - bx0, by1 - by0)));
+    const rx = Math.max(0, bx0 - m);
+    const ry = Math.max(0, by0 - m);
+    const roi = { x: rx, y: ry, width: Math.min(w, bx1 + m) - rx, height: Math.min(h, by1 + m) - ry };
+    const n = roi.width * roi.height;
+    const initial = new Uint8Array(n);
+    const hardBg = new Uint8Array(n);
+    for (let y = 0; y < roi.height; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        const gx = rx + x;
+        const gy = ry + y;
+        const inside = gx >= bx0 && gx < bx1 && gy >= by0 && gy < by1;
+        initial[y * roi.width + x] = inside ? 1 : 0;
+        hardBg[y * roi.width + x] = inside ? 0 : 1;
+      }
+    }
+    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg: null }, iterations);
+    keepMainPieces(label, roi.width, roi.height, null);
+    return upscaleRegion(work, pixels, roi, label, enhance);
+  }
+  const px2 = Math.min(w - 1, Math.max(0, Math.floor(target.point.x * scale)));
+  const py = Math.min(h - 1, Math.max(0, Math.floor(target.point.y * scale)));
+  let half = Math.max(24, Math.round(0.3 * Math.max(w, h)));
+  for (; ; ) {
+    const rx = Math.max(0, px2 - half);
+    const ry = Math.max(0, py - half);
+    const roi = { x: rx, y: ry, width: Math.min(w, px2 + half + 1) - rx, height: Math.min(h, py + half + 1) - ry };
+    const whole = roi.width === w && roi.height === h;
+    const band = Math.max(4, Math.round(0.15 * half));
+    const n = roi.width * roi.height;
+    const initial = new Uint8Array(n);
+    const hardBg = new Uint8Array(n);
+    const hardFg = new Uint8Array(n);
+    const inBand = (x, y) => rx > 0 && x < band || ry > 0 && y < band || rx + roi.width < w && x >= roi.width - band || ry + roi.height < h && y >= roi.height - band;
+    for (let y = 0; y < roi.height; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        const p = y * roi.width + x;
+        if (inBand(x, y)) hardBg[p] = 1;
+        else initial[p] = 1;
+        if (Math.hypot(rx + x - px2, ry + y - py) <= 1.5) hardFg[p] = 1;
+      }
+    }
+    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, iterations);
+    keepMainPieces(label, roi.width, roi.height, (py - ry) * roi.width + (px2 - rx));
+    let touches = false;
+    for (let y = 0; y < roi.height && !touches; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        if (label[y * roi.width + x] && (inBand(x - 1, y) || inBand(x + 1, y) || inBand(x, y - 1) || inBand(x, y + 1))) {
+          touches = true;
+          break;
+        }
+      }
+    }
+    if (!touches || whole) return upscaleRegion(work, pixels, roi, label, enhance);
+    half = Math.round(half * 1.6);
+  }
+}
+
 // src/image-editor/layers/shape-type-ui.ts
 var DEFAULT_SHAPE_TOOL_OPTIONS = {
   kind: "rect",
@@ -3444,16 +3730,16 @@ function liveShapeForDrag(o, a, b, mods = {}) {
   }
   return null;
 }
-var ShapeDrawGesture = (_class6 = class {
-  constructor(controller, options) {;_class6.prototype.__init34.call(this);_class6.prototype.__init35.call(this);_class6.prototype.__init36.call(this);
+var ShapeDrawGesture = (_class7 = class {
+  constructor(controller, options) {;_class7.prototype.__init38.call(this);_class7.prototype.__init39.call(this);_class7.prototype.__init40.call(this);
     this.controller = controller;
     this.options = options;
   }
   
   
-  __init34() {this.start = null}
-  __init35() {this.layerId = null}
-  __init36() {this.error = null}
+  __init38() {this.start = null}
+  __init39() {this.layerId = null}
+  __init40() {this.error = null}
   get active() {
     return this.start !== null;
   }
@@ -3492,17 +3778,17 @@ var ShapeDrawGesture = (_class6 = class {
   cancel() {
     this.start = null;
   }
-}, _class6);
+}, _class7);
 function applyShapeOptions(controller, layerId, change) {
   const info = controller.getShapeLayer(layerId);
   const style = {};
   if ("fill" in change) style.fill = _nullishCoalesce(change.fill, () => ( null));
   if ("stroke" in change || "strokeWidth" in change) {
-    const color = "stroke" in change ? change.stroke : _optionalChain([info, 'access', _66 => _66.stroke, 'optionalAccess', _67 => _67.paint, 'access', _68 => _68.type]) === "color" ? info.stroke.paint.color : null;
-    style.stroke = color ? { width: _nullishCoalesce(_nullishCoalesce(change.strokeWidth, () => ( _optionalChain([info, 'access', _69 => _69.stroke, 'optionalAccess', _70 => _70.width]))), () => ( 2)), paint: color } : null;
+    const color = "stroke" in change ? change.stroke : _optionalChain([info, 'access', _67 => _67.stroke, 'optionalAccess', _68 => _68.paint, 'access', _69 => _69.type]) === "color" ? info.stroke.paint.color : null;
+    style.stroke = color ? { width: _nullishCoalesce(_nullishCoalesce(change.strokeWidth, () => ( _optionalChain([info, 'access', _70 => _70.stroke, 'optionalAccess', _71 => _71.width]))), () => ( 2)), paint: color } : null;
   }
   if (Object.keys(style).length) controller.setShapeStyle(layerId, style);
-  const live = _optionalChain([info, 'access', _71 => _71.components, 'access', _72 => _72[0], 'optionalAccess', _73 => _73.live]);
+  const live = _optionalChain([info, 'access', _72 => _72.components, 'access', _73 => _73[0], 'optionalAccess', _74 => _74.live]);
   if (!live) return;
   const shape = {};
   if (live.kind === "rect" && change.radius !== void 0) shape.radius = change.radius;
@@ -3513,8 +3799,8 @@ function applyShapeOptions(controller, layerId, change) {
   if (live.kind === "line" && change.arrow !== void 0) shape.endArrow = change.arrow ? { width: (live.weight || 1) * 4, length: (live.weight || 1) * 4 } : null;
   if (Object.keys(shape).length) controller.setShapeComponent(layerId, 0, { shape });
 }
-var TextEditSession = (_class7 = class {
-  constructor(controller, layerId, index) {;_class7.prototype.__init37.call(this);_class7.prototype.__init38.call(this);_class7.prototype.__init39.call(this);
+var TextEditSession = (_class8 = class {
+  constructor(controller, layerId, index) {;_class8.prototype.__init41.call(this);_class8.prototype.__init42.call(this);_class8.prototype.__init43.call(this);
     this.controller = controller;
     this.layerId = layerId;
     const n = this.text.length;
@@ -3524,11 +3810,11 @@ var TextEditSession = (_class7 = class {
   
   
   
-  __init37() {this.changed = false}
-  __init38() {this.listeners = /* @__PURE__ */ new Set()}
-  __init39() {this.error = null}
+  __init41() {this.changed = false}
+  __init42() {this.listeners = /* @__PURE__ */ new Set()}
+  __init43() {this.error = null}
   get layer() {
-    const l = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.controller.getLayers(), this.layerId), 'optionalAccess', _74 => _74.layer]);
+    const l = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.controller.getLayers(), this.layerId), 'optionalAccess', _75 => _75.layer]);
     if (!l || l.type !== "type") throw new Error("The type layer being edited is gone.");
     return l;
   }
@@ -3543,7 +3829,7 @@ var TextEditSession = (_class7 = class {
   }
   /** Whether the layer still exists (it can be deleted or undone away while editing). */
   get alive() {
-    return _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.controller.getLayers(), this.layerId), 'optionalAccess', _75 => _75.layer, 'access', _76 => _76.type]) === "type";
+    return _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.controller.getLayers(), this.layerId), 'optionalAccess', _76 => _76.layer, 'access', _77 => _77.type]) === "type";
   }
   subscribe(fn) {
     this.listeners.add(fn);
@@ -3741,7 +4027,7 @@ var TextEditSession = (_class7 = class {
     }
     return true;
   }
-}, _class7);
+}, _class8);
 function typeLayerAt(controller, p, slop = 4) {
   const layers = [...flattenTypeLayers(controller.getLayers())].reverse();
   for (const l of layers) {
@@ -3774,16 +4060,16 @@ function invert(m) {
   const det = a * d - b * c || 1;
   return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
 }
-var TypeToolGesture = (_class8 = class {
-  constructor(controller, options) {;_class8.prototype.__init40.call(this);_class8.prototype.__init41.call(this);_class8.prototype.__init42.call(this);
+var TypeToolGesture = (_class9 = class {
+  constructor(controller, options) {;_class9.prototype.__init44.call(this);_class9.prototype.__init45.call(this);_class9.prototype.__init46.call(this);
     this.controller = controller;
     this.options = options;
   }
   
   
-  __init40() {this.session = null}
-  __init41() {this.dragStart = null}
-  __init42() {this.error = null}
+  __init44() {this.session = null}
+  __init45() {this.dragStart = null}
+  __init46() {this.error = null}
   down(p, mods = {}) {
     this.error = null;
     const hit = typeLayerAt(this.controller, p);
@@ -3831,9 +4117,9 @@ var TypeToolGesture = (_class8 = class {
   finish() {
     const s = this.session;
     this.session = null;
-    _optionalChain([s, 'optionalAccess', _77 => _77.close, 'call', _78 => _78()]);
+    _optionalChain([s, 'optionalAccess', _78 => _78.close, 'call', _79 => _79()]);
   }
-}, _class8);
+}, _class9);
 
 // src/image-editor/selection/shapes.ts
 function polygonCoverage(points, width, height, antiAlias = true) {
@@ -4300,7 +4586,7 @@ function segmentToSelection(width, height, result) {
     const sized = raw.width === width && raw.height === height ? raw : _chunkUYXL6ZWQcjs.resizeSelection.call(void 0, raw, width, height);
     out = _chunkUYXL6ZWQcjs.combineSelections.call(void 0, out, sized, "add");
   }
-  return _optionalChain([out, 'optionalAccess', _79 => _79.bounds]) ? out : null;
+  return _optionalChain([out, 'optionalAccess', _80 => _80.bounds]) ? out : null;
 }
 function segmentsToSelection(width, height, results) {
   let out = null;
@@ -4581,7 +4867,7 @@ function deserializeChannels(value, size, problems = []) {
         visible: v.visible === true
       });
     } catch (err) {
-      problems.push(`Alpha channel "${String(_nullishCoalesce(_optionalChain([v, 'optionalAccess', _80 => _80.name]), () => ( "?")))}" could not be read: ${err instanceof Error ? err.message : String(err)}.`);
+      problems.push(`Alpha channel "${String(_nullishCoalesce(_optionalChain([v, 'optionalAccess', _81 => _81.name]), () => ( "?")))}" could not be read: ${err instanceof Error ? err.message : String(err)}.`);
     }
   }
   return out;
@@ -4619,16 +4905,16 @@ function checkEffectTime(time) {
   return time;
 }
 function checkEffectAnimation(animate) {
-  const duration = _optionalChain([animate, 'optionalAccess', _81 => _81.duration]);
+  const duration = _optionalChain([animate, 'optionalAccess', _82 => _82.duration]);
   if (!(typeof duration === "number" && Number.isFinite(duration) && duration > 0 && duration <= _chunkUYXL6ZWQcjs.MAX_EFFECT_ANIMATION_MS)) {
     throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`animate.duration must be more than 0 and at most ${_chunkUYXL6ZWQcjs.MAX_EFFECT_ANIMATION_MS} ms.`);
   }
   return { duration: Math.round(duration) };
 }
 function effectLayerTiming(g, d) {
-  if (!_optionalChain([d, 'optionalAccess', _82 => _82.duration])) return null;
+  if (!_optionalChain([d, 'optionalAccess', _83 => _83.duration])) return null;
   const time = _nullishCoalesce(g.time, () => ( 0));
-  return { mode: g.animate ? "animate" : "still", time, range: Math.max(d.duration, time), duration: _nullishCoalesce(_optionalChain([g, 'access', _83 => _83.animate, 'optionalAccess', _84 => _84.duration]), () => ( d.duration)), loops: d.loop };
+  return { mode: g.animate ? "animate" : "still", time, range: Math.max(d.duration, time), duration: _nullishCoalesce(_optionalChain([g, 'access', _84 => _84.animate, 'optionalAccess', _85 => _85.duration]), () => ( d.duration)), loops: d.loop };
 }
 
 // src/image-editor/effects.ts
@@ -4673,18 +4959,18 @@ function effectPixelsToSurface(p, depth) {
   }
   return _chunkCWM3CUUXcjs.surfaceFromDeepPixels.call(void 0, { width: p.width, height: p.height, data: d }, 4);
 }
-var ImageEffectsEngine = (_class9 = class {
+var ImageEffectsEngine = (_class10 = class {
   
-  __init43() {this.cache = /* @__PURE__ */ new Map()}
-  __init44() {this.pending = /* @__PURE__ */ new Map()}
-  __init45() {this.failures = /* @__PURE__ */ new Map()}
+  __init47() {this.cache = /* @__PURE__ */ new Map()}
+  __init48() {this.pending = /* @__PURE__ */ new Map()}
+  __init49() {this.failures = /* @__PURE__ */ new Map()}
   
-  __init46() {this.descriptions = /* @__PURE__ */ new Map()}
-  __init47() {this.listeners = /* @__PURE__ */ new Set()}
+  __init50() {this.descriptions = /* @__PURE__ */ new Map()}
+  __init51() {this.listeners = /* @__PURE__ */ new Set()}
   
-  __init48() {this.generation = 0}
+  __init52() {this.generation = 0}
   
-  constructor(options = {}) {;_class9.prototype.__init43.call(this);_class9.prototype.__init44.call(this);_class9.prototype.__init45.call(this);_class9.prototype.__init46.call(this);_class9.prototype.__init47.call(this);_class9.prototype.__init48.call(this);
+  constructor(options = {}) {;_class10.prototype.__init47.call(this);_class10.prototype.__init48.call(this);_class10.prototype.__init49.call(this);_class10.prototype.__init50.call(this);_class10.prototype.__init51.call(this);_class10.prototype.__init52.call(this);
     this.slot = _nullishCoalesce(options.slot, () => ( new (0, _chunkA3A5TI6Rcjs.EffectsSlot)()));
     this.maxEntries = _nullishCoalesce(options.maxEntries, () => ( 24));
     this.pool = new (0, _chunkPY4GWSE2cjs.EffectRendererPool)({ maxRenderers: options.maxRenderers });
@@ -4793,7 +5079,7 @@ var ImageEffectsEngine = (_class9 = class {
     this.detach();
     this.listeners.clear();
   }
-}, _class9);
+}, _class10);
 
 // src/image-editor/free-transform.ts
 var FREE_TRANSFORM_CONTENTS = ["auto", "layer", "selection", "selection-copy", "selection-outline"];
@@ -4875,20 +5161,20 @@ function liftMask(mask, sel, o) {
   }
   return { lifted: _chunkCWM3CUUXcjs.surfaceFromPixels.call(void 0, { width: area.width, height: area.height, data: lifted }, 4, area.x, area.y), rest: _chunkCWM3CUUXcjs.writeRegion.call(void 0, mask, area, rest) };
 }
-var FreeTransformSession = (_class10 = class {
-  constructor(host, init = {}) {;_class10.prototype.__init49.call(this);_class10.prototype.__init50.call(this);_class10.prototype.__init51.call(this);_class10.prototype.__init52.call(this);_class10.prototype.__init53.call(this);_class10.prototype.__init54.call(this);_class10.prototype.__init55.call(this);_class10.prototype.__init56.call(this);_class10.prototype.__init57.call(this);_class10.prototype.__init58.call(this);_class10.prototype.__init59.call(this);
+var FreeTransformSession = (_class11 = class {
+  constructor(host, init = {}) {;_class11.prototype.__init53.call(this);_class11.prototype.__init54.call(this);_class11.prototype.__init55.call(this);_class11.prototype.__init56.call(this);_class11.prototype.__init57.call(this);_class11.prototype.__init58.call(this);_class11.prototype.__init59.call(this);_class11.prototype.__init60.call(this);_class11.prototype.__init61.call(this);_class11.prototype.__init62.call(this);_class11.prototype.__init63.call(this);
     this.host = host;
     if (init.interpolation !== void 0 && !_chunkHGTDMKNEcjs.isInterpolation.call(void 0, init.interpolation)) fail(`Unknown interpolation "${String(init.interpolation)}"; use nearest, bilinear or bicubic.`);
     this.interp = _nullishCoalesce(init.interpolation, () => ( "bicubic"));
     const sel = host.selection();
-    const selected = Boolean(_optionalChain([sel, 'optionalAccess', _85 => _85.bounds]));
+    const selected = Boolean(_optionalChain([sel, 'optionalAccess', _86 => _86.bounds]));
     let content = _nullishCoalesce(init.content, () => ( "auto"));
     if (!["auto", "layer", "selection", "selection-copy", "selection-outline"].includes(content)) {
       fail(`Unknown content "${String(content)}"; use auto, layer, selection, selection-copy or selection-outline.`);
     }
     const targetId = _nullishCoalesce(init.layerId, () => ( host.activeLayerId()));
-    const target = targetId && content !== "selection-outline" ? _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, host.layers(), targetId), 'optionalAccess', _86 => _86.layer]) : void 0;
-    const smartTarget = (_optionalChain([target, 'optionalAccess', _87 => _87.type]) === "smart" || _optionalChain([target, 'optionalAccess', _88 => _88.type]) === "shape" || _optionalChain([target, 'optionalAccess', _89 => _89.type]) === "type") && (_nullishCoalesce(init.channel, () => ( (target.id === host.activeLayerId() ? host.activeTarget() : "pixels")))) !== "mask";
+    const target = targetId && content !== "selection-outline" ? _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, host.layers(), targetId), 'optionalAccess', _87 => _87.layer]) : void 0;
+    const smartTarget = (_optionalChain([target, 'optionalAccess', _88 => _88.type]) === "smart" || _optionalChain([target, 'optionalAccess', _89 => _89.type]) === "shape" || _optionalChain([target, 'optionalAccess', _90 => _90.type]) === "type") && (_nullishCoalesce(init.channel, () => ( (target.id === host.activeLayerId() ? host.activeTarget() : "pixels")))) !== "mask";
     if (content === "auto") content = selected && !smartTarget ? "selection" : "layer";
     this.content = content;
     if (content !== "layer" && !selected) fail(`Nothing is selected; ${content} needs a selection. Select first, or use content layer.`);
@@ -4912,9 +5198,9 @@ var FreeTransformSession = (_class10 = class {
       const mask = layer.mask && !layer.mask.source ? layer.mask : void 0;
       const channel = _nullishCoalesce(init.channel, () => ( (layer.id === host.activeLayerId() ? host.activeTarget() : "pixels")));
       if (channel !== "pixels" && channel !== "mask") fail(`Unknown channel "${String(channel)}"; use pixels or mask.`);
-      const linked = _optionalChain([mask, 'optionalAccess', _90 => _90.linked]) !== false;
+      const linked = _optionalChain([mask, 'optionalAccess', _91 => _91.linked]) !== false;
       const maskAlone = channel === "mask" && (!linked || layer.type !== "pixel");
-      if (channel === "mask" && !mask) fail(_optionalChain([layer, 'access', _91 => _91.mask, 'optionalAccess', _92 => _92.source]) ? `Layer "${layer.name || id}" has a depth mask, which is generated, not transformed.` : `Layer "${layer.name || id}" has no mask to transform; add one with add_layer_mask, or transform its pixels.`);
+      if (channel === "mask" && !mask) fail(_optionalChain([layer, 'access', _92 => _92.mask, 'optionalAccess', _93 => _93.source]) ? `Layer "${layer.name || id}" has a depth mask, which is generated, not transformed.` : `Layer "${layer.name || id}" has no mask to transform; add one with add_layer_mask, or transform its pixels.`);
       if (!maskAlone && layer.type !== "pixel" && layer.type !== "smart" && layer.type !== "shape" && layer.type !== "type") fail(`Layer "${layer.name || id}" is a ${layer.type} layer; Free Transform works on pixel, shape, type and smart object layers, layer masks (channel mask) and selections.`);
       if (!layer.visible && content !== "selection-copy") fail(`Layer "${layer.name || id}" is hidden; show it before you transform it.`);
       if (content !== "selection-copy") {
@@ -5017,7 +5303,7 @@ var FreeTransformSession = (_class10 = class {
           };
           this.copyId = copy.id;
           const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, layers, layer.id);
-          this.startLayers = _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, copy, _nullishCoalesce(_optionalChain([loc, 'access', _93 => _93.parent, 'optionalAccess', _94 => _94.id]), () => ( null)), loc.index + 1);
+          this.startLayers = _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, copy, _nullishCoalesce(_optionalChain([loc, 'access', _94 => _94.parent, 'optionalAccess', _95 => _95.id]), () => ( null)), loc.index + 1);
           this.parts.push({ what: "pixels", offset: o, moving: lifted, base: null, reduced: /* @__PURE__ */ new Map() });
           moves.push("pixels");
         }
@@ -5043,7 +5329,7 @@ var FreeTransformSession = (_class10 = class {
   /** The layer being transformed (`null` for `selection-outline`). */
   
   /** The new layer of a `selection-copy`. */
-  __init49() {this.copyId = null}
+  __init53() {this.copyId = null}
   /** The frame (document pixels). */
   
   /** What moves. */
@@ -5055,27 +5341,27 @@ var FreeTransformSession = (_class10 = class {
    */
   
   /** True when the layer is a smart object (the transform sets its placement). */
-  __init50() {this.smartObject = false}
+  __init54() {this.smartObject = false}
   /** True when the layer is a shape layer (the transform maps its paths and renders them again). */
-  __init51() {this.shapeLayer = false}
-  __init52() {this.shape = null}
+  __init55() {this.shapeLayer = false}
+  __init56() {this.shape = null}
   /** True when the layer is a type layer (the transform sets its text matrix; affine only). */
-  __init53() {this.typeLayer = false}
-  __init54() {this.typeTarget = null}
+  __init57() {this.typeLayer = false}
+  __init58() {this.typeTarget = null}
   
-  __init55() {this.smart = null}
-  __init56() {this.smartReduced = /* @__PURE__ */ new Map()}
+  __init59() {this.smart = null}
+  __init60() {this.smartReduced = /* @__PURE__ */ new Map()}
   
-  __init57() {this.smartMasksMoved = false}
+  __init61() {this.smartMasksMoved = false}
   
-  __init58() {this.parts = []}
+  __init62() {this.parts = []}
   
   
   
   
   /** The stack this session last showed: anything else means the document changed under it. */
   
-  __init59() {this.closed = false}
+  __init63() {this.closed = false}
   /** The current geometry. */
   get geometry() {
     return this.geometryValue;
@@ -5126,7 +5412,7 @@ var FreeTransformSession = (_class10 = class {
   moveVectorMask(layers) {
     const g = this.geometryValue;
     if (!this.layerId || this.copyId || !this.moves.includes("pixels") || _chunkUYXL6ZWQcjs.isIdentityTransform.call(void 0, g)) return layers;
-    const vm = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, layers, this.layerId), 'optionalAccess', _95 => _95.layer, 'access', _96 => _96.vectorMask]);
+    const vm = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, layers, this.layerId), 'optionalAccess', _96 => _96.layer, 'access', _97 => _97.vectorMask]);
     if (!vm || vm.linked === false) return layers;
     const warp = _chunkUYXL6ZWQcjs.hasWarp.call(void 0, g);
     const f = warp ? _chunkUYXL6ZWQcjs.transformMap.call(void 0, g) : null;
@@ -5297,11 +5583,11 @@ var FreeTransformSession = (_class10 = class {
   result(changed, layers, selection) {
     let bounds = null;
     const id = _nullishCoalesce(this.copyId, () => ( this.layerId));
-    const layer = id ? _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _97 => _97.layer]) : void 0;
-    if (this.moves.includes("pixels") && _optionalChain([layer, 'optionalAccess', _98 => _98.type]) === "pixel") bounds = toDoc(_chunkCWM3CUUXcjs.contentBounds.call(void 0, this.host.pixelsOf(layer)), layer.offset);
-    else if (this.moves.includes("pixels") && (_optionalChain([layer, 'optionalAccess', _99 => _99.type]) === "smart" || _optionalChain([layer, 'optionalAccess', _100 => _100.type]) === "shape" || _optionalChain([layer, 'optionalAccess', _101 => _101.type]) === "type")) bounds = _chunkCWM3CUUXcjs.contentBounds.call(void 0, layer.surface);
-    else if (this.moves.includes("mask") && _optionalChain([layer, 'optionalAccess', _102 => _102.mask])) bounds = toDoc(_chunkCWM3CUUXcjs.contentBounds.call(void 0, layer.mask.surface), layer.type === "pixel" ? layer.offset : { x: 0, y: 0 });
-    else if (this.moves.includes("selection")) bounds = _optionalChain([selection, 'optionalAccess', _103 => _103.bounds]) ? { ...selection.bounds } : null;
+    const layer = id ? _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _98 => _98.layer]) : void 0;
+    if (this.moves.includes("pixels") && _optionalChain([layer, 'optionalAccess', _99 => _99.type]) === "pixel") bounds = toDoc(_chunkCWM3CUUXcjs.contentBounds.call(void 0, this.host.pixelsOf(layer)), layer.offset);
+    else if (this.moves.includes("pixels") && (_optionalChain([layer, 'optionalAccess', _100 => _100.type]) === "smart" || _optionalChain([layer, 'optionalAccess', _101 => _101.type]) === "shape" || _optionalChain([layer, 'optionalAccess', _102 => _102.type]) === "type")) bounds = _chunkCWM3CUUXcjs.contentBounds.call(void 0, layer.surface);
+    else if (this.moves.includes("mask") && _optionalChain([layer, 'optionalAccess', _103 => _103.mask])) bounds = toDoc(_chunkCWM3CUUXcjs.contentBounds.call(void 0, layer.mask.surface), layer.type === "pixel" ? layer.offset : { x: 0, y: 0 });
+    else if (this.moves.includes("selection")) bounds = _optionalChain([selection, 'optionalAccess', _104 => _104.bounds]) ? { ...selection.bounds } : null;
     return {
       layerId: _nullishCoalesce(this.copyId, () => ( this.layerId)),
       content: this.content,
@@ -5312,7 +5598,7 @@ var FreeTransformSession = (_class10 = class {
       changed
     };
   }
-}, _class10);
+}, _class11);
 
 // src/image-editor/color-management.ts
 var DEFAULT_PROOF = { intent: "relative", bpc: true, simulatePaper: false, gamutWarning: false };
@@ -5330,7 +5616,7 @@ function deserializeColorMode(raw, problems) {
 }
 function effectiveProof(proof, mode) {
   if (proof) return proof;
-  if (_optionalChain([mode, 'optionalAccess', _104 => _104.mode]) === "cmyk") return { ...DEFAULT_PROOF, profile: mode.profile, intent: mode.intent };
+  if (_optionalChain([mode, 'optionalAccess', _105 => _105.mode]) === "cmyk") return { ...DEFAULT_PROOF, profile: mode.profile, intent: mode.intent };
   return null;
 }
 function colorModePlanes(doc, mode) {
@@ -5385,7 +5671,7 @@ function resolveProfile(doc) {
   return p;
 }
 function profileBytes(doc) {
-  if (_optionalChain([doc, 'optionalAccess', _105 => _105.icc])) return doc.icc;
+  if (_optionalChain([doc, 'optionalAccess', _106 => _106.icc])) return doc.icc;
   const p = resolveProfile(doc);
   return _nullishCoalesce(p.bytes, () => ( _chunkBROJYMWUcjs.encodeProfile.call(void 0, p)));
 }
@@ -5547,7 +5833,7 @@ function paintCoverageInto(base, coverage, apply, rects, depth = null) {
         else tiles.delete(key);
         continue;
       }
-      const src = _nullishCoalesce(_optionalChain([base, 'access', _106 => _106.tiles, 'access', _107 => _107.get, 'call', _108 => _108(key), 'optionalAccess', _109 => _109.data]), () => ( defaultTile(base)));
+      const src = _nullishCoalesce(_optionalChain([base, 'access', _107 => _107.tiles, 'access', _108 => _108.get, 'call', _109 => _109(key), 'optionalAccess', _110 => _110.data]), () => ( defaultTile(base)));
       const data = _chunkEBDCRTZIcjs.applyStrokeToTile.call(void 0, coverage, src, base.channels, t.tx, t.ty, apply);
       const tile = _chunkCWM3CUUXcjs.finishTile.call(void 0, data, base.channels, base.defaultValue);
       if (tile) tiles.set(key, tile);
@@ -5561,8 +5847,8 @@ function defaultTile(s) {
   if (s.defaultValue) d.fill(s.defaultValue);
   return d;
 }
-var PaintStrokeSession = (_class11 = class {
-  constructor(controller, target, stroke, apply, depth = null) {;_class11.prototype.__init60.call(this);_class11.prototype.__init61.call(this);_class11.prototype.__init62.call(this);_class11.prototype.__init63.call(this);_class11.prototype.__init64.call(this);_class11.prototype.__init65.call(this);_class11.prototype.__init66.call(this);_class11.prototype.__init67.call(this);_class11.prototype.__init68.call(this);_class11.prototype.__init69.call(this);_class11.prototype.__init70.call(this);
+var PaintStrokeSession = (_class12 = class {
+  constructor(controller, target, stroke, apply, depth = null) {;_class12.prototype.__init64.call(this);_class12.prototype.__init65.call(this);_class12.prototype.__init66.call(this);_class12.prototype.__init67.call(this);_class12.prototype.__init68.call(this);_class12.prototype.__init69.call(this);_class12.prototype.__init70.call(this);_class12.prototype.__init71.call(this);_class12.prototype.__init72.call(this);_class12.prototype.__init73.call(this);_class12.prototype.__init74.call(this);
     this.controller = controller;
     this.target = target;
     this.apply = apply;
@@ -5599,28 +5885,28 @@ var PaintStrokeSession = (_class11 = class {
   
   
   
-  __init60() {this.touched = /* @__PURE__ */ new Set()}
+  __init64() {this.touched = /* @__PURE__ */ new Set()}
   
   
-  __init61() {this.mixerInit = null}
-  __init62() {this.retouch = null}
+  __init65() {this.mixerInit = null}
+  __init66() {this.retouch = null}
   /** Writes a mask's RGBA view back (sequential retouching on a mask). */
-  __init63() {this.flushView = null}
-  __init64() {this.started = false}
+  __init67() {this.flushView = null}
+  __init68() {this.started = false}
   /** Mixer tiles written since the last update: they get new tile objects so the compositor sees them change. */
-  __init65() {this.fresh = /* @__PURE__ */ new Set()}
-  __init66() {this.last = null}
-  __init67() {this.closed = false}
+  __init69() {this.fresh = /* @__PURE__ */ new Set()}
+  __init70() {this.last = null}
+  __init71() {this.closed = false}
   /** Brush and eraser strokes on a 16- or 32-bit document: the deep samples of each touched tile. */
   
-  __init68() {this.liveDeep = /* @__PURE__ */ new Map()}
+  __init72() {this.liveDeep = /* @__PURE__ */ new Map()}
   /**
    * Mixer Brush, Smudge and Sponge on a 16- or 32-bit layer: they read and write float working
    * tiles on the 8-bit 0..255 sRGB-encoded scale, which keep the fractions bytes would round away.
    */
   
-  __init69() {this.work = /* @__PURE__ */ new Map()}
-  __init70() {this.workRead = /* @__PURE__ */ new Map()}
+  __init73() {this.work = /* @__PURE__ */ new Map()}
+  __init74() {this.workRead = /* @__PURE__ */ new Map()}
   /** The pre-stroke tile as a float working tile (cached; `null`: transparent). */
   readWork(key) {
     if (!this.workRead.has(key)) this.workRead.set(key, workTileOf(this.base.tiles.get(key)));
@@ -5660,7 +5946,7 @@ var PaintStrokeSession = (_class11 = class {
         writeTile: (tx, ty) => {
           const key = _chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty);
           if (!this.touched.has(key)) {
-            this.work.set(key, _nullishCoalesce(_optionalChain([read, 'call', _110 => _110(key), 'optionalAccess', _111 => _111.slice, 'call', _112 => _112()]), () => ( new Float32Array(_chunkCWM3CUUXcjs.TILE * _chunkCWM3CUUXcjs.TILE * 4))));
+            this.work.set(key, _nullishCoalesce(_optionalChain([read, 'call', _111 => _111(key), 'optionalAccess', _112 => _112.slice, 'call', _113 => _113()]), () => ( new Float32Array(_chunkCWM3CUUXcjs.TILE * _chunkCWM3CUUXcjs.TILE * 4))));
             this.touched.add(key);
           }
           this.fresh.add(key);
@@ -5672,11 +5958,11 @@ var PaintStrokeSession = (_class11 = class {
       offset: a.offset,
       lockTransparency: a.lockTransparency,
       selection: a.selection,
-      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _113 => _113.live, 'access', _114 => _114.get, 'call', _115 => _115(_chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _116 => _116.data]), () => ( (this.base.defaultValue ? defaultTile(this.base) : null))),
+      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _114 => _114.live, 'access', _115 => _115.get, 'call', _116 => _116(_chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _117 => _117.data]), () => ( (this.base.defaultValue ? defaultTile(this.base) : null))),
       writeTile: (tx, ty) => {
         const key = _chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty);
         if (!this.touched.has(key)) {
-          const src = _nullishCoalesce(_optionalChain([this, 'access', _117 => _117.base, 'access', _118 => _118.tiles, 'access', _119 => _119.get, 'call', _120 => _120(key), 'optionalAccess', _121 => _121.data]), () => ( defaultTile(this.base)));
+          const src = _nullishCoalesce(_optionalChain([this, 'access', _118 => _118.base, 'access', _119 => _119.tiles, 'access', _120 => _120.get, 'call', _121 => _121(key), 'optionalAccess', _122 => _122.data]), () => ( defaultTile(this.base)));
           this.live.set(key, { data: new Uint8ClampedArray(src), uniform: null });
           this.touched.add(key);
         }
@@ -5693,11 +5979,11 @@ var PaintStrokeSession = (_class11 = class {
     if (this.closed || !points.length) return;
     if (!this.started) {
       this.started = true;
-      if (_optionalChain([this, 'access', _122 => _122.retouch, 'optionalAccess', _123 => _123.kind]) === "coverage") this.retouch.start(points[0]);
+      if (_optionalChain([this, 'access', _123 => _123.retouch, 'optionalAccess', _124 => _124.kind]) === "coverage") this.retouch.start(points[0]);
     }
     this.last = points[points.length - 1];
     const rects = this.mixer ? this.mixer.push(points) : this.stroke.push(points);
-    _optionalChain([this, 'access', _124 => _124.flushView, 'optionalCall', _125 => _125()]);
+    _optionalChain([this, 'access', _125 => _125.flushView, 'optionalCall', _126 => _126()]);
     this.update(rects);
   }
   update(rects) {
@@ -5727,7 +6013,7 @@ var PaintStrokeSession = (_class11 = class {
     for (const [key, { tx, ty, r }] of regions) {
       if (this.deep) {
         const rt = this.retouch;
-        const paint = _optionalChain([rt, 'optionalAccess', _126 => _126.kind]) === "coverage" ? rt.paint() : null;
+        const paint = _optionalChain([rt, 'optionalAccess', _127 => _127.kind]) === "coverage" ? rt.paint() : null;
         if (paint && paint.kind !== "tone") {
           const prevWork = this.touched.has(key) ? this.work.get(key) : void 0;
           this.touched.add(key);
@@ -5738,13 +6024,13 @@ var PaintStrokeSession = (_class11 = class {
         const prev2 = this.touched.has(key) ? this.liveDeep.get(key) : void 0;
         this.touched.add(key);
         const opts = prev2 ? { into: prev2, region: r, channels: ch } : { channels: ch };
-        const d = _optionalChain([rt, 'optionalAccess', _127 => _127.kind]) === "coverage" && _optionalChain([paint, 'optionalAccess', _128 => _128.kind]) === "tone" ? _chunk7NW46N7Icjs.applyToneToDeepTile.call(void 0, stroke.coverage, src2, tx, ty, paint.tone, rt.apply, opts) : _chunkEBDCRTZIcjs.applyStrokeToDeepTile.call(void 0, stroke.coverage, src2, tx, ty, this.apply, opts);
+        const d = _optionalChain([rt, 'optionalAccess', _128 => _128.kind]) === "coverage" && _optionalChain([paint, 'optionalAccess', _129 => _129.kind]) === "tone" ? _chunk7NW46N7Icjs.applyToneToDeepTile.call(void 0, stroke.coverage, src2, tx, ty, paint.tone, rt.apply, opts) : _chunkEBDCRTZIcjs.applyStrokeToDeepTile.call(void 0, stroke.coverage, src2, tx, ty, this.apply, opts);
         this.liveDeep.set(key, d);
         this.live.set(key, { data: _chunkCWM3CUUXcjs.proxyOf.call(void 0, d, ch), uniform: null, deep: d });
         continue;
       }
-      const src = _nullishCoalesce(_optionalChain([this, 'access', _129 => _129.base, 'access', _130 => _130.tiles, 'access', _131 => _131.get, 'call', _132 => _132(key), 'optionalAccess', _133 => _133.data]), () => ( defaultTile(this.base)));
-      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _134 => _134.live, 'access', _135 => _135.get, 'call', _136 => _136(key), 'optionalAccess', _137 => _137.data]) : void 0;
+      const src = _nullishCoalesce(_optionalChain([this, 'access', _130 => _130.base, 'access', _131 => _131.tiles, 'access', _132 => _132.get, 'call', _133 => _133(key), 'optionalAccess', _134 => _134.data]), () => ( defaultTile(this.base)));
+      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _135 => _135.live, 'access', _136 => _136.get, 'call', _137 => _137(key), 'optionalAccess', _138 => _138.data]) : void 0;
       this.touched.add(key);
       const data = this.compositeTile(src, tx, ty, prev ? { into: prev, region: r } : {});
       this.live.set(key, { data, uniform: null });
@@ -5756,12 +6042,12 @@ var PaintStrokeSession = (_class11 = class {
     if (this.closed) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("This stroke has already ended.");
     const last = _nullishCoalesce(this.last, () => ( void 0));
     const rects = this.mixer ? this.mixer.finish(last) : this.stroke.finish(last);
-    _optionalChain([this, 'access', _138 => _138.flushView, 'optionalCall', _139 => _139()]);
+    _optionalChain([this, 'access', _139 => _139.flushView, 'optionalCall', _140 => _140()]);
     this.update(rects);
     this.closed = true;
     const ch = this.base.channels;
     const r = this.retouch;
-    if (_optionalChain([r, 'optionalAccess', _140 => _140.kind]) === "coverage" && r.finalPaint) {
+    if (_optionalChain([r, 'optionalAccess', _141 => _141.kind]) === "coverage" && r.finalPaint) {
       const final = r.finalPaint(this.stroke.coverage);
       if (final) {
         for (const key of this.touched) {
@@ -5770,7 +6056,7 @@ var PaintStrokeSession = (_class11 = class {
             this.retouchDeepTile(key, tx, ty, final, {});
             continue;
           }
-          const src = _nullishCoalesce(_optionalChain([this, 'access', _141 => _141.base, 'access', _142 => _142.tiles, 'access', _143 => _143.get, 'call', _144 => _144(key), 'optionalAccess', _145 => _145.data]), () => ( defaultTile(this.base)));
+          const src = _nullishCoalesce(_optionalChain([this, 'access', _142 => _142.base, 'access', _143 => _143.tiles, 'access', _144 => _144.get, 'call', _145 => _145(key), 'optionalAccess', _146 => _146.data]), () => ( defaultTile(this.base)));
           this.live.set(key, { data: this.compositeTile(src, tx, ty, {}, final), uniform: null });
         }
       }
@@ -5792,7 +6078,7 @@ var PaintStrokeSession = (_class11 = class {
     const b = this.mixer ? this.mixer.bounds : this.stroke.coverage.bounds;
     const result = { layerId: this.target.id, channel: this.target.channel, bounds: changed ? b : null, dabs: (_nullishCoalesce(this.mixer, () => ( this.stroke))).dabCount };
     if (mixerLoad) result.mixerLoad = mixerLoad;
-    if (_optionalChain([r, 'optionalAccess', _146 => _146.result])) Object.assign(result, r.result());
+    if (_optionalChain([r, 'optionalAccess', _147 => _147.result])) Object.assign(result, r.result());
     return result;
   }
   /** Abandons the stroke and restores the layer. */
@@ -5801,7 +6087,7 @@ var PaintStrokeSession = (_class11 = class {
     this.closed = true;
     this.controller._strokeCommit(this.before, this.target.id, this.target.channel, null);
   }
-}, _class11);
+}, _class12);
 function workRegionOf(surface, rect, depth) {
   if (!depth) return Float32Array.from(_chunkCWM3CUUXcjs.readRegion.call(void 0, surface, rect));
   const d = _chunkCWM3CUUXcjs.readDeepRegion.call(void 0, surface, rect, depth);
@@ -5918,14 +6204,14 @@ function migrateSerializedImageEditorState(data) {
   const legacy = data;
   const adjustments = normalizeStoredAdjustments(legacy.adjustments);
   return {
-    version: _optionalChain([adjustments, 'access', _147 => _147.layers, 'optionalAccess', _148 => _148.length]) ? 2 : 1,
+    version: _optionalChain([adjustments, 'access', _148 => _148.layers, 'optionalAccess', _149 => _149.length]) ? 2 : 1,
     crop: legacy.crop ? { ...legacy.crop } : null,
     transform: { ...DEFAULT_TRANSFORM, ...legacy.transform },
     adjustments: serializeAdjustments(adjustments),
     depthMask: {
       ...DEFAULT_DEPTH_MASK,
       ...legacy.depthMask,
-      depthRange: [..._nullishCoalesce(_optionalChain([legacy, 'access', _149 => _149.depthMask, 'optionalAccess', _150 => _150.depthRange]), () => ( DEFAULT_DEPTH_MASK.depthRange))]
+      depthRange: [..._nullishCoalesce(_optionalChain([legacy, 'access', _150 => _150.depthMask, 'optionalAccess', _151 => _151.depthRange]), () => ( DEFAULT_DEPTH_MASK.depthRange))]
     },
     annotations: JSON.parse(JSON.stringify(_nullishCoalesce(legacy.annotations, () => ( [])))),
     ...legacy.selection ? { selection: { ...legacy.selection } } : {}
@@ -5954,36 +6240,36 @@ function migrateToLayeredState(data, size) {
 var DEFAULT_TRANSFORM = _chunkUYXL6ZWQcjs.DEFAULT_TRANSFORM_VALUES;
 var DEFAULT_DEPTH_MASK = _chunkUYXL6ZWQcjs.DEFAULT_DEPTH_MASK_VALUES;
 var DEVELOP_KEYS = ["brightness", "contrast", "saturation", "exposure", "temperature", "tint"];
-var ImageEditorController = (_class12 = class {
+var ImageEditorController = (_class13 = class {
   
   
-  __init71() {this.imageElement = null}
-  __init72() {this.listeners = /* @__PURE__ */ new Set()}
-  __init73() {this.histogramListeners = /* @__PURE__ */ new Set()}
+  __init75() {this.imageElement = null}
+  __init76() {this.listeners = /* @__PURE__ */ new Set()}
+  __init77() {this.histogramListeners = /* @__PURE__ */ new Set()}
   
   // History stacks
-  __init74() {this.undoStack = []}
-  __init75() {this.redoStack = []}
+  __init78() {this.undoStack = []}
+  __init79() {this.redoStack = []}
   
   
-  __init76() {this.isApplyingHistory = false}
+  __init80() {this.isApplyingHistory = false}
   
   /** Pixels the selection tools sample (host-provided or read back from the source). */
-  __init77() {this.samplePixels = null}
-  __init78() {this.samplePixelsOverride = false}
+  __init81() {this.samplePixels = null}
+  __init82() {this.samplePixelsOverride = false}
   /** Decoded source pixels (the Background's surface), by the buffer or element they came from. */
-  __init79() {this.sourceSurfaces = /* @__PURE__ */ new WeakMap()}
-  __init80() {this.viewKey = []}
+  __init83() {this.sourceSurfaces = /* @__PURE__ */ new WeakMap()}
+  __init84() {this.viewKey = []}
   /** For `compositePixels` and mask evaluation (the renderer keeps its own for the viewport). */
-  __init81() {this.compositor = new (0, _chunkUYXL6ZWQcjs.LayerCompositor)()}
+  __init85() {this.compositor = new (0, _chunkUYXL6ZWQcjs.LayerCompositor)()}
   /** The segmentation provider behind `selectSubject` (see `setSegmentationProvider`). */
-  __init82() {this.segmentation = null}
+  __init86() {this.segmentation = null}
   /** The effects provider slot (see `setEffectsProvider`). */
-  __init83() {this.effects = new (0, _chunkA3A5TI6Rcjs.EffectsSlot)()}
+  __init87() {this.effects = new (0, _chunkA3A5TI6Rcjs.EffectsSlot)()}
   /** Renders provider effects: effect smart filter results and effect layers. */
-  __init84() {this.effectsEngine = new ImageEffectsEngine({ slot: this.effects })}
-  __init85() {this.effectRefresh = "none"}
-  constructor(options = {}) {;_class12.prototype.__init71.call(this);_class12.prototype.__init72.call(this);_class12.prototype.__init73.call(this);_class12.prototype.__init74.call(this);_class12.prototype.__init75.call(this);_class12.prototype.__init76.call(this);_class12.prototype.__init77.call(this);_class12.prototype.__init78.call(this);_class12.prototype.__init79.call(this);_class12.prototype.__init80.call(this);_class12.prototype.__init81.call(this);_class12.prototype.__init82.call(this);_class12.prototype.__init83.call(this);_class12.prototype.__init84.call(this);_class12.prototype.__init85.call(this);_class12.prototype.__init86.call(this);_class12.prototype.__init87.call(this);_class12.prototype.__init88.call(this);_class12.prototype.__init89.call(this);_class12.prototype.__init90.call(this);_class12.prototype.__init91.call(this);_class12.prototype.__init92.call(this);_class12.prototype.__init93.call(this);_class12.prototype.__init94.call(this);_class12.prototype.__init95.call(this);_class12.prototype.__init96.call(this);_class12.prototype.__init97.call(this);_class12.prototype.__init98.call(this);_class12.prototype.__init99.call(this);_class12.prototype.__init100.call(this);_class12.prototype.__init101.call(this);
+  __init88() {this.effectsEngine = new ImageEffectsEngine({ slot: this.effects })}
+  __init89() {this.effectRefresh = "none"}
+  constructor(options = {}) {;_class13.prototype.__init75.call(this);_class13.prototype.__init76.call(this);_class13.prototype.__init77.call(this);_class13.prototype.__init78.call(this);_class13.prototype.__init79.call(this);_class13.prototype.__init80.call(this);_class13.prototype.__init81.call(this);_class13.prototype.__init82.call(this);_class13.prototype.__init83.call(this);_class13.prototype.__init84.call(this);_class13.prototype.__init85.call(this);_class13.prototype.__init86.call(this);_class13.prototype.__init87.call(this);_class13.prototype.__init88.call(this);_class13.prototype.__init89.call(this);_class13.prototype.__init90.call(this);_class13.prototype.__init91.call(this);_class13.prototype.__init92.call(this);_class13.prototype.__init93.call(this);_class13.prototype.__init94.call(this);_class13.prototype.__init95.call(this);_class13.prototype.__init96.call(this);_class13.prototype.__init97.call(this);_class13.prototype.__init98.call(this);_class13.prototype.__init99.call(this);_class13.prototype.__init100.call(this);_class13.prototype.__init101.call(this);_class13.prototype.__init102.call(this);_class13.prototype.__init103.call(this);_class13.prototype.__init104.call(this);_class13.prototype.__init105.call(this);
     this.effects.subscribe(() => this.queueEffectRefresh("all"));
     this.effectsEngine.subscribe(() => this.queueEffectRefresh("incomplete"));
     if (options.effects) this.effects.set(options.effects);
@@ -6001,7 +6287,7 @@ var ImageEditorController = (_class12 = class {
       sourceIsOpaque: () => this.sourceIsOpaque(),
       version: () => `${this.sourceVersion()}:${this.patternsVersion()}`,
       globalLight: () => this.state.globalLight,
-      pattern: (id) => _nullishCoalesce(_optionalChain([this, 'access', _151 => _151.state, 'access', _152 => _152.patterns, 'optionalAccess', _153 => _153.find, 'call', _154 => _154((p) => p.id === id)]), () => ( null))
+      pattern: (id) => _nullishCoalesce(_optionalChain([this, 'access', _152 => _152.state, 'access', _153 => _153.patterns, 'optionalAccess', _154 => _154.find, 'call', _155 => _155((p) => p.id === id)]), () => ( null))
     };
     this.state = {
       sourceUrl: typeof options.image === "string" ? options.image : null,
@@ -6034,13 +6320,13 @@ var ImageEditorController = (_class12 = class {
       };
     }
     this.applyStored(_nullishCoalesce(options.initialState, () => ( {})));
-    if (_optionalChain([options, 'access', _155 => _155.initialState, 'optionalAccess', _156 => _156.selection])) {
+    if (_optionalChain([options, 'access', _156 => _156.initialState, 'optionalAccess', _157 => _157.selection])) {
       try {
         this.state.selection = normalizeSelection(_chunkUYXL6ZWQcjs.deserializeSelection.call(void 0, options.initialState.selection));
       } catch (e20) {
       }
     }
-    if (_optionalChain([options, 'access', _157 => _157.initialState, 'optionalAccess', _158 => _158.channels])) {
+    if (_optionalChain([options, 'access', _158 => _158.initialState, 'optionalAccess', _159 => _159.channels])) {
       const channels = deserializeChannels(options.initialState.channels, this.naturalSize, this.lastLoadProblems);
       if (channels.length) this.state.channels = channels;
     }
@@ -6116,7 +6402,7 @@ var ImageEditorController = (_class12 = class {
    * Where layer pixels changed since the last viewport render, when only strokes changed them
    * (the renderer then recomposites just those rectangles); `'all'` after any other change.
    */
-  __init86() {this.pendingDirty = "all"}
+  __init90() {this.pendingDirty = "all"}
   notify(strokeRects) {
     if (strokeRects) this.docRevision++;
     if (strokeRects && this.pendingDirty !== "all") this.pendingDirty.push(...strokeRects);
@@ -6124,7 +6410,7 @@ var ImageEditorController = (_class12 = class {
     this.syncViews();
     this.syncDisplay();
     const currentState = { ...this.state };
-    _optionalChain([this, 'access', _159 => _159.onStateChange, 'optionalCall', _160 => _160(currentState)]);
+    _optionalChain([this, 'access', _160 => _160.onStateChange, 'optionalCall', _161 => _161(currentState)]);
     this.listeners.forEach((l) => l(currentState));
     if (this.effects.provider) this.queueEffectRefresh("incomplete");
   }
@@ -6153,7 +6439,7 @@ var ImageEditorController = (_class12 = class {
         if (l.type === "group") {
           const children = walk(l.children);
           if (children !== l.children) next2 = { ...l, children };
-        } else if (l.type === "smart" && _optionalChain([l, 'access', _161 => _161.smartFilters, 'optionalAccess', _162 => _162.filters, 'access', _163 => _163.some, 'call', _164 => _164((f) => f.kind === "effect")]) && (all || _chunkUYXL6ZWQcjs.isSmartSurfaceIncomplete.call(void 0, l.surface))) {
+        } else if (l.type === "smart" && _optionalChain([l, 'access', _162 => _162.smartFilters, 'optionalAccess', _163 => _163.filters, 'access', _164 => _164.some, 'call', _165 => _165((f) => f.kind === "effect")]) && (all || _chunkUYXL6ZWQcjs.isSmartSurfaceIncomplete.call(void 0, l.surface))) {
           try {
             const r = _chunkUYXL6ZWQcjs.rerender.call(void 0, l, canvas);
             if (all || !_chunkUYXL6ZWQcjs.isSmartSurfaceIncomplete.call(void 0, r.surface)) next2 = r;
@@ -6249,8 +6535,8 @@ var ImageEditorController = (_class12 = class {
    */
   async updateEffectFilter(layerId, filterId, changes, commitToHistory = true) {
     const layer = _chunkUYXL6ZWQcjs.requireSmartObject.call(void 0, this.state.layers, layerId);
-    const was = _optionalChain([layer, 'access', _165 => _165.smartFilters, 'optionalAccess', _166 => _166.filters, 'access', _167 => _167.find, 'call', _168 => _168((f) => f.id === filterId)]);
-    if (!was || was.kind !== "effect") throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Smart object "${layer.name || layerId}" has no effect filter "${filterId}"; its filters are ${(_nullishCoalesce(_optionalChain([layer, 'access', _169 => _169.smartFilters, 'optionalAccess', _170 => _170.filters]), () => ( []))).map((f) => `${f.id} (${f.kind === "effect" ? _nullishCoalesce(f.name, () => ( f.effect)) : f.kind})`).join(", ") || "none"}.`);
+    const was = _optionalChain([layer, 'access', _166 => _166.smartFilters, 'optionalAccess', _167 => _167.filters, 'access', _168 => _168.find, 'call', _169 => _169((f) => f.id === filterId)]);
+    if (!was || was.kind !== "effect") throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Smart object "${layer.name || layerId}" has no effect filter "${filterId}"; its filters are ${(_nullishCoalesce(_optionalChain([layer, 'access', _170 => _170.smartFilters, 'optionalAccess', _171 => _171.filters]), () => ( []))).map((f) => `${f.id} (${f.kind === "effect" ? _nullishCoalesce(f.name, () => ( f.effect)) : f.kind})`).join(", ") || "none"}.`);
     const update = {};
     if (changes.values) {
       const d = await this.describeEffect(was.effect);
@@ -6292,7 +6578,7 @@ var ImageEditorController = (_class12 = class {
     const layer = {
       type: "pixel",
       id,
-      name: _optionalChain([options, 'access', _171 => _171.name, 'optionalAccess', _172 => _172.trim, 'call', _173 => _173()]) || d.name,
+      name: _optionalChain([options, 'access', _172 => _172.name, 'optionalAccess', _173 => _173.trim, 'call', _174 => _174()]) || d.name,
       visible: true,
       opacity: _nullishCoalesce(options.opacity, () => ( 1)),
       blend: _nullishCoalesce(blend, () => ( "normal")),
@@ -6317,7 +6603,7 @@ var ImageEditorController = (_class12 = class {
    */
   async updateEffectLayer(layerId, changes, commitToHistory = true) {
     const found = _chunkHGTDMKNEcjs.findLayer.call(void 0, this.state.layers, layerId);
-    const layer = _optionalChain([found, 'optionalAccess', _174 => _174.layer]);
+    const layer = _optionalChain([found, 'optionalAccess', _175 => _175.layer]);
     if (!layer || layer.type !== "pixel" || !layer.generator) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`"${layerId}" is not an effect layer; add one with add_effect_layer.`);
     _chunkUYXL6ZWQcjs.requireUnlocked.call(void 0, layer, "pixels", "draw its effect again");
     const g = layer.generator;
@@ -6346,7 +6632,7 @@ var ImageEditorController = (_class12 = class {
    * and how long it runs, the longest of theirs (ms). Null when none animates.
    */
   getAnimation() {
-    const layers = _chunkHGTDMKNEcjs.flattenLayers.call(void 0, this.state.layers).filter((l) => l.type === "pixel" && l.visible && !!_optionalChain([l, 'access', _175 => _175.generator, 'optionalAccess', _176 => _176.animate]));
+    const layers = _chunkHGTDMKNEcjs.flattenLayers.call(void 0, this.state.layers).filter((l) => l.type === "pixel" && l.visible && !!_optionalChain([l, 'access', _176 => _176.generator, 'optionalAccess', _177 => _177.animate]));
     if (!layers.length) return null;
     return { duration: Math.max(...layers.map((l) => l.generator.animate.duration)), layerIds: layers.map((l) => l.id) };
   }
@@ -6363,7 +6649,7 @@ var ImageEditorController = (_class12 = class {
     const { width, height } = this.naturalSize;
     const surfaces = /* @__PURE__ */ new Map();
     for (const l of _chunkHGTDMKNEcjs.flattenLayers.call(void 0, this.state.layers)) {
-      if (l.type !== "pixel" || !l.visible || !_optionalChain([l, 'access', _177 => _177.generator, 'optionalAccess', _178 => _178.animate])) continue;
+      if (l.type !== "pixel" || !l.visible || !_optionalChain([l, 'access', _178 => _178.generator, 'optionalAccess', _179 => _179.animate])) continue;
       const g = l.generator;
       const pixels = await this.effectsEngine.renderLayer(g.effect, g.values, { width, height, depth: this.bitDepth, time: (_nullishCoalesce(g.time, () => ( 0))) + time });
       surfaces.set(l.id, effectPixelsToSurface(pixels, this.bitDepth));
@@ -6383,7 +6669,7 @@ var ImageEditorController = (_class12 = class {
       })
     );
   }
-  __init87() {this.displayFor = null}
+  __init91() {this.displayFor = null}
   /** Keeps the renderer's display transform in step with the document profile, mode and Proof Setup. */
   syncDisplay() {
     const s = this.state;
@@ -6424,7 +6710,7 @@ var ImageEditorController = (_class12 = class {
       transform: { ...s.transform },
       outputOpacity: s.outputOpacity,
       selection: _nullishCoalesce(s.selection, () => ( null)),
-      ..._optionalChain([s, 'access', _179 => _179.channels, 'optionalAccess', _180 => _180.length]) ? { channels: s.channels } : {},
+      ..._optionalChain([s, 'access', _180 => _180.channels, 'optionalAccess', _181 => _181.length]) ? { channels: s.channels } : {},
       source: {
         sourceUrl: s.sourceUrl,
         element: this.imageElement,
@@ -6460,7 +6746,7 @@ var ImageEditorController = (_class12 = class {
     if (entry.colorMode) s.colorMode = entry.colorMode;
     else delete s.colorMode;
     s.selection = entry.selection;
-    if (_optionalChain([entry, 'access', _181 => _181.channels, 'optionalAccess', _182 => _182.length])) s.channels = entry.channels;
+    if (_optionalChain([entry, 'access', _182 => _182.channels, 'optionalAccess', _183 => _183.length])) s.channels = entry.channels;
     else delete s.channels;
     if (this.imageElement !== entry.source.element && !this.samplePixelsOverride) this.samplePixels = null;
     this.imageElement = entry.source.element;
@@ -6472,7 +6758,7 @@ var ImageEditorController = (_class12 = class {
     }
   }
   /** Set while `asOneStep` runs: the step is already recorded, so nested commands add none. */
-  __init88() {this.historyGrouped = false}
+  __init92() {this.historyGrouped = false}
   /**
    * Runs `fn` as one undo step: history is recorded once, before it, and the commands it calls
    * record none. If `fn` throws, the step is dropped and the state goes back to before it, so a
@@ -6535,7 +6821,7 @@ var ImageEditorController = (_class12 = class {
   get canUndo() {
     return this.undoStack.length > 0;
   }
-  __init89() {this.docRevision = 0}
+  __init93() {this.docRevision = 0}
   /**
    * Bumped on every change to the document (an undoable edit, a stroke, undo, redo), not on view
    * or tool changes, nor on `loadImage` (the source image is the host's, not part of the document). `createImageEditorDocument` uses it to tell document changes apart.
@@ -6667,7 +6953,7 @@ var ImageEditorController = (_class12 = class {
     return this.state.layers;
   }
   getLayer(id) {
-    return _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.state.layers, id), 'optionalAccess', _183 => _183.layer]);
+    return _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.state.layers, id), 'optionalAccess', _184 => _184.layer]);
   }
   /** The active layer, or `undefined`. */
   getActiveLayer() {
@@ -6680,7 +6966,7 @@ var ImageEditorController = (_class12 = class {
   setActiveLayer(id, target = "pixels") {
     if (id !== null && !this.getLayer(id)) return false;
     const layer = id ? this.getLayer(id) : void 0;
-    const t = target === "mask" && _optionalChain([layer, 'optionalAccess', _184 => _184.mask]) ? "mask" : target === "filter-mask" && _optionalChain([layer, 'optionalAccess', _185 => _185.type]) === "smart" && _optionalChain([layer, 'access', _186 => _186.smartFilters, 'optionalAccess', _187 => _187.mask]) ? "filter-mask" : "pixels";
+    const t = target === "mask" && _optionalChain([layer, 'optionalAccess', _185 => _185.mask]) ? "mask" : target === "filter-mask" && _optionalChain([layer, 'optionalAccess', _186 => _186.type]) === "smart" && _optionalChain([layer, 'access', _187 => _187.smartFilters, 'optionalAccess', _188 => _188.mask]) ? "filter-mask" : "pixels";
     if (this.state.activeLayerId === id && this.state.activeTarget === t) return true;
     this.state.activeLayerId = id;
     this.state.activeTarget = t;
@@ -6699,7 +6985,7 @@ var ImageEditorController = (_class12 = class {
     if (!b) return null;
     return { x: b.x + layer.offset.x, y: b.y + layer.offset.y, width: b.width, height: b.height, data: _chunkCWM3CUUXcjs.readRegion.call(void 0, surface, b) };
   }
-  __init90() {this.boundsCache = /* @__PURE__ */ new WeakMap()}
+  __init94() {this.boundsCache = /* @__PURE__ */ new WeakMap()}
   /**
    * Document bounds of a layer's non-transparent pixels (pixel layers; the Background's source
    * included), or `null` for an empty or non-pixel layer.
@@ -6842,11 +7128,11 @@ var ImageEditorController = (_class12 = class {
       surfaceOf: (l) => this.surfaceOf(l),
       version: `${this.sourceVersion()}:${this.patternsVersion()}`,
       globalLight: this.state.globalLight,
-      pattern: (id) => _nullishCoalesce(_optionalChain([this, 'access', _188 => _188.state, 'access', _189 => _189.patterns, 'optionalAccess', _190 => _190.find, 'call', _191 => _191((p) => p.id === id)]), () => ( null))
+      pattern: (id) => _nullishCoalesce(_optionalChain([this, 'access', _189 => _189.state, 'access', _190 => _190.patterns, 'optionalAccess', _191 => _191.find, 'call', _192 => _192((p) => p.id === id)]), () => ( null))
     };
   }
-  __init91() {this.sourceIds = /* @__PURE__ */ new WeakMap()}
-  __init92() {this.nextSourceId = 1}
+  __init95() {this.sourceIds = /* @__PURE__ */ new WeakMap()}
+  __init96() {this.nextSourceId = 1}
   /** Changes whenever the Background's source pixels can have changed. */
   sourceVersion() {
     const key = this.samplePixelsOverride ? this.samplePixels : _nullishCoalesce(this.imageElement, () => ( this.samplePixels));
@@ -6895,7 +7181,7 @@ var ImageEditorController = (_class12 = class {
     }
     return fits ? fromPixels(px2) : null;
   }
-  __init93() {this.opaqueCache = /* @__PURE__ */ new WeakMap()}
+  __init97() {this.opaqueCache = /* @__PURE__ */ new WeakMap()}
   /** Whether every source pixel is opaque (some legacy renders depend on it). */
   sourceIsOpaque() {
     const s = this.sourceSurface();
@@ -6919,7 +7205,7 @@ var ImageEditorController = (_class12 = class {
       if (!ctx || typeof ctx.getImageData !== "function") return null;
       ctx.drawImage(el, 0, 0, width, height);
       const data = ctx.getImageData(0, 0, width, height);
-      if (!_optionalChain([data, 'optionalAccess', _192 => _192.data]) || data.data.length < width * height * 4) return null;
+      if (!_optionalChain([data, 'optionalAccess', _193 => _193.data]) || data.data.length < width * height * 4) return null;
       return { width, height, data: data.data };
     } catch (e24) {
       return null;
@@ -6932,7 +7218,7 @@ var ImageEditorController = (_class12 = class {
     const prev = this.state.layers;
     const depth = this.bitDepth;
     this.state.layers = next;
-    _optionalChain([extra, 'optionalCall', _193 => _193()]);
+    _optionalChain([extra, 'optionalCall', _194 => _194()]);
     if (depth !== 8 && this.bitDepth === depth) this.state.layers = keepDeepLayers(prev, this.state.layers);
     if (this.state.activeLayerId && !_chunkHGTDMKNEcjs.findLayer.call(void 0, this.state.layers, this.state.activeLayerId)) {
       this.state.activeLayerId = _chunkUYXL6ZWQcjs.activeLayerAfterRemoval.call(void 0, prev, this.state.layers, this.state.activeLayerId);
@@ -6970,7 +7256,7 @@ var ImageEditorController = (_class12 = class {
     const layer = {
       type: "pixel",
       id: init.id && !ids.has(init.id) ? init.id : _chunkUYXL6ZWQcjs.newLayerId.call(void 0, ),
-      name: _optionalChain([init, 'access', _194 => _194.name, 'optionalAccess', _195 => _195.trim, 'call', _196 => _196()]) || this.nextLayerName(),
+      name: _optionalChain([init, 'access', _195 => _195.name, 'optionalAccess', _196 => _196.trim, 'call', _197 => _197()]) || this.nextLayerName(),
       visible: _nullishCoalesce(init.visible, () => ( true)),
       opacity: _nullishCoalesce(init.opacity, () => ( 1)),
       blend: _nullishCoalesce(blend, () => ( "normal")),
@@ -6997,7 +7283,7 @@ var ImageEditorController = (_class12 = class {
   async decodeImage(image) {
     const trimmed = image.trim();
     let png = null;
-    if (/^data:image\/png/i.test(trimmed)) png = _nullishCoalesce(_optionalChain([_chunkCWM3CUUXcjs.parseDataUrl.call(void 0, trimmed), 'optionalAccess', _197 => _197.bytes]), () => ( null));
+    if (/^data:image\/png/i.test(trimmed)) png = _nullishCoalesce(_optionalChain([_chunkCWM3CUUXcjs.parseDataUrl.call(void 0, trimmed), 'optionalAccess', _198 => _198.bytes]), () => ( null));
     else if (/^[A-Za-z0-9+/=\s]+$/.test(trimmed) && trimmed.length > 16) {
       try {
         const bytes = _chunkCWM3CUUXcjs.base64ToBytes.call(void 0, trimmed);
@@ -7046,7 +7332,7 @@ var ImageEditorController = (_class12 = class {
   removeLayer(id) {
     const next = _chunkUYXL6ZWQcjs.removeLayer.call(void 0, this.state.layers, id);
     this.commitLayers(next, () => {
-      if (this.state.selectedAnnotationId && !_chunkHGTDMKNEcjs.flattenLayers.call(void 0, next).some((l) => _optionalChain([_chunkUYXL6ZWQcjs.annotationOfLayer.call(void 0, l), 'optionalAccess', _198 => _198.id]) === this.state.selectedAnnotationId)) {
+      if (this.state.selectedAnnotationId && !_chunkHGTDMKNEcjs.flattenLayers.call(void 0, next).some((l) => _optionalChain([_chunkUYXL6ZWQcjs.annotationOfLayer.call(void 0, l), 'optionalAccess', _199 => _199.id]) === this.state.selectedAnnotationId)) {
         this.state.selectedAnnotationId = null;
       }
     });
@@ -7055,9 +7341,9 @@ var ImageEditorController = (_class12 = class {
   moveLayer(id, placement) {
     const next = _chunkUYXL6ZWQcjs.moveLayer.call(void 0, this.state.layers, id, placement);
     const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, next, id);
-    if (next === this.state.layers) return { parentId: _nullishCoalesce(_optionalChain([loc, 'access', _199 => _199.parent, 'optionalAccess', _200 => _200.id]), () => ( null)), index: loc.index };
+    if (next === this.state.layers) return { parentId: _nullishCoalesce(_optionalChain([loc, 'access', _200 => _200.parent, 'optionalAccess', _201 => _201.id]), () => ( null)), index: loc.index };
     this.commitLayers(next);
-    return { parentId: _nullishCoalesce(_optionalChain([loc, 'access', _201 => _201.parent, 'optionalAccess', _202 => _202.id]), () => ( null)), index: loc.index };
+    return { parentId: _nullishCoalesce(_optionalChain([loc, 'access', _202 => _202.parent, 'optionalAccess', _203 => _203.id]), () => ( null)), index: loc.index };
   }
   /**
    * Changes name, visibility, opacity, fill, blend, clipping, locks or (groups) collapsed state, as
@@ -7074,7 +7360,7 @@ var ImageEditorController = (_class12 = class {
     const group = {
       type: "group",
       id: _chunkUYXL6ZWQcjs.newLayerId.call(void 0, "group"),
-      name: _optionalChain([init, 'access', _203 => _203.name, 'optionalAccess', _204 => _204.trim, 'call', _205 => _205()]) || "Group",
+      name: _optionalChain([init, 'access', _204 => _204.name, 'optionalAccess', _205 => _205.trim, 'call', _206 => _206()]) || "Group",
       visible: true,
       opacity: 1,
       blend,
@@ -7167,7 +7453,7 @@ var ImageEditorController = (_class12 = class {
         sel = this.layerTransparency(id);
       } else {
         const current = this.state.selection;
-        if (!_optionalChain([current, 'optionalAccess', _206 => _206.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, or use reveal-all / hide-all / transparency.");
+        if (!_optionalChain([current, 'optionalAccess', _207 => _207.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, or use reveal-all / hide-all / transparency.");
         sel = from === "hide-selection" ? _chunkUYXL6ZWQcjs.invertSelection.call(void 0, current) : current;
       }
       mask = this.maskFromSelection(sel, props);
@@ -7198,7 +7484,7 @@ var ImageEditorController = (_class12 = class {
     const layer = _chunkUYXL6ZWQcjs.requireLayer.call(void 0, this.state.layers, id).layer;
     const name = layer.name || id;
     if (layer.type === "shape") throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${name}" is a shape layer, whose path already is its vector mask; change it with set_shape_component, or rasterize the layer first.`);
-    if (_optionalChain([layer, 'access', _207 => _207.mask, 'optionalAccess', _208 => _208.source])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${name}" has a depth mask, which cannot be combined with a vector mask; remove the depth mask first.`);
+    if (_optionalChain([layer, 'access', _208 => _208.mask, 'optionalAccess', _209 => _209.source])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${name}" has a depth mask, which cannot be combined with a vector mask; remove the depth mask first.`);
     return layer;
   }
   requireVectorMask(id) {
@@ -7208,10 +7494,10 @@ var ImageEditorController = (_class12 = class {
   }
   /** Components from a path spec: `components`, or one `shape` / `subpaths`. */
   vectorMaskComponents(path) {
-    if (_optionalChain([path, 'access', _209 => _209.components, 'optionalAccess', _210 => _210.length]) && (path.shape !== void 0 || path.subpaths !== void 0)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Give components, or shape / subpaths, not both.");
+    if (_optionalChain([path, 'access', _210 => _210.components, 'optionalAccess', _211 => _211.length]) && (path.shape !== void 0 || path.subpaths !== void 0)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Give components, or shape / subpaths, not both.");
     if (path.fillRule !== void 0 && path.fillRule !== "nonzero" && path.fillRule !== "evenodd") throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("fillRule must be nonzero or evenodd.");
-    const specs = _optionalChain([path, 'access', _211 => _211.components, 'optionalAccess', _212 => _212.length]) ? path.components : [path];
-    return specs.map((c, i) => this.componentFrom(c, _optionalChain([path, 'access', _213 => _213.components, 'optionalAccess', _214 => _214.length]) ? `components[${i}].` : ""));
+    const specs = _optionalChain([path, 'access', _212 => _212.components, 'optionalAccess', _213 => _213.length]) ? path.components : [path];
+    return specs.map((c, i) => this.componentFrom(c, _optionalChain([path, 'access', _214 => _214.components, 'optionalAccess', _215 => _215.length]) ? `components[${i}].` : ""));
   }
   /**
    * Layer › Vector Mask: `reveal-all` (an empty path showing everything), `hide-all` (an empty path
@@ -7228,7 +7514,7 @@ var ImageEditorController = (_class12 = class {
       vm = { components: this.vectorMaskComponents(path) };
       if (path.fillRule === "evenodd") vm.fillRule = "evenodd";
     } else if (from === "reveal-all" || from === "hide-all") {
-      if (_optionalChain([path, 'access', _215 => _215.components, 'optionalAccess', _216 => _216.length]) || path.shape !== void 0 || path.subpaths !== void 0) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`A ${from} vector mask starts empty; use from path to give a path.`);
+      if (_optionalChain([path, 'access', _216 => _216.components, 'optionalAccess', _217 => _217.length]) || path.shape !== void 0 || path.subpaths !== void 0) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`A ${from} vector mask starts empty; use from path to give a path.`);
       vm = { components: [], ...from === "reveal-all" ? { inverted: true } : {} };
     } else {
       throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Unknown vector mask source "${String(from)}". Use reveal-all, hide-all, path or selection.`);
@@ -7239,7 +7525,7 @@ var ImageEditorController = (_class12 = class {
   /** The selection's outline as subpaths; throws when nothing is selected or nothing is left to trace. */
   traceSelection(options) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _217 => _217.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, then make a path from the selection.");
+    if (!_optionalChain([sel, 'optionalAccess', _218 => _218.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, then make a path from the selection.");
     if (options.tolerance !== void 0 && !(options.tolerance >= 0.1 && options.tolerance <= 10)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("tolerance must be from 0.1 to 10 px.");
     const subpaths = selectionToSubpaths(sel, options);
     if (!subpaths.length) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("The selection is too small or too faint to trace (below minArea, or under half selected); lower minArea or threshold.");
@@ -7420,7 +7706,7 @@ var ImageEditorController = (_class12 = class {
     const layer = loc.layer;
     if (layer.type !== "pixel") throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer via copy needs a pixel layer; "${id}" is a ${layer.type} layer.`);
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _218 => _218.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select the pixels to copy first.");
+    if (!_optionalChain([sel, 'optionalAccess', _219 => _219.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select the pixels to copy first.");
     if (options.cut) _chunkUYXL6ZWQcjs.requireUnlocked.call(void 0, layer, "pixels", "cut from it");
     const surface = this.surfaceOf(layer);
     const sb = sel.bounds;
@@ -7438,14 +7724,14 @@ var ImageEditorController = (_class12 = class {
     const copy = {
       type: "pixel",
       id: _chunkUYXL6ZWQcjs.newLayerId.call(void 0, ),
-      name: _optionalChain([options, 'access', _219 => _219.name, 'optionalAccess', _220 => _220.trim, 'call', _221 => _221()]) || `${layer.name || "Layer"} ${options.cut ? "cut" : "copy"}`,
+      name: _optionalChain([options, 'access', _220 => _220.name, 'optionalAccess', _221 => _221.trim, 'call', _222 => _222()]) || `${layer.name || "Layer"} ${options.cut ? "cut" : "copy"}`,
       visible: true,
       opacity: 1,
       blend: "normal",
       surface: _chunkCWM3CUUXcjs.surfaceFromPixels.call(void 0, { width: src.width, height: src.height, data: px2 }, 4, src.x, src.y),
       offset: { ...layer.offset }
     };
-    let next = _chunkHGTDMKNEcjs.insertLayer.call(void 0, this.state.layers, copy, _nullishCoalesce(_optionalChain([loc, 'access', _222 => _222.parent, 'optionalAccess', _223 => _223.id]), () => ( null)), loc.index + 1);
+    let next = _chunkHGTDMKNEcjs.insertLayer.call(void 0, this.state.layers, copy, _nullishCoalesce(_optionalChain([loc, 'access', _223 => _223.parent, 'optionalAccess', _224 => _224.id]), () => ( null)), loc.index + 1);
     if (kept) {
       const cutLayer = { ...layer, surface: _chunkCWM3CUUXcjs.writeRegion.call(void 0, surface, src, kept) };
       delete cutLayer.source;
@@ -7458,7 +7744,7 @@ var ImageEditorController = (_class12 = class {
     return copy.id;
   }
   // --- Free Transform ---
-  __init94() {this.openTransform = null}
+  __init98() {this.openTransform = null}
   /** The Free Transform in progress (see `beginFreeTransform`), or `null`. */
   getFreeTransform() {
     if (this.openTransform && !this.openTransform.isOpen) this.openTransform = null;
@@ -7469,7 +7755,7 @@ var ImageEditorController = (_class12 = class {
       layers: () => this.state.layers,
       activeLayerId: () => this.state.activeLayerId,
       activeTarget: () => this.state.activeTarget,
-      selection: () => _optionalChain([this, 'access', _224 => _224.state, 'access', _225 => _225.selection, 'optionalAccess', _226 => _226.bounds]) ? this.state.selection : null,
+      selection: () => _optionalChain([this, 'access', _225 => _225.state, 'access', _226 => _226.selection, 'optionalAccess', _227 => _227.bounds]) ? this.state.selection : null,
       canvas: () => this.naturalSize,
       pixelsOf: (layer) => this.surfaceOf(layer),
       shapeEnv: () => this.shapeEnv(),
@@ -7617,7 +7903,7 @@ var ImageEditorController = (_class12 = class {
    * anything else nests as a layer document. Returns the smart object's id.
    */
   convertToSmartObject(ids, options = {}) {
-    const list = _optionalChain([ids, 'optionalAccess', _227 => _227.length]) ? ids : this.state.activeLayerId ? [this.state.activeLayerId] : [];
+    const list = _optionalChain([ids, 'optionalAccess', _228 => _228.length]) ? ids : this.state.activeLayerId ? [this.state.activeLayerId] : [];
     if (!list.length) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("No layers given and none is active; pass layerIds (see list_layers).");
     const res = _chunkUYXL6ZWQcjs.convertToSmartObject.call(void 0, this.state.layers, list, this.canvasSize, { surfaceOf: (l) => this.surfaceOf(l), name: options.name });
     this.commitLayers(res.layers, () => {
@@ -7650,8 +7936,8 @@ var ImageEditorController = (_class12 = class {
         width: c.width,
         height: c.height,
         decoded: _chunkUYXL6ZWQcjs.isContentsDecoded.call(void 0, c),
-        fileType: _nullishCoalesce(_optionalChain([c, 'access', _228 => _228.file, 'optionalAccess', _229 => _229.type]), () => ( null)),
-        linkedPath: _nullishCoalesce(_optionalChain([c, 'access', _230 => _230.linked, 'optionalAccess', _231 => _231.path]), () => ( null)),
+        fileType: _nullishCoalesce(_optionalChain([c, 'access', _229 => _229.file, 'optionalAccess', _230 => _230.type]), () => ( null)),
+        linkedPath: _nullishCoalesce(_optionalChain([c, 'access', _231 => _231.linked, 'optionalAccess', _232 => _232.path]), () => ( null)),
         instances: _chunkUYXL6ZWQcjs.instancesOf.call(void 0, this.state.layers, c.id),
         layerCount: c.document ? _chunkHGTDMKNEcjs.flattenLayers.call(void 0, c.document.layers).length : 0
       },
@@ -7668,9 +7954,9 @@ var ImageEditorController = (_class12 = class {
         bounds: _chunkUYXL6ZWQcjs.transformedBox.call(void 0, g)
       },
       smartFilters: {
-        enabled: _nullishCoalesce(_optionalChain([stack, 'optionalAccess', _232 => _232.enabled]), () => ( true)),
-        filters: (_nullishCoalesce(_optionalChain([stack, 'optionalAccess', _233 => _233.filters]), () => ( []))).map((f) => f.kind === "psd" ? { id: f.id, kind: "psd", name: f.name, enabled: f.enabled, blend: f.blend, opacity: f.opacity } : { ...f }),
-        mask: _optionalChain([stack, 'optionalAccess', _234 => _234.mask]) ? { enabled: stack.mask.enabled !== false, linked: stack.mask.linked !== false, density: _nullishCoalesce(stack.mask.density, () => ( 1)), feather: _nullishCoalesce(stack.mask.feather, () => ( 0)), bounds: _chunkCWM3CUUXcjs.contentBounds.call(void 0, stack.mask.surface), defaultValue: stack.mask.defaultValue } : null
+        enabled: _nullishCoalesce(_optionalChain([stack, 'optionalAccess', _233 => _233.enabled]), () => ( true)),
+        filters: (_nullishCoalesce(_optionalChain([stack, 'optionalAccess', _234 => _234.filters]), () => ( []))).map((f) => f.kind === "psd" ? { id: f.id, kind: "psd", name: f.name, enabled: f.enabled, blend: f.blend, opacity: f.opacity } : { ...f }),
+        mask: _optionalChain([stack, 'optionalAccess', _235 => _235.mask]) ? { enabled: stack.mask.enabled !== false, linked: stack.mask.linked !== false, density: _nullishCoalesce(stack.mask.density, () => ( 1)), feather: _nullishCoalesce(stack.mask.feather, () => ( 0)), bounds: _chunkCWM3CUUXcjs.contentBounds.call(void 0, stack.mask.surface), defaultValue: stack.mask.defaultValue } : null
       },
       bounds: this.getLayerBounds(id)
     };
@@ -7809,7 +8095,7 @@ var ImageEditorController = (_class12 = class {
    * it in the same undo step (Photoshop limits a filter to the selection). Returns whether it did.
    */
   maskFiltersWithSelection(id, useSelection) {
-    if (!useSelection || !_optionalChain([this, 'access', _235 => _235.state, 'access', _236 => _236.selection, 'optionalAccess', _237 => _237.bounds])) return false;
+    if (!useSelection || !_optionalChain([this, 'access', _236 => _236.state, 'access', _237 => _237.selection, 'optionalAccess', _238 => _238.bounds])) return false;
     this.setSmartFilterMask(id, "selection", {}, false);
     return true;
   }
@@ -7823,19 +8109,19 @@ var ImageEditorController = (_class12 = class {
   removeSmartFilter(id, filterId) {
     const res = _chunkUYXL6ZWQcjs.removeSmartFilter.call(void 0, this.state.layers, id, filterId, this.canvasSize);
     this.commitLayers(res.layers);
-    return _nullishCoalesce(_optionalChain([res, 'access', _238 => _238.layer, 'access', _239 => _239.smartFilters, 'optionalAccess', _240 => _240.filters]), () => ( []));
+    return _nullishCoalesce(_optionalChain([res, 'access', _239 => _239.layer, 'access', _240 => _240.smartFilters, 'optionalAccess', _241 => _241.filters]), () => ( []));
   }
   /** Moves one smart filter to `index` (0 = bottom, applied first), as one undo step. Returns the filters. */
   moveSmartFilter(id, filterId, index) {
     const res = _chunkUYXL6ZWQcjs.moveSmartFilter.call(void 0, this.state.layers, id, filterId, index, this.canvasSize);
     this.commitLayers(res.layers);
-    return _nullishCoalesce(_optionalChain([res, 'access', _241 => _241.layer, 'access', _242 => _242.smartFilters, 'optionalAccess', _243 => _243.filters]), () => ( []));
+    return _nullishCoalesce(_optionalChain([res, 'access', _242 => _242.layer, 'access', _243 => _243.smartFilters, 'optionalAccess', _244 => _244.filters]), () => ( []));
   }
   /** Turns a smart object's whole filter stack on or off (one undo step). */
   setSmartFiltersEnabled(id, enabled) {
     const res = _chunkUYXL6ZWQcjs.setSmartFiltersEnabled.call(void 0, this.state.layers, id, enabled, this.canvasSize);
     this.commitLayers(res.layers);
-    return _nullishCoalesce(_optionalChain([res, 'access', _244 => _244.layer, 'access', _245 => _245.smartFilters, 'optionalAccess', _246 => _246.enabled]), () => ( true));
+    return _nullishCoalesce(_optionalChain([res, 'access', _245 => _245.layer, 'access', _246 => _246.smartFilters, 'optionalAccess', _247 => _247.enabled]), () => ( true));
   }
   /**
    * Sets the smart filter mask (one undo step): `reveal-all`, `hide-all`, `selection` (the
@@ -7847,11 +8133,11 @@ var ImageEditorController = (_class12 = class {
     let mask;
     if (from === "none") mask = null;
     else if (from === "keep") {
-      if (!_optionalChain([layer, 'access', _247 => _247.smartFilters, 'optionalAccess', _248 => _248.mask])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Smart object "${layer.name || id}" has no filter mask; add one with from reveal-all, hide-all or selection.`);
+      if (!_optionalChain([layer, 'access', _248 => _248.smartFilters, 'optionalAccess', _249 => _249.mask])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Smart object "${layer.name || id}" has no filter mask; add one with from reveal-all, hide-all or selection.`);
       mask = withMaskProps(layer.smartFilters.mask, props);
     } else if (from === "selection") {
       const sel = this.state.selection;
-      if (!_optionalChain([sel, 'optionalAccess', _249 => _249.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, or use reveal-all / hide-all.");
+      if (!_optionalChain([sel, 'optionalAccess', _250 => _250.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, or use reveal-all / hide-all.");
       mask = this.maskFromSelection(sel, props);
     } else {
       const v = from === "reveal-all" ? 255 : 0;
@@ -7863,7 +8149,7 @@ var ImageEditorController = (_class12 = class {
       if (mask && from !== "keep") this.state.activeTarget = "filter-mask";
       else if (!mask && this.state.activeTarget === "filter-mask") this.state.activeTarget = "pixels";
     }, commitToHistory);
-    return _nullishCoalesce(_optionalChain([res, 'access', _250 => _250.layer, 'access', _251 => _251.smartFilters, 'optionalAccess', _252 => _252.mask]), () => ( null));
+    return _nullishCoalesce(_optionalChain([res, 'access', _251 => _251.layer, 'access', _252 => _252.smartFilters, 'optionalAccess', _253 => _253.mask]), () => ( null));
   }
   /**
    * Decodes smart object contents that came as files the synchronous decoders cannot read (a JPEG
@@ -7896,7 +8182,7 @@ var ImageEditorController = (_class12 = class {
     return left;
   }
   // --- Smart object contents (Edit Contents) ---
-  __init95() {this.contentsStack = []}
+  __init99() {this.contentsStack = []}
   /** The smart objects whose contents are open (outermost first); empty when the document itself is shown. */
   getEditingContents() {
     return this.contentsStack.map((e) => ({ layerId: e.layerId, name: e.name }));
@@ -7911,7 +8197,7 @@ var ImageEditorController = (_class12 = class {
     if (this.getFreeTransform()) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("A Free Transform is open; commit or cancel it first.");
     const layer = _chunkUYXL6ZWQcjs.requireSmartObject.call(void 0, this.state.layers, id);
     const c = layer.contents;
-    if (!_chunkUYXL6ZWQcjs.isContentsDecoded.call(void 0, c)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`The contents of "${layer.name || id}" are a ${_nullishCoalesce(_optionalChain([c, 'access', _253 => _253.file, 'optionalAccess', _254 => _254.type]), () => ( "file"))} that could not be decoded here; run prepareSmartObjects() in a browser first.`);
+    if (!_chunkUYXL6ZWQcjs.isContentsDecoded.call(void 0, c)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`The contents of "${layer.name || id}" are a ${_nullishCoalesce(_optionalChain([c, 'access', _254 => _254.file, 'optionalAccess', _255 => _255.type]), () => ( "file"))} that could not be decoded here; run prepareSmartObjects() in a browser first.`);
     const saved = {
       state: { ...this.state },
       undo: this.undoStack,
@@ -7942,9 +8228,9 @@ var ImageEditorController = (_class12 = class {
       editingContents: this.getEditingContents()
     };
     delete this.state.legacyOutputBlur;
-    if (_optionalChain([c, 'access', _255 => _255.document, 'optionalAccess', _256 => _256.globalLight])) this.state.globalLight = c.document.globalLight;
+    if (_optionalChain([c, 'access', _256 => _256.document, 'optionalAccess', _257 => _257.globalLight])) this.state.globalLight = c.document.globalLight;
     else delete this.state.globalLight;
-    if (_optionalChain([c, 'access', _257 => _257.document, 'optionalAccess', _258 => _258.patterns, 'optionalAccess', _259 => _259.length])) this.state.patterns = c.document.patterns;
+    if (_optionalChain([c, 'access', _258 => _258.document, 'optionalAccess', _259 => _259.patterns, 'optionalAccess', _260 => _260.length])) this.state.patterns = c.document.patterns;
     else delete this.state.patterns;
     this.imageElement = null;
     this.samplePixels = null;
@@ -7964,23 +8250,23 @@ var ImageEditorController = (_class12 = class {
   closeSmartObjectContents(save = true) {
     const top = this.contentsStack.pop();
     if (!top) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("No smart object contents are open; open them with edit_smart_object_contents.");
-    if (_optionalChain([this, 'access', _260 => _260.openTransform, 'optionalAccess', _261 => _261.isOpen])) this.openTransform.cancel();
+    if (_optionalChain([this, 'access', _261 => _261.openTransform, 'optionalAccess', _262 => _262.isOpen])) this.openTransform.cancel();
     this.openTransform = null;
     const edited = this.state;
     const changed = save && this.undoStack.length > 0;
     let next = null;
     if (changed) {
-      const layer = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, top.saved.state.layers, top.layerId), 'optionalAccess', _262 => _262.layer]);
-      const old = _optionalChain([layer, 'optionalAccess', _263 => _263.contents]);
+      const layer = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, top.saved.state.layers, top.layerId), 'optionalAccess', _263 => _263.layer]);
+      const old = _optionalChain([layer, 'optionalAccess', _264 => _264.contents]);
       const { width, height } = edited.imageDimensions;
       const only = edited.layers.length === 1 ? edited.layers[0] : null;
-      const plain3 = _optionalChain([only, 'optionalAccess', _264 => _264.type]) === "pixel" && only.visible && only.opacity === 1 && only.blend === "normal" && !only.mask && !only.effects && !_optionalChain([only, 'access', _265 => _265.filters, 'optionalAccess', _266 => _266.length]) && !only.clipped && (_nullishCoalesce(only.fillOpacity, () => ( 1))) === 1 && only.source !== "document";
-      if (_optionalChain([old, 'optionalAccess', _267 => _267.kind]) === "raster" && plain3) {
+      const plain3 = _optionalChain([only, 'optionalAccess', _265 => _265.type]) === "pixel" && only.visible && only.opacity === 1 && only.blend === "normal" && !only.mask && !only.effects && !_optionalChain([only, 'access', _266 => _266.filters, 'optionalAccess', _267 => _267.length]) && !only.clipped && (_nullishCoalesce(only.fillOpacity, () => ( 1))) === 1 && only.source !== "document";
+      if (_optionalChain([old, 'optionalAccess', _268 => _268.kind]) === "raster" && plain3) {
         const px2 = _chunkCWM3CUUXcjs.readRegion.call(void 0, only.surface, { x: -only.offset.x, y: -only.offset.y, width, height });
         next = _chunkUYXL6ZWQcjs.rasterContents.call(void 0, { width, height, data: px2 }, old.name, old.id);
       } else {
         const doc = { layers: edited.layers, globalLight: edited.globalLight, patterns: edited.patterns };
-        next = _chunkUYXL6ZWQcjs.documentContents.call(void 0, doc, width, height, _optionalChain([old, 'optionalAccess', _268 => _268.kind]) === "document" ? old.name : `${(_nullishCoalesce(_optionalChain([old, 'optionalAccess', _269 => _269.name]), () => ( "Contents"))).replace(/\.\w+$/, "")}.psb`, top.contentsId);
+        next = _chunkUYXL6ZWQcjs.documentContents.call(void 0, doc, width, height, _optionalChain([old, 'optionalAccess', _269 => _269.kind]) === "document" ? old.name : `${(_nullishCoalesce(_optionalChain([old, 'optionalAccess', _270 => _270.name]), () => ( "Contents"))).replace(/\.\w+$/, "")}.psb`, top.contentsId);
       }
     }
     const saved = top.saved;
@@ -8005,7 +8291,7 @@ var ImageEditorController = (_class12 = class {
   }
   /** The document's own layers (not the contents open for editing). */
   rootLayers() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _270 => _270.contentsStack, 'access', _271 => _271[0], 'optionalAccess', _272 => _272.saved, 'access', _273 => _273.state, 'access', _274 => _274.layers]), () => ( this.state.layers));
+    return _nullishCoalesce(_optionalChain([this, 'access', _271 => _271.contentsStack, 'access', _272 => _272[0], 'optionalAccess', _273 => _273.saved, 'access', _274 => _274.state, 'access', _275 => _275.layers]), () => ( this.state.layers));
   }
   /** Drops every open contents edit (loading another document). */
   abandonContents() {
@@ -8045,7 +8331,7 @@ var ImageEditorController = (_class12 = class {
     this.commitLayers(_chunkUYXL6ZWQcjs.setLayerEffects.call(void 0, this.state.layers, id, effects), void 0, commitToHistory);
     return this.getLayerEffects(id);
   }
-  __init96() {this.patternIds = /* @__PURE__ */ new WeakMap()}
+  __init100() {this.patternIds = /* @__PURE__ */ new WeakMap()}
   /** Changes whenever the document's pattern list is replaced (the compositor then drops its caches). */
   patternsVersion() {
     const list = this.state.patterns;
@@ -8207,7 +8493,7 @@ var ImageEditorController = (_class12 = class {
     });
     return bg.id;
   }
-  __init97() {this.thumbCache = /* @__PURE__ */ new WeakMap()}
+  __init101() {this.thumbCache = /* @__PURE__ */ new WeakMap()}
   /**
    * A small RGBA preview of a pixel layer over the canvas (or of its mask with `mask: true`),
    * longest side `maxSide` px, point-sampled; `null` for layers without pixels.
@@ -8226,7 +8512,7 @@ var ImageEditorController = (_class12 = class {
     const oy = layer.type === "pixel" ? layer.offset.y : 0;
     const key = `${tw}x${th}:${ox},${oy}`;
     let byKey = this.thumbCache.get(surface);
-    const hit = _optionalChain([byKey, 'optionalAccess', _275 => _275.get, 'call', _276 => _276(key)]);
+    const hit = _optionalChain([byKey, 'optionalAccess', _276 => _276.get, 'call', _277 => _277(key)]);
     if (hit) return hit;
     const out = new Uint8ClampedArray(tw * th * 4);
     for (let y = 0; y < th; y++) {
@@ -8367,7 +8653,7 @@ var ImageEditorController = (_class12 = class {
       if (layer.mask.source) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${name}" has a depth mask, which is generated, not painted.`);
       _chunkUYXL6ZWQcjs.requireUnlocked.call(void 0, layer, "all", action);
     } else if (ch === "filter-mask") {
-      if (layer.type !== "smart" || !_optionalChain([layer, 'access', _277 => _277.smartFilters, 'optionalAccess', _278 => _278.mask])) {
+      if (layer.type !== "smart" || !_optionalChain([layer, 'access', _278 => _278.smartFilters, 'optionalAccess', _279 => _279.mask])) {
         throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${name}" has no smart filter mask to ${action}; add one with set_smart_filter_mask, or target pixels or mask.`, `Layer "${name}" has no smart filter mask to ${action}.`);
       }
       if (!_chunkUYXL6ZWQcjs.isContentsDecoded.call(void 0, layer.contents)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`The contents of "${name}" are not decoded here, so its filter mask cannot be painted; run prepareSmartObjects() first.`, `The smart object "${name}" is still loading; try again in a moment.`);
@@ -8382,7 +8668,7 @@ var ImageEditorController = (_class12 = class {
     if (!layer.visible) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${name}" is hidden; show it before you ${action}.`);
     const offset = layer.type === "pixel" ? layer.offset : { x: 0, y: 0 };
     const surface = ch === "mask" ? layer.mask.surface : ch === "filter-mask" ? layer.smartFilters.mask.surface : this.surfaceOf(layer);
-    const lockTransparency = ch === "pixels" && Boolean(_optionalChain([layer, 'access', _279 => _279.locks, 'optionalAccess', _280 => _280.transparency]));
+    const lockTransparency = ch === "pixels" && Boolean(_optionalChain([layer, 'access', _280 => _280.locks, 'optionalAccess', _281 => _281.transparency]));
     return { id, layer, channel: ch, offset, surface, lockTransparency };
   }
   /** The layer with its pixels (or mask) replaced by `surface`. */
@@ -8426,13 +8712,13 @@ var ImageEditorController = (_class12 = class {
       blend: target.channel !== "pixels" ? "normal" : brush.blend,
       lockTransparency: target.lockTransparency,
       // In Quick Mask mode the selection is what is painted, so it does not limit the stroke.
-      selection: target.channel !== "quick-mask" && _optionalChain([this, 'access', _281 => _281.state, 'access', _282 => _282.selection, 'optionalAccess', _283 => _283.bounds]) ? this.state.selection : null,
+      selection: target.channel !== "quick-mask" && _optionalChain([this, 'access', _282 => _282.state, 'access', _283 => _283.selection, 'optionalAccess', _284 => _284.bounds]) ? this.state.selection : null,
       offset: target.offset
     };
     const depth = target.channel !== "filter-mask" && target.channel !== "quick-mask" && this.bitDepth !== 8 ? this.bitDepth : null;
     if (tool === "mixer") return new PaintStrokeSession(this, target, this.mixerStroke(init, brush), apply, depth);
     if (isRetouchTool(tool)) return new PaintStrokeSession(this, target, this.retouchStroke(tool, init, brush, target, apply), apply, depth);
-    const gradient = tool === "brush" && _optionalChain([strokePaint, 'optionalAccess', _284 => _284.type]) === "gradient" ? _chunkEBDCRTZIcjs.resolvePaintGradient.call(void 0, strokePaint, { paint: toHex(color), secondary: toHex(background) }) : null;
+    const gradient = tool === "brush" && _optionalChain([strokePaint, 'optionalAccess', _285 => _285.type]) === "gradient" ? _chunkEBDCRTZIcjs.resolvePaintGradient.call(void 0, strokePaint, { paint: toHex(color), secondary: toHex(background) }) : null;
     return new PaintStrokeSession(this, target, new (0, _chunkEBDCRTZIcjs.StrokeCoverage)(brush, gradient, _nullishCoalesce(init.seed, () => ( 0))), apply, depth);
   }
   /** A retouching stroke's start: its settings, what it samples and how it composites. */
@@ -8479,9 +8765,9 @@ var ImageEditorController = (_class12 = class {
       const steps = settings.historySteps;
       const entry = steps > 0 ? _nullishCoalesce(this.undoStack[this.undoStack.length - steps], () => ( this.undoStack[0])) : this.undoStack[0];
       if (!entry) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("There is no earlier state to paint from yet: the History Brush paints a layer as it was some undo steps back. Make a change first.");
-      const then = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, entry.layers, target.id), 'optionalAccess', _285 => _285.layer]);
+      const then = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, entry.layers, target.id), 'optionalAccess', _286 => _286.layer]);
       if (!then) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${target.id}" did not exist ${steps > 0 ? `${steps} steps back` : "in the oldest state"}; choose fewer history steps (historySteps).`);
-      const surface = target.channel === "mask" ? _optionalChain([then, 'access', _286 => _286.mask, 'optionalAccess', _287 => _287.surface]) : then.type === "pixel" ? then.surface : void 0;
+      const surface = target.channel === "mask" ? _optionalChain([then, 'access', _287 => _287.mask, 'optionalAccess', _288 => _288.surface]) : then.type === "pixel" ? then.surface : void 0;
       if (!surface) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${target.id}" had no ${target.channel === "mask" ? "mask" : "pixels"} in that state.`);
       const offset2 = then.type === "pixel" ? then.offset : { x: 0, y: 0 };
       const depth = !mask && this.bitDepth !== 8 ? this.bitDepth : null;
@@ -8555,7 +8841,7 @@ var ImageEditorController = (_class12 = class {
   }
   /** A pixel source over a surface (layer pixels or a mask) in layer space at `offset`. */
   surfaceSource(surface, offset) {
-    return new (0, _chunk7NW46N7Icjs.TilePixelSource)((tx, ty) => _nullishCoalesce(_optionalChain([surface, 'access', _288 => _288.tiles, 'access', _289 => _289.get, 'call', _290 => _290(_chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _291 => _291.data]), () => ( (surface.defaultValue ? defaultTile(surface) : null))), surface.channels, offset);
+    return new (0, _chunk7NW46N7Icjs.TilePixelSource)((tx, ty) => _nullishCoalesce(_optionalChain([surface, 'access', _289 => _289.tiles, 'access', _290 => _290.get, 'call', _291 => _291(_chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _292 => _292.data]), () => ( (surface.defaultValue ? defaultTile(surface) : null))), surface.channels, offset);
   }
   /** A pixel source over the composite of the current layers (through `throughId` and below, or all of them), as it is now. */
   compositeSource(throughId, depth = null) {
@@ -8631,7 +8917,7 @@ var ImageEditorController = (_class12 = class {
   paintStroke(init) {
     if (!Array.isArray(init.points) || !init.points.length) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("points must hold at least one { x, y } point.");
     for (const p of init.points) {
-      if (!Number.isFinite(_optionalChain([p, 'optionalAccess', _292 => _292.x])) || !Number.isFinite(_optionalChain([p, 'optionalAccess', _293 => _293.y]))) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Every point needs finite x and y (document pixels).");
+      if (!Number.isFinite(_optionalChain([p, 'optionalAccess', _293 => _293.x])) || !Number.isFinite(_optionalChain([p, 'optionalAccess', _294 => _294.y]))) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Every point needs finite x and y (document pixels).");
     }
     const session = this.beginStroke(init);
     session.push(init.points);
@@ -8660,7 +8946,7 @@ var ImageEditorController = (_class12 = class {
    */
   strokeSelection(options) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _294 => _294.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, then stroke the selection.");
+    if (!_optionalChain([sel, 'optionalAccess', _295 => _295.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, then stroke the selection.");
     const width = options.width;
     if (!(width > 0 && width <= 250)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("width must be greater than 0 and at most 250 px.");
     const location = _nullishCoalesce(options.location, () => ( "outside"));
@@ -8677,7 +8963,7 @@ var ImageEditorController = (_class12 = class {
    */
   cropToSelection() {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _295 => _295.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select the area to keep, then crop to it.");
+    if (!_optionalChain([sel, 'optionalAccess', _296 => _296.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select the area to keep, then crop to it.");
     const crop = { ...sel.bounds };
     this.setCrop(crop);
     return crop;
@@ -8691,7 +8977,7 @@ var ImageEditorController = (_class12 = class {
    */
   contentAwareFill(options = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _296 => _296.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select what to remove, then fill it.");
+    if (!_optionalChain([sel, 'optionalAccess', _297 => _297.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select what to remove, then fill it.");
     if (this.bitDepth !== 8) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Content-Aware Fill works on 8-bit documents for now; set_bit_depth 8 first, or use spot_heal.");
     const output = _nullishCoalesce(options.output, () => ( "current"));
     if (output !== "current" && output !== "new-layer") throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Unknown output "${String(output)}"; use current or new-layer.`);
@@ -8737,7 +9023,7 @@ var ImageEditorController = (_class12 = class {
     return { layerId: target.id, bounds: { ...b }, output };
   }
   /** The pixel clipboard (Copy / Cut), or null. */
-  __init98() {this.clipboard = null}
+  __init102() {this.clipboard = null}
   /** What Copy or Cut last put on the editor's clipboard, or null. */
   getClipboard() {
     return this.clipboard;
@@ -8756,8 +9042,8 @@ var ImageEditorController = (_class12 = class {
    */
   copyPixels(options = {}) {
     const { width, height } = this.naturalSize;
-    const sel = _optionalChain([this, 'access', _297 => _297.state, 'access', _298 => _298.selection, 'optionalAccess', _299 => _299.bounds]) ? this.state.selection : null;
-    const rect = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _300 => _300.bounds]), () => ( { x: 0, y: 0, width, height }));
+    const sel = _optionalChain([this, 'access', _298 => _298.state, 'access', _299 => _299.selection, 'optionalAccess', _300 => _300.bounds]) ? this.state.selection : null;
+    const rect = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _301 => _301.bounds]), () => ( { x: 0, y: 0, width, height }));
     let data;
     if (options.merged) {
       data = new Uint8ClampedArray(this.compositePixels(rect).data);
@@ -8797,7 +9083,7 @@ var ImageEditorController = (_class12 = class {
   pastePixels(mode = "new-layer", image = this.clipboard) {
     if (!image) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("The clipboard is empty; copy_pixels first.");
     if (!PASTE_MODES.includes(mode)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Unknown paste mode "${String(mode)}"; use ${PASTE_MODES.join(", ")}.`);
-    const sel = _optionalChain([this, 'access', _301 => _301.state, 'access', _302 => _302.selection, 'optionalAccess', _303 => _303.bounds]) ? this.state.selection : null;
+    const sel = _optionalChain([this, 'access', _302 => _302.state, 'access', _303 => _303.selection, 'optionalAccess', _304 => _304.bounds]) ? this.state.selection : null;
     if ((mode === "into" || mode === "outside") && !sel) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Paste ${mode === "into" ? "Into" : "Outside"} needs a selection; select where it goes first.`);
     const { width, height } = this.naturalSize;
     let x;
@@ -8806,7 +9092,7 @@ var ImageEditorController = (_class12 = class {
       x = image.x;
       y = image.y;
     } else {
-      const frame = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _304 => _304.bounds]), () => ( { x: 0, y: 0, width, height }));
+      const frame = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _305 => _305.bounds]), () => ( { x: 0, y: 0, width, height }));
       x = Math.round(frame.x + (frame.width - image.width) / 2);
       y = Math.round(frame.y + (frame.height - image.height) / 2);
     }
@@ -8823,8 +9109,8 @@ var ImageEditorController = (_class12 = class {
     if (!(opacity >= 0 && opacity <= 1)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("opacity must be from 0 to 1.");
     const blend = _nullishCoalesce(_chunkUYXL6ZWQcjs.parseBlend.call(void 0, options.blend), () => ( "normal"));
     const quickMask = target.channel === "quick-mask";
-    const sel = _nullishCoalesce(coverageMask, () => ( (!quickMask && options.useSelection !== false && _optionalChain([this, 'access', _305 => _305.state, 'access', _306 => _306.selection, 'optionalAccess', _307 => _307.bounds]) ? this.state.selection : null)));
-    const region = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _308 => _308.bounds]), () => ( { x: 0, y: 0, width, height }));
+    const sel = _nullishCoalesce(coverageMask, () => ( (!quickMask && options.useSelection !== false && _optionalChain([this, 'access', _306 => _306.state, 'access', _307 => _307.selection, 'optionalAccess', _308 => _308.bounds]) ? this.state.selection : null)));
+    const region = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _309 => _309.bounds]), () => ( { x: 0, y: 0, width, height }));
     const coverage = new (0, _chunkEBDCRTZIcjs.CoverageMap)();
     const ones = new Float32Array(region.width * region.height);
     if (sel) {
@@ -8949,7 +9235,7 @@ var ImageEditorController = (_class12 = class {
   placeLayer(layers, node, where) {
     if (where.aboveId) {
       const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, layers, where.aboveId);
-      if (loc) return _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, node, _nullishCoalesce(_optionalChain([loc, 'access', _309 => _309.parent, 'optionalAccess', _310 => _310.id]), () => ( null)), loc.index + 1);
+      if (loc) return _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, node, _nullishCoalesce(_optionalChain([loc, 'access', _310 => _310.parent, 'optionalAccess', _311 => _311.id]), () => ( null)), loc.index + 1);
     }
     if (where.parentId) {
       const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, layers, where.parentId);
@@ -8960,11 +9246,11 @@ var ImageEditorController = (_class12 = class {
       const at = Math.max(0, Math.min(nodes.length, Math.round(where.adjustmentIndex)));
       if (at < nodes.length) {
         const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, layers, nodes[at].id);
-        return _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, node, _nullishCoalesce(_optionalChain([loc, 'access', _311 => _311.parent, 'optionalAccess', _312 => _312.id]), () => ( null)), loc.index);
+        return _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, node, _nullishCoalesce(_optionalChain([loc, 'access', _312 => _312.parent, 'optionalAccess', _313 => _313.id]), () => ( null)), loc.index);
       }
       if (nodes.length) {
         const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, layers, nodes[nodes.length - 1].id);
-        return _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, node, _nullishCoalesce(_optionalChain([loc, 'access', _313 => _313.parent, 'optionalAccess', _314 => _314.id]), () => ( null)), loc.index + 1);
+        return _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, node, _nullishCoalesce(_optionalChain([loc, 'access', _314 => _314.parent, 'optionalAccess', _315 => _315.id]), () => ( null)), loc.index + 1);
       }
     }
     return _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, node, null, this.defaultInsertIndex(layers));
@@ -9003,7 +9289,7 @@ var ImageEditorController = (_class12 = class {
       enabled: spec.enabled,
       opacity: spec.opacity,
       blend: spec.blend,
-      mask: _nullishCoalesce(spec.mask, () => ( (spec.useSelection && _optionalChain([this, 'access', _315 => _315.state, 'access', _316 => _316.selection, 'optionalAccess', _317 => _317.bounds]) ? _chunkUYXL6ZWQcjs.layerMaskFromSelection.call(void 0, this.state.selection) : void 0)))
+      mask: _nullishCoalesce(spec.mask, () => ( (spec.useSelection && _optionalChain([this, 'access', _316 => _316.state, 'access', _317 => _317.selection, 'optionalAccess', _318 => _318.bounds]) ? _chunkUYXL6ZWQcjs.layerMaskFromSelection.call(void 0, this.state.selection) : void 0)))
     });
     while (ids.has(layer.id)) layer.id = _chunkUYXL6ZWQcjs.newLayerId.call(void 0, "adj");
     const { width, height } = this.naturalSize;
@@ -9080,7 +9366,7 @@ var ImageEditorController = (_class12 = class {
     const anchor = nodes[to];
     const without = _chunkHGTDMKNEcjs.mapLayer.call(void 0, layers, id, () => null);
     const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, without, anchor.id);
-    return _chunkHGTDMKNEcjs.insertLayer.call(void 0, without, node, _nullishCoalesce(_optionalChain([loc, 'access', _318 => _318.parent, 'optionalAccess', _319 => _319.id]), () => ( null)), to > from ? loc.index + 1 : loc.index);
+    return _chunkHGTDMKNEcjs.insertLayer.call(void 0, without, node, _nullishCoalesce(_optionalChain([loc, 'access', _319 => _319.parent, 'optionalAccess', _320 => _320.id]), () => ( null)), to > from ? loc.index + 1 : loc.index);
   }
   /** Moves a layer to `toIndex` among the adjustment layers (0 = bottom) as one undo step. Returns false if nothing moved. */
   moveAdjustmentLayer(id, toIndex) {
@@ -9121,7 +9407,7 @@ var ImageEditorController = (_class12 = class {
     return _nullishCoalesce(this.state.selection, () => ( null));
   }
   get hasSelection() {
-    return Boolean(_optionalChain([this, 'access', _320 => _320.state, 'access', _321 => _321.selection, 'optionalAccess', _322 => _322.bounds]));
+    return Boolean(_optionalChain([this, 'access', _321 => _321.state, 'access', _322 => _322.selection, 'optionalAccess', _323 => _323.bounds]));
   }
   /** Returns the current canvas (composition) dimensions. */
   getCanvasSize() {
@@ -9213,7 +9499,7 @@ var ImageEditorController = (_class12 = class {
     const prev = normalizeSelection(_nullishCoalesce(this.state.selection, () => ( null)));
     if (prev === next || prev && next && sameSelection(prev, next)) return false;
     this.recordHistory();
-    if (!next && _optionalChain([prev, 'optionalAccess', _323 => _323.bounds])) this.lastSelection = prev;
+    if (!next && _optionalChain([prev, 'optionalAccess', _324 => _324.bounds])) this.lastSelection = prev;
     this.state.selection = next;
     this.notify();
     return true;
@@ -9228,7 +9514,7 @@ var ImageEditorController = (_class12 = class {
     return this.setSelection(null);
   }
   /** The selection a Deselect cleared, for `reselect` (not saved, not part of history). */
-  __init99() {this.lastSelection = null}
+  __init103() {this.lastSelection = null}
   /** Whether `reselect` has a selection to bring back. */
   canReselect() {
     const { width, height } = this.naturalSize;
@@ -9256,14 +9542,14 @@ var ImageEditorController = (_class12 = class {
   /** Select › Grow: adds connected pixels within `tolerance` of a selected colour (one undo step). */
   async growSelection(options = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _324 => _324.bounds])) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _325 => _325.bounds])) return false;
     const pixels = await this.requirePixels(options);
     return this.setSelection(growSelection(pixels, sel, options));
   }
   /** Select › Similar: adds every pixel within `tolerance` of a selected colour (one undo step). */
   async selectSimilar(options = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _325 => _325.bounds])) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _326 => _326.bounds])) return false;
     const pixels = await this.requirePixels(options);
     return this.setSelection(selectSimilar(pixels, sel, options));
   }
@@ -9355,6 +9641,28 @@ var ImageEditorController = (_class12 = class {
     this.setSelection(sel, "replace");
     return _nullishCoalesce(this.state.selection, () => ( null));
   }
+  /**
+   * Object Selection: the object inside `target.rect` (natural pixels; what is outside the box is
+   * background) or under `target.point`, found by GrabCut (colour models of object and background
+   * plus a graph cut along edges), combined with the selection by `mode` as one undo step.
+   * Resolves to the resulting selection.
+   */
+  async selectObject(target, options = {}) {
+    const { width, height } = this.naturalSize;
+    if ("rect" in target) {
+      const r = target.rect;
+      if (!(r.width > 0 && r.height > 0)) throw new Error("The box needs a positive width and height.");
+      if (r.x >= width || r.y >= height || r.x + r.width <= 0 || r.y + r.height <= 0) {
+        throw new Error(`The box lies outside the image (0..${width}, 0..${height}); draw it around the object.`);
+      }
+    } else if (!(target.point.x >= 0 && target.point.y >= 0 && target.point.x < width && target.point.y < height)) {
+      throw new Error(`(${target.point.x}, ${target.point.y}) is outside the image (0..${width - 1}, 0..${height - 1}); click on the object.`);
+    }
+    const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
+    const region = selectObjectIn(pixels, target, { enhanceEdge: options.enhanceEdge });
+    this.setSelection(region, _nullishCoalesce(options.mode, () => ( "replace")));
+    return _nullishCoalesce(this.state.selection, () => ( null));
+  }
   /**
    * Supplies the pixels the selection tools sample (natural size RGBA), e.g. decoded in a worker
    * or in a test; `null` goes back to reading the source image. Without a canvas (Node, workers)
@@ -9376,7 +9684,7 @@ var ImageEditorController = (_class12 = class {
       try {
         const canvas = await this.renderSource();
         const ctx = canvas.getContext("2d");
-        const data2 = _optionalChain([ctx, 'optionalAccess', _326 => _326.getImageData, 'optionalCall', _327 => _327(0, 0, width, height)]);
+        const data2 = _optionalChain([ctx, 'optionalAccess', _327 => _327.getImageData, 'optionalCall', _328 => _328(0, 0, width, height)]);
         if (data2 && data2.data && data2.data.length >= width * height * 4) {
           base = { width, height, data: data2.data };
           this.samplePixels = base;
@@ -9451,7 +9759,7 @@ var ImageEditorController = (_class12 = class {
   /** Select › Modify: grow, shrink, feather, border or smooth by `radius` pixels (one undo step). */
   modifySelection(op, radius) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _328 => _328.bounds])) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _329 => _329.bounds])) return false;
     return this.setSelection(_chunkUYXL6ZWQcjs.modifySelection.call(void 0, sel, op, radius));
   }
   /**
@@ -9460,7 +9768,7 @@ var ImageEditorController = (_class12 = class {
    */
   async refineSelection(params, options = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _329 => _329.bounds])) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _330 => _330.bounds])) return false;
     const pixels = (_nullishCoalesce(params.radius, () => ( 0))) > 0 ? await this.requirePixels(options) : null;
     return this.setSelection(refineSelection(pixels, sel, params));
   }
@@ -9491,7 +9799,7 @@ var ImageEditorController = (_class12 = class {
     let mask;
     if (source === "selection") {
       const sel = this.state.selection;
-      if (!_optionalChain([sel, 'optionalAccess', _330 => _330.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, or export a channel or a layer mask.");
+      if (!_optionalChain([sel, 'optionalAccess', _331 => _331.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, or export a channel or a layer mask.");
       mask = sel;
     } else if ("channelId" in source) {
       mask = this.requireChannel(source.channelId).mask;
@@ -9515,7 +9823,7 @@ var ImageEditorController = (_class12 = class {
     const canvas = this.renderer.createCanvas(w, h);
     const ctx = canvas.getContext("2d");
     if (ctx) ctx.drawImage(img, 0, 0, w, h);
-    const data = _optionalChain([ctx, 'optionalAccess', _331 => _331.getImageData, 'optionalCall', _332 => _332(0, 0, w, h)]);
+    const data = _optionalChain([ctx, 'optionalAccess', _332 => _332.getImageData, 'optionalCall', _333 => _333(0, 0, w, h)]);
     if (!data) throw new Error("The mask image pixels are not available (no canvas access); pass pixels.");
     return { width: w, height: h, data: data.data };
   }
@@ -9533,24 +9841,24 @@ var ImageEditorController = (_class12 = class {
     const { width, height } = this.naturalSize;
     const image = await this.toDataURL({ format: "image/png" });
     const results = await provider.segment({ image, width, height, target: description, maxSegments: options.maxSegments, signal: options.signal });
-    _optionalChain([options, 'access', _333 => _333.signal, 'optionalAccess', _334 => _334.throwIfAborted, 'call', _335 => _335()]);
+    _optionalChain([options, 'access', _334 => _334.signal, 'optionalAccess', _335 => _335.throwIfAborted, 'call', _336 => _336()]);
     const decoded = [];
     for (const r of _nullishCoalesce(results, () => ( []))) {
       decoded.push({ ...r, mask: r.mask !== void 0 ? await this.decodeMaskImage(r.mask) : void 0 });
     }
     const segments = decoded.map((r) => {
       const one = segmentsToSelection(width, height, [r]);
-      return { label: r.label || description, bounds: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _336 => _336.bounds]), () => ( null)), ...r.score !== void 0 ? { score: r.score } : {} };
+      return { label: r.label || description, bounds: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _337 => _337.bounds]), () => ( null)), ...r.score !== void 0 ? { score: r.score } : {} };
     });
     const mask = segmentsToSelection(width, height, decoded);
     if (mask && options.beforeApply) {
       const outlines = decoded.flatMap((r, i) => {
         const rings = segmentationOutlines(r);
-        const b = _optionalChain([segments, 'access', _337 => _337[i], 'optionalAccess', _338 => _338.bounds]);
+        const b = _optionalChain([segments, 'access', _338 => _338[i], 'optionalAccess', _339 => _339.bounds]);
         return rings.length ? rings : b ? [[{ x: b.x, y: b.y }, { x: b.x + b.width, y: b.y }, { x: b.x + b.width, y: b.y + b.height }, { x: b.x, y: b.y + b.height }]] : [];
       });
       await options.beforeApply(outlines);
-      _optionalChain([options, 'access', _339 => _339.signal, 'optionalAccess', _340 => _340.throwIfAborted, 'call', _341 => _341()]);
+      _optionalChain([options, 'access', _340 => _340.signal, 'optionalAccess', _341 => _341.throwIfAborted, 'call', _342 => _342()]);
     }
     if (mask) this.shapeCommand(mask, options);
     return { segments: segments.filter((s) => s.bounds) };
@@ -9583,7 +9891,7 @@ var ImageEditorController = (_class12 = class {
     const view = this.state.maskView;
     if (!view) return null;
     const layer = this.getLayer(view.layerId);
-    return _optionalChain([layer, 'optionalAccess', _342 => _342.mask]) && !layer.mask.source ? view : null;
+    return _optionalChain([layer, 'optionalAccess', _343 => _343.mask]) && !layer.mask.source ? view : null;
   }
   /**
    * Shows a layer's mask on the canvas: `gray` alone in grey (Alt-click the mask thumbnail),
@@ -9606,7 +9914,7 @@ var ImageEditorController = (_class12 = class {
     if (!layer.mask) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${layer.name || id}" has no mask to show; add one with add_layer_mask.`);
     if (layer.mask.source) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${layer.name || id}" has a depth mask, which is computed, not painted, so it has no mask view.`);
     const cur = this.state.maskView;
-    if (_optionalChain([cur, 'optionalAccess', _343 => _343.layerId]) !== id || cur.mode !== mode) {
+    if (_optionalChain([cur, 'optionalAccess', _344 => _344.layerId]) !== id || cur.mode !== mode) {
       this.state.maskView = { layerId: id, mode };
       this.notify();
     }
@@ -9618,7 +9926,7 @@ var ImageEditorController = (_class12 = class {
     return _nullishCoalesce(this.state.channels, () => ( []));
   }
   getChannel(id) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _344 => _344.state, 'access', _345 => _345.channels, 'optionalAccess', _346 => _346.find, 'call', _347 => _347((c) => c.id === id)]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _345 => _345.state, 'access', _346 => _346.channels, 'optionalAccess', _347 => _347.find, 'call', _348 => _348((c) => c.id === id)]), () => ( null));
   }
   requireChannel(id) {
     const channel = this.getChannel(id);
@@ -9647,14 +9955,14 @@ var ImageEditorController = (_class12 = class {
    */
   saveSelection(options = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _348 => _348.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, then save the selection to a channel.");
+    if (!_optionalChain([sel, 'optionalAccess', _349 => _349.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, then save the selection to a channel.");
     const { width, height } = this.naturalSize;
     const sized = sel.width === width && sel.height === height ? sel : _chunkUYXL6ZWQcjs.resizeSelection.call(void 0, sel, width, height);
     const channels = [...this.getChannels()];
     if (options.channelId !== void 0) {
       const existing = this.requireChannel(options.channelId);
       const mask = _nullishCoalesce(_chunkUYXL6ZWQcjs.combineSelections.call(void 0, existing.mask.bounds ? existing.mask : null, sized, _nullishCoalesce(options.mode, () => ( "replace"))), () => ( _chunkUYXL6ZWQcjs.createSelectionMask.call(void 0, width, height)));
-      const next = { ...existing, mask, ..._optionalChain([options, 'access', _349 => _349.name, 'optionalAccess', _350 => _350.trim, 'call', _351 => _351()]) ? { name: options.name.trim() } : {} };
+      const next = { ...existing, mask, ..._optionalChain([options, 'access', _350 => _350.name, 'optionalAccess', _351 => _351.trim, 'call', _352 => _352()]) ? { name: options.name.trim() } : {} };
       this.setChannels(channels.map((c) => c.id === existing.id ? next : c));
       return next;
     }
@@ -9665,7 +9973,7 @@ var ImageEditorController = (_class12 = class {
     const channels = this.getChannels();
     const channel = {
       id: this.newChannelId(),
-      name: _optionalChain([name, 'optionalAccess', _352 => _352.trim, 'call', _353 => _353()]) || `Alpha ${channels.length + 1}`,
+      name: _optionalChain([name, 'optionalAccess', _353 => _353.trim, 'call', _354 => _354()]) || `Alpha ${channels.length + 1}`,
       mask,
       color: DEFAULT_CHANNEL_COLOR,
       opacity: 0.5,
@@ -9710,7 +10018,7 @@ var ImageEditorController = (_class12 = class {
   /** Duplicates an alpha channel just after it (one undo step). Returns the copy. */
   duplicateChannel(id, name) {
     const channel = this.requireChannel(id);
-    const copy = { ...channel, id: this.newChannelId(), name: _optionalChain([name, 'optionalAccess', _354 => _354.trim, 'call', _355 => _355()]) || `${channel.name} copy` };
+    const copy = { ...channel, id: this.newChannelId(), name: _optionalChain([name, 'optionalAccess', _355 => _355.trim, 'call', _356 => _356()]) || `${channel.name} copy` };
     const channels = [...this.getChannels()];
     channels.splice(channels.findIndex((c) => c.id === id) + 1, 0, copy);
     this.setChannels(channels);
@@ -9741,7 +10049,7 @@ var ImageEditorController = (_class12 = class {
   quickMaskSurface() {
     const { width, height } = this.naturalSize;
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _356 => _356.bounds])) return _chunkCWM3CUUXcjs.emptySurface.call(void 0, 1, 0);
+    if (!_optionalChain([sel, 'optionalAccess', _357 => _357.bounds])) return _chunkCWM3CUUXcjs.emptySurface.call(void 0, 1, 0);
     return (sel.width === width && sel.height === height ? sel : _chunkUYXL6ZWQcjs.resizeSelection.call(void 0, sel, width, height)).surface;
   }
   /** The selection a painted Quick Mask surface stands for (it shares the surface's tiles). */
@@ -9762,7 +10070,7 @@ var ImageEditorController = (_class12 = class {
    */
   applySelectionAsLayerMask(layerId, props = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _357 => _357.bounds]) || !this.getAdjustmentLayer(layerId)) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _358 => _358.bounds]) || !this.getAdjustmentLayer(layerId)) return false;
     return this.setLayerMask(layerId, this.maskFromSelection(sel, props));
   }
   setLayerMask(layerId, mask, commitToHistory = true) {
@@ -9802,7 +10110,7 @@ var ImageEditorController = (_class12 = class {
   /** A layer's painted mask over the canvas as a selection mask; null without one (or for a depth mask). */
   layerMaskCoverage(layerId) {
     const layer = this.getLayer(layerId);
-    if (!_optionalChain([layer, 'optionalAccess', _358 => _358.mask]) || layer.mask.source) return null;
+    if (!_optionalChain([layer, 'optionalAccess', _359 => _359.mask]) || layer.mask.source) return null;
     const { width, height } = this.naturalSize;
     const ox = layer.type === "pixel" ? layer.offset.x : 0;
     const oy = layer.type === "pixel" ? layer.offset.y : 0;
@@ -9837,7 +10145,7 @@ var ImageEditorController = (_class12 = class {
       this.state.layers = _chunkHGTDMKNEcjs.mapLayer.call(void 0, this.state.layers, target.id, (l) => {
         const next = { ...l };
         if (_chunkUYXL6ZWQcjs.isDefaultDepthMask.call(void 0, merged)) {
-          if (_optionalChain([next, 'access', _359 => _359.mask, 'optionalAccess', _360 => _360.source])) delete next.mask;
+          if (_optionalChain([next, 'access', _360 => _360.mask, 'optionalAccess', _361 => _361.source])) delete next.mask;
         } else next.mask = _chunkUYXL6ZWQcjs.depthRasterMask.call(void 0, merged);
         return next;
       });
@@ -9847,7 +10155,7 @@ var ImageEditorController = (_class12 = class {
   resetDepthMask() {
     this.recordHistory();
     const target = this.developLayer();
-    if (_optionalChain([target, 'optionalAccess', _361 => _361.mask, 'optionalAccess', _362 => _362.source])) {
+    if (_optionalChain([target, 'optionalAccess', _362 => _362.mask, 'optionalAccess', _363 => _363.source])) {
       this.state.layers = _chunkHGTDMKNEcjs.mapLayer.call(void 0, this.state.layers, target.id, (l) => {
         const next = { ...l };
         delete next.mask;
@@ -9859,7 +10167,7 @@ var ImageEditorController = (_class12 = class {
   // --- Annotations & Layers ---
   /** The layer showing annotation `id`: an annotation layer, or a shape layer migrated from it. */
   annotationLayer(id) {
-    return _chunkHGTDMKNEcjs.flattenLayers.call(void 0, this.state.layers).find((l) => (l.type === "annotation" || l.type === "shape" || l.type === "type") && _optionalChain([_chunkUYXL6ZWQcjs.annotationOfLayer.call(void 0, l), 'optionalAccess', _363 => _363.id]) === id);
+    return _chunkHGTDMKNEcjs.flattenLayers.call(void 0, this.state.layers).find((l) => (l.type === "annotation" || l.type === "shape" || l.type === "type") && _optionalChain([_chunkUYXL6ZWQcjs.annotationOfLayer.call(void 0, l), 'optionalAccess', _364 => _364.id]) === id);
   }
   /** What migrating an annotation needs: the canvas size, patterns and the text shaper. */
   annotationEnv() {
@@ -9877,7 +10185,7 @@ var ImageEditorController = (_class12 = class {
     const fullAnnotation = { ...annotation, id };
     const layer = _chunkUYXL6ZWQcjs.annotationLayerFor.call(void 0, fullAnnotation, this.annotationEnv());
     const loc = placement.aboveId ? _chunkHGTDMKNEcjs.findLayer.call(void 0, this.state.layers, placement.aboveId) : null;
-    this.state.layers = loc ? _chunkHGTDMKNEcjs.insertLayer.call(void 0, this.state.layers, layer, _nullishCoalesce(_optionalChain([loc, 'access', _364 => _364.parent, 'optionalAccess', _365 => _365.id]), () => ( null)), loc.index + 1) : _chunkHGTDMKNEcjs.insertLayer.call(void 0, this.state.layers, layer, null);
+    this.state.layers = loc ? _chunkHGTDMKNEcjs.insertLayer.call(void 0, this.state.layers, layer, _nullishCoalesce(_optionalChain([loc, 'access', _365 => _365.parent, 'optionalAccess', _366 => _366.id]), () => ( null)), loc.index + 1) : _chunkHGTDMKNEcjs.insertLayer.call(void 0, this.state.layers, layer, null);
     this.state.selectedAnnotationId = id;
     this.notify();
     return id;
@@ -9957,7 +10265,7 @@ var ImageEditorController = (_class12 = class {
     this.notify();
   }
   // --- Rendering & Export ---
-  __init100() {this.blankSource = null}
+  __init104() {this.blankSource = null}
   /**
    * What the renderer draws from: the source image, or, for a document without one (an opened
    * PSD, a v3 document loaded on its own), a transparent canvas of the document size, since every
@@ -10000,7 +10308,7 @@ var ImageEditorController = (_class12 = class {
       await this.renderer.renderToCanvas(targetCanvas, source, this.state, {
         ...options,
         // The clone source follows the brush cursor (both editors pass it).
-        cloneSourceMarker: _optionalChain([options, 'optionalAccess', _366 => _366.cloneSourceMarker]) !== void 0 ? options.cloneSourceMarker : _optionalChain([options, 'optionalAccess', _367 => _367.brushCursor]) ? this.cloneSourceMarker(options.brushCursor) : null,
+        cloneSourceMarker: _optionalChain([options, 'optionalAccess', _367 => _367.cloneSourceMarker]) !== void 0 ? options.cloneSourceMarker : _optionalChain([options, 'optionalAccess', _368 => _368.brushCursor]) ? this.cloneSourceMarker(options.brushCursor) : null,
         dirty: dirty === "all" ? void 0 : dirty,
         checkpointLayerId: this.state.activeLayerId
       });
@@ -10013,7 +10321,7 @@ var ImageEditorController = (_class12 = class {
       return this.renderer.createCanvas(1, 1);
     }
     this.syncViews();
-    if (_optionalChain([options, 'optionalAccess', _368 => _368.layerIds])) {
+    if (_optionalChain([options, 'optionalAccess', _369 => _369.layerIds])) {
       const keep = new Set(options.layerIds);
       const layers = _chunkHGTDMKNEcjs.flattenLayers.call(void 0, this.state.layers).filter((l) => keep.has(l.id));
       return this.renderer.renderExport(source, { ...this.state, layers }, options);
@@ -10167,7 +10475,7 @@ var ImageEditorController = (_class12 = class {
     let px2 = await this.decodeImage(newDataUrl);
     if (px2.width !== width || px2.height !== height) px2 = resizePixels(px2, width, height);
     const data = new Uint8ClampedArray(px2.data);
-    const sel = _optionalChain([this, 'access', _369 => _369.state, 'access', _370 => _370.selection, 'optionalAccess', _371 => _371.bounds]) ? this.state.selection : null;
+    const sel = _optionalChain([this, 'access', _370 => _370.state, 'access', _371 => _371.selection, 'optionalAccess', _372 => _372.bounds]) ? this.state.selection : null;
     if (sel) for (let p = 0, i = 3; p < width * height; p++, i += 4) data[i] = Math.round(data[i] * sel.data[p] / 255);
     return this.addPixelLayer({ name: "Inpaint", pixels: { width, height, data } });
   }
@@ -10214,7 +10522,7 @@ var ImageEditorController = (_class12 = class {
   }
   /** Font families the shaper offers (generic families at least). */
   listFonts() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _372 => _372.getTextShaper, 'call', _373 => _373(), 'optionalAccess', _374 => _374.families, 'optionalCall', _375 => _375()]), () => ( ["sans-serif", "serif", "monospace"]));
+    return _nullishCoalesce(_optionalChain([this, 'access', _373 => _373.getTextShaper, 'call', _374 => _374(), 'optionalAccess', _375 => _375.families, 'optionalCall', _376 => _376()]), () => ( ["sans-serif", "serif", "monospace"]));
   }
   typeInfo(id) {
     const layer = _chunkUYXL6ZWQcjs.requireTypeLayer.call(void 0, this.state.layers, id);
@@ -10288,8 +10596,8 @@ var ImageEditorController = (_class12 = class {
     const layer = this.layoutTypeLayer({ ...init, text, orientation: vertical ? "vertical" : "horizontal" });
     const { width, height } = this.naturalSize;
     const b = _chunkCWM3CUUXcjs.contentBounds.call(void 0, layer.surface);
-    const x0 = Math.max(0, _nullishCoalesce(_optionalChain([b, 'optionalAccess', _376 => _376.x]), () => ( 0)));
-    const y0 = Math.max(0, _nullishCoalesce(_optionalChain([b, 'optionalAccess', _377 => _377.y]), () => ( 0)));
+    const x0 = Math.max(0, _nullishCoalesce(_optionalChain([b, 'optionalAccess', _377 => _377.x]), () => ( 0)));
+    const y0 = Math.max(0, _nullishCoalesce(_optionalChain([b, 'optionalAccess', _378 => _378.y]), () => ( 0)));
     const x1 = Math.min(width, b ? b.x + b.width : 0);
     const y1 = Math.min(height, b ? b.y + b.height : 0);
     let mask;
@@ -10466,7 +10774,7 @@ var ImageEditorController = (_class12 = class {
     if (colors.size > 1) warnings.push("The text had several colours; the shape takes the first one.");
     const missing = _chunkBRKVNXDZcjs.layoutText.call(void 0, layer, shaper).missingFonts;
     if (missing.length) warnings.push(`Missing fonts were drawn with a fallback: ${missing.join(", ")}.`);
-    const first = _nullishCoalesce(_optionalChain([layer, 'access', _378 => _378.runs, 'access', _379 => _379.find, 'call', _380 => _380((r) => r.length > 0), 'optionalAccess', _381 => _381.style]), () => ( _chunkBRKVNXDZcjs.DEFAULT_TEXT_STYLE));
+    const first = _nullishCoalesce(_optionalChain([layer, 'access', _379 => _379.runs, 'access', _380 => _380.find, 'call', _381 => _381((r) => r.length > 0), 'optionalAccess', _382 => _382.style]), () => ( _chunkBRKVNXDZcjs.DEFAULT_TEXT_STYLE));
     const fill = first.opacity !== void 0 && first.opacity !== 1 ? { type: "color", color: first.color, opacity: first.opacity } : { type: "color", color: first.color };
     const shape = _chunkUYXL6ZWQcjs.createShapeLayer.call(void 0, { components: [{ op: "combine", subpaths }], fill, stroke: null, name: layer.name }, this.shapeEnv(), layer.id);
     const keep = { visible: layer.visible, opacity: layer.opacity, blend: layer.blend };
@@ -10499,7 +10807,7 @@ var ImageEditorController = (_class12 = class {
   // --- Shape layers ---
   /** What shape rendering needs: the canvas size and the document's patterns. */
   shapeEnv() {
-    return { ...this.naturalSize, pattern: (id) => _nullishCoalesce(_optionalChain([this, 'access', _382 => _382.state, 'access', _383 => _383.patterns, 'optionalAccess', _384 => _384.find, 'call', _385 => _385((p) => p.id === id)]), () => ( null)) };
+    return { ...this.naturalSize, pattern: (id) => _nullishCoalesce(_optionalChain([this, 'access', _383 => _383.state, 'access', _384 => _384.patterns, 'optionalAccess', _385 => _385.find, 'call', _386 => _386((p) => p.id === id)]), () => ( null)) };
   }
   /** One component from tool or UI input (validated). */
   componentFrom(spec, path) {
@@ -10542,9 +10850,9 @@ var ImageEditorController = (_class12 = class {
    * open path) and stroked with `stroke`. Goes above the active layer unless placed. Returns its id.
    */
   addShapeLayer(init) {
-    const specs = _optionalChain([init, 'access', _386 => _386.components, 'optionalAccess', _387 => _387.length]) ? init.components : [init];
-    if (_optionalChain([init, 'access', _388 => _388.components, 'optionalAccess', _389 => _389.length]) && (init.shape !== void 0 || init.subpaths !== void 0)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Give components, or shape / subpaths, not both.");
-    const components = specs.map((c, i) => this.componentFrom(c, _optionalChain([init, 'access', _390 => _390.components, 'optionalAccess', _391 => _391.length]) ? `components[${i}].` : ""));
+    const specs = _optionalChain([init, 'access', _387 => _387.components, 'optionalAccess', _388 => _388.length]) ? init.components : [init];
+    if (_optionalChain([init, 'access', _389 => _389.components, 'optionalAccess', _390 => _390.length]) && (init.shape !== void 0 || init.subpaths !== void 0)) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Give components, or shape / subpaths, not both.");
+    const components = specs.map((c, i) => this.componentFrom(c, _optionalChain([init, 'access', _391 => _391.components, 'optionalAccess', _392 => _392.length]) ? `components[${i}].` : ""));
     const stroke = init.stroke ? _chunkUYXL6ZWQcjs.normalizeShapeStroke.call(void 0, init.stroke, "stroke") : null;
     const openOnly = components.every((c) => !c.live && c.subpaths.every((sp) => !sp.closed));
     const fill = init.fill === void 0 ? stroke && openOnly ? null : _chunkUYXL6ZWQcjs.normalizeShapePaint.call(void 0, this.state.paint.foreground, "fill") : init.fill === null ? null : _chunkUYXL6ZWQcjs.normalizeShapePaint.call(void 0, init.fill, "fill");
@@ -10655,7 +10963,7 @@ var ImageEditorController = (_class12 = class {
       if (layer.locks) next.locks = layer.locks;
       if (this.state.selectedAnnotationId === layer.annotation.id) this.state.selectedAnnotationId = null;
     } else if (layer.type === "pixel") {
-      if (!_optionalChain([layer, 'access', _392 => _392.filters, 'optionalAccess', _393 => _393.length])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${layer.name || id}" is already pixels with no filters to bake.`);
+      if (!_optionalChain([layer, 'access', _393 => _393.filters, 'optionalAccess', _394 => _394.length])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${layer.name || id}" is already pixels with no filters to bake.`);
       _chunkUYXL6ZWQcjs.requireUnlocked.call(void 0, layer, "pixels", "rasterize it");
       const spatial = layer.filters.some((f) => f.enabled && f.kind === "blur");
       const content = { ...layer, visible: true, opacity: 1, blend: "normal" };
@@ -10674,7 +10982,7 @@ var ImageEditorController = (_class12 = class {
       return this.rasterizeSmartObject(id);
     } else if (layer.type === "shape" || layer.type === "type") {
       next = layer.type === "shape" ? _chunkUYXL6ZWQcjs.shapeAsPixelLayer.call(void 0, layer) : _chunkUYXL6ZWQcjs.typeAsPixelLayer.call(void 0, layer);
-      if (this.state.selectedAnnotationId && this.state.selectedAnnotationId === _optionalChain([layer, 'access', _394 => _394.annotation, 'optionalAccess', _395 => _395.id])) this.state.selectedAnnotationId = null;
+      if (this.state.selectedAnnotationId && this.state.selectedAnnotationId === _optionalChain([layer, 'access', _395 => _395.annotation, 'optionalAccess', _396 => _396.id])) this.state.selectedAnnotationId = null;
     } else {
       throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Only shape, type and annotation layers, smart objects and pixel layers with filters rasterize; "${layer.name || id}" is a ${layer.type} layer. Merge it down or flatten instead.`);
     }
@@ -10688,8 +10996,8 @@ var ImageEditorController = (_class12 = class {
     const doc = this.state.colorProfile;
     const p = resolveProfile(doc);
     const m = this.state.colorMode;
-    const out = { name: _nullishCoalesce(_optionalChain([doc, 'optionalAccess', _396 => _396.name]), () => ( p.description)), builtin: doc ? _nullishCoalesce(doc.builtin, () => ( null)) : "srgb", colorSpace: p.colorSpace, srgb: isSrgb(doc), mode: _nullishCoalesce(_optionalChain([m, 'optionalAccess', _397 => _397.mode]), () => ( "rgb")) };
-    if (_optionalChain([m, 'optionalAccess', _398 => _398.mode]) === "cmyk") out.cmykProfile = { name: m.profile.name, builtin: _nullishCoalesce(m.profile.builtin, () => ( null)), intent: m.intent };
+    const out = { name: _nullishCoalesce(_optionalChain([doc, 'optionalAccess', _397 => _397.name]), () => ( p.description)), builtin: doc ? _nullishCoalesce(doc.builtin, () => ( null)) : "srgb", colorSpace: p.colorSpace, srgb: isSrgb(doc), mode: _nullishCoalesce(_optionalChain([m, 'optionalAccess', _398 => _398.mode]), () => ( "rgb")) };
+    if (_optionalChain([m, 'optionalAccess', _399 => _399.mode]) === "cmyk") out.cmykProfile = { name: m.profile.name, builtin: _nullishCoalesce(m.profile.builtin, () => ( null)), intent: m.intent };
     return out;
   }
   /**
@@ -10779,7 +11087,7 @@ var ImageEditorController = (_class12 = class {
     const textEnv = this.textEnv();
     const walk = (layers) => layers.map((l) => {
       let next2 = l;
-      if (_optionalChain([l, 'access', _399 => _399.effects, 'optionalAccess', _400 => _400.items, 'access', _401 => _401.length])) next2 = { ...next2, effects: convertColorFields(l.effects, hex) };
+      if (_optionalChain([l, 'access', _400 => _400.effects, 'optionalAccess', _401 => _401.items, 'access', _402 => _402.length])) next2 = { ...next2, effects: convertColorFields(l.effects, hex) };
       if (l.type === "group") {
         if (next2 !== l) converted.push(l.id);
         return { ...next2, children: walk(l.children) };
@@ -10963,8 +11271,8 @@ var ImageEditorController = (_class12 = class {
     else delete s.bitDepth;
     delete s.colorProfile;
     delete s.colorMode;
-    if (_optionalChain([result, 'access', _402 => _402.sourceMode, 'optionalAccess', _403 => _403.mode]) === "cmyk") s.colorMode = { mode: "cmyk", profile: result.sourceMode.profile, intent: "relative" };
-    else if (_optionalChain([result, 'access', _404 => _404.sourceMode, 'optionalAccess', _405 => _405.mode]) === "lab") s.colorMode = { mode: "lab" };
+    if (_optionalChain([result, 'access', _403 => _403.sourceMode, 'optionalAccess', _404 => _404.mode]) === "cmyk") s.colorMode = { mode: "cmyk", profile: result.sourceMode.profile, intent: "relative" };
+    else if (_optionalChain([result, 'access', _405 => _405.sourceMode, 'optionalAccess', _406 => _406.mode]) === "lab") s.colorMode = { mode: "lab" };
     else if (result.iccProfile) {
       try {
         const doc = documentProfile(result.iccProfile);
@@ -11028,7 +11336,7 @@ var ImageEditorController = (_class12 = class {
     const compositor = new (0, _chunkUYXL6ZWQcjs.LayerCompositor)();
     const bakeMask = (layer) => {
       const mask = layer.mask;
-      if (!_optionalChain([mask, 'optionalAccess', _406 => _406.source])) return mask;
+      if (!_optionalChain([mask, 'optionalAccess', _407 => _407.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 ox = layer.type === "pixel" ? layer.offset.x : 0;
@@ -11045,7 +11353,7 @@ var ImageEditorController = (_class12 = class {
     };
     const prepare = async (layer) => {
       const p = await prepareLayer(layer);
-      if (_optionalChain([p, 'optionalAccess', _407 => _407.blend]) === "pigment") add2("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
+      if (_optionalChain([p, 'optionalAccess', _408 => _408.blend]) === "pigment") add2("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
       return p;
     };
     const prepareLayer = async (layer) => {
@@ -11088,7 +11396,7 @@ var ImageEditorController = (_class12 = class {
         return out2;
       }
       if (layer.type === "shape" || layer.type === "type") {
-        if (layer.type === "type" && _optionalChain([layer, 'access', _408 => _408.missingFonts, 'optionalAccess', _409 => _409.length])) add2(`Type layers drawn with a fallback for missing fonts (${layer.missingFonts.join(", ")}) keep the font names, so Photoshop may draw them differently`, layer.name);
+        if (layer.type === "type" && _optionalChain([layer, 'access', _409 => _409.missingFonts, 'optionalAccess', _410 => _410.length])) add2(`Type layers drawn with a fallback for missing fonts (${layer.missingFonts.join(", ")}) keep the font names, so Photoshop may draw them differently`, layer.name);
         const out2 = { ...layer };
         const mask2 = bakeMask(layer);
         if (mask2) out2.mask = mask2;
@@ -11107,7 +11415,7 @@ var ImageEditorController = (_class12 = class {
         out.surface = this.surfaceOf(layer);
         delete out.source;
       }
-      const active = _nullishCoalesce(_optionalChain([layer, 'access', _410 => _410.filters, 'optionalAccess', _411 => _411.filter, 'call', _412 => _412(_chunkUYXL6ZWQcjs.isActiveFilter)]), () => ( []));
+      const active = _nullishCoalesce(_optionalChain([layer, 'access', _411 => _411.filters, 'optionalAccess', _412 => _412.filter, 'call', _413 => _413(_chunkUYXL6ZWQcjs.isActiveFilter)]), () => ( []));
       if (active.length) {
         add2("Layer filters (develop, blur) were baked into the pixels", layer.name);
         const content = { ...out, visible: true, opacity: 1, blend: "normal" };
@@ -11118,7 +11426,7 @@ var ImageEditorController = (_class12 = class {
         const data = compositor.composite([content], canvas, sources);
         out = { ...out, surface: _chunkCWM3CUUXcjs.surfaceFromPixels.call(void 0, { width, height, data }, 4, -layer.offset.x, -layer.offset.y) };
       }
-      if (_optionalChain([layer, 'access', _413 => _413.filters, 'optionalAccess', _414 => _414.some, 'call', _415 => _415((f) => !f.enabled)])) add2("Disabled layer filters were left out", layer.name);
+      if (_optionalChain([layer, 'access', _414 => _414.filters, 'optionalAccess', _415 => _415.some, 'call', _416 => _416((f) => !f.enabled)])) add2("Disabled layer filters were left out", layer.name);
       delete out.filters;
       const mask = bakeMask(layer);
       if (mask) out.mask = mask;
@@ -11182,7 +11490,7 @@ var ImageEditorController = (_class12 = class {
         );
       }
       layers = resizeLegacyMasks(layers, prev, next.dimensions);
-      const env = { ...next.dimensions, pattern: (pid) => _nullishCoalesce(_optionalChain([this, 'access', _416 => _416.state, 'access', _417 => _417.patterns, 'optionalAccess', _418 => _418.find, 'call', _419 => _419((p) => p.id === pid)]), () => ( null)) };
+      const env = { ...next.dimensions, pattern: (pid) => _nullishCoalesce(_optionalChain([this, 'access', _417 => _417.state, 'access', _418 => _418.patterns, 'optionalAccess', _419 => _419.find, 'call', _420 => _420((p) => p.id === pid)]), () => ( null)) };
       for (const l of _chunkHGTDMKNEcjs.flattenLayers.call(void 0, layers)) {
         if (l.type === "annotation") {
           layers = _chunkHGTDMKNEcjs.mapLayer.call(void 0, layers, l.id, () => ({ ...l, annotation: scaleAnnotation(l.annotation, sx, sy) }));
@@ -11191,7 +11499,7 @@ var ImageEditorController = (_class12 = class {
           const scaled = a ? scaleAnnotation(a, sx, sy) : null;
           const fromAnnotation = scaled ? _chunkUYXL6ZWQcjs.shapeFromAnnotation.call(void 0, scaled) : null;
           const m = [sx, 0, 0, sy, 0, 0];
-          const components = _nullishCoalesce(_optionalChain([fromAnnotation, 'optionalAccess', _420 => _420.components]), () => ( _chunkUYXL6ZWQcjs.transformShapeComponents.call(void 0, l.components, (p) => ({ x: p.x * sx, y: p.y * sy }), m)));
+          const components = _nullishCoalesce(_optionalChain([fromAnnotation, 'optionalAccess', _421 => _421.components]), () => ( _chunkUYXL6ZWQcjs.transformShapeComponents.call(void 0, l.components, (p) => ({ x: p.x * sx, y: p.y * sy }), m)));
           const moved = { ...l, components, ...fromAnnotation ? { fill: fromAnnotation.fill, stroke: fromAnnotation.stroke } : {} };
           if (scaled && fromAnnotation) moved.annotation = scaled;
           else delete moved.annotation;
@@ -11209,7 +11517,7 @@ var ImageEditorController = (_class12 = class {
     this.notify();
   }
   toJSON(options) {
-    const root = _optionalChain([this, 'access', _421 => _421.contentsStack, 'access', _422 => _422[0], 'optionalAccess', _423 => _423.saved]);
+    const root = _optionalChain([this, 'access', _422 => _422.contentsStack, 'access', _423 => _423[0], 'optionalAccess', _424 => _424.saved]);
     const current = this.state;
     const element = this.imageElement;
     if (root) {
@@ -11220,8 +11528,8 @@ var ImageEditorController = (_class12 = class {
     let out;
     try {
       out = this.serializeState();
-      if (_optionalChain([this, 'access', _424 => _424.state, 'access', _425 => _425.selection, 'optionalAccess', _426 => _426.bounds])) out.selection = _chunkUYXL6ZWQcjs.serializeSelection.call(void 0, this.state.selection);
-      if (_optionalChain([this, 'access', _427 => _427.state, 'access', _428 => _428.channels, 'optionalAccess', _429 => _429.length])) out.channels = serializeChannels(this.state.channels);
+      if (_optionalChain([this, 'access', _425 => _425.state, 'access', _426 => _426.selection, 'optionalAccess', _427 => _427.bounds])) out.selection = _chunkUYXL6ZWQcjs.serializeSelection.call(void 0, this.state.selection);
+      if (_optionalChain([this, 'access', _428 => _428.state, 'access', _429 => _429.channels, 'optionalAccess', _430 => _430.length])) out.channels = serializeChannels(this.state.channels);
     } finally {
       if (root) {
         this.state = current;
@@ -11270,7 +11578,7 @@ var ImageEditorController = (_class12 = class {
     this.notify();
   }
   /** Problems found by the last `loadJSON` / `initialState` of a v3 document (unreadable layers or assets). */
-  __init101() {this.lastLoadProblems = []}
+  __init105() {this.lastLoadProblems = []}
   applyStored(raw) {
     const s = this.state;
     const data = migrateSerializedImageEditorState(raw);
@@ -11335,10 +11643,10 @@ var ImageEditorController = (_class12 = class {
   serializeState() {
     const { width, height } = this.naturalSize;
     const view = _chunkUYXL6ZWQcjs.legacyView.call(void 0, this.stack(), width, height, null);
-    if (view.exact && !this.state.globalLight && !_optionalChain([this, 'access', _430 => _430.state, 'access', _431 => _431.patterns, 'optionalAccess', _432 => _432.length]) && this.bitDepth === 8 && !this.state.colorProfile && !this.state.colorMode) {
+    if (view.exact && !this.state.globalLight && !_optionalChain([this, 'access', _431 => _431.state, 'access', _432 => _432.patterns, 'optionalAccess', _433 => _433.length]) && this.bitDepth === 8 && !this.state.colorProfile && !this.state.colorMode) {
       return {
         // States without adjustment layers keep schema 1, so they round-trip unchanged.
-        version: _optionalChain([view, 'access', _433 => _433.adjustments, 'access', _434 => _434.layers, 'optionalAccess', _435 => _435.length]) ? 2 : 1,
+        version: _optionalChain([view, 'access', _434 => _434.adjustments, 'access', _435 => _435.layers, 'optionalAccess', _436 => _436.length]) ? 2 : 1,
         crop: this.state.crop ? { ...this.state.crop } : null,
         transform: { ...this.state.transform },
         adjustments: serializeAdjustments(view.adjustments),
@@ -11363,17 +11671,17 @@ var ImageEditorController = (_class12 = class {
     };
     if (this.state.legacyOutputBlur !== void 0) out.legacyOutputBlur = this.state.legacyOutputBlur;
     if (this.state.globalLight) out.globalLight = { ...this.state.globalLight };
-    if (_optionalChain([this, 'access', _436 => _436.state, 'access', _437 => _437.patterns, 'optionalAccess', _438 => _438.length])) out.patterns = _chunkUYXL6ZWQcjs.serializePatterns.call(void 0, this.state.patterns);
+    if (_optionalChain([this, 'access', _437 => _437.state, 'access', _438 => _438.patterns, 'optionalAccess', _439 => _439.length])) out.patterns = _chunkUYXL6ZWQcjs.serializePatterns.call(void 0, this.state.patterns);
     if (smartContents) out.smartContents = smartContents;
     if (this.state.bitDepth === 16 || this.state.bitDepth === 32) out.bitDepth = this.state.bitDepth;
     if (this.state.colorProfile) out.colorProfile = serializeColorProfile(this.state.colorProfile);
     if (this.state.colorMode) out.colorMode = serializeColorMode(this.state.colorMode);
     return out;
   }
-}, _class12);
+}, _class13);
 function serializeAdjustments(adjustments) {
   const out = { ...adjustments };
-  if (_optionalChain([out, 'access', _439 => _439.layers, 'optionalAccess', _440 => _440.length])) out.layers = JSON.parse(JSON.stringify(out.layers));
+  if (_optionalChain([out, 'access', _440 => _440.layers, 'optionalAccess', _441 => _441.length])) out.layers = JSON.parse(JSON.stringify(out.layers));
   else delete out.layers;
   if (_chunkUYXL6ZWQcjs.normalizeProcessVersion.call(void 0, out.process) === _chunkUYXL6ZWQcjs.LEGACY_PROCESS_VERSION) {
     delete out.process;
@@ -11409,11 +11717,11 @@ function withDevelop(layer, partial) {
   return { ...layer, filters };
 }
 function withBlur(layer, radius) {
-  const existing = _optionalChain([layer, 'access', _441 => _441.filters, 'optionalAccess', _442 => _442.find, 'call', _443 => _443((f) => f.kind === "blur")]);
+  const existing = _optionalChain([layer, 'access', _442 => _442.filters, 'optionalAccess', _443 => _443.find, 'call', _444 => _444((f) => f.kind === "blur")]);
   const filters = (_nullishCoalesce(layer.filters, () => ( []))).filter((f) => f.kind !== "blur");
   if (radius > 0) {
     filters.push({
-      id: _nullishCoalesce(_optionalChain([existing, 'optionalAccess', _444 => _444.id]), () => ( (layer.source === "document" ? _chunkUYXL6ZWQcjs.BLUR_FILTER_ID : _chunkUYXL6ZWQcjs.newLayerId.call(void 0, "flt")))),
+      id: _nullishCoalesce(_optionalChain([existing, 'optionalAccess', _445 => _445.id]), () => ( (layer.source === "document" ? _chunkUYXL6ZWQcjs.BLUR_FILTER_ID : _chunkUYXL6ZWQcjs.newLayerId.call(void 0, "flt")))),
       kind: "blur",
       enabled: true,
       radius
@@ -11509,7 +11817,7 @@ function collectStateTiles(layers, into) {
     if (l.type === "shape" || l.type === "type") _chunkCWM3CUUXcjs.collectTiles.call(void 0, l.surface, into);
     if (l.type === "smart") {
       _chunkCWM3CUUXcjs.collectTiles.call(void 0, l.surface, into);
-      if (_optionalChain([l, 'access', _445 => _445.smartFilters, 'optionalAccess', _446 => _446.mask])) _chunkCWM3CUUXcjs.collectTiles.call(void 0, l.smartFilters.mask.surface, into);
+      if (_optionalChain([l, 'access', _446 => _446.smartFilters, 'optionalAccess', _447 => _447.mask])) _chunkCWM3CUUXcjs.collectTiles.call(void 0, l.smartFilters.mask.surface, into);
       if (l.contents.raster) _chunkCWM3CUUXcjs.collectTiles.call(void 0, l.contents.raster, into);
       if (l.contents.document) collectStateTiles(l.contents.document.layers, into);
     }
@@ -11541,7 +11849,7 @@ function pixelsOnly(layers) {
   for (const l of layers) {
     if (l.type === "adjustment") continue;
     if (l.type === "group") out.push({ ...l, children: pixelsOnly(l.children) });
-    else if (l.type === "pixel" && _optionalChain([l, 'access', _447 => _447.filters, 'optionalAccess', _448 => _448.length])) {
+    else if (l.type === "pixel" && _optionalChain([l, 'access', _448 => _448.filters, 'optionalAccess', _449 => _449.length])) {
       const p = { ...l };
       delete p.filters;
       out.push(p);
@@ -11607,7 +11915,7 @@ function toHex(c) {
   return "#" + [c[0], c[1], c[2]].map((v) => Math.round(v).toString(16).padStart(2, "0")).join("");
 }
 function normalizeSelection(mask) {
-  return _optionalChain([mask, 'optionalAccess', _449 => _449.bounds]) ? mask : null;
+  return _optionalChain([mask, 'optionalAccess', _450 => _450.bounds]) ? mask : null;
 }
 function sameSelection(a, b) {
   if (a.width !== b.width || a.height !== b.height) return false;
@@ -11817,7 +12125,7 @@ function loadImageEditorDocument(input) {
   }
   const state = { version: 1, ...result.value };
   if (isV2) {
-    if (_optionalChain([state, 'access', _450 => _450.adjustments, 'access', _451 => _451.layers, 'optionalAccess', _452 => _452.length])) state.version = 2;
+    if (_optionalChain([state, 'access', _451 => _451.adjustments, 'access', _452 => _452.layers, 'optionalAccess', _453 => _453.length])) state.version = 2;
     result.report.version = 2;
   }
   if (state.selection === void 0) delete state.selection;
@@ -12025,7 +12333,7 @@ function findAdjustmentControl(id) {
 }
 function findLayerControl(kind, id) {
   if (id === "opacity") return ADJUSTMENT_LAYER_OPACITY_CONTROL;
-  return _optionalChain([ADJUSTMENT_LAYER_CONTROLS, 'access', _453 => _453[kind], 'optionalAccess', _454 => _454.find, 'call', _455 => _455((c) => c.id === id)]);
+  return _optionalChain([ADJUSTMENT_LAYER_CONTROLS, 'access', _454 => _454[kind], 'optionalAccess', _455 => _455.find, 'call', _456 => _456((c) => c.id === id)]);
 }
 function clampControlValue(spec, v) {
   if (typeof v !== "number" || !Number.isFinite(v)) return spec.default;
@@ -12242,7 +12550,7 @@ var DEPTH_MASK_CONTROLS = [
 // src/image-editor/playback.ts
 var IMAGE_PLAYBACK_KIND = "layer";
 var PAINT = /^(paint_stroke|clone_stamp|heal_brush|spot_heal|dodge|burn|sponge|smudge|blur_stroke|sharpen_stroke|history_brush|set_clone_source|set_clone_transform|fill_pixels|clear_pixels|set_paint|set_retouch_options|load_mixer_brush|clean_mixer_brush)$/;
-var SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|quick_select|select_line|magic_wand|grow_selection|select_similar|reselect|select_layer_transparency|select_color_range|load_selection_from_image|load_selection_from_mask|set_selection_display|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy|stroke_selection|content_aware_fill|copy_pixels|cut_pixels|paste_pixels|save_selection|load_selection_from_channel|set_channel_properties|duplicate_channel|delete_channel|load_channel_from_image|set_quick_mask|path_to_selection|select_text_shape)$/;
+var SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|quick_select|select_object|select_line|magic_wand|grow_selection|select_similar|reselect|select_layer_transparency|select_color_range|load_selection_from_image|load_selection_from_mask|set_selection_display|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy|stroke_selection|content_aware_fill|copy_pixels|cut_pixels|paste_pixels|save_selection|load_selection_from_channel|set_channel_properties|duplicate_channel|delete_channel|load_channel_from_image|set_quick_mask|path_to_selection|select_text_shape)$/;
 var ANNOTATE = /^(add_shape_layer|update_shape|add_shape_component|set_shape_component|remove_shape_component|merge_shape_components|add_text_layer|set_text|set_text_style|set_paragraph_style|set_text_frame|set_text_orientation|convert_text_to_shape)$/;
 var CROP = /^(set_crop|crop_to_selection|reset_crop|set_rotation|flip_image|transform_layer|warp_layer|flip_layer|offset_layer)$/;
 var ADJUST = /^(set_adjustments|add_adjustment_layer|update_adjustment_layer|remove_adjustment_layer|move_adjustment_layer)$/;
@@ -12365,6 +12673,7 @@ var SELECTION_TOOLS = [
   { 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" }
@@ -12405,6 +12714,8 @@ var DEFAULT_SELECTION_TOOL_OPTIONS = {
   quickSize: 30,
   quickSampleAll: true,
   quickEnhance: false,
+  objectSampleAll: true,
+  objectEnhance: false,
   typeText: "Type",
   typeSize: 72,
   typeFamily: "sans-serif"
@@ -12477,7 +12788,7 @@ function summary(controller) {
   const area = _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel);
   return {
     empty: !sel,
-    bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _456 => _456.bounds]), () => ( null)),
+    bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _457 => _457.bounds]), () => ( null)),
     /** Σ coverage in pixels. */
     area: Math.round(area),
     percent: Math.round(area / Math.max(1, width * height) * 1e4) / 100,
@@ -12553,7 +12864,7 @@ function createImageSelectionTools(controller) {
           break;
         }
         case "polygon": {
-          const list = Array.isArray(points) ? points.map((p) => ({ x: num2(_optionalChain([p, 'optionalAccess', _457 => _457.x]), NaN), y: num2(_optionalChain([p, 'optionalAccess', _458 => _458.y]), NaN) })) : [];
+          const list = Array.isArray(points) ? points.map((p) => ({ x: num2(_optionalChain([p, 'optionalAccess', _458 => _458.x]), NaN), y: num2(_optionalChain([p, 'optionalAccess', _459 => _459.y]), NaN) })) : [];
           if (list.length < 3 || !list.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) {
             throw new Error("polygon needs points: at least 3 { x, y } vertices.");
           }
@@ -12790,7 +13101,7 @@ function createImageSelectionTools(controller) {
     },
     annotations: writeAnnotations("Select a polygon (lasso)", true),
     handler: async (args) => {
-      const list = Array.isArray(args.points) ? args.points.map((p) => ({ x: num2(_optionalChain([p, 'optionalAccess', _459 => _459.x]), NaN), y: num2(_optionalChain([p, 'optionalAccess', _460 => _460.y]), NaN) })) : [];
+      const list = Array.isArray(args.points) ? args.points.map((p) => ({ x: num2(_optionalChain([p, 'optionalAccess', _460 => _460.x]), NaN), y: num2(_optionalChain([p, 'optionalAccess', _461 => _461.y]), NaN) })) : [];
       if (list.length < 3 || !list.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) {
         throw new Error("points needs at least 3 { x, y } vertices in natural image pixels.");
       }
@@ -12827,7 +13138,7 @@ function createImageSelectionTools(controller) {
     },
     annotations: writeAnnotations("Quick Selection"),
     handler: async (args) => {
-      const strokes = Array.isArray(args.strokes) ? args.strokes.map((s) => Array.isArray(s) ? s.map((p) => ({ x: num2(_optionalChain([p, 'optionalAccess', _461 => _461.x]), NaN), y: num2(_optionalChain([p, 'optionalAccess', _462 => _462.y]), NaN) })) : []) : [];
+      const strokes = Array.isArray(args.strokes) ? args.strokes.map((s) => Array.isArray(s) ? s.map((p) => ({ x: num2(_optionalChain([p, 'optionalAccess', _462 => _462.x]), NaN), y: num2(_optionalChain([p, 'optionalAccess', _463 => _463.y]), NaN) })) : []) : [];
       if (!strokes.length || strokes.some((s) => !s.length || !s.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y)))) {
         throw new Error("strokes needs at least one stroke of { x, y } points in natural image pixels.");
       }
@@ -12840,6 +13151,39 @@ function createImageSelectionTools(controller) {
       return summary(controller);
     }
   };
+  const selectObjectTool = {
+    name: "select_object",
+    title: "Object Selection",
+    description: "Object Selection: selects the object inside rect (a box drawn loosely around it, natural image pixels; what lies outside the box is treated as background) or the object under point, found from the colours of object and background and the edges between them (GrabCut). Combined with the selection by mode. A box is more reliable than a point: make it a little larger than the object on every side. Check with get_selection and capture_view, then fix with quick_select strokes or select_object with mode add / subtract. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rect: {
+          type: "object",
+          properties: rectProperties,
+          required: ["x", "y", "width", "height"],
+          additionalProperties: false,
+          description: "A box around the object (x, y, width, height in natural image pixels). Pass this or point."
+        },
+        point: { ...pointSchema, description: "A point on the object (natural image pixels). Pass this or rect." },
+        mode: modeSchema,
+        sampleAllLayers: { type: "boolean", description: "Read every layer (default true); false reads only the active pixel layer." },
+        enhanceEdge: { type: "boolean", description: "Smoother, less blocky edges (Auto-Enhance; default false)." }
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Object Selection"),
+    handler: async (args) => {
+      const rect = args.rect;
+      const point = args.point;
+      if (!rect && !point) throw new Error("Pass rect (a box around the object) or point (a point on it).");
+      if (rect && point) throw new Error("Pass rect or point, not both.");
+      const options = { mode: _chunkUYXL6ZWQcjs.parseSelectionMode.call(void 0, args.mode), sampleAllLayers: args.sampleAllLayers, enhanceEdge: args.enhanceEdge };
+      if (rect) await controller.selectObject({ rect: { x: num2(rect.x, NaN), y: num2(rect.y, NaN), width: num2(rect.width, NaN), height: num2(rect.height, NaN) } }, options);
+      else await controller.selectObject({ point: { x: num2(point.x, NaN), y: num2(point.y, NaN) } }, options);
+      return summary(controller);
+    }
+  };
   const magicWandTool = {
     name: "magic_wand",
     title: "Magic wand",
@@ -12933,7 +13277,7 @@ function createImageSelectionTools(controller) {
         await controller.selectColorRangePreset(args.preset, { ...common, falloff: num2(args.fuzziness, 20) });
       } else {
         const samples = args.samples.map((s, i) => {
-          if (typeof _optionalChain([s, 'optionalAccess', _463 => _463.color]) !== "string" || !/^#?[0-9a-f]{6}$/i.test(s.color.trim())) throw new Error(`samples[${i}].color must be #rrggbb.`);
+          if (typeof _optionalChain([s, 'optionalAccess', _464 => _464.color]) !== "string" || !/^#?[0-9a-f]{6}$/i.test(s.color.trim())) throw new Error(`samples[${i}].color must be #rrggbb.`);
           const at = typeof s.x === "number" && typeof s.y === "number" ? { x: s.x, y: s.y } : void 0;
           return at ? { color: s.color, at } : { color: s.color };
         });
@@ -13393,6 +13737,7 @@ function createImageSelectionTools(controller) {
     selectEllipse,
     selectPolygonTool,
     quickSelectTool,
+    selectObjectTool,
     lineTool,
     magicWandTool,
     colorRangeTool,
@@ -13449,12 +13794,12 @@ function createImageSubjectSelectionTool(controller) {
     annotations: { ...writeAnnotations("Select a subject"), openWorldHint: true },
     handler: async ({ target, maxSegments, mode, feather }, context) => {
       if (typeof target !== "string" || !target.trim()) throw new Error("target must describe what to select.");
-      const perform = _optionalChain([context, 'optionalAccess', _464 => _464.perform]);
+      const perform = _optionalChain([context, 'optionalAccess', _465 => _465.perform]);
       const { segments } = await controller.selectSubject(target, {
         mode: _chunkUYXL6ZWQcjs.parseSelectionMode.call(void 0, mode),
         feather: num2(feather, 0),
         maxSegments: typeof maxSegments === "number" ? Math.max(1, Math.round(maxSegments)) : void 0,
-        signal: _optionalChain([context, 'optionalAccess', _465 => _465.signal]),
+        signal: _optionalChain([context, 'optionalAccess', _466 => _466.signal]),
         // Under playback the cursor traces what the model found, as a lasso, before it is selected.
         beforeApply: perform ? (outlines) => perform(planOutlineTrace(outlines)) : void 0
       });
@@ -13533,7 +13878,7 @@ async function renderImageRegion(controller, request) {
     const maskView = maskViewCanvas(controller, document);
     if (maskView) context.drawImage(maskView, rect.x, rect.y, rect.width, rect.height, 0, 0, out.width, out.height);
     const selection = state.selection;
-    if (_optionalChain([selection, 'optionalAccess', _466 => _466.bounds]) && selection.width === state.imageDimensions.width && selection.height === state.imageDimensions.height) {
+    if (_optionalChain([selection, 'optionalAccess', _467 => _467.bounds]) && selection.width === state.imageDimensions.width && selection.height === state.imageDimensions.height) {
       const shade = selectionShade(selection, document);
       if (shade) context.drawImage(shade, rect.x, rect.y, rect.width, rect.height, 0, 0, out.width, out.height);
     }
@@ -13558,7 +13903,7 @@ function createImageCaptureSurface(controller) {
   return {
     units: "image pixels",
     content: whole,
-    selection: () => ({ rect: _nullishCoalesce(_optionalChain([controller, 'access', _467 => _467.getState, 'call', _468 => _468(), 'access', _469 => _469.selection, 'optionalAccess', _470 => _470.bounds]), () => ( null)) }),
+    selection: () => ({ rect: _nullishCoalesce(_optionalChain([controller, 'access', _468 => _468.getState, 'call', _469 => _469(), 'access', _470 => _470.selection, 'optionalAccess', _471 => _471.bounds]), () => ( null)) }),
     overlays: "a shade over unselected pixels, the crop box outline and a layer mask view (set_mask_view)",
     maxScale: 8,
     render: (request) => renderImageRegion(controller, request)
@@ -13892,7 +14237,7 @@ function describeLayer(layer, activeId, boundsOf) {
       out.bounds = boundsOf(layer);
       out.fillOpacity = round3(_nullishCoalesce(layer.fillOpacity, () => ( 1)));
       out.shape = {
-        components: layer.components.map((c) => ({ op: c.op, kind: _nullishCoalesce(_optionalChain([c, 'access', _471 => _471.live, 'optionalAccess', _472 => _472.kind]), () => ( "path")) })),
+        components: layer.components.map((c) => ({ op: c.op, kind: _nullishCoalesce(_optionalChain([c, 'access', _472 => _472.live, 'optionalAccess', _473 => _473.kind]), () => ( "path")) })),
         fill: layer.fill ? layer.fill.type : null,
         stroke: layer.stroke ? { width: layer.stroke.width, paint: layer.stroke.paint.type } : null
       };
@@ -13915,8 +14260,8 @@ function describeLayer(layer, activeId, boundsOf) {
       out.bounds = boundsOf(layer);
       out.fillOpacity = round3(_nullishCoalesce(layer.fillOpacity, () => ( 1)));
       out.contents = { id: layer.contents.id, name: layer.contents.name, kind: layer.contents.kind, width: layer.contents.width, height: layer.contents.height };
-      out.smartFilters = (_nullishCoalesce(_optionalChain([layer, 'access', _473 => _473.smartFilters, 'optionalAccess', _474 => _474.filters]), () => ( []))).map((f) => ({ id: f.id, kind: f.kind, enabled: f.enabled }));
-      out.filterMask = maskSummary(_optionalChain([layer, 'access', _475 => _475.smartFilters, 'optionalAccess', _476 => _476.mask]));
+      out.smartFilters = (_nullishCoalesce(_optionalChain([layer, 'access', _474 => _474.smartFilters, 'optionalAccess', _475 => _475.filters]), () => ( []))).map((f) => ({ id: f.id, kind: f.kind, enabled: f.enabled }));
+      out.filterMask = maskSummary(_optionalChain([layer, 'access', _476 => _476.smartFilters, 'optionalAccess', _477 => _477.mask]));
       break;
   }
   return out;
@@ -13944,7 +14289,7 @@ function createImageLayerTools(controller) {
     if (!loc) return null;
     return {
       ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)),
-      parentId: _nullishCoalesce(_optionalChain([loc, 'access', _477 => _477.parent, 'optionalAccess', _478 => _478.id]), () => ( null)),
+      parentId: _nullishCoalesce(_optionalChain([loc, 'access', _478 => _478.parent, 'optionalAccess', _479 => _479.id]), () => ( null)),
       index: loc.index
     };
   };
@@ -14267,7 +14612,7 @@ function createImageLayerTools(controller) {
       if (view !== "gray" && view !== "overlay" && view !== "off") throw new Error(`Unknown view "${String(view)}". Use gray, overlay or off.`);
       const id = view === "off" || layerId === void 0 ? void 0 : exists(layerId);
       const shown = controller.setMaskView(view, id);
-      return { view: _nullishCoalesce(_optionalChain([shown, 'optionalAccess', _479 => _479.mode]), () => ( "off")), layerId: _nullishCoalesce(_optionalChain([shown, 'optionalAccess', _480 => _480.layerId]), () => ( null)) };
+      return { view: _nullishCoalesce(_optionalChain([shown, 'optionalAccess', _480 => _480.mode]), () => ( "off")), layerId: _nullishCoalesce(_optionalChain([shown, 'optionalAccess', _481 => _481.layerId]), () => ( null)) };
     }
   };
   const maskProps = {
@@ -14760,31 +15105,31 @@ function snapTo45(from, point) {
   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 = (_class13 = class {
-  constructor(controller, getOptions) {;_class13.prototype.__init102.call(this);_class13.prototype.__init103.call(this);_class13.prototype.__init104.call(this);_class13.prototype.__init105.call(this);_class13.prototype.__init106.call(this);_class13.prototype.__init107.call(this);_class13.prototype.__init108.call(this);_class13.prototype.__init109.call(this);_class13.prototype.__init110.call(this);_class13.prototype.__init111.call(this);_class13.prototype.__init112.call(this);
+var SelectionGesture = (_class14 = class {
+  constructor(controller, getOptions) {;_class14.prototype.__init106.call(this);_class14.prototype.__init107.call(this);_class14.prototype.__init108.call(this);_class14.prototype.__init109.call(this);_class14.prototype.__init110.call(this);_class14.prototype.__init111.call(this);_class14.prototype.__init112.call(this);_class14.prototype.__init113.call(this);_class14.prototype.__init114.call(this);_class14.prototype.__init115.call(this);_class14.prototype.__init116.call(this);
     this.controller = controller;
     this.getOptions = getOptions;
   }
   
   
-  __init102() {this.start = null}
-  __init103() {this.points = []}
-  __init104() {this.current = null}
-  __init105() {this.modifiers = {}}
+  __init106() {this.start = null}
+  __init107() {this.points = []}
+  __init108() {this.current = null}
+  __init109() {this.modifiers = {}}
   /** Polygonal lasso corners while one is being drawn. */
-  __init106() {this.polygon = null}
-  __init107() {this.pressedAt = null}
-  __init108() {this.freehand = false}
-  __init109() {this.magnetic = null}
+  __init110() {this.polygon = null}
+  __init111() {this.pressedAt = null}
+  __init112() {this.freehand = false}
+  __init113() {this.magnetic = null}
   /** A click this close to the first corner (natural pixels) closes a polygonal lasso. */
-  __init110() {this.closeRadius = 8}
+  __init114() {this.closeRadius = 8}
   /** The last error (e.g. pixels unavailable for the wand), for the UI to show. */
-  __init111() {this.error = null}
-  __init112() {this.pending = Promise.resolve()}
+  __init115() {this.error = null}
+  __init116() {this.pending = Promise.resolve()}
   get active() {
     return this.start !== null || this.polygon !== null || this.magnetic !== null;
   }
-  /** Resolves once a Quick Selection stroke has been applied. */
+  /** Resolves once a Quick Selection stroke or an Object Selection has been applied. */
   get settled() {
     return this.pending;
   }
@@ -14954,6 +15299,20 @@ var SelectionGesture = (_class13 = class {
     if (point) this.move(point);
     const options = this.getOptions();
     const mode = selectionModeFromModifiers(_nullishCoalesce(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: _nullishCoalesce(options.objectSampleAll, () => ( true)), enhanceEdge: _nullishCoalesce(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;
@@ -15107,7 +15466,7 @@ var SelectionGesture = (_class13 = class {
     this.pressedAt = null;
     this.freehand = false;
   }
-}, _class13);
+}, _class14);
 function handleSelectionShortcut(controller, e, onError) {
   if (!(e.ctrlKey || e.metaKey)) return false;
   const key = e.key.toLowerCase();
@@ -15115,7 +15474,7 @@ function handleSelectionShortcut(controller, e, onError) {
     try {
       fn();
     } catch (err) {
-      _optionalChain([onError, 'optionalCall', _481 => _481(err instanceof Error ? err.message : String(err))]);
+      _optionalChain([onError, 'optionalCall', _482 => _482(err instanceof Error ? err.message : String(err))]);
     }
     return true;
   };
@@ -15130,9 +15489,9 @@ 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 (!_optionalChain([layer, 'optionalAccess', _482 => _482.mask]) || layer.mask.source) return false;
+  if (!_optionalChain([layer, 'optionalAccess', _483 => _483.mask]) || layer.mask.source) return false;
   const view = controller.getMaskView();
-  controller.setMaskView(_optionalChain([view, 'optionalAccess', _483 => _483.layerId]) === layer.id && view.mode === "overlay" ? "off" : "overlay", layer.id);
+  controller.setMaskView(_optionalChain([view, 'optionalAccess', _484 => _484.layerId]) === layer.id && view.mode === "overlay" ? "off" : "overlay", layer.id);
   return true;
 }
 function handleQuickMaskKey(controller, e) {
@@ -15326,15 +15685,15 @@ function handlePaintShortcut(controller, e) {
   }
   return false;
 }
-var PaintGesture = (_class14 = class {
-  constructor(controller) {;_class14.prototype.__init113.call(this);_class14.prototype.__init114.call(this);_class14.prototype.__init115.call(this);
+var PaintGesture = (_class15 = class {
+  constructor(controller) {;_class15.prototype.__init117.call(this);_class15.prototype.__init118.call(this);_class15.prototype.__init119.call(this);
     this.controller = controller;
   }
   
-  __init113() {this.stroke = null}
-  __init114() {this.move = null}
+  __init117() {this.stroke = null}
+  __init118() {this.move = null}
   /** The last refusal (e.g. "layer is locked"), for the editor to show. */
-  __init115() {this.error = null}
+  __init119() {this.error = null}
   get active() {
     return Boolean(this.stroke || this.move);
   }
@@ -15346,7 +15705,7 @@ var PaintGesture = (_class14 = class {
         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 (_optionalChain([layer, 'access', _484 => _484.locks, 'optionalAccess', _485 => _485.all]) || _optionalChain([layer, 'access', _486 => _486.locks, 'optionalAccess', _487 => _487.position])) throw new Error(`Layer "${layer.name}" has its position locked.`);
+        if (_optionalChain([layer, 'access', _485 => _485.locks, 'optionalAccess', _486 => _486.all]) || _optionalChain([layer, 'access', _487 => _487.locks, 'optionalAccess', _488 => _488.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 = _chunkUYXL6ZWQcjs.shapeGeometryBounds.call(void 0, layer);
           return b ? { x: b.x, y: b.y } : { x: 0, y: 0 };
@@ -15403,11 +15762,11 @@ var PaintGesture = (_class14 = class {
     this.move = null;
   }
   cancel() {
-    _optionalChain([this, 'access', _488 => _488.stroke, 'optionalAccess', _489 => _489.cancel, 'call', _490 => _490()]);
+    _optionalChain([this, 'access', _489 => _489.stroke, 'optionalAccess', _490 => _490.cancel, 'call', _491 => _491()]);
     this.stroke = null;
     this.move = null;
   }
-}, _class14);
+}, _class15);
 
 // src/image-editor/paint-tools.ts
 var READ4 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
@@ -16484,7 +16843,7 @@ function createImageSmartObjectTools(controller) {
   const layerSummary = (id) => {
     const s = controller.getState();
     const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, s.layers, id);
-    return loc ? { ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)), parentId: _nullishCoalesce(_optionalChain([loc, 'access', _491 => _491.parent, 'optionalAccess', _492 => _492.id]), () => ( null)), index: loc.index } : null;
+    return loc ? { ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)), parentId: _nullishCoalesce(_optionalChain([loc, 'access', _492 => _492.parent, 'optionalAccess', _493 => _493.id]), () => ( null)), index: loc.index } : null;
   };
   const getSmart = {
     name: "get_smart_object",
@@ -17041,7 +17400,7 @@ function createImageShapeTools(controller) {
   const layerSummary = (id) => {
     const s = controller.getState();
     const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, s.layers, id);
-    return loc ? { ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)), parentId: _nullishCoalesce(_optionalChain([loc, 'access', _493 => _493.parent, 'optionalAccess', _494 => _494.id]), () => ( null)), index: loc.index } : null;
+    return loc ? { ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)), parentId: _nullishCoalesce(_optionalChain([loc, 'access', _494 => _494.parent, 'optionalAccess', _495 => _495.id]), () => ( null)), index: loc.index } : null;
   };
   const get = {
     name: "get_shape_layer",
@@ -17258,7 +17617,7 @@ function createImageShapeTools(controller) {
       const mode = args.mode;
       controller.pathToSelection(pathSpec(args), { feather: args.feather, antiAlias: args.antiAlias, mode });
       const sel = controller.getSelection();
-      return { empty: !sel, bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _495 => _495.bounds]), () => ( null)), area: Math.round(sel ? _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel) : 0) };
+      return { empty: !sel, bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _496 => _496.bounds]), () => ( null)), area: Math.round(sel ? _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel) : 0) };
     }
   };
   const getVectorMask = {
@@ -17289,7 +17648,7 @@ function createImageShapeTools(controller) {
     handler: (args) => {
       const id = layerArg(args.layerId);
       const spec = pathSpec(args);
-      const hasPath = _optionalChain([spec, 'access', _496 => _496.components, 'optionalAccess', _497 => _497.length]) || spec.shape !== void 0 || spec.subpaths !== void 0;
+      const hasPath = _optionalChain([spec, 'access', _497 => _497.components, 'optionalAccess', _498 => _498.length]) || spec.shape !== void 0 || spec.subpaths !== void 0;
       const from = _nullishCoalesce(args.from, () => ( (hasPath ? "path" : "reveal-all")));
       if (from !== "selection" && TRACE_KEYS.some((k) => args[k] !== void 0)) throw new Error("tolerance, cornerRoundness and minArea apply only to from selection.");
       controller.addVectorMask(id, from, spec, traceOptions(args));
@@ -17409,7 +17768,7 @@ function createImageTypeTools(controller) {
   const layerSummary = (id) => {
     const s = controller.getState();
     const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, s.layers, id);
-    return loc ? { ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)), parentId: _nullishCoalesce(_optionalChain([loc, 'access', _498 => _498.parent, 'optionalAccess', _499 => _499.id]), () => ( null)), index: loc.index } : null;
+    return loc ? { ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)), parentId: _nullishCoalesce(_optionalChain([loc, 'access', _499 => _499.parent, 'optionalAccess', _500 => _500.id]), () => ( null)), index: loc.index } : null;
   };
   const range = (args) => ({ start: args.start, end: args.end });
   const listFonts = {
@@ -17418,7 +17777,7 @@ function createImageTypeTools(controller) {
     description: "Returns the font families type layers can use here (generic families such as sans-serif always work). Changes nothing.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
     annotations: { title: "List fonts", ...READ11 },
-    handler: () => ({ families: controller.listFonts(), shaper: _nullishCoalesce(_optionalChain([controller, 'access', _500 => _500.getTextShaper, 'call', _501 => _501(), 'optionalAccess', _502 => _502.id]), () => ( null)) })
+    handler: () => ({ families: controller.listFonts(), shaper: _nullishCoalesce(_optionalChain([controller, 'access', _501 => _501.getTextShaper, 'call', _502 => _502(), 'optionalAccess', _503 => _503.id]), () => ( null)) })
   };
   const get = {
     name: "get_text_layer",
@@ -17574,7 +17933,7 @@ function createImageTypeTools(controller) {
       const init = pick2(args, ["text", "x", "y", "orientation", "box", "style", "paragraph", "rotation", "mode", "feather", "antiAlias"]);
       controller.selectTextShape(init);
       const sel = controller.getSelection();
-      return { empty: !sel, bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _503 => _503.bounds]), () => ( null)), area: Math.round(sel ? _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel) : 0) };
+      return { empty: !sel, bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _504 => _504.bounds]), () => ( null)), area: Math.round(sel ? _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel) : 0) };
     }
   };
   return [listFonts, get, add2, setText, setStyle, setParagraph, setFrame, setOrientation, toShape, typeMask];
@@ -17753,7 +18112,7 @@ function createImageEditorToolProvider(controller, options = {}) {
       for (const ref of [aboveId, parentId]) {
         if (ref !== void 0 && !controller.getLayer(ref)) throw new Error(`Unknown layer "${ref}". Call list_layers for ids.`);
       }
-      if (parentId !== void 0 && _optionalChain([controller, 'access', _504 => _504.getLayer, 'call', _505 => _505(parentId), 'optionalAccess', _506 => _506.type]) !== "group") throw new Error(`Layer "${parentId}" is not a group.`);
+      if (parentId !== void 0 && _optionalChain([controller, 'access', _505 => _505.getLayer, 'call', _506 => _506(parentId), 'optionalAccess', _507 => _507.type]) !== "group") throw new Error(`Layer "${parentId}" is not a group.`);
       const id = controller.addAdjustmentLayer({ kind, params, opacity, blend, name, aboveId, parentId, useSelection: useSelection !== false });
       const layer = controller.getAdjustmentLayer(id);
       return { layer: JSON.parse(JSON.stringify(layer)), index: controller.getAdjustmentLayers().findIndex((l) => l.id === id), masked: Boolean(layer.mask) };
@@ -18067,7 +18426,7 @@ function maskThumbnailClick(controller, layer, e) {
   } else if (e.altKey && !layer.mask.source) {
     const mode = e.shiftKey ? "overlay" : "gray";
     const view = controller.getMaskView();
-    controller.setMaskView(_optionalChain([view, 'optionalAccess', _507 => _507.layerId]) === layer.id && view.mode === mode ? "off" : mode, layer.id);
+    controller.setMaskView(_optionalChain([view, 'optionalAccess', _508 => _508.layerId]) === layer.id && view.mode === mode ? "off" : mode, layer.id);
   } else if (e.shiftKey) {
     controller.setLayerMaskProps(layer.id, { enabled: layer.mask.enabled === false });
   } else {
@@ -18131,7 +18490,7 @@ function layerHasThumbnail(layer) {
   return layer.type === "pixel" || layer.type === "shape" || layer.type === "type";
 }
 function layerWarning(layer) {
-  if (layer.type === "type" && _optionalChain([layer, 'access', _508 => _508.missingFonts, 'optionalAccess', _509 => _509.length])) {
+  if (layer.type === "type" && _optionalChain([layer, 'access', _509 => _509.missingFonts, 'optionalAccess', _510 => _510.length])) {
     return `Missing ${layer.missingFonts.length === 1 ? "font" : "fonts"}: ${layer.missingFonts.join(", ")}. ${layer.rendering === "stored" ? "Showing the saved pixels until the text is edited." : "Drawn with a fallback font."}`;
   }
   return null;
@@ -18154,16 +18513,16 @@ function layerMenu(controller) {
   const siblings = loc ? loc.parent ? loc.parent.children : s.layers : [];
   const below = loc ? siblings[loc.index - 1] : void 0;
   const hasSel = controller.hasSelection;
-  const isPixel = _optionalChain([active, 'optionalAccess', _510 => _510.type]) === "pixel";
-  const hasOwnPixels = _optionalChain([active, 'optionalAccess', _511 => _511.type]) === "pixel" || _optionalChain([active, 'optionalAccess', _512 => _512.type]) === "shape" || _optionalChain([active, 'optionalAccess', _513 => _513.type]) === "type" || _optionalChain([active, 'optionalAccess', _514 => _514.type]) === "smart";
+  const isPixel = _optionalChain([active, 'optionalAccess', _511 => _511.type]) === "pixel";
+  const hasOwnPixels = _optionalChain([active, 'optionalAccess', _512 => _512.type]) === "pixel" || _optionalChain([active, 'optionalAccess', _513 => _513.type]) === "shape" || _optionalChain([active, 'optionalAccess', _514 => _514.type]) === "type" || _optionalChain([active, 'optionalAccess', _515 => _515.type]) === "smart";
   return [
     { action: "new-layer", label: "New Layer", enabled: true },
     { action: "new-group", label: "New Group", enabled: true },
     { action: "duplicate", label: "Duplicate Layer", enabled: Boolean(active) },
     { action: "delete", label: "Delete Layer", enabled: Boolean(active) },
     { action: "group-selected", label: "Group Layer", enabled: Boolean(active) },
-    { action: "ungroup", label: "Ungroup", enabled: _optionalChain([active, 'optionalAccess', _515 => _515.type]) === "group" },
-    { action: "merge-down", label: "Merge Down", enabled: Boolean(_optionalChain([active, 'optionalAccess', _516 => _516.visible]) && _optionalChain([below, 'optionalAccess', _517 => _517.type]) === "pixel") },
+    { action: "ungroup", label: "Ungroup", enabled: _optionalChain([active, 'optionalAccess', _516 => _516.type]) === "group" },
+    { action: "merge-down", label: "Merge Down", enabled: Boolean(_optionalChain([active, 'optionalAccess', _517 => _517.visible]) && _optionalChain([below, 'optionalAccess', _518 => _518.type]) === "pixel") },
     { action: "merge-visible", label: "Merge Visible", enabled: s.layers.some((l) => l.visible) },
     { action: "flatten", label: "Flatten Image", enabled: s.layers.length > 0 },
     { action: "via-copy", label: "Layer via Copy", enabled: isPixel && hasSel },
@@ -18173,27 +18532,27 @@ function layerMenu(controller) {
     { action: "add-mask-hide-selection", label: "Add Mask Hiding Selection", enabled: Boolean(active) && hasSel },
     { action: "add-mask-transparency", label: "Add Mask from Transparency", enabled: hasOwnPixels },
     { action: "select-transparency", label: "Select Layer Pixels", enabled: hasOwnPixels },
-    { action: "apply-mask", label: "Apply Layer Mask", enabled: isPixel && Boolean(_optionalChain([active, 'optionalAccess', _518 => _518.mask])) },
-    { action: "delete-mask", label: "Delete Layer Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _519 => _519.mask])) },
-    { action: "toggle-mask", label: _optionalChain([active, 'optionalAccess', _520 => _520.mask, 'optionalAccess', _521 => _521.enabled]) === false ? "Enable Layer Mask" : "Disable Layer Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _522 => _522.mask])) },
-    { action: "toggle-mask-link", label: _optionalChain([active, 'optionalAccess', _523 => _523.mask, 'optionalAccess', _524 => _524.linked]) === false ? "Link Layer Mask" : "Unlink Layer Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _525 => _525.mask]) && !active.mask.source) },
-    { action: "add-vector-mask", label: "Add Vector Mask (Reveal All)", enabled: Boolean(active && active.type !== "shape" && !_optionalChain([active, 'access', _526 => _526.mask, 'optionalAccess', _527 => _527.source])) },
-    { action: "add-vector-mask-hide", label: "Add Vector Mask (Hide All)", enabled: Boolean(active && active.type !== "shape" && !_optionalChain([active, 'access', _528 => _528.mask, 'optionalAccess', _529 => _529.source])) },
-    { action: "add-vector-mask-selection", label: "Add Vector Mask from Selection", enabled: Boolean(active && active.type !== "shape" && !_optionalChain([active, 'access', _530 => _530.mask, 'optionalAccess', _531 => _531.source])) && hasSel },
-    { action: "delete-vector-mask", label: "Delete Vector Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _532 => _532.vectorMask])) },
-    { action: "toggle-vector-mask", label: _optionalChain([active, 'optionalAccess', _533 => _533.vectorMask, 'optionalAccess', _534 => _534.enabled]) === false ? "Enable Vector Mask" : "Disable Vector Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _535 => _535.vectorMask])) },
-    { action: "rasterize-vector-mask", label: "Rasterize Vector Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _536 => _536.vectorMask])) },
-    { action: "rasterize", label: "Rasterize Layer", enabled: _optionalChain([active, 'optionalAccess', _537 => _537.type]) === "annotation" || _optionalChain([active, 'optionalAccess', _538 => _538.type]) === "smart" || _optionalChain([active, 'optionalAccess', _539 => _539.type]) === "shape" || _optionalChain([active, 'optionalAccess', _540 => _540.type]) === "type" || isPixel && Boolean(_optionalChain([active, 'optionalAccess', _541 => _541.type]) === "pixel" && _optionalChain([active, 'access', _542 => _542.filters, 'optionalAccess', _543 => _543.length])) },
+    { action: "apply-mask", label: "Apply Layer Mask", enabled: isPixel && Boolean(_optionalChain([active, 'optionalAccess', _519 => _519.mask])) },
+    { action: "delete-mask", label: "Delete Layer Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _520 => _520.mask])) },
+    { action: "toggle-mask", label: _optionalChain([active, 'optionalAccess', _521 => _521.mask, 'optionalAccess', _522 => _522.enabled]) === false ? "Enable Layer Mask" : "Disable Layer Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _523 => _523.mask])) },
+    { action: "toggle-mask-link", label: _optionalChain([active, 'optionalAccess', _524 => _524.mask, 'optionalAccess', _525 => _525.linked]) === false ? "Link Layer Mask" : "Unlink Layer Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _526 => _526.mask]) && !active.mask.source) },
+    { action: "add-vector-mask", label: "Add Vector Mask (Reveal All)", enabled: Boolean(active && active.type !== "shape" && !_optionalChain([active, 'access', _527 => _527.mask, 'optionalAccess', _528 => _528.source])) },
+    { action: "add-vector-mask-hide", label: "Add Vector Mask (Hide All)", enabled: Boolean(active && active.type !== "shape" && !_optionalChain([active, 'access', _529 => _529.mask, 'optionalAccess', _530 => _530.source])) },
+    { action: "add-vector-mask-selection", label: "Add Vector Mask from Selection", enabled: Boolean(active && active.type !== "shape" && !_optionalChain([active, 'access', _531 => _531.mask, 'optionalAccess', _532 => _532.source])) && hasSel },
+    { action: "delete-vector-mask", label: "Delete Vector Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _533 => _533.vectorMask])) },
+    { action: "toggle-vector-mask", label: _optionalChain([active, 'optionalAccess', _534 => _534.vectorMask, 'optionalAccess', _535 => _535.enabled]) === false ? "Enable Vector Mask" : "Disable Vector Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _536 => _536.vectorMask])) },
+    { action: "rasterize-vector-mask", label: "Rasterize Vector Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _537 => _537.vectorMask])) },
+    { action: "rasterize", label: "Rasterize Layer", enabled: _optionalChain([active, 'optionalAccess', _538 => _538.type]) === "annotation" || _optionalChain([active, 'optionalAccess', _539 => _539.type]) === "smart" || _optionalChain([active, 'optionalAccess', _540 => _540.type]) === "shape" || _optionalChain([active, 'optionalAccess', _541 => _541.type]) === "type" || isPixel && Boolean(_optionalChain([active, 'optionalAccess', _542 => _542.type]) === "pixel" && _optionalChain([active, 'access', _543 => _543.filters, 'optionalAccess', _544 => _544.length])) },
     { action: "convert-smart", label: "Convert to Smart Object", enabled: Boolean(active && active.type !== "annotation") },
-    { action: "edit-contents", label: "Edit Contents", enabled: _optionalChain([active, 'optionalAccess', _544 => _544.type]) === "smart" },
-    { action: "smart-via-copy", label: "New Smart Object via Copy", enabled: _optionalChain([active, 'optionalAccess', _545 => _545.type]) === "smart" },
-    { action: "add-filter-mask", label: "Add Smart Filter Mask", enabled: _optionalChain([active, 'optionalAccess', _546 => _546.type]) === "smart" && !_optionalChain([active, 'access', _547 => _547.smartFilters, 'optionalAccess', _548 => _548.mask]) },
-    { action: "toggle-clip", label: _optionalChain([active, 'optionalAccess', _549 => _549.clipped]) ? "Release Clipping Mask" : "Create Clipping Mask", enabled: Boolean(loc && loc.index > 0) }
+    { action: "edit-contents", label: "Edit Contents", enabled: _optionalChain([active, 'optionalAccess', _545 => _545.type]) === "smart" },
+    { action: "smart-via-copy", label: "New Smart Object via Copy", enabled: _optionalChain([active, 'optionalAccess', _546 => _546.type]) === "smart" },
+    { action: "add-filter-mask", label: "Add Smart Filter Mask", enabled: _optionalChain([active, 'optionalAccess', _547 => _547.type]) === "smart" && !_optionalChain([active, 'access', _548 => _548.smartFilters, 'optionalAccess', _549 => _549.mask]) },
+    { action: "toggle-clip", label: _optionalChain([active, 'optionalAccess', _550 => _550.clipped]) ? "Release Clipping Mask" : "Create Clipping Mask", enabled: Boolean(loc && loc.index > 0) }
   ];
 }
 async function runLayerMenuAction(controller, action) {
   const active = controller.getActiveLayer();
-  const id = _optionalChain([active, 'optionalAccess', _550 => _550.id]);
+  const id = _optionalChain([active, 'optionalAccess', _551 => _551.id]);
   try {
     switch (action) {
       case "new-layer":
@@ -18249,10 +18608,10 @@ async function runLayerMenuAction(controller, action) {
         if (id) controller.removeLayerMask(id);
         break;
       case "toggle-mask":
-        if (id && _optionalChain([active, 'optionalAccess', _551 => _551.mask])) controller.setLayerMaskProps(id, { enabled: active.mask.enabled === false });
+        if (id && _optionalChain([active, 'optionalAccess', _552 => _552.mask])) controller.setLayerMaskProps(id, { enabled: active.mask.enabled === false });
         break;
       case "toggle-mask-link":
-        if (id && _optionalChain([active, 'optionalAccess', _552 => _552.mask])) controller.setLayerMaskProps(id, { linked: active.mask.linked === false });
+        if (id && _optionalChain([active, 'optionalAccess', _553 => _553.mask])) controller.setLayerMaskProps(id, { linked: active.mask.linked === false });
         break;
       case "add-vector-mask":
       case "add-vector-mask-hide":
@@ -18265,7 +18624,7 @@ async function runLayerMenuAction(controller, action) {
         if (id) controller.removeVectorMask(id);
         break;
       case "toggle-vector-mask":
-        if (id && _optionalChain([active, 'optionalAccess', _553 => _553.vectorMask])) controller.setVectorMaskProps(id, { enabled: active.vectorMask.enabled === false });
+        if (id && _optionalChain([active, 'optionalAccess', _554 => _554.vectorMask])) controller.setVectorMaskProps(id, { enabled: active.vectorMask.enabled === false });
         break;
       case "rasterize-vector-mask":
         if (id) controller.rasterizeVectorMask(id);
@@ -18286,7 +18645,7 @@ async function runLayerMenuAction(controller, action) {
         if (id) controller.setSmartFilterMask(id, "reveal-all");
         break;
       case "toggle-clip":
-        if (id) controller.setLayerProperties(id, { clipped: !_optionalChain([active, 'optionalAccess', _554 => _554.clipped]) });
+        if (id) controller.setLayerProperties(id, { clipped: !_optionalChain([active, 'optionalAccess', _555 => _555.clipped]) });
         break;
     }
     return null;
@@ -18296,7 +18655,7 @@ async function runLayerMenuAction(controller, action) {
 }
 function smartFilterRows(layer) {
   if (layer.type !== "smart") return [];
-  const list = _nullishCoalesce(_optionalChain([layer, 'access', _555 => _555.smartFilters, 'optionalAccess', _556 => _556.filters]), () => ( []));
+  const list = _nullishCoalesce(_optionalChain([layer, 'access', _556 => _556.smartFilters, 'optionalAccess', _557 => _557.filters]), () => ( []));
   const rows = list.map((f, index) => ({
     filter: f,
     index,
@@ -18322,8 +18681,8 @@ function extractNormalizedLayerItems(controller, fallbackImageUrl = "") {
   };
   collectSerialized(_nullishCoalesce(serialized.layers, () => ( [])));
   const sLayerMap = new Map(allSerializedLayers.map((sl) => [sl.id, sl]));
-  const imgW = _optionalChain([state, 'access', _557 => _557.imageDimensions, 'optionalAccess', _558 => _558.width]) || 1;
-  const imgH = _optionalChain([state, 'access', _559 => _559.imageDimensions, 'optionalAccess', _560 => _560.height]) || 1;
+  const imgW = _optionalChain([state, 'access', _558 => _558.imageDimensions, 'optionalAccess', _559 => _559.width]) || 1;
+  const imgH = _optionalChain([state, 'access', _560 => _560.imageDimensions, 'optionalAccess', _561 => _561.height]) || 1;
   return ctrlLayers.map((l) => {
     const bounds = controller.getLayerBounds(l.id) || {
       x: 0,
@@ -18332,8 +18691,8 @@ function extractNormalizedLayerItems(controller, fallbackImageUrl = "") {
       height: imgH
     };
     const sLayer = sLayerMap.get(l.id);
-    const assetKey = _optionalChain([sLayer, 'optionalAccess', _561 => _561.asset]);
-    const layerDataUrl = assetKey && assets[assetKey] || assets[l.id] || (_optionalChain([sLayer, 'optionalAccess', _562 => _562.source]) === "document" ? fallbackImageUrl : "");
+    const assetKey = _optionalChain([sLayer, 'optionalAccess', _562 => _562.asset]);
+    const layerDataUrl = assetKey && assets[assetKey] || assets[l.id] || (_optionalChain([sLayer, 'optionalAccess', _563 => _563.source]) === "document" ? fallbackImageUrl : "");
     return {
       id: l.id,
       name: l.name || "Untitled Layer",
@@ -18387,9 +18746,9 @@ async function addLayerOfKind(controller, id, init) {
     const cx = Math.round(canvas.width / 2);
     const cy = Math.round(canvas.height / 2);
     return controller.addTextLayer({
-      text: _optionalChain([init, 'optionalAccess', _563 => _563.text]) || "New Text",
-      x: typeof _optionalChain([init, 'optionalAccess', _564 => _564.x]) === "number" ? init.x : cx - 100,
-      y: typeof _optionalChain([init, 'optionalAccess', _565 => _565.y]) === "number" ? init.y : cy,
+      text: _optionalChain([init, 'optionalAccess', _564 => _564.text]) || "New Text",
+      x: typeof _optionalChain([init, 'optionalAccess', _565 => _565.x]) === "number" ? init.x : cx - 100,
+      y: typeof _optionalChain([init, 'optionalAccess', _566 => _566.y]) === "number" ? init.y : cy,
       ...init
     });
   }
@@ -18402,10 +18761,10 @@ async function addLayerOfKind(controller, id, init) {
     return controller.addShapeLayer({
       shape: {
         kind: "rect",
-        x: typeof _optionalChain([init, 'optionalAccess', _566 => _566.x]) === "number" ? init.x : cx - Math.round(w / 2),
-        y: typeof _optionalChain([init, 'optionalAccess', _567 => _567.y]) === "number" ? init.y : cy - Math.round(h / 2),
-        width: typeof _optionalChain([init, 'optionalAccess', _568 => _568.width]) === "number" ? init.width : w,
-        height: typeof _optionalChain([init, 'optionalAccess', _569 => _569.height]) === "number" ? init.height : h
+        x: typeof _optionalChain([init, 'optionalAccess', _567 => _567.x]) === "number" ? init.x : cx - Math.round(w / 2),
+        y: typeof _optionalChain([init, 'optionalAccess', _568 => _568.y]) === "number" ? init.y : cy - Math.round(h / 2),
+        width: typeof _optionalChain([init, 'optionalAccess', _569 => _569.width]) === "number" ? init.width : w,
+        height: typeof _optionalChain([init, 'optionalAccess', _570 => _570.height]) === "number" ? init.height : h
       },
       name: "Rectangle",
       ...init
@@ -18420,10 +18779,10 @@ async function addLayerOfKind(controller, id, init) {
     return controller.addShapeLayer({
       shape: {
         kind: "ellipse",
-        x: typeof _optionalChain([init, 'optionalAccess', _570 => _570.x]) === "number" ? init.x : cx - Math.round(w / 2),
-        y: typeof _optionalChain([init, 'optionalAccess', _571 => _571.y]) === "number" ? init.y : cy - Math.round(h / 2),
-        width: typeof _optionalChain([init, 'optionalAccess', _572 => _572.width]) === "number" ? init.width : w,
-        height: typeof _optionalChain([init, 'optionalAccess', _573 => _573.height]) === "number" ? init.height : h
+        x: typeof _optionalChain([init, 'optionalAccess', _571 => _571.x]) === "number" ? init.x : cx - Math.round(w / 2),
+        y: typeof _optionalChain([init, 'optionalAccess', _572 => _572.y]) === "number" ? init.y : cy - Math.round(h / 2),
+        width: typeof _optionalChain([init, 'optionalAccess', _573 => _573.width]) === "number" ? init.width : w,
+        height: typeof _optionalChain([init, 'optionalAccess', _574 => _574.height]) === "number" ? init.height : h
       },
       name: "Ellipse",
       ...init
@@ -18484,18 +18843,18 @@ function layerEffectsPanel(layer) {
   if (!layer) return { ...empty, available: false, reason: "Select a layer to add a layer style." };
   if (layer.type === "adjustment") return { ...empty, available: false, reason: "Adjustment layers cannot have a layer style." };
   const fx = layer.effects;
-  const readOnly = Boolean(_optionalChain([layer, 'access', _574 => _574.locks, 'optionalAccess', _575 => _575.all]));
+  const readOnly = Boolean(_optionalChain([layer, 'access', _575 => _575.locks, 'optionalAccess', _576 => _576.all]));
   return {
     available: true,
     readOnly,
     reason: readOnly ? "The layer is locked; unlock it to change its layer style." : void 0,
-    enabled: _nullishCoalesce(_optionalChain([fx, 'optionalAccess', _576 => _576.enabled]), () => ( true)),
-    scale: _nullishCoalesce(_optionalChain([fx, 'optionalAccess', _577 => _577.scale]), () => ( 1)),
-    rows: (_nullishCoalesce(_optionalChain([fx, 'optionalAccess', _578 => _578.items]), () => ( []))).map((e) => ({ id: e.id, kind: e.kind, label: _chunkHGTDMKNEcjs.layerEffectLabel.call(void 0, e.kind), enabled: e.enabled }))
+    enabled: _nullishCoalesce(_optionalChain([fx, 'optionalAccess', _577 => _577.enabled]), () => ( true)),
+    scale: _nullishCoalesce(_optionalChain([fx, 'optionalAccess', _578 => _578.scale]), () => ( 1)),
+    rows: (_nullishCoalesce(_optionalChain([fx, 'optionalAccess', _579 => _579.items]), () => ( []))).map((e) => ({ id: e.id, kind: e.kind, label: _chunkHGTDMKNEcjs.layerEffectLabel.call(void 0, e.kind), enabled: e.enabled }))
   };
 }
 function layerEffectsBadge(layer) {
-  if (!_optionalChain([layer, 'access', _579 => _579.effects, 'optionalAccess', _580 => _580.items, 'access', _581 => _581.length])) return null;
+  if (!_optionalChain([layer, 'access', _580 => _580.effects, 'optionalAccess', _581 => _581.items, 'access', _582 => _582.length])) return null;
   return _chunkHGTDMKNEcjs.hasActiveEffects.call(void 0, layer.effects) ? "on" : "off";
 }
 var LAYER_EFFECT_MENU = _chunkHGTDMKNEcjs.LAYER_EFFECT_KINDS.map((kind) => ({ kind, label: _chunkHGTDMKNEcjs.layerEffectLabel.call(void 0, kind) }));
@@ -18540,8 +18899,8 @@ function fillControls(f, allowPattern, patterns) {
 }
 function gradientControls(prefix, g) {
   return [
-    { key: `${prefix}.stops.0.color`, label: "Start colour", type: "color", value: _nullishCoalesce(_optionalChain([g, 'access', _582 => _582.stops, 'access', _583 => _583[0], 'optionalAccess', _584 => _584.color]), () => ( "#000000")) },
-    { key: `${prefix}.stops.last.color`, label: "End colour", type: "color", value: _nullishCoalesce(_optionalChain([g, 'access', _585 => _585.stops, 'access', _586 => _586[g.stops.length - 1], 'optionalAccess', _587 => _587.color]), () => ( "#ffffff")) },
+    { key: `${prefix}.stops.0.color`, label: "Start colour", type: "color", value: _nullishCoalesce(_optionalChain([g, 'access', _583 => _583.stops, 'access', _584 => _584[0], 'optionalAccess', _585 => _585.color]), () => ( "#000000")) },
+    { key: `${prefix}.stops.last.color`, label: "End colour", type: "color", value: _nullishCoalesce(_optionalChain([g, 'access', _586 => _586.stops, 'access', _587 => _587[g.stops.length - 1], 'optionalAccess', _588 => _588.color]), () => ( "#ffffff")) },
     { key: `${prefix}.style`, label: "Style", type: "select", value: g.style, options: opt(["linear", "Linear"], ["radial", "Radial"], ["angle", "Angle"], ["reflected", "Reflected"], ["diamond", "Diamond"]) },
     { key: `${prefix}.angle`, label: "Angle", type: "range", min: -180, max: 180, step: 1, value: g.angle, unit: "\xB0" },
     { key: `${prefix}.scale`, label: "Scale", type: "range", min: 0.1, max: 1.5, step: 0.01, value: g.scale, percent: true, unit: "%" },
@@ -18633,19 +18992,19 @@ function layerEffectControls(e, patterns = []) {
 }
 function fillOfType(current, type, patterns) {
   if (type === "gradient") return { type: "gradient", gradient: _chunkHGTDMKNEcjs.defaultEffectGradient.call(void 0, ) };
-  if (type === "pattern") return { type: "pattern", patternId: _nullishCoalesce(_optionalChain([patterns, 'access', _588 => _588[0], 'optionalAccess', _589 => _589.id]), () => ( "checker")), scale: 1 };
+  if (type === "pattern") return { type: "pattern", patternId: _nullishCoalesce(_optionalChain([patterns, 'access', _589 => _589[0], 'optionalAccess', _590 => _590.id]), () => ( "checker")), scale: 1 };
   return { type: "color", color: current.type === "color" ? current.color : "#000000" };
 }
 function effectControlChange(effect, key, value, patterns = []) {
   const [top, ...rest] = key.split(".");
   if (top === "fill" && rest[0] === "type") return { fill: fillOfType(effect.fill, String(value), patterns) };
   if (top === "patternId" && !rest.length) {
-    const name = _optionalChain([patternOptions, 'call', _590 => _590(patterns), 'access', _591 => _591.find, 'call', _592 => _592((o) => o.value === value), 'optionalAccess', _593 => _593.label]);
+    const name = _optionalChain([patternOptions, 'call', _591 => _591(patterns), 'access', _592 => _592.find, 'call', _593 => _593((o) => o.value === value), 'optionalAccess', _594 => _594.label]);
     return name ? { patternId: value, name } : { patternId: value };
   }
   if (!rest.length) return { [top]: value };
   if (top === "fill" && rest[0] === "patternId") {
-    const name = _optionalChain([patternOptions, 'call', _594 => _594(patterns), 'access', _595 => _595.find, 'call', _596 => _596((o) => o.value === value), 'optionalAccess', _597 => _597.label]);
+    const name = _optionalChain([patternOptions, 'call', _595 => _595(patterns), 'access', _596 => _596.find, 'call', _597 => _597((o) => o.value === value), 'optionalAccess', _598 => _598.label]);
     return { fill: { ...effect.fill, patternId: value, ...name ? { name } : {} } };
   }
   return { [top]: setPath(getPath(effect, top), rest, value) };
@@ -18672,7 +19031,7 @@ function colorPanelView(controller) {
     profileName: profile.name,
     workingSpace: profile.builtin,
     mode: profile.mode,
-    cmykProfileName: _nullishCoalesce(_optionalChain([profile, 'access', _598 => _598.cmykProfile, 'optionalAccess', _599 => _599.name]), () => ( null)),
+    cmykProfileName: _nullishCoalesce(_optionalChain([profile, 'access', _599 => _599.cmykProfile, 'optionalAccess', _600 => _600.name]), () => ( null)),
     proof: proof ? { id: _nullishCoalesce(proof.profile.builtin, () => ( null)), name: proof.profile.name, intent: proof.intent, simulatePaper: proof.simulatePaper, gamutWarning: proof.gamutWarning, bpc: proof.bpc } : null
   };
 }
@@ -18854,33 +19213,33 @@ function boxFrameHit(overlay, p, tolerance, band) {
   }
   return null;
 }
-var FreeTransformTool = (_class15 = class {
-  constructor(controller, options = {}) {;_class15.prototype.__init116.call(this);_class15.prototype.__init117.call(this);_class15.prototype.__init118.call(this);_class15.prototype.__init119.call(this);_class15.prototype.__init120.call(this);_class15.prototype.__init121.call(this);_class15.prototype.__init122.call(this);_class15.prototype.__init123.call(this);_class15.prototype.__init124.call(this);_class15.prototype.__init125.call(this);_class15.prototype.__init126.call(this);_class15.prototype.__init127.call(this);_class15.prototype.__init128.call(this);_class15.prototype.__init129.call(this);
+var FreeTransformTool = (_class16 = class {
+  constructor(controller, options = {}) {;_class16.prototype.__init120.call(this);_class16.prototype.__init121.call(this);_class16.prototype.__init122.call(this);_class16.prototype.__init123.call(this);_class16.prototype.__init124.call(this);_class16.prototype.__init125.call(this);_class16.prototype.__init126.call(this);_class16.prototype.__init127.call(this);_class16.prototype.__init128.call(this);_class16.prototype.__init129.call(this);_class16.prototype.__init130.call(this);_class16.prototype.__init131.call(this);_class16.prototype.__init132.call(this);_class16.prototype.__init133.call(this);
     this.controller = controller;
     this.options = options;
   }
   
   
-  __init116() {this.sessionRef = null}
-  __init117() {this.modeValue = "scale"}
+  __init120() {this.sessionRef = null}
+  __init121() {this.modeValue = "scale"}
   /** The reference point in the untransformed frame's space (follows the transform). */
-  __init118() {this.refBox = { x: 0, y: 0 }}
-  __init119() {this.corners = null}
-  __init120() {this.drag = null}
+  __init122() {this.refBox = { x: 0, y: 0 }}
+  __init123() {this.corners = null}
+  __init124() {this.drag = null}
   /** The warp mesh in the frame's own space (null: no warp). */
-  __init121() {this.mesh = null}
-  __init122() {this.warpSettings = { style: "custom", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", columns: 1, rows: 1 }}
-  __init123() {this.pending = false}
-  __init124() {this.viewScale = 1}
+  __init125() {this.mesh = null}
+  __init126() {this.warpSettings = { style: "custom", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", columns: 1, rows: 1 }}
+  __init127() {this.pending = false}
+  __init128() {this.viewScale = 1}
   
   /** Values typed into the options bar since the last drag (V skew is not recovered from the shape). */
-  __init125() {this.typed = {}}
+  __init129() {this.typed = {}}
   /** Width and height scale together when typed (the chain icon). */
-  __init126() {this.proportional = true}
-  __init127() {this.error = null}
-  __init128() {this.lastResult = null}
+  __init130() {this.proportional = true}
+  __init131() {this.error = null}
+  __init132() {this.lastResult = null}
   get active() {
-    return Boolean(_optionalChain([this, 'access', _600 => _600.sessionRef, 'optionalAccess', _601 => _601.isOpen]));
+    return Boolean(_optionalChain([this, 'access', _601 => _601.sessionRef, 'optionalAccess', _602 => _602.isOpen]));
   }
   get session() {
     return this.active ? this.sessionRef : null;
@@ -18889,7 +19248,7 @@ var FreeTransformTool = (_class15 = class {
     return this.modeValue;
   }
   get interpolation() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _602 => _602.sessionRef, 'optionalAccess', _603 => _603.interpolation]), () => ( "bicubic"));
+    return _nullishCoalesce(_optionalChain([this, 'access', _603 => _603.sessionRef, 'optionalAccess', _604 => _604.interpolation]), () => ( "bicubic"));
   }
   /** Whether the open transform has changed anything yet (a commit would add an undo step). */
   get modified() {
@@ -18899,7 +19258,7 @@ var FreeTransformTool = (_class15 = class {
     const start = s.startGeometry.corners;
     return this.corners.some((p, i) => p.x !== start[i].x || p.y !== start[i].y);
   }
-  __init129() {this.listeners = /* @__PURE__ */ new Set()}
+  __init133() {this.listeners = /* @__PURE__ */ new Set()}
   /** Calls `listener` whenever the overlay, readout, mode or error changes. Returns the unsubscribe. */
   subscribe(listener) {
     this.listeners.add(listener);
@@ -18908,7 +19267,7 @@ var FreeTransformTool = (_class15 = class {
     };
   }
   changed() {
-    _optionalChain([this, 'access', _604 => _604.options, 'access', _605 => _605.onChange, 'optionalCall', _606 => _606()]);
+    _optionalChain([this, 'access', _605 => _605.options, 'access', _606 => _606.onChange, 'optionalCall', _607 => _607()]);
     for (const l of this.listeners) l();
   }
   /** Opens a Free Transform (default: the selected pixels of the active layer, or the whole layer). Returns an error message or `null`. */
@@ -19301,7 +19660,7 @@ var FreeTransformTool = (_class15 = class {
   }
   /** Abandons the transform and restores everything. */
   cancel() {
-    _optionalChain([this, 'access', _607 => _607.sessionRef, 'optionalAccess', _608 => _608.cancel, 'call', _609 => _609()]);
+    _optionalChain([this, 'access', _608 => _608.sessionRef, 'optionalAccess', _609 => _609.cancel, 'call', _610 => _610()]);
     this.sessionRef = null;
     this.corners = null;
     this.mesh = null;
@@ -19342,7 +19701,7 @@ var FreeTransformTool = (_class15 = class {
     }
     return false;
   }
-}, _class15);
+}, _class16);
 
 // src/image-editor/provider-effect-tools.ts
 var ANIMATE_SCHEMA = {
@@ -19357,7 +19716,7 @@ function imageLayerAppliedEffects(layer) {
   const ref = (r) => ({ effect: r.effect, ...r.name ? { name: r.name } : {}, ...r.provider ? { provider: r.provider } : {} });
   if (layer.type === "pixel" && layer.generator) out.push({ id: "generator", ...ref(layer.generator), role: "effect layer", enabled: true, values: layer.generator.values, ...layer.generator.time ? { time: layer.generator.time } : {}, ...layer.generator.animate ? { animate: layer.generator.animate } : {} });
   if (layer.type === "smart")
-    (_nullishCoalesce(_optionalChain([layer, 'access', _610 => _610.smartFilters, 'optionalAccess', _611 => _611.filters]), () => ( []))).forEach((f, index) => {
+    (_nullishCoalesce(_optionalChain([layer, 'access', _611 => _611.smartFilters, 'optionalAccess', _612 => _612.filters]), () => ( []))).forEach((f, index) => {
       if (f.kind === "effect") out.push({ id: f.id, ...ref(f), role: "smart filter", enabled: f.enabled && layer.smartFilters.enabled, opacity: f.opacity, blend: f.blend, values: f.values, index });
     });
   return out;
@@ -19509,7 +19868,7 @@ var OTHER_TOOL_LABELS = {
   watermark: "Watermark"
 };
 function imageToolLabel(tool) {
-  return _nullishCoalesce(_nullishCoalesce(_optionalChain([PAINT_TOOLS, 'access', _612 => _612.find, 'call', _613 => _613((t) => t.id === tool), 'optionalAccess', _614 => _614.label]), () => ( OTHER_TOOL_LABELS[tool])), () => ( tool));
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([PAINT_TOOLS, 'access', _613 => _613.find, 'call', _614 => _614((t) => t.id === tool), 'optionalAccess', _615 => _615.label]), () => ( OTHER_TOOL_LABELS[tool])), () => ( tool));
 }
 var IMAGE_TOOL_SHORTCUTS = {
   ...Object.fromEntries(PAINT_TOOLS.filter((t) => t.shortcut).map((t) => [t.id, t.shortcut])),
@@ -20627,4 +20986,11 @@ function createImageEditorDocument(controller, options = {}) {
 
 
 
-exports.ADJUSTMENT_KEYS = _chunkUYXL6ZWQcjs.ADJUSTMENT_KEYS; exports.ADJUSTMENT_KINDS = _chunkUYXL6ZWQcjs.ADJUSTMENT_KINDS; exports.ADJUSTMENT_LAYER_CONTROLS = ADJUSTMENT_LAYER_CONTROLS; exports.ADJUSTMENT_LAYER_OPACITY_CONTROL = ADJUSTMENT_LAYER_OPACITY_CONTROL; exports.ADJUSTMENT_LUT_SIZE = _chunkUYXL6ZWQcjs.ADJUSTMENT_LUT_SIZE; exports.ANCHOR_FRACTION = _chunkUYXL6ZWQcjs.ANCHOR_FRACTION; exports.AS_SHOT_KELVIN = _chunkUYXL6ZWQcjs.AS_SHOT_KELVIN; exports.BACKGROUND_LAYER_ID = _chunkUYXL6ZWQcjs.BACKGROUND_LAYER_ID; exports.BACKGROUND_LAYER_NAME = _chunkUYXL6ZWQcjs.BACKGROUND_LAYER_NAME; exports.BIT_DEPTHS = _chunkCWM3CUUXcjs.BIT_DEPTHS; exports.BIT_DEPTH_OPTIONS = BIT_DEPTH_OPTIONS; exports.BLEND_MODES = _chunkCWM3CUUXcjs.BLEND_MODES; exports.BLUR_FILTER_ID = _chunkUYXL6ZWQcjs.BLUR_FILTER_ID; exports.BODY_SCATTER = _chunkV7GWZIZKcjs.BODY_SCATTER; exports.BRUSHSTROKE_MAX_SCALE = _chunkYQGCPL5Xcjs.BRUSHSTROKE_MAX_SCALE; exports.BRUSHSTROKE_MIN_SCALE = _chunkYQGCPL5Xcjs.BRUSHSTROKE_MIN_SCALE; exports.BRUSH_OPTION_CONTROLS = BRUSH_OPTION_CONTROLS; exports.BUILTIN_PROFILES = _chunkBROJYMWUcjs.BUILTIN_PROFILES; exports.BrushstrokeCache = _chunkEBDCRTZIcjs.BrushstrokeCache; exports.CANVAS_SIZE_PRESETS = CANVAS_SIZE_PRESETS; exports.CLONE_TRANSFORM_CONTROLS = CLONE_TRANSFORM_CONTROLS; exports.COLOR_MODE_OPTIONS = COLOR_MODE_OPTIONS; exports.COLOR_RANGE_PRESETS = COLOR_RANGE_PRESETS; exports.COLOR_RANGE_PRESET_LABELS = COLOR_RANGE_PRESET_LABELS; exports.CoverageMap = _chunkEBDCRTZIcjs.CoverageMap; exports.D50 = _chunkUYXL6ZWQcjs.D50; exports.D65 = _chunkUYXL6ZWQcjs.D65; exports.DEFAULT_ADJUSTMENTS = DEFAULT_ADJUSTMENTS; exports.DEFAULT_AUTO_LEADING = _chunkBRKVNXDZcjs.DEFAULT_AUTO_LEADING; exports.DEFAULT_BLENDER = _chunkEBDCRTZIcjs.DEFAULT_BLENDER; exports.DEFAULT_BRUSH = _chunkEBDCRTZIcjs.DEFAULT_BRUSH; exports.DEFAULT_CANVAS_VIEWPORT = DEFAULT_CANVAS_VIEWPORT; exports.DEFAULT_CHANNEL_COLOR = DEFAULT_CHANNEL_COLOR; exports.DEFAULT_DEPTH_MASK = DEFAULT_DEPTH_MASK; exports.DEFAULT_FLOW = _chunkV7GWZIZKcjs.DEFAULT_FLOW; exports.DEFAULT_GLOBAL_LIGHT = _chunkHGTDMKNEcjs.DEFAULT_GLOBAL_LIGHT; exports.DEFAULT_MITER_LIMIT = _chunkUYXL6ZWQcjs.DEFAULT_MITER_LIMIT; exports.DEFAULT_MIXER = _chunkEBDCRTZIcjs.DEFAULT_MIXER; exports.DEFAULT_PAINT_GRADIENT = _chunkEBDCRTZIcjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkEBDCRTZIcjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PROOF = DEFAULT_PROOF; exports.DEFAULT_REFINE_EDGE_PARAMS = DEFAULT_REFINE_EDGE_PARAMS; exports.DEFAULT_RETOUCH = _chunk7NW46N7Icjs.DEFAULT_RETOUCH; exports.DEFAULT_SELECTION_TOOL_OPTIONS = DEFAULT_SELECTION_TOOL_OPTIONS; exports.DEFAULT_SHAPE_TOOL_OPTIONS = DEFAULT_SHAPE_TOOL_OPTIONS; exports.DEFAULT_SMUDGE = _chunkEBDCRTZIcjs.DEFAULT_SMUDGE; exports.DEFAULT_TEXT_STYLE = _chunkBRKVNXDZcjs.DEFAULT_TEXT_STYLE; exports.DEFAULT_TRANSFORM = DEFAULT_TRANSFORM; exports.DEFAULT_TYPE_TOOL_OPTIONS = DEFAULT_TYPE_TOOL_OPTIONS; exports.DEFAULT_WET_PAPER = _chunkV7GWZIZKcjs.DEFAULT_WET_PAPER; exports.DEFAULT_WET_PARAMS = _chunkV7GWZIZKcjs.DEFAULT_WET_PARAMS; exports.DEPTH_MASK_CONTROLS = DEPTH_MASK_CONTROLS; exports.DEVELOP_FILTER_ID = _chunkUYXL6ZWQcjs.DEVELOP_FILTER_ID; exports.DIRECT_GAUSSIAN_MAX_SIGMA = _chunkHGTDMKNEcjs.DIRECT_GAUSSIAN_MAX_SIGMA; exports.DRY_EPS = _chunkV7GWZIZKcjs.DRY_EPS; exports.DabWalker = _chunkEBDCRTZIcjs.DabWalker; exports.EFFECT_LAYER_USES = EFFECT_LAYER_USES; exports.EMPTY_DISTANCE = _chunkUYXL6ZWQcjs.EMPTY_DISTANCE; exports.EMPTY_MIXER_LOAD = _chunkEBDCRTZIcjs.EMPTY_MIXER_LOAD; exports.EX = _chunkV7GWZIZKcjs.EX; exports.EY = _chunkV7GWZIZKcjs.EY; exports.EdgeMap = EdgeMap; exports.FLAG_ALIVE = _chunkV7GWZIZKcjs.FLAG_ALIVE; exports.FLAG_BOTTOM = _chunkV7GWZIZKcjs.FLAG_BOTTOM; exports.FLAG_LEFT = _chunkV7GWZIZKcjs.FLAG_LEFT; exports.FLAG_RIGHT = _chunkV7GWZIZKcjs.FLAG_RIGHT; exports.FLAG_TOP = _chunkV7GWZIZKcjs.FLAG_TOP; exports.FLAG_WET = _chunkV7GWZIZKcjs.FLAG_WET; exports.FLAT = _chunkV7GWZIZKcjs.FLAT; exports.FREE_INTERVAL = _chunkV7GWZIZKcjs.FREE_INTERVAL; exports.FREE_TRANSFORM_CONTENTS = FREE_TRANSFORM_CONTENTS; exports.FREE_TRANSFORM_FIELDS = FREE_TRANSFORM_FIELDS; exports.FREE_TRANSFORM_MODES = _chunkUYXL6ZWQcjs.FREE_TRANSFORM_MODES; exports.FREE_TRANSFORM_MODE_OPTIONS = FREE_TRANSFORM_MODE_OPTIONS; exports.FreeTransformSession = FreeTransformSession; exports.FreeTransformTool = FreeTransformTool; exports.GRAIN_PATTERNS = _chunkEBDCRTZIcjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkEBDCRTZIcjs.GRAIN_TILE; exports.GUIDED_FILTER_EPS = GUIDED_FILTER_EPS; exports.GridGraph = GridGraph; exports.HIDE = _chunkV7GWZIZKcjs.HIDE; exports.HISTOGRAM_BINS = HISTOGRAM_BINS; exports.HUE_RANGE_LABELS = _chunkUYXL6ZWQcjs.HUE_RANGE_LABELS; exports.HUE_RANGE_PRESETS = HUE_RANGE_PRESETS; exports.IDENTITY_CLONE_TRANSFORM = _chunk7NW46N7Icjs.IDENTITY_CLONE_TRANSFORM; exports.IDENTITY_MATRIX3 = _chunkUYXL6ZWQcjs.IDENTITY_MATRIX3; exports.IMAGE_ADJUSTMENT_CONTROLS = IMAGE_ADJUSTMENT_CONTROLS; exports.IMAGE_CROP_PRESETS = IMAGE_CROP_PRESETS; exports.IMAGE_EDITOR_SCHEMA_VERSION = IMAGE_EDITOR_SCHEMA_VERSION; exports.IMAGE_EDITOR_STATE_VERSION = IMAGE_EDITOR_STATE_VERSION; exports.IMAGE_EFFECT_PLACES = IMAGE_EFFECT_PLACES; exports.IMAGE_FILTER_PRESETS = IMAGE_FILTER_PRESETS; exports.IMAGE_PLAYBACK_KIND = IMAGE_PLAYBACK_KIND; exports.IMAGE_TOOL_GROUPS = IMAGE_TOOL_GROUPS; exports.IMAGE_TOOL_SHORTCUTS = IMAGE_TOOL_SHORTCUTS; exports.INTENTS = _chunkBROJYMWUcjs.INTENTS; exports.INTENT_OPTIONS = INTENT_OPTIONS; exports.INTERPOLATIONS = _chunkHGTDMKNEcjs.INTERPOLATIONS; exports.ImageEditorController = ImageEditorController; exports.ImageEditorRenderer = ImageEditorRenderer; exports.ImageEffectsEngine = ImageEffectsEngine; exports.LATEST_PROCESS_VERSION = _chunkUYXL6ZWQcjs.LATEST_PROCESS_VERSION; exports.LAYERED_SCHEMA_VERSION = _chunkUYXL6ZWQcjs.LAYERED_SCHEMA_VERSION; exports.LAYER_EFFECT_KINDS = _chunkHGTDMKNEcjs.LAYER_EFFECT_KINDS; exports.LAYER_EFFECT_MENU = LAYER_EFFECT_MENU; exports.LEGACY_PROCESS_VERSION = _chunkUYXL6ZWQcjs.LEGACY_PROCESS_VERSION; exports.LIVE_SHAPE_KINDS = _chunkUYXL6ZWQcjs.LIVE_SHAPE_KINDS; exports.LUMA_709 = _chunkUYXL6ZWQcjs.LUMA_709; exports.LayerCompositor = _chunkUYXL6ZWQcjs.LayerCompositor; exports.LayerEffectError = _chunkHGTDMKNEcjs.LayerEffectError; exports.LayerOperationError = _chunkUYXL6ZWQcjs.LayerOperationError; exports.MARCHING_ANTS_STEP_MS = MARCHING_ANTS_STEP_MS; exports.MASK_FILE_ACCEPT = MASK_FILE_ACCEPT; exports.MAX_BATCH = _chunkV7GWZIZKcjs.MAX_BATCH; exports.MAX_BRUSH_SIZE = _chunkEBDCRTZIcjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_BACKING_SIDE = MAX_CANVAS_BACKING_SIDE; exports.MAX_EFFECT_ANIMATION_MS = _chunkUYXL6ZWQcjs.MAX_EFFECT_ANIMATION_MS; exports.MAX_EFFECT_REACH = _chunkHGTDMKNEcjs.MAX_EFFECT_REACH; exports.MAX_KELVIN = _chunkUYXL6ZWQcjs.MAX_KELVIN; exports.MAX_TILT_ACCEL = _chunkV7GWZIZKcjs.MAX_TILT_ACCEL; exports.MAX_TRANSFORM_PIXELS = _chunkHGTDMKNEcjs.MAX_TRANSFORM_PIXELS; exports.MAX_WET_LANES = _chunkV7GWZIZKcjs.MAX_WET_LANES; exports.MAX_WET_SLOTS = _chunkV7GWZIZKcjs.MAX_WET_SLOTS; exports.MIN_KELVIN = _chunkUYXL6ZWQcjs.MIN_KELVIN; exports.MIRED_PER_TEMPERATURE_UNIT = _chunkUYXL6ZWQcjs.MIRED_PER_TEMPERATURE_UNIT; exports.MIXER_DRAIN = _chunkEBDCRTZIcjs.MIXER_DRAIN; exports.MIXER_MIXING_OPTIONS = MIXER_MIXING_OPTIONS; exports.MIXER_OPTION_CONTROLS = MIXER_OPTION_CONTROLS; exports.MIXER_PICKUP_RATE = _chunkEBDCRTZIcjs.MIXER_PICKUP_RATE; exports.MIXING_MODELS = _chunkEBDCRTZIcjs.MIXING_MODELS; exports.MixerStroke = _chunkEBDCRTZIcjs.MixerStroke; exports.OPP = _chunkV7GWZIZKcjs.OPP; exports.PAINTERLY_BLEND_MODES = _chunkCWM3CUUXcjs.PAINTERLY_BLEND_MODES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkEBDCRTZIcjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_GRADIENT_FULL_SPEED = _chunkEBDCRTZIcjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkEBDCRTZIcjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkEBDCRTZIcjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkEBDCRTZIcjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkEBDCRTZIcjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_CAPACITY = _chunkV7GWZIZKcjs.PAPER_CAPACITY; exports.PARAGRAPH_STYLE_FIELDS = _chunkUYXL6ZWQcjs.PARAGRAPH_STYLE_FIELDS; exports.PARAM = _chunkV7GWZIZKcjs.PARAM; exports.PARAM_FLOATS = _chunkV7GWZIZKcjs.PARAM_FLOATS; exports.PASTE_MODES = PASTE_MODES; exports.PATTERN_BLOCK_KEYS = _chunkUYXL6ZWQcjs.PATTERN_BLOCK_KEYS; exports.PIGMENT_BANDS = _chunkCWM3CUUXcjs.PIGMENT_BANDS; exports.PIGMENT_CHANNELS = _chunkV7GWZIZKcjs.PIGMENT_CHANNELS; exports.PIGMENT_LAMBDA_MIN = _chunkCWM3CUUXcjs.PIGMENT_LAMBDA_MIN; exports.PIGMENT_LAMBDA_STEP = _chunkCWM3CUUXcjs.PIGMENT_LAMBDA_STEP; exports.PIGMENT_UNIT = _chunkV7GWZIZKcjs.PIGMENT_UNIT; exports.PIGMENT_WAVELENGTHS = _chunkCWM3CUUXcjs.PIGMENT_WAVELENGTHS; exports.PLANE = _chunkV7GWZIZKcjs.PLANE; exports.PLANE_BYTES = _chunkV7GWZIZKcjs.PLANE_BYTES; exports.PROOF_PROFILE_OPTIONS = PROOF_PROFILE_OPTIONS; exports.PSD_BLEND_KEYS = _chunkUYXL6ZWQcjs.PSD_BLEND_KEYS; exports.PSD_FILE_ACCEPT = PSD_FILE_ACCEPT; exports.P_D0 = _chunkV7GWZIZKcjs.P_D0; exports.P_EDGE = _chunkV7GWZIZKcjs.P_EDGE; exports.P_FX = _chunkV7GWZIZKcjs.P_FX; exports.P_FY = _chunkV7GWZIZKcjs.P_FY; exports.P_H = _chunkV7GWZIZKcjs.P_H; exports.P_P0 = _chunkV7GWZIZKcjs.P_P0; exports.P_RHO = _chunkV7GWZIZKcjs.P_RHO; exports.P_SW = _chunkV7GWZIZKcjs.P_SW; exports.P_UX = _chunkV7GWZIZKcjs.P_UX; exports.P_UY = _chunkV7GWZIZKcjs.P_UY; exports.PaintExchange = _chunkEBDCRTZIcjs.PaintExchange; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _chunkEBDCRTZIcjs.PaintGradientSampler; exports.PaintSourceError = _chunkEBDCRTZIcjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaperGrain = _chunkEBDCRTZIcjs.PaperGrain; exports.PatternPlacement = _chunkHGTDMKNEcjs.PatternPlacement; exports.PatternTile = _chunkHGTDMKNEcjs.PatternTile; exports.PsdError = _chunkUYXL6ZWQcjs.PsdError; exports.QUICK_MASK_TARGET = QUICK_MASK_TARGET; exports.REFINE_EDGE_CONTROLS = REFINE_EDGE_CONTROLS; exports.RETOUCH_CHOICES = RETOUCH_CHOICES; exports.RETOUCH_OPTION_CONTROLS = RETOUCH_OPTION_CONTROLS; exports.RETOUCH_SAMPLES = _chunk7NW46N7Icjs.RETOUCH_SAMPLES; exports.RETOUCH_TOGGLES = RETOUCH_TOGGLES; exports.RETOUCH_TOOLS = RETOUCH_TOOLS; exports.RegionPixelSource = _chunk7NW46N7Icjs.RegionPixelSource; exports.RetouchDabStroke = _chunk7NW46N7Icjs.RetouchDabStroke; exports.SELECTION_MODES = _chunkUYXL6ZWQcjs.SELECTION_MODES; exports.SELECTION_MODE_LABELS = SELECTION_MODE_LABELS; exports.SELECTION_MODIFY_OPS = _chunkUYXL6ZWQcjs.SELECTION_MODIFY_OPS; exports.SELECTION_TOOLS = SELECTION_TOOLS; exports.SET_PLANES = _chunkV7GWZIZKcjs.SET_PLANES; exports.SHADOW_AMBIENT = _chunkCWM3CUUXcjs.SHADOW_AMBIENT; exports.SHAPE_KIND_LABELS = SHAPE_KIND_LABELS; exports.SHAPE_OPERATIONS = _chunkUYXL6ZWQcjs.SHAPE_OPERATIONS; exports.SHAPE_RENDER_MARGIN = _chunkUYXL6ZWQcjs.SHAPE_RENDER_MARGIN; exports.SLOT_BYTES = _chunkV7GWZIZKcjs.SLOT_BYTES; exports.SLOT_PLANES = _chunkV7GWZIZKcjs.SLOT_PLANES; exports.SLOT_SIDE = _chunkV7GWZIZKcjs.SLOT_SIDE; exports.SMART_RENDER_MARGIN = _chunkUYXL6ZWQcjs.SMART_RENDER_MARGIN; exports.SPOT_HEAL_TYPES = _chunk7NW46N7Icjs.SPOT_HEAL_TYPES; exports.SRGB_TO_LINEAR = _chunkV7GWZIZKcjs.SRGB_TO_LINEAR; exports.STRIP = _chunkV7GWZIZKcjs.STRIP; exports.SUPPORTED_ADJUSTMENT_KEYS = _chunkUYXL6ZWQcjs.SUPPORTED_ADJUSTMENT_KEYS; exports.SelectionGesture = SelectionGesture; exports.ShapeDrawGesture = ShapeDrawGesture; exports.SmudgeTip = _chunkEBDCRTZIcjs.SmudgeTip; exports.StrokeCoverage = _chunkEBDCRTZIcjs.StrokeCoverage; exports.SurfaceDraft = _chunkCWM3CUUXcjs.SurfaceDraft; exports.TEXT_ALIGNS = _chunkUYXL6ZWQcjs.TEXT_ALIGNS; exports.TEXT_ORIENTATIONS = _chunkUYXL6ZWQcjs.TEXT_ORIENTATIONS; exports.TEXT_RENDER_MARGIN = _chunkUYXL6ZWQcjs.TEXT_RENDER_MARGIN; exports.TEXT_STYLE_FIELDS = _chunkUYXL6ZWQcjs.TEXT_STYLE_FIELDS; exports.TILE = _chunkCWM3CUUXcjs.TILE; exports.TILE_SHIFT = _chunkCWM3CUUXcjs.TILE_SHIFT; exports.TINT_SCALE = _chunkUYXL6ZWQcjs.TINT_SCALE; exports.TIP_GRADIENT_STEPS = _chunkEBDCRTZIcjs.TIP_GRADIENT_STEPS; exports.TONE_LUT_SIZE = _chunkUYXL6ZWQcjs.TONE_LUT_SIZE; exports.TONE_RANGES = _chunk7NW46N7Icjs.TONE_RANGES; exports.TONE_RANGE_PRESETS = TONE_RANGE_PRESETS; exports.TRANSFORM_ANCHORS = _chunkUYXL6ZWQcjs.TRANSFORM_ANCHORS; exports.TRANSFORM_ROTATE_HANDLE_OFFSET = TRANSFORM_ROTATE_HANDLE_OFFSET; exports.TextEditSession = TextEditSession; exports.TileMedium = _chunkEBDCRTZIcjs.TileMedium; exports.TilePixelSource = _chunk7NW46N7Icjs.TilePixelSource; exports.TileableNoise = _chunkEBDCRTZIcjs.TileableNoise; exports.TiledSurface = _chunkCWM3CUUXcjs.TiledSurface; exports.TransformTooLargeError = _chunkHGTDMKNEcjs.TransformTooLargeError; exports.TransformedPixelSource = _chunk7NW46N7Icjs.TransformedPixelSource; exports.TypeToolGesture = TypeToolGesture; exports.U_MAX = _chunkV7GWZIZKcjs.U_MAX; exports.VIBRANCE_GREY = _chunkUYXL6ZWQcjs.VIBRANCE_GREY; exports.W9 = _chunkV7GWZIZKcjs.W9; exports.WARP_GRID_OPTIONS = WARP_GRID_OPTIONS; exports.WARP_STYLES = _chunkBRKVNXDZcjs.WARP_STYLES; exports.WARP_STYLE_LABELS = _chunkBRKVNXDZcjs.WARP_STYLE_LABELS; exports.WARP_STYLE_OPTIONS = WARP_STYLE_OPTIONS; exports.WET_FLOW_KINDS = _chunkV7GWZIZKcjs.WET_FLOW_KINDS; exports.WET_PARAM_KEYS = _chunkV7GWZIZKcjs.WET_PARAM_KEYS; exports.WET_TILE = _chunkV7GWZIZKcjs.WET_TILE; exports.WGSL_HALO = _chunkV7GWZIZKcjs.WGSL_HALO; exports.WGSL_SHADE = _chunkV7GWZIZKcjs.WGSL_SHADE; exports.WGSL_STEP = _chunkV7GWZIZKcjs.WGSL_STEP; exports.WORKING_SPACE_OPTIONS = WORKING_SPACE_OPTIONS; exports.WORK_SIZE = WORK_SIZE; exports.WetGpuEngine = _chunkV7GWZIZKcjs.WetGpuEngine; exports.WetMedium = _chunkV7GWZIZKcjs.WetMedium; exports.WetWorkerPool = _chunkV7GWZIZKcjs.WetWorkerPool; exports.WetWorld = _chunkV7GWZIZKcjs.WetWorld; exports.WetWorldError = _chunkV7GWZIZKcjs.WetWorldError; exports.XYZ_D50_TO_SRGB = _chunkUYXL6ZWQcjs.XYZ_D50_TO_SRGB; exports.ZlibError = _chunkXFM3OCHUcjs.ZlibError; exports.activeAdjustmentLayers = _chunkUYXL6ZWQcjs.activeAdjustmentLayers; exports.activeEffectSmartFilters = _chunkUYXL6ZWQcjs.activeEffectSmartFilters; exports.activeLayerAfterRemoval = _chunkUYXL6ZWQcjs.activeLayerAfterRemoval; exports.activeSmartFilters = _chunkUYXL6ZWQcjs.activeSmartFilters; exports.addLayerEffect = _chunkUYXL6ZWQcjs.addLayerEffect; exports.addLayerFilter = _chunkUYXL6ZWQcjs.addLayerFilter; exports.addLayerOfKind = addLayerOfKind; exports.addPaintGradientStop = _chunkEBDCRTZIcjs.addPaintGradientStop; exports.addSmartFilter = _chunkUYXL6ZWQcjs.addSmartFilter; exports.addToHistogram = addToHistogram; exports.adjustmentKindLabel = _chunkUYXL6ZWQcjs.adjustmentKindLabel; exports.adjustmentLayersKey = _chunkUYXL6ZWQcjs.adjustmentLayersKey; exports.adjustmentNodeAsLayer = _chunkUYXL6ZWQcjs.adjustmentNodeAsLayer; exports.adjustmentNodeFromLegacy = _chunkUYXL6ZWQcjs.adjustmentNodeFromLegacy; exports.adler32 = _chunkXFM3OCHUcjs.adler32; exports.agentDragDraft = agentDragDraft; exports.anchorPoint = _chunkUYXL6ZWQcjs.anchorPoint; exports.annotationBlend = _chunkUYXL6ZWQcjs.annotationBlend; exports.annotationLayerFor = _chunkUYXL6ZWQcjs.annotationLayerFor; exports.annotationLayerName = _chunkUYXL6ZWQcjs.annotationLayerName; exports.annotationOfLayer = _chunkUYXL6ZWQcjs.annotationOfLayer; exports.annotationOfShape = _chunkUYXL6ZWQcjs.annotationOfShape; exports.annotationOfType = _chunkUYXL6ZWQcjs.annotationOfType; exports.applyAdjustmentLayers = _chunkUYXL6ZWQcjs.applyAdjustmentLayers; exports.applyAdjustmentLayersFloat = _chunkUYXL6ZWQcjs.applyAdjustmentLayersFloat; exports.applyAdjustments = _chunkUYXL6ZWQcjs.applyAdjustments; exports.applyBoxBlur = _chunkUYXL6ZWQcjs.applyBoxBlur; exports.applyBoxBlurFloat = _chunkUYXL6ZWQcjs.applyBoxBlurFloat; exports.applyDepthMask = _chunkUYXL6ZWQcjs.applyDepthMask; exports.applyHomography = _chunkQT26RHKKcjs.applyHomography; exports.applyImageProjectionToContext = _chunkUYXL6ZWQcjs.applyImageProjectionToContext; exports.applyLegacyAdjustments = _chunkUYXL6ZWQcjs.applyLegacyAdjustments; exports.applyLegacyFloat = _chunkUYXL6ZWQcjs.applyLegacyFloat; exports.applyMatrix3 = _chunkUYXL6ZWQcjs.applyMatrix3; exports.applyOutputStage = applyOutputStage; exports.applyParams = _chunkUYXL6ZWQcjs.applyParams; exports.applyProcess2Adjustments = _chunkUYXL6ZWQcjs.applyProcess2Adjustments; exports.applyProcess2Float = _chunkUYXL6ZWQcjs.applyProcess2Float; exports.applyRegionBlur = applyRegionBlur; exports.applyRegionMosaic = applyRegionMosaic; exports.applyRetouchToTile = _chunk7NW46N7Icjs.applyRetouchToTile; exports.applyShapeOptions = applyShapeOptions; exports.applySmartFilters = _chunkUYXL6ZWQcjs.applySmartFilters; exports.applyStrokeToDeepTile = _chunkEBDCRTZIcjs.applyStrokeToDeepTile; exports.applyStrokeToTile = _chunkEBDCRTZIcjs.applyStrokeToTile; exports.applyToneToDeepTile = _chunk7NW46N7Icjs.applyToneToDeepTile; exports.backgroundLayer = _chunkUYXL6ZWQcjs.backgroundLayer; exports.base64ToBytes = _chunkCWM3CUUXcjs.base64ToBytes; exports.baseProjection = baseProjection; exports.bestOffset = _chunk7NW46N7Icjs.bestOffset; exports.blackWhiteGray = _chunkUYXL6ZWQcjs.blackWhiteGray; exports.blendChannel = _chunkCWM3CUUXcjs.blendChannel; exports.blendImageData = _chunkCWM3CUUXcjs.blendImageData; exports.blendLum = _chunkCWM3CUUXcjs.blendLum; exports.blendPixel = _chunkCWM3CUUXcjs.blendPixel; exports.blendRadius = _chunkEBDCRTZIcjs.blendRadius; exports.blendRgb = _chunkCWM3CUUXcjs.blendRgb; exports.blendTile = _chunkHGTDMKNEcjs.blendTile; exports.blenderDab = _chunkEBDCRTZIcjs.blenderDab; exports.blurFilter = _chunkUYXL6ZWQcjs.blurFilter; exports.borderCoverage = _chunkUYXL6ZWQcjs.borderCoverage; exports.boxBlurPixels = _chunk7NW46N7Icjs.boxBlurPixels; exports.boxFrameHit = boxFrameHit; exports.boxFrameOverlay = boxFrameOverlay; exports.boxMean = boxMean; exports.boxPointOf = _chunkUYXL6ZWQcjs.boxPointOf; exports.boxQuad = _chunkQT26RHKKcjs.boxQuad; exports.boxToCurvePoint = boxToCurvePoint; exports.bradfordAdaptation = _chunkUYXL6ZWQcjs.bradfordAdaptation; exports.brushstrokeDataUrl = _chunkEBDCRTZIcjs.brushstrokeDataUrl; exports.brushstrokeKey = _chunkEBDCRTZIcjs.brushstrokeKey; exports.brushstrokeSamples = _chunkEBDCRTZIcjs.brushstrokeSamples; exports.brushstrokeScaleBucket = _chunkYQGCPL5Xcjs.brushstrokeScaleBucket; exports.brushstrokeStrokeOptions = _chunkEBDCRTZIcjs.brushstrokeStrokeOptions; exports.brushstrokeToCanvas = _chunkEBDCRTZIcjs.brushstrokeToCanvas; exports.buildLayerMaskPlanes = _chunkUYXL6ZWQcjs.buildLayerMaskPlanes; exports.buildToneLut = _chunkUYXL6ZWQcjs.buildToneLut; exports.builtinPattern = _chunkHGTDMKNEcjs.builtinPattern; exports.builtinPatternIds = _chunkHGTDMKNEcjs.builtinPatternIds; exports.bytesToBase64 = _chunkCWM3CUUXcjs.bytesToBase64; exports.calculateCropDrag = _chunkUYXL6ZWQcjs.calculateCropDrag; exports.canShareMemory = _chunkV7GWZIZKcjs.canShareMemory; exports.canvasCompositeOperation = _chunkCWM3CUUXcjs.canvasCompositeOperation; exports.canvasToImagePoint = _chunkUYXL6ZWQcjs.canvasToImagePoint; exports.caretAt = _chunkBRKVNXDZcjs.caretAt; exports.changedTiles = _chunkHGTDMKNEcjs.changedTiles; exports.channelThumbnail = channelThumbnail; exports.checkEffectAnimation = checkEffectAnimation; exports.checkEffectTime = checkEffectTime; exports.checkImageEffectPlace = checkImageEffectPlace; exports.clampControlValue = clampControlValue; exports.clampCropToImage = _chunkUYXL6ZWQcjs.clampCropToImage; exports.cleanMixer = _chunkEBDCRTZIcjs.cleanMixer; exports.cloneSamplePoint = _chunk7NW46N7Icjs.cloneSamplePoint; exports.cloneSourceLabel = cloneSourceLabel; exports.cloneTransformView = cloneTransformView; exports.collectTiles = _chunkCWM3CUUXcjs.collectTiles; exports.colorBalanceChannel = _chunkUYXL6ZWQcjs.colorBalanceChannel; exports.colorModePlanes = colorModePlanes; exports.colorModePlanes16 = colorModePlanes16; exports.colorPanelView = colorPanelView; exports.colorRange = colorRange; exports.colorRangePreset = colorRangePreset; exports.combineSelections = _chunkUYXL6ZWQcjs.combineSelections; exports.compileAdjustmentLayer = _chunkUYXL6ZWQcjs.compileAdjustmentLayer; exports.componentPath = _chunkUYXL6ZWQcjs.componentPath; exports.componentsCoverage = _chunkUYXL6ZWQcjs.componentsCoverage; exports.compositeDeep = _chunkUYXL6ZWQcjs.compositeDeep; exports.compositeSurfaceOver = _chunkHGTDMKNEcjs.compositeSurfaceOver; exports.computeHistogram = computeHistogram; exports.computeSelectionBounds = _chunkUYXL6ZWQcjs.computeSelectionBounds; exports.contentAwareFill = _chunk7NW46N7Icjs.contentAwareFill; exports.contentBounds = _chunkCWM3CUUXcjs.contentBounds; exports.contentsBox = _chunkUYXL6ZWQcjs.contentsBox; exports.contentsSurface = _chunkUYXL6ZWQcjs.contentsSurface; exports.contractCoverage = _chunkUYXL6ZWQcjs.contractCoverage; exports.controlPosition = controlPosition; exports.controlTrackBackground = controlTrackBackground; exports.convertColorFields = convertColorFields; exports.convertHex = convertHex; exports.convertSurfaceColors = convertSurfaceColors; exports.convertSurfaceDepth = _chunkCWM3CUUXcjs.convertSurfaceDepth; exports.convertToSmartObject = _chunkUYXL6ZWQcjs.convertToSmartObject; exports.copySmartObject = _chunkUYXL6ZWQcjs.copySmartObject; exports.cornersFromMatrix = _chunkUYXL6ZWQcjs.cornersFromMatrix; exports.coverageTileCoord = _chunkEBDCRTZIcjs.coverageTileCoord; exports.coverageToByte = _chunkUYXL6ZWQcjs.coverageToByte; exports.coveringRect = coveringRect; exports.createAdjustmentLayer = _chunkUYXL6ZWQcjs.createAdjustmentLayer; exports.createBlenderScratch = _chunkEBDCRTZIcjs.createBlenderScratch; exports.createCanvasTextShaper = _chunkBRKVNXDZcjs.createCanvasTextShaper; exports.createImageCaptureSurface = createImageCaptureSurface; exports.createImageColorTools = createImageColorTools; exports.createImageEditTools = createImageEditTools; exports.createImageEditorDocument = createImageEditorDocument; exports.createImageEditorToolProvider = createImageEditorToolProvider; exports.createImageEffectTools = createImageEffectTools; exports.createImageEffectsToolProvider = createImageEffectsToolProvider; exports.createImageLayerTools = createImageLayerTools; exports.createImagePaintTools = createImagePaintTools; exports.createImagePlaybackLocator = createImagePlaybackLocator; exports.createImagePsdTools = createImagePsdTools; exports.createImageRetouchTools = createImageRetouchTools; exports.createImageSegmentationToolProvider = createImageSegmentationToolProvider; exports.createImageSelectionTools = createImageSelectionTools; exports.createImageShapeTools = createImageShapeTools; exports.createImageSmartObjectTools = createImageSmartObjectTools; exports.createImageSubjectSelectionTool = createImageSubjectSelectionTool; exports.createImageTransformTools = createImageTransformTools; exports.createImageTypeTools = createImageTypeTools; exports.createMetricTextShaper = _chunkBRKVNXDZcjs.createMetricTextShaper; exports.createOutlineTextShaper = _chunkBRKVNXDZcjs.createOutlineTextShaper; exports.createPigment = _chunkCWM3CUUXcjs.createPigment; exports.createPigmentTools = _chunkV7GWZIZKcjs.createPigmentTools; exports.createSelectionMask = _chunkUYXL6ZWQcjs.createSelectionMask; exports.createShapeLayer = _chunkUYXL6ZWQcjs.createShapeLayer; exports.createTypeLayer = _chunkUYXL6ZWQcjs.createTypeLayer; exports.createWetGpuEngine = _chunkV7GWZIZKcjs.createWetGpuEngine; exports.cssFont = _chunkBRKVNXDZcjs.cssFont; exports.cssFontFamily = _chunkBRKVNXDZcjs.cssFontFamily; exports.curveLut = _chunkHGTDMKNEcjs.curveLut; exports.curveLutFromLevels = _chunkUYXL6ZWQcjs.curveLutFromLevels; exports.curvePointToBox = curvePointToBox; exports.curveSvgPath = curveSvgPath; exports.dabCoverage = _chunkEBDCRTZIcjs.dabCoverage; exports.dabRect = _chunkEBDCRTZIcjs.dabRect; exports.decodeDeepSurface = _chunkUYXL6ZWQcjs.decodeDeepSurface; exports.decodeLayerChannel = _chunkUYXL6ZWQcjs.decodeLayerChannel; exports.decodeLayerMask = _chunkUYXL6ZWQcjs.decodeLayerMask; exports.decodeMergedImage = _chunkUYXL6ZWQcjs.decodeMergedImage; exports.decodePlanes = _chunkUYXL6ZWQcjs.decodePlanes; exports.decodePng = _chunkCWM3CUUXcjs.decodePng; exports.decodePngDataUrl = _chunkUYXL6ZWQcjs.decodePngDataUrl; exports.decodeSelectionRle = _chunkUYXL6ZWQcjs.decodeSelectionRle; exports.deepBytes = _chunkCWM3CUUXcjs.deepBytes; exports.deepTile = _chunkCWM3CUUXcjs.deepTile; exports.defaultActiveLayerId = _chunkUYXL6ZWQcjs.defaultActiveLayerId; exports.defaultAdjustmentParams = _chunkUYXL6ZWQcjs.defaultAdjustmentParams; exports.defaultEffectGradient = _chunkHGTDMKNEcjs.defaultEffectGradient; exports.defaultLayerEffect = _chunkHGTDMKNEcjs.defaultLayerEffect; exports.defaultShapeName = _chunkUYXL6ZWQcjs.defaultShapeName; exports.deflate = _chunkXFM3OCHUcjs.deflate; exports.deflateRaw = _chunkXFM3OCHUcjs.deflateRaw; exports.depthMaskAlpha = _chunkUYXL6ZWQcjs.depthMaskAlpha; exports.depthOf = _chunkCWM3CUUXcjs.depthOf; exports.depthRasterMask = _chunkUYXL6ZWQcjs.depthRasterMask; exports.describeChannel = describeChannel; exports.describeLayer = describeLayer; exports.describeLayerEffects = describeLayerEffects; exports.describeSelection = describeSelection; exports.describeTransform = _chunkUYXL6ZWQcjs.describeTransform; exports.deserializeChannels = deserializeChannels; exports.deserializeColorMode = deserializeColorMode; exports.deserializeColorProfile = deserializeColorProfile; exports.deserializeEffects = _chunkUYXL6ZWQcjs.deserializeEffects; exports.deserializeLayer = _chunkUYXL6ZWQcjs.deserializeLayer; exports.deserializeLayers = _chunkUYXL6ZWQcjs.deserializeLayers; exports.deserializePatterns = _chunkUYXL6ZWQcjs.deserializePatterns; exports.deserializeSelection = _chunkUYXL6ZWQcjs.deserializeSelection; exports.developFilter = _chunkUYXL6ZWQcjs.developFilter; exports.developFromAdjustments = _chunkUYXL6ZWQcjs.developFromAdjustments; exports.developTarget = _chunkUYXL6ZWQcjs.developTarget; exports.dexp = _chunkV7GWZIZKcjs.dexp; exports.dilateMask = _chunk7NW46N7Icjs.dilateMask; exports.displayTransform = displayTransform; exports.distanceTransform = _chunkUYXL6ZWQcjs.distanceTransform; exports.dlog = _chunkV7GWZIZKcjs.dlog; exports.documentContents = _chunkUYXL6ZWQcjs.documentContents; exports.documentProfile = documentProfile; exports.dodgeBurn = _chunk7NW46N7Icjs.dodgeBurn; exports.dodgeBurnCurve = _chunk7NW46N7Icjs.dodgeBurnCurve; exports.downloadMaskImage = downloadMaskImage; exports.downloadPsd = downloadPsd; exports.dpow = _chunkV7GWZIZKcjs.dpow; exports.dragWarpMeshPoint = _chunkBRKVNXDZcjs.dragWarpMeshPoint; exports.dropPlacement = dropPlacement; exports.dropZone = dropZone; exports.dsincos = _chunkV7GWZIZKcjs.dsincos; exports.duplicateLayer = _chunkUYXL6ZWQcjs.duplicateLayer; exports.edgeBits = _chunkV7GWZIZKcjs.edgeBits; exports.edgeWidth = edgeWidth; exports.effectColorHex = _chunkHGTDMKNEcjs.effectColorHex; exports.effectControlChange = effectControlChange; exports.effectLayerTiming = effectLayerTiming; exports.effectPixelsToSurface = effectPixelsToSurface; exports.effectReach = _chunkHGTDMKNEcjs.effectReach; exports.effectiveLayerMask = _chunkUYXL6ZWQcjs.effectiveLayerMask; exports.effectiveProof = effectiveProof; exports.effectsFingerprint = _chunkHGTDMKNEcjs.effectsFingerprint; exports.effectsMargin = _chunkHGTDMKNEcjs.effectsMargin; exports.effectsScale = _chunkHGTDMKNEcjs.effectsScale; exports.ellipsePoints = ellipsePoints; exports.ellipseSelection = ellipseSelection; exports.emptyHistogram = emptyHistogram; exports.emptySurface = _chunkCWM3CUUXcjs.emptySurface; exports.encodeDeepSurface = _chunkUYXL6ZWQcjs.encodeDeepSurface; exports.encodePng = _chunkCWM3CUUXcjs.encodePng; exports.encodeRle = _chunkUYXL6ZWQcjs.encodeRle; exports.encodeSelectionRle = _chunkUYXL6ZWQcjs.encodeSelectionRle; exports.encodeSurface = _chunkUYXL6ZWQcjs.encodeSurface; exports.evalWarpMesh = _chunkBRKVNXDZcjs.evalWarpMesh; exports.evaluateAdjustmentLayers = _chunkUYXL6ZWQcjs.evaluateAdjustmentLayers; exports.exchangeRates = _chunkEBDCRTZIcjs.exchangeRates; exports.expNeg = _chunkV7GWZIZKcjs.expNeg; exports.expandCoverage = _chunkUYXL6ZWQcjs.expandCoverage; exports.exportPsd = _chunkUYXL6ZWQcjs.exportPsd; exports.extractNormalizedLayerItems = extractNormalizedLayerItems; exports.featherCoverage = _chunkUYXL6ZWQcjs.featherCoverage; exports.fillRect = _chunkCWM3CUUXcjs.fillRect; exports.filmPixel = _chunkV7GWZIZKcjs.filmPixel; exports.filmReflectance = _chunkV7GWZIZKcjs.filmReflectance; exports.filterMaskCoverage = _chunkUYXL6ZWQcjs.filterMaskCoverage; exports.findAdjustmentControl = findAdjustmentControl; exports.findLayer = _chunkHGTDMKNEcjs.findLayer; exports.findLayerControl = findLayerControl; exports.findWebGpu = _chunkV7GWZIZKcjs.findWebGpu; exports.finishTile = _chunkCWM3CUUXcjs.finishTile; exports.fitParagraphRuns = _chunkBRKVNXDZcjs.fitParagraphRuns; exports.fitRuns = _chunkBRKVNXDZcjs.fitRuns; exports.flattenLayers = _chunkHGTDMKNEcjs.flattenLayers; exports.flattenPath = _chunkUYXL6ZWQcjs.flattenPath; exports.flipCorners = _chunkUYXL6ZWQcjs.flipCorners; exports.flowField = _chunkV7GWZIZKcjs.flowField; exports.followLayerMove = _chunkUYXL6ZWQcjs.followLayerMove; exports.fontOf = _chunkBRKVNXDZcjs.fontOf; exports.formatControlValue = formatControlValue; exports.fullSelection = _chunkUYXL6ZWQcjs.fullSelection; exports.gaussianBlur = _chunkHGTDMKNEcjs.gaussianBlur; exports.geometryHomography = _chunkUYXL6ZWQcjs.geometryHomography; exports.getAnnotationBounds = _chunkUYXL6ZWQcjs.getAnnotationBounds; exports.getControlPath = getControlPath; exports.getCropCursor = _chunkUYXL6ZWQcjs.getCropCursor; exports.getRotatedSize = _chunkUYXL6ZWQcjs.getRotatedSize; exports.getViewportMetrics = _chunkUYXL6ZWQcjs.getViewportMetrics; exports.getViewportProjection = _chunkUYXL6ZWQcjs.getViewportProjection; exports.globalImageCache = globalImageCache; exports.gradientDabColor = _chunkEBDCRTZIcjs.gradientDabColor; exports.grainCatch = _chunkEBDCRTZIcjs.grainCatch; exports.grainHeights = _chunkEBDCRTZIcjs.grainHeights; exports.greyMorphology = _chunkUYXL6ZWQcjs.greyMorphology; exports.groupLayers = _chunkUYXL6ZWQcjs.groupLayers; exports.growSelection = growSelection; exports.guidePlanes = guidePlanes; exports.guidedFilterColor = guidedFilterColor; exports.handleMaskViewKey = handleMaskViewKey; exports.handlePaintShortcut = handlePaintShortcut; exports.handleQuickMaskKey = handleQuickMaskKey; exports.handleSelectionShortcut = handleSelectionShortcut; exports.hasActiveEffects = _chunkHGTDMKNEcjs.hasActiveEffects; exports.hasLayersBelow = hasLayersBelow; exports.hasResampledLegacyMask = _chunkUYXL6ZWQcjs.hasResampledLegacyMask; exports.hasSurface = _chunkUYXL6ZWQcjs.hasSurface; exports.hasWarp = _chunkUYXL6ZWQcjs.hasWarp; exports.hash2 = _chunkEBDCRTZIcjs.hash2; exports.hashMaskContent = _chunkUYXL6ZWQcjs.hashMaskContent; exports.hashNoise = _chunkHGTDMKNEcjs.hashNoise; exports.healPixels = _chunk7NW46N7Icjs.healPixels; exports.hexToPaintRgb = _chunkEBDCRTZIcjs.hexToPaintRgb; exports.hexToRgb = _chunkUYXL6ZWQcjs.hexToRgb; exports.histogramPath = histogramPath; exports.hitTestAnnotation = _chunkUYXL6ZWQcjs.hitTestAnnotation; exports.hitTestCrop = _chunkUYXL6ZWQcjs.hitTestCrop; exports.hitTestCurvePoint = hitTestCurvePoint; exports.homographyFromAffine = _chunkQT26RHKKcjs.homographyFromAffine; exports.homographyFromPoints = _chunkQT26RHKKcjs.homographyFromPoints; exports.hslToRgb = _chunkUYXL6ZWQcjs.hslToRgb; exports.hueRange = hueRange; exports.hueRangeTables = _chunkUYXL6ZWQcjs.hueRangeTables; exports.hueRangeWeight = _chunkUYXL6ZWQcjs.hueRangeWeight; exports.hueSaturation = _chunkUYXL6ZWQcjs.hueSaturation; exports.identityCurve = _chunkUYXL6ZWQcjs.identityCurve; exports.identityLevels = _chunkUYXL6ZWQcjs.identityLevels; exports.identityTransform = _chunkUYXL6ZWQcjs.identityTransform; exports.identityWarpMesh = _chunkBRKVNXDZcjs.identityWarpMesh; exports.imageEditorStateMigrations = imageEditorStateMigrations; exports.imageLayerAppliedEffects = imageLayerAppliedEffects; exports.imagePanelTool = imagePanelTool; exports.imagePlaybackPanel = imagePlaybackPanel; exports.imageToCanvasPoint = _chunkUYXL6ZWQcjs.imageToCanvasPoint; exports.imageToolCanvasMode = imageToolCanvasMode; exports.imageToolForShortcut = imageToolForShortcut; exports.imageToolGroup = imageToolGroup; exports.imageToolLabel = imageToolLabel; exports.imageToolPanel = imageToolPanel; exports.importPsd = _chunkUYXL6ZWQcjs.importPsd; exports.inflate = _chunkXFM3OCHUcjs.inflate; exports.inflateRaw = _chunkXFM3OCHUcjs.inflateRaw; exports.insertCurvePoint = insertCurvePoint; exports.insertLayer = _chunkHGTDMKNEcjs.insertLayer; exports.instancesOf = _chunkUYXL6ZWQcjs.instancesOf; exports.invertHomography = _chunkQT26RHKKcjs.invertHomography; exports.invertMatrix3 = _chunkUYXL6ZWQcjs.invertMatrix3; exports.invertSelection = _chunkUYXL6ZWQcjs.invertSelection; exports.isActiveFilter = _chunkUYXL6ZWQcjs.isActiveFilter; exports.isActiveVectorMask = _chunkUYXL6ZWQcjs.isActiveVectorMask; exports.isAdjustmentKind = _chunkUYXL6ZWQcjs.isAdjustmentKind; exports.isBitDepth = _chunkCWM3CUUXcjs.isBitDepth; exports.isBlendMode = _chunkCWM3CUUXcjs.isBlendMode; exports.isBrushstrokeBrush = _chunkEBDCRTZIcjs.isBrushstrokeBrush; exports.isColorRangePreset = isColorRangePreset; exports.isContentsDecoded = _chunkUYXL6ZWQcjs.isContentsDecoded; exports.isDefaultDepthMask = _chunkUYXL6ZWQcjs.isDefaultDepthMask; exports.isGradientPaint = _chunkEBDCRTZIcjs.isGradientPaint; exports.isIdentityCloneTransform = _chunk7NW46N7Icjs.isIdentityCloneTransform; exports.isIdentityTransform = _chunkUYXL6ZWQcjs.isIdentityTransform; exports.isInterpolation = _chunkHGTDMKNEcjs.isInterpolation; exports.isLayerEffectKind = _chunkHGTDMKNEcjs.isLayerEffectKind; exports.isLayerLocked = _chunkHGTDMKNEcjs.isLayerLocked; exports.isLegacyShape = _chunkUYXL6ZWQcjs.isLegacyShape; exports.isPaintTool = isPaintTool; exports.isPaintableLayer = _chunkUYXL6ZWQcjs.isPaintableLayer; exports.isPainterlyBlendMode = _chunkCWM3CUUXcjs.isPainterlyBlendMode; exports.isPng = _chunkCWM3CUUXcjs.isPng; exports.isQuarterTurn = isQuarterTurn; exports.isQuarterTurnSwapped = _chunkUYXL6ZWQcjs.isQuarterTurnSwapped; exports.isRenderedLayer = _chunkUYXL6ZWQcjs.isRenderedLayer; exports.isRetouchPaintTool = isRetouchPaintTool; exports.isRetouchTool = isRetouchTool; exports.isSelectionEmpty = _chunkUYXL6ZWQcjs.isSelectionEmpty; exports.isSelectionMode = _chunkUYXL6ZWQcjs.isSelectionMode; exports.isSeparableBlendMode = _chunkCWM3CUUXcjs.isSeparableBlendMode; exports.isSmartSurfaceIncomplete = _chunkUYXL6ZWQcjs.isSmartSurfaceIncomplete; exports.isSpatialFilter = _chunkUYXL6ZWQcjs.isSpatialFilter; exports.isSrgb = isSrgb; exports.isTransformAnchor = _chunkUYXL6ZWQcjs.isTransformAnchor; exports.isValidWarp = _chunkUYXL6ZWQcjs.isValidWarp; exports.keepDeepSamples = _chunkCWM3CUUXcjs.keepDeepSamples; exports.kelvinToTemperature = _chunkUYXL6ZWQcjs.kelvinToTemperature; exports.keysWeight = _chunkHGTDMKNEcjs.keysWeight; exports.latticeViscosity = _chunkV7GWZIZKcjs.latticeViscosity; exports.layerBadge = layerBadge; exports.layerEffectControls = layerEffectControls; exports.layerEffectFields = _chunkHGTDMKNEcjs.layerEffectFields; exports.layerEffectLabel = _chunkHGTDMKNEcjs.layerEffectLabel; exports.layerEffectsBadge = layerEffectsBadge; exports.layerEffectsOf = _chunkUYXL6ZWQcjs.layerEffectsOf; exports.layerEffectsPanel = layerEffectsPanel; exports.layerHasThumbnail = layerHasThumbnail; exports.layerLabel = layerLabel; exports.layerMaskCoverage = _chunkUYXL6ZWQcjs.layerMaskCoverage; exports.layerMaskFromSelection = _chunkUYXL6ZWQcjs.layerMaskFromSelection; exports.layerMaskKey = _chunkUYXL6ZWQcjs.layerMaskKey; exports.layerMaskSelection = _chunkUYXL6ZWQcjs.layerMaskSelection; exports.layerMenu = layerMenu; exports.layerName = _chunkUYXL6ZWQcjs.layerName; exports.layerPanelRows = layerPanelRows; exports.layerPanels = layerPanels; exports.layerThumbnailClick = layerThumbnailClick; exports.layerTree = _chunkUYXL6ZWQcjs.layerTree; exports.layerTypeLabel = _chunkUYXL6ZWQcjs.layerTypeLabel; exports.layerWarning = layerWarning; exports.layersFromLegacy = _chunkUYXL6ZWQcjs.layersFromLegacy; exports.layoutText = _chunkBRKVNXDZcjs.layoutText; exports.legacyAdjustmentLayer = _chunkUYXL6ZWQcjs.legacyAdjustmentLayer; exports.legacyMaskOf = _chunkUYXL6ZWQcjs.legacyMaskOf; exports.legacyView = _chunkUYXL6ZWQcjs.legacyView; exports.lerpPigment = _chunkCWM3CUUXcjs.lerpPigment; exports.lerpPigmentInto = _chunkCWM3CUUXcjs.lerpPigmentInto; exports.levelsValue = _chunkUYXL6ZWQcjs.levelsValue; exports.linearSrgbToXy = _chunkUYXL6ZWQcjs.linearSrgbToXy; exports.linearToSrgb = _chunkUYXL6ZWQcjs.linearToSrgb; exports.linearToSrgb8 = _chunkV7GWZIZKcjs.linearToSrgb8; exports.liveComponent = _chunkUYXL6ZWQcjs.liveComponent; exports.liveShapeForDrag = liveShapeForDrag; exports.liveShapeSubpaths = _chunkUYXL6ZWQcjs.liveShapeSubpaths; exports.liveWire = liveWire; exports.loadImageEditorDocument = loadImageEditorDocument; exports.loadMixer = _chunkEBDCRTZIcjs.loadMixer; exports.loadOpenTypeFont = _chunk3T5VCDIVcjs.loadOpenTypeFont; exports.loadWetKernel = _chunkV7GWZIZKcjs.loadWetKernel; exports.luma = _chunk7NW46N7Icjs.luma; exports.magicWand = magicWand; exports.magneticAnchorSpacing = magneticAnchorSpacing; exports.mapCropHandle = _chunkUYXL6ZWQcjs.mapCropHandle; exports.mapLayer = _chunkHGTDMKNEcjs.mapLayer; exports.mapSubpaths = _chunkUYXL6ZWQcjs.mapSubpaths; exports.maskBounds = _chunk7NW46N7Icjs.maskBounds; exports.maskFileName = maskFileName; exports.maskNameFromFile = maskNameFromFile; exports.maskSummary = maskSummary; exports.maskThumbnailClick = maskThumbnailClick; exports.matrixFromCorners = _chunkUYXL6ZWQcjs.matrixFromCorners; exports.matrixFromParams = _chunkUYXL6ZWQcjs.matrixFromParams; exports.measureCanvasViewport = measureCanvasViewport; exports.membraneFill = _chunk7NW46N7Icjs.membraneFill; exports.mergeLayerEffect = _chunkHGTDMKNEcjs.mergeLayerEffect; exports.mergeShapeComponents = _chunkUYXL6ZWQcjs.mergeShapeComponents; exports.migrateSerializedImageEditorState = migrateSerializedImageEditorState; exports.migrateToLayeredState = migrateToLayeredState; exports.mix32 = _chunkEBDCRTZIcjs.mix32; exports.mixPigment8 = _chunkCWM3CUUXcjs.mixPigment8; exports.mixPigmentRgb = _chunkCWM3CUUXcjs.mixPigmentRgb; exports.mixPigments = _chunkCWM3CUUXcjs.mixPigments; exports.mixerLoadResult = mixerLoadResult; exports.mixerRates = _chunkEBDCRTZIcjs.mixerRates; exports.modifySelection = _chunkUYXL6ZWQcjs.modifySelection; exports.moveCurvePoint = moveCurvePoint; exports.moveLayer = _chunkUYXL6ZWQcjs.moveLayer; exports.moveSmartFilter = _chunkUYXL6ZWQcjs.moveSmartFilter; exports.mulMatrix3 = _chunkUYXL6ZWQcjs.mulMatrix3; exports.needsLegacyBase = needsLegacyBase; exports.neutralHueRange = _chunkUYXL6ZWQcjs.neutralHueRange; exports.newContentsId = _chunkUYXL6ZWQcjs.newContentsId; exports.newEffectId = _chunkHGTDMKNEcjs.newEffectId; exports.newLayerId = _chunkUYXL6ZWQcjs.newLayerId; exports.newLayerOptions = newLayerOptions; exports.normalizeAdjustmentLayer = _chunkUYXL6ZWQcjs.normalizeAdjustmentLayer; exports.normalizeAdjustmentLayers = _chunkUYXL6ZWQcjs.normalizeAdjustmentLayers; exports.normalizeAngle = _chunkUYXL6ZWQcjs.normalizeAngle; exports.normalizeBlendMode = _chunkCWM3CUUXcjs.normalizeBlendMode; exports.normalizeBlender = _chunkEBDCRTZIcjs.normalizeBlender; exports.normalizeBrush = _chunkEBDCRTZIcjs.normalizeBrush; exports.normalizeFilter = _chunkUYXL6ZWQcjs.normalizeFilter; exports.normalizeFlow = _chunkV7GWZIZKcjs.normalizeFlow; exports.normalizeHexColor = _chunkEBDCRTZIcjs.normalizeHexColor; exports.normalizeLayerEffects = _chunkHGTDMKNEcjs.normalizeLayerEffects; exports.normalizeLayerMask = _chunkUYXL6ZWQcjs.normalizeLayerMask; exports.normalizeLiveShape = _chunkUYXL6ZWQcjs.normalizeLiveShape; exports.normalizeMixer = _chunkEBDCRTZIcjs.normalizeMixer; exports.normalizePlacement = _chunkUYXL6ZWQcjs.normalizePlacement; exports.normalizeProcessVersion = _chunkUYXL6ZWQcjs.normalizeProcessVersion; exports.normalizeRect = normalizeRect; exports.normalizeRefineEdgeParams = normalizeRefineEdgeParams; exports.normalizeRetouch = _chunk7NW46N7Icjs.normalizeRetouch; exports.normalizeShapePaint = _chunkUYXL6ZWQcjs.normalizeShapePaint; exports.normalizeShapeStroke = _chunkUYXL6ZWQcjs.normalizeShapeStroke; exports.normalizeSmartFilter = _chunkUYXL6ZWQcjs.normalizeSmartFilter; exports.normalizeSmudge = _chunkEBDCRTZIcjs.normalizeSmudge; exports.normalizeStoredAdjustments = normalizeStoredAdjustments; exports.normalizeSubpaths = _chunkUYXL6ZWQcjs.normalizeSubpaths; exports.normalizeText = _chunkUYXL6ZWQcjs.normalizeText; exports.normalizeTilt = _chunkV7GWZIZKcjs.normalizeTilt; exports.normalizeWetParams = _chunkV7GWZIZKcjs.normalizeWetParams; exports.offsetLayer = _chunkUYXL6ZWQcjs.offsetLayer; exports.offsetShape = _chunkUYXL6ZWQcjs.offsetShape; exports.offsetSmartObject = _chunkUYXL6ZWQcjs.offsetSmartObject; exports.offsetVectorMask = _chunkUYXL6ZWQcjs.offsetVectorMask; exports.openMaskFile = openMaskFile; exports.openPsdFile = openPsdFile; exports.packRgba = _chunkCWM3CUUXcjs.packRgba; exports.packWetParams = _chunkV7GWZIZKcjs.packWetParams; exports.paintGradientMappingFor = _chunkEBDCRTZIcjs.paintGradientMappingFor; exports.paintPathStroke = _chunkEBDCRTZIcjs.paintPathStroke; exports.paintSourceColor = _chunkEBDCRTZIcjs.paintSourceColor; exports.paintSourceCss = _chunkEBDCRTZIcjs.paintSourceCss; exports.paragraphRanges = _chunkBRKVNXDZcjs.paragraphRanges; exports.parseAdjustmentBlock = _chunkUYXL6ZWQcjs.parseAdjustmentBlock; exports.parseBlend = _chunkUYXL6ZWQcjs.parseBlend; exports.parseColor = parseColor; exports.parseCssColor = _chunkA2IS7EHEcjs.parseCssColor; exports.parseDataUrl = _chunkCWM3CUUXcjs.parseDataUrl; exports.parseEffectColor = _chunkHGTDMKNEcjs.parseEffectColor; exports.parseLfx2 = _chunkUYXL6ZWQcjs.parseLfx2; exports.parseLrfx = _chunkUYXL6ZWQcjs.parseLrfx; exports.parseOpenTypeFont = _chunk3T5VCDIVcjs.parseOpenTypeFont; exports.parsePaintSource = _chunkEBDCRTZIcjs.parsePaintSource; exports.parsePatternBlock = _chunkUYXL6ZWQcjs.parsePatternBlock; exports.parseSelectionMode = _chunkUYXL6ZWQcjs.parseSelectionMode; exports.parseVersionedDescriptor = _chunkUYXL6ZWQcjs.parseVersionedDescriptor; exports.patchParagraphStyle = _chunkUYXL6ZWQcjs.patchParagraphStyle; exports.patchTextStyle = _chunkUYXL6ZWQcjs.patchTextStyle; exports.pathStrokeCoverage = _chunkEBDCRTZIcjs.pathStrokeCoverage; exports.pathStrokeDabs = _chunkEBDCRTZIcjs.pathStrokeDabs; exports.pathToSelection = pathToSelection; exports.perDabStrength = _chunk7NW46N7Icjs.perDabStrength; exports.photoFilterMatrix = _chunkUYXL6ZWQcjs.photoFilterMatrix; exports.pigment8 = _chunkCWM3CUUXcjs.pigment8; exports.pigmentColor = _chunkV7GWZIZKcjs.pigmentColor; exports.pigmentOf = _chunkV7GWZIZKcjs.pigmentOf; exports.pixelLayerBounds = _chunkUYXL6ZWQcjs.pixelLayerBounds; exports.pixelLayers = _chunkUYXL6ZWQcjs.pixelLayers; exports.pixelPigment = _chunkV7GWZIZKcjs.pixelPigment; exports.placeContents = _chunkUYXL6ZWQcjs.placeContents; exports.placeLayer = _chunkUYXL6ZWQcjs.placeLayer; exports.placementAt = _chunkUYXL6ZWQcjs.placementAt; exports.placementBounds = _chunkUYXL6ZWQcjs.placementBounds; exports.placementGeometry = _chunkUYXL6ZWQcjs.placementGeometry; exports.planImageToolPlayback = planImageToolPlayback; exports.planOutlineTrace = planOutlineTrace; exports.pngDataUrl = _chunkCWM3CUUXcjs.pngDataUrl; exports.pointerPressure = _chunkV7GWZIZKcjs.pointerPressure; exports.pointerStrokeSample = _chunkV7GWZIZKcjs.pointerStrokeSample; exports.pointerStrokeSamples = _chunkV7GWZIZKcjs.pointerStrokeSamples; exports.polygonCoverage = polygonCoverage; exports.polygonCoverageBox = polygonCoverageBox; exports.polygonSelection = polygonSelection; exports.posterizeValue = _chunkUYXL6ZWQcjs.posterizeValue; exports.presetWarp = _chunkUYXL6ZWQcjs.presetWarp; exports.previewStep = previewStep; exports.profileBytes = profileBytes; exports.projectImagePoint = _chunkUYXL6ZWQcjs.projectImagePoint; exports.projectImageRect = _chunkUYXL6ZWQcjs.projectImageRect; exports.projectMaskCoverage = _chunkUYXL6ZWQcjs.projectMaskCoverage; exports.projectQuarterTurn = projectQuarterTurn; exports.proxyOf = _chunkCWM3CUUXcjs.proxyOf; exports.psdBytesFromBase64 = psdBytesFromBase64; exports.psdFileName = psdFileName; exports.psdPatternToEffectPattern = _chunkUYXL6ZWQcjs.psdPatternToEffectPattern; exports.psdToLayers = _chunkUYXL6ZWQcjs.psdToLayers; exports.pullWarpMesh = _chunkBRKVNXDZcjs.pullWarpMesh; exports.put255 = _chunkEBDCRTZIcjs.put255; exports.quadFrameOverlay = quadFrameOverlay; exports.quickMaskPixels = quickMaskPixels; exports.quickSelectStroke = quickSelectStroke; exports.rand01 = _chunkEBDCRTZIcjs.rand01; exports.randSigned = _chunkEBDCRTZIcjs.randSigned; exports.rangeLightness = _chunkUYXL6ZWQcjs.rangeLightness; exports.rasterContents = _chunkUYXL6ZWQcjs.rasterContents; exports.rasterMaskFromLegacy = _chunkUYXL6ZWQcjs.rasterMaskFromLegacy; exports.rasterizeCoverage = _chunkUYXL6ZWQcjs.rasterizeCoverage; exports.rasterizeDab = _chunkEBDCRTZIcjs.rasterizeDab; exports.rasterizeSmartObject = _chunkUYXL6ZWQcjs.rasterizeSmartObject; exports.readAdjustmentControls = readAdjustmentControls; exports.readDeepRegion = _chunkCWM3CUUXcjs.readDeepRegion; exports.readPaintSource = _chunkEBDCRTZIcjs.readPaintSource; exports.readPixel = _chunkCWM3CUUXcjs.readPixel; exports.readPsd = _chunkUYXL6ZWQcjs.readPsd; exports.readRegion = _chunkCWM3CUUXcjs.readRegion; exports.readSourceRegion = _chunk7NW46N7Icjs.readSourceRegion; exports.rectSelection = rectSelection; exports.rectToQuad = _chunkQT26RHKKcjs.rectToQuad; exports.reduceSurface = _chunkHGTDMKNEcjs.reduceSurface; exports.referencePoint = _chunkUYXL6ZWQcjs.referencePoint; exports.refineCoverage = refineCoverage; exports.refineEdgeHalo = refineEdgeHalo; exports.refineSelection = refineSelection; exports.reflectanceToRgb = _chunkCWM3CUUXcjs.reflectanceToRgb; exports.removeAlpha = _chunkUYXL6ZWQcjs.removeAlpha; exports.removeCurvePoint = removeCurvePoint; exports.removeLayer = _chunkUYXL6ZWQcjs.removeLayer; exports.removeLayerEffect = _chunkUYXL6ZWQcjs.removeLayerEffect; exports.removeLayerFilter = _chunkUYXL6ZWQcjs.removeLayerFilter; exports.removePaintGradientStop = _chunkEBDCRTZIcjs.removePaintGradientStop; exports.removeSmartFilter = _chunkUYXL6ZWQcjs.removeSmartFilter; exports.renderBrushstroke = _chunkEBDCRTZIcjs.renderBrushstroke; exports.renderLayerEffects = _chunkHGTDMKNEcjs.renderLayerEffects; exports.renderLayeredBase = renderLayeredBase; exports.renderShape = _chunkUYXL6ZWQcjs.renderShape; exports.renderShapeRect = _chunkUYXL6ZWQcjs.renderShapeRect; exports.renderSmartObject = _chunkUYXL6ZWQcjs.renderSmartObject; exports.renderText = _chunkUYXL6ZWQcjs.renderText; exports.replaceContents = _chunkUYXL6ZWQcjs.replaceContents; exports.replaceTextRange = _chunkUYXL6ZWQcjs.replaceTextRange; exports.requireLayer = _chunkUYXL6ZWQcjs.requireLayer; exports.requireOperation = _chunkUYXL6ZWQcjs.requireOperation; exports.requireShapeLayer = _chunkUYXL6ZWQcjs.requireShapeLayer; exports.requireSmartObject = _chunkUYXL6ZWQcjs.requireSmartObject; exports.requireTypeLayer = _chunkUYXL6ZWQcjs.requireTypeLayer; exports.requireUnlocked = _chunkUYXL6ZWQcjs.requireUnlocked; exports.rerender = _chunkUYXL6ZWQcjs.rerender; exports.rerenderShape = _chunkUYXL6ZWQcjs.rerenderShape; exports.rerenderText = _chunkUYXL6ZWQcjs.rerenderText; exports.resizePixels = resizePixels; exports.resizeSelection = _chunkUYXL6ZWQcjs.resizeSelection; exports.resizeWarpMesh = _chunkBRKVNXDZcjs.resizeWarpMesh; exports.resolveExternalAssets = _chunkUYXL6ZWQcjs.resolveExternalAssets; exports.resolveMosaicRegionBounds = resolveMosaicRegionBounds; exports.resolvePaintGradient = _chunkEBDCRTZIcjs.resolvePaintGradient; exports.resolveProfile = resolveProfile; exports.resolveVectorMasks = _chunkUYXL6ZWQcjs.resolveVectorMasks; exports.restyleRange = _chunkBRKVNXDZcjs.restyleRange; exports.retouchFilter = _chunk7NW46N7Icjs.retouchFilter; exports.reversePaintGradient = _chunkEBDCRTZIcjs.reversePaintGradient; exports.rgbToGray = _chunkUYXL6ZWQcjs.rgbToGray; exports.rgbToHsl = _chunkUYXL6ZWQcjs.rgbToHsl; exports.rgbToReflectance = _chunkCWM3CUUXcjs.rgbToReflectance; exports.rgbUnitToHex = rgbUnitToHex; exports.rgbaViewOfGrey = _chunk7NW46N7Icjs.rgbaViewOfGrey; exports.runLayerFilters = _chunkUYXL6ZWQcjs.runLayerFilters; exports.runLayerFiltersFloat = _chunkUYXL6ZWQcjs.runLayerFiltersFloat; exports.runLayerMenuAction = runLayerMenuAction; exports.sameCanvasViewport = sameCanvasViewport; exports.sampleLut = _chunkUYXL6ZWQcjs.sampleLut; exports.sampleToneLut = _chunkUYXL6ZWQcjs.sampleToneLut; exports.saturationOf = _chunk7NW46N7Icjs.saturationOf; exports.scaleLayerEffect = _chunkHGTDMKNEcjs.scaleLayerEffect; exports.scalePaintGradient = _chunkEBDCRTZIcjs.scalePaintGradient; exports.seamlessClone = _chunk7NW46N7Icjs.seamlessClone; exports.seedFromString = _chunkEBDCRTZIcjs.seedFromString; exports.segmentToSelection = segmentToSelection; exports.segmentationOutlines = segmentationOutlines; exports.segmentsToSelection = segmentsToSelection; exports.selectSimilar = selectSimilar; exports.selectionArea = _chunkUYXL6ZWQcjs.selectionArea; exports.selectionFromCoverage = _chunkUYXL6ZWQcjs.selectionFromCoverage; exports.selectionFromPixels = _chunkUYXL6ZWQcjs.selectionFromPixels; exports.selectionFromRegion = _chunkUYXL6ZWQcjs.selectionFromRegion; exports.selectionFromTiles = _chunkUYXL6ZWQcjs.selectionFromTiles; exports.selectionModeFromModifiers = selectionModeFromModifiers; exports.selectionOutline = selectionOutline; exports.selectionRing = selectionRing; exports.selectionToCoverage = _chunkUYXL6ZWQcjs.selectionToCoverage; exports.selectionToPixels = _chunkUYXL6ZWQcjs.selectionToPixels; exports.selectionToSubpaths = selectionToSubpaths; exports.selectionValueAt = _chunkUYXL6ZWQcjs.selectionValueAt; exports.serializeChannels = serializeChannels; exports.serializeColorMode = serializeColorMode; exports.serializeColorProfile = serializeColorProfile; exports.serializeContents = _chunkUYXL6ZWQcjs.serializeContents; exports.serializeEffects = _chunkUYXL6ZWQcjs.serializeEffects; exports.serializeLayer = _chunkUYXL6ZWQcjs.serializeLayer; exports.serializeLayers = _chunkUYXL6ZWQcjs.serializeLayers; exports.serializeLayersExternal = _chunkUYXL6ZWQcjs.serializeLayersExternal; exports.serializePatterns = _chunkUYXL6ZWQcjs.serializePatterns; exports.serializeSelection = _chunkUYXL6ZWQcjs.serializeSelection; exports.setCloneTransformValue = setCloneTransformValue; exports.setControlPath = setControlPath; exports.setLayerEffects = _chunkUYXL6ZWQcjs.setLayerEffects; exports.setLayerEffectsEnabled = _chunkUYXL6ZWQcjs.setLayerEffectsEnabled; exports.setLayerMask = _chunkUYXL6ZWQcjs.setLayerMask; exports.setLayerProperties = _chunkUYXL6ZWQcjs.setLayerProperties; exports.setLum = _chunkCWM3CUUXcjs.setLum; exports.setPigmentColor = _chunkCWM3CUUXcjs.setPigmentColor; exports.setRetouchChoice = setRetouchChoice; exports.setSmartFilterMask = _chunkUYXL6ZWQcjs.setSmartFilterMask; exports.setSmartFiltersEnabled = _chunkUYXL6ZWQcjs.setSmartFiltersEnabled; exports.setSmartPlacement = _chunkUYXL6ZWQcjs.setSmartPlacement; exports.shadeTile = _chunkV7GWZIZKcjs.shadeTile; exports.shapeAsPixelLayer = _chunkUYXL6ZWQcjs.shapeAsPixelLayer; exports.shapeFromAnnotation = _chunkUYXL6ZWQcjs.shapeFromAnnotation; exports.shapeGeometryBounds = _chunkUYXL6ZWQcjs.shapeGeometryBounds; exports.shapeLayers = _chunkUYXL6ZWQcjs.shapeLayers; exports.shapeOutline = _chunkUYXL6ZWQcjs.shapeOutline; exports.shapeRenderClip = _chunkUYXL6ZWQcjs.shapeRenderClip; exports.shiftCoverage = _chunkUYXL6ZWQcjs.shiftCoverage; exports.simplifyPixelPath = simplifyPixelPath; exports.skinToneRange = skinToneRange; exports.smartFilterRows = smartFilterRows; exports.smartObjectLayers = _chunkUYXL6ZWQcjs.smartObjectLayers; exports.smoothCoverage = _chunkUYXL6ZWQcjs.smoothCoverage; exports.smoothPoints = _chunkEBDCRTZIcjs.smoothPoints; exports.smudgeEffect = _chunk7NW46N7Icjs.smudgeEffect; exports.snapPolygonToEdges = snapPolygonToEdges; exports.snapTo45 = snapTo45; exports.snapToEdge = snapToEdge; exports.solidPaint = _chunkEBDCRTZIcjs.solidPaint; exports.solidSurface = _chunkCWM3CUUXcjs.solidSurface; exports.solveMembrane = _chunk7NW46N7Icjs.solveMembrane; exports.spliceRuns = _chunkBRKVNXDZcjs.spliceRuns; exports.splitOverlayAnnotations = splitOverlayAnnotations; exports.sponge = _chunk7NW46N7Icjs.sponge; exports.spongeEffect = _chunk7NW46N7Icjs.spongeEffect; exports.spotHealPixels = _chunk7NW46N7Icjs.spotHealPixels; exports.spotHealWindow = _chunk7NW46N7Icjs.spotHealWindow; exports.srgb8ToLab = srgb8ToLab; exports.srgbByteToLinear = _chunkV7GWZIZKcjs.srgbByteToLinear; exports.srgbDecode = _chunkCWM3CUUXcjs.srgbDecode; exports.srgbEncode = _chunkCWM3CUUXcjs.srgbEncode; exports.srgbToLinear = _chunkUYXL6ZWQcjs.srgbToLinear; exports.standardBlendMode = _chunkCWM3CUUXcjs.standardBlendMode; exports.startMarchingAnts = startMarchingAnts; exports.stepSlotTs = _chunkV7GWZIZKcjs.stepSlotTs; exports.strokeGrainCatch = _chunkEBDCRTZIcjs.strokeGrainCatch; exports.styleAt = _chunkBRKVNXDZcjs.styleAt; exports.subpathsToSvgPath = subpathsToSvgPath; exports.sumHistograms = sumHistograms; exports.surfaceBytes = _chunkCWM3CUUXcjs.surfaceBytes; exports.surfaceDepth = _chunkCWM3CUUXcjs.surfaceDepth; exports.surfaceFromDeepPixels = _chunkCWM3CUUXcjs.surfaceFromDeepPixels; exports.surfaceFromPixels = _chunkCWM3CUUXcjs.surfaceFromPixels; exports.surfacesEqual = _chunkCWM3CUUXcjs.surfacesEqual; exports.tempTintToXy = _chunkUYXL6ZWQcjs.tempTintToXy; exports.temperatureToKelvin = _chunkUYXL6ZWQcjs.temperatureToKelvin; exports.textIndexAt = _chunkBRKVNXDZcjs.textIndexAt; exports.textMatrix = _chunkUYXL6ZWQcjs.textMatrix; exports.textOrientation = _chunkUYXL6ZWQcjs.textOrientation; exports.textOutlines = _chunkUYXL6ZWQcjs.textOutlines; exports.textRange = _chunkUYXL6ZWQcjs.textRange; exports.tileCoord = _chunkCWM3CUUXcjs.tileCoord; exports.tileKey = _chunkCWM3CUUXcjs.tileKey; exports.tileRect = _chunkCWM3CUUXcjs.tileRect; exports.tileSamples = _chunkCWM3CUUXcjs.tileSamples; exports.tileSamples16 = _chunkCWM3CUUXcjs.tileSamples16; exports.tileSamples32 = _chunkCWM3CUUXcjs.tileSamples32; exports.tilesInRect = _chunkCWM3CUUXcjs.tilesInRect; exports.tipFalloff = _chunkEBDCRTZIcjs.tipFalloff; exports.tipReach = _chunkEBDCRTZIcjs.tipReach; exports.tipShape = _chunkEBDCRTZIcjs.tipShape; exports.to16From32 = _chunkCWM3CUUXcjs.to16From32; exports.to16From8 = _chunkCWM3CUUXcjs.to16From8; exports.to32From16 = _chunkCWM3CUUXcjs.to32From16; exports.to32From8 = _chunkCWM3CUUXcjs.to32From8; exports.to8From16 = _chunkCWM3CUUXcjs.to8From16; exports.to8From32 = _chunkCWM3CUUXcjs.to8From32; exports.toHex = toHex; exports.toTextSpace = _chunkUYXL6ZWQcjs.toTextSpace; exports.toneCurve = _chunkUYXL6ZWQcjs.toneCurve; exports.toneLuts = _chunkUYXL6ZWQcjs.toneLuts; exports.toneOf = _chunk7NW46N7Icjs.toneOf; exports.toneRange = toneRange; exports.transformHomography = _chunkUYXL6ZWQcjs.transformHomography; exports.transformMap = _chunkUYXL6ZWQcjs.transformMap; exports.transformShapeComponents = _chunkUYXL6ZWQcjs.transformShapeComponents; exports.transformSurface = _chunkHGTDMKNEcjs.transformSurface; exports.transformTypeLayer = _chunkUYXL6ZWQcjs.transformTypeLayer; exports.transformVectorMask = _chunkUYXL6ZWQcjs.transformVectorMask; exports.transformedBounds = _chunkHGTDMKNEcjs.transformedBounds; exports.transformedBox = _chunkUYXL6ZWQcjs.transformedBox; exports.transformedPoint = _chunkUYXL6ZWQcjs.transformedPoint; exports.translateLayer = _chunkUYXL6ZWQcjs.translateLayer; exports.translateSurface = _chunkCWM3CUUXcjs.translateSurface; exports.typeAsPixelLayer = _chunkUYXL6ZWQcjs.typeAsPixelLayer; exports.typeFrame = _chunkUYXL6ZWQcjs.typeFrame; exports.typeFromAnnotation = _chunkUYXL6ZWQcjs.typeFromAnnotation; exports.typeLayerAt = typeLayerAt; exports.typeLayerName = _chunkUYXL6ZWQcjs.typeLayerName; exports.ungroupLayer = _chunkUYXL6ZWQcjs.ungroupLayer; exports.uniformTile = _chunkCWM3CUUXcjs.uniformTile; exports.unionRect = _chunkUYXL6ZWQcjs.unionRect; exports.unprojectCanvasPoint = _chunkUYXL6ZWQcjs.unprojectCanvasPoint; exports.updateLayerEffect = _chunkUYXL6ZWQcjs.updateLayerEffect; exports.updateLayerFilter = _chunkUYXL6ZWQcjs.updateLayerFilter; exports.updateLayerMaskProps = _chunkUYXL6ZWQcjs.updateLayerMaskProps; exports.updatePaintGradientStop = _chunkEBDCRTZIcjs.updatePaintGradientStop; exports.updateShapeLayer = _chunkUYXL6ZWQcjs.updateShapeLayer; exports.updateSmartFilter = _chunkUYXL6ZWQcjs.updateSmartFilter; exports.updateTypeLayer = _chunkUYXL6ZWQcjs.updateTypeLayer; exports.userErrorMessage = _chunkUYXL6ZWQcjs.userErrorMessage; exports.uvToXy = _chunkUYXL6ZWQcjs.uvToXy; exports.validateEffectGradient = _chunkHGTDMKNEcjs.validateEffectGradient; exports.validateLayerEffect = _chunkHGTDMKNEcjs.validateLayerEffect; exports.validateLayerEffects = _chunkHGTDMKNEcjs.validateLayerEffects; exports.vectorMaskBounds = _chunkUYXL6ZWQcjs.vectorMaskBounds; exports.vectorMaskCoverage = _chunkUYXL6ZWQcjs.vectorMaskCoverage; exports.vectorMaskThumbnail = _chunkUYXL6ZWQcjs.vectorMaskThumbnail; exports.vectorMaskThumbnailClick = vectorMaskThumbnailClick; exports.versionedDescriptorBytes = _chunkUYXL6ZWQcjs.versionedDescriptorBytes; exports.vibranceLinear = _chunkUYXL6ZWQcjs.vibranceLinear; exports.vibrancePixel = _chunkUYXL6ZWQcjs.vibrancePixel; exports.walkDabs = _chunkEBDCRTZIcjs.walkDabs; exports.warpMeshEditPoints = _chunkBRKVNXDZcjs.warpMeshEditPoints; exports.warpMeshGridCurves = _chunkBRKVNXDZcjs.warpMeshGridCurves; exports.warpMeshParamAt = _chunkBRKVNXDZcjs.warpMeshParamAt; exports.warpPresetMesh = _chunkBRKVNXDZcjs.warpPresetMesh; exports.warpSurface = _chunkHGTDMKNEcjs.warpSurface; exports.watchCanvasViewport = watchCanvasViewport; exports.wbMatrix = _chunkUYXL6ZWQcjs.wbMatrix; exports.wetGpuSupport = _chunkV7GWZIZKcjs.wetGpuSupport; exports.wetSimdSupported = _chunkV7GWZIZKcjs.wetSimdSupported; exports.wetSupport = _chunkV7GWZIZKcjs.wetSupport; exports.whiteBalanceFromSample = _chunkUYXL6ZWQcjs.whiteBalanceFromSample; exports.whiteBalanceMatrix = _chunkUYXL6ZWQcjs.whiteBalanceMatrix; exports.withBackgroundOpacity = withBackgroundOpacity; exports.withFilterMaskSurface = _chunkUYXL6ZWQcjs.withFilterMaskSurface; exports.withImagePlayback = withImagePlayback; exports.withNewIds = _chunkUYXL6ZWQcjs.withNewIds; exports.workImage = workImage; exports.writeAdjustmentBlock = _chunkUYXL6ZWQcjs.writeAdjustmentBlock; exports.writeDeepRegion = _chunkCWM3CUUXcjs.writeDeepRegion; exports.writeLfx2 = _chunkUYXL6ZWQcjs.writeLfx2; exports.writePatternBlock = _chunkUYXL6ZWQcjs.writePatternBlock; exports.writePsd = _chunkUYXL6ZWQcjs.writePsd; exports.writeRegion = _chunkCWM3CUUXcjs.writeRegion; exports.xyToTempTint = _chunkUYXL6ZWQcjs.xyToTempTint; exports.xyToUv = _chunkUYXL6ZWQcjs.xyToUv;
+
+
+
+
+
+
+
+exports.ADJUSTMENT_KEYS = _chunkUYXL6ZWQcjs.ADJUSTMENT_KEYS; exports.ADJUSTMENT_KINDS = _chunkUYXL6ZWQcjs.ADJUSTMENT_KINDS; exports.ADJUSTMENT_LAYER_CONTROLS = ADJUSTMENT_LAYER_CONTROLS; exports.ADJUSTMENT_LAYER_OPACITY_CONTROL = ADJUSTMENT_LAYER_OPACITY_CONTROL; exports.ADJUSTMENT_LUT_SIZE = _chunkUYXL6ZWQcjs.ADJUSTMENT_LUT_SIZE; exports.ANCHOR_FRACTION = _chunkUYXL6ZWQcjs.ANCHOR_FRACTION; exports.AS_SHOT_KELVIN = _chunkUYXL6ZWQcjs.AS_SHOT_KELVIN; exports.BACKGROUND_LAYER_ID = _chunkUYXL6ZWQcjs.BACKGROUND_LAYER_ID; exports.BACKGROUND_LAYER_NAME = _chunkUYXL6ZWQcjs.BACKGROUND_LAYER_NAME; exports.BIT_DEPTHS = _chunkCWM3CUUXcjs.BIT_DEPTHS; exports.BIT_DEPTH_OPTIONS = BIT_DEPTH_OPTIONS; exports.BLEND_MODES = _chunkCWM3CUUXcjs.BLEND_MODES; exports.BLUR_FILTER_ID = _chunkUYXL6ZWQcjs.BLUR_FILTER_ID; exports.BODY_SCATTER = _chunkV7GWZIZKcjs.BODY_SCATTER; exports.BRUSHSTROKE_MAX_SCALE = _chunkYQGCPL5Xcjs.BRUSHSTROKE_MAX_SCALE; exports.BRUSHSTROKE_MIN_SCALE = _chunkYQGCPL5Xcjs.BRUSHSTROKE_MIN_SCALE; exports.BRUSH_OPTION_CONTROLS = BRUSH_OPTION_CONTROLS; exports.BUILTIN_PROFILES = _chunkBROJYMWUcjs.BUILTIN_PROFILES; exports.BrushstrokeCache = _chunkEBDCRTZIcjs.BrushstrokeCache; exports.CANVAS_SIZE_PRESETS = CANVAS_SIZE_PRESETS; exports.CLONE_TRANSFORM_CONTROLS = CLONE_TRANSFORM_CONTROLS; exports.COLOR_MODE_OPTIONS = COLOR_MODE_OPTIONS; exports.COLOR_RANGE_PRESETS = COLOR_RANGE_PRESETS; exports.COLOR_RANGE_PRESET_LABELS = COLOR_RANGE_PRESET_LABELS; exports.ColorGmm = ColorGmm; exports.CoverageMap = _chunkEBDCRTZIcjs.CoverageMap; exports.D50 = _chunkUYXL6ZWQcjs.D50; exports.D65 = _chunkUYXL6ZWQcjs.D65; exports.DEFAULT_ADJUSTMENTS = DEFAULT_ADJUSTMENTS; exports.DEFAULT_AUTO_LEADING = _chunkBRKVNXDZcjs.DEFAULT_AUTO_LEADING; exports.DEFAULT_BLENDER = _chunkEBDCRTZIcjs.DEFAULT_BLENDER; exports.DEFAULT_BRUSH = _chunkEBDCRTZIcjs.DEFAULT_BRUSH; exports.DEFAULT_CANVAS_VIEWPORT = DEFAULT_CANVAS_VIEWPORT; exports.DEFAULT_CHANNEL_COLOR = DEFAULT_CHANNEL_COLOR; exports.DEFAULT_DEPTH_MASK = DEFAULT_DEPTH_MASK; exports.DEFAULT_FLOW = _chunkV7GWZIZKcjs.DEFAULT_FLOW; exports.DEFAULT_GLOBAL_LIGHT = _chunkHGTDMKNEcjs.DEFAULT_GLOBAL_LIGHT; exports.DEFAULT_MITER_LIMIT = _chunkUYXL6ZWQcjs.DEFAULT_MITER_LIMIT; exports.DEFAULT_MIXER = _chunkEBDCRTZIcjs.DEFAULT_MIXER; exports.DEFAULT_PAINT_GRADIENT = _chunkEBDCRTZIcjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkEBDCRTZIcjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PROOF = DEFAULT_PROOF; exports.DEFAULT_REFINE_EDGE_PARAMS = DEFAULT_REFINE_EDGE_PARAMS; exports.DEFAULT_RETOUCH = _chunk7NW46N7Icjs.DEFAULT_RETOUCH; exports.DEFAULT_SELECTION_TOOL_OPTIONS = DEFAULT_SELECTION_TOOL_OPTIONS; exports.DEFAULT_SHAPE_TOOL_OPTIONS = DEFAULT_SHAPE_TOOL_OPTIONS; exports.DEFAULT_SMUDGE = _chunkEBDCRTZIcjs.DEFAULT_SMUDGE; exports.DEFAULT_TEXT_STYLE = _chunkBRKVNXDZcjs.DEFAULT_TEXT_STYLE; exports.DEFAULT_TRANSFORM = DEFAULT_TRANSFORM; exports.DEFAULT_TYPE_TOOL_OPTIONS = DEFAULT_TYPE_TOOL_OPTIONS; exports.DEFAULT_WET_PAPER = _chunkV7GWZIZKcjs.DEFAULT_WET_PAPER; exports.DEFAULT_WET_PARAMS = _chunkV7GWZIZKcjs.DEFAULT_WET_PARAMS; exports.DEPTH_MASK_CONTROLS = DEPTH_MASK_CONTROLS; exports.DEVELOP_FILTER_ID = _chunkUYXL6ZWQcjs.DEVELOP_FILTER_ID; exports.DIRECT_GAUSSIAN_MAX_SIGMA = _chunkHGTDMKNEcjs.DIRECT_GAUSSIAN_MAX_SIGMA; exports.DRY_EPS = _chunkV7GWZIZKcjs.DRY_EPS; exports.DabWalker = _chunkEBDCRTZIcjs.DabWalker; exports.EFFECT_LAYER_USES = EFFECT_LAYER_USES; exports.EMPTY_DISTANCE = _chunkUYXL6ZWQcjs.EMPTY_DISTANCE; exports.EMPTY_MIXER_LOAD = _chunkEBDCRTZIcjs.EMPTY_MIXER_LOAD; exports.EX = _chunkV7GWZIZKcjs.EX; exports.EY = _chunkV7GWZIZKcjs.EY; exports.EdgeMap = EdgeMap; exports.FLAG_ALIVE = _chunkV7GWZIZKcjs.FLAG_ALIVE; exports.FLAG_BOTTOM = _chunkV7GWZIZKcjs.FLAG_BOTTOM; exports.FLAG_LEFT = _chunkV7GWZIZKcjs.FLAG_LEFT; exports.FLAG_RIGHT = _chunkV7GWZIZKcjs.FLAG_RIGHT; exports.FLAG_TOP = _chunkV7GWZIZKcjs.FLAG_TOP; exports.FLAG_WET = _chunkV7GWZIZKcjs.FLAG_WET; exports.FLAT = _chunkV7GWZIZKcjs.FLAT; exports.FREE_INTERVAL = _chunkV7GWZIZKcjs.FREE_INTERVAL; exports.FREE_TRANSFORM_CONTENTS = FREE_TRANSFORM_CONTENTS; exports.FREE_TRANSFORM_FIELDS = FREE_TRANSFORM_FIELDS; exports.FREE_TRANSFORM_MODES = _chunkUYXL6ZWQcjs.FREE_TRANSFORM_MODES; exports.FREE_TRANSFORM_MODE_OPTIONS = FREE_TRANSFORM_MODE_OPTIONS; exports.FreeTransformSession = FreeTransformSession; exports.FreeTransformTool = FreeTransformTool; exports.GAMMA = GAMMA; exports.GRAIN_PATTERNS = _chunkEBDCRTZIcjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkEBDCRTZIcjs.GRAIN_TILE; exports.GUIDED_FILTER_EPS = GUIDED_FILTER_EPS; exports.GridGraph = GridGraph; exports.HIDE = _chunkV7GWZIZKcjs.HIDE; exports.HISTOGRAM_BINS = HISTOGRAM_BINS; exports.HUE_RANGE_LABELS = _chunkUYXL6ZWQcjs.HUE_RANGE_LABELS; exports.HUE_RANGE_PRESETS = HUE_RANGE_PRESETS; exports.IDENTITY_CLONE_TRANSFORM = _chunk7NW46N7Icjs.IDENTITY_CLONE_TRANSFORM; exports.IDENTITY_MATRIX3 = _chunkUYXL6ZWQcjs.IDENTITY_MATRIX3; exports.IMAGE_ADJUSTMENT_CONTROLS = IMAGE_ADJUSTMENT_CONTROLS; exports.IMAGE_CROP_PRESETS = IMAGE_CROP_PRESETS; exports.IMAGE_EDITOR_SCHEMA_VERSION = IMAGE_EDITOR_SCHEMA_VERSION; exports.IMAGE_EDITOR_STATE_VERSION = IMAGE_EDITOR_STATE_VERSION; exports.IMAGE_EFFECT_PLACES = IMAGE_EFFECT_PLACES; exports.IMAGE_FILTER_PRESETS = IMAGE_FILTER_PRESETS; exports.IMAGE_PLAYBACK_KIND = IMAGE_PLAYBACK_KIND; exports.IMAGE_TOOL_GROUPS = IMAGE_TOOL_GROUPS; exports.IMAGE_TOOL_SHORTCUTS = IMAGE_TOOL_SHORTCUTS; exports.INTENTS = _chunkBROJYMWUcjs.INTENTS; exports.INTENT_OPTIONS = INTENT_OPTIONS; exports.INTERPOLATIONS = _chunkHGTDMKNEcjs.INTERPOLATIONS; exports.ImageEditorController = ImageEditorController; exports.ImageEditorRenderer = ImageEditorRenderer; exports.ImageEffectsEngine = ImageEffectsEngine; exports.LATEST_PROCESS_VERSION = _chunkUYXL6ZWQcjs.LATEST_PROCESS_VERSION; exports.LAYERED_SCHEMA_VERSION = _chunkUYXL6ZWQcjs.LAYERED_SCHEMA_VERSION; exports.LAYER_EFFECT_KINDS = _chunkHGTDMKNEcjs.LAYER_EFFECT_KINDS; exports.LAYER_EFFECT_MENU = LAYER_EFFECT_MENU; exports.LEGACY_PROCESS_VERSION = _chunkUYXL6ZWQcjs.LEGACY_PROCESS_VERSION; exports.LIVE_SHAPE_KINDS = _chunkUYXL6ZWQcjs.LIVE_SHAPE_KINDS; exports.LUMA_709 = _chunkUYXL6ZWQcjs.LUMA_709; exports.LayerCompositor = _chunkUYXL6ZWQcjs.LayerCompositor; exports.LayerEffectError = _chunkHGTDMKNEcjs.LayerEffectError; exports.LayerOperationError = _chunkUYXL6ZWQcjs.LayerOperationError; exports.MARCHING_ANTS_STEP_MS = MARCHING_ANTS_STEP_MS; exports.MASK_FILE_ACCEPT = MASK_FILE_ACCEPT; exports.MAX_BATCH = _chunkV7GWZIZKcjs.MAX_BATCH; exports.MAX_BRUSH_SIZE = _chunkEBDCRTZIcjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_BACKING_SIDE = MAX_CANVAS_BACKING_SIDE; exports.MAX_EFFECT_ANIMATION_MS = _chunkUYXL6ZWQcjs.MAX_EFFECT_ANIMATION_MS; exports.MAX_EFFECT_REACH = _chunkHGTDMKNEcjs.MAX_EFFECT_REACH; exports.MAX_KELVIN = _chunkUYXL6ZWQcjs.MAX_KELVIN; exports.MAX_TILT_ACCEL = _chunkV7GWZIZKcjs.MAX_TILT_ACCEL; exports.MAX_TRANSFORM_PIXELS = _chunkHGTDMKNEcjs.MAX_TRANSFORM_PIXELS; exports.MAX_WET_LANES = _chunkV7GWZIZKcjs.MAX_WET_LANES; exports.MAX_WET_SLOTS = _chunkV7GWZIZKcjs.MAX_WET_SLOTS; exports.MIN_KELVIN = _chunkUYXL6ZWQcjs.MIN_KELVIN; exports.MIRED_PER_TEMPERATURE_UNIT = _chunkUYXL6ZWQcjs.MIRED_PER_TEMPERATURE_UNIT; exports.MIXER_DRAIN = _chunkEBDCRTZIcjs.MIXER_DRAIN; exports.MIXER_MIXING_OPTIONS = MIXER_MIXING_OPTIONS; exports.MIXER_OPTION_CONTROLS = MIXER_OPTION_CONTROLS; exports.MIXER_PICKUP_RATE = _chunkEBDCRTZIcjs.MIXER_PICKUP_RATE; exports.MIXING_MODELS = _chunkEBDCRTZIcjs.MIXING_MODELS; exports.MixerStroke = _chunkEBDCRTZIcjs.MixerStroke; exports.OPP = _chunkV7GWZIZKcjs.OPP; exports.PAINTERLY_BLEND_MODES = _chunkCWM3CUUXcjs.PAINTERLY_BLEND_MODES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkEBDCRTZIcjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_GRADIENT_FULL_SPEED = _chunkEBDCRTZIcjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkEBDCRTZIcjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkEBDCRTZIcjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkEBDCRTZIcjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkEBDCRTZIcjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkEBDCRTZIcjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_CAPACITY = _chunkV7GWZIZKcjs.PAPER_CAPACITY; exports.PARAGRAPH_STYLE_FIELDS = _chunkUYXL6ZWQcjs.PARAGRAPH_STYLE_FIELDS; exports.PARAM = _chunkV7GWZIZKcjs.PARAM; exports.PARAM_FLOATS = _chunkV7GWZIZKcjs.PARAM_FLOATS; exports.PASTE_MODES = PASTE_MODES; exports.PATTERN_BLOCK_KEYS = _chunkUYXL6ZWQcjs.PATTERN_BLOCK_KEYS; exports.PIGMENT_BANDS = _chunkCWM3CUUXcjs.PIGMENT_BANDS; exports.PIGMENT_CHANNELS = _chunkV7GWZIZKcjs.PIGMENT_CHANNELS; exports.PIGMENT_LAMBDA_MIN = _chunkCWM3CUUXcjs.PIGMENT_LAMBDA_MIN; exports.PIGMENT_LAMBDA_STEP = _chunkCWM3CUUXcjs.PIGMENT_LAMBDA_STEP; exports.PIGMENT_UNIT = _chunkV7GWZIZKcjs.PIGMENT_UNIT; exports.PIGMENT_WAVELENGTHS = _chunkCWM3CUUXcjs.PIGMENT_WAVELENGTHS; exports.PLANE = _chunkV7GWZIZKcjs.PLANE; exports.PLANE_BYTES = _chunkV7GWZIZKcjs.PLANE_BYTES; exports.PROOF_PROFILE_OPTIONS = PROOF_PROFILE_OPTIONS; exports.PSD_BLEND_KEYS = _chunkUYXL6ZWQcjs.PSD_BLEND_KEYS; exports.PSD_FILE_ACCEPT = PSD_FILE_ACCEPT; exports.P_D0 = _chunkV7GWZIZKcjs.P_D0; exports.P_EDGE = _chunkV7GWZIZKcjs.P_EDGE; exports.P_FX = _chunkV7GWZIZKcjs.P_FX; exports.P_FY = _chunkV7GWZIZKcjs.P_FY; exports.P_H = _chunkV7GWZIZKcjs.P_H; exports.P_P0 = _chunkV7GWZIZKcjs.P_P0; exports.P_RHO = _chunkV7GWZIZKcjs.P_RHO; exports.P_SW = _chunkV7GWZIZKcjs.P_SW; exports.P_UX = _chunkV7GWZIZKcjs.P_UX; exports.P_UY = _chunkV7GWZIZKcjs.P_UY; exports.PaintExchange = _chunkEBDCRTZIcjs.PaintExchange; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _chunkEBDCRTZIcjs.PaintGradientSampler; exports.PaintSourceError = _chunkEBDCRTZIcjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaperGrain = _chunkEBDCRTZIcjs.PaperGrain; exports.PatternPlacement = _chunkHGTDMKNEcjs.PatternPlacement; exports.PatternTile = _chunkHGTDMKNEcjs.PatternTile; exports.PsdError = _chunkUYXL6ZWQcjs.PsdError; exports.QUICK_MASK_TARGET = QUICK_MASK_TARGET; exports.REFINE_EDGE_CONTROLS = REFINE_EDGE_CONTROLS; exports.RETOUCH_CHOICES = RETOUCH_CHOICES; exports.RETOUCH_OPTION_CONTROLS = RETOUCH_OPTION_CONTROLS; exports.RETOUCH_SAMPLES = _chunk7NW46N7Icjs.RETOUCH_SAMPLES; exports.RETOUCH_TOGGLES = RETOUCH_TOGGLES; exports.RETOUCH_TOOLS = RETOUCH_TOOLS; exports.RegionPixelSource = _chunk7NW46N7Icjs.RegionPixelSource; exports.RetouchDabStroke = _chunk7NW46N7Icjs.RetouchDabStroke; exports.SELECTION_MODES = _chunkUYXL6ZWQcjs.SELECTION_MODES; exports.SELECTION_MODE_LABELS = SELECTION_MODE_LABELS; exports.SELECTION_MODIFY_OPS = _chunkUYXL6ZWQcjs.SELECTION_MODIFY_OPS; exports.SELECTION_TOOLS = SELECTION_TOOLS; exports.SET_PLANES = _chunkV7GWZIZKcjs.SET_PLANES; exports.SHADOW_AMBIENT = _chunkCWM3CUUXcjs.SHADOW_AMBIENT; exports.SHAPE_KIND_LABELS = SHAPE_KIND_LABELS; exports.SHAPE_OPERATIONS = _chunkUYXL6ZWQcjs.SHAPE_OPERATIONS; exports.SHAPE_RENDER_MARGIN = _chunkUYXL6ZWQcjs.SHAPE_RENDER_MARGIN; exports.SLOT_BYTES = _chunkV7GWZIZKcjs.SLOT_BYTES; exports.SLOT_PLANES = _chunkV7GWZIZKcjs.SLOT_PLANES; exports.SLOT_SIDE = _chunkV7GWZIZKcjs.SLOT_SIDE; exports.SMART_RENDER_MARGIN = _chunkUYXL6ZWQcjs.SMART_RENDER_MARGIN; exports.SPOT_HEAL_TYPES = _chunk7NW46N7Icjs.SPOT_HEAL_TYPES; exports.SRGB_TO_LINEAR = _chunkV7GWZIZKcjs.SRGB_TO_LINEAR; exports.STRIP = _chunkV7GWZIZKcjs.STRIP; exports.SUPPORTED_ADJUSTMENT_KEYS = _chunkUYXL6ZWQcjs.SUPPORTED_ADJUSTMENT_KEYS; exports.SelectionGesture = SelectionGesture; exports.ShapeDrawGesture = ShapeDrawGesture; exports.SmudgeTip = _chunkEBDCRTZIcjs.SmudgeTip; exports.StrokeCoverage = _chunkEBDCRTZIcjs.StrokeCoverage; exports.SurfaceDraft = _chunkCWM3CUUXcjs.SurfaceDraft; exports.TEXT_ALIGNS = _chunkUYXL6ZWQcjs.TEXT_ALIGNS; exports.TEXT_ORIENTATIONS = _chunkUYXL6ZWQcjs.TEXT_ORIENTATIONS; exports.TEXT_RENDER_MARGIN = _chunkUYXL6ZWQcjs.TEXT_RENDER_MARGIN; exports.TEXT_STYLE_FIELDS = _chunkUYXL6ZWQcjs.TEXT_STYLE_FIELDS; exports.TILE = _chunkCWM3CUUXcjs.TILE; exports.TILE_SHIFT = _chunkCWM3CUUXcjs.TILE_SHIFT; exports.TINT_SCALE = _chunkUYXL6ZWQcjs.TINT_SCALE; exports.TIP_GRADIENT_STEPS = _chunkEBDCRTZIcjs.TIP_GRADIENT_STEPS; exports.TONE_LUT_SIZE = _chunkUYXL6ZWQcjs.TONE_LUT_SIZE; exports.TONE_RANGES = _chunk7NW46N7Icjs.TONE_RANGES; exports.TONE_RANGE_PRESETS = TONE_RANGE_PRESETS; exports.TRANSFORM_ANCHORS = _chunkUYXL6ZWQcjs.TRANSFORM_ANCHORS; exports.TRANSFORM_ROTATE_HANDLE_OFFSET = TRANSFORM_ROTATE_HANDLE_OFFSET; exports.TextEditSession = TextEditSession; exports.TileMedium = _chunkEBDCRTZIcjs.TileMedium; exports.TilePixelSource = _chunk7NW46N7Icjs.TilePixelSource; exports.TileableNoise = _chunkEBDCRTZIcjs.TileableNoise; exports.TiledSurface = _chunkCWM3CUUXcjs.TiledSurface; exports.TransformTooLargeError = _chunkHGTDMKNEcjs.TransformTooLargeError; exports.TransformedPixelSource = _chunk7NW46N7Icjs.TransformedPixelSource; exports.TypeToolGesture = TypeToolGesture; exports.UNITS = UNITS; exports.U_MAX = _chunkV7GWZIZKcjs.U_MAX; exports.VIBRANCE_GREY = _chunkUYXL6ZWQcjs.VIBRANCE_GREY; exports.W9 = _chunkV7GWZIZKcjs.W9; exports.WARP_GRID_OPTIONS = WARP_GRID_OPTIONS; exports.WARP_STYLES = _chunkBRKVNXDZcjs.WARP_STYLES; exports.WARP_STYLE_LABELS = _chunkBRKVNXDZcjs.WARP_STYLE_LABELS; exports.WARP_STYLE_OPTIONS = WARP_STYLE_OPTIONS; exports.WET_FLOW_KINDS = _chunkV7GWZIZKcjs.WET_FLOW_KINDS; exports.WET_PARAM_KEYS = _chunkV7GWZIZKcjs.WET_PARAM_KEYS; exports.WET_TILE = _chunkV7GWZIZKcjs.WET_TILE; exports.WGSL_HALO = _chunkV7GWZIZKcjs.WGSL_HALO; exports.WGSL_SHADE = _chunkV7GWZIZKcjs.WGSL_SHADE; exports.WGSL_STEP = _chunkV7GWZIZKcjs.WGSL_STEP; exports.WORKING_SPACE_OPTIONS = WORKING_SPACE_OPTIONS; exports.WORK_SIZE = WORK_SIZE; exports.WetGpuEngine = _chunkV7GWZIZKcjs.WetGpuEngine; exports.WetMedium = _chunkV7GWZIZKcjs.WetMedium; exports.WetWorkerPool = _chunkV7GWZIZKcjs.WetWorkerPool; exports.WetWorld = _chunkV7GWZIZKcjs.WetWorld; exports.WetWorldError = _chunkV7GWZIZKcjs.WetWorldError; exports.XYZ_D50_TO_SRGB = _chunkUYXL6ZWQcjs.XYZ_D50_TO_SRGB; exports.ZlibError = _chunkXFM3OCHUcjs.ZlibError; exports.activeAdjustmentLayers = _chunkUYXL6ZWQcjs.activeAdjustmentLayers; exports.activeEffectSmartFilters = _chunkUYXL6ZWQcjs.activeEffectSmartFilters; exports.activeLayerAfterRemoval = _chunkUYXL6ZWQcjs.activeLayerAfterRemoval; exports.activeSmartFilters = _chunkUYXL6ZWQcjs.activeSmartFilters; exports.addLayerEffect = _chunkUYXL6ZWQcjs.addLayerEffect; exports.addLayerFilter = _chunkUYXL6ZWQcjs.addLayerFilter; exports.addLayerOfKind = addLayerOfKind; exports.addPaintGradientStop = _chunkEBDCRTZIcjs.addPaintGradientStop; exports.addSmartFilter = _chunkUYXL6ZWQcjs.addSmartFilter; exports.addToHistogram = addToHistogram; exports.adjustmentKindLabel = _chunkUYXL6ZWQcjs.adjustmentKindLabel; exports.adjustmentLayersKey = _chunkUYXL6ZWQcjs.adjustmentLayersKey; exports.adjustmentNodeAsLayer = _chunkUYXL6ZWQcjs.adjustmentNodeAsLayer; exports.adjustmentNodeFromLegacy = _chunkUYXL6ZWQcjs.adjustmentNodeFromLegacy; exports.adler32 = _chunkXFM3OCHUcjs.adler32; exports.agentDragDraft = agentDragDraft; exports.anchorPoint = _chunkUYXL6ZWQcjs.anchorPoint; exports.annotationBlend = _chunkUYXL6ZWQcjs.annotationBlend; exports.annotationLayerFor = _chunkUYXL6ZWQcjs.annotationLayerFor; exports.annotationLayerName = _chunkUYXL6ZWQcjs.annotationLayerName; exports.annotationOfLayer = _chunkUYXL6ZWQcjs.annotationOfLayer; exports.annotationOfShape = _chunkUYXL6ZWQcjs.annotationOfShape; exports.annotationOfType = _chunkUYXL6ZWQcjs.annotationOfType; exports.applyAdjustmentLayers = _chunkUYXL6ZWQcjs.applyAdjustmentLayers; exports.applyAdjustmentLayersFloat = _chunkUYXL6ZWQcjs.applyAdjustmentLayersFloat; exports.applyAdjustments = _chunkUYXL6ZWQcjs.applyAdjustments; exports.applyBoxBlur = _chunkUYXL6ZWQcjs.applyBoxBlur; exports.applyBoxBlurFloat = _chunkUYXL6ZWQcjs.applyBoxBlurFloat; exports.applyDepthMask = _chunkUYXL6ZWQcjs.applyDepthMask; exports.applyHomography = _chunkQT26RHKKcjs.applyHomography; exports.applyImageProjectionToContext = _chunkUYXL6ZWQcjs.applyImageProjectionToContext; exports.applyLegacyAdjustments = _chunkUYXL6ZWQcjs.applyLegacyAdjustments; exports.applyLegacyFloat = _chunkUYXL6ZWQcjs.applyLegacyFloat; exports.applyMatrix3 = _chunkUYXL6ZWQcjs.applyMatrix3; exports.applyOutputStage = applyOutputStage; exports.applyParams = _chunkUYXL6ZWQcjs.applyParams; exports.applyProcess2Adjustments = _chunkUYXL6ZWQcjs.applyProcess2Adjustments; exports.applyProcess2Float = _chunkUYXL6ZWQcjs.applyProcess2Float; exports.applyRegionBlur = applyRegionBlur; exports.applyRegionMosaic = applyRegionMosaic; exports.applyRetouchToTile = _chunk7NW46N7Icjs.applyRetouchToTile; exports.applyShapeOptions = applyShapeOptions; exports.applySmartFilters = _chunkUYXL6ZWQcjs.applySmartFilters; exports.applyStrokeToDeepTile = _chunkEBDCRTZIcjs.applyStrokeToDeepTile; exports.applyStrokeToTile = _chunkEBDCRTZIcjs.applyStrokeToTile; exports.applyToneToDeepTile = _chunk7NW46N7Icjs.applyToneToDeepTile; exports.backgroundLayer = _chunkUYXL6ZWQcjs.backgroundLayer; exports.base64ToBytes = _chunkCWM3CUUXcjs.base64ToBytes; exports.baseProjection = baseProjection; exports.bestOffset = _chunk7NW46N7Icjs.bestOffset; exports.blackWhiteGray = _chunkUYXL6ZWQcjs.blackWhiteGray; exports.blendChannel = _chunkCWM3CUUXcjs.blendChannel; exports.blendImageData = _chunkCWM3CUUXcjs.blendImageData; exports.blendLum = _chunkCWM3CUUXcjs.blendLum; exports.blendPixel = _chunkCWM3CUUXcjs.blendPixel; exports.blendRadius = _chunkEBDCRTZIcjs.blendRadius; exports.blendRgb = _chunkCWM3CUUXcjs.blendRgb; exports.blendTile = _chunkHGTDMKNEcjs.blendTile; exports.blenderDab = _chunkEBDCRTZIcjs.blenderDab; exports.blurFilter = _chunkUYXL6ZWQcjs.blurFilter; exports.borderCoverage = _chunkUYXL6ZWQcjs.borderCoverage; exports.boxBlur = boxBlur; exports.boxBlurPixels = _chunk7NW46N7Icjs.boxBlurPixels; exports.boxFrameHit = boxFrameHit; exports.boxFrameOverlay = boxFrameOverlay; exports.boxMean = boxMean; exports.boxPointOf = _chunkUYXL6ZWQcjs.boxPointOf; exports.boxQuad = _chunkQT26RHKKcjs.boxQuad; exports.boxToCurvePoint = boxToCurvePoint; exports.bradfordAdaptation = _chunkUYXL6ZWQcjs.bradfordAdaptation; exports.brushstrokeDataUrl = _chunkEBDCRTZIcjs.brushstrokeDataUrl; exports.brushstrokeKey = _chunkEBDCRTZIcjs.brushstrokeKey; exports.brushstrokeSamples = _chunkEBDCRTZIcjs.brushstrokeSamples; exports.brushstrokeScaleBucket = _chunkYQGCPL5Xcjs.brushstrokeScaleBucket; exports.brushstrokeStrokeOptions = _chunkEBDCRTZIcjs.brushstrokeStrokeOptions; exports.brushstrokeToCanvas = _chunkEBDCRTZIcjs.brushstrokeToCanvas; exports.buildLayerMaskPlanes = _chunkUYXL6ZWQcjs.buildLayerMaskPlanes; exports.buildToneLut = _chunkUYXL6ZWQcjs.buildToneLut; exports.builtinPattern = _chunkHGTDMKNEcjs.builtinPattern; exports.builtinPatternIds = _chunkHGTDMKNEcjs.builtinPatternIds; exports.bytesToBase64 = _chunkCWM3CUUXcjs.bytesToBase64; exports.calculateCropDrag = _chunkUYXL6ZWQcjs.calculateCropDrag; exports.canShareMemory = _chunkV7GWZIZKcjs.canShareMemory; exports.canvasCompositeOperation = _chunkCWM3CUUXcjs.canvasCompositeOperation; exports.canvasToImagePoint = _chunkUYXL6ZWQcjs.canvasToImagePoint; exports.caretAt = _chunkBRKVNXDZcjs.caretAt; exports.changedTiles = _chunkHGTDMKNEcjs.changedTiles; exports.channelThumbnail = channelThumbnail; exports.checkEffectAnimation = checkEffectAnimation; exports.checkEffectTime = checkEffectTime; exports.checkImageEffectPlace = checkImageEffectPlace; exports.clampControlValue = clampControlValue; exports.clampCropToImage = _chunkUYXL6ZWQcjs.clampCropToImage; exports.cleanMixer = _chunkEBDCRTZIcjs.cleanMixer; exports.cloneSamplePoint = _chunk7NW46N7Icjs.cloneSamplePoint; exports.cloneSourceLabel = cloneSourceLabel; exports.cloneTransformView = cloneTransformView; exports.collectTiles = _chunkCWM3CUUXcjs.collectTiles; exports.colorBalanceChannel = _chunkUYXL6ZWQcjs.colorBalanceChannel; exports.colorModePlanes = colorModePlanes; exports.colorModePlanes16 = colorModePlanes16; exports.colorPanelView = colorPanelView; exports.colorRange = colorRange; exports.colorRangePreset = colorRangePreset; exports.combineSelections = _chunkUYXL6ZWQcjs.combineSelections; exports.compileAdjustmentLayer = _chunkUYXL6ZWQcjs.compileAdjustmentLayer; exports.componentPath = _chunkUYXL6ZWQcjs.componentPath; exports.componentsCoverage = _chunkUYXL6ZWQcjs.componentsCoverage; exports.compositeDeep = _chunkUYXL6ZWQcjs.compositeDeep; exports.compositeSurfaceOver = _chunkHGTDMKNEcjs.compositeSurfaceOver; exports.computeHistogram = computeHistogram; exports.computeSelectionBounds = _chunkUYXL6ZWQcjs.computeSelectionBounds; exports.contentAwareFill = _chunk7NW46N7Icjs.contentAwareFill; exports.contentBounds = _chunkCWM3CUUXcjs.contentBounds; exports.contentsBox = _chunkUYXL6ZWQcjs.contentsBox; exports.contentsSurface = _chunkUYXL6ZWQcjs.contentsSurface; exports.contractCoverage = _chunkUYXL6ZWQcjs.contractCoverage; exports.controlPosition = controlPosition; exports.controlTrackBackground = controlTrackBackground; exports.convertColorFields = convertColorFields; exports.convertHex = convertHex; exports.convertSurfaceColors = convertSurfaceColors; exports.convertSurfaceDepth = _chunkCWM3CUUXcjs.convertSurfaceDepth; exports.convertToSmartObject = _chunkUYXL6ZWQcjs.convertToSmartObject; exports.copySmartObject = _chunkUYXL6ZWQcjs.copySmartObject; exports.cornersFromMatrix = _chunkUYXL6ZWQcjs.cornersFromMatrix; exports.coverageTileCoord = _chunkEBDCRTZIcjs.coverageTileCoord; exports.coverageToByte = _chunkUYXL6ZWQcjs.coverageToByte; exports.coveringRect = coveringRect; exports.createAdjustmentLayer = _chunkUYXL6ZWQcjs.createAdjustmentLayer; exports.createBlenderScratch = _chunkEBDCRTZIcjs.createBlenderScratch; exports.createCanvasTextShaper = _chunkBRKVNXDZcjs.createCanvasTextShaper; exports.createImageCaptureSurface = createImageCaptureSurface; exports.createImageColorTools = createImageColorTools; exports.createImageEditTools = createImageEditTools; exports.createImageEditorDocument = createImageEditorDocument; exports.createImageEditorToolProvider = createImageEditorToolProvider; exports.createImageEffectTools = createImageEffectTools; exports.createImageEffectsToolProvider = createImageEffectsToolProvider; exports.createImageLayerTools = createImageLayerTools; exports.createImagePaintTools = createImagePaintTools; exports.createImagePlaybackLocator = createImagePlaybackLocator; exports.createImagePsdTools = createImagePsdTools; exports.createImageRetouchTools = createImageRetouchTools; exports.createImageSegmentationToolProvider = createImageSegmentationToolProvider; exports.createImageSelectionTools = createImageSelectionTools; exports.createImageShapeTools = createImageShapeTools; exports.createImageSmartObjectTools = createImageSmartObjectTools; exports.createImageSubjectSelectionTool = createImageSubjectSelectionTool; exports.createImageTransformTools = createImageTransformTools; exports.createImageTypeTools = createImageTypeTools; exports.createMetricTextShaper = _chunkBRKVNXDZcjs.createMetricTextShaper; exports.createOutlineTextShaper = _chunkBRKVNXDZcjs.createOutlineTextShaper; exports.createPigment = _chunkCWM3CUUXcjs.createPigment; exports.createPigmentTools = _chunkV7GWZIZKcjs.createPigmentTools; exports.createSelectionMask = _chunkUYXL6ZWQcjs.createSelectionMask; exports.createShapeLayer = _chunkUYXL6ZWQcjs.createShapeLayer; exports.createTypeLayer = _chunkUYXL6ZWQcjs.createTypeLayer; exports.createWetGpuEngine = _chunkV7GWZIZKcjs.createWetGpuEngine; exports.cssFont = _chunkBRKVNXDZcjs.cssFont; exports.cssFontFamily = _chunkBRKVNXDZcjs.cssFontFamily; exports.curveLut = _chunkHGTDMKNEcjs.curveLut; exports.curveLutFromLevels = _chunkUYXL6ZWQcjs.curveLutFromLevels; exports.curvePointToBox = curvePointToBox; exports.curveSvgPath = curveSvgPath; exports.dabCoverage = _chunkEBDCRTZIcjs.dabCoverage; exports.dabRect = _chunkEBDCRTZIcjs.dabRect; exports.decodeDeepSurface = _chunkUYXL6ZWQcjs.decodeDeepSurface; exports.decodeLayerChannel = _chunkUYXL6ZWQcjs.decodeLayerChannel; exports.decodeLayerMask = _chunkUYXL6ZWQcjs.decodeLayerMask; exports.decodeMergedImage = _chunkUYXL6ZWQcjs.decodeMergedImage; exports.decodePlanes = _chunkUYXL6ZWQcjs.decodePlanes; exports.decodePng = _chunkCWM3CUUXcjs.decodePng; exports.decodePngDataUrl = _chunkUYXL6ZWQcjs.decodePngDataUrl; exports.decodeSelectionRle = _chunkUYXL6ZWQcjs.decodeSelectionRle; exports.deepBytes = _chunkCWM3CUUXcjs.deepBytes; exports.deepTile = _chunkCWM3CUUXcjs.deepTile; exports.defaultActiveLayerId = _chunkUYXL6ZWQcjs.defaultActiveLayerId; exports.defaultAdjustmentParams = _chunkUYXL6ZWQcjs.defaultAdjustmentParams; exports.defaultEffectGradient = _chunkHGTDMKNEcjs.defaultEffectGradient; exports.defaultLayerEffect = _chunkHGTDMKNEcjs.defaultLayerEffect; exports.defaultShapeName = _chunkUYXL6ZWQcjs.defaultShapeName; exports.deflate = _chunkXFM3OCHUcjs.deflate; exports.deflateRaw = _chunkXFM3OCHUcjs.deflateRaw; exports.depthMaskAlpha = _chunkUYXL6ZWQcjs.depthMaskAlpha; exports.depthOf = _chunkCWM3CUUXcjs.depthOf; exports.depthRasterMask = _chunkUYXL6ZWQcjs.depthRasterMask; exports.describeChannel = describeChannel; exports.describeLayer = describeLayer; exports.describeLayerEffects = describeLayerEffects; exports.describeSelection = describeSelection; exports.describeTransform = _chunkUYXL6ZWQcjs.describeTransform; exports.deserializeChannels = deserializeChannels; exports.deserializeColorMode = deserializeColorMode; exports.deserializeColorProfile = deserializeColorProfile; exports.deserializeEffects = _chunkUYXL6ZWQcjs.deserializeEffects; exports.deserializeLayer = _chunkUYXL6ZWQcjs.deserializeLayer; exports.deserializeLayers = _chunkUYXL6ZWQcjs.deserializeLayers; exports.deserializePatterns = _chunkUYXL6ZWQcjs.deserializePatterns; exports.deserializeSelection = _chunkUYXL6ZWQcjs.deserializeSelection; exports.developFilter = _chunkUYXL6ZWQcjs.developFilter; exports.developFromAdjustments = _chunkUYXL6ZWQcjs.developFromAdjustments; exports.developTarget = _chunkUYXL6ZWQcjs.developTarget; exports.dexp = _chunkV7GWZIZKcjs.dexp; exports.dilateMask = _chunk7NW46N7Icjs.dilateMask; exports.displayTransform = displayTransform; exports.distanceTransform = _chunkUYXL6ZWQcjs.distanceTransform; exports.dlog = _chunkV7GWZIZKcjs.dlog; exports.documentContents = _chunkUYXL6ZWQcjs.documentContents; exports.documentProfile = documentProfile; exports.dodgeBurn = _chunk7NW46N7Icjs.dodgeBurn; exports.dodgeBurnCurve = _chunk7NW46N7Icjs.dodgeBurnCurve; exports.downloadMaskImage = downloadMaskImage; exports.downloadPsd = downloadPsd; exports.dpow = _chunkV7GWZIZKcjs.dpow; exports.dragWarpMeshPoint = _chunkBRKVNXDZcjs.dragWarpMeshPoint; exports.dropPlacement = dropPlacement; exports.dropZone = dropZone; exports.dsincos = _chunkV7GWZIZKcjs.dsincos; exports.duplicateLayer = _chunkUYXL6ZWQcjs.duplicateLayer; exports.edgeBits = _chunkV7GWZIZKcjs.edgeBits; exports.edgeWidth = edgeWidth; exports.effectColorHex = _chunkHGTDMKNEcjs.effectColorHex; exports.effectControlChange = effectControlChange; exports.effectLayerTiming = effectLayerTiming; exports.effectPixelsToSurface = effectPixelsToSurface; exports.effectReach = _chunkHGTDMKNEcjs.effectReach; exports.effectiveLayerMask = _chunkUYXL6ZWQcjs.effectiveLayerMask; exports.effectiveProof = effectiveProof; exports.effectsFingerprint = _chunkHGTDMKNEcjs.effectsFingerprint; exports.effectsMargin = _chunkHGTDMKNEcjs.effectsMargin; exports.effectsScale = _chunkHGTDMKNEcjs.effectsScale; exports.ellipsePoints = ellipsePoints; exports.ellipseSelection = ellipseSelection; exports.emptyHistogram = emptyHistogram; exports.emptySurface = _chunkCWM3CUUXcjs.emptySurface; exports.encodeDeepSurface = _chunkUYXL6ZWQcjs.encodeDeepSurface; exports.encodePng = _chunkCWM3CUUXcjs.encodePng; exports.encodeRle = _chunkUYXL6ZWQcjs.encodeRle; exports.encodeSelectionRle = _chunkUYXL6ZWQcjs.encodeSelectionRle; exports.encodeSurface = _chunkUYXL6ZWQcjs.encodeSurface; exports.evalWarpMesh = _chunkBRKVNXDZcjs.evalWarpMesh; exports.evaluateAdjustmentLayers = _chunkUYXL6ZWQcjs.evaluateAdjustmentLayers; exports.exchangeRates = _chunkEBDCRTZIcjs.exchangeRates; exports.expNeg = _chunkV7GWZIZKcjs.expNeg; exports.expandCoverage = _chunkUYXL6ZWQcjs.expandCoverage; exports.exportPsd = _chunkUYXL6ZWQcjs.exportPsd; exports.extractNormalizedLayerItems = extractNormalizedLayerItems; exports.featherCoverage = _chunkUYXL6ZWQcjs.featherCoverage; exports.fillRect = _chunkCWM3CUUXcjs.fillRect; exports.filmPixel = _chunkV7GWZIZKcjs.filmPixel; exports.filmReflectance = _chunkV7GWZIZKcjs.filmReflectance; exports.filterMaskCoverage = _chunkUYXL6ZWQcjs.filterMaskCoverage; exports.findAdjustmentControl = findAdjustmentControl; exports.findLayer = _chunkHGTDMKNEcjs.findLayer; exports.findLayerControl = findLayerControl; exports.findWebGpu = _chunkV7GWZIZKcjs.findWebGpu; exports.finishTile = _chunkCWM3CUUXcjs.finishTile; exports.fitParagraphRuns = _chunkBRKVNXDZcjs.fitParagraphRuns; exports.fitRuns = _chunkBRKVNXDZcjs.fitRuns; exports.flattenLayers = _chunkHGTDMKNEcjs.flattenLayers; exports.flattenPath = _chunkUYXL6ZWQcjs.flattenPath; exports.flipCorners = _chunkUYXL6ZWQcjs.flipCorners; exports.flowField = _chunkV7GWZIZKcjs.flowField; exports.followLayerMove = _chunkUYXL6ZWQcjs.followLayerMove; exports.fontOf = _chunkBRKVNXDZcjs.fontOf; exports.formatControlValue = formatControlValue; exports.fullSelection = _chunkUYXL6ZWQcjs.fullSelection; exports.gaussianBlur = _chunkHGTDMKNEcjs.gaussianBlur; exports.geometryHomography = _chunkUYXL6ZWQcjs.geometryHomography; exports.getAnnotationBounds = _chunkUYXL6ZWQcjs.getAnnotationBounds; exports.getControlPath = getControlPath; exports.getCropCursor = _chunkUYXL6ZWQcjs.getCropCursor; exports.getRotatedSize = _chunkUYXL6ZWQcjs.getRotatedSize; exports.getViewportMetrics = _chunkUYXL6ZWQcjs.getViewportMetrics; exports.getViewportProjection = _chunkUYXL6ZWQcjs.getViewportProjection; exports.globalImageCache = globalImageCache; exports.gradientDabColor = _chunkEBDCRTZIcjs.gradientDabColor; exports.grainCatch = _chunkEBDCRTZIcjs.grainCatch; exports.grainHeights = _chunkEBDCRTZIcjs.grainHeights; exports.greyMorphology = _chunkUYXL6ZWQcjs.greyMorphology; exports.groupLayers = _chunkUYXL6ZWQcjs.groupLayers; exports.growSelection = growSelection; exports.guidePlanes = guidePlanes; exports.guidedFilterColor = guidedFilterColor; exports.handleMaskViewKey = handleMaskViewKey; exports.handlePaintShortcut = handlePaintShortcut; exports.handleQuickMaskKey = handleQuickMaskKey; exports.handleSelectionShortcut = handleSelectionShortcut; exports.hasActiveEffects = _chunkHGTDMKNEcjs.hasActiveEffects; exports.hasLayersBelow = hasLayersBelow; exports.hasResampledLegacyMask = _chunkUYXL6ZWQcjs.hasResampledLegacyMask; exports.hasSurface = _chunkUYXL6ZWQcjs.hasSurface; exports.hasWarp = _chunkUYXL6ZWQcjs.hasWarp; exports.hash2 = _chunkEBDCRTZIcjs.hash2; exports.hashMaskContent = _chunkUYXL6ZWQcjs.hashMaskContent; exports.hashNoise = _chunkHGTDMKNEcjs.hashNoise; exports.healPixels = _chunk7NW46N7Icjs.healPixels; exports.hexToPaintRgb = _chunkEBDCRTZIcjs.hexToPaintRgb; exports.hexToRgb = _chunkUYXL6ZWQcjs.hexToRgb; exports.histogramPath = histogramPath; exports.hitTestAnnotation = _chunkUYXL6ZWQcjs.hitTestAnnotation; exports.hitTestCrop = _chunkUYXL6ZWQcjs.hitTestCrop; exports.hitTestCurvePoint = hitTestCurvePoint; exports.homographyFromAffine = _chunkQT26RHKKcjs.homographyFromAffine; exports.homographyFromPoints = _chunkQT26RHKKcjs.homographyFromPoints; exports.hslToRgb = _chunkUYXL6ZWQcjs.hslToRgb; exports.hueRange = hueRange; exports.hueRangeTables = _chunkUYXL6ZWQcjs.hueRangeTables; exports.hueRangeWeight = _chunkUYXL6ZWQcjs.hueRangeWeight; exports.hueSaturation = _chunkUYXL6ZWQcjs.hueSaturation; exports.identityCurve = _chunkUYXL6ZWQcjs.identityCurve; exports.identityLevels = _chunkUYXL6ZWQcjs.identityLevels; exports.identityTransform = _chunkUYXL6ZWQcjs.identityTransform; exports.identityWarpMesh = _chunkBRKVNXDZcjs.identityWarpMesh; exports.imageEditorStateMigrations = imageEditorStateMigrations; exports.imageLayerAppliedEffects = imageLayerAppliedEffects; exports.imagePanelTool = imagePanelTool; exports.imagePlaybackPanel = imagePlaybackPanel; exports.imageToCanvasPoint = _chunkUYXL6ZWQcjs.imageToCanvasPoint; exports.imageToolCanvasMode = imageToolCanvasMode; exports.imageToolForShortcut = imageToolForShortcut; exports.imageToolGroup = imageToolGroup; exports.imageToolLabel = imageToolLabel; exports.imageToolPanel = imageToolPanel; exports.importPsd = _chunkUYXL6ZWQcjs.importPsd; exports.inflate = _chunkXFM3OCHUcjs.inflate; exports.inflateRaw = _chunkXFM3OCHUcjs.inflateRaw; exports.insertCurvePoint = insertCurvePoint; exports.insertLayer = _chunkHGTDMKNEcjs.insertLayer; exports.instancesOf = _chunkUYXL6ZWQcjs.instancesOf; exports.invertHomography = _chunkQT26RHKKcjs.invertHomography; exports.invertMatrix3 = _chunkUYXL6ZWQcjs.invertMatrix3; exports.invertSelection = _chunkUYXL6ZWQcjs.invertSelection; exports.isActiveFilter = _chunkUYXL6ZWQcjs.isActiveFilter; exports.isActiveVectorMask = _chunkUYXL6ZWQcjs.isActiveVectorMask; exports.isAdjustmentKind = _chunkUYXL6ZWQcjs.isAdjustmentKind; exports.isBitDepth = _chunkCWM3CUUXcjs.isBitDepth; exports.isBlendMode = _chunkCWM3CUUXcjs.isBlendMode; exports.isBrushstrokeBrush = _chunkEBDCRTZIcjs.isBrushstrokeBrush; exports.isColorRangePreset = isColorRangePreset; exports.isContentsDecoded = _chunkUYXL6ZWQcjs.isContentsDecoded; exports.isDefaultDepthMask = _chunkUYXL6ZWQcjs.isDefaultDepthMask; exports.isGradientPaint = _chunkEBDCRTZIcjs.isGradientPaint; exports.isIdentityCloneTransform = _chunk7NW46N7Icjs.isIdentityCloneTransform; exports.isIdentityTransform = _chunkUYXL6ZWQcjs.isIdentityTransform; exports.isInterpolation = _chunkHGTDMKNEcjs.isInterpolation; exports.isLayerEffectKind = _chunkHGTDMKNEcjs.isLayerEffectKind; exports.isLayerLocked = _chunkHGTDMKNEcjs.isLayerLocked; exports.isLegacyShape = _chunkUYXL6ZWQcjs.isLegacyShape; exports.isPaintTool = isPaintTool; exports.isPaintableLayer = _chunkUYXL6ZWQcjs.isPaintableLayer; exports.isPainterlyBlendMode = _chunkCWM3CUUXcjs.isPainterlyBlendMode; exports.isPng = _chunkCWM3CUUXcjs.isPng; exports.isQuarterTurn = isQuarterTurn; exports.isQuarterTurnSwapped = _chunkUYXL6ZWQcjs.isQuarterTurnSwapped; exports.isRenderedLayer = _chunkUYXL6ZWQcjs.isRenderedLayer; exports.isRetouchPaintTool = isRetouchPaintTool; exports.isRetouchTool = isRetouchTool; exports.isSelectionEmpty = _chunkUYXL6ZWQcjs.isSelectionEmpty; exports.isSelectionMode = _chunkUYXL6ZWQcjs.isSelectionMode; exports.isSeparableBlendMode = _chunkCWM3CUUXcjs.isSeparableBlendMode; exports.isSmartSurfaceIncomplete = _chunkUYXL6ZWQcjs.isSmartSurfaceIncomplete; exports.isSpatialFilter = _chunkUYXL6ZWQcjs.isSpatialFilter; exports.isSrgb = isSrgb; exports.isTransformAnchor = _chunkUYXL6ZWQcjs.isTransformAnchor; exports.isValidWarp = _chunkUYXL6ZWQcjs.isValidWarp; exports.keepDeepSamples = _chunkCWM3CUUXcjs.keepDeepSamples; exports.kelvinToTemperature = _chunkUYXL6ZWQcjs.kelvinToTemperature; exports.keysWeight = _chunkHGTDMKNEcjs.keysWeight; exports.latticeViscosity = _chunkV7GWZIZKcjs.latticeViscosity; exports.layerBadge = layerBadge; exports.layerEffectControls = layerEffectControls; exports.layerEffectFields = _chunkHGTDMKNEcjs.layerEffectFields; exports.layerEffectLabel = _chunkHGTDMKNEcjs.layerEffectLabel; exports.layerEffectsBadge = layerEffectsBadge; exports.layerEffectsOf = _chunkUYXL6ZWQcjs.layerEffectsOf; exports.layerEffectsPanel = layerEffectsPanel; exports.layerHasThumbnail = layerHasThumbnail; exports.layerLabel = layerLabel; exports.layerMaskCoverage = _chunkUYXL6ZWQcjs.layerMaskCoverage; exports.layerMaskFromSelection = _chunkUYXL6ZWQcjs.layerMaskFromSelection; exports.layerMaskKey = _chunkUYXL6ZWQcjs.layerMaskKey; exports.layerMaskSelection = _chunkUYXL6ZWQcjs.layerMaskSelection; exports.layerMenu = layerMenu; exports.layerName = _chunkUYXL6ZWQcjs.layerName; exports.layerPanelRows = layerPanelRows; exports.layerPanels = layerPanels; exports.layerThumbnailClick = layerThumbnailClick; exports.layerTree = _chunkUYXL6ZWQcjs.layerTree; exports.layerTypeLabel = _chunkUYXL6ZWQcjs.layerTypeLabel; exports.layerWarning = layerWarning; exports.layersFromLegacy = _chunkUYXL6ZWQcjs.layersFromLegacy; exports.layoutText = _chunkBRKVNXDZcjs.layoutText; exports.legacyAdjustmentLayer = _chunkUYXL6ZWQcjs.legacyAdjustmentLayer; exports.legacyMaskOf = _chunkUYXL6ZWQcjs.legacyMaskOf; exports.legacyView = _chunkUYXL6ZWQcjs.legacyView; exports.lerpPigment = _chunkCWM3CUUXcjs.lerpPigment; exports.lerpPigmentInto = _chunkCWM3CUUXcjs.lerpPigmentInto; exports.levelsValue = _chunkUYXL6ZWQcjs.levelsValue; exports.linearSrgbToXy = _chunkUYXL6ZWQcjs.linearSrgbToXy; exports.linearToSrgb = _chunkUYXL6ZWQcjs.linearToSrgb; exports.linearToSrgb8 = _chunkV7GWZIZKcjs.linearToSrgb8; exports.liveComponent = _chunkUYXL6ZWQcjs.liveComponent; exports.liveShapeForDrag = liveShapeForDrag; exports.liveShapeSubpaths = _chunkUYXL6ZWQcjs.liveShapeSubpaths; exports.liveWire = liveWire; exports.loadImageEditorDocument = loadImageEditorDocument; exports.loadMixer = _chunkEBDCRTZIcjs.loadMixer; exports.loadOpenTypeFont = _chunk3T5VCDIVcjs.loadOpenTypeFont; exports.loadWetKernel = _chunkV7GWZIZKcjs.loadWetKernel; exports.luma = _chunk7NW46N7Icjs.luma; exports.magicWand = magicWand; exports.magneticAnchorSpacing = magneticAnchorSpacing; exports.mapCropHandle = _chunkUYXL6ZWQcjs.mapCropHandle; exports.mapLayer = _chunkHGTDMKNEcjs.mapLayer; exports.mapSubpaths = _chunkUYXL6ZWQcjs.mapSubpaths; exports.maskBounds = _chunk7NW46N7Icjs.maskBounds; exports.maskFileName = maskFileName; exports.maskNameFromFile = maskNameFromFile; exports.maskSummary = maskSummary; exports.maskThumbnailClick = maskThumbnailClick; exports.matrixFromCorners = _chunkUYXL6ZWQcjs.matrixFromCorners; exports.matrixFromParams = _chunkUYXL6ZWQcjs.matrixFromParams; exports.measureCanvasViewport = measureCanvasViewport; exports.membraneFill = _chunk7NW46N7Icjs.membraneFill; exports.mergeLayerEffect = _chunkHGTDMKNEcjs.mergeLayerEffect; exports.mergeShapeComponents = _chunkUYXL6ZWQcjs.mergeShapeComponents; exports.migrateSerializedImageEditorState = migrateSerializedImageEditorState; exports.migrateToLayeredState = migrateToLayeredState; exports.mix32 = _chunkEBDCRTZIcjs.mix32; exports.mixPigment8 = _chunkCWM3CUUXcjs.mixPigment8; exports.mixPigmentRgb = _chunkCWM3CUUXcjs.mixPigmentRgb; exports.mixPigments = _chunkCWM3CUUXcjs.mixPigments; exports.mixerLoadResult = mixerLoadResult; exports.mixerRates = _chunkEBDCRTZIcjs.mixerRates; exports.modifySelection = _chunkUYXL6ZWQcjs.modifySelection; exports.moveCurvePoint = moveCurvePoint; exports.moveLayer = _chunkUYXL6ZWQcjs.moveLayer; exports.moveSmartFilter = _chunkUYXL6ZWQcjs.moveSmartFilter; exports.mulMatrix3 = _chunkUYXL6ZWQcjs.mulMatrix3; exports.needsLegacyBase = needsLegacyBase; exports.neutralHueRange = _chunkUYXL6ZWQcjs.neutralHueRange; exports.newContentsId = _chunkUYXL6ZWQcjs.newContentsId; exports.newEffectId = _chunkHGTDMKNEcjs.newEffectId; exports.newLayerId = _chunkUYXL6ZWQcjs.newLayerId; exports.newLayerOptions = newLayerOptions; exports.normalizeAdjustmentLayer = _chunkUYXL6ZWQcjs.normalizeAdjustmentLayer; exports.normalizeAdjustmentLayers = _chunkUYXL6ZWQcjs.normalizeAdjustmentLayers; exports.normalizeAngle = _chunkUYXL6ZWQcjs.normalizeAngle; exports.normalizeBlendMode = _chunkCWM3CUUXcjs.normalizeBlendMode; exports.normalizeBlender = _chunkEBDCRTZIcjs.normalizeBlender; exports.normalizeBrush = _chunkEBDCRTZIcjs.normalizeBrush; exports.normalizeFilter = _chunkUYXL6ZWQcjs.normalizeFilter; exports.normalizeFlow = _chunkV7GWZIZKcjs.normalizeFlow; exports.normalizeHexColor = _chunkEBDCRTZIcjs.normalizeHexColor; exports.normalizeLayerEffects = _chunkHGTDMKNEcjs.normalizeLayerEffects; exports.normalizeLayerMask = _chunkUYXL6ZWQcjs.normalizeLayerMask; exports.normalizeLiveShape = _chunkUYXL6ZWQcjs.normalizeLiveShape; exports.normalizeMixer = _chunkEBDCRTZIcjs.normalizeMixer; exports.normalizePlacement = _chunkUYXL6ZWQcjs.normalizePlacement; exports.normalizeProcessVersion = _chunkUYXL6ZWQcjs.normalizeProcessVersion; exports.normalizeRect = normalizeRect; exports.normalizeRefineEdgeParams = normalizeRefineEdgeParams; exports.normalizeRetouch = _chunk7NW46N7Icjs.normalizeRetouch; exports.normalizeShapePaint = _chunkUYXL6ZWQcjs.normalizeShapePaint; exports.normalizeShapeStroke = _chunkUYXL6ZWQcjs.normalizeShapeStroke; exports.normalizeSmartFilter = _chunkUYXL6ZWQcjs.normalizeSmartFilter; exports.normalizeSmudge = _chunkEBDCRTZIcjs.normalizeSmudge; exports.normalizeStoredAdjustments = normalizeStoredAdjustments; exports.normalizeSubpaths = _chunkUYXL6ZWQcjs.normalizeSubpaths; exports.normalizeText = _chunkUYXL6ZWQcjs.normalizeText; exports.normalizeTilt = _chunkV7GWZIZKcjs.normalizeTilt; exports.normalizeWetParams = _chunkV7GWZIZKcjs.normalizeWetParams; exports.offsetLayer = _chunkUYXL6ZWQcjs.offsetLayer; exports.offsetShape = _chunkUYXL6ZWQcjs.offsetShape; exports.offsetSmartObject = _chunkUYXL6ZWQcjs.offsetSmartObject; exports.offsetVectorMask = _chunkUYXL6ZWQcjs.offsetVectorMask; exports.openMaskFile = openMaskFile; exports.openPsdFile = openPsdFile; exports.packRgba = _chunkCWM3CUUXcjs.packRgba; exports.packWetParams = _chunkV7GWZIZKcjs.packWetParams; exports.paintGradientMappingFor = _chunkEBDCRTZIcjs.paintGradientMappingFor; exports.paintPathStroke = _chunkEBDCRTZIcjs.paintPathStroke; exports.paintSourceColor = _chunkEBDCRTZIcjs.paintSourceColor; exports.paintSourceCss = _chunkEBDCRTZIcjs.paintSourceCss; exports.paragraphRanges = _chunkBRKVNXDZcjs.paragraphRanges; exports.parseAdjustmentBlock = _chunkUYXL6ZWQcjs.parseAdjustmentBlock; exports.parseBlend = _chunkUYXL6ZWQcjs.parseBlend; exports.parseColor = parseColor; exports.parseCssColor = _chunkA2IS7EHEcjs.parseCssColor; exports.parseDataUrl = _chunkCWM3CUUXcjs.parseDataUrl; exports.parseEffectColor = _chunkHGTDMKNEcjs.parseEffectColor; exports.parseLfx2 = _chunkUYXL6ZWQcjs.parseLfx2; exports.parseLrfx = _chunkUYXL6ZWQcjs.parseLrfx; exports.parseOpenTypeFont = _chunk3T5VCDIVcjs.parseOpenTypeFont; exports.parsePaintSource = _chunkEBDCRTZIcjs.parsePaintSource; exports.parsePatternBlock = _chunkUYXL6ZWQcjs.parsePatternBlock; exports.parseSelectionMode = _chunkUYXL6ZWQcjs.parseSelectionMode; exports.parseVersionedDescriptor = _chunkUYXL6ZWQcjs.parseVersionedDescriptor; exports.patchParagraphStyle = _chunkUYXL6ZWQcjs.patchParagraphStyle; exports.patchTextStyle = _chunkUYXL6ZWQcjs.patchTextStyle; exports.pathStrokeCoverage = _chunkEBDCRTZIcjs.pathStrokeCoverage; exports.pathStrokeDabs = _chunkEBDCRTZIcjs.pathStrokeDabs; exports.pathToSelection = pathToSelection; exports.perDabStrength = _chunk7NW46N7Icjs.perDabStrength; exports.photoFilterMatrix = _chunkUYXL6ZWQcjs.photoFilterMatrix; exports.pigment8 = _chunkCWM3CUUXcjs.pigment8; exports.pigmentColor = _chunkV7GWZIZKcjs.pigmentColor; exports.pigmentOf = _chunkV7GWZIZKcjs.pigmentOf; exports.pixelLayerBounds = _chunkUYXL6ZWQcjs.pixelLayerBounds; exports.pixelLayers = _chunkUYXL6ZWQcjs.pixelLayers; exports.pixelPigment = _chunkV7GWZIZKcjs.pixelPigment; exports.placeContents = _chunkUYXL6ZWQcjs.placeContents; exports.placeLayer = _chunkUYXL6ZWQcjs.placeLayer; exports.placementAt = _chunkUYXL6ZWQcjs.placementAt; exports.placementBounds = _chunkUYXL6ZWQcjs.placementBounds; exports.placementGeometry = _chunkUYXL6ZWQcjs.placementGeometry; exports.planImageToolPlayback = planImageToolPlayback; exports.planOutlineTrace = planOutlineTrace; exports.pngDataUrl = _chunkCWM3CUUXcjs.pngDataUrl; exports.pointerPressure = _chunkV7GWZIZKcjs.pointerPressure; exports.pointerStrokeSample = _chunkV7GWZIZKcjs.pointerStrokeSample; exports.pointerStrokeSamples = _chunkV7GWZIZKcjs.pointerStrokeSamples; exports.polygonCoverage = polygonCoverage; exports.polygonCoverageBox = polygonCoverageBox; exports.polygonSelection = polygonSelection; exports.posterizeValue = _chunkUYXL6ZWQcjs.posterizeValue; exports.presetWarp = _chunkUYXL6ZWQcjs.presetWarp; exports.previewStep = previewStep; exports.profileBytes = profileBytes; exports.projectImagePoint = _chunkUYXL6ZWQcjs.projectImagePoint; exports.projectImageRect = _chunkUYXL6ZWQcjs.projectImageRect; exports.projectMaskCoverage = _chunkUYXL6ZWQcjs.projectMaskCoverage; exports.projectQuarterTurn = projectQuarterTurn; exports.proxyOf = _chunkCWM3CUUXcjs.proxyOf; exports.psdBytesFromBase64 = psdBytesFromBase64; exports.psdFileName = psdFileName; exports.psdPatternToEffectPattern = _chunkUYXL6ZWQcjs.psdPatternToEffectPattern; exports.psdToLayers = _chunkUYXL6ZWQcjs.psdToLayers; exports.pullWarpMesh = _chunkBRKVNXDZcjs.pullWarpMesh; exports.put255 = _chunkEBDCRTZIcjs.put255; exports.quadFrameOverlay = quadFrameOverlay; exports.quickMaskPixels = quickMaskPixels; exports.quickSelectStroke = quickSelectStroke; exports.rand01 = _chunkEBDCRTZIcjs.rand01; exports.randSigned = _chunkEBDCRTZIcjs.randSigned; exports.rangeLightness = _chunkUYXL6ZWQcjs.rangeLightness; exports.rasterContents = _chunkUYXL6ZWQcjs.rasterContents; exports.rasterMaskFromLegacy = _chunkUYXL6ZWQcjs.rasterMaskFromLegacy; exports.rasterizeCoverage = _chunkUYXL6ZWQcjs.rasterizeCoverage; exports.rasterizeDab = _chunkEBDCRTZIcjs.rasterizeDab; exports.rasterizeSmartObject = _chunkUYXL6ZWQcjs.rasterizeSmartObject; exports.readAdjustmentControls = readAdjustmentControls; exports.readDeepRegion = _chunkCWM3CUUXcjs.readDeepRegion; exports.readPaintSource = _chunkEBDCRTZIcjs.readPaintSource; exports.readPixel = _chunkCWM3CUUXcjs.readPixel; exports.readPsd = _chunkUYXL6ZWQcjs.readPsd; exports.readRegion = _chunkCWM3CUUXcjs.readRegion; exports.readSourceRegion = _chunk7NW46N7Icjs.readSourceRegion; exports.rectSelection = rectSelection; exports.rectToQuad = _chunkQT26RHKKcjs.rectToQuad; exports.reduceSurface = _chunkHGTDMKNEcjs.reduceSurface; exports.referencePoint = _chunkUYXL6ZWQcjs.referencePoint; exports.refineCoverage = refineCoverage; exports.refineEdgeHalo = refineEdgeHalo; exports.refineSelection = refineSelection; exports.reflectanceToRgb = _chunkCWM3CUUXcjs.reflectanceToRgb; exports.removeAlpha = _chunkUYXL6ZWQcjs.removeAlpha; exports.removeCurvePoint = removeCurvePoint; exports.removeLayer = _chunkUYXL6ZWQcjs.removeLayer; exports.removeLayerEffect = _chunkUYXL6ZWQcjs.removeLayerEffect; exports.removeLayerFilter = _chunkUYXL6ZWQcjs.removeLayerFilter; exports.removePaintGradientStop = _chunkEBDCRTZIcjs.removePaintGradientStop; exports.removeSmartFilter = _chunkUYXL6ZWQcjs.removeSmartFilter; exports.renderBrushstroke = _chunkEBDCRTZIcjs.renderBrushstroke; exports.renderLayerEffects = _chunkHGTDMKNEcjs.renderLayerEffects; exports.renderLayeredBase = renderLayeredBase; exports.renderShape = _chunkUYXL6ZWQcjs.renderShape; exports.renderShapeRect = _chunkUYXL6ZWQcjs.renderShapeRect; exports.renderSmartObject = _chunkUYXL6ZWQcjs.renderSmartObject; exports.renderText = _chunkUYXL6ZWQcjs.renderText; exports.replaceContents = _chunkUYXL6ZWQcjs.replaceContents; exports.replaceTextRange = _chunkUYXL6ZWQcjs.replaceTextRange; exports.requireLayer = _chunkUYXL6ZWQcjs.requireLayer; exports.requireOperation = _chunkUYXL6ZWQcjs.requireOperation; exports.requireShapeLayer = _chunkUYXL6ZWQcjs.requireShapeLayer; exports.requireSmartObject = _chunkUYXL6ZWQcjs.requireSmartObject; exports.requireTypeLayer = _chunkUYXL6ZWQcjs.requireTypeLayer; exports.requireUnlocked = _chunkUYXL6ZWQcjs.requireUnlocked; exports.rerender = _chunkUYXL6ZWQcjs.rerender; exports.rerenderShape = _chunkUYXL6ZWQcjs.rerenderShape; exports.rerenderText = _chunkUYXL6ZWQcjs.rerenderText; exports.resizePixels = resizePixels; exports.resizeSelection = _chunkUYXL6ZWQcjs.resizeSelection; exports.resizeWarpMesh = _chunkBRKVNXDZcjs.resizeWarpMesh; exports.resolveExternalAssets = _chunkUYXL6ZWQcjs.resolveExternalAssets; exports.resolveMosaicRegionBounds = resolveMosaicRegionBounds; exports.resolvePaintGradient = _chunkEBDCRTZIcjs.resolvePaintGradient; exports.resolveProfile = resolveProfile; exports.resolveVectorMasks = _chunkUYXL6ZWQcjs.resolveVectorMasks; exports.restyleRange = _chunkBRKVNXDZcjs.restyleRange; exports.retouchFilter = _chunk7NW46N7Icjs.retouchFilter; exports.reversePaintGradient = _chunkEBDCRTZIcjs.reversePaintGradient; exports.rgbToGray = _chunkUYXL6ZWQcjs.rgbToGray; exports.rgbToHsl = _chunkUYXL6ZWQcjs.rgbToHsl; exports.rgbToReflectance = _chunkCWM3CUUXcjs.rgbToReflectance; exports.rgbUnitToHex = rgbUnitToHex; exports.rgbaViewOfGrey = _chunk7NW46N7Icjs.rgbaViewOfGrey; exports.runLayerFilters = _chunkUYXL6ZWQcjs.runLayerFilters; exports.runLayerFiltersFloat = _chunkUYXL6ZWQcjs.runLayerFiltersFloat; exports.runLayerMenuAction = runLayerMenuAction; exports.sameCanvasViewport = sameCanvasViewport; exports.sampleLut = _chunkUYXL6ZWQcjs.sampleLut; exports.sampleToneLut = _chunkUYXL6ZWQcjs.sampleToneLut; exports.saturationOf = _chunk7NW46N7Icjs.saturationOf; exports.scaleLayerEffect = _chunkHGTDMKNEcjs.scaleLayerEffect; exports.scalePaintGradient = _chunkEBDCRTZIcjs.scalePaintGradient; exports.seamlessClone = _chunk7NW46N7Icjs.seamlessClone; exports.seedFromString = _chunkEBDCRTZIcjs.seedFromString; exports.segmentToSelection = segmentToSelection; exports.segmentationOutlines = segmentationOutlines; exports.segmentsToSelection = segmentsToSelection; exports.selectObjectIn = selectObjectIn; exports.selectSimilar = selectSimilar; exports.selectionArea = _chunkUYXL6ZWQcjs.selectionArea; exports.selectionFromCoverage = _chunkUYXL6ZWQcjs.selectionFromCoverage; exports.selectionFromPixels = _chunkUYXL6ZWQcjs.selectionFromPixels; exports.selectionFromRegion = _chunkUYXL6ZWQcjs.selectionFromRegion; exports.selectionFromTiles = _chunkUYXL6ZWQcjs.selectionFromTiles; exports.selectionModeFromModifiers = selectionModeFromModifiers; exports.selectionOutline = selectionOutline; exports.selectionRing = selectionRing; exports.selectionToCoverage = _chunkUYXL6ZWQcjs.selectionToCoverage; exports.selectionToPixels = _chunkUYXL6ZWQcjs.selectionToPixels; exports.selectionToSubpaths = selectionToSubpaths; exports.selectionValueAt = _chunkUYXL6ZWQcjs.selectionValueAt; exports.serializeChannels = serializeChannels; exports.serializeColorMode = serializeColorMode; exports.serializeColorProfile = serializeColorProfile; exports.serializeContents = _chunkUYXL6ZWQcjs.serializeContents; exports.serializeEffects = _chunkUYXL6ZWQcjs.serializeEffects; exports.serializeLayer = _chunkUYXL6ZWQcjs.serializeLayer; exports.serializeLayers = _chunkUYXL6ZWQcjs.serializeLayers; exports.serializeLayersExternal = _chunkUYXL6ZWQcjs.serializeLayersExternal; exports.serializePatterns = _chunkUYXL6ZWQcjs.serializePatterns; exports.serializeSelection = _chunkUYXL6ZWQcjs.serializeSelection; exports.setCloneTransformValue = setCloneTransformValue; exports.setControlPath = setControlPath; exports.setLayerEffects = _chunkUYXL6ZWQcjs.setLayerEffects; exports.setLayerEffectsEnabled = _chunkUYXL6ZWQcjs.setLayerEffectsEnabled; exports.setLayerMask = _chunkUYXL6ZWQcjs.setLayerMask; exports.setLayerProperties = _chunkUYXL6ZWQcjs.setLayerProperties; exports.setLum = _chunkCWM3CUUXcjs.setLum; exports.setPigmentColor = _chunkCWM3CUUXcjs.setPigmentColor; exports.setRetouchChoice = setRetouchChoice; exports.setSmartFilterMask = _chunkUYXL6ZWQcjs.setSmartFilterMask; exports.setSmartFiltersEnabled = _chunkUYXL6ZWQcjs.setSmartFiltersEnabled; exports.setSmartPlacement = _chunkUYXL6ZWQcjs.setSmartPlacement; exports.shadeTile = _chunkV7GWZIZKcjs.shadeTile; exports.shapeAsPixelLayer = _chunkUYXL6ZWQcjs.shapeAsPixelLayer; exports.shapeFromAnnotation = _chunkUYXL6ZWQcjs.shapeFromAnnotation; exports.shapeGeometryBounds = _chunkUYXL6ZWQcjs.shapeGeometryBounds; exports.shapeLayers = _chunkUYXL6ZWQcjs.shapeLayers; exports.shapeOutline = _chunkUYXL6ZWQcjs.shapeOutline; exports.shapeRenderClip = _chunkUYXL6ZWQcjs.shapeRenderClip; exports.shiftCoverage = _chunkUYXL6ZWQcjs.shiftCoverage; exports.simplifyPixelPath = simplifyPixelPath; exports.skinToneRange = skinToneRange; exports.smartFilterRows = smartFilterRows; exports.smartObjectLayers = _chunkUYXL6ZWQcjs.smartObjectLayers; exports.smoothCoverage = _chunkUYXL6ZWQcjs.smoothCoverage; exports.smoothPoints = _chunkEBDCRTZIcjs.smoothPoints; exports.smoothnessWeights = smoothnessWeights; exports.smudgeEffect = _chunk7NW46N7Icjs.smudgeEffect; exports.snapPolygonToEdges = snapPolygonToEdges; exports.snapTo45 = snapTo45; exports.snapToEdge = snapToEdge; exports.solidPaint = _chunkEBDCRTZIcjs.solidPaint; exports.solidSurface = _chunkCWM3CUUXcjs.solidSurface; exports.solveMembrane = _chunk7NW46N7Icjs.solveMembrane; exports.spliceRuns = _chunkBRKVNXDZcjs.spliceRuns; exports.splitOverlayAnnotations = splitOverlayAnnotations; exports.sponge = _chunk7NW46N7Icjs.sponge; exports.spongeEffect = _chunk7NW46N7Icjs.spongeEffect; exports.spotHealPixels = _chunk7NW46N7Icjs.spotHealPixels; exports.spotHealWindow = _chunk7NW46N7Icjs.spotHealWindow; exports.srgb8ToLab = srgb8ToLab; exports.srgbByteToLinear = _chunkV7GWZIZKcjs.srgbByteToLinear; exports.srgbDecode = _chunkCWM3CUUXcjs.srgbDecode; exports.srgbEncode = _chunkCWM3CUUXcjs.srgbEncode; exports.srgbToLinear = _chunkUYXL6ZWQcjs.srgbToLinear; exports.standardBlendMode = _chunkCWM3CUUXcjs.standardBlendMode; exports.startMarchingAnts = startMarchingAnts; exports.stepSlotTs = _chunkV7GWZIZKcjs.stepSlotTs; exports.strokeGrainCatch = _chunkEBDCRTZIcjs.strokeGrainCatch; exports.styleAt = _chunkBRKVNXDZcjs.styleAt; exports.subpathsToSvgPath = subpathsToSvgPath; exports.sumHistograms = sumHistograms; exports.surfaceBytes = _chunkCWM3CUUXcjs.surfaceBytes; exports.surfaceDepth = _chunkCWM3CUUXcjs.surfaceDepth; exports.surfaceFromDeepPixels = _chunkCWM3CUUXcjs.surfaceFromDeepPixels; exports.surfaceFromPixels = _chunkCWM3CUUXcjs.surfaceFromPixels; exports.surfacesEqual = _chunkCWM3CUUXcjs.surfacesEqual; exports.tempTintToXy = _chunkUYXL6ZWQcjs.tempTintToXy; exports.temperatureToKelvin = _chunkUYXL6ZWQcjs.temperatureToKelvin; exports.textIndexAt = _chunkBRKVNXDZcjs.textIndexAt; exports.textMatrix = _chunkUYXL6ZWQcjs.textMatrix; exports.textOrientation = _chunkUYXL6ZWQcjs.textOrientation; exports.textOutlines = _chunkUYXL6ZWQcjs.textOutlines; exports.textRange = _chunkUYXL6ZWQcjs.textRange; exports.tileCoord = _chunkCWM3CUUXcjs.tileCoord; exports.tileKey = _chunkCWM3CUUXcjs.tileKey; exports.tileRect = _chunkCWM3CUUXcjs.tileRect; exports.tileSamples = _chunkCWM3CUUXcjs.tileSamples; exports.tileSamples16 = _chunkCWM3CUUXcjs.tileSamples16; exports.tileSamples32 = _chunkCWM3CUUXcjs.tileSamples32; exports.tilesInRect = _chunkCWM3CUUXcjs.tilesInRect; exports.tipFalloff = _chunkEBDCRTZIcjs.tipFalloff; exports.tipReach = _chunkEBDCRTZIcjs.tipReach; exports.tipShape = _chunkEBDCRTZIcjs.tipShape; exports.to16From32 = _chunkCWM3CUUXcjs.to16From32; exports.to16From8 = _chunkCWM3CUUXcjs.to16From8; exports.to32From16 = _chunkCWM3CUUXcjs.to32From16; exports.to32From8 = _chunkCWM3CUUXcjs.to32From8; exports.to8From16 = _chunkCWM3CUUXcjs.to8From16; exports.to8From32 = _chunkCWM3CUUXcjs.to8From32; exports.toHex = toHex; exports.toTextSpace = _chunkUYXL6ZWQcjs.toTextSpace; exports.toneCurve = _chunkUYXL6ZWQcjs.toneCurve; exports.toneLuts = _chunkUYXL6ZWQcjs.toneLuts; exports.toneOf = _chunk7NW46N7Icjs.toneOf; exports.toneRange = toneRange; exports.transformHomography = _chunkUYXL6ZWQcjs.transformHomography; exports.transformMap = _chunkUYXL6ZWQcjs.transformMap; exports.transformShapeComponents = _chunkUYXL6ZWQcjs.transformShapeComponents; exports.transformSurface = _chunkHGTDMKNEcjs.transformSurface; exports.transformTypeLayer = _chunkUYXL6ZWQcjs.transformTypeLayer; exports.transformVectorMask = _chunkUYXL6ZWQcjs.transformVectorMask; exports.transformedBounds = _chunkHGTDMKNEcjs.transformedBounds; exports.transformedBox = _chunkUYXL6ZWQcjs.transformedBox; exports.transformedPoint = _chunkUYXL6ZWQcjs.transformedPoint; exports.translateLayer = _chunkUYXL6ZWQcjs.translateLayer; exports.translateSurface = _chunkCWM3CUUXcjs.translateSurface; exports.typeAsPixelLayer = _chunkUYXL6ZWQcjs.typeAsPixelLayer; exports.typeFrame = _chunkUYXL6ZWQcjs.typeFrame; exports.typeFromAnnotation = _chunkUYXL6ZWQcjs.typeFromAnnotation; exports.typeLayerAt = typeLayerAt; exports.typeLayerName = _chunkUYXL6ZWQcjs.typeLayerName; exports.ungroupLayer = _chunkUYXL6ZWQcjs.ungroupLayer; exports.uniformTile = _chunkCWM3CUUXcjs.uniformTile; exports.unionRect = _chunkUYXL6ZWQcjs.unionRect; exports.unprojectCanvasPoint = _chunkUYXL6ZWQcjs.unprojectCanvasPoint; exports.updateLayerEffect = _chunkUYXL6ZWQcjs.updateLayerEffect; exports.updateLayerFilter = _chunkUYXL6ZWQcjs.updateLayerFilter; exports.updateLayerMaskProps = _chunkUYXL6ZWQcjs.updateLayerMaskProps; exports.updatePaintGradientStop = _chunkEBDCRTZIcjs.updatePaintGradientStop; exports.updateShapeLayer = _chunkUYXL6ZWQcjs.updateShapeLayer; exports.updateSmartFilter = _chunkUYXL6ZWQcjs.updateSmartFilter; exports.updateTypeLayer = _chunkUYXL6ZWQcjs.updateTypeLayer; exports.upscaleRegion = upscaleRegion; exports.userErrorMessage = _chunkUYXL6ZWQcjs.userErrorMessage; exports.uvToXy = _chunkUYXL6ZWQcjs.uvToXy; exports.validateEffectGradient = _chunkHGTDMKNEcjs.validateEffectGradient; exports.validateLayerEffect = _chunkHGTDMKNEcjs.validateLayerEffect; exports.validateLayerEffects = _chunkHGTDMKNEcjs.validateLayerEffects; exports.vectorMaskBounds = _chunkUYXL6ZWQcjs.vectorMaskBounds; exports.vectorMaskCoverage = _chunkUYXL6ZWQcjs.vectorMaskCoverage; exports.vectorMaskThumbnail = _chunkUYXL6ZWQcjs.vectorMaskThumbnail; exports.vectorMaskThumbnailClick = vectorMaskThumbnailClick; exports.versionedDescriptorBytes = _chunkUYXL6ZWQcjs.versionedDescriptorBytes; exports.vibranceLinear = _chunkUYXL6ZWQcjs.vibranceLinear; exports.vibrancePixel = _chunkUYXL6ZWQcjs.vibrancePixel; exports.walkDabs = _chunkEBDCRTZIcjs.walkDabs; exports.warpMeshEditPoints = _chunkBRKVNXDZcjs.warpMeshEditPoints; exports.warpMeshGridCurves = _chunkBRKVNXDZcjs.warpMeshGridCurves; exports.warpMeshParamAt = _chunkBRKVNXDZcjs.warpMeshParamAt; exports.warpPresetMesh = _chunkBRKVNXDZcjs.warpPresetMesh; exports.warpSurface = _chunkHGTDMKNEcjs.warpSurface; exports.watchCanvasViewport = watchCanvasViewport; exports.wbMatrix = _chunkUYXL6ZWQcjs.wbMatrix; exports.wetGpuSupport = _chunkV7GWZIZKcjs.wetGpuSupport; exports.wetSimdSupported = _chunkV7GWZIZKcjs.wetSimdSupported; exports.wetSupport = _chunkV7GWZIZKcjs.wetSupport; exports.whiteBalanceFromSample = _chunkUYXL6ZWQcjs.whiteBalanceFromSample; exports.whiteBalanceMatrix = _chunkUYXL6ZWQcjs.whiteBalanceMatrix; exports.withBackgroundOpacity = withBackgroundOpacity; exports.withFilterMaskSurface = _chunkUYXL6ZWQcjs.withFilterMaskSurface; exports.withImagePlayback = withImagePlayback; exports.withNewIds = _chunkUYXL6ZWQcjs.withNewIds; exports.workImage = workImage; exports.writeAdjustmentBlock = _chunkUYXL6ZWQcjs.writeAdjustmentBlock; exports.writeDeepRegion = _chunkCWM3CUUXcjs.writeDeepRegion; exports.writeLfx2 = _chunkUYXL6ZWQcjs.writeLfx2; exports.writePatternBlock = _chunkUYXL6ZWQcjs.writePatternBlock; exports.writePsd = _chunkUYXL6ZWQcjs.writePsd; exports.writeRegion = _chunkCWM3CUUXcjs.writeRegion; exports.xyToTempTint = _chunkUYXL6ZWQcjs.xyToTempTint; exports.xyToUv = _chunkUYXL6ZWQcjs.xyToUv;