pantograph2d 0.4.0 → 0.5.0

package/dist/pantograph.js

@@ -1,119 +1,119 @@
-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 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 $)
-    return [new h(t)];
-  if (t instanceof P)
+  if (t instanceof d)
+    return [new g(t)];
+  if (t instanceof p)
     return t.figures;
   throw new Error("Unknown shape");
 }
-function H(t, n, e = 1e-9) {
+function Q(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,
+  n.segments.forEach((a, u) => {
+    t.segments.forEach((f) => {
+      const { intersections: l, overlaps: m } = O(
+        a,
+        f,
         e
       );
-      r.push(...f), s[i].push(...f), o.push(...c);
-      const l = c.flatMap((S) => [
-        S.firstPoint,
-        S.lastPoint
+      r.push(...l), s[u].push(...l), o.push(...m);
+      const P = m.flatMap((c) => [
+        c.firstPoint,
+        c.lastPoint
       ]);
-      r.push(...l), s[i].push(...l);
+      r.push(...P), s[u].push(...P);
     });
-  }), r = et(r, e);
-  const a = st([n.segments, s]).flatMap(([u, i]) => i.length ? u.splitAt(i) : [u]);
+  }), r = ut(r, e);
+  const i = lt([n.segments, s]).flatMap(([a, u]) => u.length ? a.splitAt(u) : [a]);
   return Array.from(
-    rt(
-      a,
+    pt(
+      i,
       r,
       o
     )
   );
 }
-function O(t, n, e = !1) {
-  return H(n, t).filter((o) => {
+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 x(t, n, e = !1) {
-  return H(n, t).filter((o) => {
+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 V(t, n, e = !1) {
-  const r = O(
+function R(t, n, e = !1) {
+  const r = C(
     t,
     n.contour,
     e
   ), o = n.holes.flatMap(
-    (s) => x(t, s, e)
+    (s) => G(t, s, e)
   );
   return [...r, ...o];
 }
-function T(t, n, e = !1) {
-  let r = x(
+function U(t, n, e = !1) {
+  let r = G(
     t,
     n.contour,
     e
   );
   return n.holes.forEach((o) => {
     r = r.flatMap(
-      (s) => O(s, o, e)
+      (s) => C(s, o, e)
     );
   }), r;
 }
-function St(t, n) {
-  return new P(
-    ot(F(t), F(n))
+function Et(t, n) {
+  return new p(
+    Pt(M(t), M(n))
   );
 }
-function R(t) {
+function E(t) {
   return t.reduce(
-    (n, e) => St(n, e),
-    new P()
+    (n, e) => Et(n, e),
+    new p()
   );
 }
-function Mt(t, n) {
-  return new P(
-    it(F(t), F(n))
+function _(t, n) {
+  return new p(
+    gt(M(t), M(n))
   );
 }
-function xt(t, n) {
-  return new P(
-    ft(F(t), F(n))
+function Nt(t, n) {
+  return new p(
+    mt(M(t), M(n))
   );
 }
-function Gt(t, n, e = !0) {
-  if (n instanceof $)
-    return O(t, n, e);
-  if (n instanceof h)
-    return V(t, n, e);
+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) => V(s, o, e));
+    r = r.flatMap((s) => R(s, o, e));
   }), r;
 }
-function Vt(t, n, e = !1) {
-  if (n instanceof $)
-    return x(t, n, e);
-  if (n instanceof h)
-    return T(t, n, e);
+function Jt(t, n, e = !1) {
+  if (n instanceof d)
+    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) => T(s, o, e));
+    r = r.flatMap((s) => U(s, o, e));
   }), r;
 }
-function U(t) {
+function z(t) {
   return t < 0 ? "before" : t > 1 ? "after" : "between";
 }
 const N = (t, n, e) => {
@@ -123,47 +123,47 @@ const N = (t, n, e) => {
     return t.distanceFrom(n.lastPoint);
   throw new Error("Invalid position");
 };
-function At(t, n) {
-  const e = at(t, n);
+function yt(t, n) {
+  const e = wt(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: r, intersectionParam2: o } = e, s = z(r), i = z(o);
+  if (s === "between" && i === "between")
     return 0;
-  if (s === "between" && a !== "between")
-    return N(t, n, a);
-  if (a === "between" && s !== "between")
+  if (s === "between" && i !== "between")
+    return N(t, n, i);
+  if (i === "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 (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);
   throw new Error("Invalid position");
 }
-function z(t, n) {
-  if (ct(t, n).length > 0)
+function q(t, n) {
+  if (dt(t, n).length > 0)
     return 0;
-  const e = ut(t, n.center);
+  const e = ht(t, n.center);
   if (t.isOnSegment(e)) {
-    const r = g(e, n.center);
+    const r = h(e, n.center);
     if (Math.abs(r - n.radius) < t.precision && n.isOnSegment(e))
       return 0;
     if (r - n.radius > t.precision) {
-      const o = Z(
-        E(e, n.center)
-      ), s = lt(
+      const o = B(
+        v(e, n.center)
+      ), s = St(
         n.center,
-        pt(o, n.radius)
+        At(o, n.radius)
       );
       if (n.isOnSegment(s))
-        return g(s, e);
+        return h(s, e);
     }
   }
   return Math.min(
@@ -173,279 +173,345 @@ function z(t, n) {
     t.distanceFrom(n.lastPoint)
   );
 }
-const Lt = (t, n) => {
+const It = (t, n) => {
   const e = t.angleToParam(n.firstAngle);
   if (t.isValidParameter(e))
     return !0;
   const r = t.angleToParam(n.lastAngle);
   return !!t.isValidParameter(r);
 };
-function $t(t, n) {
-  if (Pt(t, n, !0).length > 0)
+function bt(t, n) {
+  if (Mt(t, n, !0).length > 0)
     return 0;
-  const e = g(t.center, n.center);
-  if (e < t.precision && Lt(t, n))
+  const e = h(t.center, n.center);
+  if (e < t.precision && It(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);
+  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 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 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(
     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);
+function kt(t, n) {
   if (t instanceof w && n instanceof w)
-    return $t(t, n);
+    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");
 }
-const I = 1e-8;
-function vt(t, n) {
-  const e = t.map((i) => ({
-    offset: nt(i, n),
-    original: i
-  })), r = [];
-  let o = null, s = e.at(-1);
-  if (!s)
-    return [];
-  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;
+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 i of e.slice(0, -1))
-      yield i;
-    if (!o)
+    for (const f of r.slice(0, -1))
+      yield f;
+    if (!s)
       throw new Error("Bug in the offset algorithm");
-    yield o;
+    yield s;
   };
-  for (const i of u()) {
-    const m = s.offset.lastPoint, f = i.offset.firstPoint;
-    if (L(m, f)) {
-      a(s), s = i;
+  for (const f of u()) {
+    if (!i) {
+      i = f;
       continue;
     }
-    let c = [];
-    if (!(s.offset instanceof D) && !(i.offset instanceof D)) {
-      const { intersections: M, overlaps: A } = C(
-        s.offset,
+    const l = i.offset.lastPoint, m = f.offset.firstPoint;
+    if (A(l, m)) {
+      a(i), i = f;
+      continue;
+    }
+    let P = [];
+    if (!(i.offset instanceof b) && !(f.offset instanceof b)) {
+      const { intersections: $, overlaps: I } = O(
         i.offset,
-        I / 100
+        f.offset,
+        V / 100
       );
-      c = [
-        ...M,
-        ...A.flatMap((p) => [p.firstPoint, p.lastPoint])
+      P = [
+        ...$,
+        ...I.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 (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)
         );
-        M = c[v.indexOf(Math.min(...v))];
+        $ = P[T.indexOf(Math.min(...T))];
       }
-      const A = s.offset.splitAt([
-        M
-      ])[0], p = i.offset.splitAt([M]).at(-1);
-      if (!p)
+      const I = i.offset.splitAt([
+        $
+      ])[0], L = f.offset.splitAt([$]).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 };
+        offset: I,
+        original: i.original
+      }), i = { offset: L, original: f.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 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;
   }
-  return a(s), r;
+  return a(i), o;
 }
-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]);
+function j(t) {
+  const n = /* @__PURE__ */ new Map(), e = (r, o) => {
+    const s = n.get(r) || [];
+    n.set(r, [...s, ...o]);
   };
-  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((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);
       });
-      A.length && (s(c, A), s(S + c + 1, A));
+      f.length && (e(o, f), e(i + o + 1, f));
     });
-  }), !o.size) {
-    const f = new $(r);
-    return new P([new h(f)]);
-  }
-  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));
-  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();
+  }), n;
+}
+function tt(t, n) {
+  return n.flatMap((e, r) => {
+    if (!t.has(r))
+      return e;
+    const o = t.get(r);
+    return o ? e.splitAt(o) : e;
+  });
 }
-function Et(t, n) {
+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)]);
+  }
+  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()
+  );
+  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]
+    ),
+    ...s,
+    i(
+      s[s.length - 1],
+      o[0]
+    )
+  ], u = j(a);
+  if (!u.size) {
+    const c = new d(a);
+    return new p([new g(c)]);
+  }
+  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 = R(
-      r.holes.map((s) => q(s, n))
+    const o = E(
+      r.holes.map((s) => y(s, n))
     );
-    return Mt(q(r.contour, n), o);
+    return _(y(r.contour, n), o);
   });
-  return R(e);
+  return E(e);
 }
-function Tt(t, n) {
-  return Et(F(t), n);
+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)))
+    )
+  );
+  return E(r);
 }
-function G(t) {
-  if (t instanceof d)
-    return `L ${t.lastPoint.join(" ")}`;
+function Wt(t, n) {
+  return Ot(M(t), n);
+}
+function Xt(t, n, { endCap: e = "round" } = {}) {
+  return t instanceof K ? Dt(t, n, e) : Ct(M(t), n);
+}
+function x(t) {
   if (t instanceof w)
+    return `L ${t.lastPoint.join(" ")}`;
+  if (t instanceof S)
     return `A ${t.radius} ${t.radius} 0 ${t.angularLength > 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 et(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(x).join(" ");
   return `${n} ${e} Z`;
 }
-function Q(t) {
-  return `<path d="${t.allLoops.map(K).join(" ")}" />`;
+function rt(t) {
+  return `<path d="${t.allLoops.map(et).join(" ")}" />`;
 }
-function yt(t) {
+function Gt(t) {
   return `<g>
-  ${t.figures.map(Q).join(`
+  ${t.figures.map(rt).join(`
 `)}
 </g>`;
 }
-function bt(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(G).join(" ");
+function Vt(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(x).join(" ");
   return `${n} ${e}`;
 }
-function Dt(t, n = 1) {
+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 B(t, n, e = 1) {
+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}"` : "";
   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="${o}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke" ${s}>
     ${t}
 </svg>`;
 }
-function J(t) {
-  if (t instanceof P)
-    return yt(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(
+function W(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(
       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 Yt(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 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 e = W(t).mirror();
-  return B(
-    X(t, J(e)),
-    e.boundingBox,
-    n
+  const r = X(t).mirror();
+  return J(
+    Y(t, W(r)),
+    r.boundingBox,
+    n,
+    e
   );
 }
-const _ = (t) => {
+const st = (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 S(
       t.firstPoint,
       t.lastPoint,
       t.center,
       t.clockwise
     );
   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);
-  return new P(n);
+}, 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);
 };
-function Ut(t) {
+function Zt(t) {
   if (t.type === "DIAGRAM")
-    return It(t);
+    return Tt(t);
   if (t.type === "FIGURE")
-    return j(t);
+    return ot(t);
   if (t.type === "LOOP")
-    return k(t);
+    return D(t);
   if (t.type === "LINE" || t.type === "ARC")
-    return _(t);
+    return st(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;
+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];
 }
-function zt([t, n]) {
-  const e = Math.sqrt(t * t + n * n), r = Math.atan2(n, t) * kt;
+function Ht([t, n]) {
+  const e = Math.sqrt(t * t + n * n), r = Math.atan2(n, t) * Rt;
   return [e, r];
 }
 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,
+  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,
+  W as svgBody
 };
 //# sourceMappingURL=pantograph.js.map