@pixerate/editor 0.206.0 → 0.208.0

package/dist/{chunk-ZIDUPSP4.js → chunk-KFIOEOCQ.js}

@@ -1,6 +1,13 @@
 import {
   parseCssColor
 } from "./chunk-3CI7FRMK.js";
+import {
+  createSelectionMask,
+  decodeSelectionRle,
+  encodeSelectionRle,
+  hashMaskContent,
+  resizeSelection
+} from "./chunk-L3G23N5Y.js";
 import {
   DEFAULT_GLOBAL_LIGHT,
   DeepCompositor,
@@ -21,7 +28,6 @@ import {
   effectsScale,
   findLayer,
   flattenLayers,
-  gaussianBlur,
   insertLayer,
   isInterpolation,
   isLayerEffectKind,
@@ -37,7 +43,7 @@ import {
   validateEffectGradient,
   validateLayerEffects,
   warpSurface
-} from "./chunk-NQMP3CWF.js";
+} from "./chunk-YBJXCQTR.js";
 import {
   affineFromHomography,
   applyHomography,
@@ -48,6 +54,9 @@ import {
   multiplyHomographies,
   rectToQuad
 } from "./chunk-OHKOFKBY.js";
+import {
+  gaussianBlur
+} from "./chunk-ZIF4UJJ6.js";
 import {
   Transform,
   builtinProfile,
@@ -90,7 +99,7 @@ import {
   transformTextRect,
   translateMatrix,
   warpPresetMesh
-} from "./chunk-GHCXLQ47.js";
+} from "./chunk-NDMXB4PR.js";
 import {
   bezierPathBounds,
   outlineStroke,
@@ -99,36 +108,35 @@ import {
   transformBezierPath
 } from "./chunk-WEIK3UYB.js";
 import {
-  TILE,
-  TiledSurface,
   base64ToBytes,
   blendRgb,
   bytesToBase64,
-  contentBounds,
   decodePng,
-  emptySurface,
   encodePng,
-  finishTile,
   isBlendMode,
   mixPigmentRgb,
   normalizeBlendMode,
   parseDataUrl,
   pngDataUrl,
   readDeepRegion,
-  readPixel,
-  readRegion,
   setLum,
   surfaceDepth,
   surfaceFromDeepPixels,
+  writeDeepRegion
+} from "./chunk-42TWUPNJ.js";
+import {
+  TILE,
+  TiledSurface,
+  contentBounds,
+  emptySurface,
+  finishTile,
+  readRegion,
   surfaceFromPixels,
-  tileCoord,
   tileKey,
   tilesInRect,
   translateSurface,
-  uniformTile,
-  writeDeepRegion,
   writeRegion
-} from "./chunk-H367YTXI.js";
+} from "./chunk-HVVR5PZW.js";
 import {
   ZlibError,
   deflate,
@@ -711,716 +719,6 @@ function hitTestAnnotation(imgPt, ann, padding = 10) {
   return imgPt.x >= b.x - padding && imgPt.x <= b.x + b.width + padding && imgPt.y >= b.y - padding && imgPt.y <= b.y + b.height + padding;
 }
 
-// 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(text3) {
-  if (text3.length % 4 !== 0) throw new Error("Invalid base64 length");
-  let pad = 0;
-  if (text3.endsWith("==")) pad = 2;
-  else if (text3.endsWith("=")) pad = 1;
-  const out = new Uint8Array(text3.length / 4 * 3 - pad);
-  let o = 0;
-  const digit = (i, k) => {
-    const ch = text3.charCodeAt(i + k);
-    if (ch === 61 && i + 4 === text3.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 < text3.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 q2 = 0; q2 < width; q2++) {
-      const dq = vertical[row + q2];
-      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 * (q2 - p)) + (q2 + p) * 0.5;
-        if (start > starts[count - 1]) break;
-        count--;
-      }
-      if (count === 0) start = -Infinity;
-      sites[count] = q2;
-      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/layer-mask.ts
 function layerMaskSelection(layer, width, height) {
   if (!layer.mask || layer.mask.source) return null;
@@ -1429,12 +727,12 @@ function layerMaskSelection(layer, width, height) {
   const data = readRegion(layer.mask.surface, { x: -ox, y: -oy, width, height });
   return createSelectionMask(width, height, new Uint8Array(data.buffer, data.byteOffset, data.length));
 }
-var MAX_SIDE2 = 1 << 15;
+var MAX_SIDE = 1 << 15;
 function normalizeLayerMask(raw) {
   if (!raw || typeof raw !== "object") return null;
   const r = raw;
   const { width, height, rle } = r;
-  if (typeof width !== "number" || typeof height !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width > MAX_SIDE2 || height > MAX_SIDE2 || typeof rle !== "string" || !rle.startsWith("r1:")) {
+  if (typeof width !== "number" || typeof height !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width > MAX_SIDE || height > MAX_SIDE || typeof rle !== "string" || !rle.startsWith("r1:")) {
     return null;
   }
   const out = { width, height, rle };
@@ -12062,41 +11360,6 @@ export {
   calculateCropDrag,
   getAnnotationBounds,
   hitTestAnnotation,
-  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,
   layerMaskSelection,
   normalizeLayerMask,
   layerMaskFromSelection,