pantograph2d 0.1.0 → 0.2.0

package/dist/exportJSON-b3e1c256.js

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