@seed-ship/mcp-ui-solid 5.6.0 → 6.0.0

package/dist/node_modules/.pnpm/bubblesets-js@2.3.4/node_modules/bubblesets-js/build/index.js

@@ -0,0 +1,1660 @@
+function linePtSegDistSq(lx1, ly1, lx2, ly2, x, y) {
+  const x1 = lx1;
+  const y1 = ly1;
+  const x2 = lx2 - x1;
+  const y2 = ly2 - y1;
+  let px = x - x1;
+  let py = y - y1;
+  let dotprod = px * x2 + py * y2;
+  let projlenSq = 0;
+  if (dotprod <= 0) {
+    projlenSq = 0;
+  } else {
+    px = x2 - px;
+    py = y2 - py;
+    dotprod = px * x2 + py * y2;
+    if (dotprod <= 0) {
+      projlenSq = 0;
+    } else {
+      projlenSq = dotprod * dotprod / (x2 * x2 + y2 * y2);
+    }
+  }
+  const lenSq = px * px + py * py - projlenSq;
+  if (lenSq < 0) {
+    return 0;
+  }
+  return lenSq;
+}
+function ptsDistanceSq(x1, y1, x2, y2) {
+  return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
+}
+function doublePointsEqual(x1, y1, x2, y2, delta) {
+  return ptsDistanceSq(x1, y1, x2, y2) < delta * delta;
+}
+function round(digits) {
+  if (!Number.isFinite(digits)) {
+    return (v) => v;
+  }
+  if (digits === 0) {
+    return Math.round;
+  }
+  const factor = Math.pow(10, digits);
+  return (v) => Math.round(v * factor) / factor;
+}
+function lineBoundingBox(line) {
+  const minX = Math.min(line.x1, line.x2);
+  const maxX = Math.max(line.x1, line.x2);
+  const minY = Math.min(line.y1, line.y2);
+  const maxY = Math.max(line.y1, line.y2);
+  return {
+    x: minX,
+    y: minY,
+    x2: maxX,
+    y2: maxY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+class Line {
+  constructor(x1, y1, x2, y2) {
+    this.x1 = x1;
+    this.y1 = y1;
+    this.x2 = x2;
+    this.y2 = y2;
+  }
+  equals(that) {
+    return this.x1 === that.x1 && this.y1 === that.y1 && this.x2 === that.x2 && this.y2 === that.y2;
+  }
+  draw(ctx) {
+    ctx.moveTo(this.x1, this.y1);
+    ctx.lineTo(this.x2, this.y2);
+  }
+  toString() {
+    return `Line(from=(${this.x1},${this.y1}),to=(${this.x2},${this.y2}))`;
+  }
+  static from(l) {
+    return new Line(l.x1, l.y1, l.x2, l.y2);
+  }
+  cuts(px, py) {
+    if (this.y1 === this.y2) {
+      return false;
+    }
+    if (py < this.y1 && py <= this.y2 || py > this.y1 && py >= this.y2) {
+      return false;
+    }
+    if (px > this.x1 && px >= this.x2) {
+      return false;
+    }
+    if (px < this.x1 && px <= this.x2) {
+      return true;
+    }
+    const cross = this.x1 + (py - this.y1) * (this.x2 - this.x1) / (this.y2 - this.y1);
+    return px <= cross;
+  }
+  distSquare(x, y) {
+    return linePtSegDistSq(this.x1, this.y1, this.x2, this.y2, x, y);
+  }
+  ptClose(x, y, r) {
+    if (this.x1 < this.x2) {
+      if (x < this.x1 - r || x > this.x2 + r) {
+        return false;
+      }
+    } else {
+      if (x < this.x2 - r || x > this.x1 + r) {
+        return false;
+      }
+    }
+    if (this.y1 < this.y2) {
+      if (y < this.y1 - r || y > this.y2 + r) {
+        return false;
+      }
+    } else {
+      if (y < this.y2 - r || y > this.y1 + r) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+var EState;
+(function(EState2) {
+  EState2[EState2["POINT"] = 1] = "POINT";
+  EState2[EState2["PARALLEL"] = 2] = "PARALLEL";
+  EState2[EState2["COINCIDENT"] = 3] = "COINCIDENT";
+  EState2[EState2["NONE"] = 4] = "NONE";
+})(EState || (EState = {}));
+class Intersection {
+  constructor(state, x = 0, y = 0) {
+    this.state = state;
+    this.x = x;
+    this.y = y;
+  }
+}
+function intersectLineLine(la, lb) {
+  const uaT = (lb.x2 - lb.x1) * (la.y1 - lb.y1) - (lb.y2 - lb.y1) * (la.x1 - lb.x1);
+  const ubT = (la.x2 - la.x1) * (la.y1 - lb.y1) - (la.y2 - la.y1) * (la.x1 - lb.x1);
+  const uB = (lb.y2 - lb.y1) * (la.x2 - la.x1) - (lb.x2 - lb.x1) * (la.y2 - la.y1);
+  if (uB) {
+    const ua = uaT / uB;
+    const ub = ubT / uB;
+    if (0 <= ua && ua <= 1 && 0 <= ub && ub <= 1) {
+      return new Intersection(EState.POINT, la.x1 + ua * (la.x2 - la.x1), la.y1 + ua * (la.y2 - la.y1));
+    }
+    return new Intersection(EState.NONE);
+  }
+  return new Intersection(uaT === 0 || ubT === 0 ? EState.COINCIDENT : EState.PARALLEL);
+}
+function fractionAlongLineA(la, lb) {
+  const uaT = (lb.x2 - lb.x1) * (la.y1 - lb.y1) - (lb.y2 - lb.y1) * (la.x1 - lb.x1);
+  const ubT = (la.x2 - la.x1) * (la.y1 - lb.y1) - (la.y2 - la.y1) * (la.x1 - lb.x1);
+  const uB = (lb.y2 - lb.y1) * (la.x2 - la.x1) - (lb.x2 - lb.x1) * (la.y2 - la.y1);
+  if (uB) {
+    const ua = uaT / uB;
+    const ub = ubT / uB;
+    if (0 <= ua && ua <= 1 && 0 <= ub && ub <= 1) {
+      return ua;
+    }
+  }
+  return Number.POSITIVE_INFINITY;
+}
+function hasFractionToLineCenter(bounds, line) {
+  function testLine(xa, ya, xb, yb) {
+    let testDistance = fractionAlongLineA(line, new Line(xa, ya, xb, yb));
+    testDistance = Math.abs(testDistance - 0.5);
+    if (testDistance >= 0 && testDistance <= 1) {
+      return 1;
+    }
+    return 0;
+  }
+  let countIntersections = testLine(bounds.x, bounds.y, bounds.x2, bounds.y);
+  countIntersections += testLine(bounds.x, bounds.y, bounds.x, bounds.y2);
+  if (countIntersections > 1) {
+    return true;
+  }
+  countIntersections += testLine(bounds.x, bounds.y2, bounds.x2, bounds.y2);
+  if (countIntersections > 1) {
+    return true;
+  }
+  countIntersections += testLine(bounds.x2, bounds.y, bounds.x2, bounds.y2);
+  return countIntersections > 0;
+}
+var OutCode;
+(function(OutCode2) {
+  OutCode2[OutCode2["LEFT"] = 0] = "LEFT";
+  OutCode2[OutCode2["TOP"] = 1] = "TOP";
+  OutCode2[OutCode2["RIGHT"] = 2] = "RIGHT";
+  OutCode2[OutCode2["BOTTOM"] = 3] = "BOTTOM";
+})(OutCode || (OutCode = {}));
+function outcode(bounds, px, py) {
+  const out = /* @__PURE__ */ new Set();
+  if (bounds.width <= 0) {
+    out.add(OutCode.LEFT);
+    out.add(OutCode.RIGHT);
+  } else if (px < bounds.x) {
+    out.add(OutCode.LEFT);
+  } else if (px > bounds.x + bounds.width) {
+    out.add(OutCode.RIGHT);
+  }
+  if (bounds.height <= 0) {
+    out.add(OutCode.TOP);
+    out.add(OutCode.BOTTOM);
+  } else if (py < bounds.y) {
+    out.add(OutCode.TOP);
+  } else if (py > bounds.y + bounds.height) {
+    out.add(OutCode.BOTTOM);
+  }
+  return out;
+}
+function intersectsLine(bounds, line) {
+  let x1 = line.x1;
+  let y1 = line.y1;
+  const x2 = line.x2;
+  const y2 = line.y2;
+  const out2 = Array.from(outcode(bounds, x2, y2));
+  if (out2.length === 0) {
+    return true;
+  }
+  let out1 = outcode(bounds, x1, y1);
+  while (out1.size !== 0) {
+    for (const a of out2) {
+      if (out1.has(a)) {
+        return false;
+      }
+    }
+    if (out1.has(OutCode.RIGHT) || out1.has(OutCode.LEFT)) {
+      let x = bounds.x;
+      if (out1.has(OutCode.RIGHT)) {
+        x += bounds.width;
+      }
+      y1 = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
+      x1 = x;
+    } else {
+      let y = bounds.y;
+      if (out1.has(OutCode.BOTTOM)) {
+        y += bounds.height;
+      }
+      x1 = x1 + (y - y1) * (x2 - x1) / (y2 - y1);
+      y1 = y;
+    }
+    out1 = outcode(bounds, x1, y1);
+  }
+  return true;
+}
+function fractionToLineCenter(bounds, line) {
+  let minDistance = Number.POSITIVE_INFINITY;
+  let countIntersections = 0;
+  function testLine(xa, ya, xb, yb) {
+    let testDistance = fractionAlongLineA(line, new Line(xa, ya, xb, yb));
+    testDistance = Math.abs(testDistance - 0.5);
+    if (testDistance >= 0 && testDistance <= 1) {
+      countIntersections++;
+      if (testDistance < minDistance) {
+        minDistance = testDistance;
+      }
+    }
+  }
+  testLine(bounds.x, bounds.y, bounds.x2, bounds.y);
+  testLine(bounds.x, bounds.y, bounds.x, bounds.y2);
+  if (countIntersections > 1) {
+    return minDistance;
+  }
+  testLine(bounds.x, bounds.y2, bounds.x2, bounds.y2);
+  if (countIntersections > 1) {
+    return minDistance;
+  }
+  testLine(bounds.x2, bounds.y, bounds.x2, bounds.y2);
+  if (countIntersections === 0) {
+    return -1;
+  }
+  return minDistance;
+}
+function testIntersection(line, bounds) {
+  let count = 0;
+  const top = intersectLineLine(line, new Line(bounds.x, bounds.y, bounds.x2, bounds.y));
+  count += top.state === EState.POINT ? 1 : 0;
+  const left = intersectLineLine(line, new Line(bounds.x, bounds.y, bounds.x, bounds.y2));
+  count += left.state === EState.POINT ? 1 : 0;
+  const bottom = intersectLineLine(line, new Line(bounds.x, bounds.y2, bounds.x2, bounds.y2));
+  count += bottom.state === EState.POINT ? 1 : 0;
+  const right = intersectLineLine(line, new Line(bounds.x2, bounds.y, bounds.x2, bounds.y2));
+  count += right.state === EState.POINT ? 1 : 0;
+  return { top, left, bottom, right, count };
+}
+class Rectangle {
+  constructor(x, y, width, height) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+  }
+  get x2() {
+    return this.x + this.width;
+  }
+  get y2() {
+    return this.y + this.height;
+  }
+  get cx() {
+    return this.x + this.width / 2;
+  }
+  get cy() {
+    return this.y + this.height / 2;
+  }
+  get radius() {
+    return Math.max(this.width, this.height) / 2;
+  }
+  static from(r) {
+    return new Rectangle(r.x, r.y, r.width, r.height);
+  }
+  equals(that) {
+    return this.x === that.x && this.y === that.y && this.width === that.width && this.height === that.height;
+  }
+  clone() {
+    return new Rectangle(this.x, this.y, this.width, this.height);
+  }
+  add(that) {
+    const x = Math.min(this.x, that.x);
+    const y = Math.min(this.y, that.y);
+    const x2 = Math.max(this.x2, that.x + that.width);
+    const y2 = Math.max(this.y2, that.y + that.height);
+    this.x = x;
+    this.y = y;
+    this.width = x2 - x;
+    this.height = y2 - y;
+  }
+  addPoint(p) {
+    const x = Math.min(this.x, p.x);
+    const y = Math.min(this.y, p.y);
+    const x2 = Math.max(this.x2, p.x);
+    const y2 = Math.max(this.y2, p.y);
+    this.x = x;
+    this.y = y;
+    this.width = x2 - x;
+    this.height = y2 - y;
+  }
+  toString() {
+    return `Rectangle[x=${this.x}, y=${this.y}, w=${this.width}, h=${this.height}]`;
+  }
+  draw(ctx) {
+    ctx.rect(this.x, this.y, this.width, this.height);
+  }
+  containsPt(px, py) {
+    return px >= this.x && px <= this.x2 && py >= this.y && py <= this.y2;
+  }
+  get area() {
+    return this.width * this.height;
+  }
+  intersects(that) {
+    if (this.area <= 0 || that.width <= 0 || that.height <= 0) {
+      return false;
+    }
+    return that.x + that.width > this.x && that.y + that.height > this.y && that.x < this.x2 && that.y < this.y2;
+  }
+  distSquare(tempX, tempY) {
+    if (this.containsPt(tempX, tempY)) {
+      return 0;
+    }
+    const code = outcode(this, tempX, tempY);
+    if (code.has(OutCode.TOP)) {
+      if (code.has(OutCode.LEFT)) {
+        return ptsDistanceSq(tempX, tempY, this.x, this.y);
+      }
+      if (code.has(OutCode.RIGHT)) {
+        return ptsDistanceSq(tempX, tempY, this.x2, this.y);
+      }
+      return (this.y - tempY) * (this.y - tempY);
+    }
+    if (code.has(OutCode.BOTTOM)) {
+      if (code.has(OutCode.LEFT)) {
+        return ptsDistanceSq(tempX, tempY, this.x, this.y2);
+      }
+      if (code.has(OutCode.RIGHT)) {
+        return ptsDistanceSq(tempX, tempY, this.x2, this.y2);
+      }
+      return (tempY - this.y2) * (tempY - this.y2);
+    }
+    if (code.has(OutCode.LEFT)) {
+      return (this.x - tempX) * (this.x - tempX);
+    }
+    if (code.has(OutCode.RIGHT)) {
+      return (tempX - this.x2) * (tempX - this.x2);
+    }
+    return 0;
+  }
+}
+function boundingBox(path) {
+  if (path.length === 0) {
+    return null;
+  }
+  const first = path[0];
+  const bb = new Rectangle(first.x, first.y, 0, 0);
+  for (const point2 of path) {
+    bb.addPoint(point2);
+  }
+  return bb;
+}
+class Circle {
+  constructor(cx, cy, radius) {
+    this.cx = cx;
+    this.cy = cy;
+    this.radius = radius;
+  }
+  get x() {
+    return this.cx - this.radius;
+  }
+  get x2() {
+    return this.cx + this.radius;
+  }
+  get width() {
+    return this.radius * 2;
+  }
+  get y() {
+    return this.cy - this.radius;
+  }
+  get y2() {
+    return this.cy + this.radius;
+  }
+  get height() {
+    return this.radius * 2;
+  }
+  static from(r) {
+    return new Circle(r.cx, r.cy, r.radius);
+  }
+  containsPt(x, y) {
+    return ptsDistanceSq(this.cx, this.cy, x, y) < this.radius * this.radius;
+  }
+  distSquare(tempX, tempY) {
+    const dist = ptsDistanceSq(this.cx, this.cy, tempX, tempY);
+    if (dist < this.radius * this.radius) {
+      return 0;
+    }
+    const offset = Math.sqrt(dist) - this.radius;
+    return offset * offset;
+  }
+  draw(ctx) {
+    ctx.ellipse(this.cx, this.cy, this.radius, this.radius, 0, 0, Math.PI * 2);
+  }
+}
+class Area {
+  constructor(pixelGroup, i = 0, j = 0, pixelX = 0, pixelY = 0, width = 10, height = 10, pixels = new Float32Array(Math.max(0, width * height)).fill(0)) {
+    this.pixelGroup = pixelGroup;
+    this.i = i;
+    this.j = j;
+    this.pixelX = pixelX;
+    this.pixelY = pixelY;
+    this.width = width;
+    this.height = height;
+    this.area = pixels;
+  }
+  createSub(rect, pixelPos) {
+    return new Area(this.pixelGroup, rect.x, rect.y, pixelPos.x, pixelPos.y, rect.width, rect.height);
+  }
+  static fromPixelRegion(pixelRect, pixelGroup) {
+    return new Area(pixelGroup, 0, 0, pixelRect.x, pixelRect.y, Math.ceil(pixelRect.width / pixelGroup), Math.ceil(pixelRect.height / pixelGroup));
+  }
+  copy(sub, pixelPoint) {
+    return new Area(this.pixelGroup, this.scaleX(pixelPoint.x), this.scaleY(pixelPoint.y), pixelPoint.x, pixelPoint.y, sub.width, sub.height, sub.area);
+  }
+  boundX(pos) {
+    if (pos < this.i) {
+      return this.i;
+    }
+    if (pos >= this.width) {
+      return this.width - 1;
+    }
+    return pos;
+  }
+  boundY(pos) {
+    if (pos < this.j) {
+      return this.j;
+    }
+    if (pos >= this.height) {
+      return this.height - 1;
+    }
+    return pos;
+  }
+  scaleX(pixel) {
+    return this.boundX(Math.floor((pixel - this.pixelX) / this.pixelGroup));
+  }
+  scaleY(pixel) {
+    return this.boundY(Math.floor((pixel - this.pixelY) / this.pixelGroup));
+  }
+  scale(pixelRect) {
+    const x = this.scaleX(pixelRect.x);
+    const y = this.scaleY(pixelRect.y);
+    const x2 = this.boundX(Math.ceil((pixelRect.x + pixelRect.width - this.pixelX) / this.pixelGroup));
+    const y2 = this.boundY(Math.ceil((pixelRect.y + pixelRect.height - this.pixelY) / this.pixelGroup));
+    const width = x2 - x;
+    const height = y2 - y;
+    return new Rectangle(x, y, width, height);
+  }
+  invertScaleX(v) {
+    return Math.round(v * this.pixelGroup + this.pixelX);
+  }
+  invertScaleY(v) {
+    return Math.round(v * this.pixelGroup + this.pixelY);
+  }
+  addPadding(rect, pixelPadding) {
+    const padding = Math.ceil(pixelPadding / this.pixelGroup);
+    const x = this.boundX(rect.x - padding);
+    const y = this.boundY(rect.y - padding);
+    const x2 = this.boundX(rect.x2 + padding);
+    const y2 = this.boundY(rect.y2 + padding);
+    const width = x2 - x;
+    const height = y2 - y;
+    return new Rectangle(x, y, width, height);
+  }
+  get(i, j) {
+    if (i < 0 || j < 0 || i >= this.width || j >= this.height) {
+      return Number.NaN;
+    }
+    return this.area[i + j * this.width];
+  }
+  inc(i, j, v) {
+    if (i < 0 || j < 0 || i >= this.width || j >= this.height) {
+      return;
+    }
+    this.area[i + j * this.width] += v;
+  }
+  set(i, j, v) {
+    if (i < 0 || j < 0 || i >= this.width || j >= this.height) {
+      return;
+    }
+    this.area[i + j * this.width] = v;
+  }
+  incArea(sub, factor) {
+    if (sub.width <= 0 || sub.height <= 0 || factor === 0) {
+      return;
+    }
+    const w = this.width;
+    const aw = sub.width;
+    const i1 = Math.max(0, sub.i);
+    const j1 = Math.max(0, sub.j);
+    const i2 = Math.min(sub.i + sub.width, w);
+    const j2 = Math.min(sub.j + sub.height, this.height);
+    if (j2 <= 0 || i2 <= 0 || i1 >= w || j2 >= this.height) {
+      return;
+    }
+    for (let j = j1; j < j2; j++) {
+      const subRow = (j - sub.j) * aw;
+      const row = j * w;
+      for (let i = i1; i < i2; i++) {
+        const v = sub.area[i - sub.i + subRow];
+        if (v === 0) {
+          continue;
+        }
+        this.area[i + row] += factor * v;
+      }
+    }
+  }
+  fill(value) {
+    this.area.fill(value);
+  }
+  fillArea(rect, value) {
+    const offset = rect.x + rect.y * this.width;
+    for (let j = 0; j < rect.height; j++) {
+      const pos = offset + j * this.width;
+      this.area.fill(value, pos, pos + rect.width);
+    }
+  }
+  fillHorizontalLine(i, j, width, value) {
+    const offset = i + j * this.width;
+    this.area.fill(value, offset, offset + width);
+  }
+  fillVerticalLine(i, j, height, value) {
+    const offset = i + j * this.width;
+    for (let k = 0; k < height; k++) {
+      this.area[offset + k * this.width] = value;
+    }
+  }
+  clear() {
+    this.area.fill(0);
+  }
+  toString() {
+    let r = "";
+    for (let j = 0; j < this.height; j++) {
+      const row = j * this.width;
+      for (let i = 0; i < this.width; i++) {
+        const v = this.area[row + i];
+        r += v.toFixed(1).padStart(6);
+        r += " ";
+      }
+      r += "\n";
+    }
+    return r;
+  }
+  draw(ctx, offset = true) {
+    if (this.width <= 0 || this.height <= 0) {
+      return;
+    }
+    ctx.save();
+    if (offset) {
+      ctx.translate(this.pixelX, this.pixelY);
+    }
+    const min = this.area.reduce((acc, v) => Math.min(acc, v), Number.POSITIVE_INFINITY);
+    const max = this.area.reduce((acc, v) => Math.max(acc, v), Number.NEGATIVE_INFINITY);
+    const scale = (v) => (v - min) / (max - min);
+    ctx.scale(this.pixelGroup, this.pixelGroup);
+    for (let i = 0; i < this.width; i++) {
+      for (let j = 0; j < this.height; j++) {
+        const v = this.area[i + j * this.width];
+        ctx.fillStyle = `rgba(0, 0, 0, ${scale(v)})`;
+        ctx.fillRect(i, j, 1, 1);
+      }
+    }
+    ctx.restore();
+  }
+  drawThreshold(ctx, threshold, offset = true) {
+    if (this.width <= 0 || this.height <= 0) {
+      return;
+    }
+    ctx.save();
+    if (offset) {
+      ctx.translate(this.pixelX, this.pixelY);
+    }
+    ctx.scale(this.pixelGroup, this.pixelGroup);
+    for (let i = 0; i < this.width; i++) {
+      for (let j = 0; j < this.height; j++) {
+        const v = this.area[i + j * this.width];
+        ctx.fillStyle = v > threshold ? "black" : "white";
+        ctx.fillRect(i, j, 1, 1);
+      }
+    }
+    ctx.restore();
+  }
+}
+function addPadding(rect, padding) {
+  const map = (r) => ({
+    x: r.x - padding,
+    y: r.y - padding,
+    width: r.width + 2 * padding,
+    height: r.height + 2 * padding
+  });
+  if (Array.isArray(rect)) {
+    return rect.map(map);
+  }
+  return map(rect);
+}
+function createLineInfluenceArea(line, potentialArea, padding) {
+  return createGenericInfluenceArea(Object.assign(lineBoundingBox(line), {
+    distSquare: (x, y) => linePtSegDistSq(line.x1, line.y1, line.x2, line.y2, x, y)
+  }), potentialArea, padding);
+}
+function createGenericInfluenceArea(shape, potentialArea, padding) {
+  const lr = addPadding(shape, padding);
+  const scaled = potentialArea.scale(lr);
+  const area = potentialArea.createSub(scaled, lr);
+  sample(area, potentialArea, padding, (x, y) => shape.distSquare(x, y));
+  return area;
+}
+function sample(area, potentialArea, padding, distanceFunction) {
+  const padding2 = padding * padding;
+  for (let y = 0; y < area.height; y++) {
+    for (let x = 0; x < area.width; x++) {
+      const tempX = potentialArea.invertScaleX(area.i + x);
+      const tempY = potentialArea.invertScaleY(area.j + y);
+      const distanceSq = distanceFunction(tempX, tempY);
+      if (distanceSq === 0) {
+        area.set(x, y, padding2);
+        continue;
+      }
+      if (distanceSq < padding2) {
+        const dr = padding - Math.sqrt(distanceSq);
+        area.set(x, y, dr * dr);
+      }
+    }
+  }
+  return area;
+}
+function createRectangleInfluenceArea(rect, potentialArea, padding) {
+  const scaled = potentialArea.scale(rect);
+  const padded = potentialArea.addPadding(scaled, padding);
+  const area = potentialArea.createSub(padded, { x: rect.x - padding, y: rect.y - padding });
+  const paddingLeft = scaled.x - padded.x;
+  const paddingTop = scaled.y - padded.y;
+  const paddingRight = padded.x2 - scaled.x2;
+  const paddingBottom = padded.y2 - scaled.y2;
+  const innerWidth = padded.width - paddingLeft - paddingRight;
+  const innerHeight = padded.height - paddingTop - paddingBottom;
+  const padding2 = padding * padding;
+  area.fillArea({
+    x: paddingLeft,
+    y: paddingTop,
+    width: innerWidth + 1,
+    height: innerHeight + 1
+  }, padding2);
+  const straightDistances = [0];
+  const maxPadding = Math.max(paddingTop, paddingLeft, paddingRight, paddingBottom);
+  {
+    const tempX = potentialArea.invertScaleX(scaled.x + scaled.width / 2);
+    for (let i = 1; i < maxPadding; i++) {
+      const tempY = potentialArea.invertScaleY(scaled.y - i);
+      const distanceSq = rect.distSquare(tempX, tempY);
+      if (distanceSq < padding2) {
+        const dr = padding - Math.sqrt(distanceSq);
+        straightDistances.push(dr * dr);
+      } else {
+        break;
+      }
+    }
+  }
+  const cornerDistances = [];
+  const maxHorizontalPadding = Math.max(paddingLeft, paddingRight);
+  const maxVerticalPadding = Math.max(paddingTop, paddingRight);
+  for (let i = 1; i < maxHorizontalPadding; i++) {
+    const tempX = potentialArea.invertScaleX(scaled.x - i);
+    const row = [];
+    for (let j = 1; j < maxVerticalPadding; j++) {
+      const tempY = potentialArea.invertScaleY(scaled.y - j);
+      const distanceSq = rect.distSquare(tempX, tempY);
+      if (distanceSq < padding2) {
+        const dr = padding - Math.sqrt(distanceSq);
+        row.push(dr * dr);
+      } else {
+        row.push(0);
+      }
+    }
+    cornerDistances.push(row);
+  }
+  for (let y = 1; y < Math.min(paddingTop, straightDistances.length); y++) {
+    const value = straightDistances[y];
+    area.fillHorizontalLine(paddingLeft, paddingTop - y, innerWidth + 1, value);
+  }
+  for (let y = 1; y < Math.min(paddingBottom, straightDistances.length); y++) {
+    const value = straightDistances[y];
+    area.fillHorizontalLine(paddingLeft, paddingTop + innerHeight + y, innerWidth + 1, value);
+  }
+  for (let x = 1; x < Math.min(paddingLeft, straightDistances.length); x++) {
+    const value = straightDistances[x];
+    area.fillVerticalLine(paddingLeft - x, paddingTop, innerHeight + 1, value);
+  }
+  for (let x = 1; x < Math.min(paddingBottom, straightDistances.length); x++) {
+    const value = straightDistances[x];
+    area.fillVerticalLine(paddingLeft + innerWidth + x, paddingTop, innerHeight + 1, value);
+  }
+  for (let i = 1; i < paddingLeft; i++) {
+    const row = cornerDistances[i - 1];
+    const ii = paddingLeft - i;
+    for (let j = 1; j < paddingTop; j++) {
+      area.set(ii, paddingTop - j, row[j - 1]);
+    }
+    for (let j = 1; j < paddingBottom; j++) {
+      area.set(ii, paddingTop + innerHeight + j, row[j - 1]);
+    }
+  }
+  for (let i = 1; i < paddingRight; i++) {
+    const row = cornerDistances[i - 1];
+    const ii = paddingLeft + innerWidth + i;
+    for (let j = 1; j < paddingTop; j++) {
+      area.set(ii, paddingTop - j, row[j - 1]);
+    }
+    for (let j = 1; j < paddingBottom; j++) {
+      area.set(ii, paddingTop + innerHeight + j, row[j - 1]);
+    }
+  }
+  return area;
+}
+function point(x, y) {
+  return { x, y };
+}
+function calculateVirtualEdges(items, nonMembers, maxRoutingIterations, morphBuffer) {
+  if (items.length === 0) {
+    return [];
+  }
+  const sorted = sortByDistanceToCentroid(items);
+  return sorted.map((d, i) => {
+    const visited = sorted.slice(0, i);
+    return connectItem(nonMembers, d, visited, maxRoutingIterations, morphBuffer);
+  }).flat();
+}
+function connectItem(nonMembers, item, visited, maxRoutingIterations, morphBuffer) {
+  const itemCenter = point(item.cx, item.cy);
+  const closestNeighbor = calculateClosestNeighbor(itemCenter, visited, nonMembers);
+  if (closestNeighbor == null) {
+    return [];
+  }
+  const directLine = new Line(itemCenter.x, itemCenter.y, closestNeighbor.cx, closestNeighbor.cy);
+  const scannedLines = computeRoute(directLine, nonMembers, maxRoutingIterations, morphBuffer);
+  return mergeLines(scannedLines, nonMembers);
+}
+function computeRoute(directLine, nonMembers, maxRoutingIterations, morphBuffer) {
+  const scannedLines = [];
+  const linesToCheck = [];
+  linesToCheck.push(directLine);
+  let hasIntersection = true;
+  for (let iterations = 0; iterations < maxRoutingIterations && hasIntersection; iterations++) {
+    hasIntersection = false;
+    while (!hasIntersection && linesToCheck.length > 0) {
+      const line = linesToCheck.pop();
+      const closestItem = getCenterItem(nonMembers, line);
+      const intersections = closestItem ? testIntersection(line, closestItem) : null;
+      if (!closestItem || !intersections || intersections.count !== 2) {
+        if (!hasIntersection) {
+          scannedLines.push(line);
+        }
+        continue;
+      }
+      let tempMorphBuffer = morphBuffer;
+      let movePoint = rerouteLine(closestItem, tempMorphBuffer, intersections, true);
+      let foundFirst = pointExists(movePoint, linesToCheck) || pointExists(movePoint, scannedLines);
+      let pointInside = isPointInRectangles(movePoint, nonMembers);
+      while (!foundFirst && pointInside && tempMorphBuffer >= 1) {
+        tempMorphBuffer /= 1.5;
+        movePoint = rerouteLine(closestItem, tempMorphBuffer, intersections, true);
+        foundFirst = pointExists(movePoint, linesToCheck) || pointExists(movePoint, scannedLines);
+        pointInside = isPointInRectangles(movePoint, nonMembers);
+      }
+      if (movePoint && !foundFirst && !pointInside) {
+        linesToCheck.push(new Line(line.x1, line.y1, movePoint.x, movePoint.y));
+        linesToCheck.push(new Line(movePoint.x, movePoint.y, line.x2, line.y2));
+        hasIntersection = true;
+      }
+      if (hasIntersection) {
+        continue;
+      }
+      tempMorphBuffer = morphBuffer;
+      movePoint = rerouteLine(closestItem, tempMorphBuffer, intersections, false);
+      let foundSecond = pointExists(movePoint, linesToCheck) || pointExists(movePoint, scannedLines);
+      pointInside = isPointInRectangles(movePoint, nonMembers);
+      while (!foundSecond && pointInside && tempMorphBuffer >= 1) {
+        tempMorphBuffer /= 1.5;
+        movePoint = rerouteLine(closestItem, tempMorphBuffer, intersections, false);
+        foundSecond = pointExists(movePoint, linesToCheck) || pointExists(movePoint, scannedLines);
+        pointInside = isPointInRectangles(movePoint, nonMembers);
+      }
+      if (movePoint && !foundSecond) {
+        linesToCheck.push(new Line(line.x1, line.y1, movePoint.x, movePoint.y));
+        linesToCheck.push(new Line(movePoint.x, movePoint.y, line.x2, line.y2));
+        hasIntersection = true;
+      }
+      if (!hasIntersection) {
+        scannedLines.push(line);
+      }
+    }
+  }
+  while (linesToCheck.length > 0) {
+    scannedLines.push(linesToCheck.pop());
+  }
+  return scannedLines;
+}
+function mergeLines(scannedLines, nonMembers) {
+  const finalRoute = [];
+  while (scannedLines.length > 0) {
+    const line1 = scannedLines.pop();
+    if (scannedLines.length === 0) {
+      finalRoute.push(line1);
+      break;
+    }
+    const line2 = scannedLines.pop();
+    const mergeLine = new Line(line1.x1, line1.y1, line2.x2, line2.y2);
+    const closestItem = getCenterItem(nonMembers, mergeLine);
+    if (!closestItem) {
+      scannedLines.push(mergeLine);
+    } else {
+      finalRoute.push(line1);
+      scannedLines.push(line2);
+    }
+  }
+  return finalRoute;
+}
+function calculateClosestNeighbor(itemCenter, visited, nonMembers) {
+  let minLengthSq = Number.POSITIVE_INFINITY;
+  return visited.reduce((closestNeighbor, neighborItem) => {
+    const distanceSq = ptsDistanceSq(itemCenter.x, itemCenter.y, neighborItem.cx, neighborItem.cy);
+    if (distanceSq > minLengthSq) {
+      return closestNeighbor;
+    }
+    const directLine = new Line(itemCenter.x, itemCenter.y, neighborItem.cx, neighborItem.cy);
+    const numberInterferenceItems = itemsCuttingLine(nonMembers, directLine);
+    if (distanceSq * (numberInterferenceItems + 1) * (numberInterferenceItems + 1) < minLengthSq) {
+      closestNeighbor = neighborItem;
+      minLengthSq = distanceSq * (numberInterferenceItems + 1) * (numberInterferenceItems + 1);
+    }
+    return closestNeighbor;
+  }, null);
+}
+function sortByDistanceToCentroid(items) {
+  if (items.length < 2) {
+    return items;
+  }
+  let totalX = 0;
+  let totalY = 0;
+  items.forEach((item) => {
+    totalX += item.cx;
+    totalY += item.cy;
+  });
+  totalX /= items.length;
+  totalY /= items.length;
+  return items.map((item) => {
+    const diffX = totalX - item.cx;
+    const diffY = totalY - item.cy;
+    const dist = diffX * diffX + diffY * diffY;
+    return [item, dist];
+  }).sort((a, b) => a[1] - b[1]).map((d) => d[0]);
+}
+function isPointInRectangles(p, rects) {
+  return rects.some((r) => r.containsPt(p.x, p.y));
+}
+function pointExists(pointToCheck, lines) {
+  return lines.some((checkEndPointsLine) => {
+    if (doublePointsEqual(checkEndPointsLine.x1, checkEndPointsLine.y1, pointToCheck.x, pointToCheck.y, 1e-3)) {
+      return true;
+    }
+    if (doublePointsEqual(checkEndPointsLine.x2, checkEndPointsLine.y2, pointToCheck.x, pointToCheck.y, 1e-3)) {
+      return true;
+    }
+    return false;
+  });
+}
+function getCenterItem(items, testLine) {
+  let minDistance = Number.POSITIVE_INFINITY;
+  let closestItem = null;
+  for (const item of items) {
+    if (!intersectsLine(item, testLine)) {
+      continue;
+    }
+    const distance = fractionToLineCenter(item, testLine);
+    if (distance >= 0 && distance < minDistance) {
+      closestItem = item;
+      minDistance = distance;
+    }
+  }
+  return closestItem;
+}
+function itemsCuttingLine(items, testLine) {
+  return items.reduce((count, item) => {
+    if (intersectsLine(item, testLine) && hasFractionToLineCenter(item, testLine)) {
+      return count + 1;
+    }
+    return count;
+  }, 0);
+}
+function rerouteLine(item, rerouteBuffer, intersections, wrapNormal) {
+  const topIntersect = intersections.top;
+  const leftIntersect = intersections.left;
+  const bottomIntersect = intersections.bottom;
+  const rightIntersect = intersections.right;
+  if (wrapNormal) {
+    if (leftIntersect.state === EState.POINT) {
+      if (topIntersect.state === EState.POINT)
+        return point(item.x - rerouteBuffer, item.y - rerouteBuffer);
+      if (bottomIntersect.state === EState.POINT)
+        return point(item.x - rerouteBuffer, item.y2 + rerouteBuffer);
+      const totalArea3 = item.width * item.height;
+      const topArea = item.width * ((leftIntersect.y - item.y + (rightIntersect.y - item.y)) * 0.5);
+      if (topArea < totalArea3 * 0.5) {
+        if (leftIntersect.y > rightIntersect.y)
+          return point(item.x - rerouteBuffer, item.y - rerouteBuffer);
+        return point(item.x2 + rerouteBuffer, item.y - rerouteBuffer);
+      }
+      if (leftIntersect.y < rightIntersect.y)
+        return point(item.x - rerouteBuffer, item.y2 + rerouteBuffer);
+      return point(item.x2 + rerouteBuffer, item.y2 + rerouteBuffer);
+    }
+    if (rightIntersect.state === EState.POINT) {
+      if (topIntersect.state === EState.POINT)
+        return point(item.x2 + rerouteBuffer, item.y - rerouteBuffer);
+      if (bottomIntersect.state === EState.POINT)
+        return point(item.x2 + rerouteBuffer, item.y2 + rerouteBuffer);
+    }
+    const totalArea2 = item.height * item.width;
+    const leftArea2 = item.height * ((topIntersect.x - item.x + (rightIntersect.x - item.x)) * 0.5);
+    if (leftArea2 < totalArea2 * 0.5) {
+      if (topIntersect.x > bottomIntersect.x)
+        return point(item.x - rerouteBuffer, item.y - rerouteBuffer);
+      return point(item.x - rerouteBuffer, item.y2 + rerouteBuffer);
+    }
+    if (topIntersect.x < bottomIntersect.x)
+      return point(item.x2 + rerouteBuffer, item.y - rerouteBuffer);
+    return point(item.x2 + rerouteBuffer, item.y2 + rerouteBuffer);
+  }
+  if (leftIntersect.state === EState.POINT) {
+    if (topIntersect.state === EState.POINT)
+      return point(item.x2 + rerouteBuffer, item.y2 + rerouteBuffer);
+    if (bottomIntersect.state === EState.POINT)
+      return point(item.x2 + rerouteBuffer, item.y - rerouteBuffer);
+    const totalArea2 = item.height * item.width;
+    const topArea = item.width * ((leftIntersect.y - item.y + (rightIntersect.y - item.y)) * 0.5);
+    if (topArea < totalArea2 * 0.5) {
+      if (leftIntersect.y > rightIntersect.y)
+        return point(item.x2 + rerouteBuffer, item.y2 + rerouteBuffer);
+      return point(item.x - rerouteBuffer, item.y2 + rerouteBuffer);
+    }
+    if (leftIntersect.y < rightIntersect.y)
+      return point(item.x2 + rerouteBuffer, item.y - rerouteBuffer);
+    return point(item.x - rerouteBuffer, item.y - rerouteBuffer);
+  }
+  if (rightIntersect.state === EState.POINT) {
+    if (topIntersect.state === EState.POINT)
+      return point(item.x - rerouteBuffer, item.y2 + rerouteBuffer);
+    if (bottomIntersect.state === EState.POINT)
+      return point(item.x - rerouteBuffer, item.y - rerouteBuffer);
+  }
+  const totalArea = item.height * item.width;
+  const leftArea = item.height * ((topIntersect.x - item.x + (rightIntersect.x - item.x)) * 0.5);
+  if (leftArea < totalArea * 0.5) {
+    if (topIntersect.x > bottomIntersect.x)
+      return point(item.x2 + rerouteBuffer, item.y2 + rerouteBuffer);
+    return point(item.x2 + rerouteBuffer, item.y - rerouteBuffer);
+  }
+  if (topIntersect.x < bottomIntersect.x)
+    return point(item.x - rerouteBuffer, item.y2 + rerouteBuffer);
+  return point(item.x - rerouteBuffer, item.y - rerouteBuffer);
+}
+function canTakeNext(path, start, end, toleranceSquared) {
+  const validEnd = path.closed ? end < path.length : end < path.length - 1;
+  if (!validEnd) {
+    return false;
+  }
+  const s = path.get(start);
+  const e = path.get(end + 1);
+  for (let index = start + 1; index <= end; index++) {
+    const p = path.get(index);
+    const len = linePtSegDistSq(s.x, s.y, e.x, e.y, p.x, p.y);
+    if (len > toleranceSquared) {
+      return false;
+    }
+  }
+  return true;
+}
+function shapeSimplifier(tolerance = 0) {
+  return (path) => {
+    if (tolerance < 0 || path.length < 3) {
+      return path;
+    }
+    const points = [];
+    let start = 0;
+    const toleranceSquared = tolerance * tolerance;
+    while (start < path.length) {
+      let end = start + 1;
+      while (canTakeNext(path, start, end, toleranceSquared)) {
+        end++;
+      }
+      points.push(path.get(start));
+      start = end;
+    }
+    return new PointPath(points);
+  };
+}
+function basicFunction(i, t) {
+  switch (i) {
+    case -2:
+      return (((-t + 3) * t - 3) * t + 1) / 6;
+    case -1:
+      return ((3 * t - 6) * t * t + 4) / 6;
+    case 0:
+      return (((-3 * t + 3) * t + 3) * t + 1) / 6;
+    case 1:
+      return t * t * t / 6;
+    default:
+      throw new Error("unknown error");
+  }
+}
+function bSplineShapeGenerator(granularity = 6) {
+  const ORDER = 3;
+  const START_INDEX = ORDER - 1;
+  const REL_END = 1;
+  const REL_START = REL_END - ORDER;
+  function calcPoint(path, i, t) {
+    let px = 0;
+    let py = 0;
+    for (let j = REL_START; j <= REL_END; j++) {
+      const p = path.get(i + j);
+      const bf = basicFunction(j, t);
+      px += bf * p.x;
+      py += bf * p.y;
+    }
+    return { x: px, y: py };
+  }
+  return (path) => {
+    if (path.length < 3) {
+      return path;
+    }
+    const res = [];
+    const closed = path.closed;
+    const count = path.length + ORDER - 1 + (closed ? 0 : 2);
+    res.push(calcPoint(path, START_INDEX - (closed ? 0 : 2), 0));
+    for (let ix = START_INDEX - (closed ? 0 : 2); ix < count; ix++) {
+      for (let k = 1; k <= granularity; k++) {
+        res.push(calcPoint(path, ix, k / granularity));
+      }
+    }
+    return new PointPath(res);
+  };
+}
+function samplePath(skip = 8) {
+  return (path) => {
+    let actSkip = skip;
+    let size = path.length;
+    if (actSkip > 1) {
+      size = Math.floor(path.length / actSkip);
+      while (size < 3 && actSkip > 1) {
+        actSkip -= 1;
+        size = Math.floor(path.length / actSkip);
+      }
+    }
+    const finalHull = [];
+    for (let i = 0, j = 0; j < size; j++, i += actSkip) {
+      finalHull.push(path.get(i));
+    }
+    return new PointPath(finalHull);
+  };
+}
+class PointPath {
+  constructor(points = [], closed = true) {
+    this.points = points;
+    this.closed = closed;
+  }
+  get(index) {
+    const i = index;
+    const l = this.points.length;
+    if (index < 0) {
+      return this.closed ? this.get(index + l) : this.points[0];
+    } else if (index >= l) {
+      return this.closed ? this.get(index - l) : this.points[l - 1];
+    }
+    return this.points[i];
+  }
+  get length() {
+    return this.points.length;
+  }
+  toString(roundToDigits = Infinity) {
+    const points = this.points;
+    if (points.length === 0) {
+      return "";
+    }
+    const rounder = typeof roundToDigits === "function" ? roundToDigits : round(roundToDigits);
+    let r = "M";
+    for (const p of points) {
+      r += `${rounder(p.x)},${rounder(p.y)} L`;
+    }
+    r = r.slice(0, -1);
+    if (this.closed) {
+      r += " Z";
+    }
+    return r;
+  }
+  draw(ctx) {
+    const points = this.points;
+    if (points.length === 0) {
+      return;
+    }
+    ctx.beginPath();
+    ctx.moveTo(points[0].x, points[0].y);
+    for (const p of points) {
+      ctx.lineTo(p.x, p.y);
+    }
+    if (this.closed) {
+      ctx.closePath();
+    }
+  }
+  sample(skip) {
+    return samplePath(skip)(this);
+  }
+  simplify(tolerance) {
+    return shapeSimplifier(tolerance)(this);
+  }
+  bSplines(granularity) {
+    return bSplineShapeGenerator(granularity)(this);
+  }
+  apply(transformer) {
+    return transformer(this);
+  }
+  containsElements(members) {
+    const bb = boundingBox(this.points);
+    if (!bb) {
+      return false;
+    }
+    return members.every((member) => {
+      return bb.containsPt(member.cx, member.cy) && this.withinArea(member.cx, member.cy);
+    });
+  }
+  withinArea(px, py) {
+    if (this.length === 0) {
+      return false;
+    }
+    let crossings = 0;
+    const first = this.points[0];
+    const line = new Line(first.x, first.y, first.x, first.y);
+    for (let i = 1; i < this.points.length; i++) {
+      const cur = this.points[i];
+      line.x1 = line.x2;
+      line.y1 = line.y2;
+      line.x2 = cur.x;
+      line.y2 = cur.y;
+      if (line.cuts(px, py)) {
+        crossings++;
+      }
+    }
+    line.x1 = line.x2;
+    line.y1 = line.y2;
+    line.x2 = first.x;
+    line.y2 = first.y;
+    if (line.cuts(px, py)) {
+      crossings++;
+    }
+    return crossings % 2 === 1;
+  }
+}
+class PointList {
+  constructor(size = 0) {
+    this.count = 0;
+    this.arr = [];
+    this.set = /* @__PURE__ */ new Set();
+    this.arr.length = size;
+  }
+  add(p) {
+    this.set.add(`${p.x}x${p.y}`);
+    this.arr[this.count++] = p;
+  }
+  contains(p) {
+    return this.set.has(`${p.x}x${p.y}`);
+  }
+  isFirst(p) {
+    if (this.count === 0) {
+      return false;
+    }
+    const o = this.arr[0];
+    return o != null && o.x === p.x && o.y === p.y;
+  }
+  path() {
+    return new PointPath(this.arr.slice(0, this.count));
+  }
+  clear() {
+    this.set.clear();
+    this.count = 0;
+  }
+  get(ix) {
+    return this.arr[ix];
+  }
+  get length() {
+    return this.count;
+  }
+}
+const N = 0;
+const S = 1;
+const E = 2;
+const W = 3;
+function marchingSquares(potentialArea, threshold) {
+  const estLength = (Math.floor(potentialArea.width) + Math.floor(potentialArea.height)) * 2;
+  const contour = new PointList(estLength);
+  function updateDir(x, y, dir, res) {
+    const v = potentialArea.get(x, y);
+    if (Number.isNaN(v)) {
+      return Number.NaN;
+    }
+    if (v > threshold) {
+      return dir + res;
+    }
+    return dir;
+  }
+  function getState(x, y) {
+    let dir = N;
+    dir = updateDir(x, y, dir, 1);
+    dir = updateDir(x + 1, y, dir, 2);
+    dir = updateDir(x, y + 1, dir, 4);
+    dir = updateDir(x + 1, y + 1, dir, 8);
+    if (Number.isNaN(dir)) {
+      return -1;
+    }
+    return dir;
+  }
+  let direction = S;
+  function doMarch(xPos, yPos) {
+    let x = xPos;
+    let y = yPos;
+    let xPixel = potentialArea.invertScaleX(x);
+    let yPixel = potentialArea.invertScaleY(y);
+    for (let i = 0; i < potentialArea.width * potentialArea.height; i++) {
+      const p = { x: xPixel, y: yPixel };
+      if (contour.contains(p)) {
+        if (!contour.isFirst(p)) ;
+        else {
+          return true;
+        }
+      } else {
+        contour.add(p);
+      }
+      const state = getState(x, y);
+      switch (state) {
+        case -1:
+          return true;
+        case 0:
+        case 3:
+        case 2:
+        case 7:
+          direction = E;
+          break;
+        case 12:
+        case 14:
+        case 4:
+          direction = W;
+          break;
+        case 6:
+          direction = direction === N ? W : E;
+          break;
+        case 1:
+        case 13:
+        case 5:
+          direction = N;
+          break;
+        case 9:
+          direction = direction === E ? N : S;
+          break;
+        case 10:
+        case 8:
+        case 11:
+          direction = S;
+          break;
+        default:
+          console.warn("Marching squares invalid state: " + state);
+          return true;
+      }
+      switch (direction) {
+        case N:
+          y--;
+          yPixel -= potentialArea.pixelGroup;
+          break;
+        case S:
+          y++;
+          yPixel += potentialArea.pixelGroup;
+          break;
+        case W:
+          x--;
+          xPixel -= potentialArea.pixelGroup;
+          break;
+        case E:
+          x++;
+          xPixel += potentialArea.pixelGroup;
+          break;
+        default:
+          console.warn("Marching squares invalid state: " + state);
+          return true;
+      }
+    }
+    return true;
+  }
+  for (let x = 0; x < potentialArea.width; x++) {
+    for (let y = 0; y < potentialArea.height; y++) {
+      if (potentialArea.get(x, y) <= threshold) {
+        continue;
+      }
+      const state = getState(x, y);
+      if (state < 0 || state === 15) {
+        continue;
+      }
+      if (doMarch(x, y)) {
+        return contour.path();
+      }
+    }
+  }
+  return null;
+}
+const defaultOptions = {
+  maxRoutingIterations: 100,
+  maxMarchingIterations: 20,
+  pixelGroup: 4,
+  edgeR0: 10,
+  edgeR1: 20,
+  nodeR0: 15,
+  nodeR1: 50,
+  morphBuffer: 10,
+  threshold: 1,
+  memberInfluenceFactor: 1,
+  edgeInfluenceFactor: 1,
+  nonMemberInfluenceFactor: -0.8,
+  virtualEdges: true
+};
+function isCircle(v) {
+  return v != null && typeof v.radius === "number";
+}
+function isEqual(a, b) {
+  if (isCircle(a) !== isCircle(b)) {
+    return false;
+  }
+  if (isCircle(a)) {
+    const bc = b;
+    return a.cx === bc.cx && a.cy === bc.cy && a.radius === bc.radius;
+  }
+  const br = b;
+  return a.x === br.x && a.y === br.y && a.width === br.width && a.height === br.height;
+}
+var EDirty;
+(function(EDirty2) {
+  EDirty2[EDirty2["MEMBERS"] = 0] = "MEMBERS";
+  EDirty2[EDirty2["NON_MEMBERS"] = 1] = "NON_MEMBERS";
+  EDirty2[EDirty2["EDGES"] = 2] = "EDGES";
+})(EDirty || (EDirty = {}));
+let BubbleSets$1 = class BubbleSets {
+  constructor(options = {}) {
+    this.dirty = /* @__PURE__ */ new Set();
+    this.members = [];
+    this.nonMembers = [];
+    this.virtualEdges = [];
+    this.edges = [];
+    this.activeRegion = new Rectangle(0, 0, 0, 0);
+    this.potentialArea = new Area(1, 0, 0, 0, 0, 0, 0);
+    this.o = Object.assign({}, defaultOptions, options);
+  }
+  pushMember(...members) {
+    if (members.length === 0) {
+      return;
+    }
+    this.dirty.add(EDirty.MEMBERS);
+    for (const v of members) {
+      this.members.push({
+        raw: v,
+        obj: isCircle(v) ? Circle.from(v) : Rectangle.from(v),
+        area: null
+      });
+    }
+  }
+  removeMember(member) {
+    const index = this.members.findIndex((d) => isEqual(d.raw, member));
+    if (index < 0) {
+      return false;
+    }
+    this.members.splice(index, 1);
+    this.dirty.add(EDirty.MEMBERS);
+    return true;
+  }
+  removeNonMember(nonMember) {
+    const index = this.nonMembers.findIndex((d) => isEqual(d.raw, nonMember));
+    if (index < 0) {
+      return false;
+    }
+    this.nonMembers.splice(index, 1);
+    this.dirty.add(EDirty.NON_MEMBERS);
+    return true;
+  }
+  removeEdge(edge) {
+    const index = this.edges.findIndex((d) => d.obj.equals(edge));
+    if (index < 0) {
+      return false;
+    }
+    this.edges.splice(index, 1);
+    this.dirty.add(EDirty.NON_MEMBERS);
+    return true;
+  }
+  pushNonMember(...nonMembers) {
+    if (nonMembers.length === 0) {
+      return;
+    }
+    this.dirty.add(EDirty.NON_MEMBERS);
+    for (const v of nonMembers) {
+      this.nonMembers.push({
+        raw: v,
+        obj: isCircle(v) ? Circle.from(v) : Rectangle.from(v),
+        area: null
+      });
+    }
+  }
+  pushEdge(...edges) {
+    if (edges.length === 0) {
+      return;
+    }
+    this.dirty.add(EDirty.EDGES);
+    for (const v of edges) {
+      this.edges.push({
+        raw: v,
+        obj: Line.from(v),
+        area: null
+      });
+    }
+  }
+  update() {
+    const dirtyMembers = this.dirty.has(EDirty.MEMBERS);
+    const dirtyNonMembers = this.dirty.has(EDirty.NON_MEMBERS);
+    let dirtyEdges = this.dirty.has(EDirty.EDGES);
+    this.dirty.clear();
+    const memberObjs = this.members.map((d) => d.obj);
+    if (this.o.virtualEdges && (dirtyMembers || dirtyNonMembers)) {
+      const nonMembersAsRects = this.nonMembers.map((d) => d.obj);
+      const virtualEdges = calculateVirtualEdges(memberObjs, nonMembersAsRects, this.o.maxRoutingIterations, this.o.morphBuffer);
+      const old = new Map(this.virtualEdges.map((e) => [e.obj.toString(), e.area]));
+      this.virtualEdges = virtualEdges.map((e) => {
+        var _a;
+        return {
+          raw: e,
+          obj: e,
+          area: (_a = old.get(e.toString())) !== null && _a !== void 0 ? _a : null
+        };
+      });
+      dirtyEdges = true;
+    }
+    let activeRegionDirty = false;
+    if (dirtyMembers || dirtyEdges) {
+      const edgesObj = this.virtualEdges.concat(this.edges).map((e) => e.obj);
+      const bb = unionBoundingBox(memberObjs, edgesObj);
+      const padding = Math.max(this.o.edgeR1, this.o.nodeR1) + this.o.morphBuffer;
+      const activeRegion = Rectangle.from(addPadding(bb, padding));
+      if (!activeRegion.equals(this.activeRegion)) {
+        activeRegionDirty = true;
+        this.activeRegion = activeRegion;
+      }
+    }
+    if (activeRegionDirty) {
+      const potentialWidth = Math.ceil(this.activeRegion.width / this.o.pixelGroup);
+      const potentialHeight = Math.ceil(this.activeRegion.height / this.o.pixelGroup);
+      if (this.activeRegion.x !== this.potentialArea.pixelX || this.activeRegion.y !== this.potentialArea.pixelY) {
+        this.potentialArea = Area.fromPixelRegion(this.activeRegion, this.o.pixelGroup);
+        this.members.forEach((m) => m.area = null);
+        this.nonMembers.forEach((m) => m.area = null);
+        this.edges.forEach((m) => m.area = null);
+        this.virtualEdges.forEach((m) => m.area = null);
+      } else if (potentialWidth !== this.potentialArea.width || potentialHeight !== this.potentialArea.height) {
+        this.potentialArea = Area.fromPixelRegion(this.activeRegion, this.o.pixelGroup);
+      }
+    }
+    const existing = /* @__PURE__ */ new Map();
+    const addCache = (m) => {
+      if (m.area) {
+        const key = `${m.obj.width}x${m.obj.height}x${m.obj instanceof Rectangle ? "R" : "C"}`;
+        existing.set(key, m.area);
+      }
+    };
+    const createOrAddCache = (m) => {
+      if (m.area) {
+        return;
+      }
+      const key = `${m.obj.width}x${m.obj.height}x${m.obj instanceof Rectangle ? "R" : "C"}`;
+      if (existing.has(key)) {
+        const r2 = existing.get(key);
+        m.area = this.potentialArea.copy(r2, { x: m.obj.x - this.o.nodeR1, y: m.obj.y - this.o.nodeR1 });
+        return;
+      }
+      const r = m.obj instanceof Rectangle ? createRectangleInfluenceArea(m.obj, this.potentialArea, this.o.nodeR1) : createGenericInfluenceArea(m.obj, this.potentialArea, this.o.nodeR1);
+      m.area = r;
+      existing.set(key, r);
+    };
+    this.members.forEach(addCache);
+    this.nonMembers.forEach(addCache);
+    this.members.forEach(createOrAddCache);
+    this.nonMembers.forEach((m) => {
+      if (!this.activeRegion.intersects(m.obj)) {
+        m.area = null;
+      } else {
+        createOrAddCache(m);
+      }
+    });
+    this.edges.forEach((edge) => {
+      if (!edge.area) {
+        edge.area = createLineInfluenceArea(edge.obj, this.potentialArea, this.o.edgeR1);
+      }
+    });
+    this.virtualEdges.forEach((edge) => {
+      if (!edge.area) {
+        edge.area = createLineInfluenceArea(edge.obj, this.potentialArea, this.o.edgeR1);
+      }
+    });
+  }
+  drawMembers(ctx) {
+    for (const member of this.members) {
+      member.obj.draw(ctx);
+    }
+  }
+  drawNonMembers(ctx) {
+    for (const member of this.nonMembers) {
+      member.obj.draw(ctx);
+    }
+  }
+  drawEdges(ctx) {
+    for (const edge of this.edges) {
+      edge.obj.draw(ctx);
+    }
+  }
+  drawPotentialArea(ctx, offset = true) {
+    this.potentialArea.draw(ctx, offset);
+  }
+  compute() {
+    if (this.members.length === 0) {
+      return new PointPath([]);
+    }
+    if (this.dirty.size > 0) {
+      this.update();
+    }
+    const { o, potentialArea } = this;
+    const members = this.members.map((m) => m.area);
+    const edges = this.virtualEdges.concat(this.edges).map((d) => d.area);
+    const nonMembers = this.nonMembers.filter((d) => d.area != null).map((d) => d.area);
+    const memberObjs = this.members.map((m) => m.obj);
+    return calculatePotentialOutline(potentialArea, members, edges, nonMembers, (p) => p.containsElements(memberObjs), o);
+  }
+};
+function calculatePotentialOutline(potentialArea, members, edges, nonMembers, validPath, options = {}) {
+  const o = Object.assign({}, defaultOptions, options);
+  let threshold = o.threshold;
+  let memberInfluenceFactor = o.memberInfluenceFactor;
+  let edgeInfluenceFactor = o.edgeInfluenceFactor;
+  let nonMemberInfluenceFactor = o.nonMemberInfluenceFactor;
+  const nodeInfA = (o.nodeR0 - o.nodeR1) * (o.nodeR0 - o.nodeR1);
+  const edgeInfA = (o.edgeR0 - o.edgeR1) * (o.edgeR0 - o.edgeR1);
+  for (let iterations = 0; iterations < o.maxMarchingIterations; iterations++) {
+    potentialArea.clear();
+    if (memberInfluenceFactor !== 0) {
+      const f = memberInfluenceFactor / nodeInfA;
+      for (const item of members) {
+        potentialArea.incArea(item, f);
+      }
+    }
+    if (edgeInfluenceFactor !== 0) {
+      const f = edgeInfluenceFactor / edgeInfA;
+      for (const area of edges) {
+        potentialArea.incArea(area, f);
+      }
+    }
+    if (nonMemberInfluenceFactor !== 0) {
+      const f = nonMemberInfluenceFactor / nodeInfA;
+      for (const area of nonMembers) {
+        potentialArea.incArea(area, f);
+      }
+    }
+    const contour = marchingSquares(potentialArea, threshold);
+    if (contour && validPath(contour)) {
+      return contour;
+    }
+    threshold *= 0.95;
+    if (iterations <= o.maxMarchingIterations * 0.5) {
+      memberInfluenceFactor *= 1.2;
+      edgeInfluenceFactor *= 1.2;
+    } else if (nonMemberInfluenceFactor !== 0 && nonMembers.length > 0) {
+      nonMemberInfluenceFactor *= 0.8;
+    } else {
+      break;
+    }
+  }
+  return new PointPath([]);
+}
+function unionBoundingBox(memberItems, edgeItems) {
+  if (memberItems.length === 0) {
+    return new Rectangle(0, 0, 0, 0);
+  }
+  const activeRegion = Rectangle.from(memberItems[0]);
+  for (const m of memberItems) {
+    activeRegion.add(m);
+  }
+  for (const l of edgeItems) {
+    activeRegion.add(lineBoundingBox(l));
+  }
+  return activeRegion;
+}
+export {
+  Area,
+  BubbleSets$1 as BubbleSets,
+  Circle,
+  Line,
+  PointPath,
+  Rectangle,
+  addPadding,
+  boundingBox,
+  calculatePotentialOutline,
+  calculateVirtualEdges,
+  createGenericInfluenceArea,
+  createLineInfluenceArea,
+  createRectangleInfluenceArea,
+  BubbleSets$1 as default,
+  defaultOptions,
+  lineBoundingBox,
+  point,
+  unionBoundingBox
+};
+//# sourceMappingURL=index.js.map