pantograph2d 0.3.1 → 0.4.0

package/dist/pantograph.js

@@ -1,328 +1,169 @@
-import { L as p, A as P, a as L, s as C, p as D, t as Q, c as j, f as ct, b as ft, d as A, e as ut, g as S, h as $, T as lt, D as g, F as T, i as M, j as _, k as V, l as ht, m as gt, n as pt, o as mt, q as Pt, r as wt, u as tt, v as dt, w as At, x as nt, y as St, z as vt, S as Lt } from "./exportJSON-26bb92ef.js";
-import { B as Zt } from "./exportJSON-26bb92ef.js";
-class F {
-  constructor(n, e) {
-    this.firstPoint = n, this.lastPoint = e;
-  }
-}
-function k(t, n) {
-  if (t instanceof p)
-    return Ct(t, n);
+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)
+    return [t];
+  if (t instanceof $)
+    return [new h(t)];
   if (t instanceof P)
-    return Tt(t, n);
-  throw new Error("Not implemented");
-}
-function Ct(t, n) {
-  const { firstPoint: e, lastPoint: r } = t, s = t.normalVector;
-  return new p(
-    L(e, C(s, n)),
-    L(r, C(s, n))
-  );
+    return t.figures;
+  throw new Error("Unknown shape");
 }
-function Tt(t, n) {
-  const e = L(
-    t.firstPoint,
-    C(D(t.tangentAtFirstPoint), n)
-  ), r = L(
-    t.lastPoint,
-    C(D(t.tangentAtLastPoint), n)
-  ), s = n * (t.clockwise ? 1 : -1);
-  return t.radius + s < t.precision ? new F(e, r) : new P(e, r, t.center, t.clockwise);
-}
-function et(t, n, e) {
-  const r = j(
-    t.tangentAtLastPoint,
-    n.tangentAtFirstPoint
-  );
-  if (Math.abs(r) < 1e-10)
-    return null;
-  const s = r > 0 ? 1 : -1, i = Math.abs(e) * s, o = k(t, i), u = k(n, i);
-  if (o instanceof F || u instanceof F)
-    return null;
-  let c;
-  try {
-    c = ct(o, u, 1e-9).at(-1);
-  } catch {
-    return null;
-  }
-  if (!c)
-    return null;
-  const m = c, a = (v, b) => {
-    const w = b.tangentAt(m), d = ft(w), h = L(m, C(d, i));
-    return v.splitAt(h);
-  }, [f] = a(t, o), [, l] = a(n, u);
-  return { first: f, second: l, center: m };
-}
-function B(t, n, e) {
-  const r = et(t, n, e);
-  if (!r)
-    return console.warn(
-      "Cannot fillet between segments",
-      t.repr,
-      n.repr
-    ), [t, n];
-  const { first: s, second: i } = r;
-  return [
-    s,
-    Q(s.lastPoint, i.firstPoint, s.tangentAtLastPoint),
-    i
-  ];
-}
-function G(t, n, e) {
-  const r = et(t, n, e);
-  if (!r)
-    return console.warn(
-      "Cannot chamfer between segments",
-      t.repr,
-      n.repr
-    ), [t, n];
-  const { first: s, second: i } = r;
-  return [s, new p(s.lastPoint, i.firstPoint), i];
-}
-function N(t) {
-  return new g([new T(new M(t))]);
-}
-class Et {
-  constructor(n = [0, 0]) {
-    this.pointer = n, this.firstPoint = n, this.pendingSegments = [], this._nextCorner = null;
-  }
-  movePointerTo(n) {
-    if (this.pendingSegments.length)
-      throw new Error(
-        "You can only move the pointer if there is no segment defined"
+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,
+        e
       );
-    return this.pointer = n, this.firstPoint = n, this;
-  }
-  saveSegment(n) {
-    if (A(n.firstPoint, n.lastPoint))
-      throw new Error(`Segment has no length, ${n.repr}`);
-    if (!this._nextCorner)
-      return this.pendingSegments.push(n), this;
-    const e = this.pendingSegments.pop();
-    if (!e)
-      throw new Error("bug in the custom corner algorithm");
-    const r = this._nextCorner.mode === "chamfer" ? G : B;
-    return this.pendingSegments.push(
-      ...r(e, n, this._nextCorner.radius)
-    ), this._nextCorner = null, this;
-  }
-  lineTo(n) {
-    const e = new p(this.pointer, n);
-    return this.pointer = n, this.saveSegment(e);
-  }
-  line(n, e) {
-    return this.lineTo([this.pointer[0] + n, this.pointer[1] + e]);
-  }
-  vLine(n) {
-    return this.line(0, n);
-  }
-  hLine(n) {
-    return this.line(n, 0);
-  }
-  vLineTo(n) {
-    return this.lineTo([this.pointer[0], n]);
-  }
-  hLineTo(n) {
-    return this.lineTo([n, this.pointer[1]]);
-  }
-  polarLineTo([n, e]) {
-    const r = e * V, s = _(n, r);
-    return this.lineTo(s);
-  }
-  polarLine(n, e) {
-    const r = e * V, [s, i] = _(n, r);
-    return this.line(s, i);
-  }
-  tangentLine(n) {
-    const e = this.pendingSegments.at(-1);
-    if (!e)
-      throw new Error("You need a previous segment to sketch a tangent line");
-    const [r, s] = e.tangentAtLastPoint;
-    return this.line(r * n, s * n);
-  }
-  threePointsArcTo(n, e) {
-    return this.saveSegment(ut(this.pointer, e, n)), this.pointer = n, this;
-  }
-  threePointsArc(n, e, r, s) {
-    const [i, o] = this.pointer;
-    return this.threePointsArcTo(
-      [i + n, o + e],
-      [i + r, o + s]
-    );
-  }
-  sagittaArcTo(n, e) {
-    if (!e)
-      return this.lineTo(n);
-    const r = new p(this.pointer, n), s = D(r.tangentAtFirstPoint), i = L(r.midPoint, C(s, e));
-    return this.threePointsArcTo(n, i);
-  }
-  sagittaArc(n, e, r) {
-    return this.sagittaArcTo(
-      [n + this.pointer[0], e + this.pointer[1]],
-      r
-    );
-  }
-  vSagittaArc(n, e) {
-    return this.sagittaArc(0, n, e);
-  }
-  hSagittaArc(n, e) {
-    return this.sagittaArc(n, 0, e);
-  }
-  bulgeArcTo(n, e) {
-    if (!e)
-      return this.lineTo(n);
-    const r = S(this.pointer, n) / 2, s = -e * r;
-    return this.sagittaArcTo(n, s);
-  }
-  bulgeArc(n, e, r) {
-    return this.bulgeArcTo(
-      [n + this.pointer[0], e + this.pointer[1]],
-      r
-    );
-  }
-  vBulgeArc(n, e) {
-    return this.bulgeArc(0, n, e);
-  }
-  hBulgeArc(n, e) {
-    return this.bulgeArc(n, 0, e);
-  }
-  tangentArcTo(n) {
-    const e = this.pendingSegments.at(-1);
-    if (!e)
-      throw new Error("You need a previous curve to sketch a tangent arc");
-    return this.saveSegment(
-      Q(this.pointer, n, e.tangentAtLastPoint)
-    ), this.pointer = n, this;
-  }
-  tangentArc(n, e) {
-    const [r, s] = this.pointer;
-    return this.tangentArcTo([n + r, e + s]);
-  }
-  customCorner(n, e = "fillet") {
-    if (!this.pendingSegments.length)
-      throw new Error("You need a segment defined to fillet the angle");
-    return this._nextCorner = { mode: e, radius: n }, this;
-  }
-  _customCornerLastWithFirst(n, e = "fillet") {
-    if (!n)
-      return;
-    const r = this.pendingSegments.pop(), s = this.pendingSegments.shift();
-    if (!r || !s)
-      throw new Error("Not enough curves to close and fillet");
-    const i = e === "chamfer" ? G : B;
-    this.pendingSegments.push(...i(r, s, n));
-  }
-  close() {
-    if (!this.pendingSegments.length)
-      throw new Error("No segments to close");
-    const n = this.pendingSegments[0], e = this.pendingSegments.at(-1);
-    return A(n.firstPoint, e.lastPoint) || this.lineTo(n.firstPoint), this._nextCorner !== null && (this._customCornerLastWithFirst(
-      this._nextCorner.radius,
-      this._nextCorner.mode
-    ), this._nextCorner = null), N(this.pendingSegments);
-  }
-  closeWithMirror() {
-    if (!this.pendingSegments.length)
-      throw new Error("No segments to close");
-    const n = this.pendingSegments[0], e = this.pendingSegments.at(-1), r = $(
-      e.lastPoint,
-      n.firstPoint
-    ), s = new lt().mirrorLine(
+      r.push(...f), s[i].push(...f), o.push(...c);
+      const l = c.flatMap((S) => [
+        S.firstPoint,
+        S.lastPoint
+      ]);
+      r.push(...l), s[i].push(...l);
+    });
+  }), r = et(r, e);
+  const a = st([n.segments, s]).flatMap(([u, i]) => i.length ? u.splitAt(i) : [u]);
+  return Array.from(
+    rt(
+      a,
       r,
-      n.firstPoint
-    ), i = this.pendingSegments.map(
-      (o) => o.transform(s).reverse()
-    );
-    return i.reverse(), N([
-      ...this.pendingSegments,
-      ...i
-    ]);
-  }
+      o
+    )
+  );
 }
-function Gt(t = [0, 0]) {
-  return new Et(t);
+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 E(t) {
-  if (t instanceof T)
-    return [t];
-  if (t instanceof M)
-    return [new T(t)];
-  if (t instanceof g)
-    return t.figures;
-  throw new Error("Unknown shape");
+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 Ft(t, n) {
-  return new g(
-    ht(E(t), E(n))
+function V(t, n, e = !1) {
+  const r = O(
+    t,
+    n.contour,
+    e
+  ), o = n.holes.flatMap(
+    (s) => x(t, s, e)
   );
+  return [...r, ...o];
 }
-function U(t) {
+function T(t, n, e = !1) {
+  let r = x(
+    t,
+    n.contour,
+    e
+  );
+  return n.holes.forEach((o) => {
+    r = r.flatMap(
+      (s) => O(s, o, e)
+    );
+  }), r;
+}
+function St(t, n) {
+  return new P(
+    ot(F(t), F(n))
+  );
+}
+function R(t) {
   return t.reduce(
-    (n, e) => Ft(n, e),
-    new g()
+    (n, e) => St(n, e),
+    new P()
   );
 }
 function Mt(t, n) {
-  return new g(
-    gt(E(t), E(n))
+  return new P(
+    it(F(t), F(n))
   );
 }
-function Nt(t, n) {
-  return new g(
-    pt(E(t), E(n))
+function xt(t, n) {
+  return new P(
+    ft(F(t), F(n))
   );
 }
-function Y(t) {
+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)
+    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) {
   return t < 0 ? "before" : t > 1 ? "after" : "between";
 }
-const q = (t, n, e) => {
+const N = (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 bt(t, n) {
-  const e = mt(t, n);
+function At(t, n) {
+  const e = at(t, n);
   if (e === "parallel")
     return Math.min(
       t.distanceFrom(n.firstPoint),
       t.distanceFrom(n.lastPoint)
     );
-  const { intersectionParam1: r, intersectionParam2: s } = e, i = Y(r), o = Y(s);
-  if (i === "between" && o === "between")
+  const { intersectionParam1: r, intersectionParam2: o } = e, s = U(r), a = U(o);
+  if (s === "between" && a === "between")
     return 0;
-  if (i === "between" && o !== "between")
-    return q(t, n, o);
-  if (o === "between" && i !== "between")
-    return q(n, t, i);
-  if (i === "before" && o === "before")
-    return S(t.firstPoint, n.firstPoint);
-  if (i === "after" && o === "after")
-    return S(t.lastPoint, n.lastPoint);
-  if (i === "before" && o === "after")
-    return S(t.firstPoint, n.lastPoint);
-  if (i === "after" && o === "before")
-    return S(t.lastPoint, n.firstPoint);
+  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);
   throw new Error("Invalid position");
 }
 function z(t, n) {
-  if (Pt(t, n).length > 0)
+  if (ct(t, n).length > 0)
     return 0;
-  const e = wt(t, n.center);
+  const e = ut(t, n.center);
   if (t.isOnSegment(e)) {
-    const r = S(e, n.center);
+    const r = g(e, n.center);
     if (Math.abs(r - n.radius) < t.precision && n.isOnSegment(e))
       return 0;
     if (r - n.radius > t.precision) {
-      const s = tt(
-        $(e, n.center)
-      ), i = L(
+      const o = Z(
+        E(e, n.center)
+      ), s = lt(
         n.center,
-        C(s, n.radius)
+        pt(o, n.radius)
       );
-      if (n.isOnSegment(i))
-        return S(i, e);
+      if (n.isOnSegment(s))
+        return g(s, e);
     }
   }
   return Math.min(
@@ -332,277 +173,279 @@ function z(t, n) {
     t.distanceFrom(n.lastPoint)
   );
 }
-const $t = (t, n) => {
+const Lt = (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 yt(t, n) {
-  if (dt(t, n, !0).length > 0)
+function $t(t, n) {
+  if (Pt(t, n, !0).length > 0)
     return 0;
-  const e = S(t.center, n.center);
-  if (e < t.precision && $t(t, n))
+  const e = g(t.center, n.center);
+  if (e < t.precision && Lt(t, n))
     return Math.abs(t.radius - n.radius);
-  const r = tt($(n.center, t.center)), s = e - Math.abs(t.radius - n.radius) < t.precision;
-  let i = At(r);
-  s && n.radius > t.radius && (i += Math.PI);
-  const o = s ? i : i + Math.PI, u = t.angleToParam(i), c = n.angleToParam(o);
-  return t.isValidParameter(u) && n.isValidParameter(c) ? S(t.paramPoint(u), n.paramPoint(c)) : Math.min(
+  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(
     t.distanceFrom(n.firstPoint),
     t.distanceFrom(n.lastPoint),
     n.distanceFrom(t.firstPoint),
     n.distanceFrom(t.lastPoint)
   );
 }
-function xt(t, n) {
-  if (t instanceof p && n instanceof p)
-    return bt(t, n);
-  if (t instanceof p && n instanceof P)
+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 P && n instanceof p)
+  if (t instanceof w && n instanceof d)
     return z(n, t);
-  if (t instanceof P && n instanceof P)
-    return yt(t, n);
+  if (t instanceof w && n instanceof w)
+    return $t(t, n);
   throw new Error("Not implemented");
 }
 const I = 1e-8;
-function Dt(t, n) {
-  const e = t.map((c) => ({
-    offset: k(c, n),
-    original: c
+function vt(t, n) {
+  const e = t.map((i) => ({
+    offset: nt(i, n),
+    original: i
   })), r = [];
-  let s = null, i = e.at(-1);
-  if (!i)
+  let o = null, s = e.at(-1);
+  if (!s)
     return [];
   if (r.length === 1)
     return r;
-  const o = (c) => {
-    s ? c.offset instanceof F ? A(c.offset.firstPoint, c.offset.lastPoint) || r.push(
-      new p(c.offset.firstPoint, c.offset.lastPoint)
-    ) : r.push(c.offset) : s = c;
+  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 c of e.slice(0, -1))
-      yield c;
-    if (!s)
+    for (const i of e.slice(0, -1))
+      yield i;
+    if (!o)
       throw new Error("Bug in the offset algorithm");
-    yield s;
+    yield o;
   };
-  for (const c of u()) {
-    const m = i.offset.lastPoint, a = c.offset.firstPoint;
-    if (A(m, a)) {
-      o(i), i = c;
+  for (const i of u()) {
+    const m = s.offset.lastPoint, f = i.offset.firstPoint;
+    if (L(m, f)) {
+      a(s), s = i;
       continue;
     }
-    let f = [];
-    if (!(i.offset instanceof F) && !(c.offset instanceof F)) {
-      const { intersections: w, overlaps: d } = nt(
+    let c = [];
+    if (!(s.offset instanceof D) && !(i.offset instanceof D)) {
+      const { intersections: M, overlaps: A } = C(
+        s.offset,
         i.offset,
-        c.offset,
         I / 100
       );
-      f = [
-        ...w,
-        ...d.flatMap((h) => [h.firstPoint, h.lastPoint])
+      c = [
+        ...M,
+        ...A.flatMap((p) => [p.firstPoint, p.lastPoint])
       ];
     }
-    if (f.length > 0) {
-      let w = f[0];
-      if (f.length > 1) {
-        const x = i == null ? void 0 : i.original.lastPoint, y = f.map(
-          (at) => vt(at, x)
+    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)
         );
-        w = f[y.indexOf(Math.min(...y))];
+        M = c[v.indexOf(Math.min(...v))];
       }
-      const d = i.offset.splitAt([
-        w
-      ])[0], h = c.offset.splitAt([w]).at(-1);
-      if (!h)
+      const A = s.offset.splitAt([
+        M
+      ])[0], p = i.offset.splitAt([M]).at(-1);
+      if (!p)
         throw new Error("Bug in the splitting algo in offset");
-      o({
-        offset: d,
-        original: i.original
-      }), i = { offset: h, original: c.original };
+      a({
+        offset: A,
+        original: s.original
+      }), s = { offset: p, original: i.original };
       continue;
     }
-    const l = i.original.lastPoint, v = j(
-      $(a, l),
-      $(m, l)
-    ) > 0, b = new P(m, a, l, v);
-    o(i), r.push(b), i = c;
+    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;
   }
-  return o(i), r;
+  return a(s), r;
 }
-function W(t, n) {
-  const e = t.clockwise ? n : -n, r = Dt(t.segments, e);
+function q(t, n) {
+  const e = t.clockwise ? n : -n, r = vt(t.segments, e);
   if (r.length < 2)
-    return new g();
-  const s = /* @__PURE__ */ new Map(), i = (a, f) => {
-    const l = s.get(a) || [];
-    s.set(a, [...l, ...f]);
+    return new P();
+  const o = /* @__PURE__ */ new Map(), s = (f, c) => {
+    const l = o.get(f) || [];
+    o.set(f, [...l, ...c]);
   };
-  if (r.forEach((a, f) => {
-    r.slice(f + 1).forEach((l, v) => {
-      const { intersections: b, overlaps: w } = nt(a, l, I), d = [
-        ...b,
-        ...w.flatMap((h) => [h.firstPoint, h.lastPoint])
-      ].filter((h) => {
-        const x = A(h, a.firstPoint) || A(h, a.lastPoint), y = A(h, l.firstPoint) || A(h, l.lastPoint);
-        return !(x && y);
+  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);
       });
-      d.length && (i(f, d), i(v + f + 1, d));
+      A.length && (s(c, A), s(S + c + 1, A));
     });
-  }), !s.size) {
-    const a = new M(r);
-    return new g([new T(a)]);
-  }
-  const u = r.flatMap((a, f) => {
-    if (!s.has(f))
-      return a;
-    const l = s.get(f) || [];
-    return a.splitAt(l);
-  }).filter((a) => !t.segments.some((l) => xt(l, a) < Math.abs(n) - I));
+  }), !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 g();
-  const m = St(u).filter((a) => a.length > 1).filter((a) => A(a[0].firstPoint, a.at(-1).lastPoint)).map((a) => new M(a));
-  return m.length ? new g(m.map((a) => new T(a))) : new g();
+    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 kt(t, n) {
+function Et(t, n) {
   const e = t.map((r) => {
-    const s = U(
-      r.holes.map((i) => W(i, n))
+    const o = R(
+      r.holes.map((s) => q(s, n))
     );
-    return Mt(W(r.contour, n), s);
+    return Mt(q(r.contour, n), o);
   });
-  return U(e);
+  return R(e);
 }
-function Ut(t, n) {
-  return kt(E(t), n);
+function Tt(t, n) {
+  return Et(F(t), n);
 }
-function R(t) {
-  if (t instanceof p)
+function G(t) {
+  if (t instanceof d)
     return `L ${t.lastPoint.join(" ")}`;
-  if (t instanceof P)
+  if (t instanceof w)
     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 rt(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(R).join(" ");
+function K(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(G).join(" ");
   return `${n} ${e} Z`;
 }
-function it(t) {
-  return `<path d="${t.allLoops.map(rt).join(" ")}" />`;
+function Q(t) {
+  return `<path d="${t.allLoops.map(K).join(" ")}" />`;
 }
-function It(t) {
+function yt(t) {
   return `<g>
-  ${t.figures.map(it).join(`
+  ${t.figures.map(Q).join(`
 `)}
 </g>`;
 }
-function Ot(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(R).join(" ");
+function bt(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(G).join(" ");
   return `${n} ${e}`;
 }
-function Rt(t, n = 1) {
+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 J(t, n, e = 1) {
+function B(t, n, e = 1) {
   return `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${Rt(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="${Dt(n, e)}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke">
     ${t}
 </svg>`;
 }
-function X(t) {
-  if (t instanceof g)
-    return It(t);
-  if (t instanceof T)
-    return it(t);
-  if (t instanceof M)
-    return `<path d="${rt(t)}" />`;
-  if (t instanceof Lt)
-    return `<path d="${Ot(t)}" />`;
-  if (t instanceof P || t instanceof p)
-    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${R(
+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(
       t
     )}" />`;
   throw new Error("Unknown shape type");
 }
-const Z = (t) => "shape" in t ? t.shape : t, H = (t, n) => {
+const W = (t) => "shape" in t ? t.shape : t, X = (t, n) => {
   if (!("shape" in t))
     return n;
   const { color: e } = t;
   return e ? `<g stroke="${e}">${n}</g>` : n;
 };
-function Yt(t, n = 1) {
+function Rt(t, n = 1) {
   if (Array.isArray(t)) {
-    const r = t.map((o) => Z(o).mirror()), s = r.map((o, u) => H(t[u], X(o))).join(`
-`), i = r.slice(1).reduce((o, u) => o.merge(u.boundingBox), r[0].boundingBox);
-    return J(s, i);
+    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 e = Z(t).mirror();
-  return J(
-    H(t, X(e)),
+  const e = W(t).mirror();
+  return B(
+    X(t, J(e)),
     e.boundingBox,
     n
   );
 }
-const st = (t) => {
+const _ = (t) => {
   if (t.type === "LINE")
-    return new p(t.firstPoint, t.lastPoint);
+    return new d(t.firstPoint, t.lastPoint);
   if (t.type === "ARC")
-    return new P(
+    return new w(
       t.firstPoint,
       t.lastPoint,
       t.center,
       t.clockwise
     );
   throw new Error("Unknown segment type");
-}, O = (t) => {
-  const n = t.segments.map(st);
-  return new M(n);
-}, ot = (t) => {
-  const n = O(t.contour), e = t.holes.map(O);
-  return new T(n, e);
-}, _t = (t) => {
-  const n = t.figures.map(ot);
-  return new g(n);
+}, 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);
 };
-function qt(t) {
+function Ut(t) {
   if (t.type === "DIAGRAM")
-    return _t(t);
+    return It(t);
   if (t.type === "FIGURE")
-    return ot(t);
+    return j(t);
   if (t.type === "LOOP")
-    return O(t);
+    return k(t);
   if (t.type === "LINE" || t.type === "ARC")
-    return st(t);
+    return _(t);
   throw new Error("Unknown shape type");
 }
-const K = Math.PI / 180, Vt = 180 / Math.PI;
-function zt(t, n) {
-  const e = Math.cos(n * K) * t, r = Math.sin(n * K) * t;
+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];
 }
-function Wt([t, n]) {
-  const e = Math.sqrt(t * t + n * n), r = Math.atan2(n, t) * Vt;
+function zt([t, n]) {
+  const e = Math.sqrt(t * t + n * n), r = Math.atan2(n, t) * kt;
   return [e, r];
 }
 export {
-  K as DEG2RAD,
-  Vt as RAD2DEG,
-  Wt as cartesianToPolar,
+  Y as DEG2RAD,
+  kt as RAD2DEG,
+  zt as cartesianToPolar,
+  Vt as confineStrand,
   Mt as cut,
-  Gt as draw,
-  Zt as exportJSON,
-  Yt as exportSVG,
-  Ft as fuse,
-  U as fuseAll,
-  qt as importJSON,
-  Nt as intersect,
-  Ut as offset,
-  zt as polarToCartesian,
-  X as svgBody
+  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
 };
 //# sourceMappingURL=pantograph.js.map