gs-maplibre-draw 0.0.3 → 0.0.5

package/dist/index.js

@@ -1,8 +1,8 @@
-const { abs: R, cos: N, sin: U, acos: et, atan2: J, sqrt: F, pow: L } = Math;
-function $(o) {
-  return o < 0 ? -L(-o, 1 / 3) : L(o, 1 / 3);
+const { abs: pt, cos: ot, sin: ut, acos: ye, atan2: gt, sqrt: lt, pow: W } = Math;
+function mt(n) {
+  return n < 0 ? -W(-n, 1 / 3) : W(n, 1 / 3);
 }
-const tt = Math.PI, X = 2 * tt, P = tt / 2, nt = 1e-6, Q = Number.MAX_SAFE_INTEGER || 9007199254740991, H = Number.MIN_SAFE_INTEGER || -9007199254740991, it = { x: 0, y: 0, z: 0 }, y = {
+const Wt = Math.PI, Mt = 2 * Wt, ct = Wt / 2, de = 1e-6, Xt = Number.MAX_SAFE_INTEGER || 9007199254740991, Yt = Number.MIN_SAFE_INTEGER || -9007199254740991, pe = { x: 0, y: 0, z: 0 }, _ = {
   // Legendre-Gauss abscissae with n=24 (x_i values, defined at i=n as the roots of the nth order Legendre polynomial Pn(x))
   Tvalues: [
     -0.06405689286260563,
@@ -57,374 +57,374 @@ const tt = Math.PI, X = 2 * tt, P = tt / 2, nt = 1e-6, Q = Number.MAX_SAFE_INTEG
     0.0123412297999872,
     0.0123412297999872
   ],
-  arcfn: function(o, e) {
-    const n = e(o);
-    let i = n.x * n.x + n.y * n.y;
-    return typeof n.z < "u" && (i += n.z * n.z), F(i);
+  arcfn: function(n, e) {
+    const r = e(n);
+    let i = r.x * r.x + r.y * r.y;
+    return typeof r.z < "u" && (i += r.z * r.z), lt(i);
   },
-  compute: function(o, e, n) {
-    if (o === 0)
+  compute: function(n, e, r) {
+    if (n === 0)
       return e[0].t = 0, e[0];
     const i = e.length - 1;
-    if (o === 1)
+    if (n === 1)
       return e[i].t = 1, e[i];
-    const s = 1 - o;
-    let c = e;
+    const o = 1 - n;
+    let s = e;
     if (i === 0)
-      return e[0].t = o, e[0];
+      return e[0].t = n, e[0];
     if (i === 1) {
       const l = {
-        x: s * c[0].x + o * c[1].x,
-        y: s * c[0].y + o * c[1].y,
-        t: o
+        x: o * s[0].x + n * s[1].x,
+        y: o * s[0].y + n * s[1].y,
+        t: n
       };
-      return n && (l.z = s * c[0].z + o * c[1].z), l;
+      return r && (l.z = o * s[0].z + n * s[1].z), l;
     }
     if (i < 4) {
-      let l = s * s, u = o * o, f, h, a, p = 0;
-      i === 2 ? (c = [c[0], c[1], c[2], it], f = l, h = s * o * 2, a = u) : i === 3 && (f = l * s, h = l * o * 3, a = s * u * 3, p = o * u);
-      const g = {
-        x: f * c[0].x + h * c[1].x + a * c[2].x + p * c[3].x,
-        y: f * c[0].y + h * c[1].y + a * c[2].y + p * c[3].y,
-        t: o
+      let l = o * o, c = n * n, f, g, y, d = 0;
+      i === 2 ? (s = [s[0], s[1], s[2], pe], f = l, g = o * n * 2, y = c) : i === 3 && (f = l * o, g = l * n * 3, y = o * c * 3, d = n * c);
+      const M = {
+        x: f * s[0].x + g * s[1].x + y * s[2].x + d * s[3].x,
+        y: f * s[0].y + g * s[1].y + y * s[2].y + d * s[3].y,
+        t: n
       };
-      return n && (g.z = f * c[0].z + h * c[1].z + a * c[2].z + p * c[3].z), g;
+      return r && (M.z = f * s[0].z + g * s[1].z + y * s[2].z + d * s[3].z), M;
     }
-    const r = JSON.parse(JSON.stringify(e));
-    for (; r.length > 1; ) {
-      for (let l = 0; l < r.length - 1; l++)
-        r[l] = {
-          x: r[l].x + (r[l + 1].x - r[l].x) * o,
-          y: r[l].y + (r[l + 1].y - r[l].y) * o
-        }, typeof r[l].z < "u" && (r[l].z = r[l].z + (r[l + 1].z - r[l].z) * o);
-      r.splice(r.length - 1, 1);
+    const a = JSON.parse(JSON.stringify(e));
+    for (; a.length > 1; ) {
+      for (let l = 0; l < a.length - 1; l++)
+        a[l] = {
+          x: a[l].x + (a[l + 1].x - a[l].x) * n,
+          y: a[l].y + (a[l + 1].y - a[l].y) * n
+        }, typeof a[l].z < "u" && (a[l].z = a[l].z + (a[l + 1].z - a[l].z) * n);
+      a.splice(a.length - 1, 1);
     }
-    return r[0].t = o, r[0];
+    return a[0].t = n, a[0];
   },
-  computeWithRatios: function(o, e, n, i) {
-    const s = 1 - o, c = n, r = e;
-    let l = c[0], u = c[1], f = c[2], h = c[3], a;
-    if (l *= s, u *= o, r.length === 2)
-      return a = l + u, {
-        x: (l * r[0].x + u * r[1].x) / a,
-        y: (l * r[0].y + u * r[1].y) / a,
-        z: i ? (l * r[0].z + u * r[1].z) / a : !1,
-        t: o
+  computeWithRatios: function(n, e, r, i) {
+    const o = 1 - n, s = r, a = e;
+    let l = s[0], c = s[1], f = s[2], g = s[3], y;
+    if (l *= o, c *= n, a.length === 2)
+      return y = l + c, {
+        x: (l * a[0].x + c * a[1].x) / y,
+        y: (l * a[0].y + c * a[1].y) / y,
+        z: i ? (l * a[0].z + c * a[1].z) / y : !1,
+        t: n
       };
-    if (l *= s, u *= 2 * s, f *= o * o, r.length === 3)
-      return a = l + u + f, {
-        x: (l * r[0].x + u * r[1].x + f * r[2].x) / a,
-        y: (l * r[0].y + u * r[1].y + f * r[2].y) / a,
-        z: i ? (l * r[0].z + u * r[1].z + f * r[2].z) / a : !1,
-        t: o
+    if (l *= o, c *= 2 * o, f *= n * n, a.length === 3)
+      return y = l + c + f, {
+        x: (l * a[0].x + c * a[1].x + f * a[2].x) / y,
+        y: (l * a[0].y + c * a[1].y + f * a[2].y) / y,
+        z: i ? (l * a[0].z + c * a[1].z + f * a[2].z) / y : !1,
+        t: n
       };
-    if (l *= s, u *= 1.5 * s, f *= 3 * s, h *= o * o * o, r.length === 4)
-      return a = l + u + f + h, {
-        x: (l * r[0].x + u * r[1].x + f * r[2].x + h * r[3].x) / a,
-        y: (l * r[0].y + u * r[1].y + f * r[2].y + h * r[3].y) / a,
-        z: i ? (l * r[0].z + u * r[1].z + f * r[2].z + h * r[3].z) / a : !1,
-        t: o
+    if (l *= o, c *= 1.5 * o, f *= 3 * o, g *= n * n * n, a.length === 4)
+      return y = l + c + f + g, {
+        x: (l * a[0].x + c * a[1].x + f * a[2].x + g * a[3].x) / y,
+        y: (l * a[0].y + c * a[1].y + f * a[2].y + g * a[3].y) / y,
+        z: i ? (l * a[0].z + c * a[1].z + f * a[2].z + g * a[3].z) / y : !1,
+        t: n
       };
   },
-  derive: function(o, e) {
-    const n = [];
-    for (let i = o, s = i.length, c = s - 1; s > 1; s--, c--) {
-      const r = [];
-      for (let l = 0, u; l < c; l++)
-        u = {
-          x: c * (i[l + 1].x - i[l].x),
-          y: c * (i[l + 1].y - i[l].y)
-        }, e && (u.z = c * (i[l + 1].z - i[l].z)), r.push(u);
-      n.push(r), i = r;
+  derive: function(n, e) {
+    const r = [];
+    for (let i = n, o = i.length, s = o - 1; o > 1; o--, s--) {
+      const a = [];
+      for (let l = 0, c; l < s; l++)
+        c = {
+          x: s * (i[l + 1].x - i[l].x),
+          y: s * (i[l + 1].y - i[l].y)
+        }, e && (c.z = s * (i[l + 1].z - i[l].z)), a.push(c);
+      r.push(a), i = a;
     }
-    return n;
+    return r;
   },
-  between: function(o, e, n) {
-    return e <= o && o <= n || y.approximately(o, e) || y.approximately(o, n);
+  between: function(n, e, r) {
+    return e <= n && n <= r || _.approximately(n, e) || _.approximately(n, r);
   },
-  approximately: function(o, e, n) {
-    return R(o - e) <= (n || nt);
+  approximately: function(n, e, r) {
+    return pt(n - e) <= (r || de);
   },
-  length: function(o) {
-    const n = y.Tvalues.length;
+  length: function(n) {
+    const r = _.Tvalues.length;
     let i = 0;
-    for (let s = 0, c; s < n; s++)
-      c = 0.5 * y.Tvalues[s] + 0.5, i += y.Cvalues[s] * y.arcfn(c, o);
+    for (let o = 0, s; o < r; o++)
+      s = 0.5 * _.Tvalues[o] + 0.5, i += _.Cvalues[o] * _.arcfn(s, n);
     return 0.5 * i;
   },
-  map: function(o, e, n, i, s) {
-    const c = n - e, r = s - i, l = o - e, u = l / c;
-    return i + r * u;
+  map: function(n, e, r, i, o) {
+    const s = r - e, a = o - i, l = n - e, c = l / s;
+    return i + a * c;
   },
-  lerp: function(o, e, n) {
+  lerp: function(n, e, r) {
     const i = {
-      x: e.x + o * (n.x - e.x),
-      y: e.y + o * (n.y - e.y)
+      x: e.x + n * (r.x - e.x),
+      y: e.y + n * (r.y - e.y)
     };
-    return e.z !== void 0 && n.z !== void 0 && (i.z = e.z + o * (n.z - e.z)), i;
+    return e.z !== void 0 && r.z !== void 0 && (i.z = e.z + n * (r.z - e.z)), i;
   },
-  pointToString: function(o) {
-    let e = o.x + "/" + o.y;
-    return typeof o.z < "u" && (e += "/" + o.z), e;
+  pointToString: function(n) {
+    let e = n.x + "/" + n.y;
+    return typeof n.z < "u" && (e += "/" + n.z), e;
   },
-  pointsToString: function(o) {
-    return "[" + o.map(y.pointToString).join(", ") + "]";
+  pointsToString: function(n) {
+    return "[" + n.map(_.pointToString).join(", ") + "]";
   },
-  copy: function(o) {
-    return JSON.parse(JSON.stringify(o));
+  copy: function(n) {
+    return JSON.parse(JSON.stringify(n));
   },
-  angle: function(o, e, n) {
-    const i = e.x - o.x, s = e.y - o.y, c = n.x - o.x, r = n.y - o.y, l = i * r - s * c, u = i * c + s * r;
-    return J(l, u);
+  angle: function(n, e, r) {
+    const i = e.x - n.x, o = e.y - n.y, s = r.x - n.x, a = r.y - n.y, l = i * a - o * s, c = i * s + o * a;
+    return gt(l, c);
   },
   // round as string, to avoid rounding errors
-  round: function(o, e) {
-    const n = "" + o, i = n.indexOf(".");
-    return parseFloat(n.substring(0, i + 1 + e));
+  round: function(n, e) {
+    const r = "" + n, i = r.indexOf(".");
+    return parseFloat(r.substring(0, i + 1 + e));
   },
-  dist: function(o, e) {
-    const n = o.x - e.x, i = o.y - e.y;
-    return F(n * n + i * i);
+  dist: function(n, e) {
+    const r = n.x - e.x, i = n.y - e.y;
+    return lt(r * r + i * i);
   },
-  closest: function(o, e) {
-    let n = L(2, 63), i, s;
-    return o.forEach(function(c, r) {
-      s = y.dist(e, c), s < n && (n = s, i = r);
-    }), { mdist: n, mpos: i };
+  closest: function(n, e) {
+    let r = W(2, 63), i, o;
+    return n.forEach(function(s, a) {
+      o = _.dist(e, s), o < r && (r = o, i = a);
+    }), { mdist: r, mpos: i };
   },
-  abcratio: function(o, e) {
+  abcratio: function(n, e) {
     if (e !== 2 && e !== 3)
       return !1;
-    if (typeof o > "u")
-      o = 0.5;
-    else if (o === 0 || o === 1)
-      return o;
-    const n = L(o, e) + L(1 - o, e), i = n - 1;
-    return R(i / n);
+    if (typeof n > "u")
+      n = 0.5;
+    else if (n === 0 || n === 1)
+      return n;
+    const r = W(n, e) + W(1 - n, e), i = r - 1;
+    return pt(i / r);
   },
-  projectionratio: function(o, e) {
+  projectionratio: function(n, e) {
     if (e !== 2 && e !== 3)
       return !1;
-    if (typeof o > "u")
-      o = 0.5;
-    else if (o === 0 || o === 1)
-      return o;
-    const n = L(1 - o, e), i = L(o, e) + n;
-    return n / i;
+    if (typeof n > "u")
+      n = 0.5;
+    else if (n === 0 || n === 1)
+      return n;
+    const r = W(1 - n, e), i = W(n, e) + r;
+    return r / i;
   },
-  lli8: function(o, e, n, i, s, c, r, l) {
-    const u = (o * i - e * n) * (s - r) - (o - n) * (s * l - c * r), f = (o * i - e * n) * (c - l) - (e - i) * (s * l - c * r), h = (o - n) * (c - l) - (e - i) * (s - r);
-    return h == 0 ? !1 : { x: u / h, y: f / h };
+  lli8: function(n, e, r, i, o, s, a, l) {
+    const c = (n * i - e * r) * (o - a) - (n - r) * (o * l - s * a), f = (n * i - e * r) * (s - l) - (e - i) * (o * l - s * a), g = (n - r) * (s - l) - (e - i) * (o - a);
+    return g == 0 ? !1 : { x: c / g, y: f / g };
   },
-  lli4: function(o, e, n, i) {
-    const s = o.x, c = o.y, r = e.x, l = e.y, u = n.x, f = n.y, h = i.x, a = i.y;
-    return y.lli8(s, c, r, l, u, f, h, a);
+  lli4: function(n, e, r, i) {
+    const o = n.x, s = n.y, a = e.x, l = e.y, c = r.x, f = r.y, g = i.x, y = i.y;
+    return _.lli8(o, s, a, l, c, f, g, y);
   },
-  lli: function(o, e) {
-    return y.lli4(o, o.c, e, e.c);
+  lli: function(n, e) {
+    return _.lli4(n, n.c, e, e.c);
   },
-  makeline: function(o, e) {
-    return new E(
-      o.x,
-      o.y,
-      (o.x + e.x) / 2,
-      (o.y + e.y) / 2,
+  makeline: function(n, e) {
+    return new U(
+      n.x,
+      n.y,
+      (n.x + e.x) / 2,
+      (n.y + e.y) / 2,
       e.x,
       e.y
     );
   },
-  findbbox: function(o) {
-    let e = Q, n = Q, i = H, s = H;
-    return o.forEach(function(c) {
-      const r = c.bbox();
-      e > r.x.min && (e = r.x.min), n > r.y.min && (n = r.y.min), i < r.x.max && (i = r.x.max), s < r.y.max && (s = r.y.max);
+  findbbox: function(n) {
+    let e = Xt, r = Xt, i = Yt, o = Yt;
+    return n.forEach(function(s) {
+      const a = s.bbox();
+      e > a.x.min && (e = a.x.min), r > a.y.min && (r = a.y.min), i < a.x.max && (i = a.x.max), o < a.y.max && (o = a.y.max);
     }), {
       x: { min: e, mid: (e + i) / 2, max: i, size: i - e },
-      y: { min: n, mid: (n + s) / 2, max: s, size: s - n }
+      y: { min: r, mid: (r + o) / 2, max: o, size: o - r }
     };
   },
-  shapeintersections: function(o, e, n, i, s) {
-    if (!y.bboxoverlap(e, i))
+  shapeintersections: function(n, e, r, i, o) {
+    if (!_.bboxoverlap(e, i))
       return [];
-    const c = [], r = [o.startcap, o.forward, o.back, o.endcap], l = [n.startcap, n.forward, n.back, n.endcap];
-    return r.forEach(function(u) {
-      u.virtual || l.forEach(function(f) {
+    const s = [], a = [n.startcap, n.forward, n.back, n.endcap], l = [r.startcap, r.forward, r.back, r.endcap];
+    return a.forEach(function(c) {
+      c.virtual || l.forEach(function(f) {
         if (f.virtual)
           return;
-        const h = u.intersects(f, s);
-        h.length > 0 && (h.c1 = u, h.c2 = f, h.s1 = o, h.s2 = n, c.push(h));
+        const g = c.intersects(f, o);
+        g.length > 0 && (g.c1 = c, g.c2 = f, g.s1 = n, g.s2 = r, s.push(g));
       });
-    }), c;
+    }), s;
   },
-  makeshape: function(o, e, n) {
-    const i = e.points.length, s = o.points.length, c = y.makeline(e.points[i - 1], o.points[0]), r = y.makeline(o.points[s - 1], e.points[0]), l = {
-      startcap: c,
-      forward: o,
+  makeshape: function(n, e, r) {
+    const i = e.points.length, o = n.points.length, s = _.makeline(e.points[i - 1], n.points[0]), a = _.makeline(n.points[o - 1], e.points[0]), l = {
+      startcap: s,
+      forward: n,
       back: e,
-      endcap: r,
-      bbox: y.findbbox([c, o, e, r])
+      endcap: a,
+      bbox: _.findbbox([s, n, e, a])
     };
-    return l.intersections = function(u) {
-      return y.shapeintersections(
+    return l.intersections = function(c) {
+      return _.shapeintersections(
         l,
         l.bbox,
-        u,
-        u.bbox,
-        n
+        c,
+        c.bbox,
+        r
       );
     }, l;
   },
-  getminmax: function(o, e, n) {
-    if (!n)
+  getminmax: function(n, e, r) {
+    if (!r)
       return { min: 0, max: 0 };
-    let i = Q, s = H, c, r;
-    n.indexOf(0) === -1 && (n = [0].concat(n)), n.indexOf(1) === -1 && n.push(1);
-    for (let l = 0, u = n.length; l < u; l++)
-      c = n[l], r = o.get(c), r[e] < i && (i = r[e]), r[e] > s && (s = r[e]);
-    return { min: i, mid: (i + s) / 2, max: s, size: s - i };
+    let i = Xt, o = Yt, s, a;
+    r.indexOf(0) === -1 && (r = [0].concat(r)), r.indexOf(1) === -1 && r.push(1);
+    for (let l = 0, c = r.length; l < c; l++)
+      s = r[l], a = n.get(s), a[e] < i && (i = a[e]), a[e] > o && (o = a[e]);
+    return { min: i, mid: (i + o) / 2, max: o, size: o - i };
   },
-  align: function(o, e) {
-    const n = e.p1.x, i = e.p1.y, s = -J(e.p2.y - i, e.p2.x - n), c = function(r) {
+  align: function(n, e) {
+    const r = e.p1.x, i = e.p1.y, o = -gt(e.p2.y - i, e.p2.x - r), s = function(a) {
       return {
-        x: (r.x - n) * N(s) - (r.y - i) * U(s),
-        y: (r.x - n) * U(s) + (r.y - i) * N(s)
+        x: (a.x - r) * ot(o) - (a.y - i) * ut(o),
+        y: (a.x - r) * ut(o) + (a.y - i) * ot(o)
       };
     };
-    return o.map(c);
+    return n.map(s);
   },
-  roots: function(o, e) {
+  roots: function(n, e) {
     e = e || { p1: { x: 0, y: 0 }, p2: { x: 1, y: 0 } };
-    const n = o.length - 1, i = y.align(o, e), s = function(x) {
+    const r = n.length - 1, i = _.align(n, e), o = function(x) {
       return 0 <= x && x <= 1;
     };
-    if (n === 2) {
-      const x = i[0].y, m = i[1].y, v = i[2].y, w = x - 2 * m + v;
-      if (w !== 0) {
-        const b = -F(m * m - x * v), k = -x + m, q = -(b + k) / w, M = -(-b + k) / w;
-        return [q, M].filter(s);
-      } else if (m !== v && w === 0)
-        return [(2 * m - v) / (2 * m - 2 * v)].filter(s);
+    if (r === 2) {
+      const x = i[0].y, v = i[1].y, S = i[2].y, X = x - 2 * v + S;
+      if (X !== 0) {
+        const Y = -lt(v * v - x * S), b = -x + v, N = -(Y + b) / X, R = -(-Y + b) / X;
+        return [N, R].filter(o);
+      } else if (v !== S && X === 0)
+        return [(2 * v - S) / (2 * v - 2 * S)].filter(o);
       return [];
     }
-    const c = i[0].y, r = i[1].y, l = i[2].y, u = i[3].y;
-    let f = -c + 3 * r - 3 * l + u, h = 3 * c - 6 * r + 3 * l, a = -3 * c + 3 * r, p = c;
-    if (y.approximately(f, 0)) {
-      if (y.approximately(h, 0))
-        return y.approximately(a, 0) ? [] : [-p / a].filter(s);
-      const x = F(a * a - 4 * h * p), m = 2 * h;
-      return [(x - a) / m, (-a - x) / m].filter(s);
+    const s = i[0].y, a = i[1].y, l = i[2].y, c = i[3].y;
+    let f = -s + 3 * a - 3 * l + c, g = 3 * s - 6 * a + 3 * l, y = -3 * s + 3 * a, d = s;
+    if (_.approximately(f, 0)) {
+      if (_.approximately(g, 0))
+        return _.approximately(y, 0) ? [] : [-d / y].filter(o);
+      const x = lt(y * y - 4 * g * d), v = 2 * g;
+      return [(x - y) / v, (-y - x) / v].filter(o);
     }
-    h /= f, a /= f, p /= f;
-    const g = (3 * a - h * h) / 3, _ = g / 3, C = (2 * h * h * h - 9 * h * a + 27 * p) / 27, A = C / 2, S = A * A + _ * _ * _;
-    let j, O, T, z, d;
-    if (S < 0) {
-      const x = -g / 3, m = x * x * x, v = F(m), w = -C / (2 * v), b = w < -1 ? -1 : w > 1 ? 1 : w, k = et(b), q = $(v), M = 2 * q;
-      return T = M * N(k / 3) - h / 3, z = M * N((k + X) / 3) - h / 3, d = M * N((k + 2 * X) / 3) - h / 3, [T, z, d].filter(s);
+    g /= f, y /= f, d /= f;
+    const M = (3 * y - g * g) / 3, k = M / 3, L = (2 * g * g * g - 9 * g * y + 27 * d) / 27, D = L / 2, O = D * D + k * k * k;
+    let u, h, m, p, w;
+    if (O < 0) {
+      const x = -M / 3, v = x * x * x, S = lt(v), X = -L / (2 * S), Y = X < -1 ? -1 : X > 1 ? 1 : X, b = ye(Y), N = mt(S), R = 2 * N;
+      return m = R * ot(b / 3) - g / 3, p = R * ot((b + Mt) / 3) - g / 3, w = R * ot((b + 2 * Mt) / 3) - g / 3, [m, p, w].filter(o);
     } else {
-      if (S === 0)
-        return j = A < 0 ? $(-A) : -$(A), T = 2 * j - h / 3, z = -j - h / 3, [T, z].filter(s);
+      if (O === 0)
+        return u = D < 0 ? mt(-D) : -mt(D), m = 2 * u - g / 3, p = -u - g / 3, [m, p].filter(o);
       {
-        const x = F(S);
-        return j = $(-A + x), O = $(A + x), [j - O - h / 3].filter(s);
+        const x = lt(O);
+        return u = mt(-D + x), h = mt(D + x), [u - h - g / 3].filter(o);
       }
     }
   },
-  droots: function(o) {
-    if (o.length === 3) {
-      const e = o[0], n = o[1], i = o[2], s = e - 2 * n + i;
-      if (s !== 0) {
-        const c = -F(n * n - e * i), r = -e + n, l = -(c + r) / s, u = -(-c + r) / s;
-        return [l, u];
-      } else if (n !== i && s === 0)
-        return [(2 * n - i) / (2 * (n - i))];
+  droots: function(n) {
+    if (n.length === 3) {
+      const e = n[0], r = n[1], i = n[2], o = e - 2 * r + i;
+      if (o !== 0) {
+        const s = -lt(r * r - e * i), a = -e + r, l = -(s + a) / o, c = -(-s + a) / o;
+        return [l, c];
+      } else if (r !== i && o === 0)
+        return [(2 * r - i) / (2 * (r - i))];
       return [];
     }
-    if (o.length === 2) {
-      const e = o[0], n = o[1];
-      return e !== n ? [e / (e - n)] : [];
+    if (n.length === 2) {
+      const e = n[0], r = n[1];
+      return e !== r ? [e / (e - r)] : [];
     }
     return [];
   },
-  curvature: function(o, e, n, i, s) {
-    let c, r, l, u, f = 0, h = 0;
-    const a = y.compute(o, e), p = y.compute(o, n), g = a.x * a.x + a.y * a.y;
-    if (i ? (c = F(
-      L(a.y * p.z - p.y * a.z, 2) + L(a.z * p.x - p.z * a.x, 2) + L(a.x * p.y - p.x * a.y, 2)
-    ), r = L(g + a.z * a.z, 3 / 2)) : (c = a.x * p.y - a.y * p.x, r = L(g, 3 / 2)), c === 0 || r === 0)
+  curvature: function(n, e, r, i, o) {
+    let s, a, l, c, f = 0, g = 0;
+    const y = _.compute(n, e), d = _.compute(n, r), M = y.x * y.x + y.y * y.y;
+    if (i ? (s = lt(
+      W(y.y * d.z - d.y * y.z, 2) + W(y.z * d.x - d.z * y.x, 2) + W(y.x * d.y - d.x * y.y, 2)
+    ), a = W(M + y.z * y.z, 3 / 2)) : (s = y.x * d.y - y.y * d.x, a = W(M, 3 / 2)), s === 0 || a === 0)
       return { k: 0, r: 0 };
-    if (f = c / r, h = r / c, !s) {
-      const _ = y.curvature(o - 1e-3, e, n, i, !0).k, C = y.curvature(o + 1e-3, e, n, i, !0).k;
-      u = (C - f + (f - _)) / 2, l = (R(C - f) + R(f - _)) / 2;
+    if (f = s / a, g = a / s, !o) {
+      const k = _.curvature(n - 1e-3, e, r, i, !0).k, L = _.curvature(n + 1e-3, e, r, i, !0).k;
+      c = (L - f + (f - k)) / 2, l = (pt(L - f) + pt(f - k)) / 2;
     }
-    return { k: f, r: h, dk: u, adk: l };
+    return { k: f, r: g, dk: c, adk: l };
   },
-  inflections: function(o) {
-    if (o.length < 4)
+  inflections: function(n) {
+    if (n.length < 4)
       return [];
-    const e = y.align(o, { p1: o[0], p2: o.slice(-1)[0] }), n = e[2].x * e[1].y, i = e[3].x * e[1].y, s = e[1].x * e[2].y, c = e[3].x * e[2].y, r = 18 * (-3 * n + 2 * i + 3 * s - c), l = 18 * (3 * n - i - 3 * s), u = 18 * (s - n);
-    if (y.approximately(r, 0)) {
-      if (!y.approximately(l, 0)) {
-        let p = -u / l;
-        if (0 <= p && p <= 1)
-          return [p];
+    const e = _.align(n, { p1: n[0], p2: n.slice(-1)[0] }), r = e[2].x * e[1].y, i = e[3].x * e[1].y, o = e[1].x * e[2].y, s = e[3].x * e[2].y, a = 18 * (-3 * r + 2 * i + 3 * o - s), l = 18 * (3 * r - i - 3 * o), c = 18 * (o - r);
+    if (_.approximately(a, 0)) {
+      if (!_.approximately(l, 0)) {
+        let d = -c / l;
+        if (0 <= d && d <= 1)
+          return [d];
       }
       return [];
     }
-    const f = 2 * r;
-    if (y.approximately(f, 0))
+    const f = 2 * a;
+    if (_.approximately(f, 0))
       return [];
-    const h = l * l - 4 * r * u;
-    if (h < 0)
+    const g = l * l - 4 * a * c;
+    if (g < 0)
       return [];
-    const a = Math.sqrt(h);
-    return [(a - l) / f, -(l + a) / f].filter(function(p) {
-      return 0 <= p && p <= 1;
+    const y = Math.sqrt(g);
+    return [(y - l) / f, -(l + y) / f].filter(function(d) {
+      return 0 <= d && d <= 1;
     });
   },
-  bboxoverlap: function(o, e) {
-    const n = ["x", "y"], i = n.length;
-    for (let s = 0, c, r, l, u; s < i; s++)
-      if (c = n[s], r = o[c].mid, l = e[c].mid, u = (o[c].size + e[c].size) / 2, R(r - l) >= u)
+  bboxoverlap: function(n, e) {
+    const r = ["x", "y"], i = r.length;
+    for (let o = 0, s, a, l, c; o < i; o++)
+      if (s = r[o], a = n[s].mid, l = e[s].mid, c = (n[s].size + e[s].size) / 2, pt(a - l) >= c)
         return !1;
     return !0;
   },
-  expandbox: function(o, e) {
-    e.x.min < o.x.min && (o.x.min = e.x.min), e.y.min < o.y.min && (o.y.min = e.y.min), e.z && e.z.min < o.z.min && (o.z.min = e.z.min), e.x.max > o.x.max && (o.x.max = e.x.max), e.y.max > o.y.max && (o.y.max = e.y.max), e.z && e.z.max > o.z.max && (o.z.max = e.z.max), o.x.mid = (o.x.min + o.x.max) / 2, o.y.mid = (o.y.min + o.y.max) / 2, o.z && (o.z.mid = (o.z.min + o.z.max) / 2), o.x.size = o.x.max - o.x.min, o.y.size = o.y.max - o.y.min, o.z && (o.z.size = o.z.max - o.z.min);
+  expandbox: function(n, e) {
+    e.x.min < n.x.min && (n.x.min = e.x.min), e.y.min < n.y.min && (n.y.min = e.y.min), e.z && e.z.min < n.z.min && (n.z.min = e.z.min), e.x.max > n.x.max && (n.x.max = e.x.max), e.y.max > n.y.max && (n.y.max = e.y.max), e.z && e.z.max > n.z.max && (n.z.max = e.z.max), n.x.mid = (n.x.min + n.x.max) / 2, n.y.mid = (n.y.min + n.y.max) / 2, n.z && (n.z.mid = (n.z.min + n.z.max) / 2), n.x.size = n.x.max - n.x.min, n.y.size = n.y.max - n.y.min, n.z && (n.z.size = n.z.max - n.z.min);
   },
-  pairiteration: function(o, e, n) {
-    const i = o.bbox(), s = e.bbox(), c = 1e5, r = n || 0.5;
-    if (i.x.size + i.y.size < r && s.x.size + s.y.size < r)
+  pairiteration: function(n, e, r) {
+    const i = n.bbox(), o = e.bbox(), s = 1e5, a = r || 0.5;
+    if (i.x.size + i.y.size < a && o.x.size + o.y.size < a)
       return [
-        (c * (o._t1 + o._t2) / 2 | 0) / c + "/" + (c * (e._t1 + e._t2) / 2 | 0) / c
+        (s * (n._t1 + n._t2) / 2 | 0) / s + "/" + (s * (e._t1 + e._t2) / 2 | 0) / s
       ];
-    let l = o.split(0.5), u = e.split(0.5), f = [
-      { left: l.left, right: u.left },
-      { left: l.left, right: u.right },
-      { left: l.right, right: u.right },
-      { left: l.right, right: u.left }
+    let l = n.split(0.5), c = e.split(0.5), f = [
+      { left: l.left, right: c.left },
+      { left: l.left, right: c.right },
+      { left: l.right, right: c.right },
+      { left: l.right, right: c.left }
     ];
-    f = f.filter(function(a) {
-      return y.bboxoverlap(a.left.bbox(), a.right.bbox());
+    f = f.filter(function(y) {
+      return _.bboxoverlap(y.left.bbox(), y.right.bbox());
     });
-    let h = [];
-    return f.length === 0 || (f.forEach(function(a) {
-      h = h.concat(
-        y.pairiteration(a.left, a.right, r)
+    let g = [];
+    return f.length === 0 || (f.forEach(function(y) {
+      g = g.concat(
+        _.pairiteration(y.left, y.right, a)
       );
-    }), h = h.filter(function(a, p) {
-      return h.indexOf(a) === p;
-    })), h;
+    }), g = g.filter(function(y, d) {
+      return g.indexOf(y) === d;
+    })), g;
   },
-  getccenter: function(o, e, n) {
-    const i = e.x - o.x, s = e.y - o.y, c = n.x - e.x, r = n.y - e.y, l = i * N(P) - s * U(P), u = i * U(P) + s * N(P), f = c * N(P) - r * U(P), h = c * U(P) + r * N(P), a = (o.x + e.x) / 2, p = (o.y + e.y) / 2, g = (e.x + n.x) / 2, _ = (e.y + n.y) / 2, C = a + l, A = p + u, S = g + f, j = _ + h, O = y.lli8(a, p, C, A, g, _, S, j), T = y.dist(O, o);
-    let z = J(o.y - O.y, o.x - O.x), d = J(e.y - O.y, e.x - O.x), x = J(n.y - O.y, n.x - O.x), m;
-    return z < x ? ((z > d || d > x) && (z += X), z > x && (m = x, x = z, z = m)) : x < d && d < z ? (m = x, x = z, z = m) : x += X, O.s = z, O.e = x, O.r = T, O;
+  getccenter: function(n, e, r) {
+    const i = e.x - n.x, o = e.y - n.y, s = r.x - e.x, a = r.y - e.y, l = i * ot(ct) - o * ut(ct), c = i * ut(ct) + o * ot(ct), f = s * ot(ct) - a * ut(ct), g = s * ut(ct) + a * ot(ct), y = (n.x + e.x) / 2, d = (n.y + e.y) / 2, M = (e.x + r.x) / 2, k = (e.y + r.y) / 2, L = y + l, D = d + c, O = M + f, u = k + g, h = _.lli8(y, d, L, D, M, k, O, u), m = _.dist(h, n);
+    let p = gt(n.y - h.y, n.x - h.x), w = gt(e.y - h.y, e.x - h.x), x = gt(r.y - h.y, r.x - h.x), v;
+    return p < x ? ((p > w || w > x) && (p += Mt), p > x && (v = x, x = p, p = v)) : x < w && w < p ? (v = x, x = p, p = v) : x += Mt, h.s = p, h.e = x, h.r = m, h;
   },
-  numberSort: function(o, e) {
-    return o - e;
+  numberSort: function(n, e) {
+    return n - e;
   }
 };
-class V {
+class wt {
   constructor(e) {
     this.curves = [], this._3d = !1, e && (this.curves = e, this._3d = this.curves[0]._3d);
   }
@@ -433,7 +433,7 @@ class V {
   }
   toString() {
     return "[" + this.curves.map(function(e) {
-      return y.pointsToString(e.points);
+      return _.pointsToString(e.points);
     }).join(", ") + "]";
   }
   addCurve(e) {
@@ -442,8 +442,8 @@ class V {
   length() {
     return this.curves.map(function(e) {
       return e.length();
-    }).reduce(function(e, n) {
-      return e + n;
+    }).reduce(function(e, r) {
+      return e + r;
     });
   }
   curve(e) {
@@ -451,97 +451,97 @@ class V {
   }
   bbox() {
     const e = this.curves;
-    for (var n = e[0].bbox(), i = 1; i < e.length; i++)
-      y.expandbox(n, e[i].bbox());
-    return n;
+    for (var r = e[0].bbox(), i = 1; i < e.length; i++)
+      _.expandbox(r, e[i].bbox());
+    return r;
   }
   offset(e) {
-    const n = [];
+    const r = [];
     return this.curves.forEach(function(i) {
-      n.push(...i.offset(e));
-    }), new V(n);
+      r.push(...i.offset(e));
+    }), new wt(r);
   }
 }
-const { abs: G, min: K, max: B, cos: rt, sin: st, acos: ot, sqrt: Z } = Math, ct = Math.PI;
-class E {
+const { abs: xt, min: $t, max: Gt, cos: ge, sin: me, acos: xe, sqrt: vt } = Math, ve = Math.PI;
+class U {
   constructor(e) {
-    let n = e && e.forEach ? e : Array.from(arguments).slice(), i = !1;
-    if (typeof n[0] == "object") {
-      i = n.length;
-      const g = [];
-      n.forEach(function(_) {
-        ["x", "y", "z"].forEach(function(C) {
-          typeof _[C] < "u" && g.push(_[C]);
+    let r = e && e.forEach ? e : Array.from(arguments).slice(), i = !1;
+    if (typeof r[0] == "object") {
+      i = r.length;
+      const M = [];
+      r.forEach(function(k) {
+        ["x", "y", "z"].forEach(function(L) {
+          typeof k[L] < "u" && M.push(k[L]);
         });
-      }), n = g;
+      }), r = M;
     }
-    let s = !1;
-    const c = n.length;
+    let o = !1;
+    const s = r.length;
     if (i) {
       if (i > 4) {
         if (arguments.length !== 1)
           throw new Error(
             "Only new Bezier(point[]) is accepted for 4th and higher order curves"
           );
-        s = !0;
+        o = !0;
       }
-    } else if (c !== 6 && c !== 8 && c !== 9 && c !== 12 && arguments.length !== 1)
+    } else if (s !== 6 && s !== 8 && s !== 9 && s !== 12 && arguments.length !== 1)
       throw new Error(
         "Only new Bezier(point[]) is accepted for 4th and higher order curves"
       );
-    const r = this._3d = !s && (c === 9 || c === 12) || e && e[0] && typeof e[0].z < "u", l = this.points = [];
-    for (let g = 0, _ = r ? 3 : 2; g < c; g += _) {
-      var u = {
-        x: n[g],
-        y: n[g + 1]
+    const a = this._3d = !o && (s === 9 || s === 12) || e && e[0] && typeof e[0].z < "u", l = this.points = [];
+    for (let M = 0, k = a ? 3 : 2; M < s; M += k) {
+      var c = {
+        x: r[M],
+        y: r[M + 1]
       };
-      r && (u.z = n[g + 2]), l.push(u);
+      a && (c.z = r[M + 2]), l.push(c);
     }
-    const f = this.order = l.length - 1, h = this.dims = ["x", "y"];
-    r && h.push("z"), this.dimlen = h.length;
-    const a = y.align(l, { p1: l[0], p2: l[f] }), p = y.dist(l[0], l[f]);
-    this._linear = a.reduce((g, _) => g + G(_.y), 0) < p / 50, this._lut = [], this._t1 = 0, this._t2 = 1, this.update();
-  }
-  static quadraticFromPoints(e, n, i, s) {
-    if (typeof s > "u" && (s = 0.5), s === 0)
-      return new E(n, n, i);
-    if (s === 1)
-      return new E(e, n, n);
-    const c = E.getABC(2, e, n, i, s);
-    return new E(e, c.A, i);
-  }
-  static cubicFromPoints(e, n, i, s, c) {
-    typeof s > "u" && (s = 0.5);
-    const r = E.getABC(3, e, n, i, s);
-    typeof c > "u" && (c = y.dist(n, r.C));
-    const l = c * (1 - s) / s, u = y.dist(e, i), f = (i.x - e.x) / u, h = (i.y - e.y) / u, a = c * f, p = c * h, g = l * f, _ = l * h, C = { x: n.x - a, y: n.y - p }, A = { x: n.x + g, y: n.y + _ }, S = r.A, j = { x: S.x + (C.x - S.x) / (1 - s), y: S.y + (C.y - S.y) / (1 - s) }, O = { x: S.x + (A.x - S.x) / s, y: S.y + (A.y - S.y) / s }, T = { x: e.x + (j.x - e.x) / s, y: e.y + (j.y - e.y) / s }, z = {
-      x: i.x + (O.x - i.x) / (1 - s),
-      y: i.y + (O.y - i.y) / (1 - s)
+    const f = this.order = l.length - 1, g = this.dims = ["x", "y"];
+    a && g.push("z"), this.dimlen = g.length;
+    const y = _.align(l, { p1: l[0], p2: l[f] }), d = _.dist(l[0], l[f]);
+    this._linear = y.reduce((M, k) => M + xt(k.y), 0) < d / 50, this._lut = [], this._t1 = 0, this._t2 = 1, this.update();
+  }
+  static quadraticFromPoints(e, r, i, o) {
+    if (typeof o > "u" && (o = 0.5), o === 0)
+      return new U(r, r, i);
+    if (o === 1)
+      return new U(e, r, r);
+    const s = U.getABC(2, e, r, i, o);
+    return new U(e, s.A, i);
+  }
+  static cubicFromPoints(e, r, i, o, s) {
+    typeof o > "u" && (o = 0.5);
+    const a = U.getABC(3, e, r, i, o);
+    typeof s > "u" && (s = _.dist(r, a.C));
+    const l = s * (1 - o) / o, c = _.dist(e, i), f = (i.x - e.x) / c, g = (i.y - e.y) / c, y = s * f, d = s * g, M = l * f, k = l * g, L = { x: r.x - y, y: r.y - d }, D = { x: r.x + M, y: r.y + k }, O = a.A, u = { x: O.x + (L.x - O.x) / (1 - o), y: O.y + (L.y - O.y) / (1 - o) }, h = { x: O.x + (D.x - O.x) / o, y: O.y + (D.y - O.y) / o }, m = { x: e.x + (u.x - e.x) / o, y: e.y + (u.y - e.y) / o }, p = {
+      x: i.x + (h.x - i.x) / (1 - o),
+      y: i.y + (h.y - i.y) / (1 - o)
     };
-    return new E(e, T, z, i);
+    return new U(e, m, p, i);
   }
   static getUtils() {
-    return y;
+    return _;
   }
   getUtils() {
-    return E.getUtils();
+    return U.getUtils();
   }
   static get PolyBezier() {
-    return V;
+    return wt;
   }
   valueOf() {
     return this.toString();
   }
   toString() {
-    return y.pointsToString(this.points);
+    return _.pointsToString(this.points);
   }
   toSVG() {
     if (this._3d)
       return !1;
-    const e = this.points, n = e[0].x, i = e[0].y, s = ["M", n, i, this.order === 2 ? "Q" : "C"];
-    for (let c = 1, r = e.length; c < r; c++)
-      s.push(e[c].x), s.push(e[c].y);
-    return s.join(" ");
+    const e = this.points, r = e[0].x, i = e[0].y, o = ["M", r, i, this.order === 2 ? "Q" : "C"];
+    for (let s = 1, a = e.length; s < a; s++)
+      o.push(e[s].x), o.push(e[s].y);
+    return o.join(" ");
   }
   setRatios(e) {
     if (e.length !== this.points.length)
@@ -553,57 +553,57 @@ class E {
     e !== this._print && (this._print = e, this.update());
   }
   coordDigest() {
-    return this.points.map(function(e, n) {
-      return "" + n + e.x + e.y + (e.z ? e.z : 0);
+    return this.points.map(function(e, r) {
+      return "" + r + e.x + e.y + (e.z ? e.z : 0);
     }).join("");
   }
   update() {
-    this._lut = [], this.dpoints = y.derive(this.points, this._3d), this.computedirection();
+    this._lut = [], this.dpoints = _.derive(this.points, this._3d), this.computedirection();
   }
   computedirection() {
-    const e = this.points, n = y.angle(e[0], e[this.order], e[1]);
-    this.clockwise = n > 0;
+    const e = this.points, r = _.angle(e[0], e[this.order], e[1]);
+    this.clockwise = r > 0;
   }
   length() {
-    return y.length(this.derivative.bind(this));
+    return _.length(this.derivative.bind(this));
   }
-  static getABC(e = 2, n, i, s, c = 0.5) {
-    const r = y.projectionratio(c, e), l = 1 - r, u = {
-      x: r * n.x + l * s.x,
-      y: r * n.y + l * s.y
-    }, f = y.abcratio(c, e);
+  static getABC(e = 2, r, i, o, s = 0.5) {
+    const a = _.projectionratio(s, e), l = 1 - a, c = {
+      x: a * r.x + l * o.x,
+      y: a * r.y + l * o.y
+    }, f = _.abcratio(s, e);
     return { A: {
-      x: i.x + (i.x - u.x) / f,
-      y: i.y + (i.y - u.y) / f
-    }, B: i, C: u, S: n, E: s };
+      x: i.x + (i.x - c.x) / f,
+      y: i.y + (i.y - c.y) / f
+    }, B: i, C: c, S: r, E: o };
   }
-  getABC(e, n) {
-    n = n || this.get(e);
-    let i = this.points[0], s = this.points[this.order];
-    return E.getABC(this.order, i, n, s, e);
+  getABC(e, r) {
+    r = r || this.get(e);
+    let i = this.points[0], o = this.points[this.order];
+    return U.getABC(this.order, i, r, o, e);
   }
   getLUT(e) {
     if (this.verify(), e = e || 100, this._lut.length === e + 1)
       return this._lut;
     this._lut = [], e++, this._lut = [];
-    for (let n = 0, i, s; n < e; n++)
-      s = n / (e - 1), i = this.compute(s), i.t = s, this._lut.push(i);
+    for (let r = 0, i, o; r < e; r++)
+      o = r / (e - 1), i = this.compute(o), i.t = o, this._lut.push(i);
     return this._lut;
   }
-  on(e, n) {
-    n = n || 5;
-    const i = this.getLUT(), s = [];
-    for (let c = 0, r, l = 0; c < i.length; c++)
-      r = i[c], y.dist(r, e) < n && (s.push(r), l += c / i.length);
-    return s.length ? t /= s.length : !1;
+  on(e, r) {
+    r = r || 5;
+    const i = this.getLUT(), o = [];
+    for (let s = 0, a, l = 0; s < i.length; s++)
+      a = i[s], _.dist(a, e) < r && (o.push(a), l += s / i.length);
+    return o.length ? t /= o.length : !1;
   }
   project(e) {
-    const n = this.getLUT(), i = n.length - 1, s = y.closest(n, e), c = s.mpos, r = (c - 1) / i, l = (c + 1) / i, u = 0.1 / i;
-    let f = s.mdist, h = r, a = h, p;
+    const r = this.getLUT(), i = r.length - 1, o = _.closest(r, e), s = o.mpos, a = (s - 1) / i, l = (s + 1) / i, c = 0.1 / i;
+    let f = o.mdist, g = a, y = g, d;
     f += 1;
-    for (let g; h < l + u; h += u)
-      p = this.compute(h), g = y.dist(e, p), g < f && (f = g, a = h);
-    return a = a < 0 ? 0 : a > 1 ? 1 : a, p = this.compute(a), p.t = a, p.d = f, p;
+    for (let M; g < l + c; g += c)
+      d = this.compute(g), M = _.dist(e, d), M < f && (f = M, y = g);
+    return y = y < 0 ? 0 : y > 1 ? 1 : y, d = this.compute(y), d.t = y, d.d = f, d;
   }
   get(e) {
     return this.compute(e);
@@ -612,136 +612,136 @@ class E {
     return this.points[e];
   }
   compute(e) {
-    return this.ratios ? y.computeWithRatios(e, this.points, this.ratios, this._3d) : y.compute(e, this.points, this._3d, this.ratios);
+    return this.ratios ? _.computeWithRatios(e, this.points, this.ratios, this._3d) : _.compute(e, this.points, this._3d, this.ratios);
   }
   raise() {
-    const e = this.points, n = [e[0]], i = e.length;
-    for (let s = 1, c, r; s < i; s++)
-      c = e[s], r = e[s - 1], n[s] = {
-        x: (i - s) / i * c.x + s / i * r.x,
-        y: (i - s) / i * c.y + s / i * r.y
+    const e = this.points, r = [e[0]], i = e.length;
+    for (let o = 1, s, a; o < i; o++)
+      s = e[o], a = e[o - 1], r[o] = {
+        x: (i - o) / i * s.x + o / i * a.x,
+        y: (i - o) / i * s.y + o / i * a.y
       };
-    return n[i] = e[i - 1], new E(n);
+    return r[i] = e[i - 1], new U(r);
   }
   derivative(e) {
-    return y.compute(e, this.dpoints[0], this._3d);
+    return _.compute(e, this.dpoints[0], this._3d);
   }
   dderivative(e) {
-    return y.compute(e, this.dpoints[1], this._3d);
+    return _.compute(e, this.dpoints[1], this._3d);
   }
   align() {
     let e = this.points;
-    return new E(y.align(e, { p1: e[0], p2: e[e.length - 1] }));
+    return new U(_.align(e, { p1: e[0], p2: e[e.length - 1] }));
   }
   curvature(e) {
-    return y.curvature(e, this.dpoints[0], this.dpoints[1], this._3d);
+    return _.curvature(e, this.dpoints[0], this.dpoints[1], this._3d);
   }
   inflections() {
-    return y.inflections(this.points);
+    return _.inflections(this.points);
   }
   normal(e) {
     return this._3d ? this.__normal3(e) : this.__normal2(e);
   }
   __normal2(e) {
-    const n = this.derivative(e), i = Z(n.x * n.x + n.y * n.y);
-    return { t: e, x: -n.y / i, y: n.x / i };
+    const r = this.derivative(e), i = vt(r.x * r.x + r.y * r.y);
+    return { t: e, x: -r.y / i, y: r.x / i };
   }
   __normal3(e) {
-    const n = this.derivative(e), i = this.derivative(e + 0.01), s = Z(n.x * n.x + n.y * n.y + n.z * n.z), c = Z(i.x * i.x + i.y * i.y + i.z * i.z);
-    n.x /= s, n.y /= s, n.z /= s, i.x /= c, i.y /= c, i.z /= c;
-    const r = {
-      x: i.y * n.z - i.z * n.y,
-      y: i.z * n.x - i.x * n.z,
-      z: i.x * n.y - i.y * n.x
-    }, l = Z(r.x * r.x + r.y * r.y + r.z * r.z);
-    r.x /= l, r.y /= l, r.z /= l;
-    const u = [
-      r.x * r.x,
-      r.x * r.y - r.z,
-      r.x * r.z + r.y,
-      r.x * r.y + r.z,
-      r.y * r.y,
-      r.y * r.z - r.x,
-      r.x * r.z - r.y,
-      r.y * r.z + r.x,
-      r.z * r.z
+    const r = this.derivative(e), i = this.derivative(e + 0.01), o = vt(r.x * r.x + r.y * r.y + r.z * r.z), s = vt(i.x * i.x + i.y * i.y + i.z * i.z);
+    r.x /= o, r.y /= o, r.z /= o, i.x /= s, i.y /= s, i.z /= s;
+    const a = {
+      x: i.y * r.z - i.z * r.y,
+      y: i.z * r.x - i.x * r.z,
+      z: i.x * r.y - i.y * r.x
+    }, l = vt(a.x * a.x + a.y * a.y + a.z * a.z);
+    a.x /= l, a.y /= l, a.z /= l;
+    const c = [
+      a.x * a.x,
+      a.x * a.y - a.z,
+      a.x * a.z + a.y,
+      a.x * a.y + a.z,
+      a.y * a.y,
+      a.y * a.z - a.x,
+      a.x * a.z - a.y,
+      a.y * a.z + a.x,
+      a.z * a.z
     ];
     return {
       t: e,
-      x: u[0] * n.x + u[1] * n.y + u[2] * n.z,
-      y: u[3] * n.x + u[4] * n.y + u[5] * n.z,
-      z: u[6] * n.x + u[7] * n.y + u[8] * n.z
+      x: c[0] * r.x + c[1] * r.y + c[2] * r.z,
+      y: c[3] * r.x + c[4] * r.y + c[5] * r.z,
+      z: c[6] * r.x + c[7] * r.y + c[8] * r.z
     };
   }
   hull(e) {
-    let n = this.points, i = [], s = [], c = 0;
-    for (s[c++] = n[0], s[c++] = n[1], s[c++] = n[2], this.order === 3 && (s[c++] = n[3]); n.length > 1; ) {
+    let r = this.points, i = [], o = [], s = 0;
+    for (o[s++] = r[0], o[s++] = r[1], o[s++] = r[2], this.order === 3 && (o[s++] = r[3]); r.length > 1; ) {
       i = [];
-      for (let r = 0, l, u = n.length - 1; r < u; r++)
-        l = y.lerp(e, n[r], n[r + 1]), s[c++] = l, i.push(l);
-      n = i;
+      for (let a = 0, l, c = r.length - 1; a < c; a++)
+        l = _.lerp(e, r[a], r[a + 1]), o[s++] = l, i.push(l);
+      r = i;
     }
-    return s;
+    return o;
   }
-  split(e, n) {
-    if (e === 0 && n)
-      return this.split(n).left;
-    if (n === 1)
+  split(e, r) {
+    if (e === 0 && r)
+      return this.split(r).left;
+    if (r === 1)
       return this.split(e).right;
-    const i = this.hull(e), s = {
-      left: this.order === 2 ? new E([i[0], i[3], i[5]]) : new E([i[0], i[4], i[7], i[9]]),
-      right: this.order === 2 ? new E([i[5], i[4], i[2]]) : new E([i[9], i[8], i[6], i[3]]),
+    const i = this.hull(e), o = {
+      left: this.order === 2 ? new U([i[0], i[3], i[5]]) : new U([i[0], i[4], i[7], i[9]]),
+      right: this.order === 2 ? new U([i[5], i[4], i[2]]) : new U([i[9], i[8], i[6], i[3]]),
       span: i
     };
-    return s.left._t1 = y.map(0, 0, 1, this._t1, this._t2), s.left._t2 = y.map(e, 0, 1, this._t1, this._t2), s.right._t1 = y.map(e, 0, 1, this._t1, this._t2), s.right._t2 = y.map(1, 0, 1, this._t1, this._t2), n ? (n = y.map(n, e, 1, 0, 1), s.right.split(n).left) : s;
+    return o.left._t1 = _.map(0, 0, 1, this._t1, this._t2), o.left._t2 = _.map(e, 0, 1, this._t1, this._t2), o.right._t1 = _.map(e, 0, 1, this._t1, this._t2), o.right._t2 = _.map(1, 0, 1, this._t1, this._t2), r ? (r = _.map(r, e, 1, 0, 1), o.right.split(r).left) : o;
   }
   extrema() {
     const e = {};
-    let n = [];
+    let r = [];
     return this.dims.forEach(
       (function(i) {
-        let s = function(r) {
-          return r[i];
-        }, c = this.dpoints[0].map(s);
-        e[i] = y.droots(c), this.order === 3 && (c = this.dpoints[1].map(s), e[i] = e[i].concat(y.droots(c))), e[i] = e[i].filter(function(r) {
-          return r >= 0 && r <= 1;
-        }), n = n.concat(e[i].sort(y.numberSort));
+        let o = function(a) {
+          return a[i];
+        }, s = this.dpoints[0].map(o);
+        e[i] = _.droots(s), this.order === 3 && (s = this.dpoints[1].map(o), e[i] = e[i].concat(_.droots(s))), e[i] = e[i].filter(function(a) {
+          return a >= 0 && a <= 1;
+        }), r = r.concat(e[i].sort(_.numberSort));
       }).bind(this)
-    ), e.values = n.sort(y.numberSort).filter(function(i, s) {
-      return n.indexOf(i) === s;
+    ), e.values = r.sort(_.numberSort).filter(function(i, o) {
+      return r.indexOf(i) === o;
     }), e;
   }
   bbox() {
-    const e = this.extrema(), n = {};
+    const e = this.extrema(), r = {};
     return this.dims.forEach(
       (function(i) {
-        n[i] = y.getminmax(this, i, e[i]);
+        r[i] = _.getminmax(this, i, e[i]);
       }).bind(this)
-    ), n;
+    ), r;
   }
   overlaps(e) {
-    const n = this.bbox(), i = e.bbox();
-    return y.bboxoverlap(n, i);
+    const r = this.bbox(), i = e.bbox();
+    return _.bboxoverlap(r, i);
   }
-  offset(e, n) {
-    if (typeof n < "u") {
-      const i = this.get(e), s = this.normal(e), c = {
+  offset(e, r) {
+    if (typeof r < "u") {
+      const i = this.get(e), o = this.normal(e), s = {
         c: i,
-        n: s,
-        x: i.x + s.x * n,
-        y: i.y + s.y * n
+        n: o,
+        x: i.x + o.x * r,
+        y: i.y + o.y * r
       };
-      return this._3d && (c.z = i.z + s.z * n), c;
+      return this._3d && (s.z = i.z + o.z * r), s;
     }
     if (this._linear) {
-      const i = this.normal(0), s = this.points.map(function(c) {
-        const r = {
-          x: c.x + e * i.x,
-          y: c.y + e * i.y
+      const i = this.normal(0), o = this.points.map(function(s) {
+        const a = {
+          x: s.x + e * i.x,
+          y: s.y + e * i.y
         };
-        return c.z && i.z && (r.z = c.z + e * i.z), r;
+        return s.z && i.z && (a.z = s.z + e * i.z), a;
       });
-      return [new E(s)];
+      return [new U(o)];
     }
     return this.reduce().map(function(i) {
       return i._linear ? i.offset(e)[0] : i.scale(e);
@@ -749,328 +749,1438 @@ class E {
   }
   simple() {
     if (this.order === 3) {
-      const s = y.angle(this.points[0], this.points[3], this.points[1]), c = y.angle(this.points[0], this.points[3], this.points[2]);
-      if (s > 0 && c < 0 || s < 0 && c > 0)
+      const o = _.angle(this.points[0], this.points[3], this.points[1]), s = _.angle(this.points[0], this.points[3], this.points[2]);
+      if (o > 0 && s < 0 || o < 0 && s > 0)
         return !1;
     }
-    const e = this.normal(0), n = this.normal(1);
-    let i = e.x * n.x + e.y * n.y;
-    return this._3d && (i += e.z * n.z), G(ot(i)) < ct / 3;
+    const e = this.normal(0), r = this.normal(1);
+    let i = e.x * r.x + e.y * r.y;
+    return this._3d && (i += e.z * r.z), xt(xe(i)) < ve / 3;
   }
   reduce() {
-    let e, n = 0, i = 0, s = 0.01, c, r = [], l = [], u = this.extrema().values;
-    for (u.indexOf(0) === -1 && (u = [0].concat(u)), u.indexOf(1) === -1 && u.push(1), n = u[0], e = 1; e < u.length; e++)
-      i = u[e], c = this.split(n, i), c._t1 = n, c._t2 = i, r.push(c), n = i;
-    return r.forEach(function(f) {
-      for (n = 0, i = 0; i <= 1; )
-        for (i = n + s; i <= 1 + s; i += s)
-          if (c = f.split(n, i), !c.simple()) {
-            if (i -= s, G(n - i) < s)
+    let e, r = 0, i = 0, o = 0.01, s, a = [], l = [], c = this.extrema().values;
+    for (c.indexOf(0) === -1 && (c = [0].concat(c)), c.indexOf(1) === -1 && c.push(1), r = c[0], e = 1; e < c.length; e++)
+      i = c[e], s = this.split(r, i), s._t1 = r, s._t2 = i, a.push(s), r = i;
+    return a.forEach(function(f) {
+      for (r = 0, i = 0; i <= 1; )
+        for (i = r + o; i <= 1 + o; i += o)
+          if (s = f.split(r, i), !s.simple()) {
+            if (i -= o, xt(r - i) < o)
               return [];
-            c = f.split(n, i), c._t1 = y.map(n, 0, 1, f._t1, f._t2), c._t2 = y.map(i, 0, 1, f._t1, f._t2), l.push(c), n = i;
+            s = f.split(r, i), s._t1 = _.map(r, 0, 1, f._t1, f._t2), s._t2 = _.map(i, 0, 1, f._t1, f._t2), l.push(s), r = i;
             break;
           }
-      n < 1 && (c = f.split(n, 1), c._t1 = y.map(n, 0, 1, f._t1, f._t2), c._t2 = f._t2, l.push(c));
+      r < 1 && (s = f.split(r, 1), s._t1 = _.map(r, 0, 1, f._t1, f._t2), s._t2 = f._t2, l.push(s));
     }), l;
   }
-  translate(e, n, i) {
-    i = typeof i == "number" ? i : n;
-    const s = this.order;
-    let c = this.points.map((r, l) => (1 - l / s) * n + l / s * i);
-    return new E(
-      this.points.map((r, l) => ({
-        x: r.x + e.x * c[l],
-        y: r.y + e.y * c[l]
+  translate(e, r, i) {
+    i = typeof i == "number" ? i : r;
+    const o = this.order;
+    let s = this.points.map((a, l) => (1 - l / o) * r + l / o * i);
+    return new U(
+      this.points.map((a, l) => ({
+        x: a.x + e.x * s[l],
+        y: a.y + e.y * s[l]
       }))
     );
   }
   scale(e) {
-    const n = this.order;
+    const r = this.order;
     let i = !1;
-    if (typeof e == "function" && (i = e), i && n === 2)
+    if (typeof e == "function" && (i = e), i && r === 2)
       return this.raise().scale(i);
-    const s = this.clockwise, c = this.points;
+    const o = this.clockwise, s = this.points;
     if (this._linear)
       return this.translate(
         this.normal(0),
         i ? i(0) : e,
         i ? i(1) : e
       );
-    const r = i ? i(0) : e, l = i ? i(1) : e, u = [this.offset(0, 10), this.offset(1, 10)], f = [], h = y.lli4(u[0], u[0].c, u[1], u[1].c);
-    if (!h)
+    const a = i ? i(0) : e, l = i ? i(1) : e, c = [this.offset(0, 10), this.offset(1, 10)], f = [], g = _.lli4(c[0], c[0].c, c[1], c[1].c);
+    if (!g)
       throw new Error("cannot scale this curve. Try reducing it first.");
-    return [0, 1].forEach(function(a) {
-      const p = f[a * n] = y.copy(c[a * n]);
-      p.x += (a ? l : r) * u[a].n.x, p.y += (a ? l : r) * u[a].n.y;
-    }), i ? ([0, 1].forEach(function(a) {
-      if (!(n === 2 && a)) {
-        var p = c[a + 1], g = {
-          x: p.x - h.x,
-          y: p.y - h.y
-        }, _ = i ? i((a + 1) / n) : e;
-        i && !s && (_ = -_);
-        var C = Z(g.x * g.x + g.y * g.y);
-        g.x /= C, g.y /= C, f[a + 1] = {
-          x: p.x + _ * g.x,
-          y: p.y + _ * g.y
+    return [0, 1].forEach(function(y) {
+      const d = f[y * r] = _.copy(s[y * r]);
+      d.x += (y ? l : a) * c[y].n.x, d.y += (y ? l : a) * c[y].n.y;
+    }), i ? ([0, 1].forEach(function(y) {
+      if (!(r === 2 && y)) {
+        var d = s[y + 1], M = {
+          x: d.x - g.x,
+          y: d.y - g.y
+        }, k = i ? i((y + 1) / r) : e;
+        i && !o && (k = -k);
+        var L = vt(M.x * M.x + M.y * M.y);
+        M.x /= L, M.y /= L, f[y + 1] = {
+          x: d.x + k * M.x,
+          y: d.y + k * M.y
         };
       }
-    }), new E(f)) : ([0, 1].forEach((a) => {
-      if (n === 2 && a)
+    }), new U(f)) : ([0, 1].forEach((y) => {
+      if (r === 2 && y)
         return;
-      const p = f[a * n], g = this.derivative(a), _ = { x: p.x + g.x, y: p.y + g.y };
-      f[a + 1] = y.lli4(p, _, h, c[a + 1]);
-    }), new E(f));
-  }
-  outline(e, n, i, s) {
-    if (n = n === void 0 ? e : n, this._linear) {
-      const z = this.normal(0), d = this.points[0], x = this.points[this.points.length - 1];
-      let m, v, w;
-      i === void 0 && (i = e, s = n), m = { x: d.x + z.x * e, y: d.y + z.y * e }, w = { x: x.x + z.x * i, y: x.y + z.y * i }, v = { x: (m.x + w.x) / 2, y: (m.y + w.y) / 2 };
-      const b = [m, v, w];
-      m = { x: d.x - z.x * n, y: d.y - z.y * n }, w = { x: x.x - z.x * s, y: x.y - z.y * s }, v = { x: (m.x + w.x) / 2, y: (m.y + w.y) / 2 };
-      const k = [w, v, m], q = y.makeline(k[2], b[0]), M = y.makeline(b[2], k[0]), I = [q, new E(b), M, new E(k)];
-      return new V(I);
+      const d = f[y * r], M = this.derivative(y), k = { x: d.x + M.x, y: d.y + M.y };
+      f[y + 1] = _.lli4(d, k, g, s[y + 1]);
+    }), new U(f));
+  }
+  outline(e, r, i, o) {
+    if (r = r === void 0 ? e : r, this._linear) {
+      const p = this.normal(0), w = this.points[0], x = this.points[this.points.length - 1];
+      let v, S, X;
+      i === void 0 && (i = e, o = r), v = { x: w.x + p.x * e, y: w.y + p.y * e }, X = { x: x.x + p.x * i, y: x.y + p.y * i }, S = { x: (v.x + X.x) / 2, y: (v.y + X.y) / 2 };
+      const Y = [v, S, X];
+      v = { x: w.x - p.x * r, y: w.y - p.y * r }, X = { x: x.x - p.x * o, y: x.y - p.y * o }, S = { x: (v.x + X.x) / 2, y: (v.y + X.y) / 2 };
+      const b = [X, S, v], N = _.makeline(b[2], Y[0]), R = _.makeline(Y[2], b[0]), H = [N, new U(Y), R, new U(b)];
+      return new wt(H);
     }
-    const c = this.reduce(), r = c.length, l = [];
-    let u = [], f, h = 0, a = this.length();
-    const p = typeof i < "u" && typeof s < "u";
-    function g(z, d, x, m, v) {
-      return function(w) {
-        const b = m / x, k = (m + v) / x, q = d - z;
-        return y.map(w, 0, 1, z + b * q, z + k * q);
+    const s = this.reduce(), a = s.length, l = [];
+    let c = [], f, g = 0, y = this.length();
+    const d = typeof i < "u" && typeof o < "u";
+    function M(p, w, x, v, S) {
+      return function(X) {
+        const Y = v / x, b = (v + S) / x, N = w - p;
+        return _.map(X, 0, 1, p + Y * N, p + b * N);
       };
     }
-    c.forEach(function(z) {
-      const d = z.length();
-      p ? (l.push(
-        z.scale(g(e, i, a, h, d))
-      ), u.push(
-        z.scale(g(-n, -s, a, h, d))
-      )) : (l.push(z.scale(e)), u.push(z.scale(-n))), h += d;
-    }), u = u.map(function(z) {
-      return f = z.points, f[3] ? z.points = [f[3], f[2], f[1], f[0]] : z.points = [f[2], f[1], f[0]], z;
+    s.forEach(function(p) {
+      const w = p.length();
+      d ? (l.push(
+        p.scale(M(e, i, y, g, w))
+      ), c.push(
+        p.scale(M(-r, -o, y, g, w))
+      )) : (l.push(p.scale(e)), c.push(p.scale(-r))), g += w;
+    }), c = c.map(function(p) {
+      return f = p.points, f[3] ? p.points = [f[3], f[2], f[1], f[0]] : p.points = [f[2], f[1], f[0]], p;
     }).reverse();
-    const _ = l[0].points[0], C = l[r - 1].points[l[r - 1].points.length - 1], A = u[r - 1].points[u[r - 1].points.length - 1], S = u[0].points[0], j = y.makeline(A, _), O = y.makeline(C, S), T = [j].concat(l).concat([O]).concat(u);
-    return new V(T);
-  }
-  outlineshapes(e, n, i) {
-    n = n || e;
-    const s = this.outline(e, n).curves, c = [];
-    for (let r = 1, l = s.length; r < l / 2; r++) {
-      const u = y.makeshape(
-        s[r],
-        s[l - r],
+    const k = l[0].points[0], L = l[a - 1].points[l[a - 1].points.length - 1], D = c[a - 1].points[c[a - 1].points.length - 1], O = c[0].points[0], u = _.makeline(D, k), h = _.makeline(L, O), m = [u].concat(l).concat([h]).concat(c);
+    return new wt(m);
+  }
+  outlineshapes(e, r, i) {
+    r = r || e;
+    const o = this.outline(e, r).curves, s = [];
+    for (let a = 1, l = o.length; a < l / 2; a++) {
+      const c = _.makeshape(
+        o[a],
+        o[l - a],
         i
       );
-      u.startcap.virtual = r > 1, u.endcap.virtual = r < l / 2 - 1, c.push(u);
+      c.startcap.virtual = a > 1, c.endcap.virtual = a < l / 2 - 1, s.push(c);
     }
-    return c;
+    return s;
   }
-  intersects(e, n) {
-    return e ? e.p1 && e.p2 ? this.lineIntersects(e) : (e instanceof E && (e = e.reduce()), this.curveintersects(
+  intersects(e, r) {
+    return e ? e.p1 && e.p2 ? this.lineIntersects(e) : (e instanceof U && (e = e.reduce()), this.curveintersects(
       this.reduce(),
       e,
-      n
-    )) : this.selfintersects(n);
+      r
+    )) : this.selfintersects(r);
   }
   lineIntersects(e) {
-    const n = K(e.p1.x, e.p2.x), i = K(e.p1.y, e.p2.y), s = B(e.p1.x, e.p2.x), c = B(e.p1.y, e.p2.y);
-    return y.roots(this.points, e).filter((r) => {
-      var l = this.get(r);
-      return y.between(l.x, n, s) && y.between(l.y, i, c);
+    const r = $t(e.p1.x, e.p2.x), i = $t(e.p1.y, e.p2.y), o = Gt(e.p1.x, e.p2.x), s = Gt(e.p1.y, e.p2.y);
+    return _.roots(this.points, e).filter((a) => {
+      var l = this.get(a);
+      return _.between(l.x, r, o) && _.between(l.y, i, s);
     });
   }
   selfintersects(e) {
-    const n = this.reduce(), i = n.length - 2, s = [];
-    for (let c = 0, r, l, u; c < i; c++)
-      l = n.slice(c, c + 1), u = n.slice(c + 2), r = this.curveintersects(l, u, e), s.push(...r);
-    return s;
+    const r = this.reduce(), i = r.length - 2, o = [];
+    for (let s = 0, a, l, c; s < i; s++)
+      l = r.slice(s, s + 1), c = r.slice(s + 2), a = this.curveintersects(l, c, e), o.push(...a);
+    return o;
   }
-  curveintersects(e, n, i) {
-    const s = [];
-    e.forEach(function(r) {
-      n.forEach(function(l) {
-        r.overlaps(l) && s.push({ left: r, right: l });
+  curveintersects(e, r, i) {
+    const o = [];
+    e.forEach(function(a) {
+      r.forEach(function(l) {
+        a.overlaps(l) && o.push({ left: a, right: l });
       });
     });
-    let c = [];
-    return s.forEach(function(r) {
-      const l = y.pairiteration(
-        r.left,
-        r.right,
+    let s = [];
+    return o.forEach(function(a) {
+      const l = _.pairiteration(
+        a.left,
+        a.right,
         i
       );
-      l.length > 0 && (c = c.concat(l));
-    }), c;
+      l.length > 0 && (s = s.concat(l));
+    }), s;
   }
   arcs(e) {
     return e = e || 0.5, this._iterate(e, []);
   }
-  _error(e, n, i, s) {
-    const c = (s - i) / 4, r = this.get(i + c), l = this.get(s - c), u = y.dist(e, n), f = y.dist(e, r), h = y.dist(e, l);
-    return G(f - u) + G(h - u);
+  _error(e, r, i, o) {
+    const s = (o - i) / 4, a = this.get(i + s), l = this.get(o - s), c = _.dist(e, r), f = _.dist(e, a), g = _.dist(e, l);
+    return xt(f - c) + xt(g - c);
   }
-  _iterate(e, n) {
-    let i = 0, s = 1, c;
+  _iterate(e, r) {
+    let i = 0, o = 1, s;
     do {
-      c = 0, s = 1;
-      let r = this.get(i), l, u, f, h, a = !1, p = !1, g, _ = s, C = 1;
+      s = 0, o = 1;
+      let a = this.get(i), l, c, f, g, y = !1, d = !1, M, k = o, L = 1;
       do
-        if (p = a, h = f, _ = (i + s) / 2, l = this.get(_), u = this.get(s), f = y.getccenter(r, l, u), f.interval = {
+        if (d = y, g = f, k = (i + o) / 2, l = this.get(k), c = this.get(o), f = _.getccenter(a, l, c), f.interval = {
           start: i,
-          end: s
-        }, a = this._error(f, r, i, s) <= e, g = p && !a, g || (C = s), a) {
-          if (s >= 1) {
-            if (f.interval.end = C = 1, h = f, s > 1) {
-              let S = {
-                x: f.x + f.r * rt(f.e),
-                y: f.y + f.r * st(f.e)
+          end: o
+        }, y = this._error(f, a, i, o) <= e, M = d && !y, M || (L = o), y) {
+          if (o >= 1) {
+            if (f.interval.end = L = 1, g = f, o > 1) {
+              let O = {
+                x: f.x + f.r * ge(f.e),
+                y: f.y + f.r * me(f.e)
               };
-              f.e += y.angle({ x: f.x, y: f.y }, S, this.get(1));
+              f.e += _.angle({ x: f.x, y: f.y }, O, this.get(1));
             }
             break;
           }
-          s = s + (s - i) / 2;
+          o = o + (o - i) / 2;
         } else
-          s = _;
-      while (!g && c++ < 100);
-      if (c >= 100)
+          o = k;
+      while (!M && s++ < 100);
+      if (s >= 100)
         break;
-      h = h || f, n.push(h), i = C;
-    } while (s < 1);
+      g = g || f, r.push(g), i = L;
+    } while (o < 1);
+    return r;
+  }
+}
+var Q = 63710088e-1, te = {
+  centimeters: Q * 100,
+  centimetres: Q * 100,
+  degrees: Q / 111325,
+  feet: Q * 3.28084,
+  inches: Q * 39.37,
+  kilometers: Q / 1e3,
+  kilometres: Q / 1e3,
+  meters: Q,
+  metres: Q,
+  miles: Q / 1609.344,
+  millimeters: Q * 1e3,
+  millimetres: Q * 1e3,
+  nauticalmiles: Q / 1852,
+  radians: 1,
+  yards: Q * 1.0936
+};
+function ee(n, e, r) {
+  r === void 0 && (r = {});
+  var i = { type: "Feature" };
+  return (r.id === 0 || r.id) && (i.id = r.id), r.bbox && (i.bbox = r.bbox), i.properties = e || {}, i.geometry = n, i;
+}
+function ht(n, e, r) {
+  if (r === void 0 && (r = {}), !n)
+    throw new Error("coordinates is required");
+  if (!Array.isArray(n))
+    throw new Error("coordinates must be an Array");
+  if (n.length < 2)
+    throw new Error("coordinates must be at least 2 numbers long");
+  if (!Tt(n[0]) || !Tt(n[1]))
+    throw new Error("coordinates must contain numbers");
+  var i = {
+    type: "Point",
+    coordinates: n
+  };
+  return ee(i, e, r);
+}
+function Dt(n, e, r) {
+  r === void 0 && (r = {});
+  for (var i = 0, o = n; i < o.length; i++) {
+    var s = o[i];
+    if (s.length < 4)
+      throw new Error("Each LinearRing of a Polygon must have 4 or more Positions.");
+    for (var a = 0; a < s[s.length - 1].length; a++)
+      if (s[s.length - 1][a] !== s[0][a])
+        throw new Error("First and last Position are not equivalent.");
+  }
+  var l = {
+    type: "Polygon",
+    coordinates: n
+  };
+  return ee(l, e, r);
+}
+function _t(n, e) {
+  if (e === void 0 && (e = 0), e && !(e >= 0))
+    throw new Error("precision must be a positive number");
+  var r = Math.pow(10, e || 0);
+  return Math.round(n * r) / r;
+}
+function we(n, e) {
+  e === void 0 && (e = "kilometers");
+  var r = te[e];
+  if (!r)
+    throw new Error(e + " units is invalid");
+  return n * r;
+}
+function Me(n, e) {
+  e === void 0 && (e = "kilometers");
+  var r = te[e];
+  if (!r)
+    throw new Error(e + " units is invalid");
+  return n / r;
+}
+function Nt(n) {
+  var e = n % (2 * Math.PI);
+  return e * 180 / Math.PI;
+}
+function it(n) {
+  var e = n % 360;
+  return e * Math.PI / 180;
+}
+function Tt(n) {
+  return !isNaN(n) && n !== null && !Array.isArray(n);
+}
+function kt(n, e, r) {
+  if (n !== null)
+    for (var i, o, s, a, l, c, f, g = 0, y = 0, d, M = n.type, k = M === "FeatureCollection", L = M === "Feature", D = k ? n.features.length : 1, O = 0; O < D; O++) {
+      f = k ? n.features[O].geometry : L ? n.geometry : n, d = f ? f.type === "GeometryCollection" : !1, l = d ? f.geometries.length : 1;
+      for (var u = 0; u < l; u++) {
+        var h = 0, m = 0;
+        if (a = d ? f.geometries[u] : f, a !== null) {
+          c = a.coordinates;
+          var p = a.type;
+          switch (g = r && (p === "Polygon" || p === "MultiPolygon") ? 1 : 0, p) {
+            case null:
+              break;
+            case "Point":
+              if (e(
+                c,
+                y,
+                O,
+                h,
+                m
+              ) === !1)
+                return !1;
+              y++, h++;
+              break;
+            case "LineString":
+            case "MultiPoint":
+              for (i = 0; i < c.length; i++) {
+                if (e(
+                  c[i],
+                  y,
+                  O,
+                  h,
+                  m
+                ) === !1)
+                  return !1;
+                y++, p === "MultiPoint" && h++;
+              }
+              p === "LineString" && h++;
+              break;
+            case "Polygon":
+            case "MultiLineString":
+              for (i = 0; i < c.length; i++) {
+                for (o = 0; o < c[i].length - g; o++) {
+                  if (e(
+                    c[i][o],
+                    y,
+                    O,
+                    h,
+                    m
+                  ) === !1)
+                    return !1;
+                  y++;
+                }
+                p === "MultiLineString" && h++, p === "Polygon" && m++;
+              }
+              p === "Polygon" && h++;
+              break;
+            case "MultiPolygon":
+              for (i = 0; i < c.length; i++) {
+                for (m = 0, o = 0; o < c[i].length; o++) {
+                  for (s = 0; s < c[i][o].length - g; s++) {
+                    if (e(
+                      c[i][o][s],
+                      y,
+                      O,
+                      h,
+                      m
+                    ) === !1)
+                      return !1;
+                    y++;
+                  }
+                  m++;
+                }
+                h++;
+              }
+              break;
+            case "GeometryCollection":
+              for (i = 0; i < a.geometries.length; i++)
+                if (kt(a.geometries[i], e, r) === !1)
+                  return !1;
+              break;
+            default:
+              throw new Error("Unknown Geometry Type");
+          }
+        }
+      }
+    }
+}
+function _e(n, e) {
+  var r, i, o, s, a, l, c, f, g, y, d = 0, M = n.type === "FeatureCollection", k = n.type === "Feature", L = M ? n.features.length : 1;
+  for (r = 0; r < L; r++) {
+    for (l = M ? n.features[r].geometry : k ? n.geometry : n, f = M ? n.features[r].properties : k ? n.properties : {}, g = M ? n.features[r].bbox : k ? n.bbox : void 0, y = M ? n.features[r].id : k ? n.id : void 0, c = l ? l.type === "GeometryCollection" : !1, a = c ? l.geometries.length : 1, o = 0; o < a; o++) {
+      if (s = c ? l.geometries[o] : l, s === null) {
+        if (e(
+          null,
+          d,
+          f,
+          g,
+          y
+        ) === !1)
+          return !1;
+        continue;
+      }
+      switch (s.type) {
+        case "Point":
+        case "LineString":
+        case "MultiPoint":
+        case "Polygon":
+        case "MultiLineString":
+        case "MultiPolygon": {
+          if (e(
+            s,
+            d,
+            f,
+            g,
+            y
+          ) === !1)
+            return !1;
+          break;
+        }
+        case "GeometryCollection": {
+          for (i = 0; i < s.geometries.length; i++)
+            if (e(
+              s.geometries[i],
+              d,
+              f,
+              g,
+              y
+            ) === !1)
+              return !1;
+          break;
+        }
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
+    }
+    d++;
+  }
+}
+function ze(n, e, r) {
+  var i = r;
+  return _e(
+    n,
+    function(o, s, a, l, c) {
+      s === 0 && r === void 0 ? i = o : i = e(
+        i,
+        o,
+        s,
+        a,
+        l,
+        c
+      );
+    }
+  ), i;
+}
+function yt(n) {
+  if (!n)
+    throw new Error("coord is required");
+  if (!Array.isArray(n)) {
+    if (n.type === "Feature" && n.geometry !== null && n.geometry.type === "Point")
+      return n.geometry.coordinates;
+    if (n.type === "Point")
+      return n.coordinates;
+  }
+  if (Array.isArray(n) && n.length >= 2 && !Array.isArray(n[0]) && !Array.isArray(n[1]))
+    return n;
+  throw new Error("coord must be GeoJSON Point or an Array of numbers");
+}
+function Se(n, e) {
+  return n.type === "FeatureCollection" ? "FeatureCollection" : n.type === "GeometryCollection" ? "GeometryCollection" : n.type === "Feature" && n.geometry !== null ? n.geometry.type : n.type;
+}
+var re = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function ke(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+function Pe(n) {
+  if (n.__esModule)
     return n;
+  var e = n.default;
+  if (typeof e == "function") {
+    var r = function i() {
+      return this instanceof i ? Reflect.construct(e, arguments, this.constructor) : e.apply(this, arguments);
+    };
+    r.prototype = e.prototype;
+  } else
+    r = {};
+  return Object.defineProperty(r, "__esModule", { value: !0 }), Object.keys(n).forEach(function(i) {
+    var o = Object.getOwnPropertyDescriptor(n, i);
+    Object.defineProperty(r, i, o.get ? o : {
+      enumerable: !0,
+      get: function() {
+        return n[i];
+      }
+    });
+  }), r;
+}
+var Jt = { exports: {} }, ne = { exports: {} };
+(function(n, e) {
+  (function(r, i) {
+    n.exports = i();
+  })(re, function() {
+    function r(u, h, m, p, w) {
+      (function x(v, S, X, Y, b) {
+        for (; Y > X; ) {
+          if (Y - X > 600) {
+            var N = Y - X + 1, R = S - X + 1, H = Math.log(N), z = 0.5 * Math.exp(2 * H / 3), E = 0.5 * Math.sqrt(H * z * (N - z) / N) * (R - N / 2 < 0 ? -1 : 1), q = Math.max(X, Math.floor(S - R * z / N + E)), F = Math.min(Y, Math.floor(S + (N - R) * z / N + E));
+            x(v, S, q, F, b);
+          }
+          var P = v[S], C = X, A = Y;
+          for (i(v, X, S), b(v[Y], P) > 0 && i(v, X, Y); C < A; ) {
+            for (i(v, C, A), C++, A--; b(v[C], P) < 0; )
+              C++;
+            for (; b(v[A], P) > 0; )
+              A--;
+          }
+          b(v[X], P) === 0 ? i(v, X, A) : i(v, ++A, Y), A <= S && (X = A + 1), S <= A && (Y = A - 1);
+        }
+      })(u, h, m || 0, p || u.length - 1, w || o);
+    }
+    function i(u, h, m) {
+      var p = u[h];
+      u[h] = u[m], u[m] = p;
+    }
+    function o(u, h) {
+      return u < h ? -1 : u > h ? 1 : 0;
+    }
+    var s = function(u) {
+      u === void 0 && (u = 9), this._maxEntries = Math.max(4, u), this._minEntries = Math.max(2, Math.ceil(0.4 * this._maxEntries)), this.clear();
+    };
+    function a(u, h, m) {
+      if (!m)
+        return h.indexOf(u);
+      for (var p = 0; p < h.length; p++)
+        if (m(u, h[p]))
+          return p;
+      return -1;
+    }
+    function l(u, h) {
+      c(u, 0, u.children.length, h, u);
+    }
+    function c(u, h, m, p, w) {
+      w || (w = D(null)), w.minX = 1 / 0, w.minY = 1 / 0, w.maxX = -1 / 0, w.maxY = -1 / 0;
+      for (var x = h; x < m; x++) {
+        var v = u.children[x];
+        f(w, u.leaf ? p(v) : v);
+      }
+      return w;
+    }
+    function f(u, h) {
+      return u.minX = Math.min(u.minX, h.minX), u.minY = Math.min(u.minY, h.minY), u.maxX = Math.max(u.maxX, h.maxX), u.maxY = Math.max(u.maxY, h.maxY), u;
+    }
+    function g(u, h) {
+      return u.minX - h.minX;
+    }
+    function y(u, h) {
+      return u.minY - h.minY;
+    }
+    function d(u) {
+      return (u.maxX - u.minX) * (u.maxY - u.minY);
+    }
+    function M(u) {
+      return u.maxX - u.minX + (u.maxY - u.minY);
+    }
+    function k(u, h) {
+      return u.minX <= h.minX && u.minY <= h.minY && h.maxX <= u.maxX && h.maxY <= u.maxY;
+    }
+    function L(u, h) {
+      return h.minX <= u.maxX && h.minY <= u.maxY && h.maxX >= u.minX && h.maxY >= u.minY;
+    }
+    function D(u) {
+      return { children: u, height: 1, leaf: !0, minX: 1 / 0, minY: 1 / 0, maxX: -1 / 0, maxY: -1 / 0 };
+    }
+    function O(u, h, m, p, w) {
+      for (var x = [h, m]; x.length; )
+        if (!((m = x.pop()) - (h = x.pop()) <= p)) {
+          var v = h + Math.ceil((m - h) / p / 2) * p;
+          r(u, v, h, m, w), x.push(h, v, v, m);
+        }
+    }
+    return s.prototype.all = function() {
+      return this._all(this.data, []);
+    }, s.prototype.search = function(u) {
+      var h = this.data, m = [];
+      if (!L(u, h))
+        return m;
+      for (var p = this.toBBox, w = []; h; ) {
+        for (var x = 0; x < h.children.length; x++) {
+          var v = h.children[x], S = h.leaf ? p(v) : v;
+          L(u, S) && (h.leaf ? m.push(v) : k(u, S) ? this._all(v, m) : w.push(v));
+        }
+        h = w.pop();
+      }
+      return m;
+    }, s.prototype.collides = function(u) {
+      var h = this.data;
+      if (!L(u, h))
+        return !1;
+      for (var m = []; h; ) {
+        for (var p = 0; p < h.children.length; p++) {
+          var w = h.children[p], x = h.leaf ? this.toBBox(w) : w;
+          if (L(u, x)) {
+            if (h.leaf || k(u, x))
+              return !0;
+            m.push(w);
+          }
+        }
+        h = m.pop();
+      }
+      return !1;
+    }, s.prototype.load = function(u) {
+      if (!u || !u.length)
+        return this;
+      if (u.length < this._minEntries) {
+        for (var h = 0; h < u.length; h++)
+          this.insert(u[h]);
+        return this;
+      }
+      var m = this._build(u.slice(), 0, u.length - 1, 0);
+      if (this.data.children.length)
+        if (this.data.height === m.height)
+          this._splitRoot(this.data, m);
+        else {
+          if (this.data.height < m.height) {
+            var p = this.data;
+            this.data = m, m = p;
+          }
+          this._insert(m, this.data.height - m.height - 1, !0);
+        }
+      else
+        this.data = m;
+      return this;
+    }, s.prototype.insert = function(u) {
+      return u && this._insert(u, this.data.height - 1), this;
+    }, s.prototype.clear = function() {
+      return this.data = D([]), this;
+    }, s.prototype.remove = function(u, h) {
+      if (!u)
+        return this;
+      for (var m, p, w, x = this.data, v = this.toBBox(u), S = [], X = []; x || S.length; ) {
+        if (x || (x = S.pop(), p = S[S.length - 1], m = X.pop(), w = !0), x.leaf) {
+          var Y = a(u, x.children, h);
+          if (Y !== -1)
+            return x.children.splice(Y, 1), S.push(x), this._condense(S), this;
+        }
+        w || x.leaf || !k(x, v) ? p ? (m++, x = p.children[m], w = !1) : x = null : (S.push(x), X.push(m), m = 0, p = x, x = x.children[0]);
+      }
+      return this;
+    }, s.prototype.toBBox = function(u) {
+      return u;
+    }, s.prototype.compareMinX = function(u, h) {
+      return u.minX - h.minX;
+    }, s.prototype.compareMinY = function(u, h) {
+      return u.minY - h.minY;
+    }, s.prototype.toJSON = function() {
+      return this.data;
+    }, s.prototype.fromJSON = function(u) {
+      return this.data = u, this;
+    }, s.prototype._all = function(u, h) {
+      for (var m = []; u; )
+        u.leaf ? h.push.apply(h, u.children) : m.push.apply(m, u.children), u = m.pop();
+      return h;
+    }, s.prototype._build = function(u, h, m, p) {
+      var w, x = m - h + 1, v = this._maxEntries;
+      if (x <= v)
+        return l(w = D(u.slice(h, m + 1)), this.toBBox), w;
+      p || (p = Math.ceil(Math.log(x) / Math.log(v)), v = Math.ceil(x / Math.pow(v, p - 1))), (w = D([])).leaf = !1, w.height = p;
+      var S = Math.ceil(x / v), X = S * Math.ceil(Math.sqrt(v));
+      O(u, h, m, X, this.compareMinX);
+      for (var Y = h; Y <= m; Y += X) {
+        var b = Math.min(Y + X - 1, m);
+        O(u, Y, b, S, this.compareMinY);
+        for (var N = Y; N <= b; N += S) {
+          var R = Math.min(N + S - 1, b);
+          w.children.push(this._build(u, N, R, p - 1));
+        }
+      }
+      return l(w, this.toBBox), w;
+    }, s.prototype._chooseSubtree = function(u, h, m, p) {
+      for (; p.push(h), !h.leaf && p.length - 1 !== m; ) {
+        for (var w = 1 / 0, x = 1 / 0, v = void 0, S = 0; S < h.children.length; S++) {
+          var X = h.children[S], Y = d(X), b = (N = u, R = X, (Math.max(R.maxX, N.maxX) - Math.min(R.minX, N.minX)) * (Math.max(R.maxY, N.maxY) - Math.min(R.minY, N.minY)) - Y);
+          b < x ? (x = b, w = Y < w ? Y : w, v = X) : b === x && Y < w && (w = Y, v = X);
+        }
+        h = v || h.children[0];
+      }
+      var N, R;
+      return h;
+    }, s.prototype._insert = function(u, h, m) {
+      var p = m ? u : this.toBBox(u), w = [], x = this._chooseSubtree(p, this.data, h, w);
+      for (x.children.push(u), f(x, p); h >= 0 && w[h].children.length > this._maxEntries; )
+        this._split(w, h), h--;
+      this._adjustParentBBoxes(p, w, h);
+    }, s.prototype._split = function(u, h) {
+      var m = u[h], p = m.children.length, w = this._minEntries;
+      this._chooseSplitAxis(m, w, p);
+      var x = this._chooseSplitIndex(m, w, p), v = D(m.children.splice(x, m.children.length - x));
+      v.height = m.height, v.leaf = m.leaf, l(m, this.toBBox), l(v, this.toBBox), h ? u[h - 1].children.push(v) : this._splitRoot(m, v);
+    }, s.prototype._splitRoot = function(u, h) {
+      this.data = D([u, h]), this.data.height = u.height + 1, this.data.leaf = !1, l(this.data, this.toBBox);
+    }, s.prototype._chooseSplitIndex = function(u, h, m) {
+      for (var p, w, x, v, S, X, Y, b = 1 / 0, N = 1 / 0, R = h; R <= m - h; R++) {
+        var H = c(u, 0, R, this.toBBox), z = c(u, R, m, this.toBBox), E = (w = H, x = z, v = void 0, S = void 0, X = void 0, Y = void 0, v = Math.max(w.minX, x.minX), S = Math.max(w.minY, x.minY), X = Math.min(w.maxX, x.maxX), Y = Math.min(w.maxY, x.maxY), Math.max(0, X - v) * Math.max(0, Y - S)), q = d(H) + d(z);
+        E < b ? (b = E, p = R, N = q < N ? q : N) : E === b && q < N && (N = q, p = R);
+      }
+      return p || m - h;
+    }, s.prototype._chooseSplitAxis = function(u, h, m) {
+      var p = u.leaf ? this.compareMinX : g, w = u.leaf ? this.compareMinY : y;
+      this._allDistMargin(u, h, m, p) < this._allDistMargin(u, h, m, w) && u.children.sort(p);
+    }, s.prototype._allDistMargin = function(u, h, m, p) {
+      u.children.sort(p);
+      for (var w = this.toBBox, x = c(u, 0, h, w), v = c(u, m - h, m, w), S = M(x) + M(v), X = h; X < m - h; X++) {
+        var Y = u.children[X];
+        f(x, u.leaf ? w(Y) : Y), S += M(x);
+      }
+      for (var b = m - h - 1; b >= h; b--) {
+        var N = u.children[b];
+        f(v, u.leaf ? w(N) : N), S += M(v);
+      }
+      return S;
+    }, s.prototype._adjustParentBBoxes = function(u, h, m) {
+      for (var p = m; p >= 0; p--)
+        f(h[p], u);
+    }, s.prototype._condense = function(u) {
+      for (var h = u.length - 1, m = void 0; h >= 0; h--)
+        u[h].children.length === 0 ? h > 0 ? (m = u[h - 1].children).splice(m.indexOf(u[h]), 1) : this.clear() : l(u[h], this.toBBox);
+    }, s;
+  });
+})(ne);
+var Le = ne.exports;
+class Xe {
+  constructor(e = [], r = Ye) {
+    if (this.data = e, this.length = this.data.length, this.compare = r, this.length > 0)
+      for (let i = (this.length >> 1) - 1; i >= 0; i--)
+        this._down(i);
+  }
+  push(e) {
+    this.data.push(e), this.length++, this._up(this.length - 1);
+  }
+  pop() {
+    if (this.length === 0)
+      return;
+    const e = this.data[0], r = this.data.pop();
+    return this.length--, this.length > 0 && (this.data[0] = r, this._down(0)), e;
+  }
+  peek() {
+    return this.data[0];
+  }
+  _up(e) {
+    const { data: r, compare: i } = this, o = r[e];
+    for (; e > 0; ) {
+      const s = e - 1 >> 1, a = r[s];
+      if (i(o, a) >= 0)
+        break;
+      r[e] = a, e = s;
+    }
+    r[e] = o;
+  }
+  _down(e) {
+    const { data: r, compare: i } = this, o = this.length >> 1, s = r[e];
+    for (; e < o; ) {
+      let a = (e << 1) + 1, l = r[a];
+      const c = a + 1;
+      if (c < this.length && i(r[c], l) < 0 && (a = c, l = r[c]), i(l, s) >= 0)
+        break;
+      r[e] = l, e = a;
+    }
+    r[e] = s;
+  }
+}
+function Ye(n, e) {
+  return n < e ? -1 : n > e ? 1 : 0;
+}
+const Ee = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: Xe
+}, Symbol.toStringTag, { value: "Module" })), Ae = /* @__PURE__ */ Pe(Ee);
+var Pt = { exports: {} }, Oe = function(e, r, i, o) {
+  var s = e[0], a = e[1], l = !1;
+  i === void 0 && (i = 0), o === void 0 && (o = r.length);
+  for (var c = (o - i) / 2, f = 0, g = c - 1; f < c; g = f++) {
+    var y = r[i + f * 2 + 0], d = r[i + f * 2 + 1], M = r[i + g * 2 + 0], k = r[i + g * 2 + 1], L = d > a != k > a && s < (M - y) * (a - d) / (k - d) + y;
+    L && (l = !l);
+  }
+  return l;
+}, Ce = function(e, r, i, o) {
+  var s = e[0], a = e[1], l = !1;
+  i === void 0 && (i = 0), o === void 0 && (o = r.length);
+  for (var c = o - i, f = 0, g = c - 1; f < c; g = f++) {
+    var y = r[f + i][0], d = r[f + i][1], M = r[g + i][0], k = r[g + i][1], L = d > a != k > a && s < (M - y) * (a - d) / (k - d) + y;
+    L && (l = !l);
+  }
+  return l;
+}, ie = Oe, oe = Ce;
+Pt.exports = function(e, r, i, o) {
+  return r.length > 0 && Array.isArray(r[0]) ? oe(e, r, i, o) : ie(e, r, i, o);
+};
+Pt.exports.nested = oe;
+Pt.exports.flat = ie;
+var be = Pt.exports, qt = { exports: {} };
+(function(n, e) {
+  (function(r, i) {
+    i(e);
+  })(re, function(r) {
+    const o = 33306690738754706e-32;
+    function s(L, D, O, u, h) {
+      let m, p, w, x, v = D[0], S = u[0], X = 0, Y = 0;
+      S > v == S > -v ? (m = v, v = D[++X]) : (m = S, S = u[++Y]);
+      let b = 0;
+      if (X < L && Y < O)
+        for (S > v == S > -v ? (w = m - ((p = v + m) - v), v = D[++X]) : (w = m - ((p = S + m) - S), S = u[++Y]), m = p, w !== 0 && (h[b++] = w); X < L && Y < O; )
+          S > v == S > -v ? (w = m - ((p = m + v) - (x = p - m)) + (v - x), v = D[++X]) : (w = m - ((p = m + S) - (x = p - m)) + (S - x), S = u[++Y]), m = p, w !== 0 && (h[b++] = w);
+      for (; X < L; )
+        w = m - ((p = m + v) - (x = p - m)) + (v - x), v = D[++X], m = p, w !== 0 && (h[b++] = w);
+      for (; Y < O; )
+        w = m - ((p = m + S) - (x = p - m)) + (S - x), S = u[++Y], m = p, w !== 0 && (h[b++] = w);
+      return m === 0 && b !== 0 || (h[b++] = m), b;
+    }
+    function a(L) {
+      return new Float64Array(L);
+    }
+    const l = 33306690738754716e-32, c = 22204460492503146e-32, f = 11093356479670487e-47, g = a(4), y = a(8), d = a(12), M = a(16), k = a(4);
+    r.orient2d = function(L, D, O, u, h, m) {
+      const p = (D - m) * (O - h), w = (L - h) * (u - m), x = p - w;
+      if (p === 0 || w === 0 || p > 0 != w > 0)
+        return x;
+      const v = Math.abs(p + w);
+      return Math.abs(x) >= l * v ? x : -function(S, X, Y, b, N, R, H) {
+        let z, E, q, F, P, C, A, $, J, T, B, G, I, Z, j, K, st, V;
+        const tt = S - N, et = Y - N, rt = X - R, nt = b - R;
+        P = (j = ($ = tt - (A = (C = 134217729 * tt) - (C - tt))) * (T = nt - (J = (C = 134217729 * nt) - (C - nt))) - ((Z = tt * nt) - A * J - $ * J - A * T)) - (B = j - (st = ($ = rt - (A = (C = 134217729 * rt) - (C - rt))) * (T = et - (J = (C = 134217729 * et) - (C - et))) - ((K = rt * et) - A * J - $ * J - A * T))), g[0] = j - (B + P) + (P - st), P = (I = Z - ((G = Z + B) - (P = G - Z)) + (B - P)) - (B = I - K), g[1] = I - (B + P) + (P - K), P = (V = G + B) - G, g[2] = G - (V - P) + (B - P), g[3] = V;
+        let at = function(he, Bt) {
+          let Rt = Bt[0];
+          for (let Lt = 1; Lt < he; Lt++)
+            Rt += Bt[Lt];
+          return Rt;
+        }(4, g), dt = c * H;
+        if (at >= dt || -at >= dt || (z = S - (tt + (P = S - tt)) + (P - N), q = Y - (et + (P = Y - et)) + (P - N), E = X - (rt + (P = X - rt)) + (P - R), F = b - (nt + (P = b - nt)) + (P - R), z === 0 && E === 0 && q === 0 && F === 0) || (dt = f * H + o * Math.abs(at), (at += tt * F + nt * z - (rt * q + et * E)) >= dt || -at >= dt))
+          return at;
+        P = (j = ($ = z - (A = (C = 134217729 * z) - (C - z))) * (T = nt - (J = (C = 134217729 * nt) - (C - nt))) - ((Z = z * nt) - A * J - $ * J - A * T)) - (B = j - (st = ($ = E - (A = (C = 134217729 * E) - (C - E))) * (T = et - (J = (C = 134217729 * et) - (C - et))) - ((K = E * et) - A * J - $ * J - A * T))), k[0] = j - (B + P) + (P - st), P = (I = Z - ((G = Z + B) - (P = G - Z)) + (B - P)) - (B = I - K), k[1] = I - (B + P) + (P - K), P = (V = G + B) - G, k[2] = G - (V - P) + (B - P), k[3] = V;
+        const ce = s(4, g, 4, k, y);
+        P = (j = ($ = tt - (A = (C = 134217729 * tt) - (C - tt))) * (T = F - (J = (C = 134217729 * F) - (C - F))) - ((Z = tt * F) - A * J - $ * J - A * T)) - (B = j - (st = ($ = rt - (A = (C = 134217729 * rt) - (C - rt))) * (T = q - (J = (C = 134217729 * q) - (C - q))) - ((K = rt * q) - A * J - $ * J - A * T))), k[0] = j - (B + P) + (P - st), P = (I = Z - ((G = Z + B) - (P = G - Z)) + (B - P)) - (B = I - K), k[1] = I - (B + P) + (P - K), P = (V = G + B) - G, k[2] = G - (V - P) + (B - P), k[3] = V;
+        const ue = s(ce, y, 4, k, d);
+        P = (j = ($ = z - (A = (C = 134217729 * z) - (C - z))) * (T = F - (J = (C = 134217729 * F) - (C - F))) - ((Z = z * F) - A * J - $ * J - A * T)) - (B = j - (st = ($ = E - (A = (C = 134217729 * E) - (C - E))) * (T = q - (J = (C = 134217729 * q) - (C - q))) - ((K = E * q) - A * J - $ * J - A * T))), k[0] = j - (B + P) + (P - st), P = (I = Z - ((G = Z + B) - (P = G - Z)) + (B - P)) - (B = I - K), k[1] = I - (B + P) + (P - K), P = (V = G + B) - G, k[2] = G - (V - P) + (B - P), k[3] = V;
+        const fe = s(ue, d, 4, k, M);
+        return M[fe - 1];
+      }(L, D, O, u, h, m, v);
+    }, r.orient2dfast = function(L, D, O, u, h, m) {
+      return (D - m) * (O - h) - (L - h) * (u - m);
+    }, Object.defineProperty(r, "__esModule", { value: !0 });
+  });
+})(qt, qt.exports);
+var De = qt.exports, Ut = Le, St = Ae, Ne = be, qe = De.orient2d;
+St.default && (St = St.default);
+Jt.exports = se;
+Jt.exports.default = se;
+function se(n, e, r) {
+  e = Math.max(0, e === void 0 ? 2 : e), r = r || 0;
+  var i = $e(n), o = new Ut(16);
+  o.toBBox = function(u) {
+    return {
+      minX: u[0],
+      minY: u[1],
+      maxX: u[0],
+      maxY: u[1]
+    };
+  }, o.compareMinX = function(u, h) {
+    return u[0] - h[0];
+  }, o.compareMinY = function(u, h) {
+    return u[1] - h[1];
+  }, o.load(n);
+  for (var s = [], a = 0, l; a < i.length; a++) {
+    var c = i[a];
+    o.remove(c), l = Ht(c, l), s.push(l);
+  }
+  var f = new Ut(16);
+  for (a = 0; a < s.length; a++)
+    f.insert(Et(s[a]));
+  for (var g = e * e, y = r * r; s.length; ) {
+    var d = s.shift(), M = d.p, k = d.next.p, L = At(M, k);
+    if (!(L < y)) {
+      var D = L / g;
+      c = Fe(o, d.prev.p, M, k, d.next.next.p, D, f), c && Math.min(At(c, M), At(c, k)) <= D && (s.push(d), s.push(Ht(c, d)), o.remove(c), f.remove(d), f.insert(Et(d)), f.insert(Et(d.next)));
+    }
+  }
+  d = l;
+  var O = [];
+  do
+    O.push(d.p), d = d.next;
+  while (d !== l);
+  return O.push(d.p), O;
+}
+function Fe(n, e, r, i, o, s, a) {
+  for (var l = new St([], Je), c = n.data; c; ) {
+    for (var f = 0; f < c.children.length; f++) {
+      var g = c.children[f], y = c.leaf ? Ot(g, r, i) : Be(r, i, g);
+      y > s || l.push({
+        node: g,
+        dist: y
+      });
+    }
+    for (; l.length && !l.peek().node.children; ) {
+      var d = l.pop(), M = d.node, k = Ot(M, e, r), L = Ot(M, i, o);
+      if (d.dist < k && d.dist < L && Zt(r, M, a) && Zt(i, M, a))
+        return M;
+    }
+    c = l.pop(), c && (c = c.node);
+  }
+  return null;
+}
+function Je(n, e) {
+  return n.dist - e.dist;
+}
+function Be(n, e, r) {
+  if (It(n, r) || It(e, r))
+    return 0;
+  var i = zt(n[0], n[1], e[0], e[1], r.minX, r.minY, r.maxX, r.minY);
+  if (i === 0)
+    return 0;
+  var o = zt(n[0], n[1], e[0], e[1], r.minX, r.minY, r.minX, r.maxY);
+  if (o === 0)
+    return 0;
+  var s = zt(n[0], n[1], e[0], e[1], r.maxX, r.minY, r.maxX, r.maxY);
+  if (s === 0)
+    return 0;
+  var a = zt(n[0], n[1], e[0], e[1], r.minX, r.maxY, r.maxX, r.maxY);
+  return a === 0 ? 0 : Math.min(i, o, s, a);
+}
+function It(n, e) {
+  return n[0] >= e.minX && n[0] <= e.maxX && n[1] >= e.minY && n[1] <= e.maxY;
+}
+function Zt(n, e, r) {
+  for (var i = Math.min(n[0], e[0]), o = Math.min(n[1], e[1]), s = Math.max(n[0], e[0]), a = Math.max(n[1], e[1]), l = r.search({ minX: i, minY: o, maxX: s, maxY: a }), c = 0; c < l.length; c++)
+    if (Re(l[c].p, l[c].next.p, n, e))
+      return !1;
+  return !0;
+}
+function ft(n, e, r) {
+  return qe(n[0], n[1], e[0], e[1], r[0], r[1]);
+}
+function Re(n, e, r, i) {
+  return n !== i && e !== r && ft(n, e, r) > 0 != ft(n, e, i) > 0 && ft(r, i, n) > 0 != ft(r, i, e) > 0;
+}
+function Et(n) {
+  var e = n.p, r = n.next.p;
+  return n.minX = Math.min(e[0], r[0]), n.minY = Math.min(e[1], r[1]), n.maxX = Math.max(e[0], r[0]), n.maxY = Math.max(e[1], r[1]), n;
+}
+function $e(n) {
+  for (var e = n[0], r = n[0], i = n[0], o = n[0], s = 0; s < n.length; s++) {
+    var a = n[s];
+    a[0] < e[0] && (e = a), a[0] > i[0] && (i = a), a[1] < r[1] && (r = a), a[1] > o[1] && (o = a);
+  }
+  var l = [e, r, i, o], c = l.slice();
+  for (s = 0; s < n.length; s++)
+    Ne(n[s], l) || c.push(n[s]);
+  return Te(c);
+}
+function Ht(n, e) {
+  var r = {
+    p: n,
+    prev: null,
+    next: null,
+    minX: 0,
+    minY: 0,
+    maxX: 0,
+    maxY: 0
+  };
+  return e ? (r.next = e.next, r.prev = e, e.next.prev = r, e.next = r) : (r.prev = r, r.next = r), r;
+}
+function At(n, e) {
+  var r = n[0] - e[0], i = n[1] - e[1];
+  return r * r + i * i;
+}
+function Ot(n, e, r) {
+  var i = e[0], o = e[1], s = r[0] - i, a = r[1] - o;
+  if (s !== 0 || a !== 0) {
+    var l = ((n[0] - i) * s + (n[1] - o) * a) / (s * s + a * a);
+    l > 1 ? (i = r[0], o = r[1]) : l > 0 && (i += s * l, o += a * l);
+  }
+  return s = n[0] - i, a = n[1] - o, s * s + a * a;
+}
+function zt(n, e, r, i, o, s, a, l) {
+  var c = r - n, f = i - e, g = a - o, y = l - s, d = n - o, M = e - s, k = c * c + f * f, L = c * g + f * y, D = g * g + y * y, O = c * d + f * M, u = g * d + y * M, h = k * D - L * L, m, p, w, x, v = h, S = h;
+  h === 0 ? (p = 0, v = 1, x = u, S = D) : (p = L * u - D * O, x = k * u - L * O, p < 0 ? (p = 0, x = u, S = D) : p > v && (p = v, x = u + L, S = D)), x < 0 ? (x = 0, -O < 0 ? p = 0 : -O > k ? p = v : (p = -O, v = k)) : x > S && (x = S, -O + L < 0 ? p = 0 : -O + L > k ? p = v : (p = -O + L, v = k)), m = p === 0 ? 0 : p / v, w = x === 0 ? 0 : x / S;
+  var X = (1 - m) * n + m * r, Y = (1 - m) * e + m * i, b = (1 - w) * o + w * a, N = (1 - w) * s + w * l, R = b - X, H = N - Y;
+  return R * R + H * H;
+}
+function Ge(n, e) {
+  return n[0] === e[0] ? n[1] - e[1] : n[0] - e[0];
+}
+function Te(n) {
+  n.sort(Ge);
+  for (var e = [], r = 0; r < n.length; r++) {
+    for (; e.length >= 2 && ft(e[e.length - 2], e[e.length - 1], n[r]) <= 0; )
+      e.pop();
+    e.push(n[r]);
+  }
+  for (var i = [], o = n.length - 1; o >= 0; o--) {
+    for (; i.length >= 2 && ft(i[i.length - 2], i[i.length - 1], n[o]) <= 0; )
+      i.pop();
+    i.push(n[o]);
+  }
+  return i.pop(), e.pop(), e.concat(i);
+}
+var Ue = Jt.exports;
+const Ie = /* @__PURE__ */ ke(Ue);
+function Ze(n, e) {
+  e === void 0 && (e = {}), e.concavity = e.concavity || 1 / 0;
+  var r = [];
+  if (kt(n, function(o) {
+    r.push([o[0], o[1]]);
+  }), !r.length)
+    return null;
+  var i = Ie(r, e.concavity);
+  return i.length > 3 ? Dt([i]) : null;
+}
+function ae(n, e, r) {
+  r === void 0 && (r = {});
+  var i = yt(n), o = yt(e), s = it(o[1] - i[1]), a = it(o[0] - i[0]), l = it(i[1]), c = it(o[1]), f = Math.pow(Math.sin(s / 2), 2) + Math.pow(Math.sin(a / 2), 2) * Math.cos(l) * Math.cos(c);
+  return we(2 * Math.atan2(Math.sqrt(f), Math.sqrt(1 - f)), r.units);
+}
+function He(n, e, r, i) {
+  i === void 0 && (i = {});
+  var o = yt(n), s = it(o[0]), a = it(o[1]), l = it(r), c = Me(e, i.units), f = Math.asin(Math.sin(a) * Math.cos(c) + Math.cos(a) * Math.sin(c) * Math.cos(l)), g = s + Math.atan2(Math.sin(l) * Math.sin(c) * Math.cos(a), Math.cos(c) - Math.sin(a) * Math.sin(f)), y = Nt(g), d = Nt(f);
+  return ht([y, d], i.properties);
+}
+function le(n, e, r) {
+  if (r === void 0 && (r = {}), r.final === !0)
+    return Qe(n, e);
+  var i = yt(n), o = yt(e), s = it(i[0]), a = it(o[0]), l = it(i[1]), c = it(o[1]), f = Math.sin(a - s) * Math.cos(c), g = Math.cos(l) * Math.sin(c) - Math.sin(l) * Math.cos(c) * Math.cos(a - s);
+  return Nt(Math.atan2(f, g));
+}
+function Qe(n, e) {
+  var r = le(e, n);
+  return r = (r + 180) % 360, r;
+}
+function je(n, e) {
+  var r = ae(n, e), i = le(n, e), o = He(n, r / 2, i);
+  return o;
+}
+function Qt(n, e) {
+  e === void 0 && (e = {});
+  var r = 0, i = 0, o = 0;
+  return kt(n, function(s) {
+    r += s[0], i += s[1], o++;
+  }, !0), ht([r / o, i / o], e.properties);
+}
+function Ft(n, e) {
+  switch (e === void 0 && (e = {}), Se(n)) {
+    case "Point":
+      return ht(yt(n), e.properties);
+    case "Polygon":
+      var r = [];
+      kt(n, function(m) {
+        r.push(m);
+      });
+      var i = Qt(n, { properties: e.properties }), o = i.geometry.coordinates, s = 0, a = 0, l = 0, c, f, g, y, d, M, k, L, D = r.map(function(m) {
+        return [m[0] - o[0], m[1] - o[1]];
+      });
+      for (c = 0; c < r.length - 1; c++)
+        f = D[c], y = f[0], M = f[1], g = D[c + 1], d = g[0], k = g[1], L = y * k - d * M, l += L, s += (y + d) * L, a += (M + k) * L;
+      if (l === 0)
+        return i;
+      var O = l * 0.5, u = 1 / (6 * O);
+      return ht([o[0] + u * s, o[1] + u * a], e.properties);
+    default:
+      var h = Ze(n);
+      return h ? Ft(h, { properties: e.properties }) : Qt(n, { properties: e.properties });
+  }
+}
+var jt = 6378137;
+function Ct(n) {
+  return ze(n, function(e, r) {
+    return e + Ke(r);
+  }, 0);
+}
+function Ke(n) {
+  var e = 0, r;
+  switch (n.type) {
+    case "Polygon":
+      return Kt(n.coordinates);
+    case "MultiPolygon":
+      for (r = 0; r < n.coordinates.length; r++)
+        e += Kt(n.coordinates[r]);
+      return e;
+    case "Point":
+    case "MultiPoint":
+    case "LineString":
+    case "MultiLineString":
+      return 0;
   }
+  return 0;
 }
-function lt(o) {
-  let e = [], n = [], i = !1, s = !1, c = [], r = "", l = "", u = {
+function Kt(n) {
+  var e = 0;
+  if (n && n.length > 0) {
+    e += Math.abs(Vt(n[0]));
+    for (var r = 1; r < n.length; r++)
+      e -= Math.abs(Vt(n[r]));
+  }
+  return e;
+}
+function Vt(n) {
+  var e, r, i, o, s, a, l, c = 0, f = n.length;
+  if (f > 2) {
+    for (l = 0; l < f; l++)
+      l === f - 2 ? (o = f - 2, s = f - 1, a = 0) : l === f - 1 ? (o = f - 1, s = 0, a = 1) : (o = l, s = l + 1, a = l + 2), e = n[o], r = n[s], i = n[a], c += (bt(i[0]) - bt(e[0])) * Math.sin(bt(r[1]));
+    c = c * jt * jt / 2;
+  }
+  return c;
+}
+function bt(n) {
+  return n * Math.PI / 180;
+}
+function Ve(n) {
+  let e = "free", r = "", i = [], o = [], s = {}, a = !1, l = !0, c = !1, f = [], g = { type: "FeatureCollection", features: [] }, y = {
     type: "Feature",
-    properties: {
-      fillColor: "",
-      MGValue: 1
-    },
+    properties: {},
+    geometry: {
+      type: "LineString",
+      coordinates: []
+    }
+  }, d = {
+    type: "Feature",
+    properties: {},
     geometry: {
       type: "Polygon",
-      coordinates: [[]]
+      coordinates: []
+    }
+  }, M = {
+    type: "Feature",
+    properties: { area: "" },
+    geometry: {
+      type: "Point",
+      coordinates: []
     }
   };
-  const f = (d, x) => {
-    u.properties.fillColor = d || "#ff0", u.properties.MGValue = x || 1, l = d || "#ff0";
-  }, h = (d, x) => {
-    i || (i = !0, f(d || "#ff0", x || 1), o.on("click", a), o.getCanvas().style.cursor = "crosshair");
-  }, a = () => {
-    if (s = !s, s)
-      r = C(), e.push(r), n.push(r), u.geometry.coordinates[0].length = 0, c.length = 0, o.addSource(r, { type: "geojson", data: u }), o.scrollZoom.disable(), o.dragPan.disable(), o.doubleClickZoom.disable(), o.addLayer({
-        id: r,
-        type: "fill",
-        source: r,
-        paint: {
-          "fill-antialias": !0,
-          "fill-color": l,
-          "fill-opacity": 0.8,
-          "fill-outline-color": "black"
-        }
-      }), o.addLayer({
-        id: "draw" + r,
-        type: "line",
-        source: r,
-        paint: {
-          "line-width": 2,
-          "line-color": "black"
-        }
-      }), o.on("mousemove", S);
-    else {
-      if (o.scrollZoom.enable(), o.dragPan.enable(), o.doubleClickZoom.enable(), o.removeLayer("draw" + r), o.off("mousemove", S), T(c)) {
-        alert("落区自相交，请重画"), e.pop(), n.pop(), o.removeLayer(r), o.removeSource(r);
-        return;
+  const k = (z) => {
+    switch (n.off("click", h), n.off("mousemove", Y), n.off("contextmenu", p), v(), a && (l = !0, n.scrollZoom.enable(), n.dragPan.enable(), n.doubleClickZoom.enable()), a = !0, e = z.type || "point", c = z.compute || !1, s = z, s.compute = c, y.properties = s, d.properties = s, M.properties = s, e) {
+      case "point":
+        r = S(), i.push(r), o.push(r), g.features.length = 0, n.addSource(r, { type: "geojson", data: g }), n.addLayer({
+          id: r,
+          type: "circle",
+          source: r,
+          paint: {
+            "circle-color": s["circle-color"] || "#ff0",
+            "circle-radius": s["circle-radius"] || 5,
+            "circle-stroke-color": s["circle-stroke-color"] || "#000",
+            "circle-stroke-width": s["circle-stroke-width"] || 2
+          }
+        });
+        break;
+    }
+    n.on("click", h), n.getCanvas().style.cursor = "crosshair";
+  }, L = (z) => {
+    g.features.push({
+      type: "Feature",
+      properties: s,
+      geometry: { type: "Point", coordinates: z.lngLat.toArray() }
+    }), n.getSource(r).setData(JSON.parse(JSON.stringify(g)));
+  }, D = (z) => {
+    l && (r = S(), i.push(r), o.push(r), y.geometry.coordinates.length = 0, g.features.length = 0, n.addSource(r, { type: "geojson", data: y }), n.addSource(r + "text", { type: "geojson", data: g }), n.addLayer({
+      id: r,
+      type: "line",
+      source: r,
+      layout: {
+        "line-join": "round",
+        "line-cap": "round"
+      },
+      paint: {
+        "line-color": "#ff0",
+        "line-width": 4
+      }
+    }), n.addLayer({
+      id: r + "point",
+      type: "circle",
+      source: r,
+      paint: {
+        "circle-color": s["circle-color"] || "#ff0",
+        "circle-radius": s["circle-radius"] || 5,
+        "circle-stroke-color": s["circle-stroke-color"] || "#000",
+        "circle-stroke-width": s["circle-stroke-width"] || 2
+      }
+    }), n.addLayer({
+      id: r + "text",
+      type: "symbol",
+      source: r + "text",
+      layout: {
+        // 'symbol-placement' :'line-center',
+        "text-field": ["get", "distance"],
+        "text-allow-overlap": !0,
+        "text-anchor": "bottom",
+        "text-overlap": "always",
+        visibility: c ? "visible" : "none"
+      }
+    }), l = !1, n.on("mousemove", Y), n.on("contextmenu", p)), y.geometry.coordinates.push(z.lngLat.toArray()), n.getSource(r).setData(y), g.features.push({
+      type: "Feature",
+      properties: { name: 0 },
+      geometry: { type: "Point", coordinates: z.lngLat.toArray() }
+    }), n.getSource(r + "text").setData(g);
+  }, O = (z) => {
+    l && (r = S(), i.push(r), o.push(r), d.geometry.coordinates.length = 0, d.geometry.coordinates[0] = [], n.addSource(r, { type: "geojson", data: d }), n.addSource(r + "area", { type: "geojson", data: M }), n.addLayer({
+      id: r,
+      type: "fill",
+      source: r,
+      paint: {
+        "fill-antialias": !1,
+        "fill-color": s.fillColor || "#ff0",
+        "fill-opacity": 0.8
+        // 'fill-outline-color': 'black',
+      }
+    }), n.addLayer({
+      id: r + "outline",
+      type: "line",
+      source: r,
+      paint: {
+        "line-width": 2,
+        "line-color": "black"
+        // 'line-translate-anchor':'viewport'
+      },
+      layout: {
+        "line-cap": "round",
+        "line-join": "round"
+      }
+    }), n.addLayer({
+      id: r + "point",
+      type: "circle",
+      source: r,
+      paint: {
+        "circle-color": s["circle-color"] || "#ff0",
+        "circle-radius": s["circle-radius"] || 5,
+        "circle-stroke-color": s["circle-stroke-color"] || "#000",
+        "circle-stroke-width": s["circle-stroke-width"] || 2
+      }
+    }), n.addLayer({
+      id: r + "area",
+      type: "symbol",
+      source: r + "area",
+      layout: {
+        "text-field": ["get", "area"],
+        // 'text-field': '456',
+        "text-allow-overlap": !0,
+        // 'text-anchor': 'bottom',
+        "text-overlap": "always",
+        visibility: c ? "visible" : "none"
+      }
+    }), l = !1, n.on("mousemove", Y), n.on("contextmenu", p)), d.geometry.coordinates[0].length >= 3 && d.geometry.coordinates[0].pop(), d.geometry.coordinates[0].push(z.lngLat.toArray()), d.geometry.coordinates[0].push(d.geometry.coordinates[0][0]), n.getSource(r).setData(d);
+  }, u = (z) => {
+    l && (r = S(), i.push(r), o.push(r), d.geometry.coordinates.length = 0, d.geometry.coordinates[0] = [], f.length = 0, n.addSource(r, { type: "geojson", data: d }), n.addSource(r + "area", { type: "geojson", data: M }), n.addLayer({
+      id: r,
+      type: "fill",
+      source: r,
+      paint: {
+        "fill-antialias": !1,
+        "fill-color": s.fillColor || "#ff0",
+        "fill-opacity": 0.8
       }
-      const d = [...c.slice(c.length / 5), ...c.slice(0, c.length / 5)], m = new E(d).getLUT(100);
-      u.geometry.coordinates[0].length = 0;
-      for (let w = 0; w < m.length; w++) {
-        const b = o.unproject(m[w]);
-        u.geometry.coordinates[0].push(b.toArray());
+    }), n.addLayer({
+      id: r + "outline",
+      type: "line",
+      source: r,
+      paint: {
+        "line-width": 2,
+        "line-color": "black"
+        // 'line-translate-anchor':'viewport'
+      },
+      layout: {
+        "line-cap": "round",
+        "line-join": "round"
       }
-      const v = o.getSource(r);
-      v !== void 0 && v.setData(JSON.parse(JSON.stringify(u)));
+    }), n.addLayer({
+      id: r + "area",
+      type: "symbol",
+      source: r + "area",
+      layout: {
+        "text-field": ["get", "area"],
+        // 'text-field': '456',
+        "text-allow-overlap": !0,
+        // 'text-anchor': 'bottom',
+        "text-overlap": "always",
+        visibility: c ? "visible" : "none"
+      }
+    }), l = !1, d.geometry.coordinates[0].push(z.lngLat.toArray()), n.getSource(r).setData(d), n.on("mousemove", Y), n.on("contextmenu", p), n.scrollZoom.disable(), n.dragPan.disable(), n.doubleClickZoom.disable());
+  }, h = (z) => {
+    switch (e) {
+      case "point":
+        L(z);
+        break;
+      case "line":
+        D(z);
+        break;
+      case "polygon":
+        O(z);
+        break;
+      case "free":
+        u(z);
+        break;
+    }
+  }, m = (z) => {
+    switch (e) {
+      case "line":
+        if (y.geometry.coordinates.length) {
+          y.geometry.coordinates.length == 1 && y.geometry.coordinates.push(z.lngLat.toArray()), y.geometry.coordinates[y.geometry.coordinates.length - 1] = z.lngLat.toArray(), n.getSource(r).setData(y);
+          const A = y.geometry.coordinates[y.geometry.coordinates.length - 2], $ = y.geometry.coordinates[y.geometry.coordinates.length - 1], J = ae(A, $, { units: "kilometers" }), T = je(ht(A), ht($)), B = g.features[g.features.length - 1];
+          B.properties.distance = _t(J, 4) + "km", B.geometry.coordinates = T.geometry.coordinates, n.getSource(r + "text").setData(JSON.parse(JSON.stringify(g)));
+        }
+        break;
+      case "polygon":
+        const F = d.geometry.coordinates[0].length;
+        if (F) {
+          F == 2 ? d.geometry.coordinates[0][F - 1] = z.lngLat.toArray() : d.geometry.coordinates[0][F - 2] = z.lngLat.toArray();
+          const C = Ct(d) / 1e6;
+          if (F >= 4) {
+            var E = Dt(d.geometry.coordinates), q = Ft(E);
+            M.geometry.coordinates = q.geometry.coordinates, M.properties.area = _t(C, 2) + "km²";
+          }
+          n.getSource(r).setData(d), n.getSource(r + "area").setData(M);
+        }
+        break;
+      case "free":
+        const P = d.geometry.coordinates[0].length;
+        if (P) {
+          f.push(z.point), d.geometry.coordinates[0].length != 1 && d.geometry.coordinates[0].pop(), d.geometry.coordinates[0].push(z.lngLat.toArray()), d.geometry.coordinates[0].push(d.geometry.coordinates[0][0]);
+          const C = Ct(d) / 1e6;
+          if (P >= 4) {
+            var E = Dt(d.geometry.coordinates), q = Ft(E);
+            M.geometry.coordinates = q.geometry.coordinates, M.properties.area = _t(C, 2) + "km²";
+          }
+          n.getSource(r).setData(d), n.getSource(r + "area").setData(M);
+        }
+        break;
     }
-  }, p = (d) => {
-    c.push(d.point), u.geometry.coordinates[0].push(d.lngLat.toArray());
-    const x = o.getSource(r);
-    x !== void 0 && x.setData(u);
-  }, g = () => {
-    const d = n.slice(0, e.length), x = [];
-    return d.forEach((m) => {
-      const v = o.getSource(m);
-      x.push(v.serialize().data);
-    }), x;
-  }, _ = () => {
-    e.forEach((d) => o.removeLayer(d)), n.forEach((d) => o.removeSource(d)), e.length = 0, n.length = 0, o.off("click", a), o.getCanvas().style.cursor = "pointer", i = !1;
-  }, C = () => {
-    let d = (/* @__PURE__ */ new Date()).getTime();
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(m) {
-      const v = (d + Math.random() * 16) % 16 | 0;
-      return d = Math.floor(d / 16), (m === "x" ? v : v & 3 | 8).toString(16);
+  }, p = (z) => {
+    z.preventDefault(), n.off("mousemove", Y), n.off("contextmenu", p), l = !0, n.scrollZoom.enable(), n.dragPan.enable(), n.doubleClickZoom.enable();
+    const E = n.getSource(r);
+    switch (e) {
+      case "line":
+        y.geometry.coordinates.length && E.setData(JSON.parse(JSON.stringify(y)));
+        break;
+      case "polygon":
+        d.geometry.coordinates[0].length && E.setData(JSON.parse(JSON.stringify(d)));
+        break;
+      case "free":
+        if (d.geometry.coordinates[0].length) {
+          if (E.setData(JSON.parse(JSON.stringify(d))), R(f)) {
+            alert("落区自相交，请重画"), i.pop(), o.pop(), n.removeLayer(r), n.removeLayer(r + "outline"), n.removeLayer(r + "area"), n.removeSource(r), n.removeSource(r + "area");
+            return;
+          }
+          const q = [...f.slice(f.length / 5), ...f.slice(0, f.length / 5)], P = new U(q).getLUT();
+          P.push(P[0]), d.geometry.coordinates[0].length = 0;
+          for (let $ = 0; $ < P.length; $++) {
+            const J = n.unproject(P[$]);
+            d.geometry.coordinates[0].push(J.toArray());
+          }
+          E.setData(JSON.parse(JSON.stringify(d)));
+          const C = Ct(d) / 1e6;
+          M.properties.area = _t(C, 2) + "km²", n.getSource(r + "area").setData(JSON.parse(JSON.stringify(M)));
+        }
+        break;
+    }
+  }, w = () => {
+    const z = o.slice(0, i.length), E = [];
+    return z.forEach((q) => {
+      const F = n.getSource(q);
+      E.push(F.serialize().data);
+    }), E;
+  }, x = () => {
+    i.forEach((z) => {
+      n.removeLayer(z), n.getLayer(z + "outline") && n.removeLayer(z + "outline"), n.getLayer(z + "point") && n.removeLayer(z + "point"), n.getLayer(z + "area") && n.removeLayer(z + "area"), n.getLayer(z + "text") && n.removeLayer(z + "text");
+    }), o.forEach((z) => {
+      n.removeSource(z), n.getSource(z + "text") && n.removeSource(z + "text"), n.getSource(z + "area") && n.removeSource(z + "area");
+    }), i.length = 0, o.length = 0, n.off("click", h), n.off("mousemove", Y), n.off("contextmenu", p), n.getCanvas().style.cursor = "pointer", a = !1, v();
+  }, v = () => {
+    g.features.length = 0, y.geometry.coordinates.length = 0, d.geometry.coordinates.length = 0, d.geometry.coordinates[0] = [], M.geometry.coordinates.length = 0;
+  }, S = () => {
+    let z = (/* @__PURE__ */ new Date()).getTime();
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(q) {
+      const F = (z + Math.random() * 16) % 16 | 0;
+      return z = Math.floor(z / 16), (q === "x" ? F : F & 3 | 8).toString(16);
     });
-  }, S = ((d, x) => {
-    let m = 0;
-    return function(...v) {
-      const w = (/* @__PURE__ */ new Date()).getTime();
-      w - m < x || (m = w, d(...v));
+  }, Y = ((z, E) => {
+    let q = 0;
+    return function(...F) {
+      const P = (/* @__PURE__ */ new Date()).getTime();
+      P - q < E || (q = P, z(...F));
     };
-  })(p, 20), j = () => {
-    e.length && (o.removeLayer(e[e.length - 1]), e.pop());
-  }, O = () => {
-    if (n.length) {
-      const d = e.length - n.length, x = n.slice(d);
-      if (console.log(x), d !== 0 && x.length) {
-        const m = o.getSource(x[0]);
-        console.log(m, "source");
-        let v = "";
-        m && (v = m.serialize().data.valueOf().properties.fillColor), o.getLayer(x[0]) || (e.push(x[0]), o.addLayer({
-          id: x[0],
+  })(m, 20), b = () => {
+    e == "free" && i.length && (n.removeLayer(i[i.length - 1]), n.removeLayer(i[i.length - 1] + "outline"), n.getLayer(i[i.length - 1] + "area") && n.removeLayer(i[i.length - 1] + "area"), i.pop());
+  }, N = () => {
+    if (e == "free" && o.length) {
+      const z = i.length - o.length, E = o.slice(z);
+      if (z !== 0 && E.length) {
+        const P = n.getSource(E[0]).serialize().data.valueOf();
+        n.getLayer(E[0]) || (i.push(E[0]), n.addLayer({
+          id: E[0],
           type: "fill",
-          source: x[0],
+          source: E[0],
           paint: {
-            "fill-color": v,
+            "fill-color": P.properties.fillColor || "#ff0",
             "fill-opacity": 0.8,
             "fill-outline-color": "black"
           }
+        }), n.addLayer({
+          id: E[0] + "outline",
+          type: "line",
+          source: E[0],
+          paint: {
+            "line-width": 2,
+            "line-color": "black"
+          }
+        }), n.addLayer({
+          id: E[0] + "area",
+          type: "symbol",
+          source: E[0] + "area",
+          layout: {
+            "text-field": ["get", "area"],
+            // 'text-field': '456',
+            "text-allow-overlap": !0,
+            // 'text-anchor': 'bottom',
+            "text-overlap": "always",
+            visibility: P.properties.compute ? "visible" : "none"
+          }
         }));
       }
     }
-  }, T = (d) => {
-    let x = !1, m = d, v = [], w = m.length - 1;
-    for (let k = 0; k < w; k++) {
-      let q = m[k], M = m[k + 1];
-      (q.x != M.x || q.y != M.y) && v.push(q);
+  }, R = (z) => {
+    let E = !1, q = z, F = [], P = q.length - 1;
+    for (let A = 0; A < P; A++) {
+      let $ = q[A], J = q[A + 1];
+      ($.x != J.x || $.y != J.y) && F.push($);
     }
-    let b = v.length - 1;
-    for (let k = 0; k < b; k++) {
-      let q = v[k], M = v[k + 1];
-      for (let I = k + 2; I < b; I++) {
-        let W = v[I], D = v[I + 1], Y = z(q, M, W, D);
-        if (Y == null && M.x == D.x && M.y == D.y && (Y = { x: M.x, y: M.y }), Y != null) {
-          x = !0;
+    let C = F.length - 1;
+    for (let A = 0; A < C; A++) {
+      let $ = F[A], J = F[A + 1];
+      for (let T = A + 2; T < C; T++) {
+        let B = F[T], G = F[T + 1], I = H($, J, B, G);
+        if (I == null && J.x == G.x && J.y == G.y && (I = { x: J.x, y: J.y }), I != null) {
+          E = !0;
           break;
         }
       }
-      if (x)
+      if (E)
         break;
     }
-    return x;
-  }, z = (d, x, m, v) => {
-    var w = null, b = (d.x - m.x) * (x.y - m.y) - (d.y - m.y) * (x.x - m.x), k = (d.x - v.x) * (x.y - v.y) - (d.y - v.y) * (x.x - v.x);
-    if (b * k >= 0)
-      return w;
-    var q = (m.x - d.x) * (v.y - d.y) - (m.y - d.y) * (v.x - d.x), M = q + b - k;
-    if (q * M >= 0)
-      return w;
-    var I = q / (k - b), W = I * (x.x - d.x), D = I * (x.y - d.y);
-    return w = { x: d.x + W, y: d.y + D }, w;
+    return E;
+  }, H = (z, E, q, F) => {
+    var P = null, C = (z.x - q.x) * (E.y - q.y) - (z.y - q.y) * (E.x - q.x), A = (z.x - F.x) * (E.y - F.y) - (z.y - F.y) * (E.x - F.x);
+    if (C * A >= 0)
+      return P;
+    var $ = (q.x - z.x) * (F.y - z.y) - (q.y - z.y) * (F.x - z.x), J = $ + C - A;
+    if ($ * J >= 0)
+      return P;
+    var T = $ / (A - C), B = T * (E.x - z.x), G = T * (E.y - z.y);
+    return P = { x: z.x + B, y: z.y + G }, P;
   };
-  return { isStart: i, start: h, getFeatures: g, clear: _, revoke: j, redo: O, setColor: f };
+  return { isDraw: a, start: k, getFeatures: w, clear: x, revoke: b, redo: N };
 }
-const ut = { drawFreehand: lt };
 export {
-  ut as default
+  Ve as draw
 };