pantograph2d 0.10.0 → 0.11.0

package/dist/pantograph.js

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