pantograph2d 0.8.1 → 0.9.1

package/dist/pantograph.js

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