@pixerate/editor 0.259.0 → 0.260.0

package/dist/chunk-ZNA3IQZF.js

@@ -1,1066 +0,0 @@
-import {
-  gaussianBlur
-} from "./chunk-ZIF4UJJ6.js";
-import {
-  TILE,
-  TiledSurface,
-  contentBounds,
-  finishTile,
-  readPixel,
-  readRegion,
-  tileCoord,
-  tileKey,
-  uniformTile,
-  writeRegion
-} from "./chunk-HVVR5PZW.js";
-
-// 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 = TILE * TILE;
-var MATERIALIZED_LIMIT = 4;
-var materialized = /* @__PURE__ */ new Map();
-var lastRead = null;
-var lastData = null;
-var TiledSelectionMask = class {
-  constructor(width, height, surface, bounds, data) {
-    this.width = width;
-    this.height = height;
-    this.surface = surface;
-    this.cachedBounds = bounds;
-    if (data) this.remember(data);
-  }
-  width;
-  height;
-  surface;
-  cachedBounds;
-  weak = null;
-  get bounds() {
-    if (this.cachedBounds === void 0) this.cachedBounds = contentBounds(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 = this.weak?.deref();
-    if (!d) {
-      const all = readRegion(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);
-  }
-};
-function tileGrid(width, height) {
-  return { cols: Math.ceil(width / TILE), rows: Math.ceil(height / TILE) };
-}
-function insideTile(tx, ty, width, height) {
-  return (tx + 1) * TILE <= width && (ty + 1) * 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 * TILE;
-      const oy = ty * TILE;
-      const w = Math.min(TILE, width - ox);
-      const h = Math.min(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 === TILE && h === TILE) {
-        tiles.set(tileKey(tx, ty), uniformTile(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 * TILE + x] = data[row + x];
-      }
-      tiles.set(tileKey(tx, ty), { data: t, uniform: null });
-    }
-  }
-  return new TiledSurface(1, tiles, 0);
-}
-function clipTile(tile, w, h) {
-  const d = tile.data;
-  let outside = false;
-  for (let y = 0; y < TILE && !outside; y++) {
-    for (let x = y < h ? w : 0; x < TILE; x++) {
-      if (d[y * 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 * TILE, y * TILE + w), y * TILE);
-  return finishTile(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 = readRegion(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 } = tileCoord(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(TILE, width - tx * TILE), Math.min(TILE, height - ty * 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 TiledSurface(1, tiles, 0) : surface);
-}
-function createSelectionMask(width, height, data) {
-  checkSize(width, height);
-  if (!data) return new TiledSelectionMask(width, height, new 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, writeRegion(new 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(tileKey(tx, ty), uniformTile(1, 255));
-        continue;
-      }
-      const t = new Uint8ClampedArray(TILE_PIXELS);
-      const w = Math.min(TILE, width - tx * TILE);
-      for (let y = 0; y < Math.min(TILE, height - ty * TILE); y++) t.fill(255, y * TILE, y * TILE + w);
-      tiles.set(tileKey(tx, ty), { data: t, uniform: null });
-    }
-  }
-  return new TiledSelectionMask(width, height, new 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 readPixel(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 || a?.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 finishTile(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 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 = tileKey(tx, ty);
-      if (insideTile(tx, ty, width, height)) {
-        if (!src) tiles.set(key, uniformTile(1, FULL));
-        else if (src.uniform !== null) {
-          if (src.uniform !== FULL) tiles.set(key, uniformTile(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 = finishTile(out2, 1, 0);
-          if (t2) tiles.set(key, t2);
-        }
-        continue;
-      }
-      const w = Math.min(TILE, width - tx * TILE);
-      const h = Math.min(TILE, height - ty * TILE);
-      const out = new Uint8ClampedArray(TILE_PIXELS);
-      for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) out[y * TILE + x] = FULL - (src ? src.data[y * TILE + x] : 0);
-      const t = finishTile(out, 1, 0);
-      if (t) tiles.set(key, t);
-    }
-  }
-  return new TiledSelectionMask(width, height, new 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 = 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 NONE = 4294967295;
-  const vertical = new Uint32Array(n).fill(NONE);
-  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 === NONE) 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 = gaussianBlur(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 = gaussianBlur(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 = gaussianBlur(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 = 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 = refineBrush?.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;
-}
-
-export {
-  SELECTION_MODES,
-  isSelectionMode,
-  parseSelectionMode,
-  computeSelectionBounds,
-  selectionFromTiles,
-  createSelectionMask,
-  selectionFromRegion,
-  fullSelection,
-  isSelectionEmpty,
-  selectionValueAt,
-  coverageToByte,
-  selectionFromCoverage,
-  selectionToCoverage,
-  selectionArea,
-  combineSelections,
-  invertSelection,
-  resizeSelection,
-  selectionFromPixels,
-  selectionToPixels,
-  encodeSelectionRle,
-  decodeSelectionRle,
-  serializeSelection,
-  deserializeSelection,
-  hashMaskContent,
-  EMPTY_DISTANCE,
-  distanceTransform,
-  expandCoverage,
-  contractCoverage,
-  borderCoverage,
-  smoothCoverage,
-  featherCoverage,
-  greyMorphology,
-  shiftCoverage,
-  SELECTION_MODIFY_OPS,
-  modifySelection,
-  DEFAULT_REFINE_EDGE_PARAMS,
-  GUIDED_FILTER_EPS,
-  normalizeRefineEdgeParams,
-  refineEdgeHalo,
-  boxMean,
-  guidedFilterColor,
-  edgeWidth,
-  refineCoverage,
-  guidePlanes,
-  refineSelection,
-  decontaminateColors
-};