pantograph2d 0.1.0

package/dist/Diagram-8b41118e.js

@@ -0,0 +1,944 @@
+function $(e, t, n, r) {
+  return e <= r && t >= n;
+}
+class B {
+  constructor(t = 1 / 0, n = 1 / 0, r = -1 / 0, s = -1 / 0) {
+    this.xMin = t, this.yMin = n, this.xMax = r, this.yMax = s;
+  }
+  get width() {
+    return this.xMax - this.xMin;
+  }
+  get height() {
+    return this.yMax - this.yMin;
+  }
+  contains(t) {
+    const [n, r] = t;
+    return $(this.xMin, this.xMax, n, n) && $(this.yMin, this.yMax, r, r);
+  }
+  overlaps(t) {
+    return $(this.xMin, this.xMax, t.xMin, t.xMax) && $(this.yMin, this.yMax, t.yMin, t.yMax);
+  }
+  addPoint(t) {
+    const [n, r] = t;
+    return new B(
+      Math.min(this.xMin, n),
+      Math.min(this.yMin, r),
+      Math.max(this.xMax, n),
+      Math.max(this.yMax, r)
+    );
+  }
+  merge(t) {
+    return new B(
+      Math.min(this.xMin, t.xMin),
+      Math.min(this.yMin, t.yMin),
+      Math.max(this.xMax, t.xMax),
+      Math.max(this.yMax, t.yMax)
+    );
+  }
+}
+function ut(e) {
+  const t = [];
+  for (let n = 0; n < e; n++)
+    for (let r = 0; r <= n; r++)
+      t.push([n, r]);
+  return t;
+}
+function* X(e) {
+  for (const [t, n] of ut(e.length))
+    t !== n && (yield [e[t], e[n]]);
+}
+const Pt = Math.PI / 180, k = (e) => `[${e[0]}, ${e[1]}]`, c = ([e, t], [n, r], s = 1e-9) => Math.abs(e - n) <= s && Math.abs(t - r) <= s, K = ([e, t], [n, r]) => [e + n, t + r], T = ([e, t], [n, r]) => [e - n, t - r], _ = ([e, t]) => e * e + t * t, Q = ([e, t], n) => [e * n, t * n], at = ([e, t], [n, r] = [0, 0]) => (e - n) ** 2 + (t - r) ** 2, F = (e, t = [0, 0]) => Math.sqrt(at(e, t));
+function q([e, t], [n, r]) {
+  return e * r - t * n;
+}
+function Z([e, t], [n, r]) {
+  return e * n + t * r;
+}
+function G([e, t]) {
+  const n = F([e, t]);
+  return [e / n, t / n];
+}
+function qt(e, t) {
+  const n = Math.cos(t) * e, r = Math.sin(t) * e;
+  return [n, r];
+}
+function lt(e, t, n = 1e-9) {
+  const r = q(e, t), s = _(e), i = _(t);
+  return r * r < s * i * n * n;
+}
+const C = (e, t) => {
+  const [n, r, s, i, o, u, a, l, h] = e, [m, f, g, P, x, d, S, v, b] = t;
+  return [
+    n * m + r * P + s * S,
+    n * f + r * x + s * v,
+    n * g + r * d + s * b,
+    i * m + o * P + u * S,
+    i * f + o * x + u * v,
+    i * g + o * d + u * b,
+    a * m + l * P + h * S,
+    a * f + l * x + h * v,
+    a * g + l * d + h * b
+  ];
+};
+class y {
+  constructor() {
+    this._matrix = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+  }
+  translate(t, n) {
+    return this._matrix = C(this._matrix, [1, 0, t, 0, 1, n, 0, 0, 1]), this;
+  }
+  rotate(t, n) {
+    const r = Math.cos(t), s = Math.sin(t), i = [r, -s, 0, s, r, 0, 0, 0, 1];
+    return n && this.translate(n[0], n[1]), this._matrix = C(this._matrix, i), n && this.translate(-n[0], -n[1]), this;
+  }
+  mirrorX() {
+    return this._matrix = C(this._matrix, [1, 0, 0, 0, -1, 0, 0, 0, 1]), this;
+  }
+  mirrorY() {
+    return this._matrix = C(this._matrix, [-1, 0, 0, 0, 1, 0, 0, 0, 1]), this;
+  }
+  mirrorLine(t, n) {
+    const [r, s] = t, i = Math.atan2(s, r);
+    return n && this.translate(n[0], n[1]), this.rotate(i), this.mirrorX(), this.rotate(-i), n && this.translate(-n[0], -n[1]), this;
+  }
+  mirrorCenter(t) {
+    return t && this.translate(t[0], t[1]), this._matrix = C(this._matrix, [-1, 0, 0, 0, -1, 0, 0, 0, 1]), t && this.translate(-t[0], -t[1]), this;
+  }
+  scale(t, n) {
+    return n && this.translate(n[0], n[1]), this._matrix = C(this._matrix, [t, 0, 0, 0, t, 0, 0, 0, 1]), n && this.translate(-n[0], -n[1]), this;
+  }
+  transform(t) {
+    const [n, r] = t, [s, i, o, u, a, l] = this._matrix;
+    return [s * n + i * r + o, u * n + a * r + l];
+  }
+}
+class D {
+  translateX(t) {
+    const n = new y().translate(t, 0);
+    return this.transform(n);
+  }
+  translateY(t) {
+    const n = new y().translate(0, t);
+    return this.transform(n);
+  }
+  translate(t, n) {
+    const r = new y().translate(t, n);
+    return this.transform(r);
+  }
+  translateTo([t, n]) {
+    const r = new y().translate(t, n);
+    return this.transform(r);
+  }
+  rotate(t, n) {
+    const r = new y().rotate(
+      t * Pt,
+      n
+    );
+    return this.transform(r);
+  }
+  scale(t, n) {
+    const r = new y().scale(t, n);
+    return this.transform(r);
+  }
+  mirrorCenter(t) {
+    const n = new y().mirrorCenter(t);
+    return this.transform(n);
+  }
+  mirror(t = "x", n) {
+    const r = new y();
+    return t === "x" ? r.mirrorX() : t === "y" ? r.mirrorY() : r.mirrorLine(t, n), this.transform(r);
+  }
+}
+class M extends D {
+  constructor(t, n = [], { ignoreChecks: r = !1 } = {}) {
+    super(), r || xt(t, n), this.contour = t, this.holes = n;
+  }
+  get boundingBox() {
+    return this.contour.boundingBox;
+  }
+  get isFull() {
+    return this.holes.length === 0;
+  }
+  get allLoops() {
+    return [this.contour, ...this.holes];
+  }
+  clone() {
+    return new M(
+      this.contour.clone(),
+      this.holes.map((t) => t.clone())
+    );
+  }
+  transform(t) {
+    return new M(
+      this.contour.transform(t),
+      this.holes.map((n) => n.transform(t))
+    );
+  }
+  contains(t) {
+    return this.contour.contains(t) && !this.holes.some((n) => n.contains(t));
+  }
+  intersects(t) {
+    return this.allLoops.some(
+      (n) => t.allLoops.some((r) => n.intersects(r))
+    );
+  }
+}
+function xt(e, t = []) {
+  if (!e)
+    throw new Error("Figure must have a contour");
+  for (const [n, r] of X([e, ...t]))
+    if (n.intersects(r))
+      throw new Error("Loops in a figure must not intersect");
+  if (t.some((n) => !e.contains(n.firstPoint)))
+    throw new Error("Holes must be inside the contour");
+  for (const [n, r] of X(t))
+    if (n.contains(r.firstPoint))
+      throw new Error("Holes must not be inside other holes");
+}
+const dt = (e) => {
+  const t = e.map((s, i) => e.slice(i + 1).map((o, u) => [u + i + 1, o]).filter(([, o]) => s.boundingBox.overlaps(o.boundingBox)).map(([o]) => o)), n = [], r = Array(t.length);
+  return t.forEach((s, i) => {
+    let o = r[i];
+    o || (o = [], n.push(o)), o.push(e[i]), s.length && s.forEach((u) => {
+      r[u] = o;
+    });
+  }), n;
+}, ct = (e) => e.map((t, n) => {
+  const s = t.segments[0].midPoint, i = e.filter((o, u) => n === u ? !1 : o.contains(s));
+  return {
+    loop: t,
+    isIn: i
+  };
+}), wt = (e, t) => e.flatMap(({ loop: n }) => Y(
+  t.filter(
+    ({ loop: r, isIn: s }) => r === n || s.indexOf(n) !== -1
+  )
+)), Mt = (e, t) => {
+  const n = t.filter(({ isIn: s }) => s.length <= 1), r = Y(
+    ct(e.map(({ loop: s }) => s))
+  );
+  return [n, ...r];
+}, Y = (e) => {
+  if (!e.length)
+    return [];
+  const t = e.filter(({ isIn: r }) => !r.length), n = e.filter(({ isIn: r }) => r.length > 1);
+  return t.length === 1 && n.length === 0 ? [e] : t.length > 1 ? wt(t, e) : Mt(n, e);
+};
+function A(e) {
+  return dt(e).map(ct).flatMap(Y).map((n) => {
+    if (n.length === 1)
+      return new M(n[0].loop);
+    n.sort((i, o) => i.isIn.length - o.isIn.length);
+    const [r, ...s] = n.map(({ loop: i }) => i);
+    return new M(r, s);
+  });
+}
+function yt(e, t) {
+  const n = [];
+  for (const r of e)
+    for (const s of t)
+      n.push([r, s]);
+  return n;
+}
+function vt(e) {
+  return Array.from(Array(e).keys());
+}
+function E(e) {
+  const t = Math.min(...e.map((n) => n.length));
+  return vt(t).map((n) => e.map((r) => r[n]));
+}
+const tt = (e, t = 1e-9) => {
+  let n = e;
+  return Math.abs(e) < t && (n = 0), n.toFixed(-Math.log10(t));
+};
+function z(e, t = 1e-9) {
+  return Array.from(
+    new Map(
+      e.map(([n, r]) => [
+        `[${tt(n, t)},${tt(r, t)}]`,
+        [n, r]
+      ])
+    ).values()
+  );
+}
+class St extends D {
+  constructor(t, n) {
+    super(), this.firstPoint = t, this.lastPoint = n, this.precision = 1e-9, this.firstPoint = t, this.lastPoint = n;
+  }
+  get repr() {
+    return `${this.segmentType} ${k(this.firstPoint)} - ${k(
+      this.lastPoint
+    )}`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.repr;
+  }
+}
+class p extends St {
+  constructor() {
+    super(...arguments), this.segmentType = "LINE", this._V = null, this._boundingBox = null;
+  }
+  isValidParameter(t) {
+    const n = this.length * this.precision;
+    return t >= -n && 1 - t >= -n;
+  }
+  paramPoint(t) {
+    return K(this.firstPoint, Q(this.V, t));
+  }
+  get length() {
+    return F(this.firstPoint, this.lastPoint);
+  }
+  get squareLength() {
+    return at(this.firstPoint, this.lastPoint);
+  }
+  get V() {
+    return this._V === null && (this._V = T(this.lastPoint, this.firstPoint)), this._V;
+  }
+  get midPoint() {
+    return K(this.firstPoint, Q(this.V, 0.5));
+  }
+  isSame(t) {
+    return t instanceof p ? c(this.firstPoint, t.firstPoint) && c(this.lastPoint, t.lastPoint) || c(this.lastPoint, t.firstPoint) && c(this.firstPoint, t.lastPoint) : !1;
+  }
+  clone() {
+    return new p(this.firstPoint, this.lastPoint);
+  }
+  reverse() {
+    return new p(this.lastPoint, this.firstPoint);
+  }
+  get boundingBox() {
+    return this._boundingBox === null && (this._boundingBox = new B(
+      Math.min(this.firstPoint[0], this.lastPoint[0]) - this.precision,
+      Math.min(this.firstPoint[1], this.lastPoint[1]) - this.precision,
+      Math.max(this.firstPoint[0], this.lastPoint[0]) + this.precision,
+      Math.max(this.firstPoint[1], this.lastPoint[1]) + this.precision
+    )), this._boundingBox;
+  }
+  distanceFrom(t) {
+    const n = T(t, this.firstPoint), r = Z(n, this.V) / this.squareLength;
+    if (r < 0)
+      return F(t, this.firstPoint);
+    if (r > 1)
+      return F(t, this.lastPoint);
+    const s = this.paramPoint(r);
+    return F(t, s);
+  }
+  isOnSegment(t) {
+    if (c(t, this.firstPoint, this.precision))
+      return !0;
+    const n = T(t, this.firstPoint);
+    if (!lt(this.V, n))
+      return !1;
+    const r = Z(n, this.V) / this.squareLength;
+    return this.isValidParameter(r);
+  }
+  tangentAt(t) {
+    if (!this.isOnSegment(t))
+      throw new Error("Point is not on segment");
+    return G(this.V);
+  }
+  get tangentAtFirstPoint() {
+    return G(this.V);
+  }
+  get tangentAtLastPoint() {
+    return G(this.V);
+  }
+  splitAt(t) {
+    let n;
+    if (Array.isArray(t) && t.length === 0)
+      return [this];
+    Array.isArray(t[0]) ? n = t : n = [t], n.forEach((a) => {
+      if (!this.isOnSegment(a))
+        throw new Error(
+          `Point ${k(a)} is not on segment ${this.repr}`
+        );
+    });
+    const r = [this.firstPoint, ...n, this.lastPoint], s = z(r), i = this.lastPoint[0] - this.firstPoint[0];
+    let o = Math.sign(i), u = 0;
+    return Math.abs(i) < this.precision && (o = Math.sign(this.lastPoint[1] - this.firstPoint[1]), u = 1), s.sort(
+      (a, l) => o * (a[u] - l[u])
+    ), s.flatMap((a, l) => l === s.length - 1 ? [] : new p(a, s[l + 1]));
+  }
+  transform(t) {
+    return new p(
+      t.transform(this.firstPoint),
+      t.transform(this.lastPoint)
+    );
+  }
+}
+const ht = (e, t, n) => {
+  const r = q(e.V, t.V), s = _(e.V), i = _(t.V), o = n ? n * n : e.precision * t.precision;
+  if (r * r < s * i * o)
+    return "parallel";
+  const u = T(t.firstPoint, e.firstPoint), a = q(u, t.V) / r, l = q(u, e.V) / r;
+  return {
+    intersectionParam1: a,
+    intersectionParam2: l
+  };
+};
+function bt(e, t, n = !1, r) {
+  const s = ht(e, t, r);
+  if (s === "parallel") {
+    if (!n)
+      return null;
+    if (e.isSame(t))
+      return e;
+    const u = z(
+      [
+        t.isOnSegment(e.firstPoint) ? e.firstPoint : null,
+        t.isOnSegment(e.lastPoint) ? e.lastPoint : null,
+        e.isOnSegment(t.firstPoint) ? t.firstPoint : null,
+        e.isOnSegment(t.lastPoint) ? t.lastPoint : null
+      ].filter((a) => a !== null)
+    ).sort((a, l) => a[0] - l[0]);
+    if (u.length === 0)
+      return null;
+    if (u.length === 1)
+      return null;
+    if (u.length === 2)
+      return new p(u[0], u[1]);
+    throw console.error(u), new Error(
+      "Unexpected number of points while intersecting parallel lines"
+    );
+  }
+  const { intersectionParam1: i, intersectionParam2: o } = s;
+  return !e.isValidParameter(i) || !t.isValidParameter(o) ? null : e.paramPoint(i);
+}
+function R(e, t, n) {
+  if (e instanceof p && t instanceof p) {
+    const r = bt(
+      e,
+      t,
+      !0,
+      n
+    );
+    return r === null ? { intersections: [], overlaps: [], count: 0 } : r instanceof p ? { intersections: [], overlaps: [r], count: 1 } : { intersections: [r], overlaps: [], count: 1 };
+  }
+  throw new Error("Not implemented");
+}
+class ft extends D {
+  constructor(t, { ignoreChecks: n = !1 } = {}) {
+    super(), this._boundingBox = null, n || mt(t), this.segments = t;
+  }
+  get repr() {
+    return this.segments.map((t) => t.repr).join(`
+`) + `
+`;
+  }
+  get firstPoint() {
+    return this.segments[0].firstPoint;
+  }
+  get lastPoint() {
+    return this.segments[this.segments.length - 1].lastPoint;
+  }
+  get segmentsCount() {
+    return this.segments.length;
+  }
+  onStroke(t) {
+    return this.segments.some((n) => n.isOnSegment(t));
+  }
+  intersects(t) {
+    return this.boundingBox.overlaps(t.boundingBox) ? this.segments.some(
+      (n) => t.segments.some(
+        (r) => R(n, r).count > 0
+      )
+    ) : !1;
+  }
+  get boundingBox() {
+    if (this._boundingBox === null) {
+      let t = this.segments[0].boundingBox;
+      this.segments.slice(1).forEach((n) => {
+        t = t.merge(n.boundingBox);
+      }), this._boundingBox = t;
+    }
+    return this._boundingBox;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.repr;
+  }
+}
+function Ct(e, t = "Stroke") {
+  ut(e.length).forEach(
+    ([n, r]) => {
+      if (n === r)
+        return;
+      const s = e[n], i = e[r], o = R(s, i);
+      if (o.count !== 0) {
+        if (o.count === 1 && !o.overlaps.length) {
+          const u = n - r, a = o.intersections[0];
+          if (u === 1 && c(s.firstPoint, a) || u === -1 && c(s.lastPoint, a) || u === e.length - 1 && c(s.lastPoint, a) && c(i.firstPoint, a) || -u === e.length - 1 && c(s.firstPoint, a) && c(i.lastPoint, a))
+            return;
+        }
+        throw new Error(
+          `${t} segments must not intersect, but segments ${s.repr} and ${i.repr} do`
+        );
+      }
+    }
+  );
+}
+function mt(e, t = "Stroke") {
+  if (e.length === 0)
+    throw new Error(`${t} must have at least one segment`);
+  E([e.slice(0, -1), e.slice(1)]).forEach(
+    ([n, r]) => {
+      if (!c(n.lastPoint, r.firstPoint))
+        throw new Error(
+          `${t} segments must be connected, but ${n.repr} and ${r.repr} are not`
+        );
+    }
+  ), Ct(e, t);
+}
+function nt(e, t) {
+  return !!(e instanceof p && t instanceof p && lt(e.V, t.V));
+}
+function et(e, t) {
+  if (e instanceof p && t instanceof p)
+    return new p(e.firstPoint, t.lastPoint);
+  throw new Error("Not implemented");
+}
+function gt(e) {
+  let t = !1;
+  const n = [];
+  for (const r of e.segments) {
+    if (n.length === 0) {
+      n.push(r);
+      continue;
+    }
+    const s = n[n.length - 1];
+    nt(s, r) ? (t = !0, n.pop(), n.push(et(s, r))) : n.push(r);
+  }
+  if (c(e.firstPoint, e.lastPoint) && nt(
+    n[0],
+    n[n.length - 1]
+  )) {
+    t = !0;
+    const r = n.pop();
+    n[0] = et(r, n[0]);
+  }
+  return t ? n : null;
+}
+class w extends ft {
+  reverse() {
+    const t = this.segments.map((n) => n.reverse());
+    return t.reverse(), new w(t, { ignoreChecks: !0 });
+  }
+  clone() {
+    return new w(
+      this.segments.map((t) => t.clone()),
+      { ignoreChecks: !0 }
+    );
+  }
+  extend(t) {
+    if (!c(this.lastPoint, t.firstPoint))
+      throw console.error(this.repr, t.repr), new Error("Cannot extend strand: connection point is not the same");
+    return new w([...this.segments, ...t.segments]);
+  }
+  simplify() {
+    const t = gt(this);
+    return t ? new w(t, { ignoreChecks: !0 }) : this;
+  }
+  transform(t) {
+    return new w(
+      this.segments.map((n) => n.transform(t)),
+      { ignoreChecks: !0 }
+    );
+  }
+}
+const It = (e, t) => {
+  const n = ht(t, {
+    V: [1, 0],
+    firstPoint: e,
+    precision: t.precision
+  });
+  if (n === "parallel")
+    return 0;
+  const { intersectionParam1: r, intersectionParam2: s } = n;
+  if (!t.isValidParameter(r) || s <= -t.precision)
+    return 0;
+  if (Math.abs(r) < t.precision || Math.abs(r - 1) < t.precision) {
+    const [, i] = t.midPoint;
+    return e[1] - i < 0 ? 1 : 0;
+  }
+  return 1;
+};
+function Vt(e, t) {
+  if (t instanceof p)
+    return It(e, t);
+  throw new Error("Not implemented");
+}
+class V extends ft {
+  constructor(t, { ignoreChecks: n = !1 } = {}) {
+    super(t, { ignoreChecks: !0 }), n || Et(t);
+  }
+  clone() {
+    return new V(
+      this.segments.map((t) => t.clone()),
+      { ignoreChecks: !0 }
+    );
+  }
+  reverse() {
+    const t = this.segments.map((n) => n.reverse());
+    return t.reverse(), new V(t, { ignoreChecks: !0 });
+  }
+  transform(t) {
+    return new V(
+      this.segments.map((n) => n.transform(t)),
+      { ignoreChecks: !0 }
+    );
+  }
+  contains(t) {
+    return this.onStroke(t) ? !1 : this.segments.reduce((r, s) => r + Vt(t, s), 0) % 2 === 1;
+  }
+  simplify() {
+    const t = gt(this);
+    return t ? new V(t, { ignoreChecks: !0 }) : this;
+  }
+}
+function Et(e) {
+  if (mt(e, "Loop"), !c(e[0].firstPoint, e[e.length - 1].lastPoint))
+    throw new Error("Loop segment must be closed");
+}
+const rt = (e, t) => {
+  const n = e.findIndex((i) => c(t, i.firstPoint)), r = e.slice(0, n);
+  return e.slice(n).concat(r);
+}, st = (e, t) => {
+  let n = e;
+  const r = (u) => c(u.firstPoint, t.firstPoint) && c(u.lastPoint, t.lastPoint);
+  let s = e.findIndex(r);
+  if (s === -1) {
+    const u = e.map((a) => a.reverse());
+    if (u.reverse(), s = u.findIndex(r), s === -1)
+      throw console.error(
+        u.map((a) => a.repr),
+        t.repr
+      ), new Error("Failed to rotate to segment start");
+    n = u;
+  }
+  const i = n.slice(0, s);
+  return n.slice(s).concat(i);
+};
+function* it(e, t, n) {
+  const r = (o) => t.some((u) => c(u, o.lastPoint)), s = (o) => n.some((u) => o.isSame(u));
+  let i = [];
+  for (const o of e)
+    r(o) ? (i.push(o), yield new w(i, { ignoreChecks: !0 }), i = []) : s(o) ? (i.length && (yield new w(i, { ignoreChecks: !0 }), i = []), yield new w([o], { ignoreChecks: !0 })) : i.push(o);
+  i.length && (yield new w(i, { ignoreChecks: !0 }));
+}
+function Ft(e, t, n) {
+  return e.filter((r) => {
+    const s = t.filter((u) => c(u.firstPoint, r) || c(u.lastPoint, r));
+    if (s.length % 2)
+      throw new Error("Bug in the intersection algo on non crossing point");
+    const i = s.map((u) => n.contains(u.midPoint));
+    return !(i.every((u) => u) || !i.some((u) => u));
+  });
+}
+function At(e, t, n) {
+  let r = [];
+  const s = [], i = new Array(e.segments.length).fill(0).map(() => []), o = new Array(t.segments.length).fill(0).map(() => []);
+  if (e.segments.forEach((f, g) => {
+    t.segments.forEach((P, x) => {
+      const { intersections: d, overlaps: S } = R(
+        f,
+        P,
+        n
+      );
+      r.push(...d), i[g].push(...d), o[x].push(...d), s.push(...S);
+      const v = S.flatMap((b) => [
+        b.firstPoint,
+        b.lastPoint
+      ]);
+      r.push(...v), i[g].push(...v), o[x].push(...v);
+    });
+  }), r = z(r, n), !r.length || r.length === 1)
+    return null;
+  const u = ([f, g]) => g.length ? f.splitAt(g) : [f];
+  let a = E([e.segments, i]).flatMap(u), l = E([t.segments, o]).flatMap(u);
+  if (r = Ft(
+    r,
+    a,
+    t
+  ), !r.length && !s.length)
+    return null;
+  if (s.length) {
+    const f = s[0];
+    a = st(
+      a,
+      f
+    ), l = st(
+      l,
+      f
+    );
+  } else {
+    const f = r[0];
+    a = rt(a, f), l = rt(l, f);
+  }
+  const h = Array.from(
+    it(
+      a,
+      r,
+      s
+    )
+  );
+  let m = Array.from(
+    it(
+      l,
+      r,
+      s
+    )
+  );
+  return (!c(
+    m[0].lastPoint,
+    h[0].lastPoint
+  ) || s.length > 0 && m[0].segmentsCount !== 1) && (m = m.reverse().map((f) => f.reverse())), E([h, m]).map(([f, g]) => f.segmentsCount === 1 && s.some((P) => f.segments[0].isSame(P)) ? [f, "same"] : [f, g]);
+}
+function W(e) {
+  let t = e[0];
+  for (const n of e.slice(1))
+    t = t.extend(n);
+  if (!c(t.firstPoint, t.lastPoint))
+    throw console.error(
+      k(t.firstPoint),
+      k(t.lastPoint)
+    ), new Error("Bug in the intersection algo on non closing strand");
+  return new V(t.segments);
+}
+function Bt(e) {
+  if (!e.length)
+    return [];
+  const t = e.map((o) => o.firstPoint);
+  let n = e.map((o) => o.lastPoint);
+  n = n.slice(-1).concat(n.slice(0, -1));
+  const r = E([t, n]).flatMap(
+    ([o, u], a) => c(o, u) ? [] : a
+  );
+  if (!r.length)
+    return [W(e)];
+  const s = E([
+    r.slice(0, -1),
+    r.slice(1)
+  ]).map(([o, u]) => W(e.slice(o, u)));
+  let i = e.slice(
+    r[r.length - 1]
+  );
+  return r[0] !== 0 && (i = i.concat(e.slice(0, r[0]))), s.push(W(i)), s;
+}
+const ot = (e, t) => {
+  if (e.length === 0)
+    return [t];
+  const n = e.at(-1);
+  return c(n.lastPoint, t.firstPoint) ? e.slice(0, -1).concat([n.extend(t)]) : c(n.lastPoint, t.lastPoint) ? e.slice(0, -1).concat([n.extend(t.reverse())]) : e.concat([t]);
+}, kt = (e, t) => e.length === 0 ? [t] : c(e[0].firstPoint, t.lastPoint) ? [t.extend(e[0])].concat(e.slice(1)) : [t].concat(e);
+function U(e, t, {
+  firstInside: n,
+  secondInside: r
+}) {
+  const s = At(e, t);
+  if (!s) {
+    const a = e.segments[0].midPoint, l = t.contains(a), h = t.segments[0].midPoint, m = e.contains(h);
+    return {
+      identical: !1,
+      firstCurveInSecond: l,
+      secondCurveInFirst: m
+    };
+  }
+  if (s.every(([, a]) => a === "same"))
+    return { identical: !0 };
+  let i = null, o = null;
+  const u = s.flatMap(([a, l]) => {
+    let h = [], m = 0;
+    if (l === "same")
+      return o === 1 ? (o = 1, a) : o === 2 || o === 0 ? (o = null, []) : o === null ? (i ? i = i.extend(a) : i = a, []) : (console.error("weird situation"), []);
+    const f = a.segments[0].midPoint, g = t.contains(f);
+    (n === "keep" && g || n === "remove" && !g) && (m += 1, h = ot(h, a));
+    const P = l.segments[0].midPoint, x = e.contains(P);
+    if (r === "keep" && x || r === "remove" && !x) {
+      const d = l;
+      m += 1, m === 2 && h.length ? (h = ot(h, d), i = null) : h = [d];
+    }
+    return o === null && m === 1 && i && (h = kt(h, i)), m === 1 && (o = m, i = null), h.length ? h : (i = null, []);
+  });
+  return Bt(u);
+}
+const Lt = (e, t) => {
+  const n = U(e, t, {
+    firstInside: "remove",
+    secondInside: "remove"
+  });
+  return Array.isArray(n) ? n : n.identical ? [e] : n.firstCurveInSecond ? [t] : n.secondCurveInFirst ? [e] : [e, t];
+}, j = (e, t) => {
+  const n = U(e, t, {
+    firstInside: "remove",
+    secondInside: "keep"
+  });
+  return Array.isArray(n) ? n : n.identical ? [] : n.firstCurveInSecond ? [] : n.secondCurveInFirst ? [e, t] : [e];
+}, J = (e, t) => {
+  const n = U(e, t, {
+    firstInside: "keep",
+    secondInside: "keep"
+  });
+  return Array.isArray(n) ? n : n.identical ? [e] : n.firstCurveInSecond ? [e] : n.secondCurveInFirst ? [t] : [];
+};
+function Ot(e) {
+  const t = /* @__PURE__ */ new Map(), n = [];
+  return e.forEach((r, s) => {
+    let i;
+    t.has(s) ? i = t.get(s) : (i = { current: [r], fusedWith: /* @__PURE__ */ new Set([s]) }, n.push(i)), e.slice(s + 1).forEach((o, u) => {
+      const a = i.current, l = s + u + 1;
+      if (i.fusedWith.has(l))
+        return;
+      let h = [o], m = !1;
+      if (t.has(l) && (h = t.get(l).current, m = !0), !a.some(
+        (P) => h.some((x) => P.intersects(x))
+      ))
+        return;
+      let g;
+      a.length > 1 || h.length > 1 ? g = L(a, h) : g = pt(a[0], h[0]), i.fusedWith.add(l), i.current = g, m || t.set(l, i);
+    });
+  }), n.flatMap(({ current: r }) => r);
+}
+function pt(e, t) {
+  const n = Lt(e.contour, t.contour), r = t.holes.flatMap((o) => j(o, e.contour)), s = e.holes.flatMap((o) => j(o, t.contour)), i = yt(e.holes, t.holes).flatMap(
+    ([o, u]) => J(o, u)
+  );
+  return A([
+    ...n,
+    ...r,
+    ...s,
+    ...i
+  ]);
+}
+function N(e, t) {
+  if (e.isFull && t.isFull)
+    return A(j(e.contour, t.contour));
+  if (e.isFull) {
+    const r = j(e.contour, t.contour), s = t.holes.flatMap(
+      (i) => J(i, e.contour)
+    );
+    return A([...r, ...s]);
+  } else if (t.isFull && !e.contour.intersects(t.contour))
+    if (e.contour.contains(t.contour.firstPoint)) {
+      const r = L(
+        e.holes.map((s) => new M(s)),
+        [t]
+      );
+      return A([
+        e.contour,
+        ...r.flatMap((s) => s.allLoops)
+      ]);
+    } else
+      return [e];
+  let n = N(new M(e.contour), t);
+  return e.holes.forEach((r) => {
+    n = n.flatMap((s) => N(s, new M(r)));
+  }), n;
+}
+function $t(e, t) {
+  const n = J(e.contour, t.contour);
+  if (!n.length)
+    return [];
+  let r = A(n);
+  return r = O(
+    r,
+    e.holes.map((s) => new M(s))
+  ), O(
+    r,
+    t.holes.map((s) => new M(s))
+  );
+}
+function L(e, t) {
+  if (!e.length)
+    return t;
+  if (!t.length)
+    return e;
+  if (e.length === 1 && t.length > 1 || t.length === 1 && e.length > 1)
+    return Ot([...e, ...t]);
+  if (e.length > 1 && t.length > 1) {
+    let n = L([e[0]], t);
+    return e.slice(1).forEach((r) => {
+      n = L([r], n);
+    }), n;
+  }
+  return e.length === 1 && t.length === 1 ? pt(e[0], t[0]) : [];
+}
+function O(e, t) {
+  if (!e.length)
+    return [];
+  if (!t.length)
+    return e;
+  if (e.length === 1 && t.length === 1)
+    return N(e[0], t[0]);
+  if (e.length > 1)
+    return e.flatMap((r) => O([r], t));
+  let n = N(e[0], t[0]);
+  return t.slice(1).forEach((r) => {
+    n = O(n, [r]);
+  }), n;
+}
+function H(e, t) {
+  return !e.length || !t.length ? [] : e.length === 1 && t.length === 1 ? $t(e[0], t[0]) : e.length > 1 ? e.flatMap((n) => H([n], t)) : t.flatMap((n) => H(e, [n]));
+}
+class I extends D {
+  constructor(t = [], { ignoreChecks: n = !1 } = {}) {
+    super(), this._boundingBox = null, n || Tt(t), this.figures = t;
+  }
+  get isEmpty() {
+    return this.figures.length === 0;
+  }
+  get boundingBox() {
+    if (this.isEmpty)
+      return new B();
+    if (this._boundingBox === null) {
+      let t = this.figures[0].boundingBox;
+      for (const n of this.figures.slice(1))
+        t = t.merge(n.boundingBox);
+      this._boundingBox = t;
+    }
+    return this._boundingBox;
+  }
+  clone() {
+    return new I(this.figures.map((t) => t.clone()));
+  }
+  transform(t) {
+    return new I(this.figures.map((n) => n.transform(t)));
+  }
+  contains(t) {
+    return this.figures.some((n) => n.contains(t));
+  }
+  intersects(t) {
+    return this.figures.some(
+      (n) => t.figures.some((r) => n.intersects(r))
+    );
+  }
+  fuse(t) {
+    return new I(L(this.figures, t.figures));
+  }
+  cut(t) {
+    return new I(O(this.figures, t.figures));
+  }
+  intersect(t) {
+    return new I(H(this.figures, t.figures));
+  }
+}
+function Tt(e) {
+  for (const [t, n] of X(e))
+    if (t.intersects(n))
+      throw new Error("Diagram figures must not intersect");
+}
+export {
+  B,
+  I as D,
+  M as F,
+  p as L,
+  w as S,
+  y as T,
+  c as a,
+  V as b,
+  Pt as c,
+  O as d,
+  L as f,
+  H as i,
+  qt as p,
+  T as s
+};
+//# sourceMappingURL=Diagram-8b41118e.js.map