@hkyhy/marsun-components-core 0.1.113 → 0.1.115

package/dist/node_modules/bubblesets-js/build/index.js

@@ -0,0 +1,1075 @@
+function _(i, t, s, e, r, n) {
+  const h = i, o = t, a = s - h, c = e - o;
+  let l = r - h, f = n - o, u = l * a + f * c, x = 0;
+  u <= 0 ? x = 0 : (l = a - l, f = c - f, u = l * a + f * c, u <= 0 ? x = 0 : x = u * u / (a * a + c * c));
+  const p = l * l + f * f - x;
+  return p < 0 ? 0 : p;
+}
+function P(i, t, s, e) {
+  return (i - s) * (i - s) + (t - e) * (t - e);
+}
+function z(i, t, s, e, r) {
+  return P(i, t, s, e) < r * r;
+}
+function et(i) {
+  if (!Number.isFinite(i))
+    return (s) => s;
+  if (i === 0)
+    return Math.round;
+  const t = Math.pow(10, i);
+  return (s) => Math.round(s * t) / t;
+}
+function J(i) {
+  const t = Math.min(i.x1, i.x2), s = Math.max(i.x1, i.x2), e = Math.min(i.y1, i.y2), r = Math.max(i.y1, i.y2);
+  return {
+    x: t,
+    y: e,
+    x2: s,
+    y2: r,
+    width: s - t,
+    height: r - e
+  };
+}
+class T {
+  constructor(t, s, e, r) {
+    this.x1 = t, this.y1 = s, this.x2 = e, this.y2 = r;
+  }
+  equals(t) {
+    return this.x1 === t.x1 && this.y1 === t.y1 && this.x2 === t.x2 && this.y2 === t.y2;
+  }
+  draw(t) {
+    t.moveTo(this.x1, this.y1), t.lineTo(this.x2, this.y2);
+  }
+  toString() {
+    return `Line(from=(${this.x1},${this.y1}),to=(${this.x2},${this.y2}))`;
+  }
+  static from(t) {
+    return new T(t.x1, t.y1, t.x2, t.y2);
+  }
+  cuts(t, s) {
+    if (this.y1 === this.y2 || s < this.y1 && s <= this.y2 || s > this.y1 && s >= this.y2 || t > this.x1 && t >= this.x2)
+      return !1;
+    if (t < this.x1 && t <= this.x2)
+      return !0;
+    const e = this.x1 + (s - this.y1) * (this.x2 - this.x1) / (this.y2 - this.y1);
+    return t <= e;
+  }
+  distSquare(t, s) {
+    return _(this.x1, this.y1, this.x2, this.y2, t, s);
+  }
+  ptClose(t, s, e) {
+    if (this.x1 < this.x2) {
+      if (t < this.x1 - e || t > this.x2 + e)
+        return !1;
+    } else if (t < this.x2 - e || t > this.x1 + e)
+      return !1;
+    if (this.y1 < this.y2) {
+      if (s < this.y1 - e || s > this.y2 + e)
+        return !1;
+    } else if (s < this.y2 - e || s > this.y1 + e)
+      return !1;
+    return !0;
+  }
+}
+var w;
+(function(i) {
+  i[i.POINT = 1] = "POINT", i[i.PARALLEL = 2] = "PARALLEL", i[i.COINCIDENT = 3] = "COINCIDENT", i[i.NONE = 4] = "NONE";
+})(w || (w = {}));
+class k {
+  constructor(t, s = 0, e = 0) {
+    this.state = t, this.x = s, this.y = e;
+  }
+}
+function A(i, t) {
+  const s = (t.x2 - t.x1) * (i.y1 - t.y1) - (t.y2 - t.y1) * (i.x1 - t.x1), e = (i.x2 - i.x1) * (i.y1 - t.y1) - (i.y2 - i.y1) * (i.x1 - t.x1), r = (t.y2 - t.y1) * (i.x2 - i.x1) - (t.x2 - t.x1) * (i.y2 - i.y1);
+  if (r) {
+    const n = s / r, h = e / r;
+    return 0 <= n && n <= 1 && 0 <= h && h <= 1 ? new k(w.POINT, i.x1 + n * (i.x2 - i.x1), i.y1 + n * (i.y2 - i.y1)) : new k(w.NONE);
+  }
+  return new k(s === 0 || e === 0 ? w.COINCIDENT : w.PARALLEL);
+}
+function K(i, t) {
+  const s = (t.x2 - t.x1) * (i.y1 - t.y1) - (t.y2 - t.y1) * (i.x1 - t.x1), e = (i.x2 - i.x1) * (i.y1 - t.y1) - (i.y2 - i.y1) * (i.x1 - t.x1), r = (t.y2 - t.y1) * (i.x2 - i.x1) - (t.x2 - t.x1) * (i.y2 - i.y1);
+  if (r) {
+    const n = s / r, h = e / r;
+    if (0 <= n && n <= 1 && 0 <= h && h <= 1)
+      return n;
+  }
+  return Number.POSITIVE_INFINITY;
+}
+function nt(i, t) {
+  function s(r, n, h, o) {
+    let a = K(t, new T(r, n, h, o));
+    return a = Math.abs(a - 0.5), a >= 0 && a <= 1 ? 1 : 0;
+  }
+  let e = s(i.x, i.y, i.x2, i.y);
+  return e += s(i.x, i.y, i.x, i.y2), e > 1 || (e += s(i.x, i.y2, i.x2, i.y2), e > 1) ? !0 : (e += s(i.x2, i.y, i.x2, i.y2), e > 0);
+}
+var M;
+(function(i) {
+  i[i.LEFT = 0] = "LEFT", i[i.TOP = 1] = "TOP", i[i.RIGHT = 2] = "RIGHT", i[i.BOTTOM = 3] = "BOTTOM";
+})(M || (M = {}));
+function $(i, t, s) {
+  const e = /* @__PURE__ */ new Set();
+  return i.width <= 0 ? (e.add(M.LEFT), e.add(M.RIGHT)) : t < i.x ? e.add(M.LEFT) : t > i.x + i.width && e.add(M.RIGHT), i.height <= 0 ? (e.add(M.TOP), e.add(M.BOTTOM)) : s < i.y ? e.add(M.TOP) : s > i.y + i.height && e.add(M.BOTTOM), e;
+}
+function Q(i, t) {
+  let s = t.x1, e = t.y1;
+  const r = t.x2, n = t.y2, h = Array.from($(i, r, n));
+  if (h.length === 0)
+    return !0;
+  let o = $(i, s, e);
+  for (; o.size !== 0; ) {
+    for (const a of h)
+      if (o.has(a))
+        return !1;
+    if (o.has(M.RIGHT) || o.has(M.LEFT)) {
+      let a = i.x;
+      o.has(M.RIGHT) && (a += i.width), e = e + (a - s) * (n - e) / (r - s), s = a;
+    } else {
+      let a = i.y;
+      o.has(M.BOTTOM) && (a += i.height), s = s + (a - e) * (r - s) / (n - e), e = a;
+    }
+    o = $(i, s, e);
+  }
+  return !0;
+}
+function rt(i, t) {
+  let s = Number.POSITIVE_INFINITY, e = 0;
+  function r(n, h, o, a) {
+    let c = K(t, new T(n, h, o, a));
+    c = Math.abs(c - 0.5), c >= 0 && c <= 1 && (e++, c < s && (s = c));
+  }
+  return r(i.x, i.y, i.x2, i.y), r(i.x, i.y, i.x, i.y2), e > 1 || (r(i.x, i.y2, i.x2, i.y2), e > 1) ? s : (r(i.x2, i.y, i.x2, i.y2), e === 0 ? -1 : s);
+}
+function ht(i, t) {
+  let s = 0;
+  const e = A(i, new T(t.x, t.y, t.x2, t.y));
+  s += e.state === w.POINT ? 1 : 0;
+  const r = A(i, new T(t.x, t.y, t.x, t.y2));
+  s += r.state === w.POINT ? 1 : 0;
+  const n = A(i, new T(t.x, t.y2, t.x2, t.y2));
+  s += n.state === w.POINT ? 1 : 0;
+  const h = A(i, new T(t.x2, t.y, t.x2, t.y2));
+  return s += h.state === w.POINT ? 1 : 0, { top: e, left: r, bottom: n, right: h, count: s };
+}
+class N {
+  constructor(t, s, e, r) {
+    this.x = t, this.y = s, this.width = e, this.height = r;
+  }
+  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(t) {
+    return new N(t.x, t.y, t.width, t.height);
+  }
+  equals(t) {
+    return this.x === t.x && this.y === t.y && this.width === t.width && this.height === t.height;
+  }
+  clone() {
+    return new N(this.x, this.y, this.width, this.height);
+  }
+  add(t) {
+    const s = Math.min(this.x, t.x), e = Math.min(this.y, t.y), r = Math.max(this.x2, t.x + t.width), n = Math.max(this.y2, t.y + t.height);
+    this.x = s, this.y = e, this.width = r - s, this.height = n - e;
+  }
+  addPoint(t) {
+    const s = Math.min(this.x, t.x), e = Math.min(this.y, t.y), r = Math.max(this.x2, t.x), n = Math.max(this.y2, t.y);
+    this.x = s, this.y = e, this.width = r - s, this.height = n - e;
+  }
+  toString() {
+    return `Rectangle[x=${this.x}, y=${this.y}, w=${this.width}, h=${this.height}]`;
+  }
+  draw(t) {
+    t.rect(this.x, this.y, this.width, this.height);
+  }
+  containsPt(t, s) {
+    return t >= this.x && t <= this.x2 && s >= this.y && s <= this.y2;
+  }
+  get area() {
+    return this.width * this.height;
+  }
+  intersects(t) {
+    return this.area <= 0 || t.width <= 0 || t.height <= 0 ? !1 : t.x + t.width > this.x && t.y + t.height > this.y && t.x < this.x2 && t.y < this.y2;
+  }
+  distSquare(t, s) {
+    if (this.containsPt(t, s))
+      return 0;
+    const e = $(this, t, s);
+    return e.has(M.TOP) ? e.has(M.LEFT) ? P(t, s, this.x, this.y) : e.has(M.RIGHT) ? P(t, s, this.x2, this.y) : (this.y - s) * (this.y - s) : e.has(M.BOTTOM) ? e.has(M.LEFT) ? P(t, s, this.x, this.y2) : e.has(M.RIGHT) ? P(t, s, this.x2, this.y2) : (s - this.y2) * (s - this.y2) : e.has(M.LEFT) ? (this.x - t) * (this.x - t) : e.has(M.RIGHT) ? (t - this.x2) * (t - this.x2) : 0;
+  }
+}
+function ot(i) {
+  if (i.length === 0)
+    return null;
+  const t = i[0], s = new N(t.x, t.y, 0, 0);
+  for (const e of i)
+    s.addPoint(e);
+  return s;
+}
+class X {
+  constructor(t, s, e) {
+    this.cx = t, this.cy = s, this.radius = e;
+  }
+  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(t) {
+    return new X(t.cx, t.cy, t.radius);
+  }
+  containsPt(t, s) {
+    return P(this.cx, this.cy, t, s) < this.radius * this.radius;
+  }
+  distSquare(t, s) {
+    const e = P(this.cx, this.cy, t, s);
+    if (e < this.radius * this.radius)
+      return 0;
+    const r = Math.sqrt(e) - this.radius;
+    return r * r;
+  }
+  draw(t) {
+    t.ellipse(this.cx, this.cy, this.radius, this.radius, 0, 0, Math.PI * 2);
+  }
+}
+class m {
+  constructor(t, s = 0, e = 0, r = 0, n = 0, h = 10, o = 10, a = new Float32Array(Math.max(0, h * o)).fill(0)) {
+    this.pixelGroup = t, this.i = s, this.j = e, this.pixelX = r, this.pixelY = n, this.width = h, this.height = o, this.area = a;
+  }
+  createSub(t, s) {
+    return new m(this.pixelGroup, t.x, t.y, s.x, s.y, t.width, t.height);
+  }
+  static fromPixelRegion(t, s) {
+    return new m(s, 0, 0, t.x, t.y, Math.ceil(t.width / s), Math.ceil(t.height / s));
+  }
+  copy(t, s) {
+    return new m(this.pixelGroup, this.scaleX(s.x), this.scaleY(s.y), s.x, s.y, t.width, t.height, t.area);
+  }
+  boundX(t) {
+    return t < this.i ? this.i : t >= this.width ? this.width - 1 : t;
+  }
+  boundY(t) {
+    return t < this.j ? this.j : t >= this.height ? this.height - 1 : t;
+  }
+  scaleX(t) {
+    return this.boundX(Math.floor((t - this.pixelX) / this.pixelGroup));
+  }
+  scaleY(t) {
+    return this.boundY(Math.floor((t - this.pixelY) / this.pixelGroup));
+  }
+  scale(t) {
+    const s = this.scaleX(t.x), e = this.scaleY(t.y), r = this.boundX(Math.ceil((t.x + t.width - this.pixelX) / this.pixelGroup)), n = this.boundY(Math.ceil((t.y + t.height - this.pixelY) / this.pixelGroup)), h = r - s, o = n - e;
+    return new N(s, e, h, o);
+  }
+  invertScaleX(t) {
+    return Math.round(t * this.pixelGroup + this.pixelX);
+  }
+  invertScaleY(t) {
+    return Math.round(t * this.pixelGroup + this.pixelY);
+  }
+  addPadding(t, s) {
+    const e = Math.ceil(s / this.pixelGroup), r = this.boundX(t.x - e), n = this.boundY(t.y - e), h = this.boundX(t.x2 + e), o = this.boundY(t.y2 + e), a = h - r, c = o - n;
+    return new N(r, n, a, c);
+  }
+  get(t, s) {
+    return t < 0 || s < 0 || t >= this.width || s >= this.height ? Number.NaN : this.area[t + s * this.width];
+  }
+  inc(t, s, e) {
+    t < 0 || s < 0 || t >= this.width || s >= this.height || (this.area[t + s * this.width] += e);
+  }
+  set(t, s, e) {
+    t < 0 || s < 0 || t >= this.width || s >= this.height || (this.area[t + s * this.width] = e);
+  }
+  incArea(t, s) {
+    if (t.width <= 0 || t.height <= 0 || s === 0)
+      return;
+    const e = this.width, r = t.width, n = Math.max(0, t.i), h = Math.max(0, t.j), o = Math.min(t.i + t.width, e), a = Math.min(t.j + t.height, this.height);
+    if (!(a <= 0 || o <= 0 || n >= e || a >= this.height))
+      for (let c = h; c < a; c++) {
+        const l = (c - t.j) * r, f = c * e;
+        for (let u = n; u < o; u++) {
+          const x = t.area[u - t.i + l];
+          x !== 0 && (this.area[u + f] += s * x);
+        }
+      }
+  }
+  fill(t) {
+    this.area.fill(t);
+  }
+  fillArea(t, s) {
+    const e = t.x + t.y * this.width;
+    for (let r = 0; r < t.height; r++) {
+      const n = e + r * this.width;
+      this.area.fill(s, n, n + t.width);
+    }
+  }
+  fillHorizontalLine(t, s, e, r) {
+    const n = t + s * this.width;
+    this.area.fill(r, n, n + e);
+  }
+  fillVerticalLine(t, s, e, r) {
+    const n = t + s * this.width;
+    for (let h = 0; h < e; h++)
+      this.area[n + h * this.width] = r;
+  }
+  clear() {
+    this.area.fill(0);
+  }
+  toString() {
+    let t = "";
+    for (let s = 0; s < this.height; s++) {
+      const e = s * this.width;
+      for (let r = 0; r < this.width; r++) {
+        const n = this.area[e + r];
+        t += n.toFixed(1).padStart(6), t += " ";
+      }
+      t += `
+`;
+    }
+    return t;
+  }
+  draw(t, s = !0) {
+    if (this.width <= 0 || this.height <= 0)
+      return;
+    t.save(), s && t.translate(this.pixelX, this.pixelY);
+    const e = this.area.reduce((h, o) => Math.min(h, o), Number.POSITIVE_INFINITY), r = this.area.reduce((h, o) => Math.max(h, o), Number.NEGATIVE_INFINITY), n = (h) => (h - e) / (r - e);
+    t.scale(this.pixelGroup, this.pixelGroup);
+    for (let h = 0; h < this.width; h++)
+      for (let o = 0; o < this.height; o++) {
+        const a = this.area[h + o * this.width];
+        t.fillStyle = `rgba(0, 0, 0, ${n(a)})`, t.fillRect(h, o, 1, 1);
+      }
+    t.restore();
+  }
+  drawThreshold(t, s, e = !0) {
+    if (!(this.width <= 0 || this.height <= 0)) {
+      t.save(), e && t.translate(this.pixelX, this.pixelY), t.scale(this.pixelGroup, this.pixelGroup);
+      for (let r = 0; r < this.width; r++)
+        for (let n = 0; n < this.height; n++) {
+          const h = this.area[r + n * this.width];
+          t.fillStyle = h > s ? "black" : "white", t.fillRect(r, n, 1, 1);
+        }
+      t.restore();
+    }
+  }
+}
+function U(i, t) {
+  const s = (e) => ({
+    x: e.x - t,
+    y: e.y - t,
+    width: e.width + 2 * t,
+    height: e.height + 2 * t
+  });
+  return Array.isArray(i) ? i.map(s) : s(i);
+}
+function W(i, t, s) {
+  return B(Object.assign(J(i), {
+    distSquare: (e, r) => _(i.x1, i.y1, i.x2, i.y2, e, r)
+  }), t, s);
+}
+function B(i, t, s) {
+  const e = U(i, s), r = t.scale(e), n = t.createSub(r, e);
+  return ct(n, t, s, (h, o) => i.distSquare(h, o)), n;
+}
+function ct(i, t, s, e) {
+  const r = s * s;
+  for (let n = 0; n < i.height; n++)
+    for (let h = 0; h < i.width; h++) {
+      const o = t.invertScaleX(i.i + h), a = t.invertScaleY(i.j + n), c = e(o, a);
+      if (c === 0) {
+        i.set(h, n, r);
+        continue;
+      }
+      if (c < r) {
+        const l = s - Math.sqrt(c);
+        i.set(h, n, l * l);
+      }
+    }
+  return i;
+}
+function at(i, t, s) {
+  const e = t.scale(i), r = t.addPadding(e, s), n = t.createSub(r, { x: i.x - s, y: i.y - s }), h = e.x - r.x, o = e.y - r.y, a = r.x2 - e.x2, c = r.y2 - e.y2, l = r.width - h - a, f = r.height - o - c, u = s * s;
+  n.fillArea({
+    x: h,
+    y: o,
+    width: l + 1,
+    height: f + 1
+  }, u);
+  const x = [0], p = Math.max(o, h, a, c);
+  {
+    const y = t.invertScaleX(e.x + e.width / 2);
+    for (let I = 1; I < p; I++) {
+      const S = t.invertScaleY(e.y - I), d = i.distSquare(y, S);
+      if (d < u) {
+        const b = s - Math.sqrt(d);
+        x.push(b * b);
+      } else
+        break;
+    }
+  }
+  const E = [], R = Math.max(h, a), st = Math.max(o, a);
+  for (let y = 1; y < R; y++) {
+    const I = t.invertScaleX(e.x - y), S = [];
+    for (let d = 1; d < st; d++) {
+      const b = t.invertScaleY(e.y - d), V = i.distSquare(I, b);
+      if (V < u) {
+        const C = s - Math.sqrt(V);
+        S.push(C * C);
+      } else
+        S.push(0);
+    }
+    E.push(S);
+  }
+  for (let y = 1; y < Math.min(o, x.length); y++) {
+    const I = x[y];
+    n.fillHorizontalLine(h, o - y, l + 1, I);
+  }
+  for (let y = 1; y < Math.min(c, x.length); y++) {
+    const I = x[y];
+    n.fillHorizontalLine(h, o + f + y, l + 1, I);
+  }
+  for (let y = 1; y < Math.min(h, x.length); y++) {
+    const I = x[y];
+    n.fillVerticalLine(h - y, o, f + 1, I);
+  }
+  for (let y = 1; y < Math.min(c, x.length); y++) {
+    const I = x[y];
+    n.fillVerticalLine(h + l + y, o, f + 1, I);
+  }
+  for (let y = 1; y < h; y++) {
+    const I = E[y - 1], S = h - y;
+    for (let d = 1; d < o; d++)
+      n.set(S, o - d, I[d - 1]);
+    for (let d = 1; d < c; d++)
+      n.set(S, o + f + d, I[d - 1]);
+  }
+  for (let y = 1; y < a; y++) {
+    const I = E[y - 1], S = h + l + y;
+    for (let d = 1; d < o; d++)
+      n.set(S, o - d, I[d - 1]);
+    for (let d = 1; d < c; d++)
+      n.set(S, o + f + d, I[d - 1]);
+  }
+  return n;
+}
+function g(i, t) {
+  return { x: i, y: t };
+}
+function lt(i, t, s, e) {
+  if (i.length === 0)
+    return [];
+  const r = dt(i);
+  return r.map((n, h) => {
+    const o = r.slice(0, h);
+    return ut(t, n, o, s, e);
+  }).flat();
+}
+function ut(i, t, s, e, r) {
+  const n = g(t.cx, t.cy), h = yt(n, s, i);
+  if (h == null)
+    return [];
+  const o = new T(n.x, n.y, h.cx, h.cy), a = ft(o, i, e, r);
+  return xt(a, i);
+}
+function ft(i, t, s, e) {
+  const r = [], n = [];
+  n.push(i);
+  let h = !0;
+  for (let o = 0; o < s && h; o++)
+    for (h = !1; !h && n.length > 0; ) {
+      const a = n.pop(), c = tt(t, a), l = c ? ht(a, c) : null;
+      if (!c || !l || l.count !== 2) {
+        h || r.push(a);
+        continue;
+      }
+      let f = e, u = q(c, f, l, !0), x = O(u, n) || O(u, r), p = F(u, t);
+      for (; !x && p && f >= 1; )
+        f /= 1.5, u = q(c, f, l, !0), x = O(u, n) || O(u, r), p = F(u, t);
+      if (u && !x && !p && (n.push(new T(a.x1, a.y1, u.x, u.y)), n.push(new T(u.x, u.y, a.x2, a.y2)), h = !0), h)
+        continue;
+      f = e, u = q(c, f, l, !1);
+      let E = O(u, n) || O(u, r);
+      for (p = F(u, t); !E && p && f >= 1; )
+        f /= 1.5, u = q(c, f, l, !1), E = O(u, n) || O(u, r), p = F(u, t);
+      u && !E && (n.push(new T(a.x1, a.y1, u.x, u.y)), n.push(new T(u.x, u.y, a.x2, a.y2)), h = !0), h || r.push(a);
+    }
+  for (; n.length > 0; )
+    r.push(n.pop());
+  return r;
+}
+function xt(i, t) {
+  const s = [];
+  for (; i.length > 0; ) {
+    const e = i.pop();
+    if (i.length === 0) {
+      s.push(e);
+      break;
+    }
+    const r = i.pop(), n = new T(e.x1, e.y1, r.x2, r.y2);
+    tt(t, n) ? (s.push(e), i.push(r)) : i.push(n);
+  }
+  return s;
+}
+function yt(i, t, s) {
+  let e = Number.POSITIVE_INFINITY;
+  return t.reduce((r, n) => {
+    const h = P(i.x, i.y, n.cx, n.cy);
+    if (h > e)
+      return r;
+    const o = new T(i.x, i.y, n.cx, n.cy), a = gt(s, o);
+    return h * (a + 1) * (a + 1) < e && (r = n, e = h * (a + 1) * (a + 1)), r;
+  }, null);
+}
+function dt(i) {
+  if (i.length < 2)
+    return i;
+  let t = 0, s = 0;
+  return i.forEach((e) => {
+    t += e.cx, s += e.cy;
+  }), t /= i.length, s /= i.length, i.map((e) => {
+    const r = t - e.cx, n = s - e.cy, h = r * r + n * n;
+    return [e, h];
+  }).sort((e, r) => e[1] - r[1]).map((e) => e[0]);
+}
+function F(i, t) {
+  return t.some((s) => s.containsPt(i.x, i.y));
+}
+function O(i, t) {
+  return t.some((s) => !!(z(s.x1, s.y1, i.x, i.y, 1e-3) || z(s.x2, s.y2, i.x, i.y, 1e-3)));
+}
+function tt(i, t) {
+  let s = Number.POSITIVE_INFINITY, e = null;
+  for (const r of i) {
+    if (!Q(r, t))
+      continue;
+    const n = rt(r, t);
+    n >= 0 && n < s && (e = r, s = n);
+  }
+  return e;
+}
+function gt(i, t) {
+  return i.reduce((s, e) => Q(e, t) && nt(e, t) ? s + 1 : s, 0);
+}
+function q(i, t, s, e) {
+  const r = s.top, n = s.left, h = s.bottom, o = s.right;
+  if (e) {
+    if (n.state === w.POINT) {
+      if (r.state === w.POINT)
+        return g(i.x - t, i.y - t);
+      if (h.state === w.POINT)
+        return g(i.x - t, i.y2 + t);
+      const u = i.width * i.height;
+      return i.width * ((n.y - i.y + (o.y - i.y)) * 0.5) < u * 0.5 ? n.y > o.y ? g(i.x - t, i.y - t) : g(i.x2 + t, i.y - t) : n.y < o.y ? g(i.x - t, i.y2 + t) : g(i.x2 + t, i.y2 + t);
+    }
+    if (o.state === w.POINT) {
+      if (r.state === w.POINT)
+        return g(i.x2 + t, i.y - t);
+      if (h.state === w.POINT)
+        return g(i.x2 + t, i.y2 + t);
+    }
+    const l = i.height * i.width;
+    return i.height * ((r.x - i.x + (o.x - i.x)) * 0.5) < l * 0.5 ? r.x > h.x ? g(i.x - t, i.y - t) : g(i.x - t, i.y2 + t) : r.x < h.x ? g(i.x2 + t, i.y - t) : g(i.x2 + t, i.y2 + t);
+  }
+  if (n.state === w.POINT) {
+    if (r.state === w.POINT)
+      return g(i.x2 + t, i.y2 + t);
+    if (h.state === w.POINT)
+      return g(i.x2 + t, i.y - t);
+    const l = i.height * i.width;
+    return i.width * ((n.y - i.y + (o.y - i.y)) * 0.5) < l * 0.5 ? n.y > o.y ? g(i.x2 + t, i.y2 + t) : g(i.x - t, i.y2 + t) : n.y < o.y ? g(i.x2 + t, i.y - t) : g(i.x - t, i.y - t);
+  }
+  if (o.state === w.POINT) {
+    if (r.state === w.POINT)
+      return g(i.x - t, i.y2 + t);
+    if (h.state === w.POINT)
+      return g(i.x - t, i.y - t);
+  }
+  const a = i.height * i.width;
+  return i.height * ((r.x - i.x + (o.x - i.x)) * 0.5) < a * 0.5 ? r.x > h.x ? g(i.x2 + t, i.y2 + t) : g(i.x2 + t, i.y - t) : r.x < h.x ? g(i.x - t, i.y2 + t) : g(i.x - t, i.y - t);
+}
+function wt(i, t, s, e) {
+  if (!(i.closed ? s < i.length : s < i.length - 1))
+    return !1;
+  const n = i.get(t), h = i.get(s + 1);
+  for (let o = t + 1; o <= s; o++) {
+    const a = i.get(o);
+    if (_(n.x, n.y, h.x, h.y, a.x, a.y) > e)
+      return !1;
+  }
+  return !0;
+}
+function Mt(i = 0) {
+  return (t) => {
+    if (i < 0 || t.length < 3)
+      return t;
+    const s = [];
+    let e = 0;
+    const r = i * i;
+    for (; e < t.length; ) {
+      let n = e + 1;
+      for (; wt(t, e, n, r); )
+        n++;
+      s.push(t.get(e)), e = n;
+    }
+    return new j(s);
+  };
+}
+function It(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 pt(i = 6) {
+  function n(h, o, a) {
+    let c = 0, l = 0;
+    for (let f = -2; f <= 1; f++) {
+      const u = h.get(o + f), x = It(f, a);
+      c += x * u.x, l += x * u.y;
+    }
+    return { x: c, y: l };
+  }
+  return (h) => {
+    if (h.length < 3)
+      return h;
+    const o = [], a = h.closed, c = h.length + 3 - 1 + (a ? 0 : 2);
+    o.push(n(h, 2 - (a ? 0 : 2), 0));
+    for (let l = 2 - (a ? 0 : 2); l < c; l++)
+      for (let f = 1; f <= i; f++)
+        o.push(n(h, l, f / i));
+    return new j(o);
+  };
+}
+function Et(i = 8) {
+  return (t) => {
+    let s = i, e = t.length;
+    if (s > 1)
+      for (e = Math.floor(t.length / s); e < 3 && s > 1; )
+        s -= 1, e = Math.floor(t.length / s);
+    const r = [];
+    for (let n = 0, h = 0; h < e; h++, n += s)
+      r.push(t.get(n));
+    return new j(r);
+  };
+}
+class j {
+  constructor(t = [], s = !0) {
+    this.points = t, this.closed = s;
+  }
+  get(t) {
+    const s = t, e = this.points.length;
+    return t < 0 ? this.closed ? this.get(t + e) : this.points[0] : t >= e ? this.closed ? this.get(t - e) : this.points[e - 1] : this.points[s];
+  }
+  get length() {
+    return this.points.length;
+  }
+  toString(t = 1 / 0) {
+    const s = this.points;
+    if (s.length === 0)
+      return "";
+    const e = typeof t == "function" ? t : et(t);
+    let r = "M";
+    for (const n of s)
+      r += `${e(n.x)},${e(n.y)} L`;
+    return r = r.slice(0, -1), this.closed && (r += " Z"), r;
+  }
+  draw(t) {
+    const s = this.points;
+    if (s.length !== 0) {
+      t.beginPath(), t.moveTo(s[0].x, s[0].y);
+      for (const e of s)
+        t.lineTo(e.x, e.y);
+      this.closed && t.closePath();
+    }
+  }
+  sample(t) {
+    return Et(t)(this);
+  }
+  simplify(t) {
+    return Mt(t)(this);
+  }
+  bSplines(t) {
+    return pt(t)(this);
+  }
+  apply(t) {
+    return t(this);
+  }
+  containsElements(t) {
+    const s = ot(this.points);
+    return s ? t.every((e) => s.containsPt(e.cx, e.cy) && this.withinArea(e.cx, e.cy)) : !1;
+  }
+  withinArea(t, s) {
+    if (this.length === 0)
+      return !1;
+    let e = 0;
+    const r = this.points[0], n = new T(r.x, r.y, r.x, r.y);
+    for (let h = 1; h < this.points.length; h++) {
+      const o = this.points[h];
+      n.x1 = n.x2, n.y1 = n.y2, n.x2 = o.x, n.y2 = o.y, n.cuts(t, s) && e++;
+    }
+    return n.x1 = n.x2, n.y1 = n.y2, n.x2 = r.x, n.y2 = r.y, n.cuts(t, s) && e++, e % 2 === 1;
+  }
+}
+class Tt {
+  constructor(t = 0) {
+    this.count = 0, this.arr = [], this.set = /* @__PURE__ */ new Set(), this.arr.length = t;
+  }
+  add(t) {
+    this.set.add(`${t.x}x${t.y}`), this.arr[this.count++] = t;
+  }
+  contains(t) {
+    return this.set.has(`${t.x}x${t.y}`);
+  }
+  isFirst(t) {
+    if (this.count === 0)
+      return !1;
+    const s = this.arr[0];
+    return s != null && s.x === t.x && s.y === t.y;
+  }
+  path() {
+    return new j(this.arr.slice(0, this.count));
+  }
+  clear() {
+    this.set.clear(), this.count = 0;
+  }
+  get(t) {
+    return this.arr[t];
+  }
+  get length() {
+    return this.count;
+  }
+}
+const L = 0, Y = 1, D = 2, H = 3;
+function Nt(i, t) {
+  const s = (Math.floor(i.width) + Math.floor(i.height)) * 2, e = new Tt(s);
+  function r(a, c, l, f) {
+    const u = i.get(a, c);
+    return Number.isNaN(u) ? Number.NaN : u > t ? l + f : l;
+  }
+  function n(a, c) {
+    let l = L;
+    return l = r(a, c, l, 1), l = r(a + 1, c, l, 2), l = r(a, c + 1, l, 4), l = r(a + 1, c + 1, l, 8), Number.isNaN(l) ? -1 : l;
+  }
+  let h = Y;
+  function o(a, c) {
+    let l = a, f = c, u = i.invertScaleX(l), x = i.invertScaleY(f);
+    for (let p = 0; p < i.width * i.height; p++) {
+      const E = { x: u, y: x };
+      if (e.contains(E)) {
+        if (e.isFirst(E)) return !0;
+      } else
+        e.add(E);
+      const R = n(l, f);
+      switch (R) {
+        case -1:
+          return !0;
+        case 0:
+        case 3:
+        case 2:
+        case 7:
+          h = D;
+          break;
+        case 12:
+        case 14:
+        case 4:
+          h = H;
+          break;
+        case 6:
+          h = h === L ? H : D;
+          break;
+        case 1:
+        case 13:
+        case 5:
+          h = L;
+          break;
+        case 9:
+          h = h === D ? L : Y;
+          break;
+        case 10:
+        case 8:
+        case 11:
+          h = Y;
+          break;
+        default:
+          return console.warn("Marching squares invalid state: " + R), !0;
+      }
+      switch (h) {
+        case L:
+          f--, x -= i.pixelGroup;
+          break;
+        case Y:
+          f++, x += i.pixelGroup;
+          break;
+        case H:
+          l--, u -= i.pixelGroup;
+          break;
+        case D:
+          l++, u += i.pixelGroup;
+          break;
+        default:
+          return console.warn("Marching squares invalid state: " + R), !0;
+      }
+    }
+    return !0;
+  }
+  for (let a = 0; a < i.width; a++)
+    for (let c = 0; c < i.height; c++) {
+      if (i.get(a, c) <= t)
+        continue;
+      const l = n(a, c);
+      if (!(l < 0 || l === 15) && o(a, c))
+        return e.path();
+    }
+  return null;
+}
+const it = {
+  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: !0
+};
+function G(i) {
+  return i != null && typeof i.radius == "number";
+}
+function Z(i, t) {
+  if (G(i) !== G(t))
+    return !1;
+  if (G(i)) {
+    const e = t;
+    return i.cx === e.cx && i.cy === e.cy && i.radius === e.radius;
+  }
+  const s = t;
+  return i.x === s.x && i.y === s.y && i.width === s.width && i.height === s.height;
+}
+var v;
+(function(i) {
+  i[i.MEMBERS = 0] = "MEMBERS", i[i.NON_MEMBERS = 1] = "NON_MEMBERS", i[i.EDGES = 2] = "EDGES";
+})(v || (v = {}));
+let vt = class {
+  constructor(t = {}) {
+    this.dirty = /* @__PURE__ */ new Set(), this.members = [], this.nonMembers = [], this.virtualEdges = [], this.edges = [], this.activeRegion = new N(0, 0, 0, 0), this.potentialArea = new m(1, 0, 0, 0, 0, 0, 0), this.o = Object.assign({}, it, t);
+  }
+  pushMember(...t) {
+    if (t.length !== 0) {
+      this.dirty.add(v.MEMBERS);
+      for (const s of t)
+        this.members.push({
+          raw: s,
+          obj: G(s) ? X.from(s) : N.from(s),
+          area: null
+        });
+    }
+  }
+  removeMember(t) {
+    const s = this.members.findIndex((e) => Z(e.raw, t));
+    return s < 0 ? !1 : (this.members.splice(s, 1), this.dirty.add(v.MEMBERS), !0);
+  }
+  removeNonMember(t) {
+    const s = this.nonMembers.findIndex((e) => Z(e.raw, t));
+    return s < 0 ? !1 : (this.nonMembers.splice(s, 1), this.dirty.add(v.NON_MEMBERS), !0);
+  }
+  removeEdge(t) {
+    const s = this.edges.findIndex((e) => e.obj.equals(t));
+    return s < 0 ? !1 : (this.edges.splice(s, 1), this.dirty.add(v.NON_MEMBERS), !0);
+  }
+  pushNonMember(...t) {
+    if (t.length !== 0) {
+      this.dirty.add(v.NON_MEMBERS);
+      for (const s of t)
+        this.nonMembers.push({
+          raw: s,
+          obj: G(s) ? X.from(s) : N.from(s),
+          area: null
+        });
+    }
+  }
+  pushEdge(...t) {
+    if (t.length !== 0) {
+      this.dirty.add(v.EDGES);
+      for (const s of t)
+        this.edges.push({
+          raw: s,
+          obj: T.from(s),
+          area: null
+        });
+    }
+  }
+  update() {
+    const t = this.dirty.has(v.MEMBERS), s = this.dirty.has(v.NON_MEMBERS);
+    let e = this.dirty.has(v.EDGES);
+    this.dirty.clear();
+    const r = this.members.map((c) => c.obj);
+    if (this.o.virtualEdges && (t || s)) {
+      const c = this.nonMembers.map((u) => u.obj), l = lt(r, c, this.o.maxRoutingIterations, this.o.morphBuffer), f = new Map(this.virtualEdges.map((u) => [u.obj.toString(), u.area]));
+      this.virtualEdges = l.map((u) => {
+        var x;
+        return {
+          raw: u,
+          obj: u,
+          area: (x = f.get(u.toString())) !== null && x !== void 0 ? x : null
+        };
+      }), e = !0;
+    }
+    let n = !1;
+    if (t || e) {
+      const c = this.virtualEdges.concat(this.edges).map((x) => x.obj), l = St(r, c), f = Math.max(this.o.edgeR1, this.o.nodeR1) + this.o.morphBuffer, u = N.from(U(l, f));
+      u.equals(this.activeRegion) || (n = !0, this.activeRegion = u);
+    }
+    if (n) {
+      const c = Math.ceil(this.activeRegion.width / this.o.pixelGroup), l = Math.ceil(this.activeRegion.height / this.o.pixelGroup);
+      this.activeRegion.x !== this.potentialArea.pixelX || this.activeRegion.y !== this.potentialArea.pixelY ? (this.potentialArea = m.fromPixelRegion(this.activeRegion, this.o.pixelGroup), this.members.forEach((f) => f.area = null), this.nonMembers.forEach((f) => f.area = null), this.edges.forEach((f) => f.area = null), this.virtualEdges.forEach((f) => f.area = null)) : (c !== this.potentialArea.width || l !== this.potentialArea.height) && (this.potentialArea = m.fromPixelRegion(this.activeRegion, this.o.pixelGroup));
+    }
+    const h = /* @__PURE__ */ new Map(), o = (c) => {
+      if (c.area) {
+        const l = `${c.obj.width}x${c.obj.height}x${c.obj instanceof N ? "R" : "C"}`;
+        h.set(l, c.area);
+      }
+    }, a = (c) => {
+      if (c.area)
+        return;
+      const l = `${c.obj.width}x${c.obj.height}x${c.obj instanceof N ? "R" : "C"}`;
+      if (h.has(l)) {
+        const u = h.get(l);
+        c.area = this.potentialArea.copy(u, { x: c.obj.x - this.o.nodeR1, y: c.obj.y - this.o.nodeR1 });
+        return;
+      }
+      const f = c.obj instanceof N ? at(c.obj, this.potentialArea, this.o.nodeR1) : B(c.obj, this.potentialArea, this.o.nodeR1);
+      c.area = f, h.set(l, f);
+    };
+    this.members.forEach(o), this.nonMembers.forEach(o), this.members.forEach(a), this.nonMembers.forEach((c) => {
+      this.activeRegion.intersects(c.obj) ? a(c) : c.area = null;
+    }), this.edges.forEach((c) => {
+      c.area || (c.area = W(c.obj, this.potentialArea, this.o.edgeR1));
+    }), this.virtualEdges.forEach((c) => {
+      c.area || (c.area = W(c.obj, this.potentialArea, this.o.edgeR1));
+    });
+  }
+  drawMembers(t) {
+    for (const s of this.members)
+      s.obj.draw(t);
+  }
+  drawNonMembers(t) {
+    for (const s of this.nonMembers)
+      s.obj.draw(t);
+  }
+  drawEdges(t) {
+    for (const s of this.edges)
+      s.obj.draw(t);
+  }
+  drawPotentialArea(t, s = !0) {
+    this.potentialArea.draw(t, s);
+  }
+  compute() {
+    if (this.members.length === 0)
+      return new j([]);
+    this.dirty.size > 0 && this.update();
+    const { o: t, potentialArea: s } = this, e = this.members.map((o) => o.area), r = this.virtualEdges.concat(this.edges).map((o) => o.area), n = this.nonMembers.filter((o) => o.area != null).map((o) => o.area), h = this.members.map((o) => o.obj);
+    return Rt(s, e, r, n, (o) => o.containsElements(h), t);
+  }
+};
+function Rt(i, t, s, e, r, n = {}) {
+  const h = Object.assign({}, it, n);
+  let o = h.threshold, a = h.memberInfluenceFactor, c = h.edgeInfluenceFactor, l = h.nonMemberInfluenceFactor;
+  const f = (h.nodeR0 - h.nodeR1) * (h.nodeR0 - h.nodeR1), u = (h.edgeR0 - h.edgeR1) * (h.edgeR0 - h.edgeR1);
+  for (let x = 0; x < h.maxMarchingIterations; x++) {
+    if (i.clear(), a !== 0) {
+      const E = a / f;
+      for (const R of t)
+        i.incArea(R, E);
+    }
+    if (c !== 0) {
+      const E = c / u;
+      for (const R of s)
+        i.incArea(R, E);
+    }
+    if (l !== 0) {
+      const E = l / f;
+      for (const R of e)
+        i.incArea(R, E);
+    }
+    const p = Nt(i, o);
+    if (p && r(p))
+      return p;
+    if (o *= 0.95, x <= h.maxMarchingIterations * 0.5)
+      a *= 1.2, c *= 1.2;
+    else if (l !== 0 && e.length > 0)
+      l *= 0.8;
+    else
+      break;
+  }
+  return new j([]);
+}
+function St(i, t) {
+  if (i.length === 0)
+    return new N(0, 0, 0, 0);
+  const s = N.from(i[0]);
+  for (const e of i)
+    s.add(e);
+  for (const e of t)
+    s.add(J(e));
+  return s;
+}
+export {
+  m as Area,
+  vt as BubbleSets,
+  X as Circle,
+  T as Line,
+  j as PointPath,
+  N as Rectangle,
+  U as addPadding,
+  ot as boundingBox,
+  Rt as calculatePotentialOutline,
+  lt as calculateVirtualEdges,
+  B as createGenericInfluenceArea,
+  W as createLineInfluenceArea,
+  at as createRectangleInfluenceArea,
+  vt as default,
+  it as defaultOptions,
+  J as lineBoundingBox,
+  g as point,
+  St as unionBoundingBox
+};
+//# sourceMappingURL=index.js.map