@pixerate/editor 0.207.0 → 0.209.0

package/dist/chunk-L3G23N5Y.js

@@ -0,0 +1,763 @@
+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}"`);
+  }
+}
+
+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
+};