pantograph2d 0.8.1 → 0.9.0

package/dist/pantograph.js

@@ -1,209 +1,209 @@
-var lt = Object.defineProperty;
-var ut = (t, e, n) => e in t ? lt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
-var p = (t, e, n) => ut(t, typeof e != "symbol" ? e + "" : e, n);
-import { o as gt, D } from "./draw-DqsKIWJD.js";
-import { d as Pe } from "./draw-DqsKIWJD.js";
-import { F as d, L as P, D as g, a as B, s as ht, b as pt, c as dt, i as mt, S as C, l as Pt, p as wt, d as Mt, e as X, g as It } from "./models-WQ-B7GSL.js";
-import { h as Me } from "./models-WQ-B7GSL.js";
-import { r as St, z as bt, l as Lt, f as w, n as Y, i as E, a as vt, s as kt, k as At, m as j, L as S, A as b, d as M, t as Et, c as yt, B as Ft, E as Ct, Q as xt, C as Dt } from "./QuadraticBezier-BzVqiExF.js";
-import { s as Rt, a as Ot, b as Bt, c as $t, d as Gt, w as z } from "./svg-BylQQgsL.js";
-function I(t) {
-  if (t instanceof d)
+var bt = Object.defineProperty;
+var Lt = (t, n, e) => n in t ? bt(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var P = (t, n, e) => Lt(t, typeof n != "symbol" ? n + "" : n, e);
+import { o as At, D as T } from "./draw-N2ntigsw.js";
+import { d as Cn } from "./draw-N2ntigsw.js";
+import { F as w, L as S, D as g, a as _, s as vt, b as kt, c as Et, i as yt, S as R, l as Ft, p as Ct, d as xt, e as rt, g as Dt } from "./models-BjaFYsN2.js";
+import { h as Dn } from "./models-BjaFYsN2.js";
+import { r as Ot, z as Rt, l as Bt, e as L, n as ot, b as y, a as zt, s as Tt, m as $t, o as at, L as I, A as E, C as B, p as J, q as Q, d as Gt, T as Ut, g as A, E as ct, Q as ft, t as _t, c as Vt, B as qt } from "./QuadraticBezier-PcRS9HZK.js";
+import { s as Nt, a as Jt, b as Qt, c as Zt, d as Ht, w as Z } from "./svg-hNHYuj_r.js";
+function v(t) {
+  if (t instanceof w)
     return [t];
-  if (t instanceof P)
-    return [new d(t)];
+  if (t instanceof S)
+    return [new w(t)];
   if (t instanceof g)
     return t.figures;
   throw new Error("Unknown shape");
 }
-function tt(t, e, n = 1e-9) {
+function lt(t, n, e = 1e-9) {
   let s = [];
-  const r = [], i = new Array(e.segments.length).fill(0).map(() => []);
-  e.segments.forEach((c, f) => {
+  const r = [], i = new Array(n.segments.length).fill(0).map(() => []);
+  n.segments.forEach((f, c) => {
     t.segments.forEach((a) => {
-      const { intersections: u, overlaps: m } = B(
-        c,
+      const { intersections: l, overlaps: p } = _(
+        f,
         a,
-        n
+        e
       );
-      s.push(...u), i[f].push(...u), r.push(...m);
-      const h = m.flatMap((l) => [
-        l.firstPoint,
-        l.lastPoint
+      s.push(...l), i[c].push(...l), r.push(...p);
+      const h = p.flatMap((d) => [
+        d.firstPoint,
+        d.lastPoint
       ]);
-      s.push(...h), i[f].push(...h);
+      s.push(...h), i[c].push(...h);
     });
-  }), s = St(s, n);
-  const o = bt([e.segments, i]).flatMap(([c, f]) => f.length ? c.splitAt(f) : [c]);
+  }), s = Ot(s, e);
+  const o = Rt([n.segments, i]).flatMap(([f, c]) => c.length ? f.splitAt(c) : [f]);
   return Array.from(
-    ht(
+    vt(
       o,
       s,
       r
     )
   );
 }
-function $(t, e, n = !1) {
-  return tt(e, t).filter((r) => {
+function V(t, n, e = !1) {
+  return lt(n, t).filter((r) => {
     const i = r.segments[0].midPoint;
-    return e.onStroke(i) ? !n : !e.contains(i);
+    return n.onStroke(i) ? !e : !n.contains(i);
   });
 }
-function G(t, e, n = !1) {
-  return tt(e, t).filter((r) => {
+function q(t, n, e = !1) {
+  return lt(n, t).filter((r) => {
     const i = r.segments[0].midPoint;
-    return e.onStroke(i) ? !n : e.contains(i);
+    return n.onStroke(i) ? !e : n.contains(i);
   });
 }
-function V(t, e, n = !1) {
-  const s = $(
+function H(t, n, e = !1) {
+  const s = V(
     t,
-    e.contour,
-    n
-  ), r = e.holes.flatMap(
-    (i) => G(t, i, n)
+    n.contour,
+    e
+  ), r = n.holes.flatMap(
+    (i) => q(t, i, e)
   );
   return [...s, ...r];
 }
-function _(t, e, n = !1) {
-  let s = G(
+function W(t, n, e = !1) {
+  let s = q(
     t,
-    e.contour,
-    n
+    n.contour,
+    e
   );
-  return e.holes.forEach((r) => {
+  return n.holes.forEach((r) => {
     s = s.flatMap(
-      (i) => $(i, r, n)
+      (i) => V(i, r, e)
     );
   }), s;
 }
-function Tt(t, e) {
+function Wt(t, n) {
   return new g(
-    pt(I(t), I(e))
+    kt(v(t), v(n))
   );
 }
-function y(t) {
+function D(t) {
   return t.reduce(
-    (e, n) => Tt(e, n),
+    (n, e) => Wt(n, e),
     new g()
   );
 }
-function et(t, e) {
+function ut(t, n) {
   return new g(
-    dt(I(t), I(e))
+    Et(v(t), v(n))
   );
 }
-function oe(t, e) {
+function Mn(t, n) {
   return new g(
-    mt(I(t), I(e))
+    yt(v(t), v(n))
   );
 }
-function ae(t, e, n = !0) {
-  if (e instanceof P)
-    return $(t, e, n);
-  if (e instanceof d)
-    return V(t, e, n);
-  let s = [new C([...t.segments])];
-  return e.figures.forEach((r) => {
-    s = s.flatMap((i) => V(i, r, n));
+function In(t, n, e = !0) {
+  if (n instanceof S)
+    return V(t, n, e);
+  if (n instanceof w)
+    return H(t, n, e);
+  let s = [new R([...t.segments])];
+  return n.figures.forEach((r) => {
+    s = s.flatMap((i) => H(i, r, e));
   }), s;
 }
-function ce(t, e, n = !1) {
-  if (e instanceof P)
-    return G(t, e, n);
-  if (e instanceof d)
-    return _(t, e, n);
-  let s = [new C([...t.segments])];
-  return e.figures.forEach((r) => {
-    s = s.flatMap((i) => _(i, r, n));
+function Sn(t, n, e = !1) {
+  if (n instanceof S)
+    return q(t, n, e);
+  if (n instanceof w)
+    return W(t, n, e);
+  let s = [new R([...t.segments])];
+  return n.figures.forEach((r) => {
+    s = s.flatMap((i) => W(i, r, e));
   }), s;
 }
-function N(t) {
+function X(t) {
   return t < 0 ? "before" : t > 1 ? "after" : "between";
 }
-const q = (t, e, n) => {
-  if (n === "before")
-    return t.distanceFrom(e.firstPoint);
-  if (n === "after")
-    return t.distanceFrom(e.lastPoint);
+const Y = (t, n, e) => {
+  if (e === "before")
+    return t.distanceFrom(n.firstPoint);
+  if (e === "after")
+    return t.distanceFrom(n.lastPoint);
   throw new Error("Invalid position");
 };
-function Ut(t, e) {
-  const n = Lt(t, e);
-  if (n === "parallel")
+function Xt(t, n) {
+  const e = Bt(t, n);
+  if (e === "parallel")
     return Math.min(
-      t.distanceFrom(e.firstPoint),
-      t.distanceFrom(e.lastPoint)
+      t.distanceFrom(n.firstPoint),
+      t.distanceFrom(n.lastPoint)
     );
-  const { intersectionParam1: s, intersectionParam2: r } = n, i = N(s), o = N(r);
+  const { intersectionParam1: s, intersectionParam2: r } = e, i = X(s), o = X(r);
   if (i === "between" && o === "between")
     return 0;
   if (i === "between" && o !== "between")
-    return q(t, e, o);
+    return Y(t, n, o);
   if (o === "between" && i !== "between")
-    return q(e, t, i);
+    return Y(n, t, i);
   if (i === "before" && o === "before")
-    return w(t.firstPoint, e.firstPoint);
+    return L(t.firstPoint, n.firstPoint);
   if (i === "after" && o === "after")
-    return w(t.lastPoint, e.lastPoint);
+    return L(t.lastPoint, n.lastPoint);
   if (i === "before" && o === "after")
-    return w(t.firstPoint, e.lastPoint);
+    return L(t.firstPoint, n.lastPoint);
   if (i === "after" && o === "before")
-    return w(t.lastPoint, e.firstPoint);
+    return L(t.lastPoint, n.firstPoint);
   throw new Error("Invalid position");
 }
-function J(t, e) {
-  if (Pt(t, e).length > 0)
+function K(t, n) {
+  if (Ft(t, n).length > 0)
     return 0;
-  const n = wt(t, e.center);
-  if (t.isOnSegment(n)) {
-    const s = w(n, e.center);
-    if (Math.abs(s - e.radius) < t.precision && e.isOnSegment(n))
+  const e = Ct(t, n.center);
+  if (t.isOnSegment(e)) {
+    const s = L(e, n.center);
+    if (Math.abs(s - n.radius) < t.precision && n.isOnSegment(e))
       return 0;
-    if (s - e.radius > t.precision) {
-      const r = Y(
-        E(n, e.center)
-      ), i = vt(
-        e.center,
-        kt(r, e.radius)
+    if (s - n.radius > t.precision) {
+      const r = ot(
+        y(e, n.center)
+      ), i = zt(
+        n.center,
+        Tt(r, n.radius)
       );
-      if (e.isOnSegment(i))
-        return w(i, n);
+      if (n.isOnSegment(i))
+        return L(i, e);
     }
   }
   return Math.min(
-    e.distanceFrom(t.firstPoint),
-    e.distanceFrom(t.lastPoint),
-    t.distanceFrom(e.firstPoint),
-    t.distanceFrom(e.lastPoint)
+    n.distanceFrom(t.firstPoint),
+    n.distanceFrom(t.lastPoint),
+    t.distanceFrom(n.firstPoint),
+    t.distanceFrom(n.lastPoint)
   );
 }
-const zt = (t, e) => {
-  const n = t.angleToParam(e.firstAngle);
-  if (t.isValidParameter(n)) return !0;
-  const s = t.angleToParam(e.lastAngle);
+const Yt = (t, n) => {
+  const e = t.angleToParam(n.firstAngle);
+  if (t.isValidParameter(e)) return !0;
+  const s = t.angleToParam(n.lastAngle);
   return !!t.isValidParameter(s);
 };
-function Vt(t, e) {
-  if (Mt(t, e, !0).length > 0) return 0;
-  const n = w(t.center, e.center);
-  if (n < t.precision && zt(t, e))
-    return Math.abs(t.radius - e.radius);
-  const s = Y(E(e.center, t.center)), r = n - Math.abs(t.radius - e.radius) < t.precision;
-  let i = At(s);
-  r && e.radius > t.radius && (i += Math.PI);
-  const o = r ? i : i + Math.PI, c = t.angleToParam(i), f = e.angleToParam(o);
-  return t.isValidParameter(c) && e.isValidParameter(f) ? w(t.paramPoint(c), e.paramPoint(f)) : Math.min(
-    t.distanceFrom(e.firstPoint),
-    t.distanceFrom(e.lastPoint),
-    e.distanceFrom(t.firstPoint),
-    e.distanceFrom(t.lastPoint)
+function Kt(t, n) {
+  if (xt(t, n, !0).length > 0) return 0;
+  const e = L(t.center, n.center);
+  if (e < t.precision && Yt(t, n))
+    return Math.abs(t.radius - n.radius);
+  const s = ot(y(n.center, t.center)), r = e - Math.abs(t.radius - n.radius) < t.precision;
+  let i = $t(s);
+  r && n.radius > t.radius && (i += Math.PI);
+  const o = r ? i : i + Math.PI, f = t.angleToParam(i), c = n.angleToParam(o);
+  return t.isValidParameter(f) && n.isValidParameter(c) ? L(t.paramPoint(f), n.paramPoint(c)) : Math.min(
+    t.distanceFrom(n.firstPoint),
+    t.distanceFrom(n.lastPoint),
+    n.distanceFrom(t.firstPoint),
+    n.distanceFrom(t.lastPoint)
   );
 }
-function _t(t, e, n) {
+function jt(t, n, e) {
   let s = 0, r = t.length - 1;
   for (; s <= r; ) {
-    const i = Math.floor((s + r) / 2), o = n(t[i], e);
+    const i = Math.floor((s + r) / 2), o = e(t[i], n);
     if (o < 0)
       s = i + 1;
     else if (o > 0)
@@ -213,358 +213,401 @@ function _t(t, e, n) {
   }
   return -(s + 1);
 }
-function Nt(t, e, n) {
-  const s = _t(t, e, n);
-  s < 0 ? t.splice(-(s + 1), 0, e) : t.splice(s, 0, e);
+function tn(t, n, e) {
+  const s = jt(t, n, e);
+  s < 0 ? t.splice(-(s + 1), 0, n) : t.splice(s, 0, n);
 }
-class qt {
+class nn {
   constructor() {
-    p(this, "buckets");
+    P(this, "buckets");
     this.buckets = [];
   }
-  addInterval(e) {
-    const n = this.buckets[e.rectangle.diagonalBucketIndex];
-    n === void 0 ? this.buckets[e.rectangle.diagonalBucketIndex] = [e] : Nt(n, e, (s, r) => s.value - r.value);
+  addInterval(n) {
+    const e = this.buckets[n.rectangle.diagonalBucketIndex];
+    e === void 0 ? this.buckets[n.rectangle.diagonalBucketIndex] = [n] : tn(e, n, (s, r) => s.value - r.value);
   }
-  removeInterval(e) {
-    const n = this.buckets[e.rectangle.diagonalBucketIndex];
-    if (n === void 0)
+  removeInterval(n) {
+    const e = this.buckets[n.rectangle.diagonalBucketIndex];
+    if (e === void 0)
       throw new Error("Interval not found");
-    n.shift();
+    e.shift();
   }
   getBottomRightHullIntervals() {
-    const e = [];
-    for (let n = this.buckets.length - 1; n >= 0; n--) {
-      const s = this.buckets[n];
+    const n = [];
+    for (let e = this.buckets.length - 1; e >= 0; e--) {
+      const s = this.buckets[e];
       if (!s === void 0) continue;
       const r = s[0];
       if (r !== void 0) {
-        if (!e.length) {
-          e.push(r);
+        if (!n.length) {
+          n.push(r);
           continue;
         }
-        for (; e.length && e[e.length - 1].value >= r.value; )
-          e.pop();
-        for (; e.length >= 2; ) {
-          const i = e[e.length - 1], o = e[e.length - 2], c = (r.value - o.value) / ((r.rectangle.diagonal - o.rectangle.diagonal) * 2);
-          if (o.value + (i.rectangle.diagonal - o.rectangle.diagonal) / 2 * c < i.value)
-            e.pop();
+        for (; n.length && n[n.length - 1].value >= r.value; )
+          n.pop();
+        for (; n.length >= 2; ) {
+          const i = n[n.length - 1], o = n[n.length - 2], f = (r.value - o.value) / ((r.rectangle.diagonal - o.rectangle.diagonal) * 2);
+          if (o.value + (i.rectangle.diagonal - o.rectangle.diagonal) / 2 * f < i.value)
+            n.pop();
           else
             break;
         }
-        e.push(r);
+        n.push(r);
       }
     }
-    return e;
+    return n;
   }
 }
-class Jt {
-  constructor(e, n) {
-    p(this, "diagonal");
-    p(this, "diagonalBucketIndex");
-    p(this, "xLength");
-    p(this, "yLength");
-    p(this, "index");
-    this.x = e, this.y = n, this.xLength = Math.pow(3, -e), this.yLength = Math.pow(3, -n), this.diagonal = Math.sqrt(
+class en {
+  constructor(n, e) {
+    P(this, "diagonal");
+    P(this, "diagonalBucketIndex");
+    P(this, "xLength");
+    P(this, "yLength");
+    P(this, "index");
+    this.x = n, this.y = e, this.xLength = Math.pow(3, -n), this.yLength = Math.pow(3, -e), this.diagonal = Math.sqrt(
       this.xLength * this.xLength + this.yLength * this.yLength
-    ), this.diagonalBucketIndex = e + n, this.index = `${e},${n}`;
+    ), this.diagonalBucketIndex = n + e, this.index = `${n},${e}`;
   }
 }
-class Qt {
-  constructor(e, n = 1e-8, s = 1e3, r = 1e-6) {
-    p(this, "rectangles");
-    p(this, "buckets");
-    p(this, "fMin");
-    p(this, "argMin");
-    p(this, "tol");
-    this.fcn = e, this.endTolerance = n, this.maxIterations = s, this.epsilon = r, this.fcn = e, this.epsilon = r, this.endTolerance = n, this.maxIterations = s, this.rectangles = /* @__PURE__ */ new Map(), this.buckets = new qt();
-    const i = [0.5, 0.5], o = this.rect(0, 0), c = this.fcn(i);
-    this.buckets.addInterval(new A(i, c, o)), this.fMin = c, this.argMin = i, this.tol = o.diagonal;
+class sn {
+  constructor(n, e = 1e-8, s = 1e3, r = 1e-6) {
+    P(this, "rectangles");
+    P(this, "buckets");
+    P(this, "fMin");
+    P(this, "argMin");
+    P(this, "tol");
+    this.fcn = n, this.endTolerance = e, this.maxIterations = s, this.epsilon = r, this.fcn = n, this.epsilon = r, this.endTolerance = e, this.maxIterations = s, this.rectangles = /* @__PURE__ */ new Map(), this.buckets = new nn();
+    const i = [0.5, 0.5], o = this.rect(0, 0), f = this.fcn(i);
+    this.buckets.addInterval(new x(i, f, o)), this.fMin = f, this.argMin = i, this.tol = o.diagonal;
   }
-  registerInterval(e) {
-    this.buckets.addInterval(e), e.value <= this.fMin && (this.fMin = e.value, this.argMin = e.center, this.tol = e.rectangle.diagonal);
+  registerInterval(n) {
+    this.buckets.addInterval(n), n.value <= this.fMin && (this.fMin = n.value, this.argMin = n.center, this.tol = n.rectangle.diagonal);
   }
-  rect(e, n) {
-    const s = `${e},${n}`;
-    return this.rectangles.has(s) || this.rectangles.set(s, new Jt(e, n)), this.rectangles.get(s);
+  rect(n, e) {
+    const s = `${n},${e}`;
+    return this.rectangles.has(s) || this.rectangles.set(s, new en(n, e)), this.rectangles.get(s);
   }
-  splitInterval(e) {
-    let n, s, r;
-    const [i, o] = e.center;
-    return e.rectangle.x <= e.rectangle.y ? (n = this.rect(e.rectangle.x + 1, e.rectangle.y), s = [i - n.xLength, o], r = [i + n.xLength, o]) : (n = this.rect(e.rectangle.x, e.rectangle.y + 1), s = [i, o - n.yLength], r = [i, o + n.yLength]), [
-      new A(s, this.fcn(s), n),
-      new A(e.center, e.value, n),
-      new A(r, this.fcn(r), n)
+  splitInterval(n) {
+    let e, s, r;
+    const [i, o] = n.center;
+    return n.rectangle.x <= n.rectangle.y ? (e = this.rect(n.rectangle.x + 1, n.rectangle.y), s = [i - e.xLength, o], r = [i + e.xLength, o]) : (e = this.rect(n.rectangle.x, n.rectangle.y + 1), s = [i, o - e.yLength], r = [i, o + e.yLength]), [
+      new x(s, this.fcn(s), e),
+      new x(n.center, n.value, e),
+      new x(r, this.fcn(r), e)
     ];
   }
   single_iteration() {
-    const e = this.buckets.getBottomRightHullIntervals();
-    for (; e.length >= 2; ) {
-      const n = e[0], s = e[1], r = (s.value - n.value) / ((s.rectangle.diagonal - n.rectangle.diagonal) / 2), i = n.value - r * s.value / 2;
+    const n = this.buckets.getBottomRightHullIntervals();
+    for (; n.length >= 2; ) {
+      const e = n[0], s = n[1], r = (s.value - e.value) / ((s.rectangle.diagonal - e.rectangle.diagonal) / 2), i = e.value - r * s.value / 2;
       if ((this.fMin - i) / Math.abs(this.fMin) < this.epsilon)
-        e.shift();
+        n.shift();
       else
         break;
     }
-    e.forEach((n) => {
-      this.buckets.removeInterval(n);
+    n.forEach((e) => {
+      this.buckets.removeInterval(e);
     });
-    for (const n of e) {
-      const [s, r, i] = this.splitInterval(n);
+    for (const e of n) {
+      const [s, r, i] = this.splitInterval(e);
       this.registerInterval(s), this.registerInterval(r), this.registerInterval(i);
     }
   }
   run() {
-    let e = 0;
-    for (; this.tol > this.endTolerance / 2 && (this.single_iteration(), e++, !(e > this.maxIterations)); )
+    let n = 0;
+    for (; this.tol > this.endTolerance / 2 && (this.single_iteration(), n++, !(n > this.maxIterations)); )
       ;
     return {
       fMin: this.fMin,
       argMin: this.argMin,
       tol: this.tol,
-      iterations: e
+      iterations: n
     };
   }
 }
-class A {
-  constructor(e, n, s) {
-    this.center = e, this.value = n, this.rectangle = s;
+class x {
+  constructor(n, e, s) {
+    this.center = n, this.value = e, this.rectangle = s;
   }
 }
-function Zt(t, e = 1e-8, n = 1e3, s = 1e-6) {
-  return new Qt(
+function rn(t, n = 1e-8, e = 1e3, s = 1e-6) {
+  return new sn(
     t,
-    e,
     n,
+    e,
     s
   ).run();
 }
-function Ht(t, e, n = 1e-9) {
-  const s = Zt((r) => {
-    const i = t.paramPoint(r[0]), o = e.paramPoint(r[1]);
-    return j(i, o);
-  }, n);
+function on(t, n, e = 1e-9) {
+  const s = rn((r) => {
+    const i = t.paramPoint(r[0]), o = n.paramPoint(r[1]);
+    return at(i, o);
+  }, e);
   return Math.sqrt(s.fMin);
 }
-function Wt(t, e) {
-  return t instanceof S && e instanceof S ? Ut(t, e) : t instanceof S && e instanceof b ? J(t, e) : t instanceof b && e instanceof S ? J(e, t) : t instanceof b && e instanceof b ? Vt(t, e) : Ht(t, e);
+function an(t, n) {
+  return t instanceof I && n instanceof I ? Xt(t, n) : t instanceof I && n instanceof E ? K(t, n) : t instanceof E && n instanceof I ? K(n, t) : t instanceof E && n instanceof E ? Kt(t, n) : on(t, n);
+}
+function ht(t) {
+  if (t instanceof B) {
+    const r = y(t.lastPoint, t.firstPoint), i = y(t.firstControlPoint, t.firstPoint), o = y(t.lastControlPoint, t.firstPoint), f = Q(r, i), c = Q(r, o);
+    if (f > 0 && c < 0 || f < 0 && c > 0) return !1;
+  }
+  const n = J(t.tangentAtFirstPoint), e = J(t.tangentAtLastPoint);
+  let s = Gt(n, e);
+  return Math.abs(Math.acos(s)) < Math.PI / 3;
+}
+function $(t) {
+  if (ht(t)) return [t];
+  const [n, e] = t.splitAtParameters([0.5]);
+  return [
+    ...$(n),
+    ...$(e)
+  ];
+}
+function j(t) {
+  return ht(t) ? [t] : t.splitAtParameters(t.getParametersOfExtrema()).flatMap($);
+}
+function cn(t) {
+  const n = t.deltaAngle, e = Math.ceil(Math.abs(n) / (Math.PI / 2)), s = n / e, r = 4 * Math.tan(s / 4) / 3, i = t.clockwise ? -1 : 1, o = Array.from(
+    { length: e + 1 },
+    (c, a) => t.firstAngle + a * s * i
+  );
+  return o.slice(0, -1).map((c, a) => [c, o[a + 1]]).map(([c, a]) => {
+    const l = Math.cos(c), p = Math.sin(c), h = Math.cos(a), d = Math.sin(a), [u, M] = t.center, m = t.minorRadius, b = t.majorRadius, k = new Ut().rotate(
+      t.tiltAngle,
+      t.center
+    ), F = (St) => k.transform(St), C = F([u + b * l, M + m * p]), z = F([
+      u + b * (l - r * p * i),
+      M + m * (p + r * l * i)
+    ]), Mt = F([
+      u + b * (h + r * d * i),
+      M + m * (d - r * h * i)
+    ]), It = F([u + b * h, M + m * d]);
+    return new B(C, It, z, Mt);
+  });
 }
-const T = 1e-8;
-function R(t, e, n = !0) {
+const N = 1e-8, gt = (t) => t.flatMap((n) => n instanceof I ? [n] : n instanceof E ? [n] : n instanceof ct ? cn(n).flatMap(
+  (e) => j(e)
+) : n instanceof ft || n instanceof B ? j(n) : [new I(n.firstPoint, n.lastPoint)]);
+function G(t, n, e = !0) {
   const s = t.map((a) => ({
-    offset: gt(a, e),
+    offset: At(a, n),
     original: a
   })), r = [];
-  let i = n ? null : s.at(-1), o = n ? s.at(-1) : null;
+  let i = e ? null : s.at(-1), o = e ? s.at(-1) : null;
   if (r.length === 1) return r;
-  const c = (a) => {
-    i ? a.offset instanceof D ? M(a.offset.firstPoint, a.offset.lastPoint) || r.push(
-      new S(a.offset.firstPoint, a.offset.lastPoint)
+  const f = (a) => {
+    i ? a.offset instanceof T ? A(a.offset.firstPoint, a.offset.lastPoint) || r.push(
+      new I(a.offset.firstPoint, a.offset.lastPoint)
     ) : r.push(a.offset) : i = a;
-  }, f = function* () {
+  }, c = function* () {
     for (const a of s.slice(0, -1))
       yield a;
     if (!i) throw new Error("Bug in the offset algorithm");
     yield i;
   };
-  for (const a of f()) {
+  for (const a of c()) {
     if (!o) {
       o = a;
       continue;
     }
-    const u = o.offset.lastPoint, m = a.offset.firstPoint;
-    if (M(u, m)) {
-      c(o), o = a;
+    const l = o.offset.lastPoint, p = a.offset.firstPoint;
+    if (A(l, p)) {
+      f(o), o = a;
       continue;
     }
     let h = [];
-    if (!(o.offset instanceof D) && !(a.offset instanceof D)) {
-      const { intersections: L, overlaps: x } = B(
+    if (!(o.offset instanceof T) && !(a.offset instanceof T)) {
+      const { intersections: m, overlaps: b } = _(
         o.offset,
         a.offset,
-        T / 100
+        N / 100
       );
       h = [
-        ...L,
-        ...x.flatMap((v) => [v.firstPoint, v.lastPoint])
+        ...m,
+        ...b.flatMap((k) => [k.firstPoint, k.lastPoint])
       ];
     }
     if (h.length > 0) {
-      let L = h[0];
+      let m = h[0];
       if (h.length > 1) {
-        const ct = o == null ? void 0 : o.original.lastPoint, U = h.map(
-          (ft) => j(ft, ct)
+        const F = o == null ? void 0 : o.original.lastPoint, C = h.map(
+          (z) => at(z, F)
         );
-        L = h[U.indexOf(Math.min(...U))];
+        m = h[C.indexOf(Math.min(...C))];
       }
-      const x = o.offset.splitAt([
-        L
-      ])[0], v = a.offset.splitAt([L]).at(-1);
-      if (!v) throw new Error("Bug in the splitting algo in offset");
-      c({
-        offset: x,
+      const b = o.offset.splitAt([
+        m
+      ])[0], k = a.offset.splitAt([m]).at(-1);
+      if (!k) throw new Error("Bug in the splitting algo in offset");
+      f({
+        offset: b,
         original: o.original
-      }), o = { offset: v, original: a.original };
+      }), o = { offset: k, original: a.original };
       continue;
     }
-    const l = o.original.lastPoint, k = yt(
-      E(m, l),
-      E(u, l)
-    ) > 0, at = new b(u, m, l, k);
-    c(o), r.push(at), o = a;
+    const d = o.original.lastPoint, u = Vt(
+      y(p, d),
+      y(l, d)
+    ) > 0, M = new E(l, p, d, u);
+    f(o), r.push(M), o = a;
   }
-  return o && c(o), r;
+  return o && f(o), r;
 }
-function nt(t) {
-  const e = /* @__PURE__ */ new Map(), n = (s, r) => {
-    const i = e.get(s) || [];
-    e.set(s, [...i, ...r]);
+function pt(t) {
+  const n = /* @__PURE__ */ new Map(), e = (s, r) => {
+    const i = n.get(s) || [];
+    n.set(s, [...i, ...r]);
   };
   return t.forEach((s, r) => {
     t.slice(r + 1).forEach((i, o) => {
-      const { intersections: c, overlaps: f } = B(s, i, T), a = [
-        ...c,
-        ...f.flatMap((u) => [u.firstPoint, u.lastPoint])
-      ].filter((u) => {
-        const m = M(u, s.firstPoint) || M(u, s.lastPoint), h = M(u, i.firstPoint) || M(u, i.lastPoint);
-        return !(m && h);
+      const { intersections: f, overlaps: c } = _(s, i, N), a = [
+        ...f,
+        ...c.flatMap((l) => [l.firstPoint, l.lastPoint])
+      ].filter((l) => {
+        const p = A(l, s.firstPoint) || A(l, s.lastPoint), h = A(l, i.firstPoint) || A(l, i.lastPoint);
+        return !(p && h);
       });
-      a.length && (n(r, a), n(o + r + 1, a));
+      a.length && (e(r, a), e(o + r + 1, a));
     });
-  }), e;
+  }), n;
 }
-function st(t, e) {
-  return e.flatMap((n, s) => {
-    if (!t.has(s)) return n;
+function dt(t, n) {
+  return n.flatMap((e, s) => {
+    if (!t.has(s)) return e;
     const r = t.get(s);
-    return r ? n.splitAt(r) : n;
+    return r ? e.splitAt(r) : e;
   });
 }
-function it(t, e, n) {
-  return t.filter((s) => !e.segments.some((i) => Wt(i, s) < Math.abs(n) - T));
+function Pt(t, n, e) {
+  return t.filter((s) => !n.segments.some((i) => an(i, s) < Math.abs(e) - N));
 }
-function F(t, e) {
-  const n = t.clockwise ? e : -e, s = R(t.segments, n);
-  if (s.length < 2) return new g();
-  const r = nt(s);
-  if (!r.size) {
-    const a = new P(s);
-    return new g([new d(a)]);
+function O(t, n) {
+  const e = t.clockwise ? n : -n, s = gt(t.segments), r = G(s, e);
+  if (r.length < 2) return new g();
+  const i = pt(r);
+  if (!i.size) {
+    const l = new S(r);
+    return new g([new w(l)]);
   }
-  const i = st(
+  const o = dt(
+    i,
+    r
+  ), f = Pt(o, t, n);
+  if (!f.length) return new g();
+  const a = rt(f).filter((l) => l.length > 1).filter((l) => A(l[0].firstPoint, l.at(-1).lastPoint)).map((l) => new S(l));
+  return a.length ? new g(a.map((l) => new w(l))) : new g();
+}
+function fn(t, n, e = "round") {
+  const s = n / 2, r = gt(t.segments), i = G(r, s, !1), o = G(
     r,
-    s
-  ), o = it(i, t, e);
-  if (!o.length) return new g();
-  const f = X(o).filter((a) => a.length > 1).filter((a) => M(a[0].firstPoint, a.at(-1).lastPoint)).map((a) => new P(a));
-  return f.length ? new g(f.map((a) => new d(a))) : new g();
-}
-function Kt(t, e, n = "round") {
-  const s = e / 2, r = R(t.segments, s, !1), i = R(t.segments, -s, !1).map(
-    (l) => l.reverse()
-  );
-  i.reverse();
-  const o = (l, k) => n === "round" ? Et(
-    l.lastPoint,
-    k.firstPoint,
-    l.tangentAtLastPoint
-  ) : new S(l.lastPoint, k.firstPoint), c = [
-    ...r,
-    o(
-      r[r.length - 1],
-      i[0]
-    ),
+    -s,
+    !1
+  ).map((u) => u.reverse());
+  o.reverse();
+  const f = (u, M) => e === "round" ? _t(
+    u.lastPoint,
+    M.firstPoint,
+    u.tangentAtLastPoint
+  ) : new I(u.lastPoint, M.firstPoint), c = [
     ...i,
-    o(
+    f(
       i[i.length - 1],
-      r[0]
+      o[0]
+    ),
+    ...o,
+    f(
+      o[o.length - 1],
+      i[0]
     )
-  ], f = nt(c);
-  if (!f.size) {
-    const l = new P(c);
-    return new g([new d(l)]);
+  ], a = pt(c);
+  if (!a.size) {
+    const u = new S(c);
+    return new g([new w(u)]);
   }
-  const a = st(
-    f,
+  const l = dt(
+    a,
     c
-  ), u = it(a, t, s);
-  if (!u.length) return new g();
-  const h = X(u).filter((l) => l.length > 1).filter((l) => M(l[0].firstPoint, l.at(-1).lastPoint)).map((l) => new P(l));
-  return h.length ? new g(h.map((l) => new d(l))) : new g();
-}
-function Xt(t, e) {
-  const n = t.map((s) => {
-    const r = y(
-      s.holes.map((i) => F(i, e))
+  ), p = Pt(l, t, s);
+  if (!p.length) return new g();
+  const d = rt(p).filter((u) => u.length > 1).filter((u) => A(u[0].firstPoint, u.at(-1).lastPoint)).map((u) => new S(u));
+  return d.length ? new g(d.map((u) => new w(u))) : new g();
+}
+function ln(t, n) {
+  const e = t.map((s) => {
+    const r = D(
+      s.holes.map((i) => O(i, n))
     );
-    return et(F(s.contour, e), r);
+    return ut(O(s.contour, n), r);
   });
-  return y(n);
+  return D(e);
 }
-function Yt(t, e) {
-  const n = Math.abs(e / 2), s = t.map(
-    (r) => y(
-      r.allLoops.map((i) => et(F(i, n), F(i, -n)))
+function un(t, n) {
+  const e = Math.abs(n / 2), s = t.map(
+    (r) => D(
+      r.allLoops.map((i) => ut(O(i, e), O(i, -e)))
     )
   );
-  return y(s);
+  return D(s);
 }
-function fe(t, e) {
-  return Xt(I(t), e);
+function bn(t, n) {
+  return ln(v(t), n);
 }
-function le(t, e, { endCap: n = "round" } = {}) {
-  return t instanceof C ? Kt(t, e, n) : Yt(I(t), e);
+function Ln(t, n, { endCap: e = "round" } = {}) {
+  return t instanceof R ? fn(t, n, e) : un(v(t), n);
 }
-function Q(t) {
+function tt(t) {
   if (t instanceof g)
-    return Rt(t);
-  if (t instanceof d)
-    return Ot(t);
-  if (t instanceof P)
-    return `<path d="${Bt(t)}" />`;
-  if (t instanceof C)
-    return `<path d="${$t(t)}" />`;
-  if (It(t))
-    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${Gt(
+    return Nt(t);
+  if (t instanceof w)
+    return Jt(t);
+  if (t instanceof S)
+    return `<path d="${Qt(t)}" />`;
+  if (t instanceof R)
+    return `<path d="${Zt(t)}" />`;
+  if (Dt(t))
+    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${Ht(
       t
     )}" />`;
   throw new Error("Unknown shape type");
 }
-const Z = (t) => "shape" in t ? t.shape : t, H = (t, e) => {
-  if (!("shape" in t)) return e;
-  const { color: n } = t;
-  return n ? `<g stroke="${n}">${e}</g>` : e;
-}, W = (t) => new Ft(t.xMin, -t.yMax, t.xMax, -t.yMin);
-function ue(t, {
-  margin: e = 1,
-  unit: n = null,
+const nt = (t) => "shape" in t ? t.shape : t, et = (t, n) => {
+  if (!("shape" in t)) return n;
+  const { color: e } = t;
+  return e ? `<g stroke="${e}">${n}</g>` : n;
+}, st = (t) => new qt(t.xMin, -t.yMax, t.xMax, -t.yMin);
+function An(t, {
+  margin: n = 1,
+  unit: e = null,
   viewBox: s
 } = {}) {
   if (Array.isArray(t)) {
-    const i = t.map((f) => Z(f).mirror()), o = i.map((f, a) => H(t[a], Q(f))).join(`
-`), c = i.slice(1).reduce((f, a) => f.merge(a.boundingBox), i[0].boundingBox);
-    return z(o, s ? W(s) : c, e, n);
+    const i = t.map((c) => nt(c).mirror()), o = i.map((c, a) => et(t[a], tt(c))).join(`
+`), f = i.slice(1).reduce((c, a) => c.merge(a.boundingBox), i[0].boundingBox);
+    return Z(o, s ? st(s) : f, n, e);
   }
-  const r = Z(t).mirror();
-  return z(
-    H(t, Q(r)),
-    s ? W(s) : r.boundingBox,
-    e,
-    n
+  const r = nt(t).mirror();
+  return Z(
+    et(t, tt(r)),
+    s ? st(s) : r.boundingBox,
+    n,
+    e
   );
 }
-const rt = (t) => {
+const mt = (t) => {
   if (t.type === "LINE")
-    return new S(t.firstPoint, t.lastPoint);
+    return new I(t.firstPoint, t.lastPoint);
   if (t.type === "ARC")
-    return new b(
+    return new E(
       t.firstPoint,
       t.lastPoint,
       t.center,
       t.clockwise
     );
   if (t.type === "ELLIPSE_ARC")
-    return new Ct(
+    return new ct(
       t.firstPoint,
       t.lastPoint,
       t.center,
@@ -575,66 +618,66 @@ const rt = (t) => {
       { angleUnits: "rad" }
     );
   if (t.type === "QUADRATIC_BEZIER")
-    return new xt(
+    return new ft(
       t.firstPoint,
       t.lastPoint,
       t.controlPoint
     );
   if (t.type === "CUBIC_BEZIER")
-    return new Dt(
+    return new B(
       t.firstPoint,
       t.lastPoint,
       t.firstControlPoint,
       t.lastControlPoint
     );
   throw new Error("Unknown segment type");
-}, O = (t) => {
-  const e = t.segments.map(rt);
-  return new P(e);
-}, ot = (t) => {
-  const e = O(t.contour), n = t.holes.map(O);
-  return new d(e, n);
-}, jt = (t) => {
-  const e = t.figures.map(ot);
-  return new g(e);
+}, U = (t) => {
+  const n = t.segments.map(mt);
+  return new S(n);
+}, wt = (t) => {
+  const n = U(t.contour), e = t.holes.map(U);
+  return new w(n, e);
+}, hn = (t) => {
+  const n = t.figures.map(wt);
+  return new g(n);
 };
-function ge(t) {
+function vn(t) {
   if (t.type === "DIAGRAM")
-    return jt(t);
+    return hn(t);
   if (t.type === "FIGURE")
-    return ot(t);
+    return wt(t);
   if (t.type === "LOOP")
-    return O(t);
+    return U(t);
   if (t.type === "LINE" || t.type === "ARC" || t.type === "ELLIPSE_ARC" || t.type === "CUBIC_BEZIER")
-    return rt(t);
+    return mt(t);
   throw new Error("Unknown shape type");
 }
-const K = Math.PI / 180, te = 180 / Math.PI;
-function he(t, e) {
-  const n = Math.cos(e * K) * t, s = Math.sin(e * K) * t;
-  return [n, s];
+const it = Math.PI / 180, gn = 180 / Math.PI;
+function kn(t, n) {
+  const e = Math.cos(n * it) * t, s = Math.sin(n * it) * t;
+  return [e, s];
 }
-function pe([t, e]) {
-  const n = Math.sqrt(t * t + e * e), s = Math.atan2(e, t) * te;
-  return [n, s];
+function En([t, n]) {
+  const e = Math.sqrt(t * t + n * n), s = Math.atan2(n, t) * gn;
+  return [e, s];
 }
 export {
-  K as DEG2RAD,
-  te as RAD2DEG,
-  pe as cartesianToPolar,
-  ce as confineStrand,
-  et as cut,
-  Pe as draw,
-  ae as eraseStrand,
-  Me as exportJSON,
-  ue as exportSVG,
-  Tt as fuse,
-  y as fuseAll,
-  ge as importJSON,
-  oe as intersect,
-  fe as offset,
-  le as outlineStroke,
-  he as polarToCartesian,
-  Q as svgBody
+  it as DEG2RAD,
+  gn as RAD2DEG,
+  En as cartesianToPolar,
+  Sn as confineStrand,
+  ut as cut,
+  Cn as draw,
+  In as eraseStrand,
+  Dn as exportJSON,
+  An as exportSVG,
+  Wt as fuse,
+  D as fuseAll,
+  vn as importJSON,
+  Mn as intersect,
+  bn as offset,
+  Ln as outlineStroke,
+  kn as polarToCartesian,
+  tt as svgBody
 };
 //# sourceMappingURL=pantograph.js.map