@mui/x-charts-vendor 9.0.0 → 9.4.0

package/lib-vendor/d3-geo/dist/d3-geo.min.js

@@ -0,0 +1,1957 @@
+"use strict";
+
+// https://d3js.org/d3-geo/ v3.1.1 Copyright 2010-2024 Mike Bostock, 2008-2012 Charles Karney
+!function (n, t) {
+  "object" == typeof exports && "undefined" != typeof module ? t(exports, require("../../d3-array/src/index.js")) : "function" == typeof define && define.amd ? define(["exports", "d3-array"], t) : t((n = "undefined" != typeof globalThis ? globalThis : n || self).d3 = n.d3 || {}, n.d3);
+}(this, function (n, t) {
+  "use strict";
+
+  var r = 1e-6,
+    e = 1e-12,
+    i = Math.PI,
+    o = i / 2,
+    u = i / 4,
+    a = 2 * i,
+    c = 180 / i,
+    l = i / 180,
+    f = Math.abs,
+    p = Math.atan,
+    s = Math.atan2,
+    h = Math.cos,
+    g = Math.ceil,
+    d = Math.exp,
+    v = Math.hypot,
+    E = Math.log,
+    y = Math.pow,
+    S = Math.sin,
+    m = Math.sign || function (n) {
+      return n > 0 ? 1 : n < 0 ? -1 : 0;
+    },
+    M = Math.sqrt,
+    w = Math.tan;
+  function x(n) {
+    return n > 1 ? 0 : n < -1 ? i : Math.acos(n);
+  }
+  function _(n) {
+    return n > 1 ? o : n < -1 ? -o : Math.asin(n);
+  }
+  function N(n) {
+    return (n = S(n / 2)) * n;
+  }
+  function A() {}
+  function R(n, t) {
+    n && P.hasOwnProperty(n.type) && P[n.type](n, t);
+  }
+  var C = {
+      Feature: function (n, t) {
+        R(n.geometry, t);
+      },
+      FeatureCollection: function (n, t) {
+        for (var r = n.features, e = -1, i = r.length; ++e < i;) R(r[e].geometry, t);
+      }
+    },
+    P = {
+      Sphere: function (n, t) {
+        t.sphere();
+      },
+      Point: function (n, t) {
+        n = n.coordinates, t.point(n[0], n[1], n[2]);
+      },
+      MultiPoint: function (n, t) {
+        for (var r = n.coordinates, e = -1, i = r.length; ++e < i;) n = r[e], t.point(n[0], n[1], n[2]);
+      },
+      LineString: function (n, t) {
+        $(n.coordinates, t, 0);
+      },
+      MultiLineString: function (n, t) {
+        for (var r = n.coordinates, e = -1, i = r.length; ++e < i;) $(r[e], t, 0);
+      },
+      Polygon: function (n, t) {
+        q(n.coordinates, t);
+      },
+      MultiPolygon: function (n, t) {
+        for (var r = n.coordinates, e = -1, i = r.length; ++e < i;) q(r[e], t);
+      },
+      GeometryCollection: function (n, t) {
+        for (var r = n.geometries, e = -1, i = r.length; ++e < i;) R(r[e], t);
+      }
+    };
+  function $(n, t, r) {
+    var e,
+      i = -1,
+      o = n.length - r;
+    for (t.lineStart(); ++i < o;) e = n[i], t.point(e[0], e[1], e[2]);
+    t.lineEnd();
+  }
+  function q(n, t) {
+    var r = -1,
+      e = n.length;
+    for (t.polygonStart(); ++r < e;) $(n[r], t, 1);
+    t.polygonEnd();
+  }
+  function j(n, t) {
+    n && C.hasOwnProperty(n.type) ? C[n.type](n, t) : R(n, t);
+  }
+  var z,
+    b,
+    L,
+    T,
+    G,
+    O,
+    k,
+    F,
+    H,
+    I,
+    W,
+    X,
+    Y,
+    B,
+    D,
+    U,
+    Z = new t.Adder(),
+    J = new t.Adder(),
+    K = {
+      point: A,
+      lineStart: A,
+      lineEnd: A,
+      polygonStart: function () {
+        Z = new t.Adder(), K.lineStart = Q, K.lineEnd = V;
+      },
+      polygonEnd: function () {
+        var n = +Z;
+        J.add(n < 0 ? a + n : n), this.lineStart = this.lineEnd = this.point = A;
+      },
+      sphere: function () {
+        J.add(a);
+      }
+    };
+  function Q() {
+    K.point = nn;
+  }
+  function V() {
+    tn(z, b);
+  }
+  function nn(n, t) {
+    K.point = tn, z = n, b = t, L = n *= l, T = h(t = (t *= l) / 2 + u), G = S(t);
+  }
+  function tn(n, t) {
+    var r = (n *= l) - L,
+      e = r >= 0 ? 1 : -1,
+      i = e * r,
+      o = h(t = (t *= l) / 2 + u),
+      a = S(t),
+      c = G * a,
+      f = T * o + c * h(i),
+      p = c * e * S(i);
+    Z.add(s(p, f)), L = n, T = o, G = a;
+  }
+  function rn(n) {
+    return [s(n[1], n[0]), _(n[2])];
+  }
+  function en(n) {
+    var t = n[0],
+      r = n[1],
+      e = h(r);
+    return [e * h(t), e * S(t), S(r)];
+  }
+  function on(n, t) {
+    return n[0] * t[0] + n[1] * t[1] + n[2] * t[2];
+  }
+  function un(n, t) {
+    return [n[1] * t[2] - n[2] * t[1], n[2] * t[0] - n[0] * t[2], n[0] * t[1] - n[1] * t[0]];
+  }
+  function an(n, t) {
+    n[0] += t[0], n[1] += t[1], n[2] += t[2];
+  }
+  function cn(n, t) {
+    return [n[0] * t, n[1] * t, n[2] * t];
+  }
+  function ln(n) {
+    var t = M(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
+    n[0] /= t, n[1] /= t, n[2] /= t;
+  }
+  var fn,
+    pn,
+    sn,
+    hn,
+    gn,
+    dn,
+    vn,
+    En,
+    yn,
+    Sn,
+    mn,
+    Mn,
+    wn,
+    xn,
+    _n,
+    Nn,
+    An = {
+      point: Rn,
+      lineStart: Pn,
+      lineEnd: $n,
+      polygonStart: function () {
+        An.point = qn, An.lineStart = jn, An.lineEnd = zn, B = new t.Adder(), K.polygonStart();
+      },
+      polygonEnd: function () {
+        K.polygonEnd(), An.point = Rn, An.lineStart = Pn, An.lineEnd = $n, Z < 0 ? (O = -(F = 180), k = -(H = 90)) : B > r ? H = 90 : B < -r && (k = -90), U[0] = O, U[1] = F;
+      },
+      sphere: function () {
+        O = -(F = 180), k = -(H = 90);
+      }
+    };
+  function Rn(n, t) {
+    D.push(U = [O = n, F = n]), t < k && (k = t), t > H && (H = t);
+  }
+  function Cn(n, t) {
+    var r = en([n * l, t * l]);
+    if (Y) {
+      var e = un(Y, r),
+        i = un([e[1], -e[0], 0], e);
+      ln(i), i = rn(i);
+      var o,
+        u = n - I,
+        a = u > 0 ? 1 : -1,
+        p = i[0] * c * a,
+        s = f(u) > 180;
+      s ^ (a * I < p && p < a * n) ? (o = i[1] * c) > H && (H = o) : s ^ (a * I < (p = (p + 360) % 360 - 180) && p < a * n) ? (o = -i[1] * c) < k && (k = o) : (t < k && (k = t), t > H && (H = t)), s ? n < I ? bn(O, n) > bn(O, F) && (F = n) : bn(n, F) > bn(O, F) && (O = n) : F >= O ? (n < O && (O = n), n > F && (F = n)) : n > I ? bn(O, n) > bn(O, F) && (F = n) : bn(n, F) > bn(O, F) && (O = n);
+    } else D.push(U = [O = n, F = n]);
+    t < k && (k = t), t > H && (H = t), Y = r, I = n;
+  }
+  function Pn() {
+    An.point = Cn;
+  }
+  function $n() {
+    U[0] = O, U[1] = F, An.point = Rn, Y = null;
+  }
+  function qn(n, t) {
+    if (Y) {
+      var r = n - I;
+      B.add(f(r) > 180 ? r + (r > 0 ? 360 : -360) : r);
+    } else W = n, X = t;
+    K.point(n, t), Cn(n, t);
+  }
+  function jn() {
+    K.lineStart();
+  }
+  function zn() {
+    qn(W, X), K.lineEnd(), f(B) > r && (O = -(F = 180)), U[0] = O, U[1] = F, Y = null;
+  }
+  function bn(n, t) {
+    return (t -= n) < 0 ? t + 360 : t;
+  }
+  function Ln(n, t) {
+    return n[0] - t[0];
+  }
+  function Tn(n, t) {
+    return n[0] <= n[1] ? n[0] <= t && t <= n[1] : t < n[0] || n[1] < t;
+  }
+  var Gn = {
+    sphere: A,
+    point: On,
+    lineStart: Fn,
+    lineEnd: Wn,
+    polygonStart: function () {
+      Gn.lineStart = Xn, Gn.lineEnd = Yn;
+    },
+    polygonEnd: function () {
+      Gn.lineStart = Fn, Gn.lineEnd = Wn;
+    }
+  };
+  function On(n, t) {
+    n *= l;
+    var r = h(t *= l);
+    kn(r * h(n), r * S(n), S(t));
+  }
+  function kn(n, t, r) {
+    ++fn, sn += (n - sn) / fn, hn += (t - hn) / fn, gn += (r - gn) / fn;
+  }
+  function Fn() {
+    Gn.point = Hn;
+  }
+  function Hn(n, t) {
+    n *= l;
+    var r = h(t *= l);
+    xn = r * h(n), _n = r * S(n), Nn = S(t), Gn.point = In, kn(xn, _n, Nn);
+  }
+  function In(n, t) {
+    n *= l;
+    var r = h(t *= l),
+      e = r * h(n),
+      i = r * S(n),
+      o = S(t),
+      u = s(M((u = _n * o - Nn * i) * u + (u = Nn * e - xn * o) * u + (u = xn * i - _n * e) * u), xn * e + _n * i + Nn * o);
+    pn += u, dn += u * (xn + (xn = e)), vn += u * (_n + (_n = i)), En += u * (Nn + (Nn = o)), kn(xn, _n, Nn);
+  }
+  function Wn() {
+    Gn.point = On;
+  }
+  function Xn() {
+    Gn.point = Bn;
+  }
+  function Yn() {
+    Dn(Mn, wn), Gn.point = On;
+  }
+  function Bn(n, t) {
+    Mn = n, wn = t, n *= l, t *= l, Gn.point = Dn;
+    var r = h(t);
+    xn = r * h(n), _n = r * S(n), Nn = S(t), kn(xn, _n, Nn);
+  }
+  function Dn(n, t) {
+    n *= l;
+    var r = h(t *= l),
+      e = r * h(n),
+      i = r * S(n),
+      o = S(t),
+      u = _n * o - Nn * i,
+      a = Nn * e - xn * o,
+      c = xn * i - _n * e,
+      f = v(u, a, c),
+      p = _(f),
+      s = f && -p / f;
+    yn.add(s * u), Sn.add(s * a), mn.add(s * c), pn += p, dn += p * (xn + (xn = e)), vn += p * (_n + (_n = i)), En += p * (Nn + (Nn = o)), kn(xn, _n, Nn);
+  }
+  function Un(n) {
+    return function () {
+      return n;
+    };
+  }
+  function Zn(n, t) {
+    function r(r, e) {
+      return r = n(r, e), t(r[0], r[1]);
+    }
+    return n.invert && t.invert && (r.invert = function (r, e) {
+      return (r = t.invert(r, e)) && n.invert(r[0], r[1]);
+    }), r;
+  }
+  function Jn(n, t) {
+    return f(n) > i && (n -= Math.round(n / a) * a), [n, t];
+  }
+  function Kn(n, t, r) {
+    return (n %= a) ? t || r ? Zn(Vn(n), nt(t, r)) : Vn(n) : t || r ? nt(t, r) : Jn;
+  }
+  function Qn(n) {
+    return function (t, r) {
+      return f(t += n) > i && (t -= Math.round(t / a) * a), [t, r];
+    };
+  }
+  function Vn(n) {
+    var t = Qn(n);
+    return t.invert = Qn(-n), t;
+  }
+  function nt(n, t) {
+    var r = h(n),
+      e = S(n),
+      i = h(t),
+      o = S(t);
+    function u(n, t) {
+      var u = h(t),
+        a = h(n) * u,
+        c = S(n) * u,
+        l = S(t),
+        f = l * r + a * e;
+      return [s(c * i - f * o, a * r - l * e), _(f * i + c * o)];
+    }
+    return u.invert = function (n, t) {
+      var u = h(t),
+        a = h(n) * u,
+        c = S(n) * u,
+        l = S(t),
+        f = l * i - c * o;
+      return [s(c * i + l * o, a * r + f * e), _(f * r - a * e)];
+    }, u;
+  }
+  function tt(n) {
+    function t(t) {
+      return (t = n(t[0] * l, t[1] * l))[0] *= c, t[1] *= c, t;
+    }
+    return n = Kn(n[0] * l, n[1] * l, n.length > 2 ? n[2] * l : 0), t.invert = function (t) {
+      return (t = n.invert(t[0] * l, t[1] * l))[0] *= c, t[1] *= c, t;
+    }, t;
+  }
+  function rt(n, t, r, e, i, o) {
+    if (r) {
+      var u = h(t),
+        c = S(t),
+        l = e * r;
+      null == i ? (i = t + e * a, o = t - l / 2) : (i = et(u, i), o = et(u, o), (e > 0 ? i < o : i > o) && (i += e * a));
+      for (var f, p = i; e > 0 ? p > o : p < o; p -= l) f = rn([u, -c * h(p), -c * S(p)]), n.point(f[0], f[1]);
+    }
+  }
+  function et(n, t) {
+    (t = en(t))[0] -= n, ln(t);
+    var e = x(-t[1]);
+    return ((-t[2] < 0 ? -e : e) + a - r) % a;
+  }
+  function it() {
+    var n,
+      t = [];
+    return {
+      point: function (t, r, e) {
+        n.push([t, r, e]);
+      },
+      lineStart: function () {
+        t.push(n = []);
+      },
+      lineEnd: A,
+      rejoin: function () {
+        t.length > 1 && t.push(t.pop().concat(t.shift()));
+      },
+      result: function () {
+        var r = t;
+        return t = [], n = null, r;
+      }
+    };
+  }
+  function ot(n, t) {
+    return f(n[0] - t[0]) < r && f(n[1] - t[1]) < r;
+  }
+  function ut(n, t, r, e) {
+    this.x = n, this.z = t, this.o = r, this.e = e, this.v = !1, this.n = this.p = null;
+  }
+  function at(n, t, e, i, o) {
+    var u,
+      a,
+      c = [],
+      l = [];
+    if (n.forEach(function (n) {
+      if (!((t = n.length - 1) <= 0)) {
+        var t,
+          e,
+          i = n[0],
+          a = n[t];
+        if (ot(i, a)) {
+          if (!i[2] && !a[2]) {
+            for (o.lineStart(), u = 0; u < t; ++u) o.point((i = n[u])[0], i[1]);
+            return void o.lineEnd();
+          }
+          a[0] += 2 * r;
+        }
+        c.push(e = new ut(i, n, null, !0)), l.push(e.o = new ut(i, null, e, !1)), c.push(e = new ut(a, n, null, !1)), l.push(e.o = new ut(a, null, e, !0));
+      }
+    }), c.length) {
+      for (l.sort(t), ct(c), ct(l), u = 0, a = l.length; u < a; ++u) l[u].e = e = !e;
+      for (var f, p, s = c[0];;) {
+        for (var h = s, g = !0; h.v;) if ((h = h.n) === s) return;
+        f = h.z, o.lineStart();
+        do {
+          if (h.v = h.o.v = !0, h.e) {
+            if (g) for (u = 0, a = f.length; u < a; ++u) o.point((p = f[u])[0], p[1]);else i(h.x, h.n.x, 1, o);
+            h = h.n;
+          } else {
+            if (g) for (f = h.p.z, u = f.length - 1; u >= 0; --u) o.point((p = f[u])[0], p[1]);else i(h.x, h.p.x, -1, o);
+            h = h.p;
+          }
+          f = (h = h.o).z, g = !g;
+        } while (!h.v);
+        o.lineEnd();
+      }
+    }
+  }
+  function ct(n) {
+    if (t = n.length) {
+      for (var t, r, e = 0, i = n[0]; ++e < t;) i.n = r = n[e], r.p = i, i = r;
+      i.n = r = n[0], r.p = i;
+    }
+  }
+  function lt(n) {
+    return f(n[0]) <= i ? n[0] : m(n[0]) * ((f(n[0]) + i) % a - i);
+  }
+  function ft(n, c) {
+    var l = lt(c),
+      f = c[1],
+      p = S(f),
+      g = [S(l), -h(l), 0],
+      d = 0,
+      v = 0,
+      E = new t.Adder();
+    1 === p ? f = o + r : -1 === p && (f = -o - r);
+    for (var y = 0, m = n.length; y < m; ++y) if (w = (M = n[y]).length) for (var M, w, x = M[w - 1], N = lt(x), A = x[1] / 2 + u, R = S(A), C = h(A), P = 0; P < w; ++P, N = q, R = z, C = b, x = $) {
+      var $ = M[P],
+        q = lt($),
+        j = $[1] / 2 + u,
+        z = S(j),
+        b = h(j),
+        L = q - N,
+        T = L >= 0 ? 1 : -1,
+        G = T * L,
+        O = G > i,
+        k = R * z;
+      if (E.add(s(k * T * S(G), C * b + k * h(G))), d += O ? L + T * a : L, O ^ N >= l ^ q >= l) {
+        var F = un(en(x), en($));
+        ln(F);
+        var H = un(g, F);
+        ln(H);
+        var I = (O ^ L >= 0 ? -1 : 1) * _(H[2]);
+        (f > I || f === I && (F[0] || F[1])) && (v += O ^ L >= 0 ? 1 : -1);
+      }
+    }
+    return (d < -r || d < r && E < -e) ^ 1 & v;
+  }
+  function pt(n, r, e, i) {
+    return function (o) {
+      var u,
+        a,
+        c,
+        l = r(o),
+        f = it(),
+        p = r(f),
+        s = !1,
+        h = {
+          point: g,
+          lineStart: v,
+          lineEnd: E,
+          polygonStart: function () {
+            h.point = y, h.lineStart = S, h.lineEnd = m, a = [], u = [];
+          },
+          polygonEnd: function () {
+            h.point = g, h.lineStart = v, h.lineEnd = E, a = t.merge(a);
+            var n = ft(u, i);
+            a.length ? (s || (o.polygonStart(), s = !0), at(a, ht, n, e, o)) : n && (s || (o.polygonStart(), s = !0), o.lineStart(), e(null, null, 1, o), o.lineEnd()), s && (o.polygonEnd(), s = !1), a = u = null;
+          },
+          sphere: function () {
+            o.polygonStart(), o.lineStart(), e(null, null, 1, o), o.lineEnd(), o.polygonEnd();
+          }
+        };
+      function g(t, r) {
+        n(t, r) && o.point(t, r);
+      }
+      function d(n, t) {
+        l.point(n, t);
+      }
+      function v() {
+        h.point = d, l.lineStart();
+      }
+      function E() {
+        h.point = g, l.lineEnd();
+      }
+      function y(n, t) {
+        c.push([n, t]), p.point(n, t);
+      }
+      function S() {
+        p.lineStart(), c = [];
+      }
+      function m() {
+        y(c[0][0], c[0][1]), p.lineEnd();
+        var n,
+          t,
+          r,
+          e,
+          i = p.clean(),
+          l = f.result(),
+          h = l.length;
+        if (c.pop(), u.push(c), c = null, h) if (1 & i) {
+          if ((t = (r = l[0]).length - 1) > 0) {
+            for (s || (o.polygonStart(), s = !0), o.lineStart(), n = 0; n < t; ++n) o.point((e = r[n])[0], e[1]);
+            o.lineEnd();
+          }
+        } else h > 1 && 2 & i && l.push(l.pop().concat(l.shift())), a.push(l.filter(st));
+      }
+      return h;
+    };
+  }
+  function st(n) {
+    return n.length > 1;
+  }
+  function ht(n, t) {
+    return ((n = n.x)[0] < 0 ? n[1] - o - r : o - n[1]) - ((t = t.x)[0] < 0 ? t[1] - o - r : o - t[1]);
+  }
+  Jn.invert = Jn;
+  var gt = pt(function () {
+    return !0;
+  }, function (n) {
+    var t,
+      e = NaN,
+      u = NaN,
+      a = NaN;
+    return {
+      lineStart: function () {
+        n.lineStart(), t = 1;
+      },
+      point: function (c, l) {
+        var s = c > 0 ? i : -i,
+          g = f(c - e);
+        f(g - i) < r ? (n.point(e, u = (u + l) / 2 > 0 ? o : -o), n.point(a, u), n.lineEnd(), n.lineStart(), n.point(s, u), n.point(c, u), t = 0) : a !== s && g >= i && (f(e - a) < r && (e -= a * r), f(c - s) < r && (c -= s * r), u = function (n, t, e, i) {
+          var o,
+            u,
+            a = S(n - e);
+          return f(a) > r ? p((S(t) * (u = h(i)) * S(e) - S(i) * (o = h(t)) * S(n)) / (o * u * a)) : (t + i) / 2;
+        }(e, u, c, l), n.point(a, u), n.lineEnd(), n.lineStart(), n.point(s, u), t = 0), n.point(e = c, u = l), a = s;
+      },
+      lineEnd: function () {
+        n.lineEnd(), e = u = NaN;
+      },
+      clean: function () {
+        return 2 - t;
+      }
+    };
+  }, function (n, t, e, u) {
+    var a;
+    if (null == n) a = e * o, u.point(-i, a), u.point(0, a), u.point(i, a), u.point(i, 0), u.point(i, -a), u.point(0, -a), u.point(-i, -a), u.point(-i, 0), u.point(-i, a);else if (f(n[0] - t[0]) > r) {
+      var c = n[0] < t[0] ? i : -i;
+      a = e * c / 2, u.point(-c, a), u.point(0, a), u.point(c, a);
+    } else u.point(t[0], t[1]);
+  }, [-i, -o]);
+  function dt(n) {
+    var t = h(n),
+      e = 2 * l,
+      o = t > 0,
+      u = f(t) > r;
+    function a(n, r) {
+      return h(n) * h(r) > t;
+    }
+    function c(n, e, o) {
+      var u = [1, 0, 0],
+        a = un(en(n), en(e)),
+        c = on(a, a),
+        l = a[0],
+        p = c - l * l;
+      if (!p) return !o && n;
+      var s = t * c / p,
+        h = -t * l / p,
+        g = un(u, a),
+        d = cn(u, s);
+      an(d, cn(a, h));
+      var v = g,
+        E = on(d, v),
+        y = on(v, v),
+        S = E * E - y * (on(d, d) - 1);
+      if (!(S < 0)) {
+        var m = M(S),
+          w = cn(v, (-E - m) / y);
+        if (an(w, d), w = rn(w), !o) return w;
+        var x,
+          _ = n[0],
+          N = e[0],
+          A = n[1],
+          R = e[1];
+        N < _ && (x = _, _ = N, N = x);
+        var C = N - _,
+          P = f(C - i) < r;
+        if (!P && R < A && (x = A, A = R, R = x), P || C < r ? P ? A + R > 0 ^ w[1] < (f(w[0] - _) < r ? A : R) : A <= w[1] && w[1] <= R : C > i ^ (_ <= w[0] && w[0] <= N)) {
+          var $ = cn(v, (-E + m) / y);
+          return an($, d), [w, rn($)];
+        }
+      }
+    }
+    function p(t, r) {
+      var e = o ? n : i - n,
+        u = 0;
+      return t < -e ? u |= 1 : t > e && (u |= 2), r < -e ? u |= 4 : r > e && (u |= 8), u;
+    }
+    return pt(a, function (n) {
+      var t, r, e, l, f;
+      return {
+        lineStart: function () {
+          l = e = !1, f = 1;
+        },
+        point: function (s, h) {
+          var g,
+            d = [s, h],
+            v = a(s, h),
+            E = o ? v ? 0 : p(s, h) : v ? p(s + (s < 0 ? i : -i), h) : 0;
+          if (!t && (l = e = v) && n.lineStart(), v !== e && (!(g = c(t, d)) || ot(t, g) || ot(d, g)) && (d[2] = 1), v !== e) f = 0, v ? (n.lineStart(), g = c(d, t), n.point(g[0], g[1])) : (g = c(t, d), n.point(g[0], g[1], 2), n.lineEnd()), t = g;else if (u && t && o ^ v) {
+            var y;
+            E & r || !(y = c(d, t, !0)) || (f = 0, o ? (n.lineStart(), n.point(y[0][0], y[0][1]), n.point(y[1][0], y[1][1]), n.lineEnd()) : (n.point(y[1][0], y[1][1]), n.lineEnd(), n.lineStart(), n.point(y[0][0], y[0][1], 3)));
+          }
+          !v || t && ot(t, d) || n.point(d[0], d[1]), t = d, e = v, r = E;
+        },
+        lineEnd: function () {
+          e && n.lineEnd(), t = null;
+        },
+        clean: function () {
+          return f | (l && e) << 1;
+        }
+      };
+    }, function (t, r, i, o) {
+      rt(o, n, e, i, t, r);
+    }, o ? [0, -n] : [-i, n - i]);
+  }
+  var vt,
+    Et,
+    yt,
+    St,
+    mt = 1e9,
+    Mt = -mt;
+  function wt(n, e, i, o) {
+    function u(t, r) {
+      return n <= t && t <= i && e <= r && r <= o;
+    }
+    function a(t, r, u, a) {
+      var l = 0,
+        f = 0;
+      if (null == t || (l = c(t, u)) !== (f = c(r, u)) || p(t, r) < 0 ^ u > 0) do {
+        a.point(0 === l || 3 === l ? n : i, l > 1 ? o : e);
+      } while ((l = (l + u + 4) % 4) !== f);else a.point(r[0], r[1]);
+    }
+    function c(t, o) {
+      return f(t[0] - n) < r ? o > 0 ? 0 : 3 : f(t[0] - i) < r ? o > 0 ? 2 : 1 : f(t[1] - e) < r ? o > 0 ? 1 : 0 : o > 0 ? 3 : 2;
+    }
+    function l(n, t) {
+      return p(n.x, t.x);
+    }
+    function p(n, t) {
+      var r = c(n, 1),
+        e = c(t, 1);
+      return r !== e ? r - e : 0 === r ? t[1] - n[1] : 1 === r ? n[0] - t[0] : 2 === r ? n[1] - t[1] : t[0] - n[0];
+    }
+    return function (r) {
+      var c,
+        f,
+        p,
+        s,
+        h,
+        g,
+        d,
+        v,
+        E,
+        y,
+        S,
+        m = r,
+        M = it(),
+        w = {
+          point: x,
+          lineStart: function () {
+            w.point = _, f && f.push(p = []);
+            y = !0, E = !1, d = v = NaN;
+          },
+          lineEnd: function () {
+            c && (_(s, h), g && E && M.rejoin(), c.push(M.result()));
+            w.point = x, E && m.lineEnd();
+          },
+          polygonStart: function () {
+            m = M, c = [], f = [], S = !0;
+          },
+          polygonEnd: function () {
+            var e = function () {
+                for (var t = 0, r = 0, e = f.length; r < e; ++r) for (var i, u, a = f[r], c = 1, l = a.length, p = a[0], s = p[0], h = p[1]; c < l; ++c) i = s, u = h, s = (p = a[c])[0], h = p[1], u <= o ? h > o && (s - i) * (o - u) > (h - u) * (n - i) && ++t : h <= o && (s - i) * (o - u) < (h - u) * (n - i) && --t;
+                return t;
+              }(),
+              i = S && e,
+              u = (c = t.merge(c)).length;
+            (i || u) && (r.polygonStart(), i && (r.lineStart(), a(null, null, 1, r), r.lineEnd()), u && at(c, l, e, a, r), r.polygonEnd());
+            m = r, c = f = p = null;
+          }
+        };
+      function x(n, t) {
+        u(n, t) && m.point(n, t);
+      }
+      function _(t, r) {
+        var a = u(t, r);
+        if (f && p.push([t, r]), y) s = t, h = r, g = a, y = !1, a && (m.lineStart(), m.point(t, r));else if (a && E) m.point(t, r);else {
+          var c = [d = Math.max(Mt, Math.min(mt, d)), v = Math.max(Mt, Math.min(mt, v))],
+            l = [t = Math.max(Mt, Math.min(mt, t)), r = Math.max(Mt, Math.min(mt, r))];
+          !function (n, t, r, e, i, o) {
+            var u,
+              a = n[0],
+              c = n[1],
+              l = 0,
+              f = 1,
+              p = t[0] - a,
+              s = t[1] - c;
+            if (u = r - a, p || !(u > 0)) {
+              if (u /= p, p < 0) {
+                if (u < l) return;
+                u < f && (f = u);
+              } else if (p > 0) {
+                if (u > f) return;
+                u > l && (l = u);
+              }
+              if (u = i - a, p || !(u < 0)) {
+                if (u /= p, p < 0) {
+                  if (u > f) return;
+                  u > l && (l = u);
+                } else if (p > 0) {
+                  if (u < l) return;
+                  u < f && (f = u);
+                }
+                if (u = e - c, s || !(u > 0)) {
+                  if (u /= s, s < 0) {
+                    if (u < l) return;
+                    u < f && (f = u);
+                  } else if (s > 0) {
+                    if (u > f) return;
+                    u > l && (l = u);
+                  }
+                  if (u = o - c, s || !(u < 0)) {
+                    if (u /= s, s < 0) {
+                      if (u > f) return;
+                      u > l && (l = u);
+                    } else if (s > 0) {
+                      if (u < l) return;
+                      u < f && (f = u);
+                    }
+                    return l > 0 && (n[0] = a + l * p, n[1] = c + l * s), f < 1 && (t[0] = a + f * p, t[1] = c + f * s), !0;
+                  }
+                }
+              }
+            }
+          }(c, l, n, e, i, o) ? a && (m.lineStart(), m.point(t, r), S = !1) : (E || (m.lineStart(), m.point(c[0], c[1])), m.point(l[0], l[1]), a || m.lineEnd(), S = !1);
+        }
+        d = t, v = r, E = a;
+      }
+      return w;
+    };
+  }
+  var xt = {
+    sphere: A,
+    point: A,
+    lineStart: function () {
+      xt.point = Nt, xt.lineEnd = _t;
+    },
+    lineEnd: A,
+    polygonStart: A,
+    polygonEnd: A
+  };
+  function _t() {
+    xt.point = xt.lineEnd = A;
+  }
+  function Nt(n, t) {
+    Et = n *= l, yt = S(t *= l), St = h(t), xt.point = At;
+  }
+  function At(n, t) {
+    n *= l;
+    var r = S(t *= l),
+      e = h(t),
+      i = f(n - Et),
+      o = h(i),
+      u = e * S(i),
+      a = St * r - yt * e * o,
+      c = yt * r + St * e * o;
+    vt.add(s(M(u * u + a * a), c)), Et = n, yt = r, St = e;
+  }
+  function Rt(n) {
+    return vt = new t.Adder(), j(n, xt), +vt;
+  }
+  var Ct = [null, null],
+    Pt = {
+      type: "LineString",
+      coordinates: Ct
+    };
+  function $t(n, t) {
+    return Ct[0] = n, Ct[1] = t, Rt(Pt);
+  }
+  var qt = {
+      Feature: function (n, t) {
+        return zt(n.geometry, t);
+      },
+      FeatureCollection: function (n, t) {
+        for (var r = n.features, e = -1, i = r.length; ++e < i;) if (zt(r[e].geometry, t)) return !0;
+        return !1;
+      }
+    },
+    jt = {
+      Sphere: function () {
+        return !0;
+      },
+      Point: function (n, t) {
+        return bt(n.coordinates, t);
+      },
+      MultiPoint: function (n, t) {
+        for (var r = n.coordinates, e = -1, i = r.length; ++e < i;) if (bt(r[e], t)) return !0;
+        return !1;
+      },
+      LineString: function (n, t) {
+        return Lt(n.coordinates, t);
+      },
+      MultiLineString: function (n, t) {
+        for (var r = n.coordinates, e = -1, i = r.length; ++e < i;) if (Lt(r[e], t)) return !0;
+        return !1;
+      },
+      Polygon: function (n, t) {
+        return Tt(n.coordinates, t);
+      },
+      MultiPolygon: function (n, t) {
+        for (var r = n.coordinates, e = -1, i = r.length; ++e < i;) if (Tt(r[e], t)) return !0;
+        return !1;
+      },
+      GeometryCollection: function (n, t) {
+        for (var r = n.geometries, e = -1, i = r.length; ++e < i;) if (zt(r[e], t)) return !0;
+        return !1;
+      }
+    };
+  function zt(n, t) {
+    return !(!n || !jt.hasOwnProperty(n.type)) && jt[n.type](n, t);
+  }
+  function bt(n, t) {
+    return 0 === $t(n, t);
+  }
+  function Lt(n, t) {
+    for (var r, i, o, u = 0, a = n.length; u < a; u++) {
+      if (0 === (i = $t(n[u], t))) return !0;
+      if (u > 0 && (o = $t(n[u], n[u - 1])) > 0 && r <= o && i <= o && (r + i - o) * (1 - Math.pow((r - i) / o, 2)) < e * o) return !0;
+      r = i;
+    }
+    return !1;
+  }
+  function Tt(n, t) {
+    return !!ft(n.map(Gt), Ot(t));
+  }
+  function Gt(n) {
+    return (n = n.map(Ot)).pop(), n;
+  }
+  function Ot(n) {
+    return [n[0] * l, n[1] * l];
+  }
+  function kt(n, e, i) {
+    var o = t.range(n, e - r, i).concat(e);
+    return function (n) {
+      return o.map(function (t) {
+        return [n, t];
+      });
+    };
+  }
+  function Ft(n, e, i) {
+    var o = t.range(n, e - r, i).concat(e);
+    return function (n) {
+      return o.map(function (t) {
+        return [t, n];
+      });
+    };
+  }
+  function Ht() {
+    var n,
+      e,
+      i,
+      o,
+      u,
+      a,
+      c,
+      l,
+      p,
+      s,
+      h,
+      d,
+      v = 10,
+      E = v,
+      y = 90,
+      S = 360,
+      m = 2.5;
+    function M() {
+      return {
+        type: "MultiLineString",
+        coordinates: w()
+      };
+    }
+    function w() {
+      return t.range(g(o / y) * y, i, y).map(h).concat(t.range(g(l / S) * S, c, S).map(d)).concat(t.range(g(e / v) * v, n, v).filter(function (n) {
+        return f(n % y) > r;
+      }).map(p)).concat(t.range(g(a / E) * E, u, E).filter(function (n) {
+        return f(n % S) > r;
+      }).map(s));
+    }
+    return M.lines = function () {
+      return w().map(function (n) {
+        return {
+          type: "LineString",
+          coordinates: n
+        };
+      });
+    }, M.outline = function () {
+      return {
+        type: "Polygon",
+        coordinates: [h(o).concat(d(c).slice(1), h(i).reverse().slice(1), d(l).reverse().slice(1))]
+      };
+    }, M.extent = function (n) {
+      return arguments.length ? M.extentMajor(n).extentMinor(n) : M.extentMinor();
+    }, M.extentMajor = function (n) {
+      return arguments.length ? (o = +n[0][0], i = +n[1][0], l = +n[0][1], c = +n[1][1], o > i && (n = o, o = i, i = n), l > c && (n = l, l = c, c = n), M.precision(m)) : [[o, l], [i, c]];
+    }, M.extentMinor = function (t) {
+      return arguments.length ? (e = +t[0][0], n = +t[1][0], a = +t[0][1], u = +t[1][1], e > n && (t = e, e = n, n = t), a > u && (t = a, a = u, u = t), M.precision(m)) : [[e, a], [n, u]];
+    }, M.step = function (n) {
+      return arguments.length ? M.stepMajor(n).stepMinor(n) : M.stepMinor();
+    }, M.stepMajor = function (n) {
+      return arguments.length ? (y = +n[0], S = +n[1], M) : [y, S];
+    }, M.stepMinor = function (n) {
+      return arguments.length ? (v = +n[0], E = +n[1], M) : [v, E];
+    }, M.precision = function (t) {
+      return arguments.length ? (m = +t, p = kt(a, u, 90), s = Ft(e, n, m), h = kt(l, c, 90), d = Ft(o, i, m), M) : m;
+    }, M.extentMajor([[-180, -90 + r], [180, 90 - r]]).extentMinor([[-180, -80 - r], [180, 80 + r]]);
+  }
+  var It,
+    Wt,
+    Xt,
+    Yt,
+    Bt = n => n,
+    Dt = new t.Adder(),
+    Ut = new t.Adder(),
+    Zt = {
+      point: A,
+      lineStart: A,
+      lineEnd: A,
+      polygonStart: function () {
+        Zt.lineStart = Jt, Zt.lineEnd = Vt;
+      },
+      polygonEnd: function () {
+        Zt.lineStart = Zt.lineEnd = Zt.point = A, Dt.add(f(Ut)), Ut = new t.Adder();
+      },
+      result: function () {
+        var n = Dt / 2;
+        return Dt = new t.Adder(), n;
+      }
+    };
+  function Jt() {
+    Zt.point = Kt;
+  }
+  function Kt(n, t) {
+    Zt.point = Qt, It = Xt = n, Wt = Yt = t;
+  }
+  function Qt(n, t) {
+    Ut.add(Yt * n - Xt * t), Xt = n, Yt = t;
+  }
+  function Vt() {
+    Qt(It, Wt);
+  }
+  var nr = 1 / 0,
+    tr = nr,
+    rr = -nr,
+    er = rr,
+    ir = {
+      point: function (n, t) {
+        n < nr && (nr = n);
+        n > rr && (rr = n);
+        t < tr && (tr = t);
+        t > er && (er = t);
+      },
+      lineStart: A,
+      lineEnd: A,
+      polygonStart: A,
+      polygonEnd: A,
+      result: function () {
+        var n = [[nr, tr], [rr, er]];
+        return rr = er = -(tr = nr = 1 / 0), n;
+      }
+    };
+  var or,
+    ur,
+    ar,
+    cr,
+    lr = 0,
+    fr = 0,
+    pr = 0,
+    sr = 0,
+    hr = 0,
+    gr = 0,
+    dr = 0,
+    vr = 0,
+    Er = 0,
+    yr = {
+      point: Sr,
+      lineStart: mr,
+      lineEnd: xr,
+      polygonStart: function () {
+        yr.lineStart = _r, yr.lineEnd = Nr;
+      },
+      polygonEnd: function () {
+        yr.point = Sr, yr.lineStart = mr, yr.lineEnd = xr;
+      },
+      result: function () {
+        var n = Er ? [dr / Er, vr / Er] : gr ? [sr / gr, hr / gr] : pr ? [lr / pr, fr / pr] : [NaN, NaN];
+        return lr = fr = pr = sr = hr = gr = dr = vr = Er = 0, n;
+      }
+    };
+  function Sr(n, t) {
+    lr += n, fr += t, ++pr;
+  }
+  function mr() {
+    yr.point = Mr;
+  }
+  function Mr(n, t) {
+    yr.point = wr, Sr(ar = n, cr = t);
+  }
+  function wr(n, t) {
+    var r = n - ar,
+      e = t - cr,
+      i = M(r * r + e * e);
+    sr += i * (ar + n) / 2, hr += i * (cr + t) / 2, gr += i, Sr(ar = n, cr = t);
+  }
+  function xr() {
+    yr.point = Sr;
+  }
+  function _r() {
+    yr.point = Ar;
+  }
+  function Nr() {
+    Rr(or, ur);
+  }
+  function Ar(n, t) {
+    yr.point = Rr, Sr(or = ar = n, ur = cr = t);
+  }
+  function Rr(n, t) {
+    var r = n - ar,
+      e = t - cr,
+      i = M(r * r + e * e);
+    sr += i * (ar + n) / 2, hr += i * (cr + t) / 2, gr += i, dr += (i = cr * n - ar * t) * (ar + n), vr += i * (cr + t), Er += 3 * i, Sr(ar = n, cr = t);
+  }
+  function Cr(n) {
+    this._context = n;
+  }
+  Cr.prototype = {
+    _radius: 4.5,
+    pointRadius: function (n) {
+      return this._radius = n, this;
+    },
+    polygonStart: function () {
+      this._line = 0;
+    },
+    polygonEnd: function () {
+      this._line = NaN;
+    },
+    lineStart: function () {
+      this._point = 0;
+    },
+    lineEnd: function () {
+      0 === this._line && this._context.closePath(), this._point = NaN;
+    },
+    point: function (n, t) {
+      switch (this._point) {
+        case 0:
+          this._context.moveTo(n, t), this._point = 1;
+          break;
+        case 1:
+          this._context.lineTo(n, t);
+          break;
+        default:
+          this._context.moveTo(n + this._radius, t), this._context.arc(n, t, this._radius, 0, a);
+      }
+    },
+    result: A
+  };
+  var Pr,
+    $r,
+    qr,
+    jr,
+    zr,
+    br = new t.Adder(),
+    Lr = {
+      point: A,
+      lineStart: function () {
+        Lr.point = Tr;
+      },
+      lineEnd: function () {
+        Pr && Gr($r, qr), Lr.point = A;
+      },
+      polygonStart: function () {
+        Pr = !0;
+      },
+      polygonEnd: function () {
+        Pr = null;
+      },
+      result: function () {
+        var n = +br;
+        return br = new t.Adder(), n;
+      }
+    };
+  function Tr(n, t) {
+    Lr.point = Gr, $r = jr = n, qr = zr = t;
+  }
+  function Gr(n, t) {
+    jr -= n, zr -= t, br.add(M(jr * jr + zr * zr)), jr = n, zr = t;
+  }
+  let Or, kr, Fr, Hr;
+  class Ir {
+    constructor(n) {
+      this._append = null == n ? Wr : function (n) {
+        const t = Math.floor(n);
+        if (!(t >= 0)) throw new RangeError(`invalid digits: ${n}`);
+        if (t > 15) return Wr;
+        if (t !== Or) {
+          const n = 10 ** t;
+          Or = t, kr = function (t) {
+            let r = 1;
+            this._ += t[0];
+            for (const e = t.length; r < e; ++r) this._ += Math.round(arguments[r] * n) / n + t[r];
+          };
+        }
+        return kr;
+      }(n), this._radius = 4.5, this._ = "";
+    }
+    pointRadius(n) {
+      return this._radius = +n, this;
+    }
+    polygonStart() {
+      this._line = 0;
+    }
+    polygonEnd() {
+      this._line = NaN;
+    }
+    lineStart() {
+      this._point = 0;
+    }
+    lineEnd() {
+      0 === this._line && (this._ += "Z"), this._point = NaN;
+    }
+    point(n, t) {
+      switch (this._point) {
+        case 0:
+          this._append`M${n},${t}`, this._point = 1;
+          break;
+        case 1:
+          this._append`L${n},${t}`;
+          break;
+        default:
+          if (this._append`M${n},${t}`, this._radius !== Fr || this._append !== kr) {
+            const n = this._radius,
+              t = this._;
+            this._ = "", this._append`m0,${n}a${n},${n} 0 1,1 0,${-2 * n}a${n},${n} 0 1,1 0,${2 * n}z`, Fr = n, kr = this._append, Hr = this._, this._ = t;
+          }
+          this._ += Hr;
+      }
+    }
+    result() {
+      const n = this._;
+      return this._ = "", n.length ? n : null;
+    }
+  }
+  function Wr(n) {
+    let t = 1;
+    this._ += n[0];
+    for (const r = n.length; t < r; ++t) this._ += arguments[t] + n[t];
+  }
+  function Xr(n) {
+    return function (t) {
+      var r = new Yr();
+      for (var e in n) r[e] = n[e];
+      return r.stream = t, r;
+    };
+  }
+  function Yr() {}
+  function Br(n, t, r) {
+    var e = n.clipExtent && n.clipExtent();
+    return n.scale(150).translate([0, 0]), null != e && n.clipExtent(null), j(r, n.stream(ir)), t(ir.result()), null != e && n.clipExtent(e), n;
+  }
+  function Dr(n, t, r) {
+    return Br(n, function (r) {
+      var e = t[1][0] - t[0][0],
+        i = t[1][1] - t[0][1],
+        o = Math.min(e / (r[1][0] - r[0][0]), i / (r[1][1] - r[0][1])),
+        u = +t[0][0] + (e - o * (r[1][0] + r[0][0])) / 2,
+        a = +t[0][1] + (i - o * (r[1][1] + r[0][1])) / 2;
+      n.scale(150 * o).translate([u, a]);
+    }, r);
+  }
+  function Ur(n, t, r) {
+    return Dr(n, [[0, 0], t], r);
+  }
+  function Zr(n, t, r) {
+    return Br(n, function (r) {
+      var e = +t,
+        i = e / (r[1][0] - r[0][0]),
+        o = (e - i * (r[1][0] + r[0][0])) / 2,
+        u = -i * r[0][1];
+      n.scale(150 * i).translate([o, u]);
+    }, r);
+  }
+  function Jr(n, t, r) {
+    return Br(n, function (r) {
+      var e = +t,
+        i = e / (r[1][1] - r[0][1]),
+        o = -i * r[0][0],
+        u = (e - i * (r[1][1] + r[0][1])) / 2;
+      n.scale(150 * i).translate([o, u]);
+    }, r);
+  }
+  Yr.prototype = {
+    constructor: Yr,
+    point: function (n, t) {
+      this.stream.point(n, t);
+    },
+    sphere: function () {
+      this.stream.sphere();
+    },
+    lineStart: function () {
+      this.stream.lineStart();
+    },
+    lineEnd: function () {
+      this.stream.lineEnd();
+    },
+    polygonStart: function () {
+      this.stream.polygonStart();
+    },
+    polygonEnd: function () {
+      this.stream.polygonEnd();
+    }
+  };
+  var Kr = 16,
+    Qr = h(30 * l);
+  function Vr(n, t) {
+    return +t ? function (n, t) {
+      function e(i, o, u, a, c, l, p, h, g, d, v, E, y, S) {
+        var m = p - i,
+          w = h - o,
+          x = m * m + w * w;
+        if (x > 4 * t && y--) {
+          var N = a + d,
+            A = c + v,
+            R = l + E,
+            C = M(N * N + A * A + R * R),
+            P = _(R /= C),
+            $ = f(f(R) - 1) < r || f(u - g) < r ? (u + g) / 2 : s(A, N),
+            q = n($, P),
+            j = q[0],
+            z = q[1],
+            b = j - i,
+            L = z - o,
+            T = w * b - m * L;
+          (T * T / x > t || f((m * b + w * L) / x - .5) > .3 || a * d + c * v + l * E < Qr) && (e(i, o, u, a, c, l, j, z, $, N /= C, A /= C, R, y, S), S.point(j, z), e(j, z, $, N, A, R, p, h, g, d, v, E, y, S));
+        }
+      }
+      return function (t) {
+        var r,
+          i,
+          o,
+          u,
+          a,
+          c,
+          l,
+          f,
+          p,
+          s,
+          h,
+          g,
+          d = {
+            point: v,
+            lineStart: E,
+            lineEnd: S,
+            polygonStart: function () {
+              t.polygonStart(), d.lineStart = m;
+            },
+            polygonEnd: function () {
+              t.polygonEnd(), d.lineStart = E;
+            }
+          };
+        function v(r, e) {
+          r = n(r, e), t.point(r[0], r[1]);
+        }
+        function E() {
+          f = NaN, d.point = y, t.lineStart();
+        }
+        function y(r, i) {
+          var o = en([r, i]),
+            u = n(r, i);
+          e(f, p, l, s, h, g, f = u[0], p = u[1], l = r, s = o[0], h = o[1], g = o[2], Kr, t), t.point(f, p);
+        }
+        function S() {
+          d.point = v, t.lineEnd();
+        }
+        function m() {
+          E(), d.point = M, d.lineEnd = w;
+        }
+        function M(n, t) {
+          y(r = n, t), i = f, o = p, u = s, a = h, c = g, d.point = y;
+        }
+        function w() {
+          e(f, p, l, s, h, g, i, o, r, u, a, c, Kr, t), d.lineEnd = S, S();
+        }
+        return d;
+      };
+    }(n, t) : function (n) {
+      return Xr({
+        point: function (t, r) {
+          t = n(t, r), this.stream.point(t[0], t[1]);
+        }
+      });
+    }(n);
+  }
+  var ne = Xr({
+    point: function (n, t) {
+      this.stream.point(n * l, t * l);
+    }
+  });
+  function te(n, t, r, e, i, o) {
+    if (!o) return function (n, t, r, e, i) {
+      function o(o, u) {
+        return [t + n * (o *= e), r - n * (u *= i)];
+      }
+      return o.invert = function (o, u) {
+        return [(o - t) / n * e, (r - u) / n * i];
+      }, o;
+    }(n, t, r, e, i);
+    var u = h(o),
+      a = S(o),
+      c = u * n,
+      l = a * n,
+      f = u / n,
+      p = a / n,
+      s = (a * r - u * t) / n,
+      g = (a * t + u * r) / n;
+    function d(n, o) {
+      return [c * (n *= e) - l * (o *= i) + t, r - l * n - c * o];
+    }
+    return d.invert = function (n, t) {
+      return [e * (f * n - p * t + s), i * (g - p * n - f * t)];
+    }, d;
+  }
+  function re(n) {
+    return ee(function () {
+      return n;
+    })();
+  }
+  function ee(n) {
+    var t,
+      r,
+      e,
+      i,
+      o,
+      u,
+      a,
+      f,
+      p,
+      s,
+      h = 150,
+      g = 480,
+      d = 250,
+      v = 0,
+      E = 0,
+      y = 0,
+      S = 0,
+      m = 0,
+      w = 0,
+      x = 1,
+      _ = 1,
+      N = null,
+      A = gt,
+      R = null,
+      C = Bt,
+      P = .5;
+    function $(n) {
+      return f(n[0] * l, n[1] * l);
+    }
+    function q(n) {
+      return (n = f.invert(n[0], n[1])) && [n[0] * c, n[1] * c];
+    }
+    function j() {
+      var n = te(h, 0, 0, x, _, w).apply(null, t(v, E)),
+        e = te(h, g - n[0], d - n[1], x, _, w);
+      return r = Kn(y, S, m), a = Zn(t, e), f = Zn(r, a), u = Vr(a, P), z();
+    }
+    function z() {
+      return p = s = null, $;
+    }
+    return $.stream = function (n) {
+      return p && s === n ? p : p = ne(function (n) {
+        return Xr({
+          point: function (t, r) {
+            var e = n(t, r);
+            return this.stream.point(e[0], e[1]);
+          }
+        });
+      }(r)(A(u(C(s = n)))));
+    }, $.preclip = function (n) {
+      return arguments.length ? (A = n, N = void 0, z()) : A;
+    }, $.postclip = function (n) {
+      return arguments.length ? (C = n, R = e = i = o = null, z()) : C;
+    }, $.clipAngle = function (n) {
+      return arguments.length ? (A = +n ? dt(N = n * l) : (N = null, gt), z()) : N * c;
+    }, $.clipExtent = function (n) {
+      return arguments.length ? (C = null == n ? (R = e = i = o = null, Bt) : wt(R = +n[0][0], e = +n[0][1], i = +n[1][0], o = +n[1][1]), z()) : null == R ? null : [[R, e], [i, o]];
+    }, $.scale = function (n) {
+      return arguments.length ? (h = +n, j()) : h;
+    }, $.translate = function (n) {
+      return arguments.length ? (g = +n[0], d = +n[1], j()) : [g, d];
+    }, $.center = function (n) {
+      return arguments.length ? (v = n[0] % 360 * l, E = n[1] % 360 * l, j()) : [v * c, E * c];
+    }, $.rotate = function (n) {
+      return arguments.length ? (y = n[0] % 360 * l, S = n[1] % 360 * l, m = n.length > 2 ? n[2] % 360 * l : 0, j()) : [y * c, S * c, m * c];
+    }, $.angle = function (n) {
+      return arguments.length ? (w = n % 360 * l, j()) : w * c;
+    }, $.reflectX = function (n) {
+      return arguments.length ? (x = n ? -1 : 1, j()) : x < 0;
+    }, $.reflectY = function (n) {
+      return arguments.length ? (_ = n ? -1 : 1, j()) : _ < 0;
+    }, $.precision = function (n) {
+      return arguments.length ? (u = Vr(a, P = n * n), z()) : M(P);
+    }, $.fitExtent = function (n, t) {
+      return Dr($, n, t);
+    }, $.fitSize = function (n, t) {
+      return Ur($, n, t);
+    }, $.fitWidth = function (n, t) {
+      return Zr($, n, t);
+    }, $.fitHeight = function (n, t) {
+      return Jr($, n, t);
+    }, function () {
+      return t = n.apply(this, arguments), $.invert = t.invert && q, j();
+    };
+  }
+  function ie(n) {
+    var t = 0,
+      r = i / 3,
+      e = ee(n),
+      o = e(t, r);
+    return o.parallels = function (n) {
+      return arguments.length ? e(t = n[0] * l, r = n[1] * l) : [t * c, r * c];
+    }, o;
+  }
+  function oe(n, t) {
+    var e = S(n),
+      o = (e + S(t)) / 2;
+    if (f(o) < r) return function (n) {
+      var t = h(n);
+      function r(n, r) {
+        return [n * t, S(r) / t];
+      }
+      return r.invert = function (n, r) {
+        return [n / t, _(r * t)];
+      }, r;
+    }(n);
+    var u = 1 + e * (2 * o - e),
+      a = M(u) / o;
+    function c(n, t) {
+      var r = M(u - 2 * o * S(t)) / o;
+      return [r * S(n *= o), a - r * h(n)];
+    }
+    return c.invert = function (n, t) {
+      var r = a - t,
+        e = s(n, f(r)) * m(r);
+      return r * o < 0 && (e -= i * m(n) * m(r)), [e / o, _((u - (n * n + r * r) * o * o) / (2 * o))];
+    }, c;
+  }
+  function ue() {
+    return ie(oe).scale(155.424).center([0, 33.6442]);
+  }
+  function ae() {
+    return ue().parallels([29.5, 45.5]).scale(1070).translate([480, 250]).rotate([96, 0]).center([-.6, 38.7]);
+  }
+  function ce(n) {
+    return function (t, r) {
+      var e = h(t),
+        i = h(r),
+        o = n(e * i);
+      return o === 1 / 0 ? [2, 0] : [o * i * S(t), o * S(r)];
+    };
+  }
+  function le(n) {
+    return function (t, r) {
+      var e = M(t * t + r * r),
+        i = n(e),
+        o = S(i),
+        u = h(i);
+      return [s(t * o, e * u), _(e && r * o / e)];
+    };
+  }
+  var fe = ce(function (n) {
+    return M(2 / (1 + n));
+  });
+  fe.invert = le(function (n) {
+    return 2 * _(n / 2);
+  });
+  var pe = ce(function (n) {
+    return (n = x(n)) && n / S(n);
+  });
+  function se(n, t) {
+    return [n, E(w((o + t) / 2))];
+  }
+  function he(n) {
+    var t,
+      r,
+      e,
+      o = re(n),
+      u = o.center,
+      a = o.scale,
+      c = o.translate,
+      l = o.clipExtent,
+      f = null;
+    function p() {
+      var u = i * a(),
+        c = o(tt(o.rotate()).invert([0, 0]));
+      return l(null == f ? [[c[0] - u, c[1] - u], [c[0] + u, c[1] + u]] : n === se ? [[Math.max(c[0] - u, f), t], [Math.min(c[0] + u, r), e]] : [[f, Math.max(c[1] - u, t)], [r, Math.min(c[1] + u, e)]]);
+    }
+    return o.scale = function (n) {
+      return arguments.length ? (a(n), p()) : a();
+    }, o.translate = function (n) {
+      return arguments.length ? (c(n), p()) : c();
+    }, o.center = function (n) {
+      return arguments.length ? (u(n), p()) : u();
+    }, o.clipExtent = function (n) {
+      return arguments.length ? (null == n ? f = t = r = e = null : (f = +n[0][0], t = +n[0][1], r = +n[1][0], e = +n[1][1]), p()) : null == f ? null : [[f, t], [r, e]];
+    }, p();
+  }
+  function ge(n) {
+    return w((o + n) / 2);
+  }
+  function de(n, t) {
+    var e = h(n),
+      u = n === t ? S(n) : E(e / h(t)) / E(ge(t) / ge(n)),
+      a = e * y(ge(n), u) / u;
+    if (!u) return se;
+    function c(n, t) {
+      a > 0 ? t < -o + r && (t = -o + r) : t > o - r && (t = o - r);
+      var e = a / y(ge(t), u);
+      return [e * S(u * n), a - e * h(u * n)];
+    }
+    return c.invert = function (n, t) {
+      var r = a - t,
+        e = m(u) * M(n * n + r * r),
+        c = s(n, f(r)) * m(r);
+      return r * u < 0 && (c -= i * m(n) * m(r)), [c / u, 2 * p(y(a / e, 1 / u)) - o];
+    }, c;
+  }
+  function ve(n, t) {
+    return [n, t];
+  }
+  function Ee(n, t) {
+    var e = h(n),
+      o = n === t ? S(n) : (e - h(t)) / (t - n),
+      u = e / o + n;
+    if (f(o) < r) return ve;
+    function a(n, t) {
+      var r = u - t,
+        e = o * n;
+      return [r * S(e), u - r * h(e)];
+    }
+    return a.invert = function (n, t) {
+      var r = u - t,
+        e = s(n, f(r)) * m(r);
+      return r * o < 0 && (e -= i * m(n) * m(r)), [e / o, u - m(o) * M(n * n + r * r)];
+    }, a;
+  }
+  pe.invert = le(function (n) {
+    return n;
+  }), se.invert = function (n, t) {
+    return [n, 2 * p(d(t)) - o];
+  }, ve.invert = ve;
+  var ye = 1.340264,
+    Se = -.081106,
+    me = 893e-6,
+    Me = .003796,
+    we = M(3) / 2;
+  function xe(n, t) {
+    var r = _(we * S(t)),
+      e = r * r,
+      i = e * e * e;
+    return [n * h(r) / (we * (ye + 3 * Se * e + i * (7 * me + 9 * Me * e))), r * (ye + Se * e + i * (me + Me * e))];
+  }
+  function _e(n, t) {
+    var r = h(t),
+      e = h(n) * r;
+    return [r * S(n) / e, S(t) / e];
+  }
+  function Ne(n, t) {
+    var r = t * t,
+      e = r * r;
+    return [n * (.8707 - .131979 * r + e * (e * (.003971 * r - .001529 * e) - .013791)), t * (1.007226 + r * (.015085 + e * (.028874 * r - .044475 - .005916 * e)))];
+  }
+  function Ae(n, t) {
+    return [h(t) * S(n), S(t)];
+  }
+  function Re(n, t) {
+    var r = h(t),
+      e = 1 + h(n) * r;
+    return [r * S(n) / e, S(t) / e];
+  }
+  function Ce(n, t) {
+    return [E(w((o + t) / 2)), -n];
+  }
+  xe.invert = function (n, t) {
+    for (var r, i = t, o = i * i, u = o * o * o, a = 0; a < 12 && (u = (o = (i -= r = (i * (ye + Se * o + u * (me + Me * o)) - t) / (ye + 3 * Se * o + u * (7 * me + 9 * Me * o))) * i) * o * o, !(f(r) < e)); ++a);
+    return [we * n * (ye + 3 * Se * o + u * (7 * me + 9 * Me * o)) / h(i), _(S(i) / we)];
+  }, _e.invert = le(p), Ne.invert = function (n, t) {
+    var e,
+      i = t,
+      o = 25;
+    do {
+      var u = i * i,
+        a = u * u;
+      i -= e = (i * (1.007226 + u * (.015085 + a * (.028874 * u - .044475 - .005916 * a))) - t) / (1.007226 + u * (.045255 + a * (.259866 * u - .311325 - .005916 * 11 * a)));
+    } while (f(e) > r && --o > 0);
+    return [n / (.8707 + (u = i * i) * (u * (u * u * u * (.003971 - .001529 * u) - .013791) - .131979)), i];
+  }, Ae.invert = le(_), Re.invert = le(function (n) {
+    return 2 * p(n);
+  }), Ce.invert = function (n, t) {
+    return [-t, 2 * p(d(n)) - o];
+  }, n.geoAlbers = ae, n.geoAlbersUsa = function () {
+    var n,
+      t,
+      e,
+      i,
+      o,
+      u,
+      a = ae(),
+      c = ue().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]),
+      l = ue().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]),
+      f = {
+        point: function (n, t) {
+          u = [n, t];
+        }
+      };
+    function p(n) {
+      var t = n[0],
+        r = n[1];
+      return u = null, e.point(t, r), u || (i.point(t, r), u) || (o.point(t, r), u);
+    }
+    function s() {
+      return n = t = null, p;
+    }
+    return p.invert = function (n) {
+      var t = a.scale(),
+        r = a.translate(),
+        e = (n[0] - r[0]) / t,
+        i = (n[1] - r[1]) / t;
+      return (i >= .12 && i < .234 && e >= -.425 && e < -.214 ? c : i >= .166 && i < .234 && e >= -.214 && e < -.115 ? l : a).invert(n);
+    }, p.stream = function (r) {
+      return n && t === r ? n : (e = [a.stream(t = r), c.stream(r), l.stream(r)], i = e.length, n = {
+        point: function (n, t) {
+          for (var r = -1; ++r < i;) e[r].point(n, t);
+        },
+        sphere: function () {
+          for (var n = -1; ++n < i;) e[n].sphere();
+        },
+        lineStart: function () {
+          for (var n = -1; ++n < i;) e[n].lineStart();
+        },
+        lineEnd: function () {
+          for (var n = -1; ++n < i;) e[n].lineEnd();
+        },
+        polygonStart: function () {
+          for (var n = -1; ++n < i;) e[n].polygonStart();
+        },
+        polygonEnd: function () {
+          for (var n = -1; ++n < i;) e[n].polygonEnd();
+        }
+      });
+      var e, i;
+    }, p.precision = function (n) {
+      return arguments.length ? (a.precision(n), c.precision(n), l.precision(n), s()) : a.precision();
+    }, p.scale = function (n) {
+      return arguments.length ? (a.scale(n), c.scale(.35 * n), l.scale(n), p.translate(a.translate())) : a.scale();
+    }, p.translate = function (n) {
+      if (!arguments.length) return a.translate();
+      var t = a.scale(),
+        u = +n[0],
+        p = +n[1];
+      return e = a.translate(n).clipExtent([[u - .455 * t, p - .238 * t], [u + .455 * t, p + .238 * t]]).stream(f), i = c.translate([u - .307 * t, p + .201 * t]).clipExtent([[u - .425 * t + r, p + .12 * t + r], [u - .214 * t - r, p + .234 * t - r]]).stream(f), o = l.translate([u - .205 * t, p + .212 * t]).clipExtent([[u - .214 * t + r, p + .166 * t + r], [u - .115 * t - r, p + .234 * t - r]]).stream(f), s();
+    }, p.fitExtent = function (n, t) {
+      return Dr(p, n, t);
+    }, p.fitSize = function (n, t) {
+      return Ur(p, n, t);
+    }, p.fitWidth = function (n, t) {
+      return Zr(p, n, t);
+    }, p.fitHeight = function (n, t) {
+      return Jr(p, n, t);
+    }, p.scale(1070);
+  }, n.geoArea = function (n) {
+    return J = new t.Adder(), j(n, K), 2 * J;
+  }, n.geoAzimuthalEqualArea = function () {
+    return re(fe).scale(124.75).clipAngle(179.999);
+  }, n.geoAzimuthalEqualAreaRaw = fe, n.geoAzimuthalEquidistant = function () {
+    return re(pe).scale(79.4188).clipAngle(179.999);
+  }, n.geoAzimuthalEquidistantRaw = pe, n.geoBounds = function (n) {
+    var t, r, e, i, o, u, a;
+    if (H = F = -(O = k = 1 / 0), D = [], j(n, An), r = D.length) {
+      for (D.sort(Ln), t = 1, o = [e = D[0]]; t < r; ++t) Tn(e, (i = D[t])[0]) || Tn(e, i[1]) ? (bn(e[0], i[1]) > bn(e[0], e[1]) && (e[1] = i[1]), bn(i[0], e[1]) > bn(e[0], e[1]) && (e[0] = i[0])) : o.push(e = i);
+      for (u = -1 / 0, t = 0, e = o[r = o.length - 1]; t <= r; e = i, ++t) i = o[t], (a = bn(e[1], i[0])) > u && (u = a, O = i[0], F = e[1]);
+    }
+    return D = U = null, O === 1 / 0 || k === 1 / 0 ? [[NaN, NaN], [NaN, NaN]] : [[O, k], [F, H]];
+  }, n.geoCentroid = function (n) {
+    fn = pn = sn = hn = gn = dn = vn = En = 0, yn = new t.Adder(), Sn = new t.Adder(), mn = new t.Adder(), j(n, Gn);
+    var i = +yn,
+      o = +Sn,
+      u = +mn,
+      a = v(i, o, u);
+    return a < e && (i = dn, o = vn, u = En, pn < r && (i = sn, o = hn, u = gn), (a = v(i, o, u)) < e) ? [NaN, NaN] : [s(o, i) * c, _(u / a) * c];
+  }, n.geoCircle = function () {
+    var n,
+      t,
+      r = Un([0, 0]),
+      e = Un(90),
+      i = Un(2),
+      o = {
+        point: function (r, e) {
+          n.push(r = t(r, e)), r[0] *= c, r[1] *= c;
+        }
+      };
+    function u() {
+      var u = r.apply(this, arguments),
+        a = e.apply(this, arguments) * l,
+        c = i.apply(this, arguments) * l;
+      return n = [], t = Kn(-u[0] * l, -u[1] * l, 0).invert, rt(o, a, c, 1), u = {
+        type: "Polygon",
+        coordinates: [n]
+      }, n = t = null, u;
+    }
+    return u.center = function (n) {
+      return arguments.length ? (r = "function" == typeof n ? n : Un([+n[0], +n[1]]), u) : r;
+    }, u.radius = function (n) {
+      return arguments.length ? (e = "function" == typeof n ? n : Un(+n), u) : e;
+    }, u.precision = function (n) {
+      return arguments.length ? (i = "function" == typeof n ? n : Un(+n), u) : i;
+    }, u;
+  }, n.geoClipAntimeridian = gt, n.geoClipCircle = dt, n.geoClipExtent = function () {
+    var n,
+      t,
+      r,
+      e = 0,
+      i = 0,
+      o = 960,
+      u = 500;
+    return r = {
+      stream: function (r) {
+        return n && t === r ? n : n = wt(e, i, o, u)(t = r);
+      },
+      extent: function (a) {
+        return arguments.length ? (e = +a[0][0], i = +a[0][1], o = +a[1][0], u = +a[1][1], n = t = null, r) : [[e, i], [o, u]];
+      }
+    };
+  }, n.geoClipRectangle = wt, n.geoConicConformal = function () {
+    return ie(de).scale(109.5).parallels([30, 30]);
+  }, n.geoConicConformalRaw = de, n.geoConicEqualArea = ue, n.geoConicEqualAreaRaw = oe, n.geoConicEquidistant = function () {
+    return ie(Ee).scale(131.154).center([0, 13.9389]);
+  }, n.geoConicEquidistantRaw = Ee, n.geoContains = function (n, t) {
+    return (n && qt.hasOwnProperty(n.type) ? qt[n.type] : zt)(n, t);
+  }, n.geoDistance = $t, n.geoEqualEarth = function () {
+    return re(xe).scale(177.158);
+  }, n.geoEqualEarthRaw = xe, n.geoEquirectangular = function () {
+    return re(ve).scale(152.63);
+  }, n.geoEquirectangularRaw = ve, n.geoGnomonic = function () {
+    return re(_e).scale(144.049).clipAngle(60);
+  }, n.geoGnomonicRaw = _e, n.geoGraticule = Ht, n.geoGraticule10 = function () {
+    return Ht()();
+  }, n.geoIdentity = function () {
+    var n,
+      t,
+      r,
+      e,
+      i,
+      o,
+      u,
+      a = 1,
+      f = 0,
+      p = 0,
+      s = 1,
+      g = 1,
+      d = 0,
+      v = null,
+      E = 1,
+      y = 1,
+      m = Xr({
+        point: function (n, t) {
+          var r = x([n, t]);
+          this.stream.point(r[0], r[1]);
+        }
+      }),
+      M = Bt;
+    function w() {
+      return E = a * s, y = a * g, o = u = null, x;
+    }
+    function x(r) {
+      var e = r[0] * E,
+        i = r[1] * y;
+      if (d) {
+        var o = i * n - e * t;
+        e = e * n + i * t, i = o;
+      }
+      return [e + f, i + p];
+    }
+    return x.invert = function (r) {
+      var e = r[0] - f,
+        i = r[1] - p;
+      if (d) {
+        var o = i * n + e * t;
+        e = e * n - i * t, i = o;
+      }
+      return [e / E, i / y];
+    }, x.stream = function (n) {
+      return o && u === n ? o : o = m(M(u = n));
+    }, x.postclip = function (n) {
+      return arguments.length ? (M = n, v = r = e = i = null, w()) : M;
+    }, x.clipExtent = function (n) {
+      return arguments.length ? (M = null == n ? (v = r = e = i = null, Bt) : wt(v = +n[0][0], r = +n[0][1], e = +n[1][0], i = +n[1][1]), w()) : null == v ? null : [[v, r], [e, i]];
+    }, x.scale = function (n) {
+      return arguments.length ? (a = +n, w()) : a;
+    }, x.translate = function (n) {
+      return arguments.length ? (f = +n[0], p = +n[1], w()) : [f, p];
+    }, x.angle = function (r) {
+      return arguments.length ? (t = S(d = r % 360 * l), n = h(d), w()) : d * c;
+    }, x.reflectX = function (n) {
+      return arguments.length ? (s = n ? -1 : 1, w()) : s < 0;
+    }, x.reflectY = function (n) {
+      return arguments.length ? (g = n ? -1 : 1, w()) : g < 0;
+    }, x.fitExtent = function (n, t) {
+      return Dr(x, n, t);
+    }, x.fitSize = function (n, t) {
+      return Ur(x, n, t);
+    }, x.fitWidth = function (n, t) {
+      return Zr(x, n, t);
+    }, x.fitHeight = function (n, t) {
+      return Jr(x, n, t);
+    }, x;
+  }, n.geoInterpolate = function (n, t) {
+    var r = n[0] * l,
+      e = n[1] * l,
+      i = t[0] * l,
+      o = t[1] * l,
+      u = h(e),
+      a = S(e),
+      f = h(o),
+      p = S(o),
+      g = u * h(r),
+      d = u * S(r),
+      v = f * h(i),
+      E = f * S(i),
+      y = 2 * _(M(N(o - e) + u * f * N(i - r))),
+      m = S(y),
+      w = y ? function (n) {
+        var t = S(n *= y) / m,
+          r = S(y - n) / m,
+          e = r * g + t * v,
+          i = r * d + t * E,
+          o = r * a + t * p;
+        return [s(i, e) * c, s(o, M(e * e + i * i)) * c];
+      } : function () {
+        return [r * c, e * c];
+      };
+    return w.distance = y, w;
+  }, n.geoLength = Rt, n.geoMercator = function () {
+    return he(se).scale(961 / a);
+  }, n.geoMercatorRaw = se, n.geoNaturalEarth1 = function () {
+    return re(Ne).scale(175.295);
+  }, n.geoNaturalEarth1Raw = Ne, n.geoOrthographic = function () {
+    return re(Ae).scale(249.5).clipAngle(90 + r);
+  }, n.geoOrthographicRaw = Ae, n.geoPath = function (n, t) {
+    let r,
+      e,
+      i = 3,
+      o = 4.5;
+    function u(n) {
+      return n && ("function" == typeof o && e.pointRadius(+o.apply(this, arguments)), j(n, r(e))), e.result();
+    }
+    return u.area = function (n) {
+      return j(n, r(Zt)), Zt.result();
+    }, u.measure = function (n) {
+      return j(n, r(Lr)), Lr.result();
+    }, u.bounds = function (n) {
+      return j(n, r(ir)), ir.result();
+    }, u.centroid = function (n) {
+      return j(n, r(yr)), yr.result();
+    }, u.projection = function (t) {
+      return arguments.length ? (r = null == t ? (n = null, Bt) : (n = t).stream, u) : n;
+    }, u.context = function (n) {
+      return arguments.length ? (e = null == n ? (t = null, new Ir(i)) : new Cr(t = n), "function" != typeof o && e.pointRadius(o), u) : t;
+    }, u.pointRadius = function (n) {
+      return arguments.length ? (o = "function" == typeof n ? n : (e.pointRadius(+n), +n), u) : o;
+    }, u.digits = function (n) {
+      if (!arguments.length) return i;
+      if (null == n) i = null;else {
+        const t = Math.floor(n);
+        if (!(t >= 0)) throw new RangeError(`invalid digits: ${n}`);
+        i = t;
+      }
+      return null === t && (e = new Ir(i)), u;
+    }, u.projection(n).digits(i).context(t);
+  }, n.geoProjection = re, n.geoProjectionMutator = ee, n.geoRotation = tt, n.geoStereographic = function () {
+    return re(Re).scale(250).clipAngle(142);
+  }, n.geoStereographicRaw = Re, n.geoStream = j, n.geoTransform = function (n) {
+    return {
+      stream: Xr(n)
+    };
+  }, n.geoTransverseMercator = function () {
+    var n = he(Ce),
+      t = n.center,
+      r = n.rotate;
+    return n.center = function (n) {
+      return arguments.length ? t([-n[1], n[0]]) : [(n = t())[1], -n[0]];
+    }, n.rotate = function (n) {
+      return arguments.length ? r([n[0], n[1], n.length > 2 ? n[2] + 90 : 90]) : [(n = r())[0], n[1], n[2] - 90];
+    }, r([0, 0, 90]).scale(159.155);
+  }, n.geoTransverseMercatorRaw = Ce;
+});