@pixerate/editor 0.258.0 → 0.260.0

package/dist/{chunk-JBBJE76O.cjs → chunk-3ZRNK3RO.cjs}

@@ -1,4 +1,9 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
+
+var _chunkK6PXS6DOcjs = require('./chunk-K6PXS6DO.cjs');
+
+
+var _chunkBB6TR422cjs = require('./chunk-BB6TR422.cjs');
 
 
 
@@ -7,10 +12,1012 @@
 
 
 
-var _chunkSS53NNZOcjs = require('./chunk-SS53NNZO.cjs');
 
 
-var _chunkBB6TR422cjs = require('./chunk-BB6TR422.cjs');
+
+var _chunk474IQG74cjs = require('./chunk-474IQG74.cjs');
+
+// src/image-editor/selection/mask.ts
+var SELECTION_MODES = ["replace", "add", "subtract", "intersect"];
+function isSelectionMode(value) {
+  return typeof value === "string" && SELECTION_MODES.includes(value);
+}
+function parseSelectionMode(value) {
+  return isSelectionMode(value) ? value : "replace";
+}
+var MAX_SIDE = 1 << 15;
+function checkSize(width, height) {
+  if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width > MAX_SIDE || height > MAX_SIDE) {
+    throw new Error(`Invalid selection size ${width}\xD7${height}`);
+  }
+}
+function computeSelectionBounds(width, height, data) {
+  let x0 = width;
+  let x1 = -1;
+  let y0 = -1;
+  let y1 = -1;
+  for (let y = 0; y < height; y++) {
+    const row = y * width;
+    let first = -1;
+    for (let x = 0; x < width; x++) {
+      if (data[row + x] !== 0) {
+        first = x;
+        break;
+      }
+    }
+    if (first < 0) continue;
+    let last = first;
+    for (let x = width - 1; x > first; x--) {
+      if (data[row + x] !== 0) {
+        last = x;
+        break;
+      }
+    }
+    if (y0 < 0) y0 = y;
+    y1 = y;
+    if (first < x0) x0 = first;
+    if (last > x1) x1 = last;
+  }
+  if (y0 < 0) return null;
+  return { x: x0, y: y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+}
+var TILE_PIXELS = _chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE;
+var MATERIALIZED_LIMIT = 4;
+var materialized = /* @__PURE__ */ new Map();
+var lastRead = null;
+var lastData = null;
+var TiledSelectionMask = (_class = class {
+  constructor(width, height, surface, bounds, data) {;_class.prototype.__init.call(this);
+    this.width = width;
+    this.height = height;
+    this.surface = surface;
+    this.cachedBounds = bounds;
+    if (data) this.remember(data);
+  }
+  
+  
+  
+  
+  __init() {this.weak = null}
+  get bounds() {
+    if (this.cachedBounds === void 0) this.cachedBounds = _chunk474IQG74cjs.contentBounds.call(void 0, this.surface);
+    return this.cachedBounds;
+  }
+  get data() {
+    if (lastRead === this) return lastData;
+    let d = materialized.get(this);
+    if (d) {
+      materialized.delete(this);
+      materialized.set(this, d);
+      lastRead = this;
+      lastData = d;
+      return d;
+    }
+    d = _optionalChain([this, 'access', _ => _.weak, 'optionalAccess', _2 => _2.deref, 'call', _3 => _3()]);
+    if (!d) {
+      const all = _chunk474IQG74cjs.readRegion.call(void 0, this.surface, { x: 0, y: 0, width: this.width, height: this.height });
+      d = new Uint8Array(all.buffer, all.byteOffset, all.length);
+    }
+    this.remember(d);
+    return d;
+  }
+  remember(d) {
+    lastRead = this;
+    lastData = d;
+    this.weak = typeof WeakRef === "function" ? new WeakRef(d) : null;
+    materialized.set(this, d);
+    while (materialized.size > MATERIALIZED_LIMIT) materialized.delete(materialized.keys().next().value);
+  }
+}, _class);
+function tileGrid(width, height) {
+  return { cols: Math.ceil(width / _chunk474IQG74cjs.TILE), rows: Math.ceil(height / _chunk474IQG74cjs.TILE) };
+}
+function insideTile(tx, ty, width, height) {
+  return (tx + 1) * _chunk474IQG74cjs.TILE <= width && (ty + 1) * _chunk474IQG74cjs.TILE <= height;
+}
+function surfaceFromCoverage(width, height, data) {
+  const tiles = /* @__PURE__ */ new Map();
+  const { cols, rows } = tileGrid(width, height);
+  for (let ty = 0; ty < rows; ty++) {
+    for (let tx = 0; tx < cols; tx++) {
+      const ox = tx * _chunk474IQG74cjs.TILE;
+      const oy = ty * _chunk474IQG74cjs.TILE;
+      const w = Math.min(_chunk474IQG74cjs.TILE, width - ox);
+      const h = Math.min(_chunk474IQG74cjs.TILE, height - oy);
+      let lo = 255;
+      let hi = 0;
+      for (let y = 0; y < h && !(hi > 0 && lo < hi); y++) {
+        const row = (oy + y) * width + ox;
+        for (let x = 0; x < w; x++) {
+          const v = data[row + x];
+          if (v < lo) lo = v;
+          if (v > hi) hi = v;
+        }
+      }
+      if (hi === 0) continue;
+      if (lo === hi && w === _chunk474IQG74cjs.TILE && h === _chunk474IQG74cjs.TILE) {
+        tiles.set(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty), _chunk474IQG74cjs.uniformTile.call(void 0, 1, hi));
+        continue;
+      }
+      const t = new Uint8ClampedArray(TILE_PIXELS);
+      for (let y = 0; y < h; y++) {
+        const row = (oy + y) * width + ox;
+        for (let x = 0; x < w; x++) t[y * _chunk474IQG74cjs.TILE + x] = data[row + x];
+      }
+      tiles.set(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty), { data: t, uniform: null });
+    }
+  }
+  return new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0);
+}
+function clipTile(tile, w, h) {
+  const d = tile.data;
+  let outside = false;
+  for (let y = 0; y < _chunk474IQG74cjs.TILE && !outside; y++) {
+    for (let x = y < h ? w : 0; x < _chunk474IQG74cjs.TILE; x++) {
+      if (d[y * _chunk474IQG74cjs.TILE + x] !== 0) {
+        outside = true;
+        break;
+      }
+    }
+  }
+  if (!outside) return tile;
+  const t = new Uint8ClampedArray(TILE_PIXELS);
+  for (let y = 0; y < h; y++) t.set(d.subarray(y * _chunk474IQG74cjs.TILE, y * _chunk474IQG74cjs.TILE + w), y * _chunk474IQG74cjs.TILE);
+  return _chunk474IQG74cjs.finishTile.call(void 0, t, 1, 0);
+}
+function selectionFromTiles(width, height, surface) {
+  checkSize(width, height);
+  if (surface.channels !== 1) throw new Error("A selection needs a 1-channel surface");
+  if (surface.defaultValue !== 0) {
+    const all = _chunk474IQG74cjs.readRegion.call(void 0, surface, { x: 0, y: 0, width, height });
+    return createSelectionMask(width, height, new Uint8Array(all.buffer, all.byteOffset, all.length));
+  }
+  const { cols, rows } = tileGrid(width, height);
+  let tiles = null;
+  for (const [key, tile] of surface.tiles) {
+    const { tx, ty } = _chunk474IQG74cjs.tileCoord.call(void 0, key);
+    let next = tile;
+    if (tx < 0 || ty < 0 || tx >= cols || ty >= rows) next = null;
+    else if (!insideTile(tx, ty, width, height)) next = clipTile(tile, Math.min(_chunk474IQG74cjs.TILE, width - tx * _chunk474IQG74cjs.TILE), Math.min(_chunk474IQG74cjs.TILE, height - ty * _chunk474IQG74cjs.TILE));
+    if (next === tile) continue;
+    tiles ??= new Map(surface.tiles);
+    if (next) tiles.set(key, next);
+    else tiles.delete(key);
+  }
+  return new TiledSelectionMask(width, height, tiles ? new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0) : surface);
+}
+function createSelectionMask(width, height, data) {
+  checkSize(width, height);
+  if (!data) return new TiledSelectionMask(width, height, new (0, _chunk474IQG74cjs.TiledSurface)(1, /* @__PURE__ */ new Map(), 0), null);
+  if (data.length !== width * height) throw new Error("Selection data does not match its size");
+  return new TiledSelectionMask(width, height, surfaceFromCoverage(width, height, data), void 0, data);
+}
+function selectionFromRegion(width, height, rect, data) {
+  checkSize(width, height);
+  if (rect.x < 0 || rect.y < 0 || rect.x + rect.width > width || rect.y + rect.height > height) throw new Error("The region lies outside the selection");
+  return new TiledSelectionMask(width, height, _chunk474IQG74cjs.writeRegion.call(void 0, new (0, _chunk474IQG74cjs.TiledSurface)(1, /* @__PURE__ */ new Map(), 0), rect, data));
+}
+function fullSelection(width, height) {
+  checkSize(width, height);
+  const tiles = /* @__PURE__ */ new Map();
+  const { cols, rows } = tileGrid(width, height);
+  for (let ty = 0; ty < rows; ty++) {
+    for (let tx = 0; tx < cols; tx++) {
+      if (insideTile(tx, ty, width, height)) {
+        tiles.set(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty), _chunk474IQG74cjs.uniformTile.call(void 0, 1, 255));
+        continue;
+      }
+      const t = new Uint8ClampedArray(TILE_PIXELS);
+      const w = Math.min(_chunk474IQG74cjs.TILE, width - tx * _chunk474IQG74cjs.TILE);
+      for (let y = 0; y < Math.min(_chunk474IQG74cjs.TILE, height - ty * _chunk474IQG74cjs.TILE); y++) t.fill(255, y * _chunk474IQG74cjs.TILE, y * _chunk474IQG74cjs.TILE + w);
+      tiles.set(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty), { data: t, uniform: null });
+    }
+  }
+  return new TiledSelectionMask(width, height, new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0), { x: 0, y: 0, width, height });
+}
+function isSelectionEmpty(mask) {
+  return !mask || mask.bounds === null;
+}
+function selectionValueAt(mask, x, y) {
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  if (xi < 0 || yi < 0 || xi >= mask.width || yi >= mask.height) return 0;
+  return _chunk474IQG74cjs.readPixel.call(void 0, mask.surface, xi, yi)[0] / 255;
+}
+function coverageToByte(v) {
+  if (!(v > 0)) return 0;
+  if (v >= 1) return 255;
+  return Math.floor(v * 255 + 0.5);
+}
+function selectionFromCoverage(width, height, coverage) {
+  const n = width * height;
+  const out = new Uint8Array(n);
+  for (let i = 0; i < n; i++) out[i] = coverageToByte(coverage[i]);
+  return createSelectionMask(width, height, out);
+}
+function selectionToCoverage(mask) {
+  const out = new Float32Array(mask.data.length);
+  for (let i = 0; i < out.length; i++) out[i] = mask.data[i] / 255;
+  return out;
+}
+function selectionArea(mask) {
+  if (!mask || !mask.bounds) return 0;
+  let sum = 0;
+  for (const tile of mask.surface.tiles.values()) {
+    if (tile.uniform !== null) {
+      sum += tile.uniform * TILE_PIXELS;
+      continue;
+    }
+    const d = tile.data;
+    for (let i = 0; i < d.length; i++) sum += d[i];
+  }
+  return sum / 255;
+}
+function combineSelections(prev, next, mode) {
+  let result;
+  if (mode === "replace" || !prev && mode === "add") {
+    result = next;
+  } else if (!prev) {
+    return null;
+  } else {
+    if (prev.width !== next.width || prev.height !== next.height) throw new Error("Selections differ in size");
+    result = new TiledSelectionMask(prev.width, prev.height, combineSurfaces(prev.surface, next.surface, mode));
+  }
+  return result.bounds ? result : null;
+}
+var FULL = 255;
+function combineTile(a, b, mode) {
+  if (mode === "add") {
+    if (!b || _optionalChain([a, 'optionalAccess', _4 => _4.uniform]) === FULL) return a;
+    if (!a || b.uniform === FULL) return b;
+  } else if (mode === "subtract") {
+    if (!a || !b) return a;
+    if (b.uniform === FULL) return void 0;
+  } else {
+    if (!a || !b) return void 0;
+    if (a.uniform === FULL) return b;
+    if (b.uniform === FULL) return a;
+  }
+  const x = a.data;
+  const y = b.data;
+  const out = new Uint8ClampedArray(TILE_PIXELS);
+  if (mode === "add") for (let i = 0; i < out.length; i++) out[i] = x[i] > y[i] ? x[i] : y[i];
+  else if (mode === "subtract") for (let i = 0; i < out.length; i++) out[i] = x[i] > y[i] ? x[i] - y[i] : 0;
+  else for (let i = 0; i < out.length; i++) out[i] = x[i] < y[i] ? x[i] : y[i];
+  return _nullishCoalesce(_chunk474IQG74cjs.finishTile.call(void 0, out, 1, 0), () => ( void 0));
+}
+function combineSurfaces(a, b, mode) {
+  const tiles = /* @__PURE__ */ new Map();
+  for (const key of /* @__PURE__ */ new Set([...a.tiles.keys(), ...b.tiles.keys()])) {
+    const tile = combineTile(a.tiles.get(key), b.tiles.get(key), mode);
+    if (tile) tiles.set(key, tile);
+  }
+  return new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0);
+}
+function invertSelection(mask) {
+  const { width, height } = mask;
+  const tiles = /* @__PURE__ */ new Map();
+  const { cols, rows } = tileGrid(width, height);
+  for (let ty = 0; ty < rows; ty++) {
+    for (let tx = 0; tx < cols; tx++) {
+      const src = mask.surface.getTile(tx, ty);
+      const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
+      if (insideTile(tx, ty, width, height)) {
+        if (!src) tiles.set(key, _chunk474IQG74cjs.uniformTile.call(void 0, 1, FULL));
+        else if (src.uniform !== null) {
+          if (src.uniform !== FULL) tiles.set(key, _chunk474IQG74cjs.uniformTile.call(void 0, 1, FULL - src.uniform));
+        } else {
+          const out2 = new Uint8ClampedArray(TILE_PIXELS);
+          for (let i = 0; i < out2.length; i++) out2[i] = FULL - src.data[i];
+          const t2 = _chunk474IQG74cjs.finishTile.call(void 0, out2, 1, 0);
+          if (t2) tiles.set(key, t2);
+        }
+        continue;
+      }
+      const w = Math.min(_chunk474IQG74cjs.TILE, width - tx * _chunk474IQG74cjs.TILE);
+      const h = Math.min(_chunk474IQG74cjs.TILE, height - ty * _chunk474IQG74cjs.TILE);
+      const out = new Uint8ClampedArray(TILE_PIXELS);
+      for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) out[y * _chunk474IQG74cjs.TILE + x] = FULL - (src ? src.data[y * _chunk474IQG74cjs.TILE + x] : 0);
+      const t = _chunk474IQG74cjs.finishTile.call(void 0, out, 1, 0);
+      if (t) tiles.set(key, t);
+    }
+  }
+  return new TiledSelectionMask(width, height, new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0));
+}
+function resizeSelection(mask, width, height) {
+  if (mask.width === width && mask.height === height) return mask;
+  checkSize(width, height);
+  const out = new Uint8Array(width * height);
+  const sx = mask.width / width;
+  const sy = mask.height / height;
+  const src = mask.data;
+  const mw = mask.width;
+  for (let y = 0; y < height; y++) {
+    const fy = Math.min(mask.height - 1, Math.max(0, (y + 0.5) * sy - 0.5));
+    const y0 = Math.floor(fy);
+    const y1 = Math.min(mask.height - 1, y0 + 1);
+    const ty = fy - y0;
+    for (let x = 0; x < width; x++) {
+      const fx = Math.min(mw - 1, Math.max(0, (x + 0.5) * sx - 0.5));
+      const x0 = Math.floor(fx);
+      const x1 = Math.min(mw - 1, x0 + 1);
+      const tx = fx - x0;
+      const top = src[y0 * mw + x0] * (1 - tx) + src[y0 * mw + x1] * tx;
+      const bot = src[y1 * mw + x0] * (1 - tx) + src[y1 * mw + x1] * tx;
+      out[y * width + x] = Math.round(top * (1 - ty) + bot * ty);
+    }
+  }
+  return createSelectionMask(width, height, out);
+}
+function selectionFromPixels(pixels, options = {}) {
+  const { width, height, data } = pixels;
+  checkSize(width, height);
+  if (data.length < width * height * 4) throw new Error("Pixel data is shorter than width \xD7 height \xD7 4");
+  const channel = _nullishCoalesce(options.channel, () => ( "luminance"));
+  const out = new Uint8Array(width * height);
+  const threshold = options.threshold;
+  for (let i = 0, p = 0; i < out.length; i++, p += 4) {
+    let v;
+    switch (channel) {
+      case "alpha":
+        v = data[p + 3];
+        break;
+      case "red":
+        v = data[p];
+        break;
+      case "green":
+        v = data[p + 1];
+        break;
+      case "blue":
+        v = data[p + 2];
+        break;
+      default:
+        v = Math.round((0.2126 * data[p] + 0.7152 * data[p + 1] + 0.0722 * data[p + 2]) * data[p + 3] / 255);
+    }
+    if (options.invert) v = 255 - v;
+    if (threshold !== void 0) v = v >= threshold ? 255 : 0;
+    out[i] = v;
+  }
+  return createSelectionMask(width, height, out);
+}
+function selectionToPixels(mask, as = "gray") {
+  const out = new Uint8ClampedArray(mask.data.length * 4);
+  for (let i = 0, p = 0; i < mask.data.length; i++, p += 4) {
+    const v = mask.data[i];
+    if (as === "gray") {
+      out[p] = out[p + 1] = out[p + 2] = v;
+      out[p + 3] = 255;
+    } else {
+      out[p] = out[p + 1] = out[p + 2] = 255;
+      out[p + 3] = v;
+    }
+  }
+  return { width: mask.width, height: mask.height, data: out };
+}
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var B64_INDEX = (() => {
+  const t = new Int16Array(128).fill(-1);
+  for (let i = 0; i < B64.length; i++) t[B64.charCodeAt(i)] = i;
+  return t;
+})();
+function toBase64(bytes, length) {
+  const parts = [];
+  let chunk = "";
+  for (let i = 0; i < length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < length ? bytes[i + 1] : 0;
+    const c = i + 2 < length ? bytes[i + 2] : 0;
+    chunk += B64[a >> 2] + B64[(a & 3) << 4 | b >> 4];
+    chunk += i + 1 < length ? B64[(b & 15) << 2 | c >> 6] : "=";
+    chunk += i + 2 < length ? B64[c & 63] : "=";
+    if (chunk.length >= 8192) {
+      parts.push(chunk);
+      chunk = "";
+    }
+  }
+  parts.push(chunk);
+  return parts.join("");
+}
+function fromBase64(text) {
+  if (text.length % 4 !== 0) throw new Error("Invalid base64 length");
+  let pad = 0;
+  if (text.endsWith("==")) pad = 2;
+  else if (text.endsWith("=")) pad = 1;
+  const out = new Uint8Array(text.length / 4 * 3 - pad);
+  let o = 0;
+  const digit = (i, k) => {
+    const ch = text.charCodeAt(i + k);
+    if (ch === 61 && i + 4 === text.length && k >= 4 - pad) return 0;
+    const idx = ch < 128 ? B64_INDEX[ch] : -1;
+    if (idx < 0) throw new Error("Invalid base64 character");
+    return idx;
+  };
+  for (let i = 0; i < text.length; i += 4) {
+    const n = digit(i, 0) << 18 | digit(i, 1) << 12 | digit(i, 2) << 6 | digit(i, 3);
+    if (o < out.length) out[o++] = n >> 16 & 255;
+    if (o < out.length) out[o++] = n >> 8 & 255;
+    if (o < out.length) out[o++] = n & 255;
+  }
+  return out;
+}
+function encodeSelectionRle(data) {
+  let buf = new Uint8Array(64);
+  let len = 0;
+  const push = (b) => {
+    if (len === buf.length) {
+      const next = new Uint8Array(buf.length * 2);
+      next.set(buf);
+      buf = next;
+    }
+    buf[len++] = b;
+  };
+  let i = 0;
+  while (i < data.length) {
+    const v = data[i];
+    let j = i + 1;
+    while (j < data.length && data[j] === v) j++;
+    push(v);
+    let run = j - i;
+    while (run >= 128) {
+      push(run & 127 | 128);
+      run = Math.floor(run / 128);
+    }
+    push(run);
+    i = j;
+  }
+  return "r1:" + toBase64(buf, len);
+}
+function decodeSelectionRle(rle, length) {
+  if (typeof rle !== "string" || !rle.startsWith("r1:")) throw new Error("Unknown selection encoding");
+  const bytes = fromBase64(rle.slice(3));
+  const out = new Uint8Array(length);
+  let o = 0;
+  let i = 0;
+  while (i < bytes.length) {
+    const v = bytes[i++];
+    let run = 0;
+    let scale = 1;
+    for (; ; ) {
+      if (i >= bytes.length) throw new Error("Truncated selection run");
+      const b = bytes[i++];
+      run += (b & 127) * scale;
+      if (b < 128) break;
+      scale *= 128;
+      if (scale > 2 ** 35) throw new Error("Selection run too long");
+    }
+    if (run === 0 || o + run > length) throw new Error("Selection runs do not match its size");
+    if (v !== 0) out.fill(v, o, o + run);
+    o += run;
+  }
+  if (o !== length) throw new Error("Selection runs do not match its size");
+  return out;
+}
+function serializeSelection(mask) {
+  return { width: mask.width, height: mask.height, rle: encodeSelectionRle(mask.data) };
+}
+function deserializeSelection(value) {
+  if (!value || typeof value !== "object") throw new Error("selection must be an object");
+  const v = value;
+  const width = v.width;
+  const height = v.height;
+  checkSize(width, height);
+  return createSelectionMask(width, height, decodeSelectionRle(v.rle, width * height));
+}
+function hashMaskContent(content) {
+  let h = 2166136261;
+  if (typeof content === "string") {
+    for (let i = 0; i < content.length; i++) {
+      h ^= content.charCodeAt(i);
+      h = Math.imul(h, 16777619);
+    }
+  } else {
+    for (let i = 0; i < content.length; i++) {
+      h ^= content[i];
+      h = Math.imul(h, 16777619);
+    }
+  }
+  return `${(h >>> 0).toString(16)}:${content.length}`;
+}
+
+// src/image-editor/selection/modify.ts
+var EMPTY_DISTANCE = 1e10;
+function distanceTransform(inside, width, height) {
+  const n = width * height;
+  const out = new Float32Array(n);
+  let any = false;
+  let all = true;
+  for (let i = 0; i < n; i++) {
+    if (inside[i]) any = true;
+    else all = false;
+  }
+  if (!any) return out.fill(EMPTY_DISTANCE);
+  if (all) return out;
+  const NONE2 = 4294967295;
+  const vertical = new Uint32Array(n).fill(NONE2);
+  for (let x = 0; x < width; x++) {
+    let nearest = -1;
+    for (let y = 0; y < height; y++) {
+      const i = y * width + x;
+      if (inside[i]) nearest = y;
+      if (nearest >= 0) vertical[i] = y - nearest;
+    }
+    nearest = -1;
+    for (let y = height - 1; y >= 0; y--) {
+      const i = y * width + x;
+      if (vertical[i] === 0) nearest = y;
+      if (nearest >= 0) vertical[i] = Math.min(vertical[i], nearest - y);
+    }
+  }
+  const sites = new Int32Array(width);
+  const starts = new Float64Array(width);
+  for (let y = 0; y < height; y++) {
+    const row = y * width;
+    let count = 0;
+    for (let q = 0; q < width; q++) {
+      const dq = vertical[row + q];
+      if (dq === NONE2) continue;
+      const fq = dq * dq;
+      let start = -Infinity;
+      while (count > 0) {
+        const p = sites[count - 1];
+        const dp = vertical[row + p];
+        start = (fq - dp * dp) / (2 * (q - p)) + (q + p) * 0.5;
+        if (start > starts[count - 1]) break;
+        count--;
+      }
+      if (count === 0) start = -Infinity;
+      sites[count] = q;
+      starts[count] = start;
+      count++;
+    }
+    if (count === 0) {
+      out.fill(EMPTY_DISTANCE, row, row + width);
+      continue;
+    }
+    let k = 0;
+    for (let x = 0; x < width; x++) {
+      while (k + 1 < count && starts[k + 1] < x) k++;
+      const site = sites[k];
+      const dx = x - site;
+      const dv = vertical[row + site];
+      out[row + x] = Math.sqrt(dx * dx + dv * dv);
+    }
+  }
+  return out;
+}
+function thresholdInside(m, threshold = 0.5) {
+  const out = new Uint8Array(m.length);
+  for (let i = 0; i < m.length; i++) out[i] = m[i] >= threshold ? 1 : 0;
+  return out;
+}
+function expandCoverage(m, w, h, r) {
+  const d = distanceTransform(thresholdInside(m), w, h);
+  const out = new Float32Array(m.length);
+  for (let i = 0; i < out.length; i++) out[i] = Math.max(m[i], Math.min(1, Math.max(0, r + 1 - d[i])));
+  return out;
+}
+function contractCoverage(m, w, h, r) {
+  const inv = new Float32Array(m.length);
+  for (let i = 0; i < inv.length; i++) inv[i] = 1 - m[i];
+  const e = expandCoverage(inv, w, h, r);
+  for (let i = 0; i < e.length; i++) e[i] = 1 - e[i];
+  return e;
+}
+function borderCoverage(m, w, h, r) {
+  const inside = thresholdInside(m);
+  const outside = new Uint8Array(inside.length);
+  for (let i = 0; i < inside.length; i++) outside[i] = inside[i] ? 0 : 1;
+  const out = new Float32Array(m.length);
+  if (!(r > 0)) return out;
+  const toInside = distanceTransform(inside, w, h);
+  const toOutside = distanceTransform(outside, w, h);
+  for (let i = 0; i < out.length; i++) {
+    const d = inside[i] ? toOutside[i] : toInside[i];
+    out[i] = Math.min(1, Math.max(0, 1 - (d - 1) / r));
+  }
+  return out;
+}
+function boxLineReplicate(src, srcOff, stride, len, r, dst) {
+  const at = (i) => src[srcOff + Math.min(len - 1, Math.max(0, i)) * stride];
+  let sum = 0;
+  for (let i = -r; i <= r; i++) sum += at(i);
+  const k = 2 * r + 1;
+  for (let i = 0; i < len; i++) {
+    dst[i] = sum / k;
+    sum += at(i + r + 1) - at(i - r);
+  }
+}
+function smoothCoverage(m, w, h, r) {
+  const rr = Number.isFinite(r) ? Math.max(0, Math.round(r)) : 0;
+  const src = Float32Array.from(m);
+  const tmp = new Float32Array(src.length);
+  const line = new Float32Array(Math.max(w, h));
+  if (rr > 0) {
+    for (let y = 0; y < h; y++) {
+      boxLineReplicate(src, y * w, 1, w, rr, line);
+      tmp.set(line.subarray(0, w), y * w);
+    }
+    for (let x = 0; x < w; x++) {
+      boxLineReplicate(tmp, x, w, h, rr, line);
+      for (let y = 0; y < h; y++) src[y * w + x] = line[y];
+    }
+  }
+  for (let i = 0; i < src.length; i++) src[i] = src[i] >= 0.5 ? 1 : 0;
+  return src;
+}
+function featherCoverage(m, w, h, radius) {
+  const out = _chunkK6PXS6DOcjs.gaussianBlur.call(void 0, m, w, h, Number.isFinite(radius) ? Math.max(0, radius) : 0, "zero");
+  for (let i = 0; i < out.length; i++) if (Math.abs(out[i]) < 1e-7) out[i] = 0;
+  return out;
+}
+function runningExtreme(src, off, stride, len, r, max, g, hb, dst) {
+  const k = 2 * r + 1;
+  const pick = max ? (a, b) => a > b ? a : b : (a, b) => a < b ? a : b;
+  const fill = max ? -Infinity : Infinity;
+  const plen = len + 2 * r;
+  const at = (i) => i < r || i >= r + len ? fill : src[off + (i - r) * stride];
+  for (let start = 0; start < plen; start += k) {
+    const end = Math.min(plen, start + k);
+    g[start] = at(start);
+    for (let i = start + 1; i < end; i++) g[i] = pick(g[i - 1], at(i));
+    hb[end - 1] = at(end - 1);
+    for (let i = end - 2; i >= start; i--) hb[i] = pick(hb[i + 1], at(i));
+  }
+  for (let i = 0; i < len; i++) {
+    const a = hb[i];
+    const b = g[i + 2 * r];
+    dst[i] = pick(a, b);
+  }
+}
+function greyMorphology(src, w, h, r, grow) {
+  const out = Float32Array.from(src);
+  if (r <= 0) return out;
+  const n = Math.max(w, h);
+  const g = new Float32Array(n + 2 * r);
+  const hb = new Float32Array(n + 2 * r);
+  const line = new Float32Array(n);
+  for (let y = 0; y < h; y++) {
+    runningExtreme(out, y * w, 1, w, r, grow, g, hb, line);
+    out.set(line.subarray(0, w), y * w);
+  }
+  for (let x = 0; x < w; x++) {
+    runningExtreme(out, x, w, h, r, grow, g, hb, line);
+    for (let y = 0; y < h; y++) out[y * w + x] = line[y];
+  }
+  return out;
+}
+function shiftCoverage(src, w, h, amount) {
+  const mag = Math.abs(amount);
+  if (!Number.isFinite(mag) || mag < 1e-4) return Float32Array.from(src);
+  const grow = amount > 0;
+  const whole = Math.floor(mag);
+  const frac = mag - whole;
+  if (frac < 1e-4) return greyMorphology(src, w, h, whole, grow);
+  const lo = whole === 0 ? Float32Array.from(src) : greyMorphology(src, w, h, whole, grow);
+  const hi = greyMorphology(src, w, h, whole + 1, grow);
+  for (let i = 0; i < lo.length; i++) lo[i] += (hi[i] - lo[i]) * frac;
+  return lo;
+}
+var SELECTION_MODIFY_OPS = ["expand", "contract", "feather", "border", "smooth", "grow", "shrink"];
+function wrap(mask, coverage) {
+  const out = new Uint8Array(coverage.length);
+  for (let i = 0; i < out.length; i++) out[i] = coverageToByte(coverage[i]);
+  return createSelectionMask(mask.width, mask.height, out);
+}
+function modifySelection(mask, op, radius) {
+  const r = Number.isFinite(radius) ? Math.max(0, radius) : 0;
+  if (r === 0 && op !== "border") return mask;
+  const m = selectionToCoverage(mask);
+  const { width: w, height: h } = mask;
+  switch (op) {
+    case "expand":
+    case "grow":
+      return wrap(mask, expandCoverage(m, w, h, r));
+    case "contract":
+    case "shrink":
+      return wrap(mask, contractCoverage(m, w, h, r));
+    case "feather":
+      return wrap(mask, featherCoverage(m, w, h, r));
+    case "border":
+      return wrap(mask, borderCoverage(m, w, h, r));
+    case "smooth":
+      return wrap(mask, smoothCoverage(m, w, h, r));
+    default:
+      throw new Error(`Unknown selection modification "${op}"`);
+  }
+}
+
+// src/image-editor/selection/refine.ts
+var DEFAULT_REFINE_EDGE_PARAMS = {
+  radius: 0,
+  smartRadius: false,
+  smooth: 0,
+  feather: 0,
+  contrast: 0,
+  shiftEdge: 0
+};
+var GUIDED_FILTER_EPS = 1e-4;
+var fin = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+function normalizeRefineEdgeParams(p = {}) {
+  return {
+    radius: Math.min(250, Math.max(0, fin(p.radius, 0))),
+    smartRadius: p.smartRadius === true,
+    smooth: Math.min(100, Math.max(0, fin(p.smooth, 0))),
+    feather: Math.min(1e3, Math.max(0, fin(p.feather, 0))),
+    contrast: Math.min(100, Math.max(0, fin(p.contrast, 0))),
+    shiftEdge: Math.min(100, Math.max(-100, fin(p.shiftEdge, 0)))
+  };
+}
+var gfRadius = (p) => Math.min(64, Math.max(1, Math.ceil(p.radius)));
+var smoothSigma = (p) => p.smooth / 100 * 4;
+var featherSigma = (p) => p.feather / 2;
+function shiftAmount(p) {
+  const px = p.shiftEdge / 100 * Math.max(p.radius, 4);
+  return Number.isFinite(px) ? Math.min(64, Math.max(-64, px)) : 0;
+}
+function refineEdgeHalo(params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  const g = gfRadius(p);
+  const edge = p.radius > 0 ? Math.max(Math.ceil(p.radius), 2 * g + (p.smartRadius ? g + 1 : 0)) : 0;
+  return edge + Math.ceil(3 * smoothSigma(p)) + Math.ceil(3 * featherSigma(p)) + Math.ceil(Math.abs(shiftAmount(p))) + 2;
+}
+function boxMean(src, w, h, r) {
+  const tmp = new Float32Array(w * h);
+  const pre = new Float64Array(Math.max(w, h) + 1);
+  for (let y = 0; y < h; y++) {
+    const row = y * w;
+    for (let x = 0; x < w; x++) pre[x + 1] = pre[x] + src[row + x];
+    for (let x = 0; x < w; x++) {
+      const lo = Math.max(0, x - r);
+      const hi = Math.min(w, x + r + 1);
+      tmp[row + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  const out = new Float32Array(w * h);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) pre[y + 1] = pre[y] + tmp[y * w + x];
+    for (let y = 0; y < h; y++) {
+      const lo = Math.max(0, y - r);
+      const hi = Math.min(h, y + r + 1);
+      out[y * w + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  return out;
+}
+function guidedFilterColor(guide, p, w, h, r, eps = GUIDED_FILTER_EPS) {
+  const n = w * h;
+  const [c0, c1, c2] = guide;
+  const prod = (a, b2) => {
+    const o = new Float32Array(n);
+    for (let i = 0; i < n; i++) o[i] = a[i] * b2[i];
+    return o;
+  };
+  const m0 = boxMean(c0, w, h, r);
+  const m1 = boxMean(c1, w, h, r);
+  const m2 = boxMean(c2, w, h, r);
+  const mp = boxMean(p, w, h, r);
+  const mip0 = boxMean(prod(c0, p), w, h, r);
+  const mip1 = boxMean(prod(c1, p), w, h, r);
+  const mip2 = boxMean(prod(c2, p), w, h, r);
+  const s00 = boxMean(prod(c0, c0), w, h, r);
+  const s01 = boxMean(prod(c0, c1), w, h, r);
+  const s02 = boxMean(prod(c0, c2), w, h, r);
+  const s11 = boxMean(prod(c1, c1), w, h, r);
+  const s12 = boxMean(prod(c1, c2), w, h, r);
+  const s22 = boxMean(prod(c2, c2), w, h, r);
+  const a0 = new Float32Array(n);
+  const a1 = new Float32Array(n);
+  const a2 = new Float32Array(n);
+  const b = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const u0 = m0[i], u1 = m1[i], u2 = m2[i], up = mp[i];
+    const rr = s00[i] - u0 * u0 + eps;
+    const rg = s01[i] - u0 * u1;
+    const rb = s02[i] - u0 * u2;
+    const gg = s11[i] - u1 * u1 + eps;
+    const gb = s12[i] - u1 * u2;
+    const bb = s22[i] - u2 * u2 + eps;
+    const v0 = mip0[i] - u0 * up;
+    const v1 = mip1[i] - u1 * up;
+    const v2 = mip2[i] - u2 * up;
+    const i00 = gg * bb - gb * gb;
+    const i01 = gb * rb - rg * bb;
+    const i02 = rg * gb - gg * rb;
+    const i11 = rr * bb - rb * rb;
+    const i12 = rb * rg - rr * gb;
+    const i22 = rr * gg - rg * rg;
+    const det = rr * i00 + rg * i01 + rb * i02;
+    let x0 = 0, x1 = 0, x2 = 0;
+    if (Math.abs(det) >= 1e-30) {
+      x0 = (i00 * v0 + i01 * v1 + i02 * v2) / det;
+      x1 = (i01 * v0 + i11 * v1 + i12 * v2) / det;
+      x2 = (i02 * v0 + i12 * v1 + i22 * v2) / det;
+    }
+    a0[i] = x0;
+    a1[i] = x1;
+    a2[i] = x2;
+    b[i] = up - x0 * u0 - x1 * u1 - x2 * u2;
+  }
+  const ma0 = boxMean(a0, w, h, r);
+  const ma1 = boxMean(a1, w, h, r);
+  const ma2 = boxMean(a2, w, h, r);
+  const mb = boxMean(b, w, h, r);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = ma0[i] * c0[i] + ma1[i] * c1[i] + ma2[i] * c2[i] + mb[i];
+  return out;
+}
+function edgeWidth(guide, w, h, r) {
+  const n = w * h;
+  const y = new Float32Array(n);
+  for (let i = 0; i < n; i++) y[i] = 0.299 * guide[0][i] + 0.587 * guide[1][i] + 0.114 * guide[2][i];
+  const g = new Float32Array(n);
+  for (let yy = 0; yy < h; yy++) {
+    for (let xx = 0; xx < w; xx++) {
+      const gx = (y[yy * w + Math.min(w - 1, xx + 1)] - y[yy * w + Math.max(0, xx - 1)]) / 2;
+      const gy = (y[Math.min(h - 1, yy + 1) * w + xx] - y[Math.max(0, yy - 1) * w + xx]) / 2;
+      g[yy * w + xx] = Math.sqrt(gx * gx + gy * gy);
+    }
+  }
+  const gm = greyMorphology(g, w, h, r, true);
+  const hi = greyMorphology(y, w, h, r, true);
+  const lo = greyMorphology(y, w, h, r, false);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = (hi[i] - lo[i]) / Math.max(gm[i], 1e-4);
+  return out;
+}
+function refineCoverage(guide, m, w, h, params = {}, band = null) {
+  const p = normalizeRefineEdgeParams(params);
+  let a = Float32Array.from(m);
+  if ((p.radius > 0 || band) && guide) {
+    const n = w * h;
+    const boundary = new Uint8Array(n);
+    let any = false;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const i = y * w + x;
+        const v = m[i] >= 0.5;
+        const diff = x > 0 && m[i - 1] >= 0.5 !== v || x + 1 < w && m[i + 1] >= 0.5 !== v || y > 0 && m[i - w] >= 0.5 !== v || y + 1 < h && m[i + w] >= 0.5 !== v;
+        if (diff) {
+          boundary[i] = 1;
+          any = true;
+        }
+      }
+    }
+    if (any || band) {
+      const dist = distanceTransform(boundary, w, h);
+      const r = band ? Math.max(4, gfRadius(p)) : gfRadius(p);
+      const q = guidedFilterColor(guide, m, w, h, r);
+      const widths = p.smartRadius ? edgeWidth(guide, w, h, r) : null;
+      for (let i = 0; i < n; i++) {
+        const reff = widths ? Math.min(Math.max(p.radius, 1.5), Math.max(1.5, widths[i])) : p.radius;
+        const edge = p.radius > 0 ? Math.min(1, Math.max(0, reff + 1 - dist[i])) : 0;
+        const wgt = band ? Math.max(edge, Math.min(1, Math.max(0, band[i]))) : edge;
+        if (wgt > 0) {
+          const qi = Math.min(1, Math.max(0, q[i]));
+          a[i] = m[i] + (qi - m[i]) * wgt;
+        }
+      }
+    }
+  }
+  const ss = smoothSigma(p);
+  if (ss >= 0.3) {
+    a = _chunkK6PXS6DOcjs.gaussianBlur.call(void 0, a, w, h, ss, "clamp");
+    const gain = 1 + ss;
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  a = _chunkK6PXS6DOcjs.gaussianBlur.call(void 0, a, w, h, featherSigma(p), "clamp");
+  if (p.contrast > 0) {
+    const gain = 1 / (1 - 0.99 * p.contrast / 100);
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  const amount = shiftAmount(p);
+  if (Math.abs(amount) >= 1e-4) a = shiftCoverage(a, w, h, amount);
+  return a;
+}
+function guidePlanes(pixels, win) {
+  const box = _nullishCoalesce(win, () => ( { x: 0, y: 0, width: pixels.width, height: pixels.height }));
+  const n = box.width * box.height;
+  const r = new Float32Array(n);
+  const g = new Float32Array(n);
+  const b = new Float32Array(n);
+  const d = pixels.data;
+  for (let y = 0; y < box.height; y++) {
+    for (let x = 0; x < box.width; x++) {
+      const i = y * box.width + x;
+      const p = ((box.y + y) * pixels.width + box.x + x) * 4;
+      r[i] = d[p] / 255;
+      g[i] = d[p + 1] / 255;
+      b[i] = d[p + 2] / 255;
+    }
+  }
+  return [r, g, b];
+}
+function refineSelection(pixels, mask, params = {}, refineBrush = null) {
+  const p = normalizeRefineEdgeParams(params);
+  if (pixels && (pixels.width !== mask.width || pixels.height !== mask.height)) {
+    throw new Error("Refine Edge needs pixels the size of the selection");
+  }
+  if (!mask.bounds) return mask;
+  const brush = _optionalChain([refineBrush, 'optionalAccess', _5 => _5.bounds]) ? refineBrush : null;
+  const halo = refineEdgeHalo(p) + (brush ? 2 * Math.max(4, gfRadius(p)) : 0);
+  const b = brush ? {
+    x: Math.min(mask.bounds.x, brush.bounds.x),
+    y: Math.min(mask.bounds.y, brush.bounds.y),
+    r: Math.max(mask.bounds.x + mask.bounds.width, brush.bounds.x + brush.bounds.width),
+    btm: Math.max(mask.bounds.y + mask.bounds.height, brush.bounds.y + brush.bounds.height)
+  } : { x: mask.bounds.x, y: mask.bounds.y, r: mask.bounds.x + mask.bounds.width, btm: mask.bounds.y + mask.bounds.height };
+  const x0 = Math.max(0, b.x - halo);
+  const y0 = Math.max(0, b.y - halo);
+  const x1 = Math.min(mask.width, b.r + halo);
+  const y1 = Math.min(mask.height, b.btm + halo);
+  const ww = x1 - x0;
+  const wh = y1 - y0;
+  const m = new Float32Array(ww * wh);
+  for (let y = 0; y < wh; y++) {
+    const src = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) m[y * ww + x] = mask.data[src + x] / 255;
+  }
+  const guide = pixels && (p.radius > 0 || brush) ? guidePlanes(pixels, { x: x0, y: y0, width: ww, height: wh }) : null;
+  let band = null;
+  if (brush) {
+    band = new Float32Array(ww * wh);
+    const bd = brush.data;
+    for (let y = 0; y < wh; y++) {
+      const src = (y0 + y) * mask.width + x0;
+      for (let x = 0; x < ww; x++) band[y * ww + x] = bd[src + x] / 255;
+    }
+  }
+  const refined = refineCoverage(guide, m, ww, wh, p, band);
+  const out = new Uint8Array(mask.width * mask.height);
+  for (let y = 0; y < wh; y++) {
+    const dst = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) out[dst + x] = coverageToByte(refined[y * ww + x]);
+  }
+  return createSelectionMask(mask.width, mask.height, out);
+}
+function decontaminateColors(rgba, coverage, w, h, amount, radius = 8) {
+  const out = Uint8ClampedArray.from(rgba);
+  const n = w * h;
+  const k = Math.min(1, Math.max(0, amount));
+  if (k === 0) return out;
+  const r = Math.max(2, Math.round(radius));
+  const fgW = new Float32Array(n);
+  const bgW = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    fgW[i] = coverage[i] >= 250 ? 1 : 0;
+    bgW[i] = coverage[i] <= 5 ? 1 : 0;
+  }
+  const meanOf = (weights, radiusPx) => {
+    const wm = boxMean(weights, w, h, radiusPx);
+    const planes = [0, 1, 2].map((c) => {
+      const v = new Float32Array(n);
+      for (let i = 0; i < n; i++) v[i] = rgba[i * 4 + c] * weights[i];
+      const m = boxMean(v, w, h, radiusPx);
+      for (let i = 0; i < n; i++) m[i] = wm[i] > 1e-6 ? m[i] / wm[i] : NaN;
+      return m;
+    });
+    return { weight: wm, planes };
+  };
+  const fg = meanOf(fgW, r);
+  const fgWide = meanOf(fgW, r * 3);
+  const bg = meanOf(bgW, r);
+  for (let i = 0; i < n; i++) {
+    const c = coverage[i];
+    if (c <= 5 || c >= 250) continue;
+    const a = c / 255;
+    for (let ch = 0; ch < 3; ch++) {
+      const C = rgba[i * 4 + ch];
+      const B = bg.planes[ch][i];
+      const Fm = Number.isNaN(fg.planes[ch][i]) ? fgWide.planes[ch][i] : fg.planes[ch][i];
+      let F;
+      if (a >= 0.5 && !Number.isNaN(B)) F = (C - (1 - a) * B) / a;
+      else if (!Number.isNaN(Fm)) F = Fm;
+      else F = C;
+      out[i * 4 + ch] = Math.round(C + k * (Math.min(255, Math.max(0, F)) - C));
+    }
+  }
+  return out;
+}
 
 // src/image-editor/selection/shapes.ts
 function polygonCoverage(points, width, height, antiAlias = true) {
@@ -89,10 +1096,10 @@ function polygonCoverageBox(points, width, height, antiAlias = true) {
 }
 function polygonSelection(width, height, points, options = {}) {
   const { box, coverage } = polygonCoverageBox(points, width, height, _nullishCoalesce(options.antiAlias, () => ( true)));
-  if (!box) return _chunkSS53NNZOcjs.createSelectionMask.call(void 0, width, height);
+  if (!box) return createSelectionMask(width, height);
   const out = new Uint8Array(coverage.length);
-  for (let i = 0; i < out.length; i++) out[i] = _chunkSS53NNZOcjs.coverageToByte.call(void 0, coverage[i]);
-  return _chunkSS53NNZOcjs.selectionFromRegion.call(void 0, width, height, box, out);
+  for (let i = 0; i < out.length; i++) out[i] = coverageToByte(coverage[i]);
+  return selectionFromRegion(width, height, box, out);
 }
 function normalizeRect(rect) {
   const x = rect.width < 0 ? rect.x + rect.width : rect.x;
@@ -376,7 +1383,7 @@ var WORK_SIZE = 512;
 var workCache = /* @__PURE__ */ new WeakMap();
 function workImage(pixels, maxSide = WORK_SIZE) {
   const sizes = workCache.get(pixels.data);
-  const cached = _optionalChain([sizes, 'optionalAccess', _ => _.get, 'call', _2 => _2(maxSide)]);
+  const cached = _optionalChain([sizes, 'optionalAccess', _6 => _6.get, 'call', _7 => _7(maxSide)]);
   if (cached && cached.sourceWidth === pixels.width && cached.sourceHeight === pixels.height) return cached;
   const { width: W, height: H, data } = pixels;
   const scale = Math.min(1, maxSide / Math.max(W, H));
@@ -555,18 +1562,18 @@ function upscaleRegion(work, pixels, roi, label, enhance) {
       out[Y * RW + X] = Math.round(alpha * 255);
     }
   }
-  return _chunkSS53NNZOcjs.selectionFromRegion.call(void 0, W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
+  return selectionFromRegion(W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
 }
 
 // src/image-editor/selection/segment/grabcut.ts
 var K = 5;
-var ColorGmm = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this); }
-  __init() {this.logWeight = new Float64Array(K)}
-  __init2() {this.mean = new Float64Array(K * 3)}
+var ColorGmm = (_class2 = class {constructor() { _class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this); }
+  __init2() {this.logWeight = new Float64Array(K)}
+  __init3() {this.mean = new Float64Array(K * 3)}
   /** Inverse covariances, row-major 3 × 3. */
-  __init3() {this.inv = new Float64Array(K * 9)}
+  __init4() {this.inv = new Float64Array(K * 9)}
   /** ln(weight) − ½ ln((2π)³ |Σ|) per component; −∞ for an empty one. */
-  __init4() {this.logNorm = new Float64Array(K).fill(-Infinity)}
+  __init5() {this.logNorm = new Float64Array(K).fill(-Infinity)}
   /** Fits the components to the pixels `ids` of `rgb`, each in component `comp[id]`. */
   fit(rgb, ids, comp) {
     const n = new Float64Array(K);
@@ -651,7 +1658,7 @@ var ColorGmm = (_class = class {constructor() { _class.prototype.__init.call(thi
     }
     return best;
   }
-}, _class);
+}, _class2);
 function initialComponents(rgb, ids, comp) {
   if (!ids.length) return;
   const step = Math.max(1, Math.floor(ids.length / 6e3));
@@ -717,7 +1724,7 @@ function grabCutLabels(work, setup, iterations, onRound) {
     const graph = new GridGraph(rw, rh);
     for (let p = 0; p < n; p++) {
       if (hardBg[p]) graph.addTerminal(p, 0, HARD);
-      else if (_optionalChain([hardFg, 'optionalAccess', _3 => _3[p]])) graph.addTerminal(p, HARD, 0);
+      else if (_optionalChain([hardFg, 'optionalAccess', _8 => _8[p]])) graph.addTerminal(p, HARD, 0);
       else {
         const i = global[p] * 3;
         graph.addTerminal(p, Math.round(bg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS), Math.round(fg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS));
@@ -732,7 +1739,7 @@ function grabCutLabels(work, setup, iterations, onRound) {
       if (v !== label[p]) changed++;
       label[p] = v;
     }
-    _optionalChain([onRound, 'optionalCall', _4 => _4((iter + 1) / iterations)]);
+    _optionalChain([onRound, 'optionalCall', _9 => _9((iter + 1) / iterations)]);
     if (changed <= n * 1e-3) break;
   }
   return label;
@@ -768,10 +1775,10 @@ function keepMainPieces(label, rw, rh, seed) {
 }
 function selectObjectIn(pixels, target, options = {}) {
   const report = options.onProgress;
-  _optionalChain([report, 'optionalCall', _5 => _5(0, "Reducing the image")]);
+  _optionalChain([report, 'optionalCall', _10 => _10(0, "Reducing the image")]);
   const work = workImage(pixels);
-  _optionalChain([report, 'optionalCall', _6 => _6(0.1, "Finding the object")]);
-  const round = (fraction) => _optionalChain([report, 'optionalCall', _7 => _7(0.1 + 0.8 * fraction, "Finding the object")]);
+  _optionalChain([report, 'optionalCall', _11 => _11(0.1, "Finding the object")]);
+  const round = (fraction) => _optionalChain([report, 'optionalCall', _12 => _12(0.1 + 0.8 * fraction, "Finding the object")]);
   const { width: w, height: h, scale } = work;
   const iterations = Math.max(1, Math.round(_nullishCoalesce(options.iterations, () => ( 5))));
   const enhance = _nullishCoalesce(options.enhanceEdge, () => ( false));
@@ -781,7 +1788,7 @@ function selectObjectIn(pixels, target, options = {}) {
     const by0 = Math.max(0, Math.floor(r.y * scale));
     const bx1 = Math.min(w, Math.ceil((r.x + r.width) * scale));
     const by1 = Math.min(h, Math.ceil((r.y + r.height) * scale));
-    if (bx1 - bx0 < 2 || by1 - by0 < 2) return _chunkSS53NNZOcjs.createSelectionMask.call(void 0, pixels.width, pixels.height);
+    if (bx1 - bx0 < 2 || by1 - by0 < 2) return createSelectionMask(pixels.width, pixels.height);
     const m = Math.max(8, Math.round(0.25 * Math.max(bx1 - bx0, by1 - by0)));
     const rx = Math.max(0, bx0 - m);
     const ry = Math.max(0, by0 - m);
@@ -800,9 +1807,9 @@ function selectObjectIn(pixels, target, options = {}) {
     }
     const label = grabCutLabels(work, { roi, initial, hardBg, hardFg: null }, iterations, round);
     keepMainPieces(label, roi.width, roi.height, null);
-    _optionalChain([report, 'optionalCall', _8 => _8(0.9, "Scaling up")]);
+    _optionalChain([report, 'optionalCall', _13 => _13(0.9, "Scaling up")]);
     const out = upscaleRegion(work, pixels, roi, label, enhance);
-    _optionalChain([report, 'optionalCall', _9 => _9(1, "Done")]);
+    _optionalChain([report, 'optionalCall', _14 => _14(1, "Done")]);
     return out;
   }
   const px = Math.min(w - 1, Math.max(0, Math.floor(target.point.x * scale)));
@@ -864,9 +1871,9 @@ function selectObjectIn(pixels, target, options = {}) {
       small = !s.touches && s.found > 1.5 * s.seeded ? { roi, label: s.label } : null;
     }
     if (!touches || whole) {
-      _optionalChain([report, 'optionalCall', _10 => _10(0.9, "Scaling up")]);
+      _optionalChain([report, 'optionalCall', _15 => _15(0.9, "Scaling up")]);
       const out = small && edgesReached(label, roi, w, h) >= 3 ? upscaleRegion(work, pixels, small.roi, small.label, enhance) : upscaleRegion(work, pixels, roi, label, enhance);
-      _optionalChain([report, 'optionalCall', _11 => _11(1, "Done")]);
+      _optionalChain([report, 'optionalCall', _16 => _16(1, "Done")]);
       return out;
     }
     half = Math.round(half * 1.6);
@@ -953,7 +1960,7 @@ function segmentStroke(work, stroke, grown, start) {
         const bin = binOf(rgb, g);
         bgHist[bin]++;
         bgN++;
-        if (stroke.mask[g] || _optionalChain([grown, 'optionalAccess', _12 => _12[g]])) {
+        if (stroke.mask[g] || _optionalChain([grown, 'optionalAccess', _17 => _17[g]])) {
           fgHist[bin]++;
           fgN++;
         }
@@ -1035,12 +2042,12 @@ function quickSelectStroke(pixels, stroke, options = {}) {
   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', _13 => _13.bounds])) {
+  if (_optionalChain([sel, 'optionalAccess', _18 => _18.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 (_chunkSS53NNZOcjs.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;
+        if (selectionValueAt(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;
       }
     }
   }
@@ -1064,7 +2071,7 @@ function brushStrokeMask(width, height, points, size, hardness = 1) {
   const by = Math.max(0, Math.floor(y0 - r - 1));
   const bw = Math.min(width, Math.ceil(x1 + r + 1)) - bx;
   const bh = Math.min(height, Math.ceil(y1 + r + 1)) - by;
-  if (!(bw > 0 && bh > 0)) return _chunkSS53NNZOcjs.createSelectionMask.call(void 0, width, height);
+  if (!(bw > 0 && bh > 0)) return createSelectionMask(width, height);
   const out = new Uint8Array(bw * bh);
   const segs = points.length === 1 ? [[points[0], points[0]]] : points.slice(1).map((p, i) => [points[i], p]);
   for (let y = 0; y < bh; y++) {
@@ -1084,27 +2091,27 @@ function brushStrokeMask(width, height, points, size, hardness = 1) {
       out[y * bw + x] = Math.round(Math.max(0, v) * 255);
     }
   }
-  return _chunkSS53NNZOcjs.selectionFromRegion.call(void 0, width, height, { x: bx, y: by, width: bw, height: bh }, out);
+  return selectionFromRegion(width, height, { x: bx, y: by, width: bw, height: bh }, out);
 }
 function applyRefineEdits(pixels, selection, edits, width, height) {
-  let sel = _optionalChain([selection, 'optionalAccess', _14 => _14.bounds]) ? selection : null;
+  let sel = _optionalChain([selection, 'optionalAccess', _19 => _19.bounds]) ? selection : null;
   let band = null;
   for (const e of edits) {
     if (e.kind === "object") {
       if (!pixels) throw new Error("Object Selection needs the image pixels.");
       if (!e.rect === !e.point) throw new Error("An object edit takes rect (a box around the object) or point (on it), not both.");
       const region2 = selectObjectIn(pixels, e.rect ? { rect: e.rect } : { point: e.point });
-      sel = _chunkSS53NNZOcjs.combineSelections.call(void 0, sel, region2, _nullishCoalesce(e.mode, () => ( "add")));
+      sel = combineSelections(sel, region2, _nullishCoalesce(e.mode, () => ( "add")));
       continue;
     }
     if (!e.points.length) throw new Error(`A ${e.kind} stroke needs at least one point.`);
     if (e.kind === "lasso") {
       if (e.points.length < 3) throw new Error("A lasso edit needs at least 3 points.");
-      sel = _chunkSS53NNZOcjs.combineSelections.call(void 0, sel, polygonSelection(width, height, e.points, {}), _nullishCoalesce(e.mode, () => ( "add")));
+      sel = combineSelections(sel, polygonSelection(width, height, e.points, {}), _nullishCoalesce(e.mode, () => ( "add")));
       continue;
     }
     if (e.kind === "refine-brush") {
-      band = _chunkSS53NNZOcjs.combineSelections.call(void 0, band, brushStrokeMask(width, height, e.points, _nullishCoalesce(e.size, () => ( 40))), "add");
+      band = combineSelections(band, brushStrokeMask(width, height, e.points, _nullishCoalesce(e.size, () => ( 40))), "add");
       continue;
     }
     const mode = _nullishCoalesce(e.mode, () => ( "add"));
@@ -1115,7 +2122,7 @@ function applyRefineEdits(pixels, selection, edits, width, height) {
     } else {
       region = brushStrokeMask(width, height, e.points, _nullishCoalesce(e.size, () => ( 20)), _nullishCoalesce(e.hardness, () => ( 1)));
     }
-    sel = _chunkSS53NNZOcjs.combineSelections.call(void 0, sel, region, mode);
+    sel = combineSelections(sel, region, mode);
   }
   return { selection: sel, refineBrush: band };
 }
@@ -1162,7 +2169,7 @@ function softMaskToSelection(work, mask) {
       out[Y * W + X] = Math.round(Math.min(1, Math.max(0, m)) * 255);
     }
   }
-  return _chunkSS53NNZOcjs.selectionFromRegion.call(void 0, W, H, { x: 0, y: 0, width: W, height: H }, out);
+  return selectionFromRegion(W, H, { x: 0, y: 0, width: W, height: H }, out);
 }
 
 // src/image-editor/selection/segment/subject.ts
@@ -1334,14 +2341,14 @@ function otsuThreshold(values, weights) {
 }
 function findSubject(pixels, options = {}) {
   const report = options.onProgress;
-  _optionalChain([report, 'optionalCall', _15 => _15(0, "Reducing the image")]);
+  _optionalChain([report, 'optionalCall', _20 => _20(0, "Reducing the image")]);
   const work = workImage(pixels);
   const { width: w, height: h } = work;
-  _optionalChain([report, 'optionalCall', _16 => _16(0.1, "Grouping into superpixels")]);
+  _optionalChain([report, 'optionalCall', _21 => _21(0.1, "Grouping into superpixels")]);
   const sp = slicSuperpixels(work);
-  _optionalChain([report, 'optionalCall', _17 => _17(0.3, "Measuring what stands out")]);
+  _optionalChain([report, 'optionalCall', _22 => _22(0.3, "Measuring what stands out")]);
   const sal = superpixelSaliency(sp, w, h);
-  _optionalChain([report, 'optionalCall', _18 => _18(0.4, "Finding the subject")]);
+  _optionalChain([report, 'optionalCall', _23 => _23(0.4, "Finding the subject")]);
   const t = otsuThreshold(sal, sp.size);
   const n = w * h;
   const initial = new Uint8Array(n);
@@ -1359,20 +2366,20 @@ function findSubject(pixels, options = {}) {
   for (let y = 0; y < h; y++) {
     for (const x of [0, w - 1]) if (sal[sp.label[y * w + x]] < t * 0.5) hardBg[y * w + x] = 1;
   }
-  const empty = (reason) => ({ selection: _chunkSS53NNZOcjs.createSelectionMask.call(void 0, pixels.width, pixels.height), reason });
+  const empty = (reason) => ({ selection: createSelectionMask(pixels.width, pixels.height), reason });
   let guessed = 0;
   for (let i = 0; i < n; i++) guessed += initial[i];
   if (!guessed || guessed > n * 0.95) return empty("Nothing stands out from the background.");
   const roi = { x: 0, y: 0, width: w, height: h };
-  const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, 5, (f) => _optionalChain([report, 'optionalCall', _19 => _19(0.4 + 0.5 * f, "Finding the subject")]));
+  const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, 5, (f) => _optionalChain([report, 'optionalCall', _24 => _24(0.4 + 0.5 * f, "Finding the subject")]));
   keepMainPieces(label, w, h, null);
   let kept = 0;
   for (let i = 0; i < n; i++) kept += label[i];
   if (kept < n * 2e-3) return empty("Nothing stands out from the background.");
   if (kept > n * 0.97) return empty("The whole image looks like one subject; select it with select_all instead.");
-  _optionalChain([report, 'optionalCall', _20 => _20(0.9, "Scaling up")]);
+  _optionalChain([report, 'optionalCall', _25 => _25(0.9, "Scaling up")]);
   const selection = upscaleRegion(work, pixels, roi, label, _nullishCoalesce(options.enhanceEdge, () => ( false)));
-  _optionalChain([report, 'optionalCall', _21 => _21(1, "Done")]);
+  _optionalChain([report, 'optionalCall', _26 => _26(1, "Done")]);
   return { selection };
 }
 
@@ -1392,9 +2399,9 @@ function estimateNoise(luma, w, h) {
 }
 function focusArea(pixels, options = {}) {
   const report = options.onProgress;
-  _optionalChain([report, 'optionalCall', _22 => _22(0, "Reducing the image")]);
+  _optionalChain([report, 'optionalCall', _27 => _27(0, "Reducing the image")]);
   const work = workImage(pixels, FOCUS_SIZE);
-  _optionalChain([report, 'optionalCall', _23 => _23(0.2, "Measuring sharpness")]);
+  _optionalChain([report, 'optionalCall', _28 => _28(0.2, "Measuring sharpness")]);
   const { width: w, height: h, scale } = work;
   const n = w * h;
   const luma = workLuma(work);
@@ -1411,10 +2418,10 @@ function focusArea(pixels, options = {}) {
     }
   }
   const r = Math.max(2, Math.round(0.012 * Math.max(w, h)));
-  const energy = _chunkSS53NNZOcjs.boxMean.call(void 0, detail, w, h, r);
+  const energy = boxMean(detail, w, h, r);
   const sharp = new Float32Array(n);
   for (let i = 0; i < n; i++) sharp[i] = Math.log1p(Math.sqrt(energy[i]) * 400);
-  _optionalChain([report, 'optionalCall', _24 => _24(0.5, "Separating what is in focus")]);
+  _optionalChain([report, 'optionalCall', _29 => _29(0.5, "Separating what is in focus")]);
   const sorted = Float32Array.from(sharp).sort();
   const top = sorted[Math.floor(n * 0.995)] || 1;
   for (let i = 0; i < n; i++) sharp[i] = Math.min(1, sharp[i] / top);
@@ -1425,20 +2432,20 @@ function focusArea(pixels, options = {}) {
   let mask = new Float32Array(n);
   for (let i = 0; i < n; i++) mask[i] = sharp[i] >= t ? 1 : 0;
   const c = 2 * r;
-  const grown = _chunkSS53NNZOcjs.boxMean.call(void 0, mask, w, h, c);
+  const grown = boxMean(mask, w, h, c);
   for (let i = 0; i < n; i++) grown[i] = grown[i] > 1e-3 ? 1 : 0;
-  const shrunk = _chunkSS53NNZOcjs.boxMean.call(void 0, grown, w, h, c);
+  const shrunk = boxMean(grown, w, h, c);
   for (let i = 0; i < n; i++) mask[i] = shrunk[i] >= 0.999 ? 1 : 0;
-  const pulled = _chunkSS53NNZOcjs.boxMean.call(void 0, mask, w, h, Math.max(1, Math.round(r / 2)));
+  const pulled = boxMean(mask, w, h, Math.max(1, Math.round(r / 2)));
   for (let i = 0; i < n; i++) mask[i] = pulled[i] >= 0.999 ? 1 : 0;
-  _optionalChain([report, 'optionalCall', _25 => _25(0.7, "Fitting the edge")]);
+  _optionalChain([report, 'optionalCall', _30 => _30(0.7, "Fitting the edge")]);
   const softness = Math.max(0, _nullishCoalesce(options.softness, () => ( 4))) * scale;
   if (softness > 0) {
-    const fitted = _chunkSS53NNZOcjs.guidedFilterColor.call(void 0, workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
+    const fitted = guidedFilterColor(workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
     for (let i = 0; i < n; i++) mask[i] = Math.min(1, Math.max(0, fitted[i]));
   }
   const selection = softMaskToSelection(work, mask);
-  _optionalChain([report, 'optionalCall', _26 => _26(1, "Done")]);
+  _optionalChain([report, 'optionalCall', _31 => _31(1, "Done")]);
   return { selection, noiseLevel: Math.round(sigma * 255 * 10) / 10 };
 }
 
@@ -1461,9 +2468,9 @@ function lab(r, g, b) {
 var sigmoid = (v) => 1 / (1 + Math.exp(-v));
 function findSky(pixels, options = {}) {
   const report = options.onProgress;
-  _optionalChain([report, 'optionalCall', _27 => _27(0, "Reducing the image")]);
+  _optionalChain([report, 'optionalCall', _32 => _32(0, "Reducing the image")]);
   const work = workImage(pixels, SKY_SIZE);
-  _optionalChain([report, 'optionalCall', _28 => _28(0.2, "Scoring the sky")]);
+  _optionalChain([report, 'optionalCall', _33 => _33(0.2, "Scoring the sky")]);
   const { width: w, height: h, rgb, scale } = work;
   const n = w * h;
   const L = new Float32Array(n);
@@ -1475,7 +2482,7 @@ function findSky(pixels, options = {}) {
     A[i] = a;
     B[i] = b;
   }
-  const luma = _chunkSS53NNZOcjs.boxMean.call(void 0, workLuma(work), w, h, 1);
+  const luma = boxMean(workLuma(work), w, h, 1);
   const grad = new Float32Array(n);
   for (let y = 0; y < h; y++) {
     for (let x = 0; x < w; x++) {
@@ -1486,7 +2493,7 @@ function findSky(pixels, options = {}) {
     }
   }
   const roughR = Math.max(1, Math.round(6e-3 * Math.max(w, h)));
-  const rough = _chunkSS53NNZOcjs.boxMean.call(void 0, grad, w, h, roughR);
+  const rough = boxMean(grad, w, h, roughR);
   const score = new Float32Array(n);
   for (let i = 0; i < n; i++) {
     const chroma = Math.hypot(A[i], B[i]);
@@ -1499,7 +2506,7 @@ function findSky(pixels, options = {}) {
   }
   const threshold = Math.min(100, Math.max(0, _nullishCoalesce(options.threshold, () => ( 50))));
   const t = 0.55 - (threshold - 50) * 6e-3;
-  _optionalChain([report, 'optionalCall', _29 => _29(0.5, "Growing the sky")]);
+  _optionalChain([report, 'optionalCall', _34 => _34(0.5, "Growing the sky")]);
   const sky = new Uint8Array(n);
   const stack = [];
   const seedRows = Math.max(1, Math.round(h * 0.04));
@@ -1512,7 +2519,7 @@ function findSky(pixels, options = {}) {
       }
     }
   }
-  if (!stack.length) return { selection: _chunkSS53NNZOcjs.createSelectionMask.call(void 0, pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
+  if (!stack.length) return { selection: createSelectionMask(pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
   const low = t * 0.7;
   while (stack.length) {
     const p = stack.pop();
@@ -1556,17 +2563,17 @@ function findSky(pixels, options = {}) {
     }
     front = next;
   }
-  if (count < n * 5e-3) return { selection: _chunkSS53NNZOcjs.createSelectionMask.call(void 0, pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
-  _optionalChain([report, 'optionalCall', _30 => _30(0.7, "Fitting the edge")]);
+  if (count < n * 5e-3) return { selection: createSelectionMask(pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
+  _optionalChain([report, 'optionalCall', _35 => _35(0.7, "Fitting the edge")]);
   let mask = Float32Array.from(sky);
   const softness = Math.max(0, _nullishCoalesce(options.softness, () => ( 4))) * scale;
   if (softness > 0) {
-    const fitted = _chunkSS53NNZOcjs.guidedFilterColor.call(void 0, workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
+    const fitted = guidedFilterColor(workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
     mask = new Float32Array(n);
     for (let i = 0; i < n; i++) mask[i] = Math.min(1, Math.max(0, fitted[i]));
   }
   const selection = softMaskToSelection(work, mask);
-  _optionalChain([report, 'optionalCall', _31 => _31(1, "Done")]);
+  _optionalChain([report, 'optionalCall', _36 => _36(1, "Done")]);
   return { selection };
 }
 
@@ -1580,7 +2587,7 @@ function serializeMask(mask) {
   return { width: mask.width, height: mask.height, bounds: { ...b }, bytes };
 }
 function deserializeMask(s) {
-  return s.bounds ? _chunkSS53NNZOcjs.selectionFromRegion.call(void 0, s.width, s.height, s.bounds, s.bytes) : _chunkSS53NNZOcjs.createSelectionMask.call(void 0, s.width, s.height);
+  return s.bounds ? selectionFromRegion(s.width, s.height, s.bounds, s.bytes) : createSelectionMask(s.width, s.height);
 }
 function runSelectionJob(job, pixels, onProgress) {
   switch (job.op) {
@@ -1608,21 +2615,21 @@ function runSelectionJob(job, pixels, onProgress) {
         })
       };
     case "fill": {
-      _optionalChain([onProgress, 'optionalCall', _32 => _32(0, "Filling")]);
+      _optionalChain([onProgress, 'optionalCall', _37 => _37(0, "Filling")]);
       const filled = _chunkBB6TR422cjs.contentAwareFill.call(void 0, pixels.width, pixels.height, 4, pixels.data, job.hole, {
         seed: job.seed,
         exclude: job.exclude,
-        onProgress: (f) => _optionalChain([onProgress, 'optionalCall', _33 => _33(f * 0.99, "Filling")])
+        onProgress: (f) => _optionalChain([onProgress, 'optionalCall', _38 => _38(f * 0.99, "Filling")])
       });
-      _optionalChain([onProgress, 'optionalCall', _34 => _34(1, "Done")]);
-      return { mask: _chunkSS53NNZOcjs.createSelectionMask.call(void 0, 1, 1), pixels: Uint8ClampedArray.from(filled) };
+      _optionalChain([onProgress, 'optionalCall', _39 => _39(1, "Done")]);
+      return { mask: createSelectionMask(1, 1), pixels: Uint8ClampedArray.from(filled) };
     }
     case "refine-preview": {
-      _optionalChain([onProgress, 'optionalCall', _35 => _35(0, "Refining")]);
+      _optionalChain([onProgress, 'optionalCall', _40 => _40(0, "Refining")]);
       const base = job.base ? deserializeMask(job.base) : null;
       const { selection, refineBrush } = applyRefineEdits(pixels, base, job.edits, pixels.width, pixels.height);
-      const mask = _optionalChain([selection, 'optionalAccess', _36 => _36.bounds]) ? _chunkSS53NNZOcjs.refineSelection.call(void 0, pixels, selection, job.params, refineBrush) : _chunkSS53NNZOcjs.createSelectionMask.call(void 0, pixels.width, pixels.height);
-      _optionalChain([onProgress, 'optionalCall', _37 => _37(1, "Done")]);
+      const mask = _optionalChain([selection, 'optionalAccess', _41 => _41.bounds]) ? refineSelection(pixels, selection, job.params, refineBrush) : createSelectionMask(pixels.width, pixels.height);
+      _optionalChain([onProgress, 'optionalCall', _42 => _42(1, "Done")]);
       return { mask };
     }
   }
@@ -1650,20 +2657,20 @@ function startSelectionWorker(scope) {
   };
 }
 var abortError = () => typeof DOMException === "function" ? new DOMException("The selection was cancelled.", "AbortError") : Object.assign(new Error("The selection was cancelled."), { name: "AbortError" });
-var SelectionWorkerClient = (_class2 = class {
-  constructor(factory) {;_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);
+var SelectionWorkerClient = (_class3 = class {
+  constructor(factory) {;_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
     this.factory = factory;
   }
   
-  __init5() {this.worker = null}
+  __init6() {this.worker = null}
   /** Pixel buffers this worker already has, by their data array. */
-  __init6() {this.sent = /* @__PURE__ */ new WeakMap()}
-  __init7() {this.nextKey = 1}
-  __init8() {this.nextId = 1}
-  __init9() {this.pending = /* @__PURE__ */ new Map()}
+  __init7() {this.sent = /* @__PURE__ */ new WeakMap()}
+  __init8() {this.nextKey = 1}
+  __init9() {this.nextId = 1}
+  __init10() {this.pending = /* @__PURE__ */ new Map()}
   /** Runs `job` on `pixels` in the worker. Aborting `signal` terminates the worker and rejects with an `AbortError`. */
   run(job, pixels, options = {}) {
-    if (_optionalChain([options, 'access', _38 => _38.signal, 'optionalAccess', _39 => _39.aborted])) return Promise.reject(abortError());
+    if (_optionalChain([options, 'access', _43 => _43.signal, 'optionalAccess', _44 => _44.aborted])) return Promise.reject(abortError());
     const worker = this.ensure();
     let key = this.sent.get(pixels.data);
     if (key === void 0) {
@@ -1674,7 +2681,7 @@ var SelectionWorkerClient = (_class2 = class {
     const id = this.nextId++;
     return new Promise((resolve, reject) => {
       this.pending.set(id, { resolve, reject, onProgress: options.onProgress });
-      _optionalChain([options, 'access', _40 => _40.signal, 'optionalAccess', _41 => _41.addEventListener, 'call', _42 => _42(
+      _optionalChain([options, 'access', _45 => _45.signal, 'optionalAccess', _46 => _46.addEventListener, 'call', _47 => _47(
         "abort",
         () => {
           if (this.pending.has(id)) this.terminate(abortError());
@@ -1686,7 +2693,7 @@ var SelectionWorkerClient = (_class2 = class {
   }
   /** Stops the worker; jobs still running reject with `reason` (default an `AbortError`). */
   terminate(reason = abortError()) {
-    _optionalChain([this, 'access', _43 => _43.worker, 'optionalAccess', _44 => _44.terminate, 'optionalCall', _45 => _45()]);
+    _optionalChain([this, 'access', _48 => _48.worker, 'optionalAccess', _49 => _49.terminate, 'optionalCall', _50 => _50()]);
     this.worker = null;
     this.sent = /* @__PURE__ */ new WeakMap();
     const pending = [...this.pending.values()];
@@ -1700,18 +2707,64 @@ var SelectionWorkerClient = (_class2 = class {
       const msg = event.data;
       const p = this.pending.get(msg.id);
       if (!p) return;
-      if (msg.type === "progress") _optionalChain([p, 'access', _46 => _46.onProgress, 'optionalCall', _47 => _47(msg.fraction, msg.stage)]);
+      if (msg.type === "progress") _optionalChain([p, 'access', _51 => _51.onProgress, 'optionalCall', _52 => _52(msg.fraction, msg.stage)]);
       else {
         this.pending.delete(msg.id);
         if (msg.type === "error") p.reject(new Error(msg.message));
         else p.resolve({ mask: deserializeMask(msg.mask), reason: msg.reason, noiseLevel: msg.noiseLevel, pixels: msg.pixels });
       }
     };
-    worker.onerror = (event) => this.terminate(new Error(_optionalChain([event, 'optionalAccess', _48 => _48.message]) || "The selection worker failed."));
+    worker.onerror = (event) => this.terminate(new Error(_optionalChain([event, 'optionalAccess', _53 => _53.message]) || "The selection worker failed."));
     this.worker = worker;
     return worker;
   }
-}, _class2);
+}, _class3);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -1751,4 +2804,4 @@ var SelectionWorkerClient = (_class2 = class {
 
 
 
-exports.polygonCoverage = polygonCoverage; exports.polygonCoverageBox = polygonCoverageBox; exports.polygonSelection = polygonSelection; exports.normalizeRect = normalizeRect; exports.rectSelection = rectSelection; exports.ellipsePoints = ellipsePoints; exports.ellipseSelection = ellipseSelection; exports.GridGraph = GridGraph; exports.WORK_SIZE = WORK_SIZE; exports.workImage = workImage; exports.GAMMA = GAMMA; exports.UNITS = UNITS; exports.smoothnessWeights = smoothnessWeights; exports.boxBlur = boxBlur; exports.upscaleRegion = upscaleRegion; exports.ColorGmm = ColorGmm; exports.grabCutLabels = grabCutLabels; exports.keepMainPieces = keepMainPieces; exports.selectObjectIn = selectObjectIn; exports.quickSelectStroke = quickSelectStroke; exports.REFINE_EDIT_KINDS = REFINE_EDIT_KINDS; exports.brushStrokeMask = brushStrokeMask; exports.applyRefineEdits = applyRefineEdits; exports.workPlanes = workPlanes; exports.workLuma = workLuma; exports.softMaskToSelection = softMaskToSelection; exports.slicSuperpixels = slicSuperpixels; exports.superpixelSaliency = superpixelSaliency; exports.otsuThreshold = otsuThreshold; exports.findSubject = findSubject; exports.focusArea = focusArea; exports.findSky = findSky; exports.serializeMask = serializeMask; exports.deserializeMask = deserializeMask; exports.runSelectionJob = runSelectionJob; exports.startSelectionWorker = startSelectionWorker; exports.SelectionWorkerClient = SelectionWorkerClient;
+exports.SELECTION_MODES = SELECTION_MODES; exports.isSelectionMode = isSelectionMode; exports.parseSelectionMode = parseSelectionMode; exports.computeSelectionBounds = computeSelectionBounds; exports.selectionFromTiles = selectionFromTiles; exports.createSelectionMask = createSelectionMask; exports.selectionFromRegion = selectionFromRegion; exports.fullSelection = fullSelection; exports.isSelectionEmpty = isSelectionEmpty; exports.selectionValueAt = selectionValueAt; exports.coverageToByte = coverageToByte; exports.selectionFromCoverage = selectionFromCoverage; exports.selectionToCoverage = selectionToCoverage; exports.selectionArea = selectionArea; exports.combineSelections = combineSelections; exports.invertSelection = invertSelection; exports.resizeSelection = resizeSelection; exports.selectionFromPixels = selectionFromPixels; exports.selectionToPixels = selectionToPixels; exports.encodeSelectionRle = encodeSelectionRle; exports.decodeSelectionRle = decodeSelectionRle; exports.serializeSelection = serializeSelection; exports.deserializeSelection = deserializeSelection; exports.hashMaskContent = hashMaskContent; exports.EMPTY_DISTANCE = EMPTY_DISTANCE; exports.distanceTransform = distanceTransform; exports.expandCoverage = expandCoverage; exports.contractCoverage = contractCoverage; exports.borderCoverage = borderCoverage; exports.smoothCoverage = smoothCoverage; exports.featherCoverage = featherCoverage; exports.greyMorphology = greyMorphology; exports.shiftCoverage = shiftCoverage; exports.SELECTION_MODIFY_OPS = SELECTION_MODIFY_OPS; exports.modifySelection = modifySelection; exports.DEFAULT_REFINE_EDGE_PARAMS = DEFAULT_REFINE_EDGE_PARAMS; exports.GUIDED_FILTER_EPS = GUIDED_FILTER_EPS; exports.normalizeRefineEdgeParams = normalizeRefineEdgeParams; exports.refineEdgeHalo = refineEdgeHalo; exports.boxMean = boxMean; exports.guidedFilterColor = guidedFilterColor; exports.edgeWidth = edgeWidth; exports.refineCoverage = refineCoverage; exports.guidePlanes = guidePlanes; exports.refineSelection = refineSelection; exports.decontaminateColors = decontaminateColors; exports.polygonCoverage = polygonCoverage; exports.polygonCoverageBox = polygonCoverageBox; exports.polygonSelection = polygonSelection; exports.normalizeRect = normalizeRect; exports.rectSelection = rectSelection; exports.ellipsePoints = ellipsePoints; exports.ellipseSelection = ellipseSelection; exports.GridGraph = GridGraph; exports.WORK_SIZE = WORK_SIZE; exports.workImage = workImage; exports.GAMMA = GAMMA; exports.UNITS = UNITS; exports.smoothnessWeights = smoothnessWeights; exports.boxBlur = boxBlur; exports.upscaleRegion = upscaleRegion; exports.ColorGmm = ColorGmm; exports.grabCutLabels = grabCutLabels; exports.keepMainPieces = keepMainPieces; exports.selectObjectIn = selectObjectIn; exports.quickSelectStroke = quickSelectStroke; exports.REFINE_EDIT_KINDS = REFINE_EDIT_KINDS; exports.brushStrokeMask = brushStrokeMask; exports.applyRefineEdits = applyRefineEdits; exports.workPlanes = workPlanes; exports.workLuma = workLuma; exports.softMaskToSelection = softMaskToSelection; exports.slicSuperpixels = slicSuperpixels; exports.superpixelSaliency = superpixelSaliency; exports.otsuThreshold = otsuThreshold; exports.findSubject = findSubject; exports.focusArea = focusArea; exports.findSky = findSky; exports.serializeMask = serializeMask; exports.deserializeMask = deserializeMask; exports.runSelectionJob = runSelectionJob; exports.startSelectionWorker = startSelectionWorker; exports.SelectionWorkerClient = SelectionWorkerClient;