pantograph2d 0.5.0 → 0.6.0

package/dist/pantograph.js

@@ -1,169 +1,169 @@
-import { o as ct, D as b } from "./draw-cd61ec6b.js";
-import { d as _t } from "./draw-cd61ec6b.js";
-import { F as g, L as d, D as p, f as O, r as ut, z as lt, s as pt, a as Pt, c as gt, i as mt, l as wt, d as h, b as dt, p as ht, n as B, e as v, g as St, h as At, j as Mt, k as $t, m as w, A as S, o as H, q as A, t as Lt, u as Ft, v as vt, S as K } from "./Diagram-9915ed5e.js";
-import { w as tn } from "./Diagram-9915ed5e.js";
-function M(t) {
-  if (t instanceof g)
-    return [t];
-  if (t instanceof d)
-    return [new g(t)];
+import { o as ht, D } from "./draw-a830827a.js";
+import { d as fn } from "./draw-a830827a.js";
+import { F as p, L as P, D as h, f as C, r as gt, z as pt, s as dt, a as wt, c as Pt, i as mt, S as y, l as Mt, d as m, b as vt, p as St, n as K, e as $, g as It, h as Lt, j as kt, k as At, m as Q, o as w, A as M, q as j, t as v, u as $t, v as bt, E as O, R as Et } from "./Diagram-d848c815.js";
+import { w as un } from "./Diagram-d848c815.js";
+function S(t) {
   if (t instanceof p)
+    return [t];
+  if (t instanceof P)
+    return [new p(t)];
+  if (t instanceof h)
     return t.figures;
   throw new Error("Unknown shape");
 }
-function Q(t, n, e = 1e-9) {
-  let r = [];
-  const o = [], s = new Array(n.segments.length).fill(0).map(() => []);
-  n.segments.forEach((a, u) => {
-    t.segments.forEach((f) => {
-      const { intersections: l, overlaps: m } = O(
+function tt(t, n, e = 1e-9) {
+  let s = [];
+  const r = [], i = new Array(n.segments.length).fill(0).map(() => []);
+  n.segments.forEach((c, f) => {
+    t.segments.forEach((a) => {
+      const { intersections: u, overlaps: d } = C(
+        c,
         a,
-        f,
         e
       );
-      r.push(...l), s[u].push(...l), o.push(...m);
-      const P = m.flatMap((c) => [
-        c.firstPoint,
-        c.lastPoint
+      s.push(...u), i[f].push(...u), r.push(...d);
+      const g = d.flatMap((l) => [
+        l.firstPoint,
+        l.lastPoint
       ]);
-      r.push(...P), s[u].push(...P);
+      s.push(...g), i[f].push(...g);
     });
-  }), r = ut(r, e);
-  const i = lt([n.segments, s]).flatMap(([a, u]) => u.length ? a.splitAt(u) : [a]);
+  }), s = gt(s, e);
+  const o = pt([n.segments, i]).flatMap(([c, f]) => f.length ? c.splitAt(f) : [c]);
   return Array.from(
-    pt(
-      i,
-      r,
-      o
+    dt(
+      o,
+      s,
+      r
     )
   );
 }
-function C(t, n, e = !1) {
-  return Q(n, t).filter((o) => {
-    const s = o.segments[0].midPoint;
-    return n.onStroke(s) ? !e : !n.contains(s);
+function G(t, n, e = !1) {
+  return tt(n, t).filter((r) => {
+    const i = r.segments[0].midPoint;
+    return n.onStroke(i) ? !e : !n.contains(i);
   });
 }
-function G(t, n, e = !1) {
-  return Q(n, t).filter((o) => {
-    const s = o.segments[0].midPoint;
-    return n.onStroke(s) ? !e : n.contains(s);
+function T(t, n, e = !1) {
+  return tt(n, t).filter((r) => {
+    const i = r.segments[0].midPoint;
+    return n.onStroke(i) ? !e : n.contains(i);
   });
 }
-function R(t, n, e = !1) {
-  const r = C(
+function z(t, n, e = !1) {
+  const s = G(
     t,
     n.contour,
     e
-  ), o = n.holes.flatMap(
-    (s) => G(t, s, e)
+  ), r = n.holes.flatMap(
+    (i) => T(t, i, e)
   );
-  return [...r, ...o];
+  return [...s, ...r];
 }
-function U(t, n, e = !1) {
-  let r = G(
+function q(t, n, e = !1) {
+  let s = T(
     t,
     n.contour,
     e
   );
-  return n.holes.forEach((o) => {
-    r = r.flatMap(
-      (s) => C(s, o, e)
+  return n.holes.forEach((r) => {
+    s = s.flatMap(
+      (i) => G(i, r, e)
     );
-  }), r;
+  }), s;
 }
-function Et(t, n) {
-  return new p(
-    Pt(M(t), M(n))
+function yt(t, n) {
+  return new h(
+    wt(S(t), S(n))
   );
 }
-function E(t) {
+function b(t) {
   return t.reduce(
-    (n, e) => Et(n, e),
-    new p()
+    (n, e) => yt(n, e),
+    new h()
   );
 }
-function _(t, n) {
-  return new p(
-    gt(M(t), M(n))
+function nt(t, n) {
+  return new h(
+    Pt(S(t), S(n))
   );
 }
-function Nt(t, n) {
-  return new p(
-    mt(M(t), M(n))
+function Kt(t, n) {
+  return new h(
+    mt(S(t), S(n))
   );
 }
-function qt(t, n, e = !0) {
-  if (n instanceof d)
-    return C(t, n, e);
-  if (n instanceof g)
-    return R(t, n, e);
-  let r = [t];
-  return n.figures.forEach((o) => {
-    r = r.flatMap((s) => R(s, o, e));
-  }), r;
-}
-function Jt(t, n, e = !1) {
-  if (n instanceof d)
+function Qt(t, n, e = !0) {
+  if (n instanceof P)
     return G(t, n, e);
-  if (n instanceof g)
-    return U(t, n, e);
-  let r = [t];
-  return n.figures.forEach((o) => {
-    r = r.flatMap((s) => U(s, o, e));
-  }), r;
-}
-function z(t) {
+  if (n instanceof p)
+    return z(t, n, e);
+  let s = [new y([...t.segments])];
+  return n.figures.forEach((r) => {
+    s = s.flatMap((i) => z(i, r, e));
+  }), s;
+}
+function jt(t, n, e = !1) {
+  if (n instanceof P)
+    return T(t, n, e);
+  if (n instanceof p)
+    return q(t, n, e);
+  let s = [new y([...t.segments])];
+  return n.figures.forEach((r) => {
+    s = s.flatMap((i) => q(i, r, e));
+  }), s;
+}
+function N(t) {
   return t < 0 ? "before" : t > 1 ? "after" : "between";
 }
-const N = (t, n, e) => {
+const _ = (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 yt(t, n) {
-  const e = wt(t, n);
+function Ft(t, n) {
+  const e = Mt(t, n);
   if (e === "parallel")
     return Math.min(
       t.distanceFrom(n.firstPoint),
       t.distanceFrom(n.lastPoint)
     );
-  const { intersectionParam1: r, intersectionParam2: o } = e, s = z(r), i = z(o);
-  if (s === "between" && i === "between")
+  const { intersectionParam1: s, intersectionParam2: r } = e, i = N(s), o = N(r);
+  if (i === "between" && o === "between")
     return 0;
-  if (s === "between" && i !== "between")
-    return N(t, n, i);
-  if (i === "between" && s !== "between")
-    return N(n, t, s);
-  if (s === "before" && i === "before")
-    return h(t.firstPoint, n.firstPoint);
-  if (s === "after" && i === "after")
-    return h(t.lastPoint, n.lastPoint);
-  if (s === "before" && i === "after")
-    return h(t.firstPoint, n.lastPoint);
-  if (s === "after" && i === "before")
-    return h(t.lastPoint, n.firstPoint);
+  if (i === "between" && o !== "between")
+    return _(t, n, o);
+  if (o === "between" && i !== "between")
+    return _(n, t, i);
+  if (i === "before" && o === "before")
+    return m(t.firstPoint, n.firstPoint);
+  if (i === "after" && o === "after")
+    return m(t.lastPoint, n.lastPoint);
+  if (i === "before" && o === "after")
+    return m(t.firstPoint, n.lastPoint);
+  if (i === "after" && o === "before")
+    return m(t.lastPoint, n.firstPoint);
   throw new Error("Invalid position");
 }
-function q(t, n) {
-  if (dt(t, n).length > 0)
+function J(t, n) {
+  if (vt(t, n).length > 0)
     return 0;
-  const e = ht(t, n.center);
+  const e = St(t, n.center);
   if (t.isOnSegment(e)) {
-    const r = h(e, n.center);
-    if (Math.abs(r - n.radius) < t.precision && n.isOnSegment(e))
+    const s = m(e, n.center);
+    if (Math.abs(s - n.radius) < t.precision && n.isOnSegment(e))
       return 0;
-    if (r - n.radius > t.precision) {
-      const o = B(
-        v(e, n.center)
-      ), s = St(
+    if (s - n.radius > t.precision) {
+      const r = K(
+        $(e, n.center)
+      ), i = It(
         n.center,
-        At(o, n.radius)
+        Lt(r, n.radius)
       );
-      if (n.isOnSegment(s))
-        return h(s, e);
+      if (n.isOnSegment(i))
+        return m(i, e);
     }
   }
   return Math.min(
@@ -173,260 +173,390 @@ function q(t, n) {
     t.distanceFrom(n.lastPoint)
   );
 }
-const It = (t, n) => {
+const Dt = (t, n) => {
   const e = t.angleToParam(n.firstAngle);
   if (t.isValidParameter(e))
     return !0;
-  const r = t.angleToParam(n.lastAngle);
-  return !!t.isValidParameter(r);
+  const s = t.angleToParam(n.lastAngle);
+  return !!t.isValidParameter(s);
 };
-function bt(t, n) {
-  if (Mt(t, n, !0).length > 0)
+function xt(t, n) {
+  if (kt(t, n, !0).length > 0)
     return 0;
-  const e = h(t.center, n.center);
-  if (e < t.precision && It(t, n))
+  const e = m(t.center, n.center);
+  if (e < t.precision && Dt(t, n))
     return Math.abs(t.radius - n.radius);
-  const r = B(v(n.center, t.center)), o = e - Math.abs(t.radius - n.radius) < t.precision;
-  let s = $t(r);
-  o && n.radius > t.radius && (s += Math.PI);
-  const i = o ? s : s + Math.PI, a = t.angleToParam(s), u = n.angleToParam(i);
-  return t.isValidParameter(a) && n.isValidParameter(u) ? h(t.paramPoint(a), n.paramPoint(u)) : Math.min(
+  const s = K($(n.center, t.center)), r = e - Math.abs(t.radius - n.radius) < t.precision;
+  let i = At(s);
+  r && n.radius > t.radius && (i += Math.PI);
+  const o = r ? i : i + Math.PI, c = t.angleToParam(i), f = n.angleToParam(o);
+  return t.isValidParameter(c) && n.isValidParameter(f) ? m(t.paramPoint(c), n.paramPoint(f)) : Math.min(
     t.distanceFrom(n.firstPoint),
     t.distanceFrom(n.lastPoint),
     n.distanceFrom(t.firstPoint),
     n.distanceFrom(t.lastPoint)
   );
 }
-function kt(t, n) {
-  if (t instanceof w && n instanceof w)
-    return yt(t, n);
-  if (t instanceof w && n instanceof S)
-    return q(t, n);
-  if (t instanceof S && n instanceof w)
-    return q(n, t);
-  if (t instanceof S && n instanceof S)
-    return bt(t, n);
-  throw new Error("Not implemented");
+function Rt(t, n, e) {
+  let s = 0, r = t.length - 1;
+  for (; s <= r; ) {
+    const i = Math.floor((s + r) / 2), o = e(t[i], n);
+    if (o < 0)
+      s = i + 1;
+    else if (o > 0)
+      r = i - 1;
+    else
+      return i;
+  }
+  return -(s + 1);
+}
+function Ct(t, n, e) {
+  const s = Rt(t, n, e);
+  s < 0 ? t.splice(-(s + 1), 0, n) : t.splice(s, 0, n);
+}
+class Ot {
+  constructor() {
+    this.buckets = [];
+  }
+  addInterval(n) {
+    const e = this.buckets[n.rectangle.diagonalBucketIndex];
+    e === void 0 ? this.buckets[n.rectangle.diagonalBucketIndex] = [n] : Ct(e, n, (s, r) => s.value - r.value);
+  }
+  removeInterval(n) {
+    const e = this.buckets[n.rectangle.diagonalBucketIndex];
+    if (e === void 0)
+      throw new Error("Interval not found");
+    e.shift();
+  }
+  getBottomRightHullIntervals() {
+    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 (!n.length) {
+          n.push(r);
+          continue;
+        }
+        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], 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)
+            n.pop();
+          else
+            break;
+        }
+        n.push(r);
+      }
+    }
+    return n;
+  }
+}
+class Gt {
+  constructor(n, e) {
+    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 = n + e, this.index = `${n},${e}`;
+  }
+}
+class Tt {
+  constructor(n, e = 1e-8, s = 1e3, r = 1e-6) {
+    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 Ot();
+    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;
+  }
+  registerInterval(n) {
+    this.buckets.addInterval(n), n.value <= this.fMin && (this.fMin = n.value, this.argMin = n.center, this.tol = n.rectangle.diagonal);
+  }
+  rect(n, e) {
+    const s = `${n},${e}`;
+    return this.rectangles.has(s) || this.rectangles.set(s, new Gt(n, e)), this.rectangles.get(s);
+  }
+  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 A(s, this.fcn(s), e),
+      new A(n.center, n.value, e),
+      new A(r, this.fcn(r), e)
+    ];
+  }
+  single_iteration() {
+    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)
+        n.shift();
+      else
+        break;
+    }
+    n.forEach((e) => {
+      this.buckets.removeInterval(e);
+    });
+    for (const e of n) {
+      const [s, r, i] = this.splitInterval(e);
+      this.registerInterval(s), this.registerInterval(r), this.registerInterval(i);
+    }
+  }
+  run() {
+    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: n
+    };
+  }
+}
+class A {
+  constructor(n, e, s) {
+    this.center = n, this.value = e, this.rectangle = s;
+  }
+}
+function Vt(t, n = 1e-8, e = 1e3, s = 1e-6) {
+  return new Tt(
+    t,
+    n,
+    e,
+    s
+  ).run();
+}
+function Ut(t, n, e = 1e-9) {
+  const s = Vt((r) => {
+    const i = t.paramPoint(r[0]), o = n.paramPoint(r[1]);
+    return Q(i, o);
+  }, e);
+  return Math.sqrt(s.fMin);
+}
+function Bt(t, n) {
+  return t instanceof w && n instanceof w ? Ft(t, n) : t instanceof w && n instanceof M ? J(t, n) : t instanceof M && n instanceof w ? J(n, t) : t instanceof M && n instanceof M ? xt(t, n) : Ut(t, n);
 }
 const V = 1e-8;
-function k(t, n, e = !0) {
-  const r = t.map((f) => ({
-    offset: ct(f, n),
-    original: f
-  })), o = [];
-  let s = e ? null : r.at(-1), i = e ? r.at(-1) : null;
-  if (o.length === 1)
-    return o;
-  const a = (f) => {
-    s ? f.offset instanceof b ? A(f.offset.firstPoint, f.offset.lastPoint) || o.push(
-      new w(f.offset.firstPoint, f.offset.lastPoint)
-    ) : o.push(f.offset) : s = f;
-  }, u = function* () {
-    for (const f of r.slice(0, -1))
-      yield f;
-    if (!s)
+function x(t, n, e = !0) {
+  const s = t.map((a) => ({
+    offset: ht(a, n),
+    original: a
+  })), r = [];
+  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 ? v(a.offset.firstPoint, a.offset.lastPoint) || r.push(
+      new w(a.offset.firstPoint, a.offset.lastPoint)
+    ) : r.push(a.offset) : i = a;
+  }, f = function* () {
+    for (const a of s.slice(0, -1))
+      yield a;
+    if (!i)
       throw new Error("Bug in the offset algorithm");
-    yield s;
+    yield i;
   };
-  for (const f of u()) {
-    if (!i) {
-      i = f;
+  for (const a of f()) {
+    if (!o) {
+      o = a;
       continue;
     }
-    const l = i.offset.lastPoint, m = f.offset.firstPoint;
-    if (A(l, m)) {
-      a(i), i = f;
+    const u = o.offset.lastPoint, d = a.offset.firstPoint;
+    if (v(u, d)) {
+      c(o), o = a;
       continue;
     }
-    let P = [];
-    if (!(i.offset instanceof b) && !(f.offset instanceof b)) {
-      const { intersections: $, overlaps: I } = O(
-        i.offset,
-        f.offset,
+    let g = [];
+    if (!(o.offset instanceof D) && !(a.offset instanceof D)) {
+      const { intersections: I, overlaps: F } = C(
+        o.offset,
+        a.offset,
         V / 100
       );
-      P = [
-        ...$,
-        ...I.flatMap((L) => [L.firstPoint, L.lastPoint])
+      g = [
+        ...I,
+        ...F.flatMap((L) => [L.firstPoint, L.lastPoint])
       ];
     }
-    if (P.length > 0) {
-      let $ = P[0];
-      if (P.length > 1) {
-        const ft = i == null ? void 0 : i.original.lastPoint, T = P.map(
-          (at) => Lt(at, ft)
+    if (g.length > 0) {
+      let I = g[0];
+      if (g.length > 1) {
+        const lt = o == null ? void 0 : o.original.lastPoint, B = g.map(
+          (ut) => Q(ut, lt)
         );
-        $ = P[T.indexOf(Math.min(...T))];
+        I = g[B.indexOf(Math.min(...B))];
       }
-      const I = i.offset.splitAt([
-        $
-      ])[0], L = f.offset.splitAt([$]).at(-1);
+      const F = o.offset.splitAt([
+        I
+      ])[0], L = a.offset.splitAt([I]).at(-1);
       if (!L)
         throw new Error("Bug in the splitting algo in offset");
-      a({
-        offset: I,
-        original: i.original
-      }), i = { offset: L, original: f.original };
+      c({
+        offset: F,
+        original: o.original
+      }), o = { offset: L, original: a.original };
       continue;
     }
-    const c = i.original.lastPoint, F = vt(
-      v(m, c),
-      v(l, c)
-    ) > 0, it = new S(l, m, c, F);
-    a(i), o.push(it), i = f;
+    const l = o.original.lastPoint, k = bt(
+      $(d, l),
+      $(u, l)
+    ) > 0, ft = new M(u, d, l, k);
+    c(o), r.push(ft), o = a;
   }
-  return a(i), o;
+  return o && c(o), r;
 }
-function j(t) {
-  const n = /* @__PURE__ */ new Map(), e = (r, o) => {
-    const s = n.get(r) || [];
-    n.set(r, [...s, ...o]);
+function et(t) {
+  const n = /* @__PURE__ */ new Map(), e = (s, r) => {
+    const i = n.get(s) || [];
+    n.set(s, [...i, ...r]);
   };
-  return t.forEach((r, o) => {
-    t.slice(o + 1).forEach((s, i) => {
-      const { intersections: a, overlaps: u } = O(r, s, V), f = [
-        ...a,
-        ...u.flatMap((l) => [l.firstPoint, l.lastPoint])
-      ].filter((l) => {
-        const m = A(l, r.firstPoint) || A(l, r.lastPoint), P = A(l, s.firstPoint) || A(l, s.lastPoint);
-        return !(m && P);
+  return t.forEach((s, r) => {
+    t.slice(r + 1).forEach((i, o) => {
+      const { intersections: c, overlaps: f } = C(s, i, V), a = [
+        ...c,
+        ...f.flatMap((u) => [u.firstPoint, u.lastPoint])
+      ].filter((u) => {
+        const d = v(u, s.firstPoint) || v(u, s.lastPoint), g = v(u, i.firstPoint) || v(u, i.lastPoint);
+        return !(d && g);
       });
-      f.length && (e(o, f), e(i + o + 1, f));
+      a.length && (e(r, a), e(o + r + 1, a));
     });
   }), n;
 }
-function tt(t, n) {
-  return n.flatMap((e, r) => {
-    if (!t.has(r))
+function st(t, n) {
+  return n.flatMap((e, s) => {
+    if (!t.has(s))
       return e;
-    const o = t.get(r);
-    return o ? e.splitAt(o) : e;
+    const r = t.get(s);
+    return r ? e.splitAt(r) : e;
   });
 }
-function nt(t, n, e) {
-  return t.filter((r) => !n.segments.some((s) => kt(s, r) < Math.abs(e) - V));
-}
-function y(t, n) {
-  const e = t.clockwise ? n : -n, r = k(t.segments, e);
-  if (r.length < 2)
-    return new p();
-  const o = j(r);
-  if (!o.size) {
-    const f = new d(r);
-    return new p([new g(f)]);
+function it(t, n, e) {
+  return t.filter((s) => !n.segments.some((i) => Bt(i, s) < Math.abs(e) - V));
+}
+function E(t, n) {
+  const e = t.clockwise ? n : -n, s = x(t.segments, e);
+  if (s.length < 2)
+    return new h();
+  const r = et(s);
+  if (!r.size) {
+    const a = new P(s);
+    return new h([new p(a)]);
   }
-  const s = tt(
-    o,
-    r
-  ), i = nt(s, t, n);
-  if (!i.length)
-    return new p();
-  const u = H(i).filter((f) => f.length > 1).filter((f) => A(f[0].firstPoint, f.at(-1).lastPoint)).map((f) => new d(f));
-  return u.length ? new p(u.map((f) => new g(f))) : new p();
-}
-function Dt(t, n, e = "round") {
-  const r = n / 2, o = k(t.segments, r, !1), s = k(t.segments, -r, !1).map(
-    (c) => c.reverse()
+  const i = st(
+    r,
+    s
+  ), o = it(i, t, n);
+  if (!o.length)
+    return new h();
+  const f = j(o).filter((a) => a.length > 1).filter((a) => v(a[0].firstPoint, a.at(-1).lastPoint)).map((a) => new P(a));
+  return f.length ? new h(f.map((a) => new p(a))) : new h();
+}
+function zt(t, n, e = "round") {
+  const s = n / 2, r = x(t.segments, s, !1), i = x(t.segments, -s, !1).map(
+    (l) => l.reverse()
   );
-  s.reverse();
-  const i = (c, F) => e === "round" ? Ft(
-    c.lastPoint,
-    F.firstPoint,
-    c.tangentAtLastPoint
-  ) : new w(c.lastPoint, F.firstPoint), a = [
-    ...o,
-    i(
-      o[o.length - 1],
-      s[0]
+  i.reverse();
+  const o = (l, k) => e === "round" ? $t(
+    l.lastPoint,
+    k.firstPoint,
+    l.tangentAtLastPoint
+  ) : new w(l.lastPoint, k.firstPoint), c = [
+    ...r,
+    o(
+      r[r.length - 1],
+      i[0]
     ),
-    ...s,
-    i(
-      s[s.length - 1],
-      o[0]
+    ...i,
+    o(
+      i[i.length - 1],
+      r[0]
     )
-  ], u = j(a);
-  if (!u.size) {
-    const c = new d(a);
-    return new p([new g(c)]);
+  ], f = et(c);
+  if (!f.size) {
+    const l = new P(c);
+    return new h([new p(l)]);
   }
-  const f = tt(
-    u,
-    a
-  ), l = nt(f, t, r);
-  if (!l.length)
-    return new p();
-  const P = H(l).filter((c) => c.length > 1).filter((c) => A(c[0].firstPoint, c.at(-1).lastPoint)).map((c) => new d(c));
-  return P.length ? new p(P.map((c) => new g(c))) : new p();
-}
-function Ot(t, n) {
-  const e = t.map((r) => {
-    const o = E(
-      r.holes.map((s) => y(s, n))
+  const a = st(
+    f,
+    c
+  ), u = it(a, t, s);
+  if (!u.length)
+    return new h();
+  const g = j(u).filter((l) => l.length > 1).filter((l) => v(l[0].firstPoint, l.at(-1).lastPoint)).map((l) => new P(l));
+  return g.length ? new h(g.map((l) => new p(l))) : new h();
+}
+function qt(t, n) {
+  const e = t.map((s) => {
+    const r = b(
+      s.holes.map((i) => E(i, n))
     );
-    return _(y(r.contour, n), o);
+    return nt(E(s.contour, n), r);
   });
-  return E(e);
+  return b(e);
 }
-function Ct(t, n) {
-  const e = Math.abs(n / 2), r = t.map(
-    (o) => E(
-      o.allLoops.map((s) => _(y(s, e), y(s, -e)))
+function Nt(t, n) {
+  const e = Math.abs(n / 2), s = t.map(
+    (r) => b(
+      r.allLoops.map((i) => nt(E(i, e), E(i, -e)))
     )
   );
-  return E(r);
+  return b(s);
 }
-function Wt(t, n) {
-  return Ot(M(t), n);
+function tn(t, n) {
+  return qt(S(t), n);
 }
-function Xt(t, n, { endCap: e = "round" } = {}) {
-  return t instanceof K ? Dt(t, n, e) : Ct(M(t), n);
+function nn(t, n, { endCap: e = "round" } = {}) {
+  return t instanceof y ? zt(t, n, e) : Nt(S(t), n);
 }
-function x(t) {
+function U(t) {
   if (t instanceof w)
     return `L ${t.lastPoint.join(" ")}`;
-  if (t instanceof S)
+  if (t instanceof M)
     return `A ${t.radius} ${t.radius} 0 ${t.angularLength > Math.PI ? "1" : "0"} ${t.clockwise ? "0" : "1"} ${t.lastPoint.join(" ")}`;
+  if (t instanceof O)
+    return `A ${t.majorRadius} ${t.minorRadius} ${t.tiltAngle * Et} ${t.deltaAngle > Math.PI ? "1" : "0"} ${t.clockwise ? "0" : "1"} ${t.lastPoint.join(" ")}`;
   throw new Error("Unknown segment type");
 }
-function et(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(x).join(" ");
+function rt(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(U).join(" ");
   return `${n} ${e} Z`;
 }
-function rt(t) {
-  return `<path d="${t.allLoops.map(et).join(" ")}" />`;
+function ot(t) {
+  return `<path d="${t.allLoops.map(rt).join(" ")}" />`;
 }
-function Gt(t) {
+function _t(t) {
   return `<g>
-  ${t.figures.map(rt).join(`
+  ${t.figures.map(ot).join(`
 `)}
 </g>`;
 }
-function Vt(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(x).join(" ");
+function Jt(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(U).join(" ");
   return `${n} ${e}`;
 }
-function xt(t, n = 1) {
-  const e = t.xMin - n, r = t.yMin - n;
-  return `${e} ${r} ${t.width + 2 * n} ${t.height + 2 * n}`;
+function Ht(t, n = 1) {
+  const e = t.xMin - n, s = t.yMin - n;
+  return `${e} ${s} ${t.width + 2 * n} ${t.height + 2 * n}`;
 }
-function J(t, n, e = 1, r) {
-  const o = xt(n, e), s = r ? `width="${n.width + 2 * e}${r}" height="${n.height + 2 * e}${r}"` : "";
+function H(t, n, e = 1, s) {
+  const r = Ht(n, e), i = s ? `width="${n.width + 2 * e}${s}" height="${n.height + 2 * e}${s}"` : "";
   return `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${o}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke" ${s}>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${r}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke" ${i}>
     ${t}
 </svg>`;
 }
 function W(t) {
+  if (t instanceof h)
+    return _t(t);
   if (t instanceof p)
-    return Gt(t);
-  if (t instanceof g)
-    return rt(t);
-  if (t instanceof d)
-    return `<path d="${et(t)}" />`;
-  if (t instanceof K)
-    return `<path d="${Vt(t)}" />`;
-  if (t instanceof S || t instanceof w)
-    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${x(
+    return ot(t);
+  if (t instanceof P)
+    return `<path d="${rt(t)}" />`;
+  if (t instanceof y)
+    return `<path d="${Jt(t)}" />`;
+  if (t instanceof M || t instanceof w || t instanceof O)
+    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${U(
       t
     )}" />`;
   throw new Error("Unknown shape type");
@@ -437,81 +567,92 @@ const X = (t) => "shape" in t ? t.shape : t, Y = (t, n) => {
   const { color: e } = t;
   return e ? `<g stroke="${e}">${n}</g>` : n;
 };
-function Yt(t, {
+function en(t, {
   margin: n = 1,
   unit: e = null
 } = {}) {
   if (Array.isArray(t)) {
-    const o = t.map((a) => X(a).mirror()), s = o.map((a, u) => Y(t[u], W(a))).join(`
-`), i = o.slice(1).reduce((a, u) => a.merge(u.boundingBox), o[0].boundingBox);
-    return J(s, i, n, e);
+    const r = t.map((c) => X(c).mirror()), i = r.map((c, f) => Y(t[f], W(c))).join(`
+`), o = r.slice(1).reduce((c, f) => c.merge(f.boundingBox), r[0].boundingBox);
+    return H(i, o, n, e);
   }
-  const r = X(t).mirror();
-  return J(
-    Y(t, W(r)),
-    r.boundingBox,
+  const s = X(t).mirror();
+  return H(
+    Y(t, W(s)),
+    s.boundingBox,
     n,
     e
   );
 }
-const st = (t) => {
+const at = (t) => {
   if (t.type === "LINE")
     return new w(t.firstPoint, t.lastPoint);
   if (t.type === "ARC")
-    return new S(
+    return new M(
       t.firstPoint,
       t.lastPoint,
       t.center,
       t.clockwise
     );
+  if (t.type === "ELLIPSE_ARC")
+    return new O(
+      t.firstPoint,
+      t.lastPoint,
+      t.center,
+      t.majorRadius,
+      t.minorRadius,
+      t.tiltAngle,
+      t.clockwise,
+      { angleUnits: "rad" }
+    );
   throw new Error("Unknown segment type");
-}, D = (t) => {
-  const n = t.segments.map(st);
-  return new d(n);
-}, ot = (t) => {
-  const n = D(t.contour), e = t.holes.map(D);
-  return new g(n, e);
-}, Tt = (t) => {
-  const n = t.figures.map(ot);
-  return new p(n);
+}, R = (t) => {
+  const n = t.segments.map(at);
+  return new P(n);
+}, ct = (t) => {
+  const n = R(t.contour), e = t.holes.map(R);
+  return new p(n, e);
+}, Wt = (t) => {
+  const n = t.figures.map(ct);
+  return new h(n);
 };
-function Zt(t) {
+function sn(t) {
   if (t.type === "DIAGRAM")
-    return Tt(t);
+    return Wt(t);
   if (t.type === "FIGURE")
-    return ot(t);
+    return ct(t);
   if (t.type === "LOOP")
-    return D(t);
-  if (t.type === "LINE" || t.type === "ARC")
-    return st(t);
+    return R(t);
+  if (t.type === "LINE" || t.type === "ARC" || t.type === "ELLIPSE_ARC")
+    return at(t);
   throw new Error("Unknown shape type");
 }
-const Z = Math.PI / 180, Rt = 180 / Math.PI;
-function Bt(t, n) {
-  const e = Math.cos(n * Z) * t, r = Math.sin(n * Z) * t;
-  return [e, r];
+const Z = Math.PI / 180, Xt = 180 / Math.PI;
+function rn(t, n) {
+  const e = Math.cos(n * Z) * t, s = Math.sin(n * Z) * t;
+  return [e, s];
 }
-function Ht([t, n]) {
-  const e = Math.sqrt(t * t + n * n), r = Math.atan2(n, t) * Rt;
-  return [e, r];
+function on([t, n]) {
+  const e = Math.sqrt(t * t + n * n), s = Math.atan2(n, t) * Xt;
+  return [e, s];
 }
 export {
   Z as DEG2RAD,
-  Rt as RAD2DEG,
-  Ht as cartesianToPolar,
-  Jt as confineStrand,
-  _ as cut,
-  _t as draw,
-  qt as eraseStrand,
-  tn as exportJSON,
-  Yt as exportSVG,
-  Et as fuse,
-  E as fuseAll,
-  Zt as importJSON,
-  Nt as intersect,
-  Wt as offset,
-  Xt as outlineStroke,
-  Bt as polarToCartesian,
+  Xt as RAD2DEG,
+  on as cartesianToPolar,
+  jt as confineStrand,
+  nt as cut,
+  fn as draw,
+  Qt as eraseStrand,
+  un as exportJSON,
+  en as exportSVG,
+  yt as fuse,
+  b as fuseAll,
+  sn as importJSON,
+  Kt as intersect,
+  tn as offset,
+  nn as outlineStroke,
+  rn as polarToCartesian,
   W as svgBody
 };
 //# sourceMappingURL=pantograph.js.map