pantograph2d 0.9.0 → 0.10.0

package/dist/pantograph.js

@@ -1,209 +1,209 @@
-var bt = Object.defineProperty;
-var Lt = (t, n, e) => n in t ? bt(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
-var P = (t, n, e) => Lt(t, typeof n != "symbol" ? n + "" : n, e);
-import { o as At, D as T } from "./draw-N2ntigsw.js";
-import { d as Cn } from "./draw-N2ntigsw.js";
-import { F as w, L as S, D as g, a as _, s as vt, b as kt, c as Et, i as yt, S as R, l as Ft, p as Ct, d as xt, e as rt, g as Dt } from "./models-BjaFYsN2.js";
-import { h as Dn } from "./models-BjaFYsN2.js";
-import { r as Ot, z as Rt, l as Bt, e as L, n as ot, b as y, a as zt, s as Tt, m as $t, o as at, L as I, A as E, C as B, p as J, q as Q, d as Gt, T as Ut, g as A, E as ct, Q as ft, t as _t, c as Vt, B as qt } from "./QuadraticBezier-PcRS9HZK.js";
-import { s as Nt, a as Jt, b as Qt, c as Zt, d as Ht, w as Z } from "./svg-hNHYuj_r.js";
-function v(t) {
-  if (t instanceof w)
-    return [t];
-  if (t instanceof S)
-    return [new w(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-lOWnIN1o.js";
+import { a as _n, d as Vn } from "./draw-lOWnIN1o.js";
+import { F as m, L as w, D as h, a as N, s as Dt, b as Ot, 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-DCkOI0hV.js";
+import { h as qn } from "./models-DCkOI0hV.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 lt(t, n, e = 1e-9) {
+function mt(n, t, e = 1e-9) {
   let s = [];
-  const r = [], i = new Array(n.segments.length).fill(0).map(() => []);
-  n.segments.forEach((f, c) => {
-    t.segments.forEach((a) => {
-      const { intersections: l, overlaps: p } = _(
-        f,
+  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,
+        c,
         e
       );
-      s.push(...l), i[c].push(...l), r.push(...p);
-      const h = p.flatMap((d) => [
+      s.push(...l), i[f].push(...l), r.push(...p);
+      const g = p.flatMap((d) => [
         d.firstPoint,
         d.lastPoint
       ]);
-      s.push(...h), i[c].push(...h);
+      s.push(...g), i[f].push(...g);
     });
-  }), s = Ot(s, e);
-  const o = Rt([n.segments, i]).flatMap(([f, c]) => c.length ? f.splitAt(c) : [f]);
+  }), s = Ut(s, e);
+  const o = _t([t.segments, i]).flatMap(([a, f]) => f.length ? a.splitAt(f) : [a]);
   return Array.from(
-    vt(
+    Dt(
       o,
       s,
       r
     )
   );
 }
-function V(t, n, e = !1) {
-  return lt(n, t).filter((r) => {
+function J(n, t, e = !1) {
+  return mt(t, n).filter((r) => {
     const i = r.segments[0].midPoint;
-    return n.onStroke(i) ? !e : !n.contains(i);
+    return t.onStroke(i) ? !e : !t.contains(i);
   });
 }
-function q(t, n, e = !1) {
-  return lt(n, t).filter((r) => {
+function Q(n, t, e = !1) {
+  return mt(t, n).filter((r) => {
     const i = r.segments[0].midPoint;
-    return n.onStroke(i) ? !e : n.contains(i);
+    return t.onStroke(i) ? !e : t.contains(i);
   });
 }
-function H(t, n, e = !1) {
-  const s = V(
-    t,
-    n.contour,
+function W(n, t, e = !1) {
+  const s = J(
+    n,
+    t.contour,
     e
-  ), r = n.holes.flatMap(
-    (i) => q(t, i, e)
+  ), r = t.holes.flatMap(
+    (i) => Q(n, i, e)
   );
   return [...s, ...r];
 }
-function W(t, n, e = !1) {
-  let s = q(
-    t,
-    n.contour,
+function j(n, t, e = !1) {
+  let s = Q(
+    n,
+    t.contour,
     e
   );
-  return n.holes.forEach((r) => {
+  return t.holes.forEach((r) => {
     s = s.flatMap(
-      (i) => V(i, r, e)
+      (i) => J(i, r, e)
     );
   }), s;
 }
-function Wt(t, n) {
-  return new g(
-    kt(v(t), v(n))
+function sn(n, t) {
+  return new h(
+    Ot(L(n), L(t))
   );
 }
-function D(t) {
-  return t.reduce(
-    (n, e) => Wt(n, e),
-    new g()
+function z(n) {
+  return n.reduce(
+    (t, e) => sn(t, e),
+    new h()
   );
 }
-function ut(t, n) {
-  return new g(
-    Et(v(t), v(n))
+function Pt(n, t) {
+  return new h(
+    Bt(L(n), L(t))
   );
 }
-function Mn(t, n) {
-  return new g(
-    yt(v(t), v(n))
+function yn(n, t) {
+  return new h(
+    Rt(L(n), L(t))
   );
 }
-function In(t, n, e = !0) {
-  if (n instanceof S)
-    return V(t, n, e);
-  if (n instanceof w)
-    return H(t, n, e);
-  let s = [new R([...t.segments])];
-  return n.figures.forEach((r) => {
-    s = s.flatMap((i) => H(i, r, e));
+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 Sn(t, n, e = !1) {
-  if (n instanceof S)
-    return q(t, n, e);
-  if (n instanceof w)
-    return W(t, n, e);
-  let s = [new R([...t.segments])];
-  return n.figures.forEach((r) => {
-    s = s.flatMap((i) => W(i, r, e));
+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 X(t) {
-  return t < 0 ? "before" : t > 1 ? "after" : "between";
+function tt(n) {
+  return n < 0 ? "before" : n > 1 ? "after" : "between";
 }
-const Y = (t, n, e) => {
+const nt = (n, t, e) => {
   if (e === "before")
-    return t.distanceFrom(n.firstPoint);
+    return n.distanceFrom(t.firstPoint);
   if (e === "after")
-    return t.distanceFrom(n.lastPoint);
+    return n.distanceFrom(t.lastPoint);
   throw new Error("Invalid position");
 };
-function Xt(t, n) {
-  const e = Bt(t, n);
+function rn(n, t) {
+  const e = Vt(n, t);
   if (e === "parallel")
     return Math.min(
-      t.distanceFrom(n.firstPoint),
-      t.distanceFrom(n.lastPoint)
+      n.distanceFrom(t.firstPoint),
+      n.distanceFrom(t.lastPoint)
     );
-  const { intersectionParam1: s, intersectionParam2: r } = e, i = X(s), o = X(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 Y(t, n, o);
+    return nt(n, t, o);
   if (o === "between" && i !== "between")
-    return Y(n, t, i);
+    return nt(t, n, i);
   if (i === "before" && o === "before")
-    return L(t.firstPoint, n.firstPoint);
+    return b(n.firstPoint, t.firstPoint);
   if (i === "after" && o === "after")
-    return L(t.lastPoint, n.lastPoint);
+    return b(n.lastPoint, t.lastPoint);
   if (i === "before" && o === "after")
-    return L(t.firstPoint, n.lastPoint);
+    return b(n.firstPoint, t.lastPoint);
   if (i === "after" && o === "before")
-    return L(t.lastPoint, n.firstPoint);
+    return b(n.lastPoint, t.firstPoint);
   throw new Error("Invalid position");
 }
-function K(t, n) {
-  if (Ft(t, n).length > 0)
+function et(n, t) {
+  if (zt(n, t).length > 0)
     return 0;
-  const e = Ct(t, n.center);
-  if (t.isOnSegment(e)) {
-    const s = L(e, n.center);
-    if (Math.abs(s - n.radius) < t.precision && n.isOnSegment(e))
+  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 - n.radius > t.precision) {
-      const r = ot(
-        y(e, n.center)
-      ), i = zt(
-        n.center,
-        Tt(r, n.radius)
+    if (s - t.radius > n.precision) {
+      const r = ht(
+        F(e, t.center)
+      ), i = Kt(
+        t.center,
+        qt(r, t.radius)
       );
-      if (n.isOnSegment(i))
-        return L(i, e);
+      if (t.isOnSegment(i))
+        return b(i, e);
     }
   }
   return Math.min(
-    n.distanceFrom(t.firstPoint),
-    n.distanceFrom(t.lastPoint),
     t.distanceFrom(n.firstPoint),
-    t.distanceFrom(n.lastPoint)
+    t.distanceFrom(n.lastPoint),
+    n.distanceFrom(t.firstPoint),
+    n.distanceFrom(t.lastPoint)
   );
 }
-const Yt = (t, n) => {
-  const e = t.angleToParam(n.firstAngle);
-  if (t.isValidParameter(e)) return !0;
-  const s = t.angleToParam(n.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 Kt(t, n) {
-  if (xt(t, n, !0).length > 0) return 0;
-  const e = L(t.center, n.center);
-  if (e < t.precision && Yt(t, n))
-    return Math.abs(t.radius - n.radius);
-  const s = ot(y(n.center, t.center)), r = e - Math.abs(t.radius - n.radius) < t.precision;
-  let i = $t(s);
-  r && n.radius > t.radius && (i += Math.PI);
-  const o = r ? i : i + Math.PI, f = t.angleToParam(i), c = n.angleToParam(o);
-  return t.isValidParameter(f) && n.isValidParameter(c) ? L(t.paramPoint(f), n.paramPoint(c)) : Math.min(
-    t.distanceFrom(n.firstPoint),
-    t.distanceFrom(n.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)
+    n.distanceFrom(t.lastPoint),
+    t.distanceFrom(n.firstPoint),
+    t.distanceFrom(n.lastPoint)
   );
 }
-function jt(t, n, e) {
-  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 = e(t[i], n);
+    const i = Math.floor((s + r) / 2), o = e(n[i], t);
     if (o < 0)
       s = i + 1;
     else if (o > 0)
@@ -213,471 +213,667 @@ function jt(t, n, e) {
   }
   return -(s + 1);
 }
-function tn(t, n, e) {
-  const s = jt(t, n, e);
-  s < 0 ? t.splice(-(s + 1), 0, n) : t.splice(s, 0, n);
+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 nn {
+class ln {
   constructor() {
     P(this, "buckets");
     this.buckets = [];
   }
-  addInterval(n) {
-    const e = this.buckets[n.rectangle.diagonalBucketIndex];
-    e === void 0 ? this.buckets[n.rectangle.diagonalBucketIndex] = [n] : tn(e, n, (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(n) {
-    const e = this.buckets[n.rectangle.diagonalBucketIndex];
+  removeInterval(t) {
+    const e = this.buckets[t.rectangle.diagonalBucketIndex];
     if (e === void 0)
       throw new Error("Interval not found");
     e.shift();
   }
   getBottomRightHullIntervals() {
-    const 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 (!n.length) {
-          n.push(r);
+        if (!t.length) {
+          t.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], f = (r.value - o.value) / ((r.rectangle.diagonal - o.rectangle.diagonal) * 2);
-          if (o.value + (i.rectangle.diagonal - o.rectangle.diagonal) / 2 * f < i.value)
-            n.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;
         }
-        n.push(r);
+        t.push(r);
       }
     }
-    return n;
+    return t;
   }
 }
-class en {
-  constructor(n, e) {
+class un {
+  constructor(t, e) {
     P(this, "diagonal");
     P(this, "diagonalBucketIndex");
     P(this, "xLength");
     P(this, "yLength");
     P(this, "index");
-    this.x = n, this.y = e, this.xLength = Math.pow(3, -n), this.yLength = Math.pow(3, -e), this.diagonal = Math.sqrt(
+    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 = n + e, this.index = `${n},${e}`;
+    ), this.diagonalBucketIndex = t + e, this.index = `${t},${e}`;
   }
 }
-class sn {
-  constructor(n, e = 1e-8, s = 1e3, r = 1e-6) {
+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 = 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 nn();
-    const i = [0.5, 0.5], o = this.rect(0, 0), f = this.fcn(i);
-    this.buckets.addInterval(new x(i, f, o)), this.fMin = f, this.argMin = i, this.tol = o.diagonal;
+    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 O(i, a, o)), this.fMin = a, 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);
+  registerInterval(t) {
+    this.buckets.addInterval(t), t.value <= this.fMin && (this.fMin = t.value, this.argMin = t.center, this.tol = t.rectangle.diagonal);
   }
-  rect(n, e) {
-    const s = `${n},${e}`;
-    return this.rectangles.has(s) || this.rectangles.set(s, new en(n, e)), this.rectangles.get(s);
+  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(n) {
+  splitInterval(t) {
     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 x(s, this.fcn(s), e),
-      new x(n.center, n.value, e),
-      new x(r, this.fcn(r), e)
+    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 O(s, this.fcn(s), e),
+      new O(t.center, t.value, e),
+      new O(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;
+    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)
-        n.shift();
+        t.shift();
       else
         break;
     }
-    n.forEach((e) => {
+    t.forEach((e) => {
       this.buckets.removeInterval(e);
     });
-    for (const e of n) {
+    for (const e of t) {
       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)); )
+    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: n
+      iterations: t
     };
   }
 }
-class x {
-  constructor(n, e, s) {
-    this.center = n, this.value = e, this.rectangle = s;
+class O {
+  constructor(t, e, s) {
+    this.center = t, this.value = e, this.rectangle = s;
   }
 }
-function rn(t, n = 1e-8, e = 1e3, s = 1e-6) {
-  return new sn(
-    t,
+function gn(n, t = 1e-8, e = 1e3, s = 1e-6) {
+  return new hn(
     n,
+    t,
     e,
     s
   ).run();
 }
-function on(t, n, e = 1e-9) {
-  const s = rn((r) => {
-    const i = t.paramPoint(r[0]), o = n.paramPoint(r[1]);
-    return at(i, o);
+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 an(t, n) {
-  return t instanceof I && n instanceof I ? Xt(t, n) : t instanceof I && n instanceof E ? K(t, n) : t instanceof E && n instanceof I ? K(n, t) : t instanceof E && n instanceof E ? Kt(t, n) : on(t, n);
+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);
 }
-function ht(t) {
-  if (t instanceof B) {
-    const r = y(t.lastPoint, t.firstPoint), i = y(t.firstControlPoint, t.firstPoint), o = y(t.lastControlPoint, t.firstPoint), f = Q(r, i), c = Q(r, o);
-    if (f > 0 && c < 0 || f < 0 && c > 0) return !1;
+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 n = J(t.tangentAtFirstPoint), e = J(t.tangentAtLastPoint);
-  let s = Gt(n, e);
+  const t = Y(n.tangentAtFirstPoint), e = Y(n.tangentAtLastPoint);
+  let s = Nt(t, e);
   return Math.abs(Math.acos(s)) < Math.PI / 3;
 }
-function $(t) {
-  if (ht(t)) return [t];
-  const [n, e] = t.splitAtParameters([0.5]);
+function K(n) {
+  if (wt(n)) return [n];
+  const [t, e] = n.splitAtParameters([0.5]);
   return [
-    ...$(n),
-    ...$(e)
+    ...K(t),
+    ...K(e)
   ];
 }
-function j(t) {
-  return ht(t) ? [t] : t.splitAtParameters(t.getParametersOfExtrema()).flatMap($);
+function st(n) {
+  return wt(n) ? [n] : n.splitAtParameters(n.getParametersOfExtrema()).flatMap(K);
 }
-function cn(t) {
-  const n = t.deltaAngle, e = Math.ceil(Math.abs(n) / (Math.PI / 2)), s = n / e, r = 4 * Math.tan(s / 4) / 3, i = t.clockwise ? -1 : 1, o = Array.from(
+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 },
-    (c, a) => t.firstAngle + a * s * i
+    (f, c) => n.firstAngle + c * s * i
   );
-  return o.slice(0, -1).map((c, a) => [c, o[a + 1]]).map(([c, a]) => {
-    const l = Math.cos(c), p = Math.sin(c), h = Math.cos(a), d = Math.sin(a), [u, M] = t.center, m = t.minorRadius, b = t.majorRadius, k = new Ut().rotate(
-      t.tiltAngle,
-      t.center
-    ), F = (St) => k.transform(St), C = F([u + b * l, M + m * p]), z = F([
-      u + b * (l - r * p * i),
-      M + m * (p + r * l * i)
-    ]), Mt = F([
-      u + b * (h + r * d * i),
-      M + m * (d - r * h * i)
-    ]), It = F([u + b * h, M + m * d]);
-    return new B(C, It, z, Mt);
+  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), D = 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 $(D, Et, G, kt);
   });
 }
-const N = 1e-8, gt = (t) => t.flatMap((n) => n instanceof I ? [n] : n instanceof E ? [n] : n instanceof ct ? cn(n).flatMap(
-  (e) => j(e)
-) : n instanceof ft || n instanceof B ? j(n) : [new I(n.firstPoint, n.lastPoint)]);
-function G(t, n, e = !0) {
-  const s = t.map((a) => ({
-    offset: At(a, n),
-    original: a
+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 = e ? null : s.at(-1), o = e ? s.at(-1) : null;
   if (r.length === 1) return r;
-  const f = (a) => {
-    i ? a.offset instanceof T ? A(a.offset.firstPoint, a.offset.lastPoint) || r.push(
-      new I(a.offset.firstPoint, a.offset.lastPoint)
-    ) : r.push(a.offset) : i = a;
-  }, c = function* () {
-    for (const a of s.slice(0, -1))
-      yield 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 c of s.slice(0, -1))
+      yield c;
     if (!i) throw new Error("Bug in the offset algorithm");
     yield i;
   };
-  for (const a of c()) {
+  for (const c of f()) {
     if (!o) {
-      o = a;
+      o = c;
       continue;
     }
-    const l = o.offset.lastPoint, p = a.offset.firstPoint;
-    if (A(l, p)) {
-      f(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 T) && !(a.offset instanceof T)) {
-      const { intersections: m, overlaps: b } = _(
+    let g = [];
+    if (!(o.offset instanceof U) && !(c.offset instanceof U)) {
+      const { intersections: M, overlaps: v } = N(
         o.offset,
-        a.offset,
-        N / 100
+        c.offset,
+        X / 100
       );
-      h = [
-        ...m,
-        ...b.flatMap((k) => [k.firstPoint, k.lastPoint])
+      g = [
+        ...M,
+        ...v.flatMap((k) => [k.firstPoint, k.lastPoint])
       ];
     }
-    if (h.length > 0) {
-      let m = h[0];
-      if (h.length > 1) {
-        const F = o == null ? void 0 : o.original.lastPoint, C = h.map(
-          (z) => at(z, F)
+    if (g.length > 0) {
+      let M = g[0];
+      if (g.length > 1) {
+        const C = o == null ? void 0 : o.original.lastPoint, D = g.map(
+          (G) => gt(G, C)
         );
-        m = h[C.indexOf(Math.min(...C))];
+        M = g[D.indexOf(Math.min(...D))];
       }
-      const b = o.offset.splitAt([
-        m
-      ])[0], k = a.offset.splitAt([m]).at(-1);
+      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");
-      f({
-        offset: b,
+      a({
+        offset: v,
         original: o.original
-      }), o = { offset: k, original: a.original };
+      }), o = { offset: k, original: c.original };
       continue;
     }
-    const d = o.original.lastPoint, u = Vt(
-      y(p, d),
-      y(l, d)
-    ) > 0, M = new E(l, p, d, u);
-    f(o), r.push(M), o = a;
-  }
-  return o && f(o), r;
-}
-function pt(t) {
-  const n = /* @__PURE__ */ new Map(), e = (s, r) => {
-    const i = n.get(s) || [];
-    n.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: f, overlaps: c } = _(s, i, N), a = [
-        ...f,
-        ...c.flatMap((l) => [l.firstPoint, l.lastPoint])
+  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 = A(l, s.firstPoint) || A(l, s.lastPoint), h = A(l, i.firstPoint) || A(l, i.lastPoint);
-        return !(p && h);
+        const p = I(l, s.firstPoint) || I(l, s.lastPoint), g = I(l, i.firstPoint) || I(l, i.lastPoint);
+        return !(p && g);
       });
-      a.length && (e(r, a), e(o + r + 1, a));
+      c.length && (e(r, c), e(o + r + 1, c));
     });
-  }), n;
+  }), t;
 }
-function dt(t, n) {
-  return n.flatMap((e, s) => {
-    if (!t.has(s)) return e;
-    const r = t.get(s);
+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 Pt(t, n, e) {
-  return t.filter((s) => !n.segments.some((i) => an(i, s) < Math.abs(e) - N));
+function bt(n, t, e) {
+  return n.filter((s) => !t.segments.some((i) => dn(i, s) < Math.abs(e) - X));
 }
-function O(t, n) {
-  const e = t.clockwise ? n : -n, s = gt(t.segments), r = G(s, e);
-  if (r.length < 2) return new g();
-  const i = pt(r);
+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 S(r);
-    return new g([new w(l)]);
+    const l = new w(r);
+    return new h([new m(l)]);
   }
-  const o = dt(
+  const o = St(
     i,
     r
-  ), f = Pt(o, t, n);
-  if (!f.length) return new g();
-  const a = rt(f).filter((l) => l.length > 1).filter((l) => A(l[0].firstPoint, l.at(-1).lastPoint)).map((l) => new S(l));
-  return a.length ? new g(a.map((l) => new w(l))) : new g();
+  ), 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 fn(t, n, e = "round") {
-  const s = n / 2, r = gt(t.segments), i = G(r, s, !1), o = G(
+function Pn(n, t, e = "round") {
+  const s = t / 2, r = Mt(n.segments), i = q(r, s, !1), o = q(
     r,
     -s,
     !1
   ).map((u) => u.reverse());
   o.reverse();
-  const f = (u, M) => e === "round" ? _t(
+  const a = (u, S) => e === "round" ? Qt(
     u.lastPoint,
-    M.firstPoint,
+    S.firstPoint,
     u.tangentAtLastPoint
-  ) : new I(u.lastPoint, M.firstPoint), c = [
+  ) : new A(u.lastPoint, S.firstPoint), f = [
     ...i,
-    f(
+    a(
       i[i.length - 1],
       o[0]
     ),
     ...o,
-    f(
+    a(
       o[o.length - 1],
       i[0]
     )
-  ], a = pt(c);
-  if (!a.size) {
-    const u = new S(c);
-    return new g([new w(u)]);
-  }
-  const l = dt(
-    a,
-    c
-  ), p = Pt(l, t, s);
-  if (!p.length) return new g();
-  const d = rt(p).filter((u) => u.length > 1).filter((u) => A(u[0].firstPoint, u.at(-1).lastPoint)).map((u) => new S(u));
-  return d.length ? new g(d.map((u) => new w(u))) : new g();
-}
-function ln(t, n) {
-  const e = t.map((s) => {
-    const r = D(
-      s.holes.map((i) => O(i, n))
+  ], 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 ut(O(s.contour, n), r);
+    return Pt(T(s.contour, t), r);
   });
-  return D(e);
+  return z(e);
 }
-function un(t, n) {
-  const e = Math.abs(n / 2), s = t.map(
-    (r) => D(
-      r.allLoops.map((i) => ut(O(i, e), O(i, -e)))
+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 D(s);
+  return z(s);
 }
-function bn(t, n) {
-  return ln(v(t), n);
+function Dn(n, t) {
+  return wn(L(n), t);
 }
-function Ln(t, n, { endCap: e = "round" } = {}) {
-  return t instanceof R ? fn(t, n, e) : un(v(t), n);
+function On(n, t, { endCap: e = "round" } = {}) {
+  return n instanceof y ? Pn(n, t, e) : Mn(L(n), t);
 }
-function tt(t) {
-  if (t instanceof g)
-    return Nt(t);
-  if (t instanceof w)
-    return Jt(t);
-  if (t instanceof S)
-    return `<path d="${Qt(t)}" />`;
-  if (t instanceof R)
-    return `<path d="${Zt(t)}" />`;
-  if (Dt(t))
-    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${Ht(
-      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 nt = (t) => "shape" in t ? t.shape : t, et = (t, n) => {
-  if (!("shape" in t)) return n;
-  const { color: e } = t;
-  return e ? `<g stroke="${e}">${n}</g>` : n;
-}, st = (t) => new qt(t.xMin, -t.yMax, t.xMax, -t.yMin);
-function An(t, {
-  margin: n = 1,
+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((c) => nt(c).mirror()), o = i.map((c, a) => et(t[a], tt(c))).join(`
-`), f = i.slice(1).reduce((c, a) => c.merge(a.boundingBox), i[0].boundingBox);
-    return Z(o, s ? st(s) : f, n, e);
+  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 = nt(t).mirror();
+  const r = ot(n).mirror();
   return Z(
-    et(t, tt(r)),
-    s ? st(s) : r.boundingBox,
-    n,
+    at(n, it(r)),
+    s ? ct(s) : r.boundingBox,
+    t,
     e
   );
 }
-const mt = (t) => {
-  if (t.type === "LINE")
-    return new I(t.firstPoint, t.lastPoint);
-  if (t.type === "ARC")
+const vt = (n) => {
+  if (n.type === "LINE")
+    return new A(n.firstPoint, n.lastPoint);
+  if (n.type === "ARC")
     return new E(
-      t.firstPoint,
-      t.lastPoint,
-      t.center,
-      t.clockwise
+      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 ft(
-      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 B(
-      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");
-}, U = (t) => {
-  const n = t.segments.map(mt);
-  return new S(n);
-}, wt = (t) => {
-  const n = U(t.contour), e = t.holes.map(U);
-  return new w(n, e);
-}, hn = (t) => {
-  const n = t.figures.map(wt);
-  return new g(n);
+}, 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 vn(t) {
-  if (t.type === "DIAGRAM")
-    return hn(t);
-  if (t.type === "FIGURE")
-    return wt(t);
-  if (t.type === "LOOP")
-    return U(t);
-  if (t.type === "LINE" || t.type === "ARC" || t.type === "ELLIPSE_ARC" || t.type === "CUBIC_BEZIER")
-    return mt(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 it = Math.PI / 180, gn = 180 / Math.PI;
-function kn(t, n) {
-  const e = Math.cos(n * it) * t, s = Math.sin(n * it) * t;
+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 En([t, n]) {
-  const e = Math.sqrt(t * t + n * n), s = Math.atan2(n, t) * gn;
+function $n([n, t]) {
+  const e = Math.sqrt(n * n + t * t), s = Math.atan2(t, n) * An;
   return [e, s];
 }
 export {
-  it as DEG2RAD,
-  gn as RAD2DEG,
-  En as cartesianToPolar,
-  Sn as confineStrand,
-  ut as cut,
-  Cn as draw,
-  In as eraseStrand,
-  Dn as exportJSON,
-  An as exportSVG,
-  Wt as fuse,
-  D as fuseAll,
-  vn as importJSON,
-  Mn as intersect,
-  bn as offset,
-  Ln as outlineStroke,
-  kn as polarToCartesian,
-  tt as svgBody
+  ft as DEG2RAD,
+  _n as DrawingPen,
+  An as RAD2DEG,
+  $n as cartesianToPolar,
+  R as chamfer,
+  xn as confineStrand,
+  Pt as cut,
+  Vn as draw,
+  Cn as eraseStrand,
+  qn as exportJSON,
+  Rn as exportSVG,
+  B as fillet,
+  sn as fuse,
+  z as fuseAll,
+  zn as importJSON,
+  yn as intersect,
+  Dn as offset,
+  On as outlineStroke,
+  Tn as polarToCartesian,
+  Bn as selectCorners,
+  it as svgBody
 };
 //# sourceMappingURL=pantograph.js.map