pantograph2d 0.4.0 → 0.6.0

package/dist/pantograph.js

@@ -1,169 +1,169 @@
-import { o as nt, D } from "./draw-44dd36a9.js";
-import { d as Jt } from "./draw-44dd36a9.js";
-import { F as h, L as $, D as P, f as C, r as et, z as st, s as rt, a as ot, c as it, i as ft, l as at, d as g, b as ct, p as ut, n as Z, e as E, g as lt, h as pt, j as Pt, k as mt, m as d, A as w, o as L, q as gt, t as dt, u as wt, S as ht } from "./Diagram-1c56996e.js";
-import { v as Xt } from "./Diagram-1c56996e.js";
-function F(t) {
-  if (t instanceof h)
+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 $)
-    return [new h(t)];
   if (t instanceof P)
+    return [new p(t)];
+  if (t instanceof h)
     return t.figures;
   throw new Error("Unknown shape");
 }
-function H(t, n, e = 1e-9) {
-  let r = [];
-  const o = [], s = new Array(n.segments.length).fill(0).map(() => []);
-  n.segments.forEach((u, i) => {
-    t.segments.forEach((m) => {
-      const { intersections: f, overlaps: c } = C(
-        u,
-        m,
+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,
         e
       );
-      r.push(...f), s[i].push(...f), o.push(...c);
-      const l = c.flatMap((S) => [
-        S.firstPoint,
-        S.lastPoint
+      s.push(...u), i[f].push(...u), r.push(...d);
+      const g = d.flatMap((l) => [
+        l.firstPoint,
+        l.lastPoint
       ]);
-      r.push(...l), s[i].push(...l);
+      s.push(...g), i[f].push(...g);
     });
-  }), r = et(r, e);
-  const a = st([n.segments, s]).flatMap(([u, i]) => i.length ? u.splitAt(i) : [u]);
+  }), s = gt(s, e);
+  const o = pt([n.segments, i]).flatMap(([c, f]) => f.length ? c.splitAt(f) : [c]);
   return Array.from(
-    rt(
-      a,
-      r,
-      o
+    dt(
+      o,
+      s,
+      r
     )
   );
 }
-function O(t, n, e = !1) {
-  return H(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 x(t, n, e = !1) {
-  return H(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 V(t, n, e = !1) {
-  const r = O(
+function z(t, n, e = !1) {
+  const s = G(
     t,
     n.contour,
     e
-  ), o = n.holes.flatMap(
-    (s) => x(t, s, e)
+  ), r = n.holes.flatMap(
+    (i) => T(t, i, e)
   );
-  return [...r, ...o];
+  return [...s, ...r];
 }
-function T(t, n, e = !1) {
-  let r = x(
+function q(t, n, e = !1) {
+  let s = T(
     t,
     n.contour,
     e
   );
-  return n.holes.forEach((o) => {
-    r = r.flatMap(
-      (s) => O(s, o, e)
+  return n.holes.forEach((r) => {
+    s = s.flatMap(
+      (i) => G(i, r, e)
     );
-  }), r;
+  }), s;
 }
-function St(t, n) {
-  return new P(
-    ot(F(t), F(n))
+function yt(t, n) {
+  return new h(
+    wt(S(t), S(n))
   );
 }
-function R(t) {
+function b(t) {
   return t.reduce(
-    (n, e) => St(n, e),
-    new P()
+    (n, e) => yt(n, e),
+    new h()
   );
 }
-function Mt(t, n) {
-  return new P(
-    it(F(t), F(n))
+function nt(t, n) {
+  return new h(
+    Pt(S(t), S(n))
   );
 }
-function xt(t, n) {
-  return new P(
-    ft(F(t), F(n))
+function Kt(t, n) {
+  return new h(
+    mt(S(t), S(n))
   );
 }
-function Gt(t, n, e = !0) {
-  if (n instanceof $)
-    return O(t, n, e);
-  if (n instanceof h)
-    return V(t, n, e);
-  let r = [t];
-  return n.figures.forEach((o) => {
-    r = r.flatMap((s) => V(s, o, e));
-  }), r;
-}
-function Vt(t, n, e = !1) {
-  if (n instanceof $)
-    return x(t, n, e);
-  if (n instanceof h)
+function Qt(t, n, e = !0) {
+  if (n instanceof P)
+    return G(t, n, e);
+  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);
-  let r = [t];
-  return n.figures.forEach((o) => {
-    r = r.flatMap((s) => T(s, o, e));
-  }), r;
-}
-function U(t) {
+  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 At(t, n) {
-  const e = at(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 = U(r), a = U(o);
-  if (s === "between" && a === "between")
+  const { intersectionParam1: s, intersectionParam2: r } = e, i = N(s), o = N(r);
+  if (i === "between" && o === "between")
     return 0;
-  if (s === "between" && a !== "between")
-    return N(t, n, a);
-  if (a === "between" && s !== "between")
-    return N(n, t, s);
-  if (s === "before" && a === "before")
-    return g(t.firstPoint, n.firstPoint);
-  if (s === "after" && a === "after")
-    return g(t.lastPoint, n.lastPoint);
-  if (s === "before" && a === "after")
-    return g(t.firstPoint, n.lastPoint);
-  if (s === "after" && a === "before")
-    return g(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 z(t, n) {
-  if (ct(t, n).length > 0)
+function J(t, n) {
+  if (vt(t, n).length > 0)
     return 0;
-  const e = ut(t, n.center);
+  const e = St(t, n.center);
   if (t.isOnSegment(e)) {
-    const r = g(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 = Z(
-        E(e, n.center)
-      ), s = lt(
+    if (s - n.radius > t.precision) {
+      const r = K(
+        $(e, n.center)
+      ), i = It(
         n.center,
-        pt(o, n.radius)
+        Lt(r, n.radius)
       );
-      if (n.isOnSegment(s))
-        return g(s, e);
+      if (n.isOnSegment(i))
+        return m(i, e);
     }
   }
   return Math.min(
@@ -173,279 +173,486 @@ function z(t, n) {
     t.distanceFrom(n.lastPoint)
   );
 }
-const Lt = (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 $t(t, n) {
-  if (Pt(t, n, !0).length > 0)
+function xt(t, n) {
+  if (kt(t, n, !0).length > 0)
     return 0;
-  const e = g(t.center, n.center);
-  if (e < t.precision && Lt(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 = Z(E(n.center, t.center)), o = e - Math.abs(t.radius - n.radius) < t.precision;
-  let s = mt(r);
-  o && n.radius > t.radius && (s += Math.PI);
-  const a = o ? s : s + Math.PI, u = t.angleToParam(s), i = n.angleToParam(a);
-  return t.isValidParameter(u) && n.isValidParameter(i) ? g(t.paramPoint(u), n.paramPoint(i)) : 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 Ft(t, n) {
-  if (t instanceof d && n instanceof d)
-    return At(t, n);
-  if (t instanceof d && n instanceof w)
-    return z(t, n);
-  if (t instanceof w && n instanceof d)
-    return z(n, t);
-  if (t instanceof w && n instanceof w)
-    return $t(t, n);
-  throw new Error("Not implemented");
-}
-const I = 1e-8;
-function vt(t, n) {
-  const e = t.map((i) => ({
-    offset: nt(i, n),
-    original: i
+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 x(t, n, e = !0) {
+  const s = t.map((a) => ({
+    offset: ht(a, n),
+    original: a
   })), r = [];
-  let o = null, s = e.at(-1);
-  if (!s)
-    return [];
+  let i = e ? null : s.at(-1), o = e ? s.at(-1) : null;
   if (r.length === 1)
     return r;
-  const a = (i) => {
-    o ? i.offset instanceof D ? L(i.offset.firstPoint, i.offset.lastPoint) || r.push(
-      new d(i.offset.firstPoint, i.offset.lastPoint)
-    ) : r.push(i.offset) : o = i;
-  }, u = function* () {
-    for (const i of e.slice(0, -1))
-      yield i;
-    if (!o)
+  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 o;
+    yield i;
   };
-  for (const i of u()) {
-    const m = s.offset.lastPoint, f = i.offset.firstPoint;
-    if (L(m, f)) {
-      a(s), s = i;
+  for (const a of f()) {
+    if (!o) {
+      o = a;
+      continue;
+    }
+    const u = o.offset.lastPoint, d = a.offset.firstPoint;
+    if (v(u, d)) {
+      c(o), o = a;
       continue;
     }
-    let c = [];
-    if (!(s.offset instanceof D) && !(i.offset instanceof D)) {
-      const { intersections: M, overlaps: A } = C(
-        s.offset,
-        i.offset,
-        I / 100
+    let g = [];
+    if (!(o.offset instanceof D) && !(a.offset instanceof D)) {
+      const { intersections: I, overlaps: F } = C(
+        o.offset,
+        a.offset,
+        V / 100
       );
-      c = [
-        ...M,
-        ...A.flatMap((p) => [p.firstPoint, p.lastPoint])
+      g = [
+        ...I,
+        ...F.flatMap((L) => [L.firstPoint, L.lastPoint])
       ];
     }
-    if (c.length > 0) {
-      let M = c[0];
-      if (c.length > 1) {
-        const b = s == null ? void 0 : s.original.lastPoint, v = c.map(
-          (tt) => dt(tt, b)
+    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)
         );
-        M = c[v.indexOf(Math.min(...v))];
+        I = g[B.indexOf(Math.min(...B))];
       }
-      const A = s.offset.splitAt([
-        M
-      ])[0], p = i.offset.splitAt([M]).at(-1);
-      if (!p)
+      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: A,
-        original: s.original
-      }), s = { offset: p, original: i.original };
+      c({
+        offset: F,
+        original: o.original
+      }), o = { offset: L, original: a.original };
       continue;
     }
-    const l = s.original.lastPoint, S = wt(
-      E(f, l),
-      E(m, l)
-    ) > 0, y = new w(m, f, l, S);
-    a(s), r.push(y), s = i;
+    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(s), r;
-}
-function q(t, n) {
-  const e = t.clockwise ? n : -n, r = vt(t.segments, e);
-  if (r.length < 2)
-    return new P();
-  const o = /* @__PURE__ */ new Map(), s = (f, c) => {
-    const l = o.get(f) || [];
-    o.set(f, [...l, ...c]);
+  return o && c(o), r;
+}
+function et(t) {
+  const n = /* @__PURE__ */ new Map(), e = (s, r) => {
+    const i = n.get(s) || [];
+    n.set(s, [...i, ...r]);
   };
-  if (r.forEach((f, c) => {
-    r.slice(c + 1).forEach((l, S) => {
-      const { intersections: y, overlaps: M } = C(f, l, I), A = [
-        ...y,
-        ...M.flatMap((p) => [p.firstPoint, p.lastPoint])
-      ].filter((p) => {
-        const b = L(p, f.firstPoint) || L(p, f.lastPoint), v = L(p, l.firstPoint) || L(p, l.lastPoint);
-        return !(b && v);
+  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);
       });
-      A.length && (s(c, A), s(S + c + 1, A));
+      a.length && (e(r, a), e(o + r + 1, a));
     });
-  }), !o.size) {
-    const f = new $(r);
-    return new P([new h(f)]);
+  }), n;
+}
+function st(t, n) {
+  return n.flatMap((e, s) => {
+    if (!t.has(s))
+      return e;
+    const r = t.get(s);
+    return r ? e.splitAt(r) : e;
+  });
+}
+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 u = r.flatMap((f, c) => {
-    if (!o.has(c))
-      return f;
-    const l = o.get(c) || [];
-    return f.splitAt(l);
-  }).filter((f) => !t.segments.some((l) => Ft(l, f) < Math.abs(n) - I));
+  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()
+  );
+  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]
+    ),
+    ...i,
+    o(
+      i[i.length - 1],
+      r[0]
+    )
+  ], f = et(c);
+  if (!f.size) {
+    const l = new P(c);
+    return new h([new p(l)]);
+  }
+  const a = st(
+    f,
+    c
+  ), u = it(a, t, s);
   if (!u.length)
-    return new P();
-  const m = gt(u).filter((f) => f.length > 1).filter((f) => L(f[0].firstPoint, f.at(-1).lastPoint)).map((f) => new $(f));
-  return m.length ? new P(m.map((f) => new h(f))) : new P();
-}
-function Et(t, n) {
-  const e = t.map((r) => {
-    const o = R(
-      r.holes.map((s) => q(s, n))
+    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 Mt(q(r.contour, n), o);
+    return nt(E(s.contour, n), r);
   });
-  return R(e);
+  return b(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 b(s);
 }
-function Tt(t, n) {
-  return Et(F(t), n);
+function tn(t, n) {
+  return qt(S(t), n);
 }
-function G(t) {
-  if (t instanceof d)
-    return `L ${t.lastPoint.join(" ")}`;
+function nn(t, n, { endCap: e = "round" } = {}) {
+  return t instanceof y ? zt(t, n, e) : Nt(S(t), n);
+}
+function U(t) {
   if (t instanceof w)
+    return `L ${t.lastPoint.join(" ")}`;
+  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 K(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(G).join(" ");
+function rt(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(U).join(" ");
   return `${n} ${e} Z`;
 }
-function Q(t) {
-  return `<path d="${t.allLoops.map(K).join(" ")}" />`;
+function ot(t) {
+  return `<path d="${t.allLoops.map(rt).join(" ")}" />`;
 }
-function yt(t) {
+function _t(t) {
   return `<g>
-  ${t.figures.map(Q).join(`
+  ${t.figures.map(ot).join(`
 `)}
 </g>`;
 }
-function bt(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(G).join(" ");
+function Jt(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(U).join(" ");
   return `${n} ${e}`;
 }
-function Dt(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 B(t, n, e = 1) {
+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="${Dt(n, e)}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke">
+<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 J(t) {
-  if (t instanceof P)
-    return yt(t);
+function W(t) {
   if (t instanceof h)
-    return Q(t);
-  if (t instanceof $)
-    return `<path d="${K(t)}" />`;
-  if (t instanceof ht)
-    return `<path d="${bt(t)}" />`;
-  if (t instanceof w || t instanceof d)
-    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${G(
+    return _t(t);
+  if (t instanceof p)
+    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");
 }
-const W = (t) => "shape" in t ? t.shape : t, X = (t, n) => {
+const X = (t) => "shape" in t ? t.shape : t, Y = (t, n) => {
   if (!("shape" in t))
     return n;
   const { color: e } = t;
   return e ? `<g stroke="${e}">${n}</g>` : n;
 };
-function Rt(t, n = 1) {
+function en(t, {
+  margin: n = 1,
+  unit: e = null
+} = {}) {
   if (Array.isArray(t)) {
-    const r = t.map((a) => W(a).mirror()), o = r.map((a, u) => X(t[u], J(a))).join(`
-`), s = r.slice(1).reduce((a, u) => a.merge(u.boundingBox), r[0].boundingBox);
-    return B(o, s);
+    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 e = W(t).mirror();
-  return B(
-    X(t, J(e)),
-    e.boundingBox,
-    n
+  const s = X(t).mirror();
+  return H(
+    Y(t, W(s)),
+    s.boundingBox,
+    n,
+    e
   );
 }
-const _ = (t) => {
+const at = (t) => {
   if (t.type === "LINE")
-    return new d(t.firstPoint, t.lastPoint);
+    return new w(t.firstPoint, t.lastPoint);
   if (t.type === "ARC")
-    return new w(
+    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");
-}, k = (t) => {
-  const n = t.segments.map(_);
-  return new $(n);
-}, j = (t) => {
-  const n = k(t.contour), e = t.holes.map(k);
-  return new h(n, e);
-}, It = (t) => {
-  const n = t.figures.map(j);
+}, 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 Ut(t) {
+function sn(t) {
   if (t.type === "DIAGRAM")
-    return It(t);
+    return Wt(t);
   if (t.type === "FIGURE")
-    return j(t);
+    return ct(t);
   if (t.type === "LOOP")
-    return k(t);
-  if (t.type === "LINE" || t.type === "ARC")
-    return _(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 Y = Math.PI / 180, kt = 180 / Math.PI;
-function Nt(t, n) {
-  const e = Math.cos(n * Y) * t, r = Math.sin(n * Y) * 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 zt([t, n]) {
-  const e = Math.sqrt(t * t + n * n), r = Math.atan2(n, t) * kt;
-  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 {
-  Y as DEG2RAD,
-  kt as RAD2DEG,
-  zt as cartesianToPolar,
-  Vt as confineStrand,
-  Mt as cut,
-  Jt as draw,
-  Gt as eraseStrand,
-  Xt as exportJSON,
-  Rt as exportSVG,
-  St as fuse,
-  R as fuseAll,
-  Ut as importJSON,
-  xt as intersect,
-  Tt as offset,
-  Nt as polarToCartesian,
-  J as svgBody
+  Z as DEG2RAD,
+  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