@pixerate/editor 0.195.0 → 0.197.0

package/dist/image-editor/index.cjs

@@ -2803,6 +2803,589 @@ function magneticAnchorSpacing(frequency = 57) {
   return 8 + (100 - f);
 }
 
+// src/image-editor/selection/segment/maxflow.ts
+var TERMINAL = -2;
+var NONE = -1;
+var FREE = 0;
+var SOURCE = 1;
+var SINK = 2;
+var GridGraph = class {
+  
+  
+  /** Residual capacity of the edge leaving node `p` in direction `d`, at `p * 4 + d`. */
+  
+  /** Net terminal capacity: above 0 to the source, below 0 to the sink. */
+  
+  
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    const n = width * height;
+    this.cap = new Float64Array(n * 4);
+    this.tr = new Float64Array(n);
+    this.tree = new Uint8Array(n);
+  }
+  /** Sets the capacity of the edge between `p` and its neighbour in direction `d`, both ways. */
+  setEdge(p, d, capacity) {
+    const q = d === 0 ? p + 1 : p + this.width;
+    this.cap[p * 4 + d] = capacity;
+    this.cap[q * 4 + (d ^ 2)] = capacity;
+  }
+  /** Adds `source` (cost of putting `p` on the sink side) and `sink` (the other way) to `p`. */
+  addTerminal(p, source, sink) {
+    this.tr[p] += source - sink;
+  }
+  /** Whether `p` is on the source side of the minimum cut (after {@link maxflow}). */
+  inSource(p) {
+    return this.tree[p] === SOURCE;
+  }
+  /** Runs max-flow and returns the flow (the cut's cost, less the constant terminal parts). */
+  maxflow() {
+    const { width: w, height: h, cap, tr, tree } = this;
+    const n = w * h;
+    const nb = (p, d) => {
+      const x = p % w;
+      if (d === 0) return x < w - 1 ? p + 1 : -1;
+      if (d === 1) return p + w < n ? p + w : -1;
+      if (d === 2) return x > 0 ? p - 1 : -1;
+      return p - w >= 0 ? p - w : -1;
+    };
+    const parent = new Int8Array(n).fill(NONE);
+    const ts = new Int32Array(n);
+    const dist = new Int32Array(n);
+    const queue = new Int32Array(n + 1);
+    const queued = new Uint8Array(n);
+    let qHead = 0;
+    let qTail = 0;
+    const activate = (p) => {
+      if (queued[p]) return;
+      queued[p] = 1;
+      queue[qTail] = p;
+      qTail = qTail === n ? 0 : qTail + 1;
+    };
+    const nextActive = () => {
+      while (qHead !== qTail) {
+        const p = queue[qHead];
+        qHead = qHead === n ? 0 : qHead + 1;
+        queued[p] = 0;
+        if (tree[p] !== FREE) return p;
+      }
+      return -1;
+    };
+    let orphans = new Int32Array(64);
+    let orphanCount = 0;
+    const orphan = (p) => {
+      parent[p] = NONE;
+      if (orphanCount === orphans.length) {
+        const grown = new Int32Array(orphans.length * 2);
+        grown.set(orphans);
+        orphans = grown;
+      }
+      orphans[orphanCount++] = p;
+    };
+    tree.fill(FREE);
+    for (let p = 0; p < n; p++) {
+      if (tr[p] > 0) tree[p] = SOURCE;
+      else if (tr[p] < 0) tree[p] = SINK;
+      else continue;
+      parent[p] = TERMINAL;
+      dist[p] = 1;
+      activate(p);
+    }
+    let flow = 0;
+    let time = 0;
+    let current = -1;
+    for (; ; ) {
+      if (current < 0 || tree[current] === FREE) {
+        current = nextActive();
+        if (current < 0) break;
+      }
+      const p = current;
+      const side = tree[p];
+      let s = -1;
+      let t = -1;
+      let dir = 0;
+      for (let d = 0; d < 4; d++) {
+        const q = nb(p, d);
+        if (q < 0) continue;
+        if (side === SOURCE ? cap[p * 4 + d] <= 0 : cap[q * 4 + (d ^ 2)] <= 0) continue;
+        if (tree[q] === FREE) {
+          tree[q] = side;
+          parent[q] = d ^ 2;
+          ts[q] = ts[p];
+          dist[q] = dist[p] + 1;
+          activate(q);
+        } else if (tree[q] !== side) {
+          if (side === SOURCE) {
+            s = p;
+            t = q;
+            dir = d;
+          } else {
+            s = q;
+            t = p;
+            dir = d ^ 2;
+          }
+          break;
+        } else if (ts[q] <= ts[p] && dist[q] > dist[p]) {
+          parent[q] = d ^ 2;
+          ts[q] = ts[p];
+          dist[q] = dist[p] + 1;
+        }
+      }
+      if (s < 0) {
+        current = -1;
+        continue;
+      }
+      time++;
+      let f = cap[s * 4 + dir];
+      for (let x = s; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          f = Math.min(f, tr[x]);
+          break;
+        }
+        const up = nb(x, a);
+        f = Math.min(f, cap[up * 4 + (a ^ 2)]);
+        x = up;
+      }
+      for (let x = t; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          f = Math.min(f, -tr[x]);
+          break;
+        }
+        f = Math.min(f, cap[x * 4 + a]);
+        x = nb(x, a);
+      }
+      cap[s * 4 + dir] -= f;
+      cap[t * 4 + (dir ^ 2)] += f;
+      for (let x = s; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          tr[x] -= f;
+          if (tr[x] <= 0) orphan(x);
+          break;
+        }
+        const up = nb(x, a);
+        cap[up * 4 + (a ^ 2)] -= f;
+        cap[x * 4 + a] += f;
+        if (cap[up * 4 + (a ^ 2)] <= 0) orphan(x);
+        x = up;
+      }
+      for (let x = t; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          tr[x] += f;
+          if (tr[x] >= 0) orphan(x);
+          break;
+        }
+        const up = nb(x, a);
+        cap[x * 4 + a] -= f;
+        cap[up * 4 + (a ^ 2)] += f;
+        if (cap[x * 4 + a] <= 0) orphan(x);
+        x = up;
+      }
+      flow += f;
+      while (orphanCount) {
+        const o = orphans[--orphanCount];
+        const oSide = tree[o];
+        let best = NONE;
+        let bestDist = Infinity;
+        for (let d = 0; d < 4; d++) {
+          const q = nb(o, d);
+          if (q < 0 || tree[q] !== oSide) continue;
+          if (oSide === SOURCE ? cap[q * 4 + (d ^ 2)] <= 0 : cap[o * 4 + d] <= 0) continue;
+          let k = 0;
+          let x = q;
+          for (; ; ) {
+            if (ts[x] === time) {
+              k += dist[x];
+              break;
+            }
+            const a = parent[x];
+            k++;
+            if (a === TERMINAL) {
+              ts[x] = time;
+              dist[x] = 1;
+              break;
+            }
+            if (a === NONE) {
+              k = Infinity;
+              break;
+            }
+            x = nb(x, a);
+          }
+          if (k === Infinity) continue;
+          if (k < bestDist) {
+            bestDist = k;
+            best = d;
+          }
+          for (let y = q, dd = k; ts[y] !== time; y = nb(y, parent[y]), dd--) {
+            ts[y] = time;
+            dist[y] = dd;
+          }
+        }
+        if (best !== NONE) {
+          parent[o] = best;
+          ts[o] = time;
+          dist[o] = bestDist + 1;
+          continue;
+        }
+        for (let d = 0; d < 4; d++) {
+          const q = nb(o, d);
+          if (q < 0 || tree[q] !== oSide) continue;
+          if (oSide === SOURCE ? cap[q * 4 + (d ^ 2)] > 0 : cap[o * 4 + d] > 0) activate(q);
+          const a = parent[q];
+          if (a !== TERMINAL && a !== NONE && nb(q, a) === o) orphan(q);
+        }
+        tree[o] = FREE;
+      }
+    }
+    return flow;
+  }
+};
+
+// src/image-editor/selection/segment/quick.ts
+var WORK_SIZE = 512;
+var workCache = /* @__PURE__ */ new WeakMap();
+function workImage(pixels, maxSide = WORK_SIZE) {
+  const cached = workCache.get(pixels.data);
+  if (cached && cached.maxSide === maxSide && cached.work.sourceWidth === pixels.width && cached.work.sourceHeight === pixels.height) return cached.work;
+  const { width: W, height: H, data } = pixels;
+  const scale = Math.min(1, maxSide / Math.max(W, H));
+  const w = Math.max(1, Math.round(W * scale));
+  const h = Math.max(1, Math.round(H * scale));
+  const sum = new Float64Array(w * h * 3);
+  const count = new Float64Array(w * h);
+  const xs = new Int32Array(W);
+  for (let x = 0; x < W; x++) xs[x] = Math.min(w - 1, Math.floor(x * w / W));
+  for (let y = 0; y < H; y++) {
+    const row = Math.min(h - 1, Math.floor(y * h / H)) * w;
+    for (let x = 0, p = y * W * 4; x < W; x++, p += 4) {
+      const o = row + xs[x];
+      const a = data[p + 3] / 255;
+      const k = o * 3;
+      sum[k] += data[p] * a + 255 * (1 - a);
+      sum[k + 1] += data[p + 1] * a + 255 * (1 - a);
+      sum[k + 2] += data[p + 2] * a + 255 * (1 - a);
+      count[o]++;
+    }
+  }
+  const rgb = new Float32Array(w * h * 3);
+  for (let i = 0; i < w * h; i++) {
+    const c = count[i] || 1;
+    rgb[i * 3] = sum[i * 3] / c;
+    rgb[i * 3 + 1] = sum[i * 3 + 1] / c;
+    rgb[i * 3 + 2] = sum[i * 3 + 2] / c;
+  }
+  const work = { sourceWidth: W, sourceHeight: H, width: w, height: h, scale: w / W, rgb };
+  workCache.set(pixels.data, { maxSide, work });
+  return work;
+}
+var BINS = 16;
+var binOf = (rgb, i) => (Math.min(BINS - 1, rgb[i * 3] >> 4) * BINS + Math.min(BINS - 1, rgb[i * 3 + 1] >> 4)) * BINS + Math.min(BINS - 1, rgb[i * 3 + 2] >> 4);
+function costTable(hist, total) {
+  let a = hist;
+  for (const stride of [1, BINS, BINS * BINS]) {
+    const b = new Float64Array(a.length);
+    for (let i = 0; i < a.length; i++) {
+      const pos = Math.floor(i / stride) % BINS;
+      const lo = pos > 0 ? a[i - stride] : a[i];
+      const hi = pos < BINS - 1 ? a[i + stride] : a[i];
+      b[i] = (lo + 2 * a[i] + hi) / 4;
+    }
+    a = b;
+  }
+  const out = new Float64Array(a.length);
+  const floor = 1e-4;
+  const denom = Math.max(1, total) * (1 + floor * a.length);
+  for (let i = 0; i < a.length; i++) out[i] = -Math.log((a[i] + floor * Math.max(1, total)) / denom);
+  return out;
+}
+var GAMMA = 50;
+var UNITS = 64;
+function strokePixels(points, r, w, h) {
+  const mask = new Uint8Array(w * h);
+  const list = [];
+  const add2 = (g) => {
+    if (!mask[g]) {
+      mask[g] = 1;
+      list.push(g);
+    }
+  };
+  const segs = points.length === 1 ? [[points[0], points[0]]] : points.slice(1).map((p, i) => [points[i], p]);
+  for (const [a, b] of segs) {
+    const x0 = Math.max(0, Math.floor(Math.min(a.x, b.x) - r));
+    const x1 = Math.min(w - 1, Math.ceil(Math.max(a.x, b.x) + r));
+    const y0 = Math.max(0, Math.floor(Math.min(a.y, b.y) - r));
+    const y1 = Math.min(h - 1, Math.ceil(Math.max(a.y, b.y) + r));
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len2 = dx * dx + dy * dy;
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) {
+        const px2 = x + 0.5 - a.x;
+        const py = y + 0.5 - a.y;
+        const t = len2 > 0 ? Math.min(1, Math.max(0, (px2 * dx + py * dy) / len2)) : 0;
+        if ((px2 - t * dx) ** 2 + (py - t * dy) ** 2 <= r * r) add2(y * w + x);
+      }
+    }
+  }
+  if (!list.length) {
+    for (const p of points) add2(Math.min(h - 1, Math.max(0, Math.floor(p.y))) * w + Math.min(w - 1, Math.max(0, Math.floor(p.x))));
+  }
+  return { mask, list };
+}
+function segmentStroke(work, stroke, grown, start) {
+  const { width: w, height: h, rgb } = work;
+  let roi = start;
+  for (; ; ) {
+    const { x: rx, y: ry, width: rw, height: rh } = roi;
+    const n = rw * rh;
+    const fgHist = new Float64Array(BINS ** 3);
+    const bgHist = new Float64Array(BINS ** 3);
+    let fgN = 0;
+    let bgN = 0;
+    const atImageEdge = { l: rx === 0, t: ry === 0, r: rx + rw === w, b: ry + rh === h };
+    for (let y = 0; y < rh; y++) {
+      for (let x = 0; x < rw; x++) {
+        const g = (ry + y) * w + (rx + x);
+        const bin = binOf(rgb, g);
+        bgHist[bin]++;
+        bgN++;
+        if (stroke.mask[g] || _optionalChain([grown, 'optionalAccess', _64 => _64[g]])) {
+          fgHist[bin]++;
+          fgN++;
+        }
+      }
+    }
+    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 graph = new GridGraph(rw, rh);
+    const HARD = 1e9;
+    for (let y = 0; y < rh; y++) {
+      for (let x = 0; x < rw; x++) {
+        const p = y * rw + x;
+        const g = (ry + y) * w + rx + x;
+        if (stroke.mask[g]) graph.addTerminal(p, HARD, 0);
+        else {
+          const bin = binOf(rgb, g);
+          graph.addTerminal(p, Math.round(bgCost[bin] * UNITS), Math.round(fgCost[bin] * UNITS));
+        }
+        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)));
+        }
+      }
+    }
+    graph.maxflow();
+    const label = new Uint8Array(n);
+    const stack = [];
+    for (const g of stroke.list) {
+      const x = g % w - rx;
+      const y = Math.floor(g / w) - ry;
+      if (x < 0 || y < 0 || x >= rw || y >= rh) continue;
+      const p = y * rw + x;
+      if (!label[p]) {
+        label[p] = 1;
+        stack.push(p);
+      }
+    }
+    while (stack.length) {
+      const p = stack.pop();
+      const x = p % rw;
+      for (const q of [x + 1 < rw ? p + 1 : -1, x > 0 ? p - 1 : -1, p + rw < n ? p + rw : -1, p - rw]) {
+        if (q >= 0 && !label[q] && graph.inSource(q)) {
+          label[q] = 1;
+          stack.push(q);
+        }
+      }
+    }
+    let touches = false;
+    for (let y = 0; y < rh; y++) {
+      for (let x = 0; x < rw; x++) {
+        const p = y * rw + x;
+        if (!label[p]) continue;
+        if (!atImageEdge.l && x === 0 || !atImageEdge.t && y === 0 || !atImageEdge.r && x === rw - 1 || !atImageEdge.b && y === rh - 1) touches = true;
+      }
+    }
+    if (!touches || atImageEdge.l && atImageEdge.t && atImageEdge.r && atImageEdge.b) return { roi, label };
+    const nx = Math.max(0, rx - Math.ceil(rw / 2));
+    const ny = Math.max(0, ry - Math.ceil(rh / 2));
+    roi = { x: nx, y: ny, width: Math.min(w, rx + rw + Math.ceil(rw / 2)) - nx, height: Math.min(h, ry + rh + Math.ceil(rh / 2)) - ny };
+    if (roi.width * roi.height * 2.5 > w * h) roi = { x: 0, y: 0, width: w, height: h };
+  }
+}
+function 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);
+  const { width: w, height: h, scale } = work;
+  const r = Math.max(0.5, (_nullishCoalesce(options.size, () => ( 30))) / 2 * scale);
+  const pts = stroke.map((p) => ({ x: p.x * scale, y: p.y * scale }));
+  const seeds = strokePixels(pts, r, w, h);
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const p of pts) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
+  const margin = Math.max(24, 4 * r);
+  const rx = Math.max(0, Math.floor(x0 - margin));
+  const ry = Math.max(0, Math.floor(y0 - margin));
+  const roi = { x: rx, y: ry, width: Math.min(w, Math.ceil(x1 + margin)) - rx, height: Math.min(h, Math.ceil(y1 + margin)) - ry };
+  let grown = null;
+  const sel = options.grow ? options.selection : null;
+  if (_optionalChain([sel, 'optionalAccess', _65 => _65.bounds])) {
+    grown = new Uint8Array(w * h);
+    const b = sel.bounds;
+    for (let y = Math.max(0, Math.floor(b.y * scale)); y < Math.min(h, Math.ceil((b.y + b.height) * scale)); y++) {
+      for (let x = Math.max(0, Math.floor(b.x * scale)); x < Math.min(w, Math.ceil((b.x + b.width) * scale)); x++) {
+        if (_chunkUYXL6ZWQcjs.selectionValueAt.call(void 0, sel, Math.min(sel.width - 1, Math.floor((x + 0.5) / scale)), Math.min(sel.height - 1, Math.floor((y + 0.5) / scale))) >= 0.5) grown[y * w + x] = 1;
+      }
+    }
+  }
+  const { roi: done, label } = segmentStroke(work, seeds, grown, roi);
+  return upscaleRegion(work, pixels, done, label, _nullishCoalesce(options.enhanceEdge, () => ( false)));
+}
+
 // src/image-editor/layers/shape-type-ui.ts
 var DEFAULT_SHAPE_TOOL_OPTIONS = {
   kind: "rect",
@@ -2915,11 +3498,11 @@ function applyShapeOptions(controller, layerId, change) {
   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', _64 => _64.stroke, 'optionalAccess', _65 => _65.paint, 'access', _66 => _66.type]) === "color" ? info.stroke.paint.color : null;
-    style.stroke = color ? { width: _nullishCoalesce(_nullishCoalesce(change.strokeWidth, () => ( _optionalChain([info, 'access', _67 => _67.stroke, 'optionalAccess', _68 => _68.width]))), () => ( 2)), paint: color } : null;
+    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;
   }
   if (Object.keys(style).length) controller.setShapeStyle(layerId, style);
-  const live = _optionalChain([info, 'access', _69 => _69.components, 'access', _70 => _70[0], 'optionalAccess', _71 => _71.live]);
+  const live = _optionalChain([info, 'access', _71 => _71.components, 'access', _72 => _72[0], 'optionalAccess', _73 => _73.live]);
   if (!live) return;
   const shape = {};
   if (live.kind === "rect" && change.radius !== void 0) shape.radius = change.radius;
@@ -2945,7 +3528,7 @@ var TextEditSession = (_class7 = class {
   __init38() {this.listeners = /* @__PURE__ */ new Set()}
   __init39() {this.error = null}
   get layer() {
-    const l = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.controller.getLayers(), this.layerId), 'optionalAccess', _72 => _72.layer]);
+    const l = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.controller.getLayers(), this.layerId), 'optionalAccess', _74 => _74.layer]);
     if (!l || l.type !== "type") throw new Error("The type layer being edited is gone.");
     return l;
   }
@@ -2960,7 +3543,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', _73 => _73.layer, 'access', _74 => _74.type]) === "type";
+    return _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.controller.getLayers(), this.layerId), 'optionalAccess', _75 => _75.layer, 'access', _76 => _76.type]) === "type";
   }
   subscribe(fn) {
     this.listeners.add(fn);
@@ -3248,7 +3831,7 @@ var TypeToolGesture = (_class8 = class {
   finish() {
     const s = this.session;
     this.session = null;
-    _optionalChain([s, 'optionalAccess', _75 => _75.close, 'call', _76 => _76()]);
+    _optionalChain([s, 'optionalAccess', _77 => _77.close, 'call', _78 => _78()]);
   }
 }, _class8);
 
@@ -3717,7 +4300,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', _77 => _77.bounds]) ? out : null;
+  return _optionalChain([out, 'optionalAccess', _79 => _79.bounds]) ? out : null;
 }
 function segmentsToSelection(width, height, results) {
   let out = null;
@@ -3998,7 +4581,7 @@ function deserializeChannels(value, size, problems = []) {
         visible: v.visible === true
       });
     } catch (err) {
-      problems.push(`Alpha channel "${String(_nullishCoalesce(_optionalChain([v, 'optionalAccess', _78 => _78.name]), () => ( "?")))}" could not be read: ${err instanceof Error ? err.message : String(err)}.`);
+      problems.push(`Alpha channel "${String(_nullishCoalesce(_optionalChain([v, 'optionalAccess', _80 => _80.name]), () => ( "?")))}" could not be read: ${err instanceof Error ? err.message : String(err)}.`);
     }
   }
   return out;
@@ -4036,16 +4619,16 @@ function checkEffectTime(time) {
   return time;
 }
 function checkEffectAnimation(animate) {
-  const duration = _optionalChain([animate, 'optionalAccess', _79 => _79.duration]);
+  const duration = _optionalChain([animate, 'optionalAccess', _81 => _81.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', _80 => _80.duration])) return null;
+  if (!_optionalChain([d, 'optionalAccess', _82 => _82.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', _81 => _81.animate, 'optionalAccess', _82 => _82.duration]), () => ( d.duration)), loops: d.loop };
+  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 };
 }
 
 // src/image-editor/effects.ts
@@ -4298,14 +4881,14 @@ var FreeTransformSession = (_class10 = class {
     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', _83 => _83.bounds]));
+    const selected = Boolean(_optionalChain([sel, 'optionalAccess', _85 => _85.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', _84 => _84.layer]) : void 0;
-    const smartTarget = (_optionalChain([target, 'optionalAccess', _85 => _85.type]) === "smart" || _optionalChain([target, 'optionalAccess', _86 => _86.type]) === "shape" || _optionalChain([target, 'optionalAccess', _87 => _87.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', _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";
     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.`);
@@ -4329,9 +4912,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', _88 => _88.linked]) !== false;
+      const linked = _optionalChain([mask, 'optionalAccess', _90 => _90.linked]) !== false;
       const maskAlone = channel === "mask" && (!linked || layer.type !== "pixel");
-      if (channel === "mask" && !mask) fail(_optionalChain([layer, 'access', _89 => _89.mask, 'optionalAccess', _90 => _90.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', _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 (!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") {
@@ -4434,7 +5017,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', _91 => _91.parent, 'optionalAccess', _92 => _92.id]), () => ( null)), loc.index + 1);
+          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.parts.push({ what: "pixels", offset: o, moving: lifted, base: null, reduced: /* @__PURE__ */ new Map() });
           moves.push("pixels");
         }
@@ -4543,7 +5126,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', _93 => _93.layer, 'access', _94 => _94.vectorMask]);
+    const vm = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, layers, this.layerId), 'optionalAccess', _95 => _95.layer, 'access', _96 => _96.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;
@@ -4714,11 +5297,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', _95 => _95.layer]) : void 0;
-    if (this.moves.includes("pixels") && _optionalChain([layer, 'optionalAccess', _96 => _96.type]) === "pixel") bounds = toDoc(_chunkCWM3CUUXcjs.contentBounds.call(void 0, this.host.pixelsOf(layer)), layer.offset);
-    else if (this.moves.includes("pixels") && (_optionalChain([layer, 'optionalAccess', _97 => _97.type]) === "smart" || _optionalChain([layer, 'optionalAccess', _98 => _98.type]) === "shape" || _optionalChain([layer, 'optionalAccess', _99 => _99.type]) === "type")) bounds = _chunkCWM3CUUXcjs.contentBounds.call(void 0, layer.surface);
-    else if (this.moves.includes("mask") && _optionalChain([layer, 'optionalAccess', _100 => _100.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', _101 => _101.bounds]) ? { ...selection.bounds } : null;
+    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;
     return {
       layerId: _nullishCoalesce(this.copyId, () => ( this.layerId)),
       content: this.content,
@@ -4747,7 +5330,7 @@ function deserializeColorMode(raw, problems) {
 }
 function effectiveProof(proof, mode) {
   if (proof) return proof;
-  if (_optionalChain([mode, 'optionalAccess', _102 => _102.mode]) === "cmyk") return { ...DEFAULT_PROOF, profile: mode.profile, intent: mode.intent };
+  if (_optionalChain([mode, 'optionalAccess', _104 => _104.mode]) === "cmyk") return { ...DEFAULT_PROOF, profile: mode.profile, intent: mode.intent };
   return null;
 }
 function colorModePlanes(doc, mode) {
@@ -4802,7 +5385,7 @@ function resolveProfile(doc) {
   return p;
 }
 function profileBytes(doc) {
-  if (_optionalChain([doc, 'optionalAccess', _103 => _103.icc])) return doc.icc;
+  if (_optionalChain([doc, 'optionalAccess', _105 => _105.icc])) return doc.icc;
   const p = resolveProfile(doc);
   return _nullishCoalesce(p.bytes, () => ( _chunkBROJYMWUcjs.encodeProfile.call(void 0, p)));
 }
@@ -4964,7 +5547,7 @@ function paintCoverageInto(base, coverage, apply, rects, depth = null) {
         else tiles.delete(key);
         continue;
       }
-      const src = _nullishCoalesce(_optionalChain([base, 'access', _104 => _104.tiles, 'access', _105 => _105.get, 'call', _106 => _106(key), 'optionalAccess', _107 => _107.data]), () => ( defaultTile(base)));
+      const src = _nullishCoalesce(_optionalChain([base, 'access', _106 => _106.tiles, 'access', _107 => _107.get, 'call', _108 => _108(key), 'optionalAccess', _109 => _109.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);
@@ -5077,7 +5660,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', _108 => _108(key), 'optionalAccess', _109 => _109.slice, 'call', _110 => _110()]), () => ( new Float32Array(_chunkCWM3CUUXcjs.TILE * _chunkCWM3CUUXcjs.TILE * 4))));
+            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.touched.add(key);
           }
           this.fresh.add(key);
@@ -5089,11 +5672,11 @@ var PaintStrokeSession = (_class11 = class {
       offset: a.offset,
       lockTransparency: a.lockTransparency,
       selection: a.selection,
-      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _111 => _111.live, 'access', _112 => _112.get, 'call', _113 => _113(_chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _114 => _114.data]), () => ( (this.base.defaultValue ? defaultTile(this.base) : null))),
+      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))),
       writeTile: (tx, ty) => {
         const key = _chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty);
         if (!this.touched.has(key)) {
-          const src = _nullishCoalesce(_optionalChain([this, 'access', _115 => _115.base, 'access', _116 => _116.tiles, 'access', _117 => _117.get, 'call', _118 => _118(key), 'optionalAccess', _119 => _119.data]), () => ( defaultTile(this.base)));
+          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)));
           this.live.set(key, { data: new Uint8ClampedArray(src), uniform: null });
           this.touched.add(key);
         }
@@ -5110,11 +5693,11 @@ var PaintStrokeSession = (_class11 = class {
     if (this.closed || !points.length) return;
     if (!this.started) {
       this.started = true;
-      if (_optionalChain([this, 'access', _120 => _120.retouch, 'optionalAccess', _121 => _121.kind]) === "coverage") this.retouch.start(points[0]);
+      if (_optionalChain([this, 'access', _122 => _122.retouch, 'optionalAccess', _123 => _123.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', _122 => _122.flushView, 'optionalCall', _123 => _123()]);
+    _optionalChain([this, 'access', _124 => _124.flushView, 'optionalCall', _125 => _125()]);
     this.update(rects);
   }
   update(rects) {
@@ -5144,7 +5727,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', _124 => _124.kind]) === "coverage" ? rt.paint() : null;
+        const paint = _optionalChain([rt, 'optionalAccess', _126 => _126.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);
@@ -5155,13 +5738,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', _125 => _125.kind]) === "coverage" && _optionalChain([paint, 'optionalAccess', _126 => _126.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', _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);
         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', _127 => _127.base, 'access', _128 => _128.tiles, 'access', _129 => _129.get, 'call', _130 => _130(key), 'optionalAccess', _131 => _131.data]), () => ( defaultTile(this.base)));
-      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _132 => _132.live, 'access', _133 => _133.get, 'call', _134 => _134(key), 'optionalAccess', _135 => _135.data]) : void 0;
+      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;
       this.touched.add(key);
       const data = this.compositeTile(src, tx, ty, prev ? { into: prev, region: r } : {});
       this.live.set(key, { data, uniform: null });
@@ -5173,12 +5756,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', _136 => _136.flushView, 'optionalCall', _137 => _137()]);
+    _optionalChain([this, 'access', _138 => _138.flushView, 'optionalCall', _139 => _139()]);
     this.update(rects);
     this.closed = true;
     const ch = this.base.channels;
     const r = this.retouch;
-    if (_optionalChain([r, 'optionalAccess', _138 => _138.kind]) === "coverage" && r.finalPaint) {
+    if (_optionalChain([r, 'optionalAccess', _140 => _140.kind]) === "coverage" && r.finalPaint) {
       const final = r.finalPaint(this.stroke.coverage);
       if (final) {
         for (const key of this.touched) {
@@ -5187,7 +5770,7 @@ var PaintStrokeSession = (_class11 = class {
             this.retouchDeepTile(key, tx, ty, final, {});
             continue;
           }
-          const src = _nullishCoalesce(_optionalChain([this, 'access', _139 => _139.base, 'access', _140 => _140.tiles, 'access', _141 => _141.get, 'call', _142 => _142(key), 'optionalAccess', _143 => _143.data]), () => ( defaultTile(this.base)));
+          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)));
           this.live.set(key, { data: this.compositeTile(src, tx, ty, {}, final), uniform: null });
         }
       }
@@ -5209,7 +5792,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', _144 => _144.result])) Object.assign(result, r.result());
+    if (_optionalChain([r, 'optionalAccess', _146 => _146.result])) Object.assign(result, r.result());
     return result;
   }
   /** Abandons the stroke and restores the layer. */
@@ -5335,14 +5918,14 @@ function migrateSerializedImageEditorState(data) {
   const legacy = data;
   const adjustments = normalizeStoredAdjustments(legacy.adjustments);
   return {
-    version: _optionalChain([adjustments, 'access', _145 => _145.layers, 'optionalAccess', _146 => _146.length]) ? 2 : 1,
+    version: _optionalChain([adjustments, 'access', _147 => _147.layers, 'optionalAccess', _148 => _148.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', _147 => _147.depthMask, 'optionalAccess', _148 => _148.depthRange]), () => ( DEFAULT_DEPTH_MASK.depthRange))]
+      depthRange: [..._nullishCoalesce(_optionalChain([legacy, 'access', _149 => _149.depthMask, 'optionalAccess', _150 => _150.depthRange]), () => ( DEFAULT_DEPTH_MASK.depthRange))]
     },
     annotations: JSON.parse(JSON.stringify(_nullishCoalesce(legacy.annotations, () => ( [])))),
     ...legacy.selection ? { selection: { ...legacy.selection } } : {}
@@ -5418,7 +6001,7 @@ var ImageEditorController = (_class12 = class {
       sourceIsOpaque: () => this.sourceIsOpaque(),
       version: () => `${this.sourceVersion()}:${this.patternsVersion()}`,
       globalLight: () => this.state.globalLight,
-      pattern: (id) => _nullishCoalesce(_optionalChain([this, 'access', _149 => _149.state, 'access', _150 => _150.patterns, 'optionalAccess', _151 => _151.find, 'call', _152 => _152((p) => p.id === id)]), () => ( null))
+      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))
     };
     this.state = {
       sourceUrl: typeof options.image === "string" ? options.image : null,
@@ -5451,13 +6034,13 @@ var ImageEditorController = (_class12 = class {
       };
     }
     this.applyStored(_nullishCoalesce(options.initialState, () => ( {})));
-    if (_optionalChain([options, 'access', _153 => _153.initialState, 'optionalAccess', _154 => _154.selection])) {
+    if (_optionalChain([options, 'access', _155 => _155.initialState, 'optionalAccess', _156 => _156.selection])) {
       try {
         this.state.selection = normalizeSelection(_chunkUYXL6ZWQcjs.deserializeSelection.call(void 0, options.initialState.selection));
       } catch (e20) {
       }
     }
-    if (_optionalChain([options, 'access', _155 => _155.initialState, 'optionalAccess', _156 => _156.channels])) {
+    if (_optionalChain([options, 'access', _157 => _157.initialState, 'optionalAccess', _158 => _158.channels])) {
       const channels = deserializeChannels(options.initialState.channels, this.naturalSize, this.lastLoadProblems);
       if (channels.length) this.state.channels = channels;
     }
@@ -5541,7 +6124,7 @@ var ImageEditorController = (_class12 = class {
     this.syncViews();
     this.syncDisplay();
     const currentState = { ...this.state };
-    _optionalChain([this, 'access', _157 => _157.onStateChange, 'optionalCall', _158 => _158(currentState)]);
+    _optionalChain([this, 'access', _159 => _159.onStateChange, 'optionalCall', _160 => _160(currentState)]);
     this.listeners.forEach((l) => l(currentState));
     if (this.effects.provider) this.queueEffectRefresh("incomplete");
   }
@@ -5570,7 +6153,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', _159 => _159.smartFilters, 'optionalAccess', _160 => _160.filters, 'access', _161 => _161.some, 'call', _162 => _162((f) => f.kind === "effect")]) && (all || _chunkUYXL6ZWQcjs.isSmartSurfaceIncomplete.call(void 0, l.surface))) {
+        } 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))) {
           try {
             const r = _chunkUYXL6ZWQcjs.rerender.call(void 0, l, canvas);
             if (all || !_chunkUYXL6ZWQcjs.isSmartSurfaceIncomplete.call(void 0, r.surface)) next2 = r;
@@ -5666,8 +6249,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', _163 => _163.smartFilters, 'optionalAccess', _164 => _164.filters, 'access', _165 => _165.find, 'call', _166 => _166((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', _167 => _167.smartFilters, 'optionalAccess', _168 => _168.filters]), () => ( []))).map((f) => `${f.id} (${f.kind === "effect" ? _nullishCoalesce(f.name, () => ( f.effect)) : f.kind})`).join(", ") || "none"}.`);
+    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 update = {};
     if (changes.values) {
       const d = await this.describeEffect(was.effect);
@@ -5709,7 +6292,7 @@ var ImageEditorController = (_class12 = class {
     const layer = {
       type: "pixel",
       id,
-      name: _optionalChain([options, 'access', _169 => _169.name, 'optionalAccess', _170 => _170.trim, 'call', _171 => _171()]) || d.name,
+      name: _optionalChain([options, 'access', _171 => _171.name, 'optionalAccess', _172 => _172.trim, 'call', _173 => _173()]) || d.name,
       visible: true,
       opacity: _nullishCoalesce(options.opacity, () => ( 1)),
       blend: _nullishCoalesce(blend, () => ( "normal")),
@@ -5734,7 +6317,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', _172 => _172.layer]);
+    const layer = _optionalChain([found, 'optionalAccess', _174 => _174.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;
@@ -5763,7 +6346,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', _173 => _173.generator, 'optionalAccess', _174 => _174.animate]));
+    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]));
     if (!layers.length) return null;
     return { duration: Math.max(...layers.map((l) => l.generator.animate.duration)), layerIds: layers.map((l) => l.id) };
   }
@@ -5780,7 +6363,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', _175 => _175.generator, 'optionalAccess', _176 => _176.animate])) continue;
+      if (l.type !== "pixel" || !l.visible || !_optionalChain([l, 'access', _177 => _177.generator, 'optionalAccess', _178 => _178.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));
@@ -5841,7 +6424,7 @@ var ImageEditorController = (_class12 = class {
       transform: { ...s.transform },
       outputOpacity: s.outputOpacity,
       selection: _nullishCoalesce(s.selection, () => ( null)),
-      ..._optionalChain([s, 'access', _177 => _177.channels, 'optionalAccess', _178 => _178.length]) ? { channels: s.channels } : {},
+      ..._optionalChain([s, 'access', _179 => _179.channels, 'optionalAccess', _180 => _180.length]) ? { channels: s.channels } : {},
       source: {
         sourceUrl: s.sourceUrl,
         element: this.imageElement,
@@ -5877,7 +6460,7 @@ var ImageEditorController = (_class12 = class {
     if (entry.colorMode) s.colorMode = entry.colorMode;
     else delete s.colorMode;
     s.selection = entry.selection;
-    if (_optionalChain([entry, 'access', _179 => _179.channels, 'optionalAccess', _180 => _180.length])) s.channels = entry.channels;
+    if (_optionalChain([entry, 'access', _181 => _181.channels, 'optionalAccess', _182 => _182.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;
@@ -6084,7 +6667,7 @@ var ImageEditorController = (_class12 = class {
     return this.state.layers;
   }
   getLayer(id) {
-    return _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.state.layers, id), 'optionalAccess', _181 => _181.layer]);
+    return _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, this.state.layers, id), 'optionalAccess', _183 => _183.layer]);
   }
   /** The active layer, or `undefined`. */
   getActiveLayer() {
@@ -6097,7 +6680,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', _182 => _182.mask]) ? "mask" : target === "filter-mask" && _optionalChain([layer, 'optionalAccess', _183 => _183.type]) === "smart" && _optionalChain([layer, 'access', _184 => _184.smartFilters, 'optionalAccess', _185 => _185.mask]) ? "filter-mask" : "pixels";
+    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";
     if (this.state.activeLayerId === id && this.state.activeTarget === t) return true;
     this.state.activeLayerId = id;
     this.state.activeTarget = t;
@@ -6259,7 +6842,7 @@ var ImageEditorController = (_class12 = class {
       surfaceOf: (l) => this.surfaceOf(l),
       version: `${this.sourceVersion()}:${this.patternsVersion()}`,
       globalLight: this.state.globalLight,
-      pattern: (id) => _nullishCoalesce(_optionalChain([this, 'access', _186 => _186.state, 'access', _187 => _187.patterns, 'optionalAccess', _188 => _188.find, 'call', _189 => _189((p) => p.id === id)]), () => ( null))
+      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))
     };
   }
   __init91() {this.sourceIds = /* @__PURE__ */ new WeakMap()}
@@ -6336,7 +6919,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', _190 => _190.data]) || data.data.length < width * height * 4) return null;
+      if (!_optionalChain([data, 'optionalAccess', _192 => _192.data]) || data.data.length < width * height * 4) return null;
       return { width, height, data: data.data };
     } catch (e24) {
       return null;
@@ -6349,7 +6932,7 @@ var ImageEditorController = (_class12 = class {
     const prev = this.state.layers;
     const depth = this.bitDepth;
     this.state.layers = next;
-    _optionalChain([extra, 'optionalCall', _191 => _191()]);
+    _optionalChain([extra, 'optionalCall', _193 => _193()]);
     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);
@@ -6387,7 +6970,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', _192 => _192.name, 'optionalAccess', _193 => _193.trim, 'call', _194 => _194()]) || this.nextLayerName(),
+      name: _optionalChain([init, 'access', _194 => _194.name, 'optionalAccess', _195 => _195.trim, 'call', _196 => _196()]) || this.nextLayerName(),
       visible: _nullishCoalesce(init.visible, () => ( true)),
       opacity: _nullishCoalesce(init.opacity, () => ( 1)),
       blend: _nullishCoalesce(blend, () => ( "normal")),
@@ -6414,7 +6997,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', _195 => _195.bytes]), () => ( null));
+    if (/^data:image\/png/i.test(trimmed)) png = _nullishCoalesce(_optionalChain([_chunkCWM3CUUXcjs.parseDataUrl.call(void 0, trimmed), 'optionalAccess', _197 => _197.bytes]), () => ( null));
     else if (/^[A-Za-z0-9+/=\s]+$/.test(trimmed) && trimmed.length > 16) {
       try {
         const bytes = _chunkCWM3CUUXcjs.base64ToBytes.call(void 0, trimmed);
@@ -6463,7 +7046,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', _196 => _196.id]) === this.state.selectedAnnotationId)) {
+      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)) {
         this.state.selectedAnnotationId = null;
       }
     });
@@ -6472,9 +7055,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', _197 => _197.parent, 'optionalAccess', _198 => _198.id]), () => ( null)), index: loc.index };
+    if (next === this.state.layers) return { parentId: _nullishCoalesce(_optionalChain([loc, 'access', _199 => _199.parent, 'optionalAccess', _200 => _200.id]), () => ( null)), index: loc.index };
     this.commitLayers(next);
-    return { parentId: _nullishCoalesce(_optionalChain([loc, 'access', _199 => _199.parent, 'optionalAccess', _200 => _200.id]), () => ( null)), index: loc.index };
+    return { parentId: _nullishCoalesce(_optionalChain([loc, 'access', _201 => _201.parent, 'optionalAccess', _202 => _202.id]), () => ( null)), index: loc.index };
   }
   /**
    * Changes name, visibility, opacity, fill, blend, clipping, locks or (groups) collapsed state, as
@@ -6491,7 +7074,7 @@ var ImageEditorController = (_class12 = class {
     const group = {
       type: "group",
       id: _chunkUYXL6ZWQcjs.newLayerId.call(void 0, "group"),
-      name: _optionalChain([init, 'access', _201 => _201.name, 'optionalAccess', _202 => _202.trim, 'call', _203 => _203()]) || "Group",
+      name: _optionalChain([init, 'access', _203 => _203.name, 'optionalAccess', _204 => _204.trim, 'call', _205 => _205()]) || "Group",
       visible: true,
       opacity: 1,
       blend,
@@ -6584,7 +7167,7 @@ var ImageEditorController = (_class12 = class {
         sel = this.layerTransparency(id);
       } else {
         const current = this.state.selection;
-        if (!_optionalChain([current, 'optionalAccess', _204 => _204.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, or use reveal-all / hide-all / transparency.");
+        if (!_optionalChain([current, 'optionalAccess', _206 => _206.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);
@@ -6615,7 +7198,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', _205 => _205.mask, 'optionalAccess', _206 => _206.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', _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.`);
     return layer;
   }
   requireVectorMask(id) {
@@ -6625,10 +7208,10 @@ var ImageEditorController = (_class12 = class {
   }
   /** Components from a path spec: `components`, or one `shape` / `subpaths`. */
   vectorMaskComponents(path) {
-    if (_optionalChain([path, 'access', _207 => _207.components, 'optionalAccess', _208 => _208.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', _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 (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', _209 => _209.components, 'optionalAccess', _210 => _210.length]) ? path.components : [path];
-    return specs.map((c, i) => this.componentFrom(c, _optionalChain([path, 'access', _211 => _211.components, 'optionalAccess', _212 => _212.length]) ? `components[${i}].` : ""));
+    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}].` : ""));
   }
   /**
    * Layer › Vector Mask: `reveal-all` (an empty path showing everything), `hide-all` (an empty path
@@ -6645,7 +7228,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', _213 => _213.components, 'optionalAccess', _214 => _214.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', _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.`);
       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.`);
@@ -6656,7 +7239,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', _215 => _215.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, then make a path from the 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 (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.");
@@ -6837,7 +7420,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', _216 => _216.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select the pixels to copy first.");
+    if (!_optionalChain([sel, 'optionalAccess', _218 => _218.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;
@@ -6855,14 +7438,14 @@ var ImageEditorController = (_class12 = class {
     const copy = {
       type: "pixel",
       id: _chunkUYXL6ZWQcjs.newLayerId.call(void 0, ),
-      name: _optionalChain([options, 'access', _217 => _217.name, 'optionalAccess', _218 => _218.trim, 'call', _219 => _219()]) || `${layer.name || "Layer"} ${options.cut ? "cut" : "copy"}`,
+      name: _optionalChain([options, 'access', _219 => _219.name, 'optionalAccess', _220 => _220.trim, 'call', _221 => _221()]) || `${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', _220 => _220.parent, 'optionalAccess', _221 => _221.id]), () => ( null)), loc.index + 1);
+    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);
     if (kept) {
       const cutLayer = { ...layer, surface: _chunkCWM3CUUXcjs.writeRegion.call(void 0, surface, src, kept) };
       delete cutLayer.source;
@@ -6886,7 +7469,7 @@ var ImageEditorController = (_class12 = class {
       layers: () => this.state.layers,
       activeLayerId: () => this.state.activeLayerId,
       activeTarget: () => this.state.activeTarget,
-      selection: () => _optionalChain([this, 'access', _222 => _222.state, 'access', _223 => _223.selection, 'optionalAccess', _224 => _224.bounds]) ? this.state.selection : null,
+      selection: () => _optionalChain([this, 'access', _224 => _224.state, 'access', _225 => _225.selection, 'optionalAccess', _226 => _226.bounds]) ? this.state.selection : null,
       canvas: () => this.naturalSize,
       pixelsOf: (layer) => this.surfaceOf(layer),
       shapeEnv: () => this.shapeEnv(),
@@ -7034,7 +7617,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', _225 => _225.length]) ? ids : this.state.activeLayerId ? [this.state.activeLayerId] : [];
+    const list = _optionalChain([ids, 'optionalAccess', _227 => _227.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, () => {
@@ -7067,8 +7650,8 @@ var ImageEditorController = (_class12 = class {
         width: c.width,
         height: c.height,
         decoded: _chunkUYXL6ZWQcjs.isContentsDecoded.call(void 0, c),
-        fileType: _nullishCoalesce(_optionalChain([c, 'access', _226 => _226.file, 'optionalAccess', _227 => _227.type]), () => ( null)),
-        linkedPath: _nullishCoalesce(_optionalChain([c, 'access', _228 => _228.linked, 'optionalAccess', _229 => _229.path]), () => ( null)),
+        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)),
         instances: _chunkUYXL6ZWQcjs.instancesOf.call(void 0, this.state.layers, c.id),
         layerCount: c.document ? _chunkHGTDMKNEcjs.flattenLayers.call(void 0, c.document.layers).length : 0
       },
@@ -7085,9 +7668,9 @@ var ImageEditorController = (_class12 = class {
         bounds: _chunkUYXL6ZWQcjs.transformedBox.call(void 0, g)
       },
       smartFilters: {
-        enabled: _nullishCoalesce(_optionalChain([stack, 'optionalAccess', _230 => _230.enabled]), () => ( true)),
-        filters: (_nullishCoalesce(_optionalChain([stack, 'optionalAccess', _231 => _231.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', _232 => _232.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', _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
       },
       bounds: this.getLayerBounds(id)
     };
@@ -7226,7 +7809,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', _233 => _233.state, 'access', _234 => _234.selection, 'optionalAccess', _235 => _235.bounds])) return false;
+    if (!useSelection || !_optionalChain([this, 'access', _235 => _235.state, 'access', _236 => _236.selection, 'optionalAccess', _237 => _237.bounds])) return false;
     this.setSmartFilterMask(id, "selection", {}, false);
     return true;
   }
@@ -7240,19 +7823,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', _236 => _236.layer, 'access', _237 => _237.smartFilters, 'optionalAccess', _238 => _238.filters]), () => ( []));
+    return _nullishCoalesce(_optionalChain([res, 'access', _238 => _238.layer, 'access', _239 => _239.smartFilters, 'optionalAccess', _240 => _240.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', _239 => _239.layer, 'access', _240 => _240.smartFilters, 'optionalAccess', _241 => _241.filters]), () => ( []));
+    return _nullishCoalesce(_optionalChain([res, 'access', _241 => _241.layer, 'access', _242 => _242.smartFilters, 'optionalAccess', _243 => _243.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', _242 => _242.layer, 'access', _243 => _243.smartFilters, 'optionalAccess', _244 => _244.enabled]), () => ( true));
+    return _nullishCoalesce(_optionalChain([res, 'access', _244 => _244.layer, 'access', _245 => _245.smartFilters, 'optionalAccess', _246 => _246.enabled]), () => ( true));
   }
   /**
    * Sets the smart filter mask (one undo step): `reveal-all`, `hide-all`, `selection` (the
@@ -7264,11 +7847,11 @@ var ImageEditorController = (_class12 = class {
     let mask;
     if (from === "none") mask = null;
     else if (from === "keep") {
-      if (!_optionalChain([layer, 'access', _245 => _245.smartFilters, 'optionalAccess', _246 => _246.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', _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.`);
       mask = withMaskProps(layer.smartFilters.mask, props);
     } else if (from === "selection") {
       const sel = this.state.selection;
-      if (!_optionalChain([sel, 'optionalAccess', _247 => _247.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, or use reveal-all / hide-all.");
+      if (!_optionalChain([sel, 'optionalAccess', _249 => _249.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;
@@ -7280,7 +7863,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', _248 => _248.layer, 'access', _249 => _249.smartFilters, 'optionalAccess', _250 => _250.mask]), () => ( null));
+    return _nullishCoalesce(_optionalChain([res, 'access', _250 => _250.layer, 'access', _251 => _251.smartFilters, 'optionalAccess', _252 => _252.mask]), () => ( null));
   }
   /**
    * Decodes smart object contents that came as files the synchronous decoders cannot read (a JPEG
@@ -7328,7 +7911,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', _251 => _251.file, 'optionalAccess', _252 => _252.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', _253 => _253.file, 'optionalAccess', _254 => _254.type]), () => ( "file"))} that could not be decoded here; run prepareSmartObjects() in a browser first.`);
     const saved = {
       state: { ...this.state },
       undo: this.undoStack,
@@ -7359,9 +7942,9 @@ var ImageEditorController = (_class12 = class {
       editingContents: this.getEditingContents()
     };
     delete this.state.legacyOutputBlur;
-    if (_optionalChain([c, 'access', _253 => _253.document, 'optionalAccess', _254 => _254.globalLight])) this.state.globalLight = c.document.globalLight;
+    if (_optionalChain([c, 'access', _255 => _255.document, 'optionalAccess', _256 => _256.globalLight])) this.state.globalLight = c.document.globalLight;
     else delete this.state.globalLight;
-    if (_optionalChain([c, 'access', _255 => _255.document, 'optionalAccess', _256 => _256.patterns, 'optionalAccess', _257 => _257.length])) this.state.patterns = c.document.patterns;
+    if (_optionalChain([c, 'access', _257 => _257.document, 'optionalAccess', _258 => _258.patterns, 'optionalAccess', _259 => _259.length])) this.state.patterns = c.document.patterns;
     else delete this.state.patterns;
     this.imageElement = null;
     this.samplePixels = null;
@@ -7381,23 +7964,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', _258 => _258.openTransform, 'optionalAccess', _259 => _259.isOpen])) this.openTransform.cancel();
+    if (_optionalChain([this, 'access', _260 => _260.openTransform, 'optionalAccess', _261 => _261.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', _260 => _260.layer]);
-      const old = _optionalChain([layer, 'optionalAccess', _261 => _261.contents]);
+      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 { width, height } = edited.imageDimensions;
       const only = edited.layers.length === 1 ? edited.layers[0] : null;
-      const plain3 = _optionalChain([only, 'optionalAccess', _262 => _262.type]) === "pixel" && only.visible && only.opacity === 1 && only.blend === "normal" && !only.mask && !only.effects && !_optionalChain([only, 'access', _263 => _263.filters, 'optionalAccess', _264 => _264.length]) && !only.clipped && (_nullishCoalesce(only.fillOpacity, () => ( 1))) === 1 && only.source !== "document";
-      if (_optionalChain([old, 'optionalAccess', _265 => _265.kind]) === "raster" && plain3) {
+      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 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', _266 => _266.kind]) === "document" ? old.name : `${(_nullishCoalesce(_optionalChain([old, 'optionalAccess', _267 => _267.name]), () => ( "Contents"))).replace(/\.\w+$/, "")}.psb`, top.contentsId);
+        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);
       }
     }
     const saved = top.saved;
@@ -7422,7 +8005,7 @@ var ImageEditorController = (_class12 = class {
   }
   /** The document's own layers (not the contents open for editing). */
   rootLayers() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _268 => _268.contentsStack, 'access', _269 => _269[0], 'optionalAccess', _270 => _270.saved, 'access', _271 => _271.state, 'access', _272 => _272.layers]), () => ( this.state.layers));
+    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));
   }
   /** Drops every open contents edit (loading another document). */
   abandonContents() {
@@ -7643,7 +8226,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', _273 => _273.get, 'call', _274 => _274(key)]);
+    const hit = _optionalChain([byKey, 'optionalAccess', _275 => _275.get, 'call', _276 => _276(key)]);
     if (hit) return hit;
     const out = new Uint8ClampedArray(tw * th * 4);
     for (let y = 0; y < th; y++) {
@@ -7784,7 +8367,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', _275 => _275.smartFilters, 'optionalAccess', _276 => _276.mask])) {
+      if (layer.type !== "smart" || !_optionalChain([layer, 'access', _277 => _277.smartFilters, 'optionalAccess', _278 => _278.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.`);
@@ -7799,7 +8382,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', _277 => _277.locks, 'optionalAccess', _278 => _278.transparency]));
+    const lockTransparency = ch === "pixels" && Boolean(_optionalChain([layer, 'access', _279 => _279.locks, 'optionalAccess', _280 => _280.transparency]));
     return { id, layer, channel: ch, offset, surface, lockTransparency };
   }
   /** The layer with its pixels (or mask) replaced by `surface`. */
@@ -7843,13 +8426,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', _279 => _279.state, 'access', _280 => _280.selection, 'optionalAccess', _281 => _281.bounds]) ? this.state.selection : null,
+      selection: target.channel !== "quick-mask" && _optionalChain([this, 'access', _281 => _281.state, 'access', _282 => _282.selection, 'optionalAccess', _283 => _283.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', _282 => _282.type]) === "gradient" ? _chunkEBDCRTZIcjs.resolvePaintGradient.call(void 0, strokePaint, { paint: toHex(color), secondary: toHex(background) }) : null;
+    const gradient = tool === "brush" && _optionalChain([strokePaint, 'optionalAccess', _284 => _284.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. */
@@ -7896,9 +8479,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', _283 => _283.layer]);
+      const then = _optionalChain([_chunkHGTDMKNEcjs.findLayer.call(void 0, entry.layers, target.id), 'optionalAccess', _285 => _285.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', _284 => _284.mask, 'optionalAccess', _285 => _285.surface]) : then.type === "pixel" ? then.surface : void 0;
+      const surface = target.channel === "mask" ? _optionalChain([then, 'access', _286 => _286.mask, 'optionalAccess', _287 => _287.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;
@@ -7972,7 +8555,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', _286 => _286.tiles, 'access', _287 => _287.get, 'call', _288 => _288(_chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _289 => _289.data]), () => ( (surface.defaultValue ? defaultTile(surface) : null))), surface.channels, 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);
   }
   /** 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) {
@@ -8048,7 +8631,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', _290 => _290.x])) || !Number.isFinite(_optionalChain([p, 'optionalAccess', _291 => _291.y]))) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Every point needs finite x and y (document pixels).");
+      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).");
     }
     const session = this.beginStroke(init);
     session.push(init.points);
@@ -8077,7 +8660,7 @@ var ImageEditorController = (_class12 = class {
    */
   strokeSelection(options) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _292 => _292.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, then stroke the selection.");
+    if (!_optionalChain([sel, 'optionalAccess', _294 => _294.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"));
@@ -8094,7 +8677,7 @@ var ImageEditorController = (_class12 = class {
    */
   cropToSelection() {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _293 => _293.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select the area to keep, then crop to it.");
+    if (!_optionalChain([sel, 'optionalAccess', _295 => _295.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;
@@ -8108,7 +8691,7 @@ var ImageEditorController = (_class12 = class {
    */
   contentAwareFill(options = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _294 => _294.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select what to remove, then fill it.");
+    if (!_optionalChain([sel, 'optionalAccess', _296 => _296.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.`);
@@ -8173,8 +8756,8 @@ var ImageEditorController = (_class12 = class {
    */
   copyPixels(options = {}) {
     const { width, height } = this.naturalSize;
-    const sel = _optionalChain([this, 'access', _295 => _295.state, 'access', _296 => _296.selection, 'optionalAccess', _297 => _297.bounds]) ? this.state.selection : null;
-    const rect = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _298 => _298.bounds]), () => ( { x: 0, y: 0, width, height }));
+    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 }));
     let data;
     if (options.merged) {
       data = new Uint8ClampedArray(this.compositePixels(rect).data);
@@ -8214,7 +8797,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', _299 => _299.state, 'access', _300 => _300.selection, 'optionalAccess', _301 => _301.bounds]) ? this.state.selection : null;
+    const sel = _optionalChain([this, 'access', _301 => _301.state, 'access', _302 => _302.selection, 'optionalAccess', _303 => _303.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;
@@ -8223,7 +8806,7 @@ var ImageEditorController = (_class12 = class {
       x = image.x;
       y = image.y;
     } else {
-      const frame = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _302 => _302.bounds]), () => ( { x: 0, y: 0, width, height }));
+      const frame = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _304 => _304.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);
     }
@@ -8240,8 +8823,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', _303 => _303.state, 'access', _304 => _304.selection, 'optionalAccess', _305 => _305.bounds]) ? this.state.selection : null)));
-    const region = _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _306 => _306.bounds]), () => ( { x: 0, y: 0, width, height }));
+    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 coverage = new (0, _chunkEBDCRTZIcjs.CoverageMap)();
     const ones = new Float32Array(region.width * region.height);
     if (sel) {
@@ -8366,7 +8949,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', _307 => _307.parent, 'optionalAccess', _308 => _308.id]), () => ( null)), loc.index + 1);
+      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 (where.parentId) {
       const loc = _chunkHGTDMKNEcjs.findLayer.call(void 0, layers, where.parentId);
@@ -8377,11 +8960,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', _309 => _309.parent, 'optionalAccess', _310 => _310.id]), () => ( null)), loc.index);
+        return _chunkHGTDMKNEcjs.insertLayer.call(void 0, layers, node, _nullishCoalesce(_optionalChain([loc, 'access', _311 => _311.parent, 'optionalAccess', _312 => _312.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', _311 => _311.parent, 'optionalAccess', _312 => _312.id]), () => ( null)), loc.index + 1);
+        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, null, this.defaultInsertIndex(layers));
@@ -8420,7 +9003,7 @@ var ImageEditorController = (_class12 = class {
       enabled: spec.enabled,
       opacity: spec.opacity,
       blend: spec.blend,
-      mask: _nullishCoalesce(spec.mask, () => ( (spec.useSelection && _optionalChain([this, 'access', _313 => _313.state, 'access', _314 => _314.selection, 'optionalAccess', _315 => _315.bounds]) ? _chunkUYXL6ZWQcjs.layerMaskFromSelection.call(void 0, this.state.selection) : void 0)))
+      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)))
     });
     while (ids.has(layer.id)) layer.id = _chunkUYXL6ZWQcjs.newLayerId.call(void 0, "adj");
     const { width, height } = this.naturalSize;
@@ -8497,7 +9080,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', _316 => _316.parent, 'optionalAccess', _317 => _317.id]), () => ( null)), to > from ? loc.index + 1 : loc.index);
+    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);
   }
   /** Moves a layer to `toIndex` among the adjustment layers (0 = bottom) as one undo step. Returns false if nothing moved. */
   moveAdjustmentLayer(id, toIndex) {
@@ -8538,7 +9121,7 @@ var ImageEditorController = (_class12 = class {
     return _nullishCoalesce(this.state.selection, () => ( null));
   }
   get hasSelection() {
-    return Boolean(_optionalChain([this, 'access', _318 => _318.state, 'access', _319 => _319.selection, 'optionalAccess', _320 => _320.bounds]));
+    return Boolean(_optionalChain([this, 'access', _320 => _320.state, 'access', _321 => _321.selection, 'optionalAccess', _322 => _322.bounds]));
   }
   /** Returns the current canvas (composition) dimensions. */
   getCanvasSize() {
@@ -8630,7 +9213,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', _321 => _321.bounds])) this.lastSelection = prev;
+    if (!next && _optionalChain([prev, 'optionalAccess', _323 => _323.bounds])) this.lastSelection = prev;
     this.state.selection = next;
     this.notify();
     return true;
@@ -8673,14 +9256,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', _322 => _322.bounds])) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _324 => _324.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', _323 => _323.bounds])) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _325 => _325.bounds])) return false;
     const pixels = await this.requirePixels(options);
     return this.setSelection(selectSimilar(pixels, sel, options));
   }
@@ -8747,6 +9330,31 @@ var ImageEditorController = (_class12 = class {
     const pixels = await this.requirePixels(options);
     return snapPolygonToEdges(pixels, points, options);
   }
+  /**
+   * Quick Selection: each stroke (the brush's path in natural pixels) grows into the region it is
+   * painted on, out to that region's edges, and is combined with the selection by `mode`; with
+   * `replace`, the first stroke replaces it and the rest add, as the brush does. All strokes are
+   * one undo step. Resolves to the resulting selection.
+   */
+  async quickSelect(strokes, options = {}) {
+    if (!strokes.length || strokes.some((s) => !s.length)) throw new Error("Pass at least one stroke, each with at least one point.");
+    const { width, height } = this.naturalSize;
+    for (const s of strokes) {
+      if (!s.some((p) => p.x >= 0 && p.y >= 0 && p.x < width && p.y < height)) {
+        throw new Error(`A stroke lies entirely outside the image (0..${width - 1}, 0..${height - 1}); paint over the area to select.`);
+      }
+    }
+    const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
+    const mode = _nullishCoalesce(options.mode, () => ( "replace"));
+    let sel = _nullishCoalesce(this.state.selection, () => ( null));
+    strokes.forEach((stroke, i) => {
+      const m = mode === "replace" && i > 0 ? "add" : mode;
+      const region = quickSelectStroke(pixels, stroke, { size: options.size, selection: sel, grow: m === "add", enhanceEdge: options.enhanceEdge });
+      sel = _chunkUYXL6ZWQcjs.combineSelections.call(void 0, sel, region, m);
+    });
+    this.setSelection(sel, "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)
@@ -8768,7 +9376,7 @@ var ImageEditorController = (_class12 = class {
       try {
         const canvas = await this.renderSource();
         const ctx = canvas.getContext("2d");
-        const data2 = _optionalChain([ctx, 'optionalAccess', _324 => _324.getImageData, 'optionalCall', _325 => _325(0, 0, width, height)]);
+        const data2 = _optionalChain([ctx, 'optionalAccess', _326 => _326.getImageData, 'optionalCall', _327 => _327(0, 0, width, height)]);
         if (data2 && data2.data && data2.data.length >= width * height * 4) {
           base = { width, height, data: data2.data };
           this.samplePixels = base;
@@ -8843,7 +9451,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', _326 => _326.bounds])) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _328 => _328.bounds])) return false;
     return this.setSelection(_chunkUYXL6ZWQcjs.modifySelection.call(void 0, sel, op, radius));
   }
   /**
@@ -8852,7 +9460,7 @@ var ImageEditorController = (_class12 = class {
    */
   async refineSelection(params, options = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _327 => _327.bounds])) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _329 => _329.bounds])) return false;
     const pixels = (_nullishCoalesce(params.radius, () => ( 0))) > 0 ? await this.requirePixels(options) : null;
     return this.setSelection(refineSelection(pixels, sel, params));
   }
@@ -8883,7 +9491,7 @@ var ImageEditorController = (_class12 = class {
     let mask;
     if (source === "selection") {
       const sel = this.state.selection;
-      if (!_optionalChain([sel, 'optionalAccess', _328 => _328.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, or export a channel or a layer mask.");
+      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.");
       mask = sel;
     } else if ("channelId" in source) {
       mask = this.requireChannel(source.channelId).mask;
@@ -8907,7 +9515,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', _329 => _329.getImageData, 'optionalCall', _330 => _330(0, 0, w, h)]);
+    const data = _optionalChain([ctx, 'optionalAccess', _331 => _331.getImageData, 'optionalCall', _332 => _332(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 };
   }
@@ -8925,24 +9533,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', _331 => _331.signal, 'optionalAccess', _332 => _332.throwIfAborted, 'call', _333 => _333()]);
+    _optionalChain([options, 'access', _333 => _333.signal, 'optionalAccess', _334 => _334.throwIfAborted, 'call', _335 => _335()]);
     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', _334 => _334.bounds]), () => ( null)), ...r.score !== void 0 ? { score: r.score } : {} };
+      return { label: r.label || description, bounds: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _336 => _336.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', _335 => _335[i], 'optionalAccess', _336 => _336.bounds]);
+        const b = _optionalChain([segments, 'access', _337 => _337[i], 'optionalAccess', _338 => _338.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', _337 => _337.signal, 'optionalAccess', _338 => _338.throwIfAborted, 'call', _339 => _339()]);
+      _optionalChain([options, 'access', _339 => _339.signal, 'optionalAccess', _340 => _340.throwIfAborted, 'call', _341 => _341()]);
     }
     if (mask) this.shapeCommand(mask, options);
     return { segments: segments.filter((s) => s.bounds) };
@@ -8975,7 +9583,7 @@ var ImageEditorController = (_class12 = class {
     const view = this.state.maskView;
     if (!view) return null;
     const layer = this.getLayer(view.layerId);
-    return _optionalChain([layer, 'optionalAccess', _340 => _340.mask]) && !layer.mask.source ? view : null;
+    return _optionalChain([layer, 'optionalAccess', _342 => _342.mask]) && !layer.mask.source ? view : null;
   }
   /**
    * Shows a layer's mask on the canvas: `gray` alone in grey (Alt-click the mask thumbnail),
@@ -8998,7 +9606,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', _341 => _341.layerId]) !== id || cur.mode !== mode) {
+    if (_optionalChain([cur, 'optionalAccess', _343 => _343.layerId]) !== id || cur.mode !== mode) {
       this.state.maskView = { layerId: id, mode };
       this.notify();
     }
@@ -9010,7 +9618,7 @@ var ImageEditorController = (_class12 = class {
     return _nullishCoalesce(this.state.channels, () => ( []));
   }
   getChannel(id) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _342 => _342.state, 'access', _343 => _343.channels, 'optionalAccess', _344 => _344.find, 'call', _345 => _345((c) => c.id === id)]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _344 => _344.state, 'access', _345 => _345.channels, 'optionalAccess', _346 => _346.find, 'call', _347 => _347((c) => c.id === id)]), () => ( null));
   }
   requireChannel(id) {
     const channel = this.getChannel(id);
@@ -9039,14 +9647,14 @@ var ImageEditorController = (_class12 = class {
    */
   saveSelection(options = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _346 => _346.bounds])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)("Nothing is selected; select first, then save the selection to a channel.");
+    if (!_optionalChain([sel, 'optionalAccess', _348 => _348.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', _347 => _347.name, 'optionalAccess', _348 => _348.trim, 'call', _349 => _349()]) ? { name: options.name.trim() } : {} };
+      const next = { ...existing, mask, ..._optionalChain([options, 'access', _349 => _349.name, 'optionalAccess', _350 => _350.trim, 'call', _351 => _351()]) ? { name: options.name.trim() } : {} };
       this.setChannels(channels.map((c) => c.id === existing.id ? next : c));
       return next;
     }
@@ -9057,7 +9665,7 @@ var ImageEditorController = (_class12 = class {
     const channels = this.getChannels();
     const channel = {
       id: this.newChannelId(),
-      name: _optionalChain([name, 'optionalAccess', _350 => _350.trim, 'call', _351 => _351()]) || `Alpha ${channels.length + 1}`,
+      name: _optionalChain([name, 'optionalAccess', _352 => _352.trim, 'call', _353 => _353()]) || `Alpha ${channels.length + 1}`,
       mask,
       color: DEFAULT_CHANNEL_COLOR,
       opacity: 0.5,
@@ -9102,7 +9710,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', _352 => _352.trim, 'call', _353 => _353()]) || `${channel.name} copy` };
+    const copy = { ...channel, id: this.newChannelId(), name: _optionalChain([name, 'optionalAccess', _354 => _354.trim, 'call', _355 => _355()]) || `${channel.name} copy` };
     const channels = [...this.getChannels()];
     channels.splice(channels.findIndex((c) => c.id === id) + 1, 0, copy);
     this.setChannels(channels);
@@ -9133,7 +9741,7 @@ var ImageEditorController = (_class12 = class {
   quickMaskSurface() {
     const { width, height } = this.naturalSize;
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _354 => _354.bounds])) return _chunkCWM3CUUXcjs.emptySurface.call(void 0, 1, 0);
+    if (!_optionalChain([sel, 'optionalAccess', _356 => _356.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). */
@@ -9154,7 +9762,7 @@ var ImageEditorController = (_class12 = class {
    */
   applySelectionAsLayerMask(layerId, props = {}) {
     const sel = this.state.selection;
-    if (!_optionalChain([sel, 'optionalAccess', _355 => _355.bounds]) || !this.getAdjustmentLayer(layerId)) return false;
+    if (!_optionalChain([sel, 'optionalAccess', _357 => _357.bounds]) || !this.getAdjustmentLayer(layerId)) return false;
     return this.setLayerMask(layerId, this.maskFromSelection(sel, props));
   }
   setLayerMask(layerId, mask, commitToHistory = true) {
@@ -9194,7 +9802,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', _356 => _356.mask]) || layer.mask.source) return null;
+    if (!_optionalChain([layer, 'optionalAccess', _358 => _358.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;
@@ -9229,7 +9837,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', _357 => _357.mask, 'optionalAccess', _358 => _358.source])) delete next.mask;
+          if (_optionalChain([next, 'access', _359 => _359.mask, 'optionalAccess', _360 => _360.source])) delete next.mask;
         } else next.mask = _chunkUYXL6ZWQcjs.depthRasterMask.call(void 0, merged);
         return next;
       });
@@ -9239,7 +9847,7 @@ var ImageEditorController = (_class12 = class {
   resetDepthMask() {
     this.recordHistory();
     const target = this.developLayer();
-    if (_optionalChain([target, 'optionalAccess', _359 => _359.mask, 'optionalAccess', _360 => _360.source])) {
+    if (_optionalChain([target, 'optionalAccess', _361 => _361.mask, 'optionalAccess', _362 => _362.source])) {
       this.state.layers = _chunkHGTDMKNEcjs.mapLayer.call(void 0, this.state.layers, target.id, (l) => {
         const next = { ...l };
         delete next.mask;
@@ -9251,7 +9859,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', _361 => _361.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', _363 => _363.id]) === id);
   }
   /** What migrating an annotation needs: the canvas size, patterns and the text shaper. */
   annotationEnv() {
@@ -9269,7 +9877,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', _362 => _362.parent, 'optionalAccess', _363 => _363.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', _364 => _364.parent, 'optionalAccess', _365 => _365.id]), () => ( null)), loc.index + 1) : _chunkHGTDMKNEcjs.insertLayer.call(void 0, this.state.layers, layer, null);
     this.state.selectedAnnotationId = id;
     this.notify();
     return id;
@@ -9392,7 +10000,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', _364 => _364.cloneSourceMarker]) !== void 0 ? options.cloneSourceMarker : _optionalChain([options, 'optionalAccess', _365 => _365.brushCursor]) ? this.cloneSourceMarker(options.brushCursor) : null,
+        cloneSourceMarker: _optionalChain([options, 'optionalAccess', _366 => _366.cloneSourceMarker]) !== void 0 ? options.cloneSourceMarker : _optionalChain([options, 'optionalAccess', _367 => _367.brushCursor]) ? this.cloneSourceMarker(options.brushCursor) : null,
         dirty: dirty === "all" ? void 0 : dirty,
         checkpointLayerId: this.state.activeLayerId
       });
@@ -9405,7 +10013,7 @@ var ImageEditorController = (_class12 = class {
       return this.renderer.createCanvas(1, 1);
     }
     this.syncViews();
-    if (_optionalChain([options, 'optionalAccess', _366 => _366.layerIds])) {
+    if (_optionalChain([options, 'optionalAccess', _368 => _368.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);
@@ -9559,7 +10167,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', _367 => _367.state, 'access', _368 => _368.selection, 'optionalAccess', _369 => _369.bounds]) ? this.state.selection : null;
+    const sel = _optionalChain([this, 'access', _369 => _369.state, 'access', _370 => _370.selection, 'optionalAccess', _371 => _371.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 } });
   }
@@ -9606,7 +10214,7 @@ var ImageEditorController = (_class12 = class {
   }
   /** Font families the shaper offers (generic families at least). */
   listFonts() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _370 => _370.getTextShaper, 'call', _371 => _371(), 'optionalAccess', _372 => _372.families, 'optionalCall', _373 => _373()]), () => ( ["sans-serif", "serif", "monospace"]));
+    return _nullishCoalesce(_optionalChain([this, 'access', _372 => _372.getTextShaper, 'call', _373 => _373(), 'optionalAccess', _374 => _374.families, 'optionalCall', _375 => _375()]), () => ( ["sans-serif", "serif", "monospace"]));
   }
   typeInfo(id) {
     const layer = _chunkUYXL6ZWQcjs.requireTypeLayer.call(void 0, this.state.layers, id);
@@ -9680,8 +10288,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', _374 => _374.x]), () => ( 0)));
-    const y0 = Math.max(0, _nullishCoalesce(_optionalChain([b, 'optionalAccess', _375 => _375.y]), () => ( 0)));
+    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 x1 = Math.min(width, b ? b.x + b.width : 0);
     const y1 = Math.min(height, b ? b.y + b.height : 0);
     let mask;
@@ -9858,7 +10466,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', _376 => _376.runs, 'access', _377 => _377.find, 'call', _378 => _378((r) => r.length > 0), 'optionalAccess', _379 => _379.style]), () => ( _chunkBRKVNXDZcjs.DEFAULT_TEXT_STYLE));
+    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 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 };
@@ -9891,7 +10499,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', _380 => _380.state, 'access', _381 => _381.patterns, 'optionalAccess', _382 => _382.find, 'call', _383 => _383((p) => p.id === id)]), () => ( null)) };
+    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)) };
   }
   /** One component from tool or UI input (validated). */
   componentFrom(spec, path) {
@@ -9934,9 +10542,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', _384 => _384.components, 'optionalAccess', _385 => _385.length]) ? init.components : [init];
-    if (_optionalChain([init, 'access', _386 => _386.components, 'optionalAccess', _387 => _387.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', _388 => _388.components, 'optionalAccess', _389 => _389.length]) ? `components[${i}].` : ""));
+    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 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");
@@ -10047,7 +10655,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', _390 => _390.filters, 'optionalAccess', _391 => _391.length])) throw new (0, _chunkUYXL6ZWQcjs.LayerOperationError)(`Layer "${layer.name || id}" is already pixels with no filters to bake.`);
+      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.`);
       _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" };
@@ -10066,7 +10674,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', _392 => _392.annotation, 'optionalAccess', _393 => _393.id])) this.state.selectedAnnotationId = null;
+      if (this.state.selectedAnnotationId && this.state.selectedAnnotationId === _optionalChain([layer, 'access', _394 => _394.annotation, 'optionalAccess', _395 => _395.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.`);
     }
@@ -10080,8 +10688,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', _394 => _394.name]), () => ( p.description)), builtin: doc ? _nullishCoalesce(doc.builtin, () => ( null)) : "srgb", colorSpace: p.colorSpace, srgb: isSrgb(doc), mode: _nullishCoalesce(_optionalChain([m, 'optionalAccess', _395 => _395.mode]), () => ( "rgb")) };
-    if (_optionalChain([m, 'optionalAccess', _396 => _396.mode]) === "cmyk") out.cmykProfile = { name: m.profile.name, builtin: _nullishCoalesce(m.profile.builtin, () => ( null)), intent: m.intent };
+    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 };
     return out;
   }
   /**
@@ -10171,7 +10779,7 @@ var ImageEditorController = (_class12 = class {
     const textEnv = this.textEnv();
     const walk = (layers) => layers.map((l) => {
       let next2 = l;
-      if (_optionalChain([l, 'access', _397 => _397.effects, 'optionalAccess', _398 => _398.items, 'access', _399 => _399.length])) next2 = { ...next2, effects: convertColorFields(l.effects, hex) };
+      if (_optionalChain([l, 'access', _399 => _399.effects, 'optionalAccess', _400 => _400.items, 'access', _401 => _401.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) };
@@ -10355,8 +10963,8 @@ var ImageEditorController = (_class12 = class {
     else delete s.bitDepth;
     delete s.colorProfile;
     delete s.colorMode;
-    if (_optionalChain([result, 'access', _400 => _400.sourceMode, 'optionalAccess', _401 => _401.mode]) === "cmyk") s.colorMode = { mode: "cmyk", profile: result.sourceMode.profile, intent: "relative" };
-    else if (_optionalChain([result, 'access', _402 => _402.sourceMode, 'optionalAccess', _403 => _403.mode]) === "lab") s.colorMode = { mode: "lab" };
+    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" };
     else if (result.iccProfile) {
       try {
         const doc = documentProfile(result.iccProfile);
@@ -10420,7 +11028,7 @@ var ImageEditorController = (_class12 = class {
     const compositor = new (0, _chunkUYXL6ZWQcjs.LayerCompositor)();
     const bakeMask = (layer) => {
       const mask = layer.mask;
-      if (!_optionalChain([mask, 'optionalAccess', _404 => _404.source])) return mask;
+      if (!_optionalChain([mask, 'optionalAccess', _406 => _406.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;
@@ -10437,7 +11045,7 @@ var ImageEditorController = (_class12 = class {
     };
     const prepare = async (layer) => {
       const p = await prepareLayer(layer);
-      if (_optionalChain([p, 'optionalAccess', _405 => _405.blend]) === "pigment") add2("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
+      if (_optionalChain([p, 'optionalAccess', _407 => _407.blend]) === "pigment") add2("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
       return p;
     };
     const prepareLayer = async (layer) => {
@@ -10480,7 +11088,7 @@ var ImageEditorController = (_class12 = class {
         return out2;
       }
       if (layer.type === "shape" || layer.type === "type") {
-        if (layer.type === "type" && _optionalChain([layer, 'access', _406 => _406.missingFonts, 'optionalAccess', _407 => _407.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', _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);
         const out2 = { ...layer };
         const mask2 = bakeMask(layer);
         if (mask2) out2.mask = mask2;
@@ -10499,7 +11107,7 @@ var ImageEditorController = (_class12 = class {
         out.surface = this.surfaceOf(layer);
         delete out.source;
       }
-      const active = _nullishCoalesce(_optionalChain([layer, 'access', _408 => _408.filters, 'optionalAccess', _409 => _409.filter, 'call', _410 => _410(_chunkUYXL6ZWQcjs.isActiveFilter)]), () => ( []));
+      const active = _nullishCoalesce(_optionalChain([layer, 'access', _410 => _410.filters, 'optionalAccess', _411 => _411.filter, 'call', _412 => _412(_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" };
@@ -10510,7 +11118,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', _411 => _411.filters, 'optionalAccess', _412 => _412.some, 'call', _413 => _413((f) => !f.enabled)])) add2("Disabled layer filters were left out", layer.name);
+      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);
       delete out.filters;
       const mask = bakeMask(layer);
       if (mask) out.mask = mask;
@@ -10574,7 +11182,7 @@ var ImageEditorController = (_class12 = class {
         );
       }
       layers = resizeLegacyMasks(layers, prev, next.dimensions);
-      const env = { ...next.dimensions, pattern: (pid) => _nullishCoalesce(_optionalChain([this, 'access', _414 => _414.state, 'access', _415 => _415.patterns, 'optionalAccess', _416 => _416.find, 'call', _417 => _417((p) => p.id === pid)]), () => ( null)) };
+      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)) };
       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) }));
@@ -10583,7 +11191,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', _418 => _418.components]), () => ( _chunkUYXL6ZWQcjs.transformShapeComponents.call(void 0, l.components, (p) => ({ x: p.x * sx, y: p.y * sy }), m)));
+          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 moved = { ...l, components, ...fromAnnotation ? { fill: fromAnnotation.fill, stroke: fromAnnotation.stroke } : {} };
           if (scaled && fromAnnotation) moved.annotation = scaled;
           else delete moved.annotation;
@@ -10601,7 +11209,7 @@ var ImageEditorController = (_class12 = class {
     this.notify();
   }
   toJSON(options) {
-    const root = _optionalChain([this, 'access', _419 => _419.contentsStack, 'access', _420 => _420[0], 'optionalAccess', _421 => _421.saved]);
+    const root = _optionalChain([this, 'access', _421 => _421.contentsStack, 'access', _422 => _422[0], 'optionalAccess', _423 => _423.saved]);
     const current = this.state;
     const element = this.imageElement;
     if (root) {
@@ -10612,8 +11220,8 @@ var ImageEditorController = (_class12 = class {
     let out;
     try {
       out = this.serializeState();
-      if (_optionalChain([this, 'access', _422 => _422.state, 'access', _423 => _423.selection, 'optionalAccess', _424 => _424.bounds])) out.selection = _chunkUYXL6ZWQcjs.serializeSelection.call(void 0, this.state.selection);
-      if (_optionalChain([this, 'access', _425 => _425.state, 'access', _426 => _426.channels, 'optionalAccess', _427 => _427.length])) out.channels = serializeChannels(this.state.channels);
+      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);
     } finally {
       if (root) {
         this.state = current;
@@ -10727,10 +11335,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', _428 => _428.state, 'access', _429 => _429.patterns, 'optionalAccess', _430 => _430.length]) && this.bitDepth === 8 && !this.state.colorProfile && !this.state.colorMode) {
+    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) {
       return {
         // States without adjustment layers keep schema 1, so they round-trip unchanged.
-        version: _optionalChain([view, 'access', _431 => _431.adjustments, 'access', _432 => _432.layers, 'optionalAccess', _433 => _433.length]) ? 2 : 1,
+        version: _optionalChain([view, 'access', _433 => _433.adjustments, 'access', _434 => _434.layers, 'optionalAccess', _435 => _435.length]) ? 2 : 1,
         crop: this.state.crop ? { ...this.state.crop } : null,
         transform: { ...this.state.transform },
         adjustments: serializeAdjustments(view.adjustments),
@@ -10755,7 +11363,7 @@ 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', _434 => _434.state, 'access', _435 => _435.patterns, 'optionalAccess', _436 => _436.length])) out.patterns = _chunkUYXL6ZWQcjs.serializePatterns.call(void 0, this.state.patterns);
+    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 (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);
@@ -10765,7 +11373,7 @@ var ImageEditorController = (_class12 = class {
 }, _class12);
 function serializeAdjustments(adjustments) {
   const out = { ...adjustments };
-  if (_optionalChain([out, 'access', _437 => _437.layers, 'optionalAccess', _438 => _438.length])) out.layers = JSON.parse(JSON.stringify(out.layers));
+  if (_optionalChain([out, 'access', _439 => _439.layers, 'optionalAccess', _440 => _440.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;
@@ -10801,11 +11409,11 @@ function withDevelop(layer, partial) {
   return { ...layer, filters };
 }
 function withBlur(layer, radius) {
-  const existing = _optionalChain([layer, 'access', _439 => _439.filters, 'optionalAccess', _440 => _440.find, 'call', _441 => _441((f) => f.kind === "blur")]);
+  const existing = _optionalChain([layer, 'access', _441 => _441.filters, 'optionalAccess', _442 => _442.find, 'call', _443 => _443((f) => f.kind === "blur")]);
   const filters = (_nullishCoalesce(layer.filters, () => ( []))).filter((f) => f.kind !== "blur");
   if (radius > 0) {
     filters.push({
-      id: _nullishCoalesce(_optionalChain([existing, 'optionalAccess', _442 => _442.id]), () => ( (layer.source === "document" ? _chunkUYXL6ZWQcjs.BLUR_FILTER_ID : _chunkUYXL6ZWQcjs.newLayerId.call(void 0, "flt")))),
+      id: _nullishCoalesce(_optionalChain([existing, 'optionalAccess', _444 => _444.id]), () => ( (layer.source === "document" ? _chunkUYXL6ZWQcjs.BLUR_FILTER_ID : _chunkUYXL6ZWQcjs.newLayerId.call(void 0, "flt")))),
       kind: "blur",
       enabled: true,
       radius
@@ -10901,7 +11509,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', _443 => _443.smartFilters, 'optionalAccess', _444 => _444.mask])) _chunkCWM3CUUXcjs.collectTiles.call(void 0, l.smartFilters.mask.surface, into);
+      if (_optionalChain([l, 'access', _445 => _445.smartFilters, 'optionalAccess', _446 => _446.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);
     }
@@ -10933,7 +11541,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', _445 => _445.filters, 'optionalAccess', _446 => _446.length])) {
+    else if (l.type === "pixel" && _optionalChain([l, 'access', _447 => _447.filters, 'optionalAccess', _448 => _448.length])) {
       const p = { ...l };
       delete p.filters;
       out.push(p);
@@ -10999,7 +11607,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', _447 => _447.bounds]) ? mask : null;
+  return _optionalChain([mask, 'optionalAccess', _449 => _449.bounds]) ? mask : null;
 }
 function sameSelection(a, b) {
   if (a.width !== b.width || a.height !== b.height) return false;
@@ -11209,7 +11817,7 @@ function loadImageEditorDocument(input) {
   }
   const state = { version: 1, ...result.value };
   if (isV2) {
-    if (_optionalChain([state, 'access', _448 => _448.adjustments, 'access', _449 => _449.layers, 'optionalAccess', _450 => _450.length])) state.version = 2;
+    if (_optionalChain([state, 'access', _450 => _450.adjustments, 'access', _451 => _451.layers, 'optionalAccess', _452 => _452.length])) state.version = 2;
     result.report.version = 2;
   }
   if (state.selection === void 0) delete state.selection;
@@ -11417,7 +12025,7 @@ function findAdjustmentControl(id) {
 }
 function findLayerControl(kind, id) {
   if (id === "opacity") return ADJUSTMENT_LAYER_OPACITY_CONTROL;
-  return _optionalChain([ADJUSTMENT_LAYER_CONTROLS, 'access', _451 => _451[kind], 'optionalAccess', _452 => _452.find, 'call', _453 => _453((c) => c.id === id)]);
+  return _optionalChain([ADJUSTMENT_LAYER_CONTROLS, 'access', _453 => _453[kind], 'optionalAccess', _454 => _454.find, 'call', _455 => _455((c) => c.id === id)]);
 }
 function clampControlValue(spec, v) {
   if (typeof v !== "number" || !Number.isFinite(v)) return spec.default;
@@ -11634,7 +12242,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|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_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)$/;
@@ -11756,6 +12364,7 @@ var SELECTION_TOOLS = [
   { id: "lasso", label: "Lasso" },
   { id: "polygon", label: "Polygonal Lasso" },
   { id: "magnetic", label: "Magnetic Lasso" },
+  { id: "quick", label: "Quick Selection" },
   { id: "range", label: "Color Range" },
   { id: "type", label: "Type Mask" },
   { id: "type-vertical", label: "Vertical Type Mask" }
@@ -11793,6 +12402,9 @@ var DEFAULT_SELECTION_TOOL_OPTIONS = {
   magneticWidth: 10,
   magneticContrast: 10,
   magneticFrequency: 57,
+  quickSize: 30,
+  quickSampleAll: true,
+  quickEnhance: false,
   typeText: "Type",
   typeSize: 72,
   typeFamily: "sans-serif"
@@ -11865,7 +12477,7 @@ function summary(controller) {
   const area = _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel);
   return {
     empty: !sel,
-    bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _454 => _454.bounds]), () => ( null)),
+    bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _456 => _456.bounds]), () => ( null)),
     /** Σ coverage in pixels. */
     area: Math.round(area),
     percent: Math.round(area / Math.max(1, width * height) * 1e4) / 100,
@@ -11941,7 +12553,7 @@ function createImageSelectionTools(controller) {
           break;
         }
         case "polygon": {
-          const list = Array.isArray(points) ? points.map((p) => ({ x: num2(_optionalChain([p, 'optionalAccess', _455 => _455.x]), NaN), y: num2(_optionalChain([p, 'optionalAccess', _456 => _456.y]), NaN) })) : [];
+          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) })) : [];
           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.");
           }
@@ -12178,7 +12790,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', _457 => _457.x]), NaN), y: num2(_optionalChain([p, 'optionalAccess', _458 => _458.y]), NaN) })) : [];
+      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) })) : [];
       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.");
       }
@@ -12192,6 +12804,42 @@ function createImageSelectionTools(controller) {
       return { ...summary(controller), outlinePoints: outline.length };
     }
   };
+  const quickSelectTool = {
+    name: "quick_select",
+    title: "Quick Selection",
+    description: "Quick Selection: paints brush strokes (paths in natural image pixels) that each grow into the region they are painted on, out to its edges (a graph cut on colour and edges), combined with the selection by mode. With replace (default) the first stroke replaces the selection and later ones add, as the brush does; use mode subtract to take an area back out. Best for a subject or area that differs from its surroundings: paint inside it, away from the edge, then check with get_selection and capture_view and add or subtract strokes where it leaked or fell short. All strokes are one undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        strokes: {
+          type: "array",
+          minItems: 1,
+          items: { type: "array", minItems: 1, items: pointSchema, description: "One stroke: the brush path, in order (one point is a dab)." },
+          description: "Brush strokes in natural image pixels, applied in order."
+        },
+        size: { type: "number", minimum: 1, maximum: 2500, description: "Brush diameter in natural image pixels (default 30). Smaller for a narrow area, larger for a broad one." },
+        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). Use it before masking a smooth-edged subject." }
+      },
+      required: ["strokes"],
+      additionalProperties: false
+    },
+    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) })) : []) : [];
+      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.");
+      }
+      await controller.quickSelect(strokes, {
+        size: args.size === void 0 ? void 0 : num2(args.size, 30),
+        mode: _chunkUYXL6ZWQcjs.parseSelectionMode.call(void 0, args.mode),
+        sampleAllLayers: args.sampleAllLayers,
+        enhanceEdge: args.enhanceEdge
+      });
+      return summary(controller);
+    }
+  };
   const magicWandTool = {
     name: "magic_wand",
     title: "Magic wand",
@@ -12285,7 +12933,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', _459 => _459.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', _463 => _463.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 };
         });
@@ -12744,6 +13392,7 @@ function createImageSelectionTools(controller) {
     selectRect,
     selectEllipse,
     selectPolygonTool,
+    quickSelectTool,
     lineTool,
     magicWandTool,
     colorRangeTool,
@@ -12800,12 +13449,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', _460 => _460.perform]);
+      const perform = _optionalChain([context, 'optionalAccess', _464 => _464.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', _461 => _461.signal]),
+        signal: _optionalChain([context, 'optionalAccess', _465 => _465.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
       });
@@ -12884,7 +13533,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', _462 => _462.bounds]) && selection.width === state.imageDimensions.width && selection.height === state.imageDimensions.height) {
+    if (_optionalChain([selection, 'optionalAccess', _466 => _466.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);
     }
@@ -12909,7 +13558,7 @@ function createImageCaptureSurface(controller) {
   return {
     units: "image pixels",
     content: whole,
-    selection: () => ({ rect: _nullishCoalesce(_optionalChain([controller, 'access', _463 => _463.getState, 'call', _464 => _464(), 'access', _465 => _465.selection, 'optionalAccess', _466 => _466.bounds]), () => ( null)) }),
+    selection: () => ({ rect: _nullishCoalesce(_optionalChain([controller, 'access', _467 => _467.getState, 'call', _468 => _468(), 'access', _469 => _469.selection, 'optionalAccess', _470 => _470.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)
@@ -13243,7 +13892,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', _467 => _467.live, 'optionalAccess', _468 => _468.kind]), () => ( "path")) })),
+        components: layer.components.map((c) => ({ op: c.op, kind: _nullishCoalesce(_optionalChain([c, 'access', _471 => _471.live, 'optionalAccess', _472 => _472.kind]), () => ( "path")) })),
         fill: layer.fill ? layer.fill.type : null,
         stroke: layer.stroke ? { width: layer.stroke.width, paint: layer.stroke.paint.type } : null
       };
@@ -13266,8 +13915,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', _469 => _469.smartFilters, 'optionalAccess', _470 => _470.filters]), () => ( []))).map((f) => ({ id: f.id, kind: f.kind, enabled: f.enabled }));
-      out.filterMask = maskSummary(_optionalChain([layer, 'access', _471 => _471.smartFilters, 'optionalAccess', _472 => _472.mask]));
+      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]));
       break;
   }
   return out;
@@ -13295,7 +13944,7 @@ function createImageLayerTools(controller) {
     if (!loc) return null;
     return {
       ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)),
-      parentId: _nullishCoalesce(_optionalChain([loc, 'access', _473 => _473.parent, 'optionalAccess', _474 => _474.id]), () => ( null)),
+      parentId: _nullishCoalesce(_optionalChain([loc, 'access', _477 => _477.parent, 'optionalAccess', _478 => _478.id]), () => ( null)),
       index: loc.index
     };
   };
@@ -13618,7 +14267,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', _475 => _475.mode]), () => ( "off")), layerId: _nullishCoalesce(_optionalChain([shown, 'optionalAccess', _476 => _476.layerId]), () => ( null)) };
+      return { view: _nullishCoalesce(_optionalChain([shown, 'optionalAccess', _479 => _479.mode]), () => ( "off")), layerId: _nullishCoalesce(_optionalChain([shown, 'optionalAccess', _480 => _480.layerId]), () => ( null)) };
     }
   };
   const maskProps = {
@@ -14112,7 +14761,7 @@ function snapTo45(from, point) {
   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);
+  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);
     this.controller = controller;
     this.getOptions = getOptions;
   }
@@ -14131,9 +14780,14 @@ var SelectionGesture = (_class13 = class {
   __init110() {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()}
   get active() {
     return this.start !== null || this.polygon !== null || this.magnetic !== null;
   }
+  /** Resolves once a Quick Selection stroke has been applied. */
+  get settled() {
+    return this.pending;
+  }
   /** The anchors of a Magnetic Lasso being drawn (empty otherwise). */
   get magneticAnchors() {
     const m = this.magnetic;
@@ -14145,7 +14799,7 @@ var SelectionGesture = (_class13 = class {
     if (this.polygon) return this.current ? [...this.polygon, this.current] : this.polygon.slice();
     if (!this.start || !this.current) return null;
     const { tool } = this.getOptions();
-    if (tool === "lasso") return this.points.length > 1 ? this.points.slice() : null;
+    if (tool === "lasso" || tool === "quick") return this.points.length > 1 ? this.points.slice() : null;
     const rect = normalizeRect({
       x: this.start.x,
       y: this.start.y,
@@ -14279,7 +14933,8 @@ var SelectionGesture = (_class13 = class {
     }
     if (!this.start) return false;
     this.current = point;
-    if (this.getOptions().tool === "lasso") {
+    const drawn = this.getOptions().tool;
+    if (drawn === "lasso" || drawn === "quick") {
       const last = this.points[this.points.length - 1];
       if (Math.hypot(point.x - last.x, point.y - last.y) < 0.5) return false;
       this.points.push(point);
@@ -14299,6 +14954,25 @@ 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 === "quick") {
+      const stroke = this.points;
+      this.start = null;
+      this.current = null;
+      this.points = [];
+      const strokeMode = mode === "replace" && this.controller.getSelection() ? "add" : mode;
+      this.pending = this.controller.quickSelect([stroke], {
+        size: _nullishCoalesce(options.quickSize, () => ( 30)),
+        mode: strokeMode,
+        sampleAllLayers: _nullishCoalesce(options.quickSampleAll, () => ( true)),
+        enhanceEdge: _nullishCoalesce(options.quickEnhance, () => ( false))
+      }).then(
+        () => void 0,
+        (err) => {
+          this.error = err instanceof Error ? err.message : String(err);
+        }
+      );
+      return false;
+    }
     const path = this.draftPath;
     const rect = normalizeRect({
       x: this.start.x,
@@ -14441,7 +15115,7 @@ function handleSelectionShortcut(controller, e, onError) {
     try {
       fn();
     } catch (err) {
-      _optionalChain([onError, 'optionalCall', _477 => _477(err instanceof Error ? err.message : String(err))]);
+      _optionalChain([onError, 'optionalCall', _481 => _481(err instanceof Error ? err.message : String(err))]);
     }
     return true;
   };
@@ -14456,9 +15130,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', _478 => _478.mask]) || layer.mask.source) return false;
+  if (!_optionalChain([layer, 'optionalAccess', _482 => _482.mask]) || layer.mask.source) return false;
   const view = controller.getMaskView();
-  controller.setMaskView(_optionalChain([view, 'optionalAccess', _479 => _479.layerId]) === layer.id && view.mode === "overlay" ? "off" : "overlay", layer.id);
+  controller.setMaskView(_optionalChain([view, 'optionalAccess', _483 => _483.layerId]) === layer.id && view.mode === "overlay" ? "off" : "overlay", layer.id);
   return true;
 }
 function handleQuickMaskKey(controller, e) {
@@ -14653,14 +15327,14 @@ function handlePaintShortcut(controller, e) {
   return false;
 }
 var PaintGesture = (_class14 = class {
-  constructor(controller) {;_class14.prototype.__init112.call(this);_class14.prototype.__init113.call(this);_class14.prototype.__init114.call(this);
+  constructor(controller) {;_class14.prototype.__init113.call(this);_class14.prototype.__init114.call(this);_class14.prototype.__init115.call(this);
     this.controller = controller;
   }
   
-  __init112() {this.stroke = null}
-  __init113() {this.move = null}
+  __init113() {this.stroke = null}
+  __init114() {this.move = null}
   /** The last refusal (e.g. "layer is locked"), for the editor to show. */
-  __init114() {this.error = null}
+  __init115() {this.error = null}
   get active() {
     return Boolean(this.stroke || this.move);
   }
@@ -14672,7 +15346,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', _480 => _480.locks, 'optionalAccess', _481 => _481.all]) || _optionalChain([layer, 'access', _482 => _482.locks, 'optionalAccess', _483 => _483.position])) throw new Error(`Layer "${layer.name}" has its position locked.`);
+        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.`);
         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 };
@@ -14729,7 +15403,7 @@ var PaintGesture = (_class14 = class {
     this.move = null;
   }
   cancel() {
-    _optionalChain([this, 'access', _484 => _484.stroke, 'optionalAccess', _485 => _485.cancel, 'call', _486 => _486()]);
+    _optionalChain([this, 'access', _488 => _488.stroke, 'optionalAccess', _489 => _489.cancel, 'call', _490 => _490()]);
     this.stroke = null;
     this.move = null;
   }
@@ -15154,7 +15828,7 @@ function checkSource(controller, source) {
   }
   return p;
 }
-var SOURCE = {
+var SOURCE2 = {
   type: "object",
   description: "Source point in document pixels (an Alt-click). Given, it replaces the clone source and the offset starts afresh at this stroke; missing, the current clone source is used (set_clone_source).",
   properties: { x: { type: "number", description: "Source x in px." }, y: { type: "number", description: "Source y in px." } },
@@ -15178,7 +15852,7 @@ function createImageRetouchTools(controller) {
       type: "object",
       properties: {
         points: POINTS,
-        source: SOURCE,
+        source: SOURCE2,
         aligned: { type: "boolean", description: "Keep the offset for the next strokes (default the current option, true)." },
         sample: SAMPLE,
         brush: BRUSH2,
@@ -15198,7 +15872,7 @@ function createImageRetouchTools(controller) {
       type: "object",
       properties: {
         points: POINTS,
-        source: SOURCE,
+        source: SOURCE2,
         aligned: { type: "boolean", description: "Keep the offset for the next strokes (default the current option, true)." },
         sample: SAMPLE,
         brush: BRUSH2,
@@ -15810,7 +16484,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', _487 => _487.parent, 'optionalAccess', _488 => _488.id]), () => ( null)), index: loc.index } : null;
+    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;
   };
   const getSmart = {
     name: "get_smart_object",
@@ -16367,7 +17041,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', _489 => _489.parent, 'optionalAccess', _490 => _490.id]), () => ( null)), index: loc.index } : null;
+    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;
   };
   const get = {
     name: "get_shape_layer",
@@ -16584,7 +17258,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', _491 => _491.bounds]), () => ( null)), area: Math.round(sel ? _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel) : 0) };
+      return { empty: !sel, bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _495 => _495.bounds]), () => ( null)), area: Math.round(sel ? _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel) : 0) };
     }
   };
   const getVectorMask = {
@@ -16615,7 +17289,7 @@ function createImageShapeTools(controller) {
     handler: (args) => {
       const id = layerArg(args.layerId);
       const spec = pathSpec(args);
-      const hasPath = _optionalChain([spec, 'access', _492 => _492.components, 'optionalAccess', _493 => _493.length]) || spec.shape !== void 0 || spec.subpaths !== void 0;
+      const hasPath = _optionalChain([spec, 'access', _496 => _496.components, 'optionalAccess', _497 => _497.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));
@@ -16735,7 +17409,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', _494 => _494.parent, 'optionalAccess', _495 => _495.id]), () => ( null)), index: loc.index } : null;
+    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;
   };
   const range = (args) => ({ start: args.start, end: args.end });
   const listFonts = {
@@ -16744,7 +17418,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', _496 => _496.getTextShaper, 'call', _497 => _497(), 'optionalAccess', _498 => _498.id]), () => ( null)) })
+    handler: () => ({ families: controller.listFonts(), shaper: _nullishCoalesce(_optionalChain([controller, 'access', _500 => _500.getTextShaper, 'call', _501 => _501(), 'optionalAccess', _502 => _502.id]), () => ( null)) })
   };
   const get = {
     name: "get_text_layer",
@@ -16900,7 +17574,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', _499 => _499.bounds]), () => ( null)), area: Math.round(sel ? _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel) : 0) };
+      return { empty: !sel, bounds: _nullishCoalesce(_optionalChain([sel, 'optionalAccess', _503 => _503.bounds]), () => ( null)), area: Math.round(sel ? _chunkUYXL6ZWQcjs.selectionArea.call(void 0, sel) : 0) };
     }
   };
   return [listFonts, get, add2, setText, setStyle, setParagraph, setFrame, setOrientation, toShape, typeMask];
@@ -17079,7 +17753,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', _500 => _500.getLayer, 'call', _501 => _501(parentId), 'optionalAccess', _502 => _502.type]) !== "group") throw new Error(`Layer "${parentId}" is not a group.`);
+      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.`);
       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) };
@@ -17393,7 +18067,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', _503 => _503.layerId]) === layer.id && view.mode === mode ? "off" : mode, layer.id);
+    controller.setMaskView(_optionalChain([view, 'optionalAccess', _507 => _507.layerId]) === layer.id && view.mode === mode ? "off" : mode, layer.id);
   } else if (e.shiftKey) {
     controller.setLayerMaskProps(layer.id, { enabled: layer.mask.enabled === false });
   } else {
@@ -17457,7 +18131,7 @@ function layerHasThumbnail(layer) {
   return layer.type === "pixel" || layer.type === "shape" || layer.type === "type";
 }
 function layerWarning(layer) {
-  if (layer.type === "type" && _optionalChain([layer, 'access', _504 => _504.missingFonts, 'optionalAccess', _505 => _505.length])) {
+  if (layer.type === "type" && _optionalChain([layer, 'access', _508 => _508.missingFonts, 'optionalAccess', _509 => _509.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;
@@ -17480,16 +18154,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', _506 => _506.type]) === "pixel";
-  const hasOwnPixels = _optionalChain([active, 'optionalAccess', _507 => _507.type]) === "pixel" || _optionalChain([active, 'optionalAccess', _508 => _508.type]) === "shape" || _optionalChain([active, 'optionalAccess', _509 => _509.type]) === "type" || _optionalChain([active, 'optionalAccess', _510 => _510.type]) === "smart";
+  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";
   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', _511 => _511.type]) === "group" },
-    { action: "merge-down", label: "Merge Down", enabled: Boolean(_optionalChain([active, 'optionalAccess', _512 => _512.visible]) && _optionalChain([below, 'optionalAccess', _513 => _513.type]) === "pixel") },
+    { 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: "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 },
@@ -17499,27 +18173,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', _514 => _514.mask])) },
-    { action: "delete-mask", label: "Delete Layer Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _515 => _515.mask])) },
-    { action: "toggle-mask", label: _optionalChain([active, 'optionalAccess', _516 => _516.mask, 'optionalAccess', _517 => _517.enabled]) === false ? "Enable Layer Mask" : "Disable Layer Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _518 => _518.mask])) },
-    { action: "toggle-mask-link", label: _optionalChain([active, 'optionalAccess', _519 => _519.mask, 'optionalAccess', _520 => _520.linked]) === false ? "Link Layer Mask" : "Unlink Layer Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _521 => _521.mask]) && !active.mask.source) },
-    { action: "add-vector-mask", label: "Add Vector Mask (Reveal All)", enabled: Boolean(active && active.type !== "shape" && !_optionalChain([active, 'access', _522 => _522.mask, 'optionalAccess', _523 => _523.source])) },
-    { action: "add-vector-mask-hide", label: "Add Vector Mask (Hide All)", enabled: Boolean(active && active.type !== "shape" && !_optionalChain([active, 'access', _524 => _524.mask, 'optionalAccess', _525 => _525.source])) },
-    { action: "add-vector-mask-selection", label: "Add Vector Mask from Selection", enabled: Boolean(active && active.type !== "shape" && !_optionalChain([active, 'access', _526 => _526.mask, 'optionalAccess', _527 => _527.source])) && hasSel },
-    { action: "delete-vector-mask", label: "Delete Vector Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _528 => _528.vectorMask])) },
-    { action: "toggle-vector-mask", label: _optionalChain([active, 'optionalAccess', _529 => _529.vectorMask, 'optionalAccess', _530 => _530.enabled]) === false ? "Enable Vector Mask" : "Disable Vector Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _531 => _531.vectorMask])) },
-    { action: "rasterize-vector-mask", label: "Rasterize Vector Mask", enabled: Boolean(_optionalChain([active, 'optionalAccess', _532 => _532.vectorMask])) },
-    { action: "rasterize", label: "Rasterize Layer", enabled: _optionalChain([active, 'optionalAccess', _533 => _533.type]) === "annotation" || _optionalChain([active, 'optionalAccess', _534 => _534.type]) === "smart" || _optionalChain([active, 'optionalAccess', _535 => _535.type]) === "shape" || _optionalChain([active, 'optionalAccess', _536 => _536.type]) === "type" || isPixel && Boolean(_optionalChain([active, 'optionalAccess', _537 => _537.type]) === "pixel" && _optionalChain([active, 'access', _538 => _538.filters, 'optionalAccess', _539 => _539.length])) },
+    { 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: "convert-smart", label: "Convert to Smart Object", enabled: Boolean(active && active.type !== "annotation") },
-    { action: "edit-contents", label: "Edit Contents", enabled: _optionalChain([active, 'optionalAccess', _540 => _540.type]) === "smart" },
-    { action: "smart-via-copy", label: "New Smart Object via Copy", enabled: _optionalChain([active, 'optionalAccess', _541 => _541.type]) === "smart" },
-    { action: "add-filter-mask", label: "Add Smart Filter Mask", enabled: _optionalChain([active, 'optionalAccess', _542 => _542.type]) === "smart" && !_optionalChain([active, 'access', _543 => _543.smartFilters, 'optionalAccess', _544 => _544.mask]) },
-    { action: "toggle-clip", label: _optionalChain([active, 'optionalAccess', _545 => _545.clipped]) ? "Release Clipping Mask" : "Create Clipping Mask", enabled: Boolean(loc && loc.index > 0) }
+    { 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) }
   ];
 }
 async function runLayerMenuAction(controller, action) {
   const active = controller.getActiveLayer();
-  const id = _optionalChain([active, 'optionalAccess', _546 => _546.id]);
+  const id = _optionalChain([active, 'optionalAccess', _550 => _550.id]);
   try {
     switch (action) {
       case "new-layer":
@@ -17575,10 +18249,10 @@ async function runLayerMenuAction(controller, action) {
         if (id) controller.removeLayerMask(id);
         break;
       case "toggle-mask":
-        if (id && _optionalChain([active, 'optionalAccess', _547 => _547.mask])) controller.setLayerMaskProps(id, { enabled: active.mask.enabled === false });
+        if (id && _optionalChain([active, 'optionalAccess', _551 => _551.mask])) controller.setLayerMaskProps(id, { enabled: active.mask.enabled === false });
         break;
       case "toggle-mask-link":
-        if (id && _optionalChain([active, 'optionalAccess', _548 => _548.mask])) controller.setLayerMaskProps(id, { linked: active.mask.linked === false });
+        if (id && _optionalChain([active, 'optionalAccess', _552 => _552.mask])) controller.setLayerMaskProps(id, { linked: active.mask.linked === false });
         break;
       case "add-vector-mask":
       case "add-vector-mask-hide":
@@ -17591,7 +18265,7 @@ async function runLayerMenuAction(controller, action) {
         if (id) controller.removeVectorMask(id);
         break;
       case "toggle-vector-mask":
-        if (id && _optionalChain([active, 'optionalAccess', _549 => _549.vectorMask])) controller.setVectorMaskProps(id, { enabled: active.vectorMask.enabled === false });
+        if (id && _optionalChain([active, 'optionalAccess', _553 => _553.vectorMask])) controller.setVectorMaskProps(id, { enabled: active.vectorMask.enabled === false });
         break;
       case "rasterize-vector-mask":
         if (id) controller.rasterizeVectorMask(id);
@@ -17612,7 +18286,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', _550 => _550.clipped]) });
+        if (id) controller.setLayerProperties(id, { clipped: !_optionalChain([active, 'optionalAccess', _554 => _554.clipped]) });
         break;
     }
     return null;
@@ -17622,7 +18296,7 @@ async function runLayerMenuAction(controller, action) {
 }
 function smartFilterRows(layer) {
   if (layer.type !== "smart") return [];
-  const list = _nullishCoalesce(_optionalChain([layer, 'access', _551 => _551.smartFilters, 'optionalAccess', _552 => _552.filters]), () => ( []));
+  const list = _nullishCoalesce(_optionalChain([layer, 'access', _555 => _555.smartFilters, 'optionalAccess', _556 => _556.filters]), () => ( []));
   const rows = list.map((f, index) => ({
     filter: f,
     index,
@@ -17648,8 +18322,8 @@ function extractNormalizedLayerItems(controller, fallbackImageUrl = "") {
   };
   collectSerialized(_nullishCoalesce(serialized.layers, () => ( [])));
   const sLayerMap = new Map(allSerializedLayers.map((sl) => [sl.id, sl]));
-  const imgW = _optionalChain([state, 'access', _553 => _553.imageDimensions, 'optionalAccess', _554 => _554.width]) || 1;
-  const imgH = _optionalChain([state, 'access', _555 => _555.imageDimensions, 'optionalAccess', _556 => _556.height]) || 1;
+  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;
   return ctrlLayers.map((l) => {
     const bounds = controller.getLayerBounds(l.id) || {
       x: 0,
@@ -17658,8 +18332,8 @@ function extractNormalizedLayerItems(controller, fallbackImageUrl = "") {
       height: imgH
     };
     const sLayer = sLayerMap.get(l.id);
-    const assetKey = _optionalChain([sLayer, 'optionalAccess', _557 => _557.asset]);
-    const layerDataUrl = assetKey && assets[assetKey] || assets[l.id] || (_optionalChain([sLayer, 'optionalAccess', _558 => _558.source]) === "document" ? fallbackImageUrl : "");
+    const assetKey = _optionalChain([sLayer, 'optionalAccess', _561 => _561.asset]);
+    const layerDataUrl = assetKey && assets[assetKey] || assets[l.id] || (_optionalChain([sLayer, 'optionalAccess', _562 => _562.source]) === "document" ? fallbackImageUrl : "");
     return {
       id: l.id,
       name: l.name || "Untitled Layer",
@@ -17713,9 +18387,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', _559 => _559.text]) || "New Text",
-      x: typeof _optionalChain([init, 'optionalAccess', _560 => _560.x]) === "number" ? init.x : cx - 100,
-      y: typeof _optionalChain([init, 'optionalAccess', _561 => _561.y]) === "number" ? init.y : cy,
+      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,
       ...init
     });
   }
@@ -17728,10 +18402,10 @@ async function addLayerOfKind(controller, id, init) {
     return controller.addShapeLayer({
       shape: {
         kind: "rect",
-        x: typeof _optionalChain([init, 'optionalAccess', _562 => _562.x]) === "number" ? init.x : cx - Math.round(w / 2),
-        y: typeof _optionalChain([init, 'optionalAccess', _563 => _563.y]) === "number" ? init.y : cy - Math.round(h / 2),
-        width: typeof _optionalChain([init, 'optionalAccess', _564 => _564.width]) === "number" ? init.width : w,
-        height: typeof _optionalChain([init, 'optionalAccess', _565 => _565.height]) === "number" ? init.height : h
+        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
       },
       name: "Rectangle",
       ...init
@@ -17746,10 +18420,10 @@ async function addLayerOfKind(controller, id, init) {
     return controller.addShapeLayer({
       shape: {
         kind: "ellipse",
-        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', _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
       },
       name: "Ellipse",
       ...init
@@ -17810,18 +18484,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', _570 => _570.locks, 'optionalAccess', _571 => _571.all]));
+  const readOnly = Boolean(_optionalChain([layer, 'access', _574 => _574.locks, 'optionalAccess', _575 => _575.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', _572 => _572.enabled]), () => ( true)),
-    scale: _nullishCoalesce(_optionalChain([fx, 'optionalAccess', _573 => _573.scale]), () => ( 1)),
-    rows: (_nullishCoalesce(_optionalChain([fx, 'optionalAccess', _574 => _574.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', _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 }))
   };
 }
 function layerEffectsBadge(layer) {
-  if (!_optionalChain([layer, 'access', _575 => _575.effects, 'optionalAccess', _576 => _576.items, 'access', _577 => _577.length])) return null;
+  if (!_optionalChain([layer, 'access', _579 => _579.effects, 'optionalAccess', _580 => _580.items, 'access', _581 => _581.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) }));
@@ -17866,8 +18540,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', _578 => _578.stops, 'access', _579 => _579[0], 'optionalAccess', _580 => _580.color]), () => ( "#000000")) },
-    { key: `${prefix}.stops.last.color`, label: "End colour", type: "color", value: _nullishCoalesce(_optionalChain([g, 'access', _581 => _581.stops, 'access', _582 => _582[g.stops.length - 1], 'optionalAccess', _583 => _583.color]), () => ( "#ffffff")) },
+    { 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}.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: "%" },
@@ -17959,19 +18633,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', _584 => _584[0], 'optionalAccess', _585 => _585.id]), () => ( "checker")), scale: 1 };
+  if (type === "pattern") return { type: "pattern", patternId: _nullishCoalesce(_optionalChain([patterns, 'access', _588 => _588[0], 'optionalAccess', _589 => _589.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', _586 => _586(patterns), 'access', _587 => _587.find, 'call', _588 => _588((o) => o.value === value), 'optionalAccess', _589 => _589.label]);
+    const name = _optionalChain([patternOptions, 'call', _590 => _590(patterns), 'access', _591 => _591.find, 'call', _592 => _592((o) => o.value === value), 'optionalAccess', _593 => _593.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', _590 => _590(patterns), 'access', _591 => _591.find, 'call', _592 => _592((o) => o.value === value), 'optionalAccess', _593 => _593.label]);
+    const name = _optionalChain([patternOptions, 'call', _594 => _594(patterns), 'access', _595 => _595.find, 'call', _596 => _596((o) => o.value === value), 'optionalAccess', _597 => _597.label]);
     return { fill: { ...effect.fill, patternId: value, ...name ? { name } : {} } };
   }
   return { [top]: setPath(getPath(effect, top), rest, value) };
@@ -17998,7 +18672,7 @@ function colorPanelView(controller) {
     profileName: profile.name,
     workingSpace: profile.builtin,
     mode: profile.mode,
-    cmykProfileName: _nullishCoalesce(_optionalChain([profile, 'access', _594 => _594.cmykProfile, 'optionalAccess', _595 => _595.name]), () => ( null)),
+    cmykProfileName: _nullishCoalesce(_optionalChain([profile, 'access', _598 => _598.cmykProfile, 'optionalAccess', _599 => _599.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
   };
 }
@@ -18181,32 +18855,32 @@ function boxFrameHit(overlay, p, tolerance, band) {
   return null;
 }
 var FreeTransformTool = (_class15 = class {
-  constructor(controller, options = {}) {;_class15.prototype.__init115.call(this);_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);
+  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);
     this.controller = controller;
     this.options = options;
   }
   
   
-  __init115() {this.sessionRef = null}
-  __init116() {this.modeValue = "scale"}
+  __init116() {this.sessionRef = null}
+  __init117() {this.modeValue = "scale"}
   /** The reference point in the untransformed frame's space (follows the transform). */
-  __init117() {this.refBox = { x: 0, y: 0 }}
-  __init118() {this.corners = null}
-  __init119() {this.drag = null}
+  __init118() {this.refBox = { x: 0, y: 0 }}
+  __init119() {this.corners = null}
+  __init120() {this.drag = null}
   /** The warp mesh in the frame's own space (null: no warp). */
-  __init120() {this.mesh = null}
-  __init121() {this.warpSettings = { style: "custom", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", columns: 1, rows: 1 }}
-  __init122() {this.pending = false}
-  __init123() {this.viewScale = 1}
+  __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}
   
   /** Values typed into the options bar since the last drag (V skew is not recovered from the shape). */
-  __init124() {this.typed = {}}
+  __init125() {this.typed = {}}
   /** Width and height scale together when typed (the chain icon). */
-  __init125() {this.proportional = true}
-  __init126() {this.error = null}
-  __init127() {this.lastResult = null}
+  __init126() {this.proportional = true}
+  __init127() {this.error = null}
+  __init128() {this.lastResult = null}
   get active() {
-    return Boolean(_optionalChain([this, 'access', _596 => _596.sessionRef, 'optionalAccess', _597 => _597.isOpen]));
+    return Boolean(_optionalChain([this, 'access', _600 => _600.sessionRef, 'optionalAccess', _601 => _601.isOpen]));
   }
   get session() {
     return this.active ? this.sessionRef : null;
@@ -18215,7 +18889,7 @@ var FreeTransformTool = (_class15 = class {
     return this.modeValue;
   }
   get interpolation() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _598 => _598.sessionRef, 'optionalAccess', _599 => _599.interpolation]), () => ( "bicubic"));
+    return _nullishCoalesce(_optionalChain([this, 'access', _602 => _602.sessionRef, 'optionalAccess', _603 => _603.interpolation]), () => ( "bicubic"));
   }
   /** Whether the open transform has changed anything yet (a commit would add an undo step). */
   get modified() {
@@ -18225,7 +18899,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);
   }
-  __init128() {this.listeners = /* @__PURE__ */ new Set()}
+  __init129() {this.listeners = /* @__PURE__ */ new Set()}
   /** Calls `listener` whenever the overlay, readout, mode or error changes. Returns the unsubscribe. */
   subscribe(listener) {
     this.listeners.add(listener);
@@ -18234,7 +18908,7 @@ var FreeTransformTool = (_class15 = class {
     };
   }
   changed() {
-    _optionalChain([this, 'access', _600 => _600.options, 'access', _601 => _601.onChange, 'optionalCall', _602 => _602()]);
+    _optionalChain([this, 'access', _604 => _604.options, 'access', _605 => _605.onChange, 'optionalCall', _606 => _606()]);
     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`. */
@@ -18627,7 +19301,7 @@ var FreeTransformTool = (_class15 = class {
   }
   /** Abandons the transform and restores everything. */
   cancel() {
-    _optionalChain([this, 'access', _603 => _603.sessionRef, 'optionalAccess', _604 => _604.cancel, 'call', _605 => _605()]);
+    _optionalChain([this, 'access', _607 => _607.sessionRef, 'optionalAccess', _608 => _608.cancel, 'call', _609 => _609()]);
     this.sessionRef = null;
     this.corners = null;
     this.mesh = null;
@@ -18683,7 +19357,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', _606 => _606.smartFilters, 'optionalAccess', _607 => _607.filters]), () => ( []))).forEach((f, index) => {
+    (_nullishCoalesce(_optionalChain([layer, 'access', _610 => _610.smartFilters, 'optionalAccess', _611 => _611.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;
@@ -18835,7 +19509,7 @@ var OTHER_TOOL_LABELS = {
   watermark: "Watermark"
 };
 function imageToolLabel(tool) {
-  return _nullishCoalesce(_nullishCoalesce(_optionalChain([PAINT_TOOLS, 'access', _608 => _608.find, 'call', _609 => _609((t) => t.id === tool), 'optionalAccess', _610 => _610.label]), () => ( OTHER_TOOL_LABELS[tool])), () => ( 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));
 }
 var IMAGE_TOOL_SHORTCUTS = {
   ...Object.fromEntries(PAINT_TOOLS.filter((t) => t.shortcut).map((t) => [t.id, t.shortcut])),
@@ -19949,4 +20623,8 @@ 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.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.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.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.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.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;