pantograph2d 0.7.0 → 0.8.1

package/dist/models-WQ-B7GSL.js

@@ -0,0 +1,1749 @@
+var tn = Object.defineProperty;
+var nn = (t, n, e) => n in t ? tn(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var C = (t, n, e) => nn(t, typeof n != "symbol" ? n + "" : n, e);
+import { i as k, o as en, f as Ot, a as q, s as V, n as sn, p as Tt, r as U, A as S, d as g, q as Lt, E as M, T as on, u as rn, Q as A, v as H, C as I, c as ln, w as cn, L as y, x as zt, y as lt, z as N, F as un, l as an, m as fn, G as dt, B as hn } from "./QuadraticBezier-BzVqiExF.js";
+function pn(t, n) {
+  const e = k(n, t.firstPoint), s = en(e, t.V) / t.squareLength;
+  return t.paramPoint(s);
+}
+function J(t, n, e) {
+  const s = e || t.precision, i = pn(t, n.center), o = Ot(i, n.center);
+  if (o > n.radius + s) return [];
+  if (Math.abs(o - n.radius) < s) {
+    const u = i;
+    return t.isOnSegment(u) && n.isOnSegment(u) ? [u] : [];
+  }
+  const r = [], l = Math.sqrt(
+    n.radius * n.radius - o * o
+  ), c = t.tangentAtFirstPoint, a = q(i, V(c, l));
+  t.isOnSegment(a) && n.isOnSegment(a) && r.push(a);
+  const f = q(i, V(c, -l));
+  return t.isOnSegment(f) && n.isOnSegment(f) && r.push(f), r;
+}
+const dn = (t) => {
+  const { firstPoint: n, lastPoint: e, center: s, clockwise: i } = t;
+  return new S(e, n, s, i, {
+    ignoreChecks: !0
+  });
+}, mn = (t, n) => {
+  if (t.isSame(n))
+    return [t];
+  const e = U(
+    [
+      n.isOnSegment(t.firstPoint) ? t.firstPoint : null,
+      n.isOnSegment(t.lastPoint) ? t.lastPoint : null,
+      t.isOnSegment(n.firstPoint) ? n.firstPoint : null,
+      t.isOnSegment(n.lastPoint) ? n.lastPoint : null
+    ].filter((s) => s !== null)
+    // We sort by the param value of the first arc. This means that the points
+    // will be sorted with the same orientation than arc1
+  ).sort((s, i) => t.pointToParam(s) - t.pointToParam(i));
+  if (e.length === 0) return [];
+  if (e.length === 1) return [];
+  if (e.length === 2)
+    return t.isSame(dn(n)) ? [] : [new S(e[0], e[1], t.center, t.clockwise)];
+  if (e.length === 3) {
+    const s = g(e[0], n.lastPoint) || g(e[0], n.firstPoint) ? 1 : 0;
+    return [
+      new S(
+        e[0 + s],
+        e[1 + s],
+        t.center,
+        t.clockwise
+      )
+    ];
+  } else if (e.length === 4)
+    return [
+      new S(e[0], e[1], t.center, t.clockwise),
+      new S(e[2], e[3], t.center, t.clockwise)
+    ];
+  throw new Error("Bug in the arc arc overlap algorithm");
+};
+function qt(t, n, e = !1, s) {
+  const i = s || t.precision, o = Ot(t.center, n.center), r = t.radius + n.radius;
+  if (o > r + i)
+    return [];
+  const l = Math.abs(t.radius - n.radius);
+  if (o < l - i)
+    return [];
+  if (o < i)
+    return l > i ? [] : e ? mn(t, n) : [];
+  const c = sn(k(n.center, t.center)), a = o > r - i;
+  if (
+    // circles are outside each other
+    a || // circles are inside each other
+    Math.abs(o - l) < i
+  ) {
+    const w = a || t.radius > n.radius ? 1 : -1, x = q(
+      t.center,
+      V(c, w * t.radius)
+    );
+    return t.isOnSegment(x) && n.isOnSegment(x) ? [x] : [];
+  }
+  const f = t.radius * t.radius / (2 * o) - n.radius * n.radius / (2 * o) + o / 2, u = q(
+    t.center,
+    V(c, f)
+  ), h = Math.sqrt(
+    t.radius * t.radius - f * f
+  ), p = Tt(c), d = q(u, V(p, h)), m = q(u, V(p, -h)), P = [];
+  return t.isOnSegment(d) && n.isOnSegment(d) && P.push(d), t.isOnSegment(m) && n.isOnSegment(m) && P.push(m), P;
+}
+function et(t, n, e = 1e-9) {
+  const s = t.transform(n.ellipseReferenceFrameTransform), i = s.slope, o = s.yIntercept, r = n.majorRadius * n.majorRadius, l = n.minorRadius * n.minorRadius, c = n.majorRadius * n.minorRadius, a = s.slope * s.slope, f = s.yIntercept * s.yIntercept, u = (w) => w.map(
+    (x) => n.reverseEllipseReferenceFrameTransform.transform(x)
+  ).filter((x) => t.isOnSegment(x) && n.isOnSegment(x));
+  if (!Number.isFinite(i)) {
+    const w = s.firstPoint[0];
+    if (Math.abs(w) - n.majorRadius > e) return [];
+    if (Math.abs(Math.abs(w) - n.majorRadius) < e)
+      return u([[w, 0]]);
+    const x = n.minorRadius * Math.sqrt(1 - w * w / r), F = [w, x], b = [w, -x];
+    return u([F, b]);
+  }
+  const h = r * a + l - f;
+  if (h < -e)
+    return [];
+  const p = r * a + l;
+  if (Math.abs(h) < e) {
+    const w = -(r * i * o) / p, x = l * o / p;
+    return u([[w, x]]);
+  }
+  const d = Math.sqrt(h), m = [
+    -(r * i * o + c * d) / p,
+    (l * o - c * i * d) / p
+  ], P = [
+    -(r * i * o - c * d) / p,
+    (l * o + c * i * d) / p
+  ];
+  return u([m, P]);
+}
+function Dt(t, n) {
+  const e = Math.max(t.precision, n.precision), s = t.coefficients, i = s.x2, o = s.xy, r = s.y2, l = s.x, c = s.y, a = s.c, f = n.coefficients, u = f.x2, h = f.xy, p = f.y2, d = f.x, m = f.y, P = f.c, w = {
+    z0: a * i * d * d + i * i * P * P - l * i * d * P + u * u * a * a - 2 * i * P * u * a - l * d * u * a + u * l * l * P,
+    z1: m * l * l * u - P * d * i * o - 2 * i * P * u * c - a * u * h * l + 2 * d * h * i * a + 2 * m * P * i * i + d * d * i * c - m * d * i * l - 2 * i * m * u * a - a * u * d * o + 2 * a * c * u * u - P * h * i * l - c * u * d * l + 2 * P * o * u * l,
+    z2: m * m * i * i + 2 * p * P * i * i - c * u * d * o + P * u * o * o - c * u * h * l - P * h * i * o - 2 * i * m * u * c + 2 * d * h * i * c - p * d * i * l - 2 * i * p * u * a + h * h * i * a + 2 * m * o * u * l + c * c * u * u - r * u * d * l - m * h * i * l + 2 * a * r * u * u - a * u * h * o + p * l * l * u + d * d * i * r - m * d * i * o - 2 * i * P * u * r,
+    z3: -2 * i * u * r * m + m * u * o * o + 2 * p * o * u * l - r * u * h * l + h * h * i * c - m * h * i * o - 2 * i * p * u * c - c * u * h * o - p * h * i * l + 2 * m * p * i * i + 2 * c * r * u * u - r * u * d * o + 2 * d * h * i * r - p * d * i * o,
+    z4: i * i * p * p - 2 * i * p * u * r + u * u * r * r - o * i * h * p - o * h * u * r + o * o * u * p + r * i * h * h
+  }, F = Lt(
+    [w.z0, w.z1, w.z2, w.z3, w.z4],
+    e
+  ).flatMap((b) => {
+    const R = i * h * b + i * d - u * o * b - u * l;
+    if (R)
+      return [[-(i * P + i * p * b * b - u * r * b * b + i * m * b - u * c * b - u * a) / R, b]];
+    const T = o * b + l, L = -T / (2 * i), j = r * b * b + c * b + a, z = T * T / (4 * i * i) - j / i;
+    if (Math.abs(z) < e)
+      return [[L, b]];
+    if (z > 0) {
+      const $ = Math.sqrt(z);
+      return [[L + $, b], [L - $, b]];
+    }
+    return [];
+  });
+  return U(F, e);
+}
+function mt(t, n) {
+  return Dt(t, n).filter((s) => t.isOnSegment(s) && n.isOnSegment(s));
+}
+const gn = (t) => {
+  const {
+    firstPoint: n,
+    lastPoint: e,
+    center: s,
+    majorRadius: i,
+    minorRadius: o,
+    tiltAngle: r,
+    clockwise: l
+  } = t;
+  return new M(
+    e,
+    n,
+    s,
+    i,
+    o,
+    r,
+    l,
+    {
+      ignoreChecks: !0,
+      angleUnits: "rad"
+    }
+  );
+}, Pn = (t, n) => {
+  if (t.isSame(n))
+    return [t];
+  const e = (i, o) => new M(
+    i,
+    o,
+    t.center,
+    t.majorRadius,
+    t.minorRadius,
+    t.tiltAngle,
+    t.clockwise,
+    { ignoreChecks: !0, angleUnits: "rad" }
+  ), s = U(
+    [
+      n.isOnSegment(t.firstPoint) ? t.firstPoint : null,
+      n.isOnSegment(t.lastPoint) ? t.lastPoint : null,
+      t.isOnSegment(n.firstPoint) ? n.firstPoint : null,
+      t.isOnSegment(n.lastPoint) ? n.lastPoint : null
+    ].filter((i) => i !== null)
+    // We sort by the param value of the first arc. This means that the points
+    // will be sorted with the same orientation than arc1
+  ).sort((i, o) => t.pointToParam(i) - t.pointToParam(o));
+  if (s.length === 0) return [];
+  if (s.length === 1) return [];
+  if (s.length === 2)
+    return t.isSame(gn(n)) ? [] : [e(s[0], s[1])];
+  if (s.length === 3) {
+    const i = g(s[0], n.lastPoint) || g(s[0], n.firstPoint) ? 1 : 0;
+    return [e(s[0 + i], s[1 + i])];
+  } else if (s.length === 4)
+    return [e(s[0], s[1]), e(s[2], s[3])];
+  throw new Error("Bug in the ellipse arc ellipse arc overlap algorithm");
+};
+function wn(t, n, e = !1) {
+  const s = Math.max(t.precision, n.precision);
+  return g(t.center, n.center) && Math.abs(t.majorRadius - n.majorRadius) < s && Math.abs(t.minorRadius - n.minorRadius) < s && (Math.abs(t.tiltAngle - n.tiltAngle) < s || Math.abs(Math.abs(t.tiltAngle - n.tiltAngle) - Math.PI) < s) ? e ? Pn(t, n) : [] : Dt(t, n).filter((r) => t.isOnSegment(r) && n.isOnSegment(r));
+}
+function gt(t, n) {
+  const [e, s] = t.firstPoint, [i, o] = t.lastPoint, r = new on().rotate(-Math.atan2(o - s, i - e)).translate(-e, -s), l = r.clone().inverse(), c = n.transform(r);
+  return c.paramsAtY(0).map((a) => c.paramPoint(a)).map((a) => l.transform(a)).filter((a) => t.isOnSegment(a));
+}
+const xn = (t, n = 1e-9) => {
+  let e = t;
+  return Math.abs(t) < n && (e = 0), e.toFixed(-Math.log10(n));
+};
+function Rt(t, n = 1e-9) {
+  return Array.from(
+    new Map(t.map((e) => [xn(e, n), e])).values()
+  );
+}
+const Sn = (t, n) => {
+  const [[e, s, i, o], [r, l, c, a]] = n.polynomialCoefficients, f = t.coefficients, u = f.x2, h = f.xy, p = f.y2, d = f.x, m = f.y, P = f.c, w = e * e, x = s * s, F = i * i, b = o * o, R = r * r, T = l * l, L = c * c, j = a * a, z = P + d * e + u * w + m * r + h * e * r + p * R, $ = d * s + 2 * u * e * s + h * s * r + m * l + h * e * l + 2 * p * r * l, Qt = u * x + d * i + 2 * u * e * i + h * i * r + h * s * l + p * T + m * c + h * e * c + 2 * p * r * c, Wt = 2 * u * s * i + d * o + 2 * u * e * o + h * o * r + h * i * l + h * s * c + 2 * p * l * c + m * a + h * e * a + 2 * p * r * a, Jt = u * F + 2 * u * s * o + h * o * l + h * i * c + p * L + h * s * a + 2 * p * l * a, Kt = 2 * u * i * o + h * o * c + h * i * a + 2 * p * c * a, Zt = u * b + h * o * a + p * j;
+  return [z, $, Qt, Wt, Jt, Kt, Zt];
+};
+function Pt(t, n) {
+  const e = Math.max(t.precision, n.precision), s = Sn(t, n), i = Lt(s, e).filter((o) => o >= -n.precision && o <= 1 + n.precision);
+  return Rt(i, e).map((o) => n.paramPoint(o)).filter((o) => t.isOnSegment(o));
+}
+const yn = (t, n) => {
+  const [[e, s, i], [o, r, l]] = n.polynomialCoefficients, c = t.coefficients, a = c.x2, f = c.xy, u = c.y2, h = c.x, p = c.y, d = c.c, m = e * e, P = s * s, w = i * i, x = o * o, F = r * r, b = l * l, R = a * m + f * e * o + u * x + h * e + p * o + d, T = 2 * a * e * s + f * e * r + f * s * o + 2 * u * o * r + h * s + p * r, L = 2 * a * e * i + a * P + f * e * l + f * s * r + f * i * o + 2 * u * o * l + u * F + h * i + p * l, j = 2 * a * s * i + f * s * l + f * i * r + 2 * u * r * l, z = a * w + f * i * l + u * b;
+  return [R, T, L, j, z];
+};
+function wt(t, n) {
+  const e = Math.max(t.precision, n.precision), s = yn(t, n), i = rn(...s).filter((o) => o >= -n.precision && o <= 1 + n.precision);
+  return Rt(i, e).map((o) => n.paramPoint(o)).filter((o) => t.isOnSegment(o));
+}
+function E(t, { firstPoint: n, lastPoint: e }, s = 1e-9) {
+  const i = k(e, n);
+  return Math.abs(i[0]) < s ? i[1] > 0 ? n[0] - t[0] : t[0] - n[0] : Math.abs(i[1]) < s ? i[0] > 0 ? t[1] - n[1] : n[1] - t[1] : ln(i, k(t, n)) / cn(i);
+}
+class ct {
+  constructor(n, e, s, i) {
+    this.firstPoint = n, this.lastPoint = e, this.negativeThickness = s, this.positiveThickness = i;
+  }
+  get width() {
+    return this.positiveThickness - this.negativeThickness;
+  }
+}
+const bn = 3 / 4, Cn = 4 / 9;
+function Mn(t) {
+  const n = E(t.firstControlPoint, t), e = E(t.lastControlPoint, t), s = n * e > 0 ? bn : Cn;
+  return new ct(
+    t.firstPoint,
+    t.lastPoint,
+    s * Math.min(0, n, e),
+    s * Math.max(0, n, e)
+  );
+}
+function An(t) {
+  const n = E(t.controlPoint, t);
+  return new ct(
+    t.firstPoint,
+    t.lastPoint,
+    Math.min(0, n / 2),
+    Math.max(0, n / 2)
+  );
+}
+function In(t) {
+  if (t instanceof I)
+    return Mn(t);
+  if (t instanceof A)
+    return An(t);
+  throw new Error("Not implemented");
+}
+function En(t) {
+  const n = t.paramPoint(0.5), e = Tt(k(n, t.firstPoint)), s = q(n, e), i = {
+    firstPoint: n,
+    lastPoint: s
+  }, o = [
+    E(t.firstPoint, i),
+    E(t.lastPoint, i)
+  ];
+  return t instanceof I ? o.push(
+    E(t.firstControlPoint, i),
+    E(t.lastControlPoint, i)
+  ) : t instanceof A && o.push(E(t.controlPoint, i)), new ct(
+    n,
+    s,
+    Math.min(...o),
+    Math.max(...o)
+  );
+}
+function xt(t, n) {
+  const e = [];
+  for (let s = 1; s < t.length; s++) {
+    const i = t[s];
+    if (i[1] === n) {
+      e.push(i[0]);
+      continue;
+    }
+    const o = t[s - 1], r = n - o[1], l = n - i[1];
+    if (r * l < 0) {
+      e.push(
+        o[0] + (n - o[1]) * (i[0] - o[0]) / (i[1] - o[1])
+      );
+      continue;
+    }
+  }
+  return e;
+}
+class Y {
+  constructor(n, e) {
+    this.from = n, this.to = e;
+  }
+  get size() {
+    return this.from === "start" ? this.to === "end" ? 1 : this.to : this.to === "end" ? 1 - this.from : Math.abs(this.from - this.to);
+  }
+  clipCurve(n) {
+    return this.from === "start" ? this.to === "end" ? n : n.splitAtParameters([this.to])[0] : this.to === "end" ? n.splitAtParameters([this.from])[1] : n.splitAtParameters([this.from, this.to])[1];
+  }
+}
+function Fn(t, n) {
+  if (t instanceof I)
+    return new Bn([
+      E(t.firstPoint, n),
+      E(t.firstControlPoint, n),
+      E(t.lastControlPoint, n),
+      E(t.lastPoint, n)
+    ]);
+  if (t instanceof A)
+    return new vn([
+      E(t.firstPoint, n),
+      E(t.controlPoint, n),
+      E(t.lastPoint, n)
+    ]);
+  throw new Error("Not implemented");
+}
+class vn {
+  constructor(n) {
+    C(this, "topHull", []);
+    C(this, "bottomHull", []);
+    this.distances = n;
+    const [e, s, i] = n, o = [0, e], r = [1 / 2, s], l = [1, i], c = i - e, a = e;
+    s - (c * (1 / 2) + a) > 0 ? (this.topHull = [o, r, l], this.bottomHull = [o, l]) : (this.topHull = [o, l], this.bottomHull = [o, r, l]);
+  }
+  get startDistance() {
+    return this.distances[0];
+  }
+  get endDistance() {
+    return this.distances[2];
+  }
+}
+class Bn {
+  constructor(n) {
+    C(this, "topHull", []);
+    C(this, "bottomHull", []);
+    this.distances = n;
+    const [e, s, i, o] = n, r = [0, e], l = [1 / 3, s], c = [2 / 3, i], a = [1, o], f = o - e, u = e, h = s - (f * (1 / 3) + u), p = i - (f * (2 / 3) + u);
+    let d = null, m = null;
+    if (h * p < 0)
+      d = [r, l, a], m = [r, c, a];
+    else {
+      const w = h / p;
+      w >= 2 ? (d = [r, l, a], m = [r, a]) : w <= 0.5 ? (d = [r, c, a], m = [r, a]) : (d = [r, l, c, a], m = [r, a]);
+    }
+    h < 0 && ([d, m] = [m, d]), this.topHull = d, this.bottomHull = m;
+  }
+  get startDistance() {
+    return this.distances[0];
+  }
+  get endDistance() {
+    return this.distances[3];
+  }
+}
+function St(t, n) {
+  const e = Fn(n, t), s = xt(
+    e.topHull,
+    t.negativeThickness
+  ), i = xt(
+    e.bottomHull,
+    t.positiveThickness
+  ), o = e.endDistance >= t.negativeThickness && e.endDistance <= t.positiveThickness;
+  if (!s.length && !i.length)
+    return o ? new Y("start", "end") : null;
+  if (s.length === 1 && i.length === 1)
+    return new Y(s[0], i[0]);
+  if (s.length === 2 && i.length === 2)
+    throw new Error(
+      "Bug in the clipping algorithm, unexpected number of crossing points"
+    );
+  const r = s.length ? s : i;
+  return r.length === 2 ? new Y(r[0], r[1]) : o ? new Y(r[0], "end") : new Y("start", r[0]);
+}
+function yt(t, n) {
+  const e = In(t), s = St(e, n);
+  if (!s)
+    return null;
+  const i = En(t), o = St(
+    i,
+    n
+  );
+  return o ? s.size > o.size ? o.clipCurve(n) : s.clipCurve(n) : null;
+}
+const W = (t) => t instanceof A ? H(k(t.controlPoint, t.firstPoint)) + H(k(t.controlPoint, t.lastPoint)) : H(k(t.firstControlPoint, t.firstPoint)) + H(k(t.lastControlPoint, t.firstControlPoint)) + H(k(t.lastControlPoint, t.lastPoint));
+function D(t, n, e = 1e-9, { maxIterations: s = 100 } = {}) {
+  const i = Math.max(e * e, Number.EPSILON * 10);
+  let o = t, r = n, l = W(o), c = W(r);
+  for (let a = 0; a < s; a++) {
+    const f = l > i ? yt(r, o) : o;
+    if (!f) return [];
+    const u = W(f), h = c > i ? yt(f, r) : r;
+    if (!h) return [];
+    const p = W(h);
+    if (u <= i && p <= i)
+      return [
+        f.boundingBox.intersection(h.boundingBox).center
+      ];
+    if (g(f.firstPoint, f.lastPoint) && h.isOnSegment(f.firstPoint))
+      return [f.firstPoint];
+    if (g(h.firstPoint, h.lastPoint) && f.isOnSegment(h.firstPoint))
+      return [h.firstPoint];
+    if (u > 0.8 * l && p > 0.8 * c)
+      if (u / l > p / c) {
+        const [d, m] = f.splitAtParameters([
+          0.5
+        ]);
+        return U(
+          [
+            ...D(d, h, e, {
+              maxIterations: s - a
+            }),
+            ...D(m, h, e, {
+              maxIterations: s - a
+            })
+          ],
+          e
+        );
+      } else {
+        const [d, m] = h.splitAtParameters([
+          0.5
+        ]);
+        return U(
+          [
+            ...D(f, d, e, {
+              maxIterations: s - a
+            }),
+            ...D(f, m, e, {
+              maxIterations: s - a
+            })
+          ],
+          e
+        );
+      }
+    o = f, r = h, l = u, c = p;
+  }
+  throw new Error("Bézier clip: Maximum number of iterations reached");
+}
+function kn(t, n) {
+  const e = [];
+  if ([
+    [t.firstPoint, n],
+    [t.lastPoint, n],
+    [n.firstPoint, t],
+    [n.lastPoint, t]
+  ].forEach(([i, o]) => {
+    o.isOnSegment(i) && e.push(i);
+  }), e.length < 2)
+    return null;
+  if (e.length === 2)
+    return [t.splitAt(e)[1]];
+  if (e.length === 3)
+    return g(e[0], t.firstPoint) && g(e[1], t.lastPoint) ? [t] : [n];
+  if (e.length === 4)
+    return [t];
+}
+function _n(t, n, e = !1) {
+  const s = Math.max(t.precision, n.precision);
+  if (e) {
+    const i = kn(t, n);
+    if (i)
+      return i;
+  }
+  return D(t, n, s);
+}
+function On(t, n) {
+  const e = [];
+  if ([
+    [t.firstPoint, n],
+    [t.lastPoint, n],
+    [n.firstPoint, t],
+    [n.lastPoint, t]
+  ].forEach(([i, o]) => {
+    o.isOnSegment(i) && e.push(i);
+  }), e.length < 2)
+    return null;
+  if (e.length === 2)
+    return [t.splitAt(e)[1]];
+  if (e.length === 3)
+    return g(e[0], t.firstPoint) && g(e[1], t.lastPoint) ? [t] : [n];
+  if (e.length === 4)
+    return [t];
+}
+function Tn(t, n, e = !1) {
+  const s = Math.max(t.precision, n.precision);
+  if (e) {
+    const i = On(t, n);
+    if (i)
+      return i;
+  }
+  return D(t, n, s);
+}
+function ae(t, n, e) {
+  if (t instanceof y && n instanceof y) {
+    const s = zt(
+      t,
+      n,
+      !1,
+      e
+    );
+    return s === null ? [] : [s];
+  }
+  if (t instanceof y && n instanceof S)
+    return J(t, n, e);
+  if (t instanceof S && n instanceof y)
+    return J(n, t, e);
+  if (t instanceof S && n instanceof S)
+    return qt(t, n, !1, e);
+  throw new Error("Not implemented");
+}
+function K(t, n, e) {
+  if (t instanceof y && n instanceof y) {
+    const s = zt(
+      t,
+      n,
+      !0,
+      e
+    );
+    return s === null ? { intersections: [], overlaps: [], count: 0 } : s instanceof y ? { intersections: [], overlaps: [s], count: 1 } : { intersections: [s], overlaps: [], count: 1 };
+  }
+  if (!t.boundingBox.overlaps(n.boundingBox))
+    return { intersections: [], overlaps: [], count: 0 };
+  if (t instanceof y && n instanceof S) {
+    const s = J(t, n, e);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if (t instanceof S && n instanceof y) {
+    const s = J(n, t, e);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if (t instanceof S && n instanceof S) {
+    const s = qt(
+      t,
+      n,
+      !0,
+      e
+    );
+    return s.length ? s[0] instanceof S ? {
+      intersections: [],
+      overlaps: s,
+      count: s.length
+    } : {
+      intersections: s,
+      overlaps: [],
+      count: s.length
+    } : { intersections: [], overlaps: [], count: 0 };
+  }
+  if (t instanceof y && n instanceof M) {
+    const s = et(
+      t,
+      n,
+      e
+    );
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if (n instanceof y && t instanceof M) {
+    const s = et(
+      n,
+      t,
+      e
+    );
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if (t instanceof S && n instanceof M) {
+    const s = mt(t, n);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if (n instanceof S && t instanceof M) {
+    const s = mt(n, t);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if (t instanceof M && n instanceof M) {
+    const s = wn(
+      t,
+      n,
+      !0
+    );
+    return s.length ? s[0] instanceof M ? {
+      intersections: [],
+      overlaps: s,
+      count: s.length
+    } : {
+      intersections: s,
+      overlaps: [],
+      count: s.length
+    } : { intersections: [], overlaps: [], count: 0 };
+  }
+  if (t instanceof y && (n instanceof I || n instanceof A)) {
+    const s = gt(t, n);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if (n instanceof y && (t instanceof I || t instanceof A)) {
+    const s = gt(n, t);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if ((t instanceof S || t instanceof M) && n instanceof A) {
+    const s = wt(t, n);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if ((n instanceof S || n instanceof M) && t instanceof A) {
+    const s = wt(n, t);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if ((t instanceof S || t instanceof M) && n instanceof I) {
+    const s = Pt(t, n);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if ((n instanceof S || n instanceof M) && t instanceof I) {
+    const s = Pt(n, t);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if (t instanceof A && n instanceof A) {
+    const s = Tn(
+      t,
+      n
+    );
+    return s.length ? s[0] instanceof A ? {
+      intersections: [],
+      overlaps: s,
+      count: s.length
+    } : {
+      intersections: s,
+      overlaps: [],
+      count: s.length
+    } : { intersections: [], overlaps: [], count: 0 };
+  }
+  if (t instanceof A && n instanceof I || n instanceof A && t instanceof I) {
+    const s = D(t, n);
+    return { intersections: s, overlaps: [], count: s.length };
+  }
+  if (t instanceof I && n instanceof I) {
+    const s = _n(
+      t,
+      n
+    );
+    return s.length ? s[0] instanceof I ? {
+      intersections: [],
+      overlaps: s,
+      count: s.length
+    } : {
+      intersections: s,
+      overlaps: [],
+      count: s.length
+    } : { intersections: [], overlaps: [], count: 0 };
+  }
+  throw new Error("Not implemented");
+}
+function Vt(t) {
+  const n = [];
+  for (let e = 0; e < t; e++)
+    for (let s = 0; s <= e; s++)
+      n.push([e, s]);
+  return n;
+}
+function* st(t) {
+  for (const [n, e] of Vt(t.length))
+    n !== e && (yield [t[n], t[e]]);
+}
+class Nt extends lt {
+  constructor(e, { ignoreChecks: s = !1 } = {}) {
+    super();
+    C(this, "segments");
+    C(this, "_boundingBox", null);
+    s || Ut(e), this.segments = e;
+  }
+  get repr() {
+    return this.segments.map((e) => e.repr).join(`
+`) + `
+`;
+  }
+  get info() {
+    return this.repr;
+  }
+  get firstPoint() {
+    return this.segments[0].firstPoint;
+  }
+  get lastPoint() {
+    return this.segments[this.segments.length - 1].lastPoint;
+  }
+  get segmentsCount() {
+    return this.segments.length;
+  }
+  onStroke(e) {
+    return this.segments.some((s) => s.isOnSegment(e));
+  }
+  intersects(e) {
+    return this.boundingBox.overlaps(e.boundingBox) ? this.segments.some(
+      (s) => e.segments.some(
+        (i) => K(s, i).count > 0
+      )
+    ) : !1;
+  }
+  overlappingSegments(e) {
+    return this.segments.flatMap((s) => e.segments.flatMap((i) => s.boundingBox.overlaps(i.boundingBox) ? K(s, i).overlaps : []));
+  }
+  get boundingBox() {
+    if (this._boundingBox === null) {
+      let e = this.segments[0].boundingBox;
+      this.segments.slice(1).forEach((s) => {
+        e = e.merge(s.boundingBox);
+      }), this._boundingBox = e;
+    }
+    return this._boundingBox;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.repr;
+  }
+}
+function Ln(t, n = "Stroke") {
+  Vt(t.length).forEach(
+    ([e, s]) => {
+      if (e === s) return;
+      const i = t[e], o = t[s], r = K(i, o), l = Math.max(i.precision, o.precision);
+      if (r.count !== 0) {
+        if (r.count === 1 && !r.overlaps.length) {
+          const c = e - s, a = r.intersections[0];
+          if (c === 1 && g(i.firstPoint, a, l) || c === -1 && g(i.lastPoint, a, l) || c === t.length - 1 && g(i.lastPoint, a, l) && g(o.firstPoint, a, l) || -c === t.length - 1 && g(i.firstPoint, a, l) && g(o.lastPoint, a, l))
+            return;
+        }
+        if (!(r.count === 2 && t.length === 2 && (g(
+          i.firstPoint,
+          r.intersections[0],
+          l
+        ) && g(
+          i.lastPoint,
+          r.intersections[1],
+          l
+        ) || g(
+          i.firstPoint,
+          r.intersections[1],
+          l
+        ) && g(
+          i.lastPoint,
+          r.intersections[0],
+          l
+        ))))
+          throw new Error(
+            `${n} segments must not intersect, but segments ${i.info} and ${o.info} do at ${JSON.stringify(
+              r.intersections
+            )}`
+          );
+      }
+    }
+  );
+}
+function Ut(t, n = "Stroke") {
+  if (t.length === 0)
+    throw new Error(`${n} must have at least one segment`);
+  N([t.slice(0, -1), t.slice(1)]).forEach(
+    ([e, s]) => {
+      if (!g(e.lastPoint, s.firstPoint))
+        throw new Error(
+          `${n} segments must be connected, but ${e.info} and ${s.info} are not`
+        );
+    }
+  ), Ln(t, n);
+}
+function bt(t, n) {
+  return !!(t instanceof y && n instanceof y && un(t.V, n.V) || t instanceof S && n instanceof S && g(t.center, n.center) && t.radius - n.radius < t.precision);
+}
+function Ct(t, n) {
+  if (t instanceof y && n instanceof y)
+    return new y(t.firstPoint, n.lastPoint);
+  if (t instanceof S && n instanceof S)
+    return new S(
+      t.firstPoint,
+      n.lastPoint,
+      t.center,
+      t.clockwise
+    );
+  throw new Error("Not implemented");
+}
+function jt(t) {
+  let n = !1;
+  const e = [];
+  for (const s of t.segments) {
+    if (e.length === 0) {
+      e.push(s);
+      continue;
+    }
+    const i = e[e.length - 1];
+    bt(i, s) ? (n = !0, e.pop(), e.push(Ct(i, s))) : e.push(s);
+  }
+  if (g(t.firstPoint, t.lastPoint) && bt(
+    e[0],
+    e[e.length - 1]
+  )) {
+    n = !0;
+    const s = e.pop();
+    e[0] = Ct(s, e[0]);
+  }
+  return n ? e : null;
+}
+class B extends Nt {
+  constructor() {
+    super(...arguments);
+    C(this, "strokeType", "STRAND");
+  }
+  reverse() {
+    const e = this.segments.map((s) => s.reverse());
+    return e.reverse(), new B(e, { ignoreChecks: !0 });
+  }
+  clone() {
+    return new B(
+      this.segments.map((e) => e.clone()),
+      { ignoreChecks: !0 }
+    );
+  }
+  extend(e) {
+    if (!g(this.lastPoint, e.firstPoint))
+      throw console.error(this.repr, e.repr), new Error("Cannot extend strand: connection point is not the same");
+    return new B([...this.segments, ...e.segments]);
+  }
+  simplify() {
+    const e = jt(this);
+    return e ? new B(e, { ignoreChecks: !0 }) : this;
+  }
+  transform(e) {
+    return new B(
+      this.segments.map((s) => s.transform(e)),
+      { ignoreChecks: !0 }
+    );
+  }
+}
+const zn = (t, n) => {
+  const e = an(n, {
+    V: [1, 0],
+    firstPoint: t,
+    precision: n.precision
+  });
+  if (e === "parallel")
+    return 0;
+  const { intersectionParam1: s, intersectionParam2: i } = e;
+  if (!n.isValidParameter(s) || i <= -n.precision) return 0;
+  if (Math.abs(s) < n.precision || Math.abs(s - 1) < n.precision) {
+    const [, o] = n.midPoint;
+    return t[1] - o < 0 ? 1 : 0;
+  }
+  return 1;
+};
+class ut {
+  constructor(n) {
+    C(this, "_count", 0);
+    C(this, "segment");
+    this.segment = n;
+  }
+  update(n, e = !1) {
+    !e && !this.segment.isOnSegment(n) || (g(n, this.segment.firstPoint) ? this._count += this.segment.tangentAtFirstPoint[1] > 0 ? 1 : 0 : g(n, this.segment.lastPoint) ? this._count += this.segment.tangentAtLastPoint[1] > 0 ? 0 : 1 : this._count += 1);
+  }
+  get count() {
+    return this._count;
+  }
+}
+const qn = (t, n) => {
+  const e = n.precision, s = Math.abs(t[1] - n.center[1]);
+  if (s > n.radius + e) return 0;
+  const i = fn(t, n.center), o = n.radius * n.radius, r = e * e;
+  if (Math.abs(i - o) < r && n.isOnSegment(t))
+    return 0;
+  const l = i - o > r;
+  if (l && n.center[0] < t[0]) return 0;
+  const c = Math.sqrt(
+    n.radius * n.radius - s * s
+  ), a = new ut(n);
+  return a.update([n.center[0] + c, t[1]]), l && a.update([n.center[0] - c, t[1]]), a.count;
+}, Dn = (t, n) => {
+  const e = n.boundingBox.xMax + n.boundingBox.width / 2, s = new y(t, [e, t[1]]), i = new ut(n);
+  return et(s, n).forEach((o) => {
+    i.update(o, !0);
+  }), i.count;
+}, Rn = (t, n) => {
+  const e = new ut(n);
+  return n.paramsAtY(t[1]).map((s) => {
+    try {
+      return n.paramPoint(s);
+    } catch {
+      return null;
+    }
+  }).filter((s) => s !== null).filter((s) => {
+    const [i] = s;
+    return i >= t[0];
+  }).forEach((s) => {
+    e.update(s, !0);
+  }), e.count;
+};
+function Vn(t, n) {
+  if (n instanceof y)
+    return zn(t, n);
+  if (n instanceof S)
+    return qn(t, n);
+  if (n instanceof M)
+    return Dn(t, n);
+  if (n instanceof I || n instanceof A)
+    return Rn(t, n);
+  throw new Error("Not implemented");
+}
+class O extends Nt {
+  constructor(e, { ignoreChecks: s = !1 } = {}) {
+    super(e, { ignoreChecks: !0 });
+    C(this, "strokeType", "LOOP");
+    C(this, "_clockwise", null);
+    s || Nn(e);
+  }
+  get clockwise() {
+    if (this._clockwise === null) {
+      const e = this.segments.flatMap((i) => i instanceof y ? [i.firstPoint] : [i.firstPoint, i.paramPoint(0.5)]), s = e.map((i, o) => {
+        const r = e[(o + 1) % e.length];
+        return (r[0] - i[0]) * (r[1] + i[1]);
+      }).reduce((i, o) => i + o, 0);
+      this._clockwise = s > 0;
+    }
+    return this._clockwise;
+  }
+  clone() {
+    return new O(
+      this.segments.map((e) => e.clone()),
+      { ignoreChecks: !0 }
+    );
+  }
+  reverse() {
+    const e = this.segments.map((s) => s.reverse());
+    return e.reverse(), new O(e, { ignoreChecks: !0 });
+  }
+  transform(e) {
+    return new O(
+      this.segments.map((s) => s.transform(e)),
+      { ignoreChecks: !0 }
+    );
+  }
+  contains(e) {
+    return this.onStroke(e) || !this.boundingBox.contains(e) ? !1 : this.segments.reduce((i, o) => i + Vn(e, o), 0) % 2 === 1;
+  }
+  simplify() {
+    const e = jt(this);
+    return e ? new O(e, { ignoreChecks: !0 }) : this;
+  }
+}
+function Nn(t) {
+  if (Ut(t, "Loop"), !g(t[0].firstPoint, t[t.length - 1].lastPoint))
+    throw new Error("Loop segment must be closed");
+}
+const Un = [
+  y,
+  S,
+  M,
+  A,
+  I
+];
+function jn(t) {
+  return Un.some((n) => t instanceof n);
+}
+function $t(t) {
+  if (t instanceof y)
+    return {
+      type: t.segmentType,
+      firstPoint: t.firstPoint,
+      lastPoint: t.lastPoint
+    };
+  if (t instanceof S)
+    return {
+      type: t.segmentType,
+      firstPoint: t.firstPoint,
+      lastPoint: t.lastPoint,
+      center: t.center,
+      clockwise: t.clockwise
+    };
+  if (t instanceof M)
+    return {
+      type: t.segmentType,
+      firstPoint: t.firstPoint,
+      lastPoint: t.lastPoint,
+      center: t.center,
+      clockwise: t.clockwise,
+      majorRadius: t.majorRadius,
+      minorRadius: t.minorRadius,
+      tiltAngle: t.tiltAngle
+    };
+  if (t instanceof A)
+    return {
+      type: t.segmentType,
+      firstPoint: t.firstPoint,
+      lastPoint: t.lastPoint,
+      controlPoint: t.controlPoint
+    };
+  if (t instanceof I)
+    return {
+      type: t.segmentType,
+      firstPoint: t.firstPoint,
+      lastPoint: t.lastPoint,
+      firstControlPoint: t.firstControlPoint,
+      lastControlPoint: t.lastControlPoint
+    };
+  throw new Error("Unknown segment type");
+}
+function it(t) {
+  return {
+    type: "LOOP",
+    segments: t.segments.map($t)
+  };
+}
+function Ht(t) {
+  return {
+    type: "FIGURE",
+    contour: it(t.contour),
+    holes: t.holes.map(it)
+  };
+}
+function $n(t) {
+  return {
+    type: "DIAGRAM",
+    figures: t.figures.map(Ht)
+  };
+}
+function Mt(t) {
+  if (t instanceof _)
+    return $n(t);
+  if (t instanceof v)
+    return Ht(t);
+  if (t instanceof O)
+    return it(t);
+  if (jn(t))
+    return $t(t);
+  throw new Error("Unknown shape type");
+}
+class Hn {
+  constructor() {
+    this.ids = [], this.values = [], this.length = 0;
+  }
+  clear() {
+    this.length = 0;
+  }
+  push(n, e) {
+    let s = this.length++;
+    for (; s > 0; ) {
+      const i = s - 1 >> 1, o = this.values[i];
+      if (e >= o) break;
+      this.ids[s] = this.ids[i], this.values[s] = o, s = i;
+    }
+    this.ids[s] = n, this.values[s] = e;
+  }
+  pop() {
+    if (this.length === 0) return;
+    const n = this.ids[0];
+    if (this.length--, this.length > 0) {
+      const e = this.ids[0] = this.ids[this.length], s = this.values[0] = this.values[this.length], i = this.length >> 1;
+      let o = 0;
+      for (; o < i; ) {
+        let r = (o << 1) + 1;
+        const l = r + 1;
+        let c = this.ids[r], a = this.values[r];
+        const f = this.values[l];
+        if (l < this.length && f < a && (r = l, c = this.ids[l], a = f), a >= s) break;
+        this.ids[o] = c, this.values[o] = a, o = r;
+      }
+      this.ids[o] = e, this.values[o] = s;
+    }
+    return n;
+  }
+  peek() {
+    if (this.length !== 0)
+      return this.ids[0];
+  }
+  peekValue() {
+    if (this.length !== 0)
+      return this.values[0];
+  }
+  shrink() {
+    this.ids.length = this.values.length = this.length;
+  }
+}
+const At = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array], nt = 3;
+class at {
+  /**
+   * Recreate a Flatbush index from raw `ArrayBuffer` or `SharedArrayBuffer` data.
+   * @param {ArrayBuffer | SharedArrayBuffer} data
+   * @param {number} [byteOffset=0] byte offset to the start of the Flatbush buffer in the referenced ArrayBuffer.
+   * @returns {Flatbush} index
+   */
+  static from(n, e = 0) {
+    if (e % 8 !== 0)
+      throw new Error("byteOffset must be 8-byte aligned.");
+    if (!n || n.byteLength === void 0 || n.buffer)
+      throw new Error("Data must be an instance of ArrayBuffer or SharedArrayBuffer.");
+    const [s, i] = new Uint8Array(n, e + 0, 2);
+    if (s !== 251)
+      throw new Error("Data does not appear to be in a Flatbush format.");
+    const o = i >> 4;
+    if (o !== nt)
+      throw new Error(`Got v${o} data when expected v${nt}.`);
+    const r = At[i & 15];
+    if (!r)
+      throw new Error("Unrecognized array type.");
+    const [l] = new Uint16Array(n, e + 2, 1), [c] = new Uint32Array(n, e + 4, 1);
+    return new at(c, l, r, void 0, n, e);
+  }
+  /**
+   * Create a Flatbush index that will hold a given number of items.
+   * @param {number} numItems
+   * @param {number} [nodeSize=16] Size of the tree node (16 by default).
+   * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+   * @param {ArrayBufferConstructor | SharedArrayBufferConstructor} [ArrayBufferType=ArrayBuffer] The array buffer type used to store data (`ArrayBuffer` by default).
+   * @param {ArrayBuffer | SharedArrayBuffer} [data] (Only used internally)
+   * @param {number} [byteOffset=0] (Only used internally)
+   */
+  constructor(n, e = 16, s = Float64Array, i = ArrayBuffer, o, r = 0) {
+    if (n === void 0) throw new Error("Missing required argument: numItems.");
+    if (isNaN(n) || n <= 0) throw new Error(`Unexpected numItems value: ${n}.`);
+    this.numItems = +n, this.nodeSize = Math.min(Math.max(+e, 2), 65535), this.byteOffset = r;
+    let l = n, c = l;
+    this._levelBounds = [l * 4];
+    do
+      l = Math.ceil(l / this.nodeSize), c += l, this._levelBounds.push(c * 4);
+    while (l !== 1);
+    this.ArrayType = s, this.IndexArrayType = c < 16384 ? Uint16Array : Uint32Array;
+    const a = At.indexOf(this.ArrayType), f = c * 4 * this.ArrayType.BYTES_PER_ELEMENT;
+    if (a < 0)
+      throw new Error(`Unexpected typed array class: ${s}.`);
+    o && o.byteLength !== void 0 && !o.buffer ? (this.data = o, this._boxes = new this.ArrayType(this.data, r + 8, c * 4), this._indices = new this.IndexArrayType(this.data, r + 8 + f, c), this._pos = c * 4, this.minX = this._boxes[this._pos - 4], this.minY = this._boxes[this._pos - 3], this.maxX = this._boxes[this._pos - 2], this.maxY = this._boxes[this._pos - 1]) : (this.data = new i(8 + f + c * this.IndexArrayType.BYTES_PER_ELEMENT), this._boxes = new this.ArrayType(this.data, 8, c * 4), this._indices = new this.IndexArrayType(this.data, 8 + f, c), this._pos = 0, this.minX = 1 / 0, this.minY = 1 / 0, this.maxX = -1 / 0, this.maxY = -1 / 0, new Uint8Array(this.data, 0, 2).set([251, (nt << 4) + a]), new Uint16Array(this.data, 2, 1)[0] = e, new Uint32Array(this.data, 4, 1)[0] = n), this._queue = new Hn();
+  }
+  /**
+   * Add a given rectangle to the index.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @returns {number} A zero-based, incremental number that represents the newly added rectangle.
+   */
+  add(n, e, s = n, i = e) {
+    const o = this._pos >> 2, r = this._boxes;
+    return this._indices[o] = o, r[this._pos++] = n, r[this._pos++] = e, r[this._pos++] = s, r[this._pos++] = i, n < this.minX && (this.minX = n), e < this.minY && (this.minY = e), s > this.maxX && (this.maxX = s), i > this.maxY && (this.maxY = i), o;
+  }
+  /** Perform indexing of the added rectangles. */
+  finish() {
+    if (this._pos >> 2 !== this.numItems)
+      throw new Error(`Added ${this._pos >> 2} items when expected ${this.numItems}.`);
+    const n = this._boxes;
+    if (this.numItems <= this.nodeSize) {
+      n[this._pos++] = this.minX, n[this._pos++] = this.minY, n[this._pos++] = this.maxX, n[this._pos++] = this.maxY;
+      return;
+    }
+    const e = this.maxX - this.minX || 1, s = this.maxY - this.minY || 1, i = new Uint32Array(this.numItems), o = 65535;
+    for (let r = 0, l = 0; r < this.numItems; r++) {
+      const c = n[l++], a = n[l++], f = n[l++], u = n[l++], h = Math.floor(o * ((c + f) / 2 - this.minX) / e), p = Math.floor(o * ((a + u) / 2 - this.minY) / s);
+      i[r] = Xn(h, p);
+    }
+    ot(i, n, this._indices, 0, this.numItems - 1, this.nodeSize);
+    for (let r = 0, l = 0; r < this._levelBounds.length - 1; r++) {
+      const c = this._levelBounds[r];
+      for (; l < c; ) {
+        const a = l;
+        let f = n[l++], u = n[l++], h = n[l++], p = n[l++];
+        for (let d = 1; d < this.nodeSize && l < c; d++)
+          f = Math.min(f, n[l++]), u = Math.min(u, n[l++]), h = Math.max(h, n[l++]), p = Math.max(p, n[l++]);
+        this._indices[this._pos >> 2] = a, n[this._pos++] = f, n[this._pos++] = u, n[this._pos++] = h, n[this._pos++] = p;
+      }
+    }
+  }
+  /**
+   * Search the index by a bounding box.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @param {(index: number) => boolean} [filterFn] An optional function for filtering the results.
+   * @returns {number[]} An array of indices of items intersecting or touching the given bounding box.
+   */
+  search(n, e, s, i, o) {
+    if (this._pos !== this._boxes.length)
+      throw new Error("Data not yet indexed - call index.finish().");
+    let r = this._boxes.length - 4;
+    const l = [], c = [];
+    for (; r !== void 0; ) {
+      const a = Math.min(r + this.nodeSize * 4, Et(r, this._levelBounds));
+      for (let f = r; f < a; f += 4) {
+        if (s < this._boxes[f] || i < this._boxes[f + 1] || n > this._boxes[f + 2] || e > this._boxes[f + 3]) continue;
+        const u = this._indices[f >> 2] | 0;
+        r >= this.numItems * 4 ? l.push(u) : (o === void 0 || o(u)) && c.push(u);
+      }
+      r = l.pop();
+    }
+    return c;
+  }
+  /**
+   * Search items in order of distance from the given point.
+   * @param {number} x
+   * @param {number} y
+   * @param {number} [maxResults=Infinity]
+   * @param {number} [maxDistance=Infinity]
+   * @param {(index: number) => boolean} [filterFn] An optional function for filtering the results.
+   * @returns {number[]} An array of indices of items found.
+   */
+  neighbors(n, e, s = 1 / 0, i = 1 / 0, o) {
+    if (this._pos !== this._boxes.length)
+      throw new Error("Data not yet indexed - call index.finish().");
+    let r = this._boxes.length - 4;
+    const l = this._queue, c = [], a = i * i;
+    t: for (; r !== void 0; ) {
+      const f = Math.min(r + this.nodeSize * 4, Et(r, this._levelBounds));
+      for (let u = r; u < f; u += 4) {
+        const h = this._indices[u >> 2] | 0, p = It(n, this._boxes[u], this._boxes[u + 2]), d = It(e, this._boxes[u + 1], this._boxes[u + 3]), m = p * p + d * d;
+        m > a || (r >= this.numItems * 4 ? l.push(h << 1, m) : (o === void 0 || o(h)) && l.push((h << 1) + 1, m));
+      }
+      for (; l.length && l.peek() & 1; )
+        if (l.peekValue() > a || (c.push(l.pop() >> 1), c.length === s)) break t;
+      r = l.length ? l.pop() >> 1 : void 0;
+    }
+    return l.clear(), c;
+  }
+}
+function It(t, n, e) {
+  return t < n ? n - t : t <= e ? 0 : t - e;
+}
+function Et(t, n) {
+  let e = 0, s = n.length - 1;
+  for (; e < s; ) {
+    const i = e + s >> 1;
+    n[i] > t ? s = i : e = i + 1;
+  }
+  return n[e];
+}
+function ot(t, n, e, s, i, o) {
+  if (Math.floor(s / o) >= Math.floor(i / o)) return;
+  const r = t[s + i >> 1];
+  let l = s - 1, c = i + 1;
+  for (; ; ) {
+    do
+      l++;
+    while (t[l] < r);
+    do
+      c--;
+    while (t[c] > r);
+    if (l >= c) break;
+    Yn(t, n, e, l, c);
+  }
+  ot(t, n, e, s, c, o), ot(t, n, e, c + 1, i, o);
+}
+function Yn(t, n, e, s, i) {
+  const o = t[s];
+  t[s] = t[i], t[i] = o;
+  const r = 4 * s, l = 4 * i, c = n[r], a = n[r + 1], f = n[r + 2], u = n[r + 3];
+  n[r] = n[l], n[r + 1] = n[l + 1], n[r + 2] = n[l + 2], n[r + 3] = n[l + 3], n[l] = c, n[l + 1] = a, n[l + 2] = f, n[l + 3] = u;
+  const h = e[s];
+  e[s] = e[i], e[i] = h;
+}
+function Xn(t, n) {
+  let e = t ^ n, s = 65535 ^ e, i = 65535 ^ (t | n), o = t & (n ^ 65535), r = e | s >> 1, l = e >> 1 ^ e, c = i >> 1 ^ s & o >> 1 ^ i, a = e & i >> 1 ^ o >> 1 ^ o;
+  e = r, s = l, i = c, o = a, r = e & e >> 2 ^ s & s >> 2, l = e & s >> 2 ^ s & (e ^ s) >> 2, c ^= e & i >> 2 ^ s & o >> 2, a ^= s & i >> 2 ^ (e ^ s) & o >> 2, e = r, s = l, i = c, o = a, r = e & e >> 4 ^ s & s >> 4, l = e & s >> 4 ^ s & (e ^ s) >> 4, c ^= e & i >> 4 ^ s & o >> 4, a ^= s & i >> 4 ^ (e ^ s) & o >> 4, e = r, s = l, i = c, o = a, c ^= e & i >> 8 ^ s & o >> 8, a ^= s & i >> 8 ^ (e ^ s) & o >> 8, e = c ^ c >> 1, s = a ^ a >> 1;
+  let f = t ^ n, u = s | 65535 ^ (f | e);
+  return f = (f | f << 8) & 16711935, f = (f | f << 4) & 252645135, f = (f | f << 2) & 858993459, f = (f | f << 1) & 1431655765, u = (u | u << 8) & 16711935, u = (u | u << 4) & 252645135, u = (u | u << 2) & 858993459, u = (u | u << 1) & 1431655765, (u << 1 | f) >>> 0;
+}
+function Yt(t, n = 1e-7) {
+  if (t.length === 0) return [];
+  if (t.length === 1) return [t];
+  const e = new at(t.length);
+  t.forEach((o) => {
+    const [r, l] = o.firstPoint;
+    e.add(r - n, l - n, r + n, l + n);
+  }), e.finish();
+  const s = [], i = /* @__PURE__ */ new Set();
+  return t.forEach((o, r) => {
+    if (i.has(r)) return;
+    const l = [o];
+    let c = r;
+    i.add(r);
+    let a = t.length;
+    for (; ; ) {
+      if (a-- < 0)
+        throw new Error("Infinite loop detected");
+      const f = l[l.length - 1].lastPoint, [u, h] = f, p = e.search(
+        u - n,
+        h - n,
+        u + n,
+        h + n
+      ), d = (x) => Math.abs((c - x) % t.length), m = p.filter((x) => !i.has(x)).map((x) => [
+        t[x],
+        x,
+        d(x)
+      ]).sort(([, , x], [, , F]) => d(x) - d(F));
+      if (m.length === 0) {
+        s.push(l);
+        break;
+      }
+      const [P, w] = m[0];
+      l.push(P), i.add(w), c = w;
+    }
+  }), s;
+}
+class v extends lt {
+  constructor(e, s = [], { ignoreChecks: i = !1 } = {}) {
+    super();
+    C(this, "contour");
+    C(this, "holes");
+    i || Gn(e, s), this.contour = e, this.holes = s;
+  }
+  get boundingBox() {
+    return this.contour.boundingBox;
+  }
+  get isFull() {
+    return this.holes.length === 0;
+  }
+  get allLoops() {
+    return [this.contour, ...this.holes];
+  }
+  clone() {
+    return new v(
+      this.contour.clone(),
+      this.holes.map((e) => e.clone())
+    );
+  }
+  transform(e) {
+    return new v(
+      this.contour.transform(e),
+      this.holes.map((s) => s.transform(e))
+    );
+  }
+  contains(e) {
+    return this.contour.contains(e) && !this.holes.some((s) => s.contains(e));
+  }
+  intersects(e) {
+    return this.allLoops.some(
+      (s) => e.allLoops.some((i) => s.intersects(i))
+    );
+  }
+  overlappingStrands(e) {
+    const s = e instanceof v ? e.allLoops : [e], i = this.allLoops.flatMap((o) => s.flatMap((r) => o.overlappingSegments(r)));
+    return Yt(i).map((o) => new B(o));
+  }
+}
+function Gn(t, n = []) {
+  if (!t) throw new Error("Figure must have a contour");
+  for (const [e, s] of st([t, ...n]))
+    if (e.intersects(s))
+      throw new Error("Loops in a figure must not intersect");
+  if (n.some(
+    (e) => !t.contains(e.firstPoint) && !t.onStroke(e.firstPoint)
+  ))
+    throw new Error("Holes must be inside the contour");
+  for (const [e, s] of st(n))
+    if (e.contains(s.firstPoint))
+      throw console.error(Mt(e), Mt(s)), new Error("Holes must not be inside other holes");
+}
+const Qn = (t) => {
+  const n = t.map((i, o) => t.slice(o + 1).map((r, l) => [l + o + 1, r]).filter(([, r]) => i.boundingBox.overlaps(r.boundingBox)).map(([r]) => r)), e = [], s = Array(n.length);
+  return n.forEach((i, o) => {
+    let r = s[o];
+    r || (r = [], e.push(r)), r.push(t[o]), i.length && i.forEach((l) => {
+      s[l] = r;
+    });
+  }), e;
+}, Xt = (t) => t.map((n, e) => {
+  const i = n.segments[0].midPoint, o = t.filter((r, l) => e === l ? !1 : r.contains(i));
+  return {
+    loop: n,
+    isIn: o
+  };
+}), Wn = (t, n) => t.flatMap(({ loop: e }) => ft(
+  n.filter(
+    ({ loop: s, isIn: i }) => s === e || i.indexOf(e) !== -1
+  )
+)), Jn = (t, n) => {
+  const e = n.filter(({ isIn: i }) => i.length <= 1), s = ft(
+    Xt(t.map(({ loop: i }) => i))
+  );
+  return [e, ...s];
+}, ft = (t) => {
+  if (!t.length) return [];
+  const n = t.filter(({ isIn: s }) => !s.length), e = t.filter(({ isIn: s }) => s.length > 1);
+  return n.length === 1 && e.length === 0 ? [t] : n.length > 1 ? Wn(n, t) : Jn(e, t);
+};
+function X(t) {
+  return Qn(t).map(Xt).flatMap(ft).map((e) => {
+    if (e.length === 1) return new v(e[0].loop);
+    e.sort((o, r) => o.isIn.length - r.isIn.length);
+    const [s, ...i] = e.map(({ loop: o }) => o);
+    return new v(s, i);
+  });
+}
+function Kn(t, n) {
+  const e = [];
+  for (const s of t)
+    for (const i of n)
+      e.push([s, i]);
+  return e;
+}
+function* Ft(t, n, e) {
+  const s = (r) => n.some((l) => g(l, r.lastPoint)), i = (r) => e.some((l) => r.isSame(l));
+  let o = [];
+  for (const r of t)
+    s(r) ? (o.push(r), yield new B(o, { ignoreChecks: !0 }), o = []) : i(r) ? (o.length && (yield new B(o, { ignoreChecks: !0 }), o = []), yield new B([r], { ignoreChecks: !0 })) : o.push(r);
+  o.length && (yield new B(o, { ignoreChecks: !0 }));
+}
+const vt = (t, n) => {
+  const e = t.findIndex((o) => g(n, o.firstPoint)), s = t.slice(0, e);
+  return t.slice(e).concat(s);
+}, Bt = (t, n) => {
+  let e = t;
+  const s = (l) => g(l.firstPoint, n.firstPoint) && g(l.lastPoint, n.lastPoint);
+  let i = t.findIndex(s);
+  if (i === -1) {
+    const l = t.map((c) => c.reverse());
+    if (l.reverse(), i = l.findIndex(s), i === -1)
+      throw console.error(
+        l.map((c) => c.repr),
+        n.repr
+      ), new Error("Failed to rotate to segment start");
+    e = l;
+  }
+  const o = e.slice(0, i);
+  return e.slice(i).concat(o);
+};
+function Zn(t, n, e) {
+  return t.filter((s) => {
+    const i = n.filter((l) => g(l.firstPoint, s) || g(l.lastPoint, s));
+    if (i.length % 2)
+      throw new Error("Bug in the intersection algo on non crossing point");
+    const o = i.map((l) => e.contains(l.midPoint));
+    return !(o.every((l) => l) || !o.some((l) => l));
+  });
+}
+function te(t, n, e) {
+  let s = [];
+  const i = [], o = new Array(t.segments.length).fill(0).map(() => []), r = new Array(n.segments.length).fill(0).map(() => []);
+  if (t.segments.forEach((h, p) => {
+    n.segments.forEach((d, m) => {
+      const { intersections: P, overlaps: w } = K(
+        h,
+        d,
+        e
+      );
+      s.push(...P), o[p].push(...P), r[m].push(...P), i.push(...w);
+      const x = w.flatMap((F) => [
+        F.firstPoint,
+        F.lastPoint
+      ]);
+      s.push(...x), o[p].push(...x), r[m].push(...x);
+    });
+  }), s = U(s, e), !s.length || s.length === 1) return null;
+  const l = ([h, p]) => p.length ? h.splitAt(p) : [h];
+  let c = N([t.segments, o]).flatMap(l), a = N([n.segments, r]).flatMap(l);
+  if (s = Zn(
+    s,
+    c,
+    n
+  ), !s.length && !i.length) return null;
+  if (i.length) {
+    const h = i[0];
+    c = Bt(
+      c,
+      h
+    ), a = Bt(
+      a,
+      h
+    );
+  } else {
+    const h = s[0];
+    c = vt(c, h), a = vt(a, h);
+  }
+  let f = Array.from(
+    Ft(
+      c,
+      s,
+      i
+    )
+  ), u = Array.from(
+    Ft(
+      a,
+      s,
+      i
+    )
+  );
+  return (!g(
+    u[0].lastPoint,
+    f[0].lastPoint
+  ) || i.length > 0 && u[0].segmentsCount !== 1) && (u = u.map((h) => h.reverse()).reverse(), g(u[0].lastPoint, f[0].lastPoint) || (f = f.map((h) => h.reverse()).reverse())), N([f, u]).map(([h, p]) => h.segmentsCount === 1 && i.some((d) => h.segments[0].isSame(d)) ? [h, "same"] : [h, p]);
+}
+function kt(t) {
+  let n = t[0];
+  for (const e of t.slice(1))
+    n = n.extend(e);
+  if (!g(n.firstPoint, n.lastPoint))
+    throw console.error(
+      dt(n.firstPoint),
+      dt(n.lastPoint)
+    ), new Error("Bug in the intersection algo on non closing strand");
+  return new O(n.segments);
+}
+function ne(t, n) {
+  const e = N([
+    n.slice(0, -1),
+    n.slice(1)
+  ]).map(([i, o]) => kt(t.slice(i, o)));
+  let s = t.slice(
+    n[n.length - 1]
+  );
+  return n[0] !== 0 && (s = s.concat(t.slice(0, n[0]))), e.push(kt(s)), e;
+}
+function ee(t) {
+  if (!t.length) return [];
+  const n = t.map((i) => i.firstPoint);
+  let e = t.map((i) => i.lastPoint);
+  e = e.slice(-1).concat(e.slice(0, -1));
+  const s = N([n, e]).flatMap(
+    ([i, o], r) => g(i, o) ? [] : r
+  );
+  try {
+    return ne(t, s);
+  } catch {
+    return Yt(t.flatMap((o) => o.segments)).filter((o) => o.length > 1).filter((o) => g(o[0].firstPoint, o.at(-1).lastPoint)).map((o) => new O(o));
+  }
+}
+const _t = (t, n) => {
+  if (t.length === 0) return [n];
+  const e = t.at(-1);
+  return g(e.lastPoint, n.firstPoint) ? t.slice(0, -1).concat([e.extend(n)]) : g(e.lastPoint, n.lastPoint) ? t.slice(0, -1).concat([e.extend(n.reverse())]) : t.concat([n]);
+}, se = (t, n) => t.length === 0 ? [n] : g(t[0].firstPoint, n.lastPoint) ? [n.extend(t[0])].concat(t.slice(1)) : [n].concat(t);
+function ht(t, n, {
+  firstInside: e,
+  secondInside: s
+}) {
+  const i = te(t, n);
+  if (!i) {
+    const c = t.segments[0].midPoint, a = n.contains(c), f = n.segments[0].midPoint, u = t.contains(f);
+    return {
+      identical: !1,
+      firstCurveInSecond: a,
+      secondCurveInFirst: u
+    };
+  }
+  if (i.every(([, c]) => c === "same"))
+    return { identical: !0 };
+  let o = null, r = null;
+  const l = i.flatMap(([c, a]) => {
+    let f = [], u = 0;
+    if (a === "same")
+      return r === 1 ? (r = 1, c) : r === 2 || r === 0 ? (r = null, []) : r === null ? (o ? o = o.extend(c) : o = c, []) : (console.error("weird situation"), []);
+    const h = c.segments[0].midPoint, p = n.contains(h);
+    (e === "keep" && p || e === "remove" && !p) && (u += 1, f = _t(f, c));
+    const d = a.segments[0].midPoint, m = t.contains(d);
+    if (s === "keep" && m || s === "remove" && !m) {
+      const P = a;
+      u += 1, u === 2 && f.length ? (f = _t(f, P), o = null) : f = [P];
+    }
+    return r === null && u === 1 && o && (f = se(f, o)), u === 1 && (r = u, o = null), f.length ? f : (o = null, []);
+  });
+  return ee(l);
+}
+const ie = (t, n) => {
+  const e = ht(t, n, {
+    firstInside: "remove",
+    secondInside: "remove"
+  });
+  return Array.isArray(e) ? e : e.identical ? [t] : e.firstCurveInSecond ? [n] : e.secondCurveInFirst ? [t] : [t, n];
+}, Z = (t, n) => {
+  const e = ht(t, n, {
+    firstInside: "remove",
+    secondInside: "keep"
+  });
+  return Array.isArray(e) ? e : e.identical ? [] : e.firstCurveInSecond ? [] : e.secondCurveInFirst ? [t, n] : [t];
+}, pt = (t, n) => {
+  const e = ht(t, n, {
+    firstInside: "keep",
+    secondInside: "keep"
+  });
+  return Array.isArray(e) ? e : e.identical ? [t] : e.firstCurveInSecond ? [t] : e.secondCurveInFirst ? [n] : [];
+};
+function oe(t) {
+  const n = /* @__PURE__ */ new Map(), e = [];
+  return t.forEach((s, i) => {
+    let o;
+    n.has(i) ? o = n.get(i) : (o = { current: [s], fusedWith: /* @__PURE__ */ new Set([i]) }, e.push(o)), t.slice(i + 1).forEach((r, l) => {
+      const c = o.current, a = i + l + 1;
+      if (o.fusedWith.has(a)) return;
+      let f = [r], u = !1;
+      if (n.has(a) && (f = n.get(a).current, u = !0), !c.some(
+        (d) => f.some((m) => d.intersects(m))
+      )) return;
+      let p;
+      c.length > 1 || f.length > 1 ? p = G(c, f) : p = Gt(c[0], f[0]), o.fusedWith.add(a), o.current = p, u || n.set(a, o);
+    });
+  }), e.flatMap(({ current: s }) => s);
+}
+function Gt(t, n) {
+  const e = ie(t.contour, n.contour), s = n.holes.flatMap((r) => Z(r, t.contour)), i = t.holes.flatMap((r) => Z(r, n.contour)), o = Kn(t.holes, n.holes).flatMap(
+    ([r, l]) => pt(r, l)
+  );
+  return X([
+    ...e,
+    ...s,
+    ...i,
+    ...o
+  ]);
+}
+function tt(t, n) {
+  if (t.isFull && n.isFull)
+    return X(Z(t.contour, n.contour));
+  if (t.isFull) {
+    const s = Z(t.contour, n.contour), i = n.holes.flatMap(
+      (o) => pt(o, t.contour)
+    );
+    return X([...s, ...i]);
+  } else if (n.isFull && !t.contour.intersects(n.contour))
+    if (t.contour.contains(n.contour.firstPoint)) {
+      const s = G(
+        t.holes.map((i) => new v(i)),
+        [n]
+      );
+      return X([
+        t.contour,
+        ...s.flatMap((i) => i.allLoops)
+      ]);
+    } else
+      return [t];
+  let e = tt(new v(t.contour), n);
+  return t.holes.forEach((s) => {
+    e = e.flatMap((i) => tt(i, new v(s)));
+  }), e;
+}
+function re(t, n) {
+  const e = pt(t.contour, n.contour);
+  if (!e.length) return [];
+  let s = X(e);
+  return s = Q(
+    s,
+    t.holes.map((i) => new v(i))
+  ), Q(
+    s,
+    n.holes.map((i) => new v(i))
+  );
+}
+function G(t, n) {
+  if (!t.length) return n;
+  if (!n.length) return t;
+  if (t.length === 1 && n.length > 1 || n.length === 1 && t.length > 1)
+    return oe([...t, ...n]);
+  if (t.length > 1 && n.length > 1) {
+    let e = G([t[0]], n);
+    return t.slice(1).forEach((s) => {
+      e = G([s], e);
+    }), e;
+  }
+  return t.length === 1 && n.length === 1 ? Gt(t[0], n[0]) : [];
+}
+function Q(t, n) {
+  if (!t.length) return [];
+  if (!n.length) return t;
+  if (t.length === 1 && n.length === 1)
+    return tt(t[0], n[0]);
+  if (t.length > 1)
+    return t.flatMap((s) => Q([s], n));
+  let e = tt(t[0], n[0]);
+  return n.slice(1).forEach((s) => {
+    e = Q(e, [s]);
+  }), e;
+}
+function rt(t, n) {
+  return !t.length || !n.length ? [] : t.length === 1 && n.length === 1 ? re(t[0], n[0]) : t.length > 1 ? t.flatMap((e) => rt([e], n)) : n.flatMap((e) => rt(t, [e]));
+}
+class _ extends lt {
+  constructor(e = [], { ignoreChecks: s = !1 } = {}) {
+    super();
+    C(this, "figures");
+    C(this, "_boundingBox", null);
+    s || le(e), this.figures = e;
+  }
+  get isEmpty() {
+    return this.figures.length === 0;
+  }
+  get boundingBox() {
+    if (this.isEmpty) return new hn();
+    if (this._boundingBox === null) {
+      let e = this.figures[0].boundingBox;
+      for (const s of this.figures.slice(1))
+        e = e.merge(s.boundingBox);
+      this._boundingBox = e;
+    }
+    return this._boundingBox;
+  }
+  clone() {
+    return new _(this.figures.map((e) => e.clone()));
+  }
+  transform(e) {
+    return new _(this.figures.map((s) => s.transform(e)));
+  }
+  contains(e) {
+    return this.figures.some((s) => s.contains(e));
+  }
+  intersects(e) {
+    return this.figures.some(
+      (s) => e.figures.some((i) => s.intersects(i))
+    );
+  }
+  overlappingStrands(e) {
+    return this.figures.flatMap((s) => e instanceof _ ? e.figures.flatMap(
+      (i) => s.overlappingStrands(i)
+    ) : s.overlappingStrands(e));
+  }
+  fuse(e) {
+    return new _(G(this.figures, e.figures));
+  }
+  cut(e) {
+    return new _(Q(this.figures, e.figures));
+  }
+  intersect(e) {
+    return new _(rt(this.figures, e.figures));
+  }
+}
+function le(t) {
+  for (const [n, e] of st(t))
+    if (n.intersects(e))
+      throw new Error("Diagram figures must not intersect");
+}
+export {
+  _ as D,
+  v as F,
+  O as L,
+  B as S,
+  K as a,
+  G as b,
+  Q as c,
+  qt as d,
+  Yt as e,
+  ae as f,
+  jn as g,
+  Mt as h,
+  rt as i,
+  J as l,
+  pn as p,
+  Ft as s
+};
+//# sourceMappingURL=models-WQ-B7GSL.js.map