@orangelogic/design-system 2.69.0 → 2.70.0

package/library/chunks/map.DbgNAGxD.js

@@ -0,0 +1,3037 @@
+import { J as Wi, e as N, a4 as fi, b4 as En, bc as Nn, ap as ri, G as we, P as Rn, a as gt, L as Ji, T as Vi, D as In, F as pi, I as gi, am as Se, aF as Hi, k as zn, bd as Bn, aZ as Ft, be as kn, m as jn, w as Yn, f as Xn, ax as di, y as mi, z as Ee, t as yi, bf as $n, aj as Gn, K as Zn, bg as xe, a2 as An, C as _i, az as On, b as Fn, bh as bn } from "./am-chart.oZVBmpnn.js";
+import { g as Wn, a as Jn } from "./_commonjsHelpers.DQNKXVTB.js";
+import { i as Vn } from "./index.DU0XUO4k.js";
+import { a as qi } from "./ZoomTools.cgwuIB0e.js";
+class b {
+  constructor() {
+    this._partials = new Float64Array(32), this._n = 0;
+  }
+  add(t) {
+    const e = this._partials;
+    let i = 0;
+    for (let o = 0; o < this._n && o < 32; o++) {
+      const s = e[o], r = t + s, a = Math.abs(t) < Math.abs(s) ? t - (r - s) : s - (r - t);
+      a && (e[i++] = a), t = r;
+    }
+    return e[i] = t, this._n = i + 1, this;
+  }
+  valueOf() {
+    const t = this._partials;
+    let e = this._n, i, o, s, r = 0;
+    if (e > 0) {
+      for (r = t[--e]; e > 0 && (i = r, o = t[--e], r = i + o, s = o - (r - i), !s); )
+        ;
+      e > 0 && (s < 0 && t[e - 1] < 0 || s > 0 && t[e - 1] > 0) && (o = s * 2, i = r + o, o == i - r && (r = i));
+    }
+    return r;
+  }
+}
+function* Hn(n) {
+  for (const t of n)
+    yield* t;
+}
+function Ui(n) {
+  return Array.from(Hn(n));
+}
+function xt(n, t, e) {
+  n = +n, t = +t, e = (o = arguments.length) < 2 ? (t = n, n = 0, 1) : o < 3 ? 1 : +e;
+  for (var i = -1, o = Math.max(0, Math.ceil((t - n) / e)) | 0, s = new Array(o); ++i < o; )
+    s[i] = n + i * e;
+  return s;
+}
+var E = 1e-6, Ne = 1e-12, z = Math.PI, Q = z / 2, ee = z / 4, H = z * 2, Z = 180 / z, L = z / 180, k = Math.abs, Qi = Math.atan, ot = Math.atan2, T = Math.cos, bt = Math.ceil, qn = Math.exp, Re = Math.hypot, Un = Math.log, C = Math.sin, Qn = Math.sign || function(n) {
+  return n > 0 ? 1 : n < 0 ? -1 : 0;
+}, st = Math.sqrt, Kn = Math.tan;
+function to(n) {
+  return n > 1 ? 0 : n < -1 ? z : Math.acos(n);
+}
+function _t(n) {
+  return n > 1 ? Q : n < -1 ? -Q : Math.asin(n);
+}
+function vi(n) {
+  return (n = C(n / 2)) * n;
+}
+function $() {
+}
+function ie(n, t) {
+  n && Di.hasOwnProperty(n.type) && Di[n.type](n, t);
+}
+var Pi = {
+  Feature: function(n, t) {
+    ie(n.geometry, t);
+  },
+  FeatureCollection: function(n, t) {
+    for (var e = n.features, i = -1, o = e.length; ++i < o; ) ie(e[i].geometry, t);
+  }
+}, Di = {
+  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 e = n.coordinates, i = -1, o = e.length; ++i < o; ) n = e[i], t.point(n[0], n[1], n[2]);
+  },
+  LineString: function(n, t) {
+    Ie(n.coordinates, t, 0);
+  },
+  MultiLineString: function(n, t) {
+    for (var e = n.coordinates, i = -1, o = e.length; ++i < o; ) Ie(e[i], t, 0);
+  },
+  Polygon: function(n, t) {
+    wi(n.coordinates, t);
+  },
+  MultiPolygon: function(n, t) {
+    for (var e = n.coordinates, i = -1, o = e.length; ++i < o; ) wi(e[i], t);
+  },
+  GeometryCollection: function(n, t) {
+    for (var e = n.geometries, i = -1, o = e.length; ++i < o; ) ie(e[i], t);
+  }
+};
+function Ie(n, t, e) {
+  var i = -1, o = n.length - e, s;
+  for (t.lineStart(); ++i < o; ) s = n[i], t.point(s[0], s[1], s[2]);
+  t.lineEnd();
+}
+function wi(n, t) {
+  var e = -1, i = n.length;
+  for (t.polygonStart(); ++e < i; ) Ie(n[e], t, 1);
+  t.polygonEnd();
+}
+function rt(n, t) {
+  n && Pi.hasOwnProperty(n.type) ? Pi[n.type](n, t) : ie(n, t);
+}
+var ne = new b(), oe = new b(), Ki, tn, ze, Be, ke, ut = {
+  point: $,
+  lineStart: $,
+  lineEnd: $,
+  polygonStart: function() {
+    ne = new b(), ut.lineStart = eo, ut.lineEnd = io;
+  },
+  polygonEnd: function() {
+    var n = +ne;
+    oe.add(n < 0 ? H + n : n), this.lineStart = this.lineEnd = this.point = $;
+  },
+  sphere: function() {
+    oe.add(H);
+  }
+};
+function eo() {
+  ut.point = no;
+}
+function io() {
+  en(Ki, tn);
+}
+function no(n, t) {
+  ut.point = en, Ki = n, tn = t, n *= L, t *= L, ze = n, Be = T(t = t / 2 + ee), ke = C(t);
+}
+function en(n, t) {
+  n *= L, t *= L, t = t / 2 + ee;
+  var e = n - ze, i = e >= 0 ? 1 : -1, o = i * e, s = T(t), r = C(t), a = ke * r, u = Be * s + a * T(o), h = a * i * C(o);
+  ne.add(ot(h, u)), ze = n, Be = s, ke = r;
+}
+function oo(n) {
+  return oe = new b(), rt(n, ut), oe * 2;
+}
+function se(n) {
+  return [ot(n[1], n[0]), _t(n[2])];
+}
+function Dt(n) {
+  var t = n[0], e = n[1], i = T(e);
+  return [i * T(t), i * C(t), C(e)];
+}
+function Wt(n, t) {
+  return n[0] * t[0] + n[1] * t[1] + n[2] * t[2];
+}
+function Mt(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 Ce(n, t) {
+  n[0] += t[0], n[1] += t[1], n[2] += t[2];
+}
+function Jt(n, t) {
+  return [n[0] * t, n[1] * t, n[2] * t];
+}
+function re(n) {
+  var t = st(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
+  n[0] /= t, n[1] /= t, n[2] /= t;
+}
+var X, U, G, tt, Pt, nn, on, Lt, Yt, yt, dt, ft = {
+  point: je,
+  lineStart: Si,
+  lineEnd: xi,
+  polygonStart: function() {
+    ft.point = rn, ft.lineStart = so, ft.lineEnd = ro, Yt = new b(), ut.polygonStart();
+  },
+  polygonEnd: function() {
+    ut.polygonEnd(), ft.point = je, ft.lineStart = Si, ft.lineEnd = xi, ne < 0 ? (X = -(G = 180), U = -(tt = 90)) : Yt > E ? tt = 90 : Yt < -E && (U = -90), dt[0] = X, dt[1] = G;
+  },
+  sphere: function() {
+    X = -(G = 180), U = -(tt = 90);
+  }
+};
+function je(n, t) {
+  yt.push(dt = [X = n, G = n]), t < U && (U = t), t > tt && (tt = t);
+}
+function sn(n, t) {
+  var e = Dt([n * L, t * L]);
+  if (Lt) {
+    var i = Mt(Lt, e), o = [i[1], -i[0], 0], s = Mt(o, i);
+    re(s), s = se(s);
+    var r = n - Pt, a = r > 0 ? 1 : -1, u = s[0] * Z * a, h, l = k(r) > 180;
+    l ^ (a * Pt < u && u < a * n) ? (h = s[1] * Z, h > tt && (tt = h)) : (u = (u + 360) % 360 - 180, l ^ (a * Pt < u && u < a * n) ? (h = -s[1] * Z, h < U && (U = h)) : (t < U && (U = t), t > tt && (tt = t))), l ? n < Pt ? K(X, n) > K(X, G) && (G = n) : K(n, G) > K(X, G) && (X = n) : G >= X ? (n < X && (X = n), n > G && (G = n)) : n > Pt ? K(X, n) > K(X, G) && (G = n) : K(n, G) > K(X, G) && (X = n);
+  } else
+    yt.push(dt = [X = n, G = n]);
+  t < U && (U = t), t > tt && (tt = t), Lt = e, Pt = n;
+}
+function Si() {
+  ft.point = sn;
+}
+function xi() {
+  dt[0] = X, dt[1] = G, ft.point = je, Lt = null;
+}
+function rn(n, t) {
+  if (Lt) {
+    var e = n - Pt;
+    Yt.add(k(e) > 180 ? e + (e > 0 ? 360 : -360) : e);
+  } else
+    nn = n, on = t;
+  ut.point(n, t), sn(n, t);
+}
+function so() {
+  ut.lineStart();
+}
+function ro() {
+  rn(nn, on), ut.lineEnd(), k(Yt) > E && (X = -(G = 180)), dt[0] = X, dt[1] = G, Lt = null;
+}
+function K(n, t) {
+  return (t -= n) < 0 ? t + 360 : t;
+}
+function ao(n, t) {
+  return n[0] - t[0];
+}
+function Ci(n, t) {
+  return n[0] <= n[1] ? n[0] <= t && t <= n[1] : t < n[0] || n[1] < t;
+}
+function lo(n) {
+  var t, e, i, o, s, r, a;
+  if (tt = G = -(X = U = 1 / 0), yt = [], rt(n, ft), e = yt.length) {
+    for (yt.sort(ao), t = 1, i = yt[0], s = [i]; t < e; ++t)
+      o = yt[t], Ci(i, o[0]) || Ci(i, o[1]) ? (K(i[0], o[1]) > K(i[0], i[1]) && (i[1] = o[1]), K(o[0], i[1]) > K(i[0], i[1]) && (i[0] = o[0])) : s.push(i = o);
+    for (r = -1 / 0, e = s.length - 1, t = 0, i = s[e]; t <= e; i = o, ++t)
+      o = s[t], (a = K(i[1], o[0])) > r && (r = a, X = o[0], G = i[1]);
+  }
+  return yt = dt = null, X === 1 / 0 || U === 1 / 0 ? [[NaN, NaN], [NaN, NaN]] : [[X, U], [G, tt]];
+}
+var Rt, ae, le, ue, he, ce, fe, pe, Ye, Xe, $e, an, ln, W, J, V, nt = {
+  sphere: $,
+  point: ai,
+  lineStart: Li,
+  lineEnd: Mi,
+  polygonStart: function() {
+    nt.lineStart = co, nt.lineEnd = fo;
+  },
+  polygonEnd: function() {
+    nt.lineStart = Li, nt.lineEnd = Mi;
+  }
+};
+function ai(n, t) {
+  n *= L, t *= L;
+  var e = T(t);
+  At(e * T(n), e * C(n), C(t));
+}
+function At(n, t, e) {
+  ++Rt, le += (n - le) / Rt, ue += (t - ue) / Rt, he += (e - he) / Rt;
+}
+function Li() {
+  nt.point = uo;
+}
+function uo(n, t) {
+  n *= L, t *= L;
+  var e = T(t);
+  W = e * T(n), J = e * C(n), V = C(t), nt.point = ho, At(W, J, V);
+}
+function ho(n, t) {
+  n *= L, t *= L;
+  var e = T(t), i = e * T(n), o = e * C(n), s = C(t), r = ot(st((r = J * s - V * o) * r + (r = V * i - W * s) * r + (r = W * o - J * i) * r), W * i + J * o + V * s);
+  ae += r, ce += r * (W + (W = i)), fe += r * (J + (J = o)), pe += r * (V + (V = s)), At(W, J, V);
+}
+function Mi() {
+  nt.point = ai;
+}
+function co() {
+  nt.point = po;
+}
+function fo() {
+  un(an, ln), nt.point = ai;
+}
+function po(n, t) {
+  an = n, ln = t, n *= L, t *= L, nt.point = un;
+  var e = T(t);
+  W = e * T(n), J = e * C(n), V = C(t), At(W, J, V);
+}
+function un(n, t) {
+  n *= L, t *= L;
+  var e = T(t), i = e * T(n), o = e * C(n), s = C(t), r = J * s - V * o, a = V * i - W * s, u = W * o - J * i, h = Re(r, a, u), l = _t(h), c = h && -l / h;
+  Ye.add(c * r), Xe.add(c * a), $e.add(c * u), ae += l, ce += l * (W + (W = i)), fe += l * (J + (J = o)), pe += l * (V + (V = s)), At(W, J, V);
+}
+function go(n) {
+  Rt = ae = le = ue = he = ce = fe = pe = 0, Ye = new b(), Xe = new b(), $e = new b(), rt(n, nt);
+  var t = +Ye, e = +Xe, i = +$e, o = Re(t, e, i);
+  return o < Ne && (t = ce, e = fe, i = pe, ae < E && (t = le, e = ue, i = he), o = Re(t, e, i), o < Ne) ? [NaN, NaN] : [ot(e, t) * Z, _t(i / o) * Z];
+}
+function Ge(n, t) {
+  function e(i, o) {
+    return i = n(i, o), t(i[0], i[1]);
+  }
+  return n.invert && t.invert && (e.invert = function(i, o) {
+    return i = t.invert(i, o), i && n.invert(i[0], i[1]);
+  }), e;
+}
+function Ze(n, t) {
+  return k(n) > z && (n -= Math.round(n / H) * H), [n, t];
+}
+Ze.invert = Ze;
+function hn(n, t, e) {
+  return (n %= H) ? t || e ? Ge(Ei(n), Ni(t, e)) : Ei(n) : t || e ? Ni(t, e) : Ze;
+}
+function Ti(n) {
+  return function(t, e) {
+    return t += n, k(t) > z && (t -= Math.round(t / H) * H), [t, e];
+  };
+}
+function Ei(n) {
+  var t = Ti(n);
+  return t.invert = Ti(-n), t;
+}
+function Ni(n, t) {
+  var e = T(n), i = C(n), o = T(t), s = C(t);
+  function r(a, u) {
+    var h = T(u), l = T(a) * h, c = C(a) * h, f = C(u), p = f * e + l * i;
+    return [
+      ot(c * o - p * s, l * e - f * i),
+      _t(p * o + c * s)
+    ];
+  }
+  return r.invert = function(a, u) {
+    var h = T(u), l = T(a) * h, c = C(a) * h, f = C(u), p = f * o - c * s;
+    return [
+      ot(c * o + f * s, l * e + p * i),
+      _t(p * e - l * i)
+    ];
+  }, r;
+}
+function mo(n) {
+  n = hn(n[0] * L, n[1] * L, n.length > 2 ? n[2] * L : 0);
+  function t(e) {
+    return e = n(e[0] * L, e[1] * L), e[0] *= Z, e[1] *= Z, e;
+  }
+  return t.invert = function(e) {
+    return e = n.invert(e[0] * L, e[1] * L), e[0] *= Z, e[1] *= Z, e;
+  }, t;
+}
+function yo(n, t, e, i, o, s) {
+  if (e) {
+    var r = T(t), a = C(t), u = i * e;
+    o == null ? (o = t + i * H, s = t - u / 2) : (o = Ri(r, o), s = Ri(r, s), (i > 0 ? o < s : o > s) && (o += i * H));
+    for (var h, l = o; i > 0 ? l > s : l < s; l -= u)
+      h = se([r, -a * T(l), -a * C(l)]), n.point(h[0], h[1]);
+  }
+}
+function Ri(n, t) {
+  t = Dt(t), t[0] -= n, re(t);
+  var e = to(-t[1]);
+  return ((-t[2] < 0 ? -e : e) + H - E) % H;
+}
+function cn() {
+  var n = [], t;
+  return {
+    point: function(e, i, o) {
+      t.push([e, i, o]);
+    },
+    lineStart: function() {
+      n.push(t = []);
+    },
+    lineEnd: $,
+    rejoin: function() {
+      n.length > 1 && n.push(n.pop().concat(n.shift()));
+    },
+    result: function() {
+      var e = n;
+      return n = [], t = null, e;
+    }
+  };
+}
+function Ut(n, t) {
+  return k(n[0] - t[0]) < E && k(n[1] - t[1]) < E;
+}
+function Vt(n, t, e, i) {
+  this.x = n, this.z = t, this.o = e, this.e = i, this.v = !1, this.n = this.p = null;
+}
+function fn(n, t, e, i, o) {
+  var s = [], r = [], a, u;
+  if (n.forEach(function(g) {
+    if (!((d = g.length - 1) <= 0)) {
+      var d, m = g[0], y = g[d], P;
+      if (Ut(m, y)) {
+        if (!m[2] && !y[2]) {
+          for (o.lineStart(), a = 0; a < d; ++a) o.point((m = g[a])[0], m[1]);
+          o.lineEnd();
+          return;
+        }
+        y[0] += 2 * E;
+      }
+      s.push(P = new Vt(m, g, null, !0)), r.push(P.o = new Vt(m, null, P, !1)), s.push(P = new Vt(y, g, null, !1)), r.push(P.o = new Vt(y, null, P, !0));
+    }
+  }), !!s.length) {
+    for (r.sort(t), Ii(s), Ii(r), a = 0, u = r.length; a < u; ++a)
+      r[a].e = e = !e;
+    for (var h = s[0], l, c; ; ) {
+      for (var f = h, p = !0; f.v; ) if ((f = f.n) === h) return;
+      l = f.z, o.lineStart();
+      do {
+        if (f.v = f.o.v = !0, f.e) {
+          if (p)
+            for (a = 0, u = l.length; a < u; ++a) o.point((c = l[a])[0], c[1]);
+          else
+            i(f.x, f.n.x, 1, o);
+          f = f.n;
+        } else {
+          if (p)
+            for (l = f.p.z, a = l.length - 1; a >= 0; --a) o.point((c = l[a])[0], c[1]);
+          else
+            i(f.x, f.p.x, -1, o);
+          f = f.p;
+        }
+        f = f.o, l = f.z, p = !p;
+      } while (!f.v);
+      o.lineEnd();
+    }
+  }
+}
+function Ii(n) {
+  if (t = n.length) {
+    for (var t, e = 0, i = n[0], o; ++e < t; )
+      i.n = o = n[e], o.p = i, i = o;
+    i.n = o = n[0], o.p = i;
+  }
+}
+function Le(n) {
+  return k(n[0]) <= z ? n[0] : Qn(n[0]) * ((k(n[0]) + z) % H - z);
+}
+function _o(n, t) {
+  var e = Le(t), i = t[1], o = C(i), s = [C(e), -T(e), 0], r = 0, a = 0, u = new b();
+  o === 1 ? i = Q + E : o === -1 && (i = -Q - E);
+  for (var h = 0, l = n.length; h < l; ++h)
+    if (f = (c = n[h]).length)
+      for (var c, f, p = c[f - 1], g = Le(p), d = p[1] / 2 + ee, m = C(d), y = T(d), P = 0; P < f; ++P, g = D, m = x, y = B, p = _) {
+        var _ = c[P], D = Le(_), w = _[1] / 2 + ee, x = C(w), B = T(w), M = D - g, I = M >= 0 ? 1 : -1, j = I * M, S = j > z, F = m * x;
+        if (u.add(ot(F * I * C(j), y * B + F * T(j))), r += S ? M + I * H : M, S ^ g >= e ^ D >= e) {
+          var A = Mt(Dt(p), Dt(_));
+          re(A);
+          var Y = Mt(s, A);
+          re(Y);
+          var v = (S ^ M >= 0 ? -1 : 1) * _t(Y[2]);
+          (i > v || i === v && (A[0] || A[1])) && (a += S ^ M >= 0 ? 1 : -1);
+        }
+      }
+  return (r < -E || r < E && u < -Ne) ^ a & 1;
+}
+function pn(n, t, e, i) {
+  return function(o) {
+    var s = t(o), r = cn(), a = t(r), u = !1, h, l, c, f = {
+      point: p,
+      lineStart: d,
+      lineEnd: m,
+      polygonStart: function() {
+        f.point = y, f.lineStart = P, f.lineEnd = _, l = [], h = [];
+      },
+      polygonEnd: function() {
+        f.point = p, f.lineStart = d, f.lineEnd = m, l = Ui(l);
+        var D = _o(h, i);
+        l.length ? (u || (o.polygonStart(), u = !0), fn(l, Po, D, e, o)) : D && (u || (o.polygonStart(), u = !0), o.lineStart(), e(null, null, 1, o), o.lineEnd()), u && (o.polygonEnd(), u = !1), l = h = null;
+      },
+      sphere: function() {
+        o.polygonStart(), o.lineStart(), e(null, null, 1, o), o.lineEnd(), o.polygonEnd();
+      }
+    };
+    function p(D, w) {
+      n(D, w) && o.point(D, w);
+    }
+    function g(D, w) {
+      s.point(D, w);
+    }
+    function d() {
+      f.point = g, s.lineStart();
+    }
+    function m() {
+      f.point = p, s.lineEnd();
+    }
+    function y(D, w) {
+      c.push([D, w]), a.point(D, w);
+    }
+    function P() {
+      a.lineStart(), c = [];
+    }
+    function _() {
+      y(c[0][0], c[0][1]), a.lineEnd();
+      var D = a.clean(), w = r.result(), x, B = w.length, M, I, j;
+      if (c.pop(), h.push(c), c = null, !!B) {
+        if (D & 1) {
+          if (I = w[0], (M = I.length - 1) > 0) {
+            for (u || (o.polygonStart(), u = !0), o.lineStart(), x = 0; x < M; ++x) o.point((j = I[x])[0], j[1]);
+            o.lineEnd();
+          }
+          return;
+        }
+        B > 1 && D & 2 && w.push(w.pop().concat(w.shift())), l.push(w.filter(vo));
+      }
+    }
+    return f;
+  };
+}
+function vo(n) {
+  return n.length > 1;
+}
+function Po(n, t) {
+  return ((n = n.x)[0] < 0 ? n[1] - Q - E : Q - n[1]) - ((t = t.x)[0] < 0 ? t[1] - Q - E : Q - t[1]);
+}
+const zi = pn(
+  function() {
+    return !0;
+  },
+  Do,
+  So,
+  [-z, -Q]
+);
+function Do(n) {
+  var t = NaN, e = NaN, i = NaN, o;
+  return {
+    lineStart: function() {
+      n.lineStart(), o = 1;
+    },
+    point: function(s, r) {
+      var a = s > 0 ? z : -z, u = k(s - t);
+      k(u - z) < E ? (n.point(t, e = (e + r) / 2 > 0 ? Q : -Q), n.point(i, e), n.lineEnd(), n.lineStart(), n.point(a, e), n.point(s, e), o = 0) : i !== a && u >= z && (k(t - i) < E && (t -= i * E), k(s - a) < E && (s -= a * E), e = wo(t, e, s, r), n.point(i, e), n.lineEnd(), n.lineStart(), n.point(a, e), o = 0), n.point(t = s, e = r), i = a;
+    },
+    lineEnd: function() {
+      n.lineEnd(), t = e = NaN;
+    },
+    clean: function() {
+      return 2 - o;
+    }
+  };
+}
+function wo(n, t, e, i) {
+  var o, s, r = C(n - e);
+  return k(r) > E ? Qi((C(t) * (s = T(i)) * C(e) - C(i) * (o = T(t)) * C(n)) / (o * s * r)) : (t + i) / 2;
+}
+function So(n, t, e, i) {
+  var o;
+  if (n == null)
+    o = e * Q, i.point(-z, o), i.point(0, o), i.point(z, o), i.point(z, 0), i.point(z, -o), i.point(0, -o), i.point(-z, -o), i.point(-z, 0), i.point(-z, o);
+  else if (k(n[0] - t[0]) > E) {
+    var s = n[0] < t[0] ? z : -z;
+    o = e * s / 2, i.point(-s, o), i.point(0, o), i.point(s, o);
+  } else
+    i.point(t[0], t[1]);
+}
+function xo(n) {
+  var t = T(n), e = 2 * L, i = t > 0, o = k(t) > E;
+  function s(l, c, f, p) {
+    yo(p, n, e, f, l, c);
+  }
+  function r(l, c) {
+    return T(l) * T(c) > t;
+  }
+  function a(l) {
+    var c, f, p, g, d;
+    return {
+      lineStart: function() {
+        g = p = !1, d = 1;
+      },
+      point: function(m, y) {
+        var P = [m, y], _, D = r(m, y), w = i ? D ? 0 : h(m, y) : D ? h(m + (m < 0 ? z : -z), y) : 0;
+        if (!c && (g = p = D) && l.lineStart(), D !== p && (_ = u(c, P), (!_ || Ut(c, _) || Ut(P, _)) && (P[2] = 1)), D !== p)
+          d = 0, D ? (l.lineStart(), _ = u(P, c), l.point(_[0], _[1])) : (_ = u(c, P), l.point(_[0], _[1], 2), l.lineEnd()), c = _;
+        else if (o && c && i ^ D) {
+          var x;
+          !(w & f) && (x = u(P, c, !0)) && (d = 0, i ? (l.lineStart(), l.point(x[0][0], x[0][1]), l.point(x[1][0], x[1][1]), l.lineEnd()) : (l.point(x[1][0], x[1][1]), l.lineEnd(), l.lineStart(), l.point(x[0][0], x[0][1], 3)));
+        }
+        D && (!c || !Ut(c, P)) && l.point(P[0], P[1]), c = P, p = D, f = w;
+      },
+      lineEnd: function() {
+        p && l.lineEnd(), c = null;
+      },
+      // Rejoin first and last segments if there were intersections and the first
+      // and last points were visible.
+      clean: function() {
+        return d | (g && p) << 1;
+      }
+    };
+  }
+  function u(l, c, f) {
+    var p = Dt(l), g = Dt(c), d = [1, 0, 0], m = Mt(p, g), y = Wt(m, m), P = m[0], _ = y - P * P;
+    if (!_) return !f && l;
+    var D = t * y / _, w = -t * P / _, x = Mt(d, m), B = Jt(d, D), M = Jt(m, w);
+    Ce(B, M);
+    var I = x, j = Wt(B, I), S = Wt(I, I), F = j * j - S * (Wt(B, B) - 1);
+    if (!(F < 0)) {
+      var A = st(F), Y = Jt(I, (-j - A) / S);
+      if (Ce(Y, B), Y = se(Y), !f) return Y;
+      var v = l[0], R = c[0], O = l[1], q = c[1], et;
+      R < v && (et = v, v = R, R = et);
+      var Nt = R - v, ht = k(Nt - z) < E, vt = ht || Nt < E;
+      if (!ht && q < O && (et = O, O = q, q = et), vt ? ht ? O + q > 0 ^ Y[1] < (k(Y[0] - v) < E ? O : q) : O <= Y[1] && Y[1] <= q : Nt > z ^ (v <= Y[0] && Y[0] <= R)) {
+        var ct = Jt(I, (-j + A) / S);
+        return Ce(ct, B), [Y, se(ct)];
+      }
+    }
+  }
+  function h(l, c) {
+    var f = i ? n : z - n, p = 0;
+    return l < -f ? p |= 1 : l > f && (p |= 2), c < -f ? p |= 4 : c > f && (p |= 8), p;
+  }
+  return pn(r, a, s, i ? [0, -n] : [-z, n - z]);
+}
+function Co(n, t, e, i, o, s) {
+  var r = n[0], a = n[1], u = t[0], h = t[1], l = 0, c = 1, f = u - r, p = h - a, g;
+  if (g = e - r, !(!f && g > 0)) {
+    if (g /= f, f < 0) {
+      if (g < l) return;
+      g < c && (c = g);
+    } else if (f > 0) {
+      if (g > c) return;
+      g > l && (l = g);
+    }
+    if (g = o - r, !(!f && g < 0)) {
+      if (g /= f, f < 0) {
+        if (g > c) return;
+        g > l && (l = g);
+      } else if (f > 0) {
+        if (g < l) return;
+        g < c && (c = g);
+      }
+      if (g = i - a, !(!p && g > 0)) {
+        if (g /= p, p < 0) {
+          if (g < l) return;
+          g < c && (c = g);
+        } else if (p > 0) {
+          if (g > c) return;
+          g > l && (l = g);
+        }
+        if (g = s - a, !(!p && g < 0)) {
+          if (g /= p, p < 0) {
+            if (g > c) return;
+            g > l && (l = g);
+          } else if (p > 0) {
+            if (g < l) return;
+            g < c && (c = g);
+          }
+          return l > 0 && (n[0] = r + l * f, n[1] = a + l * p), c < 1 && (t[0] = r + c * f, t[1] = a + c * p), !0;
+        }
+      }
+    }
+  }
+}
+var It = 1e9, Ht = -It;
+function Lo(n, t, e, i) {
+  function o(h, l) {
+    return n <= h && h <= e && t <= l && l <= i;
+  }
+  function s(h, l, c, f) {
+    var p = 0, g = 0;
+    if (h == null || (p = r(h, c)) !== (g = r(l, c)) || u(h, l) < 0 ^ c > 0)
+      do
+        f.point(p === 0 || p === 3 ? n : e, p > 1 ? i : t);
+      while ((p = (p + c + 4) % 4) !== g);
+    else
+      f.point(l[0], l[1]);
+  }
+  function r(h, l) {
+    return k(h[0] - n) < E ? l > 0 ? 0 : 3 : k(h[0] - e) < E ? l > 0 ? 2 : 1 : k(h[1] - t) < E ? l > 0 ? 1 : 0 : l > 0 ? 3 : 2;
+  }
+  function a(h, l) {
+    return u(h.x, l.x);
+  }
+  function u(h, l) {
+    var c = r(h, 1), f = r(l, 1);
+    return c !== f ? c - f : c === 0 ? l[1] - h[1] : c === 1 ? h[0] - l[0] : c === 2 ? h[1] - l[1] : l[0] - h[0];
+  }
+  return function(h) {
+    var l = h, c = cn(), f, p, g, d, m, y, P, _, D, w, x, B = {
+      point: M,
+      lineStart: F,
+      lineEnd: A,
+      polygonStart: j,
+      polygonEnd: S
+    };
+    function M(v, R) {
+      o(v, R) && l.point(v, R);
+    }
+    function I() {
+      for (var v = 0, R = 0, O = p.length; R < O; ++R)
+        for (var q = p[R], et = 1, Nt = q.length, ht = q[0], vt, ct, Ot = ht[0], St = ht[1]; et < Nt; ++et)
+          vt = Ot, ct = St, ht = q[et], Ot = ht[0], St = ht[1], ct <= i ? St > i && (Ot - vt) * (i - ct) > (St - ct) * (n - vt) && ++v : St <= i && (Ot - vt) * (i - ct) < (St - ct) * (n - vt) && --v;
+      return v;
+    }
+    function j() {
+      l = c, f = [], p = [], x = !0;
+    }
+    function S() {
+      var v = I(), R = x && v, O = (f = Ui(f)).length;
+      (R || O) && (h.polygonStart(), R && (h.lineStart(), s(null, null, 1, h), h.lineEnd()), O && fn(f, a, v, s, h), h.polygonEnd()), l = h, f = p = g = null;
+    }
+    function F() {
+      B.point = Y, p && p.push(g = []), w = !0, D = !1, P = _ = NaN;
+    }
+    function A() {
+      f && (Y(d, m), y && D && c.rejoin(), f.push(c.result())), B.point = M, D && l.lineEnd();
+    }
+    function Y(v, R) {
+      var O = o(v, R);
+      if (p && g.push([v, R]), w)
+        d = v, m = R, y = O, w = !1, O && (l.lineStart(), l.point(v, R));
+      else if (O && D) l.point(v, R);
+      else {
+        var q = [P = Math.max(Ht, Math.min(It, P)), _ = Math.max(Ht, Math.min(It, _))], et = [v = Math.max(Ht, Math.min(It, v)), R = Math.max(Ht, Math.min(It, R))];
+        Co(q, et, n, t, e, i) ? (D || (l.lineStart(), l.point(q[0], q[1])), l.point(et[0], et[1]), O || l.lineEnd(), x = !1) : O && (l.lineStart(), l.point(v, R), x = !1);
+      }
+      P = v, _ = R, D = O;
+    }
+    return B;
+  };
+}
+var Ae, Oe, Qt, Kt, Tt = {
+  sphere: $,
+  point: $,
+  lineStart: Mo,
+  lineEnd: $,
+  polygonStart: $,
+  polygonEnd: $
+};
+function Mo() {
+  Tt.point = Eo, Tt.lineEnd = To;
+}
+function To() {
+  Tt.point = Tt.lineEnd = $;
+}
+function Eo(n, t) {
+  n *= L, t *= L, Oe = n, Qt = C(t), Kt = T(t), Tt.point = No;
+}
+function No(n, t) {
+  n *= L, t *= L;
+  var e = C(t), i = T(t), o = k(n - Oe), s = T(o), r = C(o), a = i * r, u = Kt * e - Qt * i * s, h = Qt * e + Kt * i * s;
+  Ae.add(ot(st(a * a + u * u), h)), Oe = n, Qt = e, Kt = i;
+}
+function gn(n) {
+  return Ae = new b(), rt(n, Tt), +Ae;
+}
+var Fe = [null, null], Ro = { type: "LineString", coordinates: Fe };
+function Io(n, t) {
+  return Fe[0] = n, Fe[1] = t, gn(Ro);
+}
+function Bi(n, t, e) {
+  var i = xt(n, t - E, e).concat(t);
+  return function(o) {
+    return i.map(function(s) {
+      return [o, s];
+    });
+  };
+}
+function ki(n, t, e) {
+  var i = xt(n, t - E, e).concat(t);
+  return function(o) {
+    return i.map(function(s) {
+      return [s, o];
+    });
+  };
+}
+function zo() {
+  var n, t, e, i, o, s, r, a, u = 10, h = u, l = 90, c = 360, f, p, g, d, m = 2.5;
+  function y() {
+    return { type: "MultiLineString", coordinates: P() };
+  }
+  function P() {
+    return xt(bt(i / l) * l, e, l).map(g).concat(xt(bt(a / c) * c, r, c).map(d)).concat(xt(bt(t / u) * u, n, u).filter(function(_) {
+      return k(_ % l) > E;
+    }).map(f)).concat(xt(bt(s / h) * h, o, h).filter(function(_) {
+      return k(_ % c) > E;
+    }).map(p));
+  }
+  return y.lines = function() {
+    return P().map(function(_) {
+      return { type: "LineString", coordinates: _ };
+    });
+  }, y.outline = function() {
+    return {
+      type: "Polygon",
+      coordinates: [
+        g(i).concat(
+          d(r).slice(1),
+          g(e).reverse().slice(1),
+          d(a).reverse().slice(1)
+        )
+      ]
+    };
+  }, y.extent = function(_) {
+    return arguments.length ? y.extentMajor(_).extentMinor(_) : y.extentMinor();
+  }, y.extentMajor = function(_) {
+    return arguments.length ? (i = +_[0][0], e = +_[1][0], a = +_[0][1], r = +_[1][1], i > e && (_ = i, i = e, e = _), a > r && (_ = a, a = r, r = _), y.precision(m)) : [[i, a], [e, r]];
+  }, y.extentMinor = function(_) {
+    return arguments.length ? (t = +_[0][0], n = +_[1][0], s = +_[0][1], o = +_[1][1], t > n && (_ = t, t = n, n = _), s > o && (_ = s, s = o, o = _), y.precision(m)) : [[t, s], [n, o]];
+  }, y.step = function(_) {
+    return arguments.length ? y.stepMajor(_).stepMinor(_) : y.stepMinor();
+  }, y.stepMajor = function(_) {
+    return arguments.length ? (l = +_[0], c = +_[1], y) : [l, c];
+  }, y.stepMinor = function(_) {
+    return arguments.length ? (u = +_[0], h = +_[1], y) : [u, h];
+  }, y.precision = function(_) {
+    return arguments.length ? (m = +_, f = Bi(s, o, 90), p = ki(t, n, m), g = Bi(a, r, 90), d = ki(i, e, m), y) : m;
+  }, y.extentMajor([[-180, -90 + E], [180, 90 - E]]).extentMinor([[-180, -80 - E], [180, 80 + E]]);
+}
+function Bo(n, t) {
+  var e = n[0] * L, i = n[1] * L, o = t[0] * L, s = t[1] * L, r = T(i), a = C(i), u = T(s), h = C(s), l = r * T(e), c = r * C(e), f = u * T(o), p = u * C(o), g = 2 * _t(st(vi(s - i) + r * u * vi(o - e))), d = C(g), m = g ? function(y) {
+    var P = C(y *= g) / d, _ = C(g - y) / d, D = _ * l + P * f, w = _ * c + P * p, x = _ * a + P * h;
+    return [
+      ot(w, D) * Z,
+      ot(x, st(D * D + w * w)) * Z
+    ];
+  } : function() {
+    return [e * Z, i * Z];
+  };
+  return m.distance = g, m;
+}
+const be = (n) => n;
+var Me = new b(), We = new b(), dn, mn, Je, Ve, pt = {
+  point: $,
+  lineStart: $,
+  lineEnd: $,
+  polygonStart: function() {
+    pt.lineStart = ko, pt.lineEnd = Yo;
+  },
+  polygonEnd: function() {
+    pt.lineStart = pt.lineEnd = pt.point = $, Me.add(k(We)), We = new b();
+  },
+  result: function() {
+    var n = Me / 2;
+    return Me = new b(), n;
+  }
+};
+function ko() {
+  pt.point = jo;
+}
+function jo(n, t) {
+  pt.point = yn, dn = Je = n, mn = Ve = t;
+}
+function yn(n, t) {
+  We.add(Ve * n - Je * t), Je = n, Ve = t;
+}
+function Yo() {
+  yn(dn, mn);
+}
+var Et = 1 / 0, ge = Et, Xt = -Et, de = Xt, me = {
+  point: Xo,
+  lineStart: $,
+  lineEnd: $,
+  polygonStart: $,
+  polygonEnd: $,
+  result: function() {
+    var n = [[Et, ge], [Xt, de]];
+    return Xt = de = -(ge = Et = 1 / 0), n;
+  }
+};
+function Xo(n, t) {
+  n < Et && (Et = n), n > Xt && (Xt = n), t < ge && (ge = t), t > de && (de = t);
+}
+var He = 0, qe = 0, zt = 0, ye = 0, _e = 0, Ct = 0, Ue = 0, Qe = 0, Bt = 0, _n, vn, at, lt, it = {
+  point: wt,
+  lineStart: ji,
+  lineEnd: Yi,
+  polygonStart: function() {
+    it.lineStart = Zo, it.lineEnd = Ao;
+  },
+  polygonEnd: function() {
+    it.point = wt, it.lineStart = ji, it.lineEnd = Yi;
+  },
+  result: function() {
+    var n = Bt ? [Ue / Bt, Qe / Bt] : Ct ? [ye / Ct, _e / Ct] : zt ? [He / zt, qe / zt] : [NaN, NaN];
+    return He = qe = zt = ye = _e = Ct = Ue = Qe = Bt = 0, n;
+  }
+};
+function wt(n, t) {
+  He += n, qe += t, ++zt;
+}
+function ji() {
+  it.point = $o;
+}
+function $o(n, t) {
+  it.point = Go, wt(at = n, lt = t);
+}
+function Go(n, t) {
+  var e = n - at, i = t - lt, o = st(e * e + i * i);
+  ye += o * (at + n) / 2, _e += o * (lt + t) / 2, Ct += o, wt(at = n, lt = t);
+}
+function Yi() {
+  it.point = wt;
+}
+function Zo() {
+  it.point = Oo;
+}
+function Ao() {
+  Pn(_n, vn);
+}
+function Oo(n, t) {
+  it.point = Pn, wt(_n = at = n, vn = lt = t);
+}
+function Pn(n, t) {
+  var e = n - at, i = t - lt, o = st(e * e + i * i);
+  ye += o * (at + n) / 2, _e += o * (lt + t) / 2, Ct += o, o = lt * n - at * t, Ue += o * (at + n), Qe += o * (lt + t), Bt += o * 3, wt(at = n, lt = t);
+}
+function Dn(n) {
+  this._context = n;
+}
+Dn.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() {
+    this._line === 0 && 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, H);
+        break;
+      }
+    }
+  },
+  result: $
+};
+var Ke = new b(), Te, wn, Sn, kt, jt, $t = {
+  point: $,
+  lineStart: function() {
+    $t.point = Fo;
+  },
+  lineEnd: function() {
+    Te && xn(wn, Sn), $t.point = $;
+  },
+  polygonStart: function() {
+    Te = !0;
+  },
+  polygonEnd: function() {
+    Te = null;
+  },
+  result: function() {
+    var n = +Ke;
+    return Ke = new b(), n;
+  }
+};
+function Fo(n, t) {
+  $t.point = xn, wn = kt = n, Sn = jt = t;
+}
+function xn(n, t) {
+  kt -= n, jt -= t, Ke.add(st(kt * kt + jt * jt)), kt = n, jt = t;
+}
+let Xi, ve, $i, Gi;
+class Zi {
+  constructor(t) {
+    this._append = t == null ? Cn : bo(t), this._radius = 4.5, this._ = "";
+  }
+  pointRadius(t) {
+    return this._radius = +t, this;
+  }
+  polygonStart() {
+    this._line = 0;
+  }
+  polygonEnd() {
+    this._line = NaN;
+  }
+  lineStart() {
+    this._point = 0;
+  }
+  lineEnd() {
+    this._line === 0 && (this._ += "Z"), this._point = NaN;
+  }
+  point(t, e) {
+    switch (this._point) {
+      case 0: {
+        this._append`M${t},${e}`, this._point = 1;
+        break;
+      }
+      case 1: {
+        this._append`L${t},${e}`;
+        break;
+      }
+      default: {
+        if (this._append`M${t},${e}`, this._radius !== $i || this._append !== ve) {
+          const i = this._radius, o = this._;
+          this._ = "", this._append`m0,${i}a${i},${i} 0 1,1 0,${-2 * i}a${i},${i} 0 1,1 0,${2 * i}z`, $i = i, ve = this._append, Gi = this._, this._ = o;
+        }
+        this._ += Gi;
+        break;
+      }
+    }
+  }
+  result() {
+    const t = this._;
+    return this._ = "", t.length ? t : null;
+  }
+}
+function Cn(n) {
+  let t = 1;
+  this._ += n[0];
+  for (const e = n.length; t < e; ++t)
+    this._ += arguments[t] + n[t];
+}
+function bo(n) {
+  const t = Math.floor(n);
+  if (!(t >= 0)) throw new RangeError(`invalid digits: ${n}`);
+  if (t > 15) return Cn;
+  if (t !== Xi) {
+    const e = 10 ** t;
+    Xi = t, ve = function(o) {
+      let s = 1;
+      this._ += o[0];
+      for (const r = o.length; s < r; ++s)
+        this._ += Math.round(arguments[s] * e) / e + o[s];
+    };
+  }
+  return ve;
+}
+function Wo(n, t) {
+  let e = 3, i = 4.5, o, s;
+  function r(a) {
+    return a && (typeof i == "function" && s.pointRadius(+i.apply(this, arguments)), rt(a, o(s))), s.result();
+  }
+  return r.area = function(a) {
+    return rt(a, o(pt)), pt.result();
+  }, r.measure = function(a) {
+    return rt(a, o($t)), $t.result();
+  }, r.bounds = function(a) {
+    return rt(a, o(me)), me.result();
+  }, r.centroid = function(a) {
+    return rt(a, o(it)), it.result();
+  }, r.projection = function(a) {
+    return arguments.length ? (o = a == null ? (n = null, be) : (n = a).stream, r) : n;
+  }, r.context = function(a) {
+    return arguments.length ? (s = a == null ? (t = null, new Zi(e)) : new Dn(t = a), typeof i != "function" && s.pointRadius(i), r) : t;
+  }, r.pointRadius = function(a) {
+    return arguments.length ? (i = typeof a == "function" ? a : (s.pointRadius(+a), +a), r) : i;
+  }, r.digits = function(a) {
+    if (!arguments.length) return e;
+    if (a == null) e = null;
+    else {
+      const u = Math.floor(a);
+      if (!(u >= 0)) throw new RangeError(`invalid digits: ${a}`);
+      e = u;
+    }
+    return t === null && (s = new Zi(e)), r;
+  }, r.projection(n).digits(e).context(t);
+}
+function li(n) {
+  return function(t) {
+    var e = new ti();
+    for (var i in n) e[i] = n[i];
+    return e.stream = t, e;
+  };
+}
+function ti() {
+}
+ti.prototype = {
+  constructor: ti,
+  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();
+  }
+};
+function ui(n, t, e) {
+  var i = n.clipExtent && n.clipExtent();
+  return n.scale(150).translate([0, 0]), i != null && n.clipExtent(null), rt(e, n.stream(me)), t(me.result()), i != null && n.clipExtent(i), n;
+}
+function Ln(n, t, e) {
+  return ui(n, function(i) {
+    var o = t[1][0] - t[0][0], s = t[1][1] - t[0][1], r = Math.min(o / (i[1][0] - i[0][0]), s / (i[1][1] - i[0][1])), a = +t[0][0] + (o - r * (i[1][0] + i[0][0])) / 2, u = +t[0][1] + (s - r * (i[1][1] + i[0][1])) / 2;
+    n.scale(150 * r).translate([a, u]);
+  }, e);
+}
+function Jo(n, t, e) {
+  return Ln(n, [[0, 0], t], e);
+}
+function Vo(n, t, e) {
+  return ui(n, function(i) {
+    var o = +t, s = o / (i[1][0] - i[0][0]), r = (o - s * (i[1][0] + i[0][0])) / 2, a = -s * i[0][1];
+    n.scale(150 * s).translate([r, a]);
+  }, e);
+}
+function Ho(n, t, e) {
+  return ui(n, function(i) {
+    var o = +t, s = o / (i[1][1] - i[0][1]), r = -s * i[0][0], a = (o - s * (i[1][1] + i[0][1])) / 2;
+    n.scale(150 * s).translate([r, a]);
+  }, e);
+}
+var Ai = 16, qo = T(30 * L);
+function Oi(n, t) {
+  return +t ? Qo(n, t) : Uo(n);
+}
+function Uo(n) {
+  return li({
+    point: function(t, e) {
+      t = n(t, e), this.stream.point(t[0], t[1]);
+    }
+  });
+}
+function Qo(n, t) {
+  function e(i, o, s, r, a, u, h, l, c, f, p, g, d, m) {
+    var y = h - i, P = l - o, _ = y * y + P * P;
+    if (_ > 4 * t && d--) {
+      var D = r + f, w = a + p, x = u + g, B = st(D * D + w * w + x * x), M = _t(x /= B), I = k(k(x) - 1) < E || k(s - c) < E ? (s + c) / 2 : ot(w, D), j = n(I, M), S = j[0], F = j[1], A = S - i, Y = F - o, v = P * A - y * Y;
+      (v * v / _ > t || k((y * A + P * Y) / _ - 0.5) > 0.3 || r * f + a * p + u * g < qo) && (e(i, o, s, r, a, u, S, F, I, D /= B, w /= B, x, d, m), m.point(S, F), e(S, F, I, D, w, x, h, l, c, f, p, g, d, m));
+    }
+  }
+  return function(i) {
+    var o, s, r, a, u, h, l, c, f, p, g, d, m = {
+      point: y,
+      lineStart: P,
+      lineEnd: D,
+      polygonStart: function() {
+        i.polygonStart(), m.lineStart = w;
+      },
+      polygonEnd: function() {
+        i.polygonEnd(), m.lineStart = P;
+      }
+    };
+    function y(M, I) {
+      M = n(M, I), i.point(M[0], M[1]);
+    }
+    function P() {
+      c = NaN, m.point = _, i.lineStart();
+    }
+    function _(M, I) {
+      var j = Dt([M, I]), S = n(M, I);
+      e(c, f, l, p, g, d, c = S[0], f = S[1], l = M, p = j[0], g = j[1], d = j[2], Ai, i), i.point(c, f);
+    }
+    function D() {
+      m.point = y, i.lineEnd();
+    }
+    function w() {
+      P(), m.point = x, m.lineEnd = B;
+    }
+    function x(M, I) {
+      _(o = M, I), s = c, r = f, a = p, u = g, h = d, m.point = _;
+    }
+    function B() {
+      e(c, f, l, p, g, d, s, r, o, a, u, h, Ai, i), m.lineEnd = D, D();
+    }
+    return m;
+  };
+}
+var Ko = li({
+  point: function(n, t) {
+    this.stream.point(n * L, t * L);
+  }
+});
+function ts(n) {
+  return li({
+    point: function(t, e) {
+      var i = n(t, e);
+      return this.stream.point(i[0], i[1]);
+    }
+  });
+}
+function es(n, t, e, i, o) {
+  function s(r, a) {
+    return r *= i, a *= o, [t + n * r, e - n * a];
+  }
+  return s.invert = function(r, a) {
+    return [(r - t) / n * i, (e - a) / n * o];
+  }, s;
+}
+function Fi(n, t, e, i, o, s) {
+  if (!s) return es(n, t, e, i, o);
+  var r = T(s), a = C(s), u = r * n, h = a * n, l = r / n, c = a / n, f = (a * e - r * t) / n, p = (a * t + r * e) / n;
+  function g(d, m) {
+    return d *= i, m *= o, [u * d - h * m + t, e - h * d - u * m];
+  }
+  return g.invert = function(d, m) {
+    return [i * (l * d - c * m + f), o * (p - c * d - l * m)];
+  }, g;
+}
+function Mn(n) {
+  return Tn(function() {
+    return n;
+  })();
+}
+function Tn(n) {
+  var t, e = 150, i = 480, o = 250, s = 0, r = 0, a = 0, u = 0, h = 0, l, c = 0, f = 1, p = 1, g = null, d = zi, m = null, y, P, _, D = be, w = 0.5, x, B, M, I, j;
+  function S(v) {
+    return M(v[0] * L, v[1] * L);
+  }
+  function F(v) {
+    return v = M.invert(v[0], v[1]), v && [v[0] * Z, v[1] * Z];
+  }
+  S.stream = function(v) {
+    return I && j === v ? I : I = Ko(ts(l)(d(x(D(j = v)))));
+  }, S.preclip = function(v) {
+    return arguments.length ? (d = v, g = void 0, Y()) : d;
+  }, S.postclip = function(v) {
+    return arguments.length ? (D = v, m = y = P = _ = null, Y()) : D;
+  }, S.clipAngle = function(v) {
+    return arguments.length ? (d = +v ? xo(g = v * L) : (g = null, zi), Y()) : g * Z;
+  }, S.clipExtent = function(v) {
+    return arguments.length ? (D = v == null ? (m = y = P = _ = null, be) : Lo(m = +v[0][0], y = +v[0][1], P = +v[1][0], _ = +v[1][1]), Y()) : m == null ? null : [[m, y], [P, _]];
+  }, S.scale = function(v) {
+    return arguments.length ? (e = +v, A()) : e;
+  }, S.translate = function(v) {
+    return arguments.length ? (i = +v[0], o = +v[1], A()) : [i, o];
+  }, S.center = function(v) {
+    return arguments.length ? (s = v[0] % 360 * L, r = v[1] % 360 * L, A()) : [s * Z, r * Z];
+  }, S.rotate = function(v) {
+    return arguments.length ? (a = v[0] % 360 * L, u = v[1] % 360 * L, h = v.length > 2 ? v[2] % 360 * L : 0, A()) : [a * Z, u * Z, h * Z];
+  }, S.angle = function(v) {
+    return arguments.length ? (c = v % 360 * L, A()) : c * Z;
+  }, S.reflectX = function(v) {
+    return arguments.length ? (f = v ? -1 : 1, A()) : f < 0;
+  }, S.reflectY = function(v) {
+    return arguments.length ? (p = v ? -1 : 1, A()) : p < 0;
+  }, S.precision = function(v) {
+    return arguments.length ? (x = Oi(B, w = v * v), Y()) : st(w);
+  }, S.fitExtent = function(v, R) {
+    return Ln(S, v, R);
+  }, S.fitSize = function(v, R) {
+    return Jo(S, v, R);
+  }, S.fitWidth = function(v, R) {
+    return Vo(S, v, R);
+  }, S.fitHeight = function(v, R) {
+    return Ho(S, v, R);
+  };
+  function A() {
+    var v = Fi(e, 0, 0, f, p, c).apply(null, t(s, r)), R = Fi(e, i - v[0], o - v[1], f, p, c);
+    return l = hn(a, u, h), B = Ge(t, R), M = Ge(l, B), x = Oi(B, w), Y();
+  }
+  function Y() {
+    return I = j = null, S;
+  }
+  return function() {
+    return t = n.apply(this, arguments), S.invert = t.invert && F, A();
+  };
+}
+function hi(n, t) {
+  return [n, Un(Kn((Q + t) / 2))];
+}
+hi.invert = function(n, t) {
+  return [n, 2 * Qi(qn(t)) - Q];
+};
+function is() {
+  return ns(hi).scale(961 / H);
+}
+function ns(n) {
+  var t = Mn(n), e = t.center, i = t.scale, o = t.translate, s = t.clipExtent, r = null, a, u, h;
+  t.scale = function(c) {
+    return arguments.length ? (i(c), l()) : i();
+  }, t.translate = function(c) {
+    return arguments.length ? (o(c), l()) : o();
+  }, t.center = function(c) {
+    return arguments.length ? (e(c), l()) : e();
+  }, t.clipExtent = function(c) {
+    return arguments.length ? (c == null ? r = a = u = h = null : (r = +c[0][0], a = +c[0][1], u = +c[1][0], h = +c[1][1]), l()) : r == null ? null : [[r, a], [u, h]];
+  };
+  function l() {
+    var c = z * i(), f = t(mo(t.rotate()).invert([0, 0]));
+    return s(r == null ? [[f[0] - c, f[1] - c], [f[0] + c, f[1] + c]] : n === hi ? [[Math.max(f[0] - c, r), a], [Math.min(f[0] + c, u), h]] : [[r, Math.max(f[1] - c, a)], [u, Math.min(f[1] + c, h)]]);
+  }
+  return l();
+}
+class mt extends Wi {
+  constructor() {
+    super(...arguments), this._types = [], this._geometries = [], this._geoJSONparsed = !1, this._excluded = [], this._notIncluded = [];
+  }
+  _afterNew() {
+    this.fields.push("geometry", "geometryType"), this._setRawDefault("geometryField", "geometry"), this._setRawDefault("geometryTypeField", "geometryType"), this._setRawDefault("idField", "id"), this.on("geoJSON", (t) => {
+      let e = this._prevSettings.geoJSON;
+      e && e != t && this.data.clear();
+    }), super._afterNew();
+  }
+  _handleDirties() {
+    const t = this.get("geoJSON");
+    let e = this._prevSettings.geoJSON;
+    e && e != t && (this._prevSettings.geoJSON = void 0, this._geoJSONparsed = !1), this._geoJSONparsed || (this._parseGeoJSON(), this._geoJSONparsed = !0);
+  }
+  _prepareChildren() {
+    if (super._prepareChildren(), this._valuesDirty && this._handleDirties(), this.get("geoJSON") && (this.isDirty("geoJSON") || this.isDirty("include") || this.isDirty("exclude"))) {
+      this._handleDirties();
+      const t = this.chart, e = this.get("exclude");
+      e && (t && (t._centerLocation = null), N(e, (o) => {
+        const s = this.getDataItemById(o);
+        s && this._excludeDataItem(s);
+      }), N(this._excluded, (o) => {
+        const s = o.get("id");
+        s && e.indexOf(s) == -1 && this._unexcludeDataItem(o);
+      })), (!e || e.length == 0) && (N(this._excluded, (o) => {
+        this._unexcludeDataItem(o);
+      }), this._excluded = []);
+      const i = this.get("include");
+      i && (t && (t._centerLocation = null), N(this.dataItems, (o) => {
+        const s = o.get("id");
+        s && i.indexOf(s) == -1 ? this._notIncludeDataItem(o) : this._unNotIncludeDataItem(o);
+      })), i || (N(this._notIncluded, (o) => {
+        this._unNotIncludeDataItem(o);
+      }), this._notIncluded = []);
+    }
+  }
+  _excludeDataItem(t) {
+    this._removeGeometry(t.get("geometry")), fi(this._excluded, t);
+  }
+  _unexcludeDataItem(t) {
+    this._addGeometry(t.get("geometry"), this);
+  }
+  _notIncludeDataItem(t) {
+    this._removeGeometry(t.get("geometry")), fi(this._notIncluded, t);
+  }
+  _unNotIncludeDataItem(t) {
+    this._addGeometry(t.get("geometry"), this);
+  }
+  checkInclude(t, e, i) {
+    if (e) {
+      if (e.length == 0)
+        return !1;
+      if (e.indexOf(t) == -1)
+        return !1;
+    }
+    return !(i && i.length > 0 && i.indexOf(t) != -1);
+  }
+  _parseGeoJSON() {
+    const t = this.get("geoJSON");
+    if (t) {
+      let e;
+      t.type == "FeatureCollection" ? e = t.features : t.type == "Feature" ? e = [t] : ["Point", "LineString", "Polygon", "MultiPoint", "MultiLineString", "MultiPolygon"].indexOf(t.type) != -1 ? e = [{ geometry: t }] : console.log("nothing found in geoJSON");
+      const i = this.get("geodataNames");
+      if (e) {
+        const s = this.get("idField", "id");
+        for (let r = 0, a = e.length; r < a; r++) {
+          let u = e[r], h = u.geometry;
+          if (h) {
+            let l = h.type, c = u[s];
+            if (i && i[c] && (u.properties.name = i[c]), this._types.indexOf(l) != -1) {
+              let f;
+              c != null && (f = En(this.dataItems, (g) => g.get("id") == c));
+              let p;
+              f && (p = f.dataContext), f ? p.geometry || (p.geometry = h, p.geometryType = l, f.set("geometry", h), f.set("geometryType", l), this.processDataItem(f)) : (p = { geometry: h, geometryType: l, madeFromGeoData: !0 }, p[s] = c, this.data.push(p)), Nn(u.properties, p);
+            }
+          }
+        }
+      }
+      const o = "geodataprocessed";
+      this.events.isEnabled(o) && this.events.dispatch(o, { type: o, target: this });
+    }
+  }
+  _placeBulletsContainer(t) {
+    this.children.moveValue(this.bulletsContainer);
+  }
+  _removeBulletsContainer() {
+  }
+  /**
+   * @ignore
+   */
+  projection() {
+    const t = this.chart;
+    if (t)
+      return t.get("projection");
+  }
+  /**
+   * @ignore
+   */
+  geoPath() {
+    const t = this.chart;
+    if (t)
+      return t.getPrivate("geoPath");
+  }
+  _addGeometry(t, e) {
+    if (t && e.get("affectsBounds", !0)) {
+      this._geometries.push(t);
+      const i = this.chart;
+      i && i.markDirtyGeometries();
+    }
+  }
+  _removeGeometry(t) {
+    if (t) {
+      ri(this._geometries, t);
+      const e = this.chart;
+      e && e.markDirtyGeometries();
+    }
+  }
+  _dispose() {
+    super._dispose();
+    const t = this.chart;
+    t && t.series.removeValue(this);
+  }
+  _onDataClear() {
+    super._onDataClear(), this._geoJSONparsed = !1, this._markDirtyKey("exclude");
+  }
+}
+mt.className = "MapSeries";
+mt.classNames = Wi.classNames.concat([mt.className]);
+class Pe extends we {
+  constructor() {
+    super(...arguments), this._projectionDirty = !1;
+  }
+  _beforeChanged() {
+    if (super._beforeChanged(), this._projectionDirty || this.isDirty("geometry") || this.isDirty("precision")) {
+      const t = this.get("geometry");
+      if (t) {
+        const i = this.getPrivate("series");
+        if (i) {
+          const o = i.chart;
+          if (o) {
+            const s = o.get("projection");
+            let r = null;
+            s && s.clipAngle && (r = s.clipAngle(), s.precision(this.get("precision", 0.5)));
+            const a = this.dataItem, u = o.getPrivate("geoPath");
+            if (u && a)
+              if (this._clear = !0, a.get("lineType", i.get("lineType")) == "straight") {
+                const h = this.get("geometry");
+                if (h) {
+                  let l = h.coordinates;
+                  if (l) {
+                    let c;
+                    h.type == "LineString" ? c = [l] : h.type == "MultiLineString" && (c = l), this.set("draw", (f) => {
+                      for (let p = 0; p < c.length; p++) {
+                        let g = c[p];
+                        if (g.length > 0) {
+                          const d = g[0], m = o.convert({ longitude: d[0], latitude: d[1] });
+                          f.lineTo(m.x, m.y);
+                          for (let y = 0; y < g.length; y++) {
+                            const P = g[y], _ = o.convert({ longitude: P[0], latitude: P[1] });
+                            f.lineTo(_.x, _.y);
+                          }
+                        }
+                      }
+                    });
+                  }
+                }
+              } else
+                this.set("draw", (h) => {
+                  s && i.get("clipBack") === !1 && s.clipAngle(180), u.context(this._display), u(t), u.context(null), s && s.clipAngle && s.clipAngle(r);
+                });
+          }
+        }
+      }
+      const e = "linechanged";
+      this.events.isEnabled(e) && this.events.dispatch(e, { type: e, target: this });
+    }
+  }
+  /**
+   * @ignore
+   */
+  markDirtyProjection() {
+    this.markDirty(), this._projectionDirty = !0;
+  }
+  _clearDirty() {
+    super._clearDirty(), this._projectionDirty = !1;
+  }
+  _getTooltipPoint() {
+    let t = this.get("tooltipX"), e = this.get("tooltipY"), i = 0, o = 0;
+    if (gt(t) && (i = t), gt(e) && (o = e), t instanceof Rn) {
+      const s = this.positionToGeoPoint(t.value), r = this.getPrivate("series");
+      if (r) {
+        const a = r.chart;
+        if (a) {
+          const u = a.convert(s);
+          i = u.x, o = u.y;
+        }
+      }
+    }
+    return { x: i, y: o };
+  }
+  /**
+   * Converts relative position along the line (0-1) into pixel coordinates.
+   *
+   * @param position  Position (0-1)
+   * @return Coordinates
+   */
+  positionToGeoPoint(t) {
+    const e = this.get("geometry"), i = this.getPrivate("series"), o = i.chart, s = this.dataItem;
+    if (e && i && o && s) {
+      const r = s.get("lineType", i.get("lineType"));
+      let a = gn(e), u = 0, h, l = 0, c = 0, f, p, g = e.coordinates;
+      if (g) {
+        let d;
+        e.type == "LineString" ? d = [g] : e.type == "MultiLineString" && (d = g);
+        for (let m = 0; m < d.length; m++) {
+          let y = d[m];
+          if (y.length > 1) {
+            for (let P = 1; P < y.length; P++)
+              if (f = y[P - 1], p = y[P], l = u / a, h = Io(f, p), u += h, c = u / a, l <= t && c > t) {
+                m = d.length;
+                break;
+              }
+          } else y.length == 1 && (f = y[0], p = y[0], l = 0, c = 1);
+        }
+        if (f && p) {
+          let m = (t - l) / (c - l), y;
+          if (r == "straight") {
+            let P = o.convert({ longitude: f[0], latitude: f[1] }), _ = o.convert({ longitude: p[0], latitude: p[1] }), D = P.x + (_.x - P.x) * m, w = P.y + (_.y - P.y) * m;
+            return o.invert({ x: D, y: w });
+          } else
+            return y = Bo(f, p)(m), { longitude: y[0], latitude: y[1] };
+        }
+      }
+    }
+    return { longitude: 0, latitude: 0 };
+  }
+}
+Pe.className = "MapLine";
+Pe.classNames = we.classNames.concat([Pe.className]);
+class Gt extends mt {
+  constructor() {
+    super(...arguments), this.mapLines = this.addDisposer(new Ji(Vi.new({}), () => Pe._new(this._root, {}, [this.mapLines.template]))), this._types = ["LineString", "MultiLineString"];
+  }
+  _afterNew() {
+    this.fields.push("lineType"), this._setRawDefault("lineTypeField", "lineType"), super._afterNew();
+  }
+  /**
+   * @ignore
+   */
+  makeMapLine(t) {
+    const e = this.children.push(this.mapLines.make());
+    return e._setDataItem(t), this.mapLines.push(e), e;
+  }
+  /**
+   * @ignore
+   */
+  markDirtyProjection() {
+    N(this.dataItems, (t) => {
+      let e = t.get("mapLine");
+      e && e.markDirtyProjection();
+    });
+  }
+  _prepareChildren() {
+    super._prepareChildren(), this.isDirty("stroke") && this.mapLines.template.set("stroke", this.get("stroke"));
+  }
+  processDataItem(t) {
+    super.processDataItem(t);
+    let e = t.get("mapLine");
+    e || (e = this.makeMapLine(t)), this._handlePointsToConnect(t), t.on("pointsToConnect", () => {
+      this._handlePointsToConnect(t);
+    }), t.set("mapLine", e), this._addGeometry(t.get("geometry"), this), e.setPrivate("series", this);
+  }
+  _handlePointsToConnect(t) {
+    const e = t.get("pointsToConnect");
+    e && (N(e, (i) => {
+      i.on("geometry", () => {
+        this.markDirtyValues(t);
+      }), i.on("longitude", () => {
+        this.markDirtyValues(t);
+      }), i.on("latitude", () => {
+        this.markDirtyValues(t);
+      });
+    }), this.markDirtyValues(t));
+  }
+  /**
+   * Forces a repaint of the element which relies on data.
+   *
+   * @since 5.0.21
+   */
+  markDirtyValues(t) {
+    if (super.markDirtyValues(), t) {
+      const e = t.get("mapLine");
+      if (e) {
+        const i = t.get("pointsToConnect");
+        if (i) {
+          let o = [];
+          N(i, (r) => {
+            const a = r.get("longitude"), u = r.get("latitude");
+            if (a != null && u != null)
+              o.push([a, u]);
+            else {
+              const h = r.get("geometry");
+              if (h) {
+                const l = h.coordinates;
+                l && o.push([l[0], l[1]]);
+              }
+            }
+          });
+          let s = { type: "LineString", coordinates: o };
+          t.setRaw("geometry", s), e.set("geometry", s);
+        } else
+          e.set("geometry", t.get("geometry"));
+      }
+    }
+  }
+  /**
+   * @ignore
+   */
+  disposeDataItem(t) {
+    super.disposeDataItem(t);
+    const e = t.get("mapLine");
+    e && (this.mapLines.removeValue(e), e.dispose());
+  }
+  /**
+   * @ignore
+   */
+  _excludeDataItem(t) {
+    super._excludeDataItem(t);
+    const e = t.get("mapLine");
+    e && e.setPrivate("visible", !1);
+  }
+  /**
+   * @ignore
+   */
+  _unexcludeDataItem(t) {
+    super._unexcludeDataItem(t);
+    const e = t.get("mapLine");
+    e && e.setPrivate("visible", !0);
+  }
+  /**
+   * @ignore
+   */
+  _notIncludeDataItem(t) {
+    super._notIncludeDataItem(t);
+    const e = t.get("mapLine");
+    e && e.setPrivate("visible", !1);
+  }
+  /**
+   * @ignore
+   */
+  _unNotIncludeDataItem(t) {
+    super._unNotIncludeDataItem(t);
+    const e = t.get("mapLine");
+    e && e.setPrivate("visible", !0);
+  }
+}
+Gt.className = "MapLineSeries";
+Gt.classNames = mt.classNames.concat([Gt.className]);
+class ei extends Gt {
+  constructor() {
+    super(...arguments), this._dataItem = this.makeDataItem({});
+  }
+  _afterNew() {
+    super._afterNew(), this.dataItems.push(this._dataItem), this._generate();
+  }
+  _updateChildren() {
+    if (super._updateChildren(), this.isDirty("step") && this._generate(), this.isDirty("clipExtent") && this.get("clipExtent")) {
+      const t = this.chart;
+      t && t.events.on("geoboundschanged", () => {
+        this._generate();
+      }), this._generate();
+    }
+  }
+  _generate() {
+    let t = zo();
+    if (t) {
+      if (this.get("clipExtent")) {
+        const i = this.chart;
+        if (i) {
+          const o = i.geoBounds();
+          o && t.extent([[o.left, o.bottom], [o.right, o.top]]);
+        }
+      }
+      const e = this.get("step", 10);
+      t.stepMinor([360, 360]), t.stepMajor([e, e]), this._dataItem.set("geometry", t());
+    }
+  }
+}
+ei.className = "GraticuleSeries";
+ei.classNames = Gt.classNames.concat([ei.className]);
+class os extends In {
+  setupDefaultRules() {
+    super.setupDefaultRules();
+    const t = this._root.interfaceColors, e = this.rule.bind(this);
+    e("MapChart").setAll({
+      projection: is(),
+      panX: "translateX",
+      panY: "translateY",
+      pinchZoom: !0,
+      zoomStep: 2,
+      zoomLevel: 1,
+      rotationX: 0,
+      rotationY: 0,
+      rotationZ: 0,
+      maxZoomLevel: 32,
+      minZoomLevel: 1,
+      wheelY: "zoom",
+      wheelX: "none",
+      animationEasing: pi(gi),
+      wheelEasing: pi(gi),
+      wheelDuration: 0,
+      wheelSensitivity: 1,
+      maxPanOut: 0.4,
+      centerMapOnZoomOut: !0
+    });
+    {
+      const i = e("MapLine");
+      i.setAll({
+        precision: 0.5,
+        role: "figure"
+      }), Se(i, "stroke", t, "grid");
+    }
+    e("MapPolygonSeries").setAll({
+      affectsBounds: !0
+    }), e("MapPointSeries").setAll({
+      affectsBounds: !1,
+      clipFront: !1,
+      clipBack: !0,
+      autoScale: !1
+    }), e("ClusteredPointSeries").setAll({
+      minDistance: 20,
+      scatterDistance: 3,
+      scatterRadius: 8,
+      stopClusterZoom: 0.95
+    }), e("MapLineSeries").setAll({
+      affectsBounds: !1
+    });
+    {
+      const i = e("MapPolygon");
+      i.setAll({
+        precision: 0.5,
+        isMeasured: !1,
+        role: "figure",
+        fillOpacity: 1,
+        position: "absolute",
+        strokeWidth: 0.2,
+        strokeOpacity: 1
+      }), Se(i, "fill", t, "primaryButton"), Se(i, "stroke", t, "background");
+    }
+    e("Button", ["zoomtools", "home"]).setAll({
+      visible: !1
+    }), e("GraticuleSeries").setAll({
+      step: 10
+    });
+  }
+}
+function ci(n) {
+  const t = go(n);
+  return { longitude: t[0], latitude: t[1] };
+}
+function te(n) {
+  const t = lo(n);
+  if (t) {
+    const e = { left: t[0][0], right: t[1][0], top: t[1][1], bottom: t[0][1] };
+    return e.right < e.left && (e.right = 180, e.left = -180), e;
+  }
+  return { left: 0, right: 0, top: 0, bottom: 0 };
+}
+class ii extends Hi {
+  constructor() {
+    super(...arguments), this._pLat = 0, this._pLon = 0, this._movePoints = {}, this._downZoomLevel = 1, this._doubleDownDistance = 0, this._dirtyGeometries = !1, this._geometryColection = { type: "GeometryCollection", geometries: [] }, this._centerLocation = null, this._mapBounds = [[0, 0], [0, 0]], this._geoCentroid = { longitude: 0, latitude: 0 }, this._geoBounds = { left: 0, right: 0, top: 0, bottom: 0 }, this._prevGeoBounds = { left: 0, right: 0, top: 0, bottom: 0 }, this._dispatchBounds = !1, this._mapFitted = !1, this._centerX = 0, this._centerY = 0;
+  }
+  _makeGeoPath() {
+    const t = this.get("projection"), e = Wo();
+    e.projection(t), this.setPrivateRaw("geoPath", e);
+  }
+  /**
+   * Returns a geoPoint of the current zoom position.
+   *
+   * You can later use it to restore zoom position, e.g.: `chart.zoomToGeoPoint(geoPoint, zoomLevel, true)`.
+   *
+   * @since 5.2.19
+   */
+  geoPoint() {
+    return this.invert(this.seriesContainer.toGlobal({ x: this.width() / 2, y: this.height() / 2 }));
+  }
+  /**
+   * Returns coordinates to geographical center of the map.
+   */
+  geoCentroid() {
+    return this._geoCentroid;
+  }
+  /**
+   * Returns geographical bounds of the map.
+   */
+  geoBounds() {
+    return this._geoBounds;
+  }
+  _handleSetWheel() {
+    const t = this.get("wheelX"), e = this.get("wheelY"), i = this.chartContainer;
+    t != "none" || e != "none" ? (this._wheelDp && this._wheelDp.dispose(), this._wheelDp = i.events.on("wheel", (o) => {
+      const s = this.get("wheelEasing"), r = this.get("wheelSensitivity", 1), a = this.get("wheelDuration", 0), u = o.originalEvent;
+      let h = !1;
+      if (zn(u, this))
+        h = !0;
+      else
+        return;
+      const l = i._display.toLocal(o.point);
+      if (e == "zoom") {
+        if (this.get("zoomLevel") == this.get("minZoomLevel", 1) && u.deltaY > 0)
+          return;
+        this._handleWheelZoom(u.deltaY, l);
+      } else e == "rotateY" ? this._handleWheelRotateY(u.deltaY / 5 * r, a, s) : e == "rotateX" && this._handleWheelRotateX(u.deltaY / 5 * r, a, s);
+      t == "zoom" ? this._handleWheelZoom(u.deltaX, l) : t == "rotateY" ? this._handleWheelRotateY(u.deltaX / 5 * r, a, s) : t == "rotateX" && this._handleWheelRotateX(u.deltaX / 5 * r, a, s), h && u.preventDefault();
+    }), this._disposers.push(this._wheelDp)) : this._wheelDp && this._wheelDp.dispose();
+  }
+  _prepareChildren() {
+    super._prepareChildren();
+    const t = this.get("projection"), e = this.innerWidth(), i = this.innerHeight(), o = this._geometryColection.geometries;
+    if (this.isDirty("projection")) {
+      this._makeGeoPath(), this.markDirtyProjection(), this._fitMap(), t.scale(this.getPrivate("mapScale") * this.get("zoomLevel", 1)), t.rotate && t.rotate([this.get("rotationX", 0), this.get("rotationY", 0), this.get("rotationZ", 0)]);
+      let s = this._prevSettings.projection;
+      if (s && s != t) {
+        let r = e / 2, a = i / 2;
+        if (s.invert) {
+          let u = s.invert([r, a]);
+          if (u) {
+            let h = t(u);
+            if (h) {
+              let l = t.translate(), c = r - (h[0] - l[0]), f = a - (h[1] - l[1]);
+              t.translate([c, f]), this.setRaw("translateX", c), this.setRaw("translateY", f);
+            }
+          }
+        }
+      }
+    }
+    if (this.isPrivateDirty("projectionBlend") && this._projectionBlendData) {
+      const s = this._projectionBlendData, r = this.getPrivate("projectionBlend", 0);
+      s.mutate(r);
+      const a = s.sourceScale + (s.targetScale - s.sourceScale) * r, u = s.sourceTranslateX + (s.targetTranslateX - s.sourceTranslateX) * r, h = s.sourceTranslateY + (s.targetTranslateY - s.sourceTranslateY) * r;
+      s.blended.scale(a * this.get("zoomLevel", 1)), s.blended.translate([u, h]), s.blended.rotate && s.blended.rotate([
+        this.get("rotationX", 0),
+        this.get("rotationY", 0),
+        this.get("rotationZ", 0)
+      ]), this.setPrivateRaw("mapScale", a), this.setRaw("translateX", u), this.setRaw("translateY", h), this.markDirtyProjection(), r >= 1 && (this._projectionRaw = s.targetRaw, this._projectionBlendData = void 0, this._projectionBlendAnim = void 0, this.set("projection", s.target));
+    }
+    if ((this.isDirty("wheelX") || this.isDirty("wheelY")) && this._handleSetWheel(), this._dirtyGeometries && (this._geometryColection.geometries = [], this.series.each((s) => {
+      Bn(this._geometryColection.geometries, s._geometries);
+    }), this._fitMap()), o.length != 0 && (e != this._pw || i != this._ph || this._dirtyGeometries) && e > 0 && i > 0) {
+      let s = e / 2, r = i / 2;
+      t.fitSize([e, i], this._geometryColection);
+      const a = t.scale();
+      if (this.setPrivateRaw("mapScale", a), t.scale(a * this.get("zoomLevel", 1)), this._centerLocation) {
+        let h = t(this._centerLocation);
+        if (h) {
+          let l = t.translate(), c = s - (h[0] - l[0]), f = r - (h[1] - l[1]);
+          t.translate([c, f]), this.setRaw("translateX", c), this.setRaw("translateY", f), this._centerX = l[0], this._centerY = l[1];
+        }
+      }
+      this.markDirtyProjection();
+      const u = this.getPrivate("geoPath");
+      this._mapBounds = u.bounds(this._geometryColection);
+    }
+    if (this._pw = e, this._ph = i, this.isDirty("zoomControl")) {
+      const s = this._prevSettings.zoomControl, r = this.get("zoomControl");
+      r !== s && (this._disposeProperty("zoomControl"), s && s.dispose(), r && (r.setPrivate("chart", this), this.children.push(r)), this.setRaw("zoomControl", r));
+    }
+    if (this.isDirty("zoomLevel")) {
+      t.scale(this.getPrivate("mapScale") * this.get("zoomLevel", 1)), this.markDirtyProjection(), this.series.each((r) => {
+        r.isType("MapPointSeries") && r.get("autoScale") && N(r.dataItems, (a) => {
+          const u = a.bullets;
+          u && N(u, (h) => {
+            const l = h.get("sprite");
+            l && l.set("scale", this.get("zoomLevel"));
+          });
+        });
+      });
+      const s = this.get("zoomControl");
+      if (s) {
+        const r = this.get("zoomLevel", 1);
+        r == this.get("minZoomLevel", 1) ? s.minusButton.set("disabled", !0) : s.minusButton.set("disabled", !1), r == this.get("maxZoomLevel", 32) ? s.plusButton.set("disabled", !0) : s.plusButton.set("disabled", !1);
+      }
+    }
+    (this.isDirty("translateX") || this.isDirty("translateY")) && (t.translate([this.get("translateX", this.width() / 2), this.get("translateY", this.height() / 2)]), this.markDirtyProjection()), t.rotate && (this.isDirty("rotationX") || this.isDirty("rotationY") || this.isDirty("rotationZ")) && (t.rotate([this.get("rotationX", 0), this.get("rotationY", 0), this.get("rotationZ", 0)]), this.markDirtyProjection()), (this.isDirty("pinchZoom") || this.get("panX") || this.get("panY")) && this._setUpTouch();
+  }
+  _fitMap() {
+    const t = this.get("projection");
+    let e = this.innerWidth(), i = this.innerHeight();
+    if (e > 0 && i > 0) {
+      t.fitSize([e, i], this._geometryColection), this.setPrivateRaw("mapScale", t.scale());
+      const o = t.translate();
+      this.setRaw("translateX", o[0]), this.setRaw("translateY", o[1]), this._centerX = o[0], this._centerY = o[1];
+      const s = this.getPrivate("geoPath");
+      this._mapBounds = s.bounds(this._geometryColection), this._geoCentroid = ci(this._geometryColection);
+      const r = te(this._geometryColection);
+      if (this._geoBounds = r, this._geometryColection.geometries.length > 0) {
+        r.left = Ft(this._geoBounds.left, 3), r.right = Ft(this._geoBounds.right, 3), r.top = Ft(this._geoBounds.top, 3), r.bottom = Ft(this._geoBounds.bottom, 3);
+        const a = this._prevGeoBounds;
+        a && !kn(r, a) && (this._dispatchBounds = !0, this._prevGeoBounds = r);
+      }
+      this._mapFitted = !0;
+    }
+  }
+  /**
+   * Returns geographical coordinates for calculated or manual center of the
+   * map.
+   */
+  homeGeoPoint() {
+    let t = this.get("homeGeoPoint");
+    if (!t) {
+      const i = this.getPrivate("geoPath").bounds(this._geometryColection), o = i[0][0], s = i[0][1], r = i[1][0], a = i[1][1];
+      t = this.invert({ x: o + (r - o) / 2, y: s + (a - s) / 2 });
+    }
+    return t;
+  }
+  /**
+   * Repositions the map to the "home" zoom level and center coordinates.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/charts/map-chart/map-pan-zoom/#Resetting_position_level} for more info
+   * @param  duration  Animation duration in milliseconds
+   */
+  goHome(t) {
+    this.zoomToGeoPoint(this.homeGeoPoint(), this.get("homeZoomLevel", 1), !0, t, this.get("homeRotationX"), this.get("homeRotationY"));
+  }
+  _updateChildren() {
+    const t = this.get("projection");
+    if (t.invert) {
+      let e = this.innerWidth(), i = this.innerHeight();
+      e > 0 && i > 0 && (this._centerLocation = t.invert([this.innerWidth() / 2, this.innerHeight() / 2]));
+    }
+    super._updateChildren();
+  }
+  _afterChanged() {
+    if (super._afterChanged(), this._dispatchBounds) {
+      this._dispatchBounds = !1;
+      const t = "geoboundschanged";
+      this.events.isEnabled(t) && this.events.dispatch(t, { type: t, target: this });
+    }
+  }
+  _setUpTouch() {
+    this.chartContainer._display.cancelTouch || (this.chartContainer._display.cancelTouch = !!(this.get("pinchZoom") || this.get("panX") || this.get("panY")));
+  }
+  /**
+   * @ignore
+   */
+  markDirtyGeometries() {
+    this._dirtyGeometries = !0, this.markDirty();
+  }
+  /**
+   * @ignore
+   */
+  markDirtyProjection() {
+    this.series.each((t) => {
+      t.markDirtyProjection();
+    });
+  }
+  _afterNew() {
+    this._defaultThemes.push(os.new(this._root)), this._settings.themeTags = jn(this._settings.themeTags, ["map"]), this.children.push(this.bulletsContainer), super._afterNew(), this._makeGeoPath(), this.chartContainer.children.push(this.seriesContainer), this.get("translateX") == null && this.set("translateX", this.width() / 2), this.get("translateY") == null && this.set("translateY", this.height() / 2), this.chartContainer.set("interactive", !0), this.chartContainer.set("interactiveChildren", !1), this.chartContainer.set("background", Yn.new(this._root, {
+      themeTags: ["map", "background"],
+      fill: Xn.fromHex(0),
+      fillOpacity: 0
+    })), this._disposers.push(this.chartContainer.events.on("pointerdown", (e) => {
+      this._handleChartDown(e);
+    })), this._disposers.push(this.chartContainer.events.on("globalpointerup", (e) => {
+      this._handleChartUp(e);
+    })), this._disposers.push(this.chartContainer.events.on("globalpointermove", (e) => {
+      this._handleChartMove(e);
+    }));
+    let t = !1;
+    for (let e = 0; e < di.licenses.length; e++)
+      di.licenses[e].match(/^AM5M.{5,}/i) && (t = !0);
+    t ? this._root._licenseApplied() : this._root._showBranding(), this._setUpTouch();
+  }
+  _handleChartDown(t) {
+    this._downZoomLevel = this.get("zoomLevel", 1);
+    const e = this.chartContainer._downPoints;
+    let i = mi(e).length;
+    if (i == 1) {
+      let o = e[1];
+      o || (o = e[0]), o && o.x == t.point.x && o.y == t.point.y && (i = 0);
+    }
+    if (i > 0) {
+      this._downTranslateX = this.get("translateX"), this._downTranslateY = this.get("translateY"), this._downRotationX = this.get("rotationX"), this._downRotationY = this.get("rotationY"), this._downRotationZ = this.get("rotationZ");
+      const o = this.chartContainer._getDownPointId();
+      if (o) {
+        let s = this._movePoints[o];
+        s && (this.chartContainer._downPoints[o] = s);
+      }
+    } else if (i == 0) {
+      let o = this.chartContainer.get("background");
+      if (o && o.events.enableType("click"), this.get("panX") || this.get("panY")) {
+        this._za && this._za.stop(), this._txa && this._txa.stop(), this._tya && this._tya.stop(), this._rxa && this._rxa.stop(), this._rya && this._rya.stop();
+        const s = this.chartContainer._display.toLocal(t.point);
+        this._downTranslateX = this.get("translateX"), this._downTranslateY = this.get("translateY"), this._downRotationX = this.get("rotationX"), this._downRotationY = this.get("rotationY"), this._downRotationZ = this.get("rotationZ");
+        let r = this.get("projection");
+        if (r.invert) {
+          let a = r.invert([s.x, s.y]), u = r.invert([s.x + 1, s.y + 1]);
+          a && u && (this._pLon = Math.abs(u[0] - a[0]), this._pLat = Math.abs(u[1] - a[1]));
+        }
+      }
+    }
+  }
+  /**
+   * Converts screen coordinates (X and Y) within chart to latitude and
+   * longitude.
+   *
+   * @param  point  Screen coordinates
+   * @return        Geographical coordinates
+   */
+  invert(t) {
+    let e = this.get("projection");
+    if (e.invert) {
+      const i = e.invert([t.x, t.y]);
+      if (i)
+        return { longitude: i[0], latitude: i[1] };
+    }
+    return { longitude: 0, latitude: 0 };
+  }
+  /**
+   * Converts latitude/longitude to screen coordinates (X and Y).
+   *
+   * @param  point  Geographical coordinates
+   * @param  rotationX  X rotation of a map if different from current
+   * @param  rotationY  Y rotation of a map if different from current
+   *
+   * @return Screen coordinates
+   */
+  convert(t, e, i) {
+    let o = this.get("projection"), s;
+    if (o.rotate || (e = void 0, i = void 0), e != null || i != null) {
+      e == null && (e = 0), i == null && (i = 0);
+      let r = o.rotate();
+      o.rotate([e, i, 0]), s = o([t.longitude, t.latitude]), o.rotate(r);
+    } else
+      s = o([t.longitude, t.latitude]);
+    return s ? { x: s[0], y: s[1] } : { x: 0, y: 0 };
+  }
+  _handleChartUp(t) {
+    this.chartContainer._downPoints = {};
+  }
+  _handlePinch() {
+    const t = this.chartContainer;
+    let e = 0, i = [], o = [];
+    if (Ee(t._downPoints, (s, r) => {
+      i[e] = r;
+      let a = this._movePoints[s];
+      a && (o[e] = a), e++;
+    }), i.length > 1 && o.length > 1) {
+      const s = t._display;
+      let r = i[0], a = i[1], u = o[0], h = o[1];
+      if (r && a && u && h) {
+        r = s.toLocal(r), a = s.toLocal(a), u = s.toLocal(u), h = s.toLocal(h);
+        let l = Math.hypot(a.x - r.x, a.y - r.y), f = Math.hypot(h.x - u.x, h.y - u.y) / l * this._downZoomLevel;
+        f = yi(f, this.get("minZoomLevel", 1), this.get("maxZoomLevel", 32));
+        let p = { x: u.x + (h.x - u.x) / 2, y: u.y + (h.y - u.y) / 2 }, g = { x: r.x + (a.x - r.x) / 2, y: r.y + (a.y - r.y) / 2 }, d = this._downTranslateX || 0, m = this._downTranslateY || 0, y = this._downZoomLevel, P = p.x - (-d + g.x) / y * f, _ = p.y - (-m + g.y) / y * f;
+        this.set("zoomLevel", f), this.set("translateX", P), this.set("translateY", _);
+      }
+    }
+  }
+  _handleChartMove(t) {
+    const e = this.chartContainer;
+    let i = e._getDownPoint();
+    const o = e._getDownPointId(), r = t.originalEvent.pointerId;
+    if (this.get("pinchZoom") && r && (this._movePoints[r] = t.point, mi(e._downPoints).length > 1)) {
+      this._handlePinch();
+      return;
+    }
+    if (!(o && r && r != o) && i) {
+      const a = this.get("panX"), u = this.get("panY");
+      if (a != "none" || u != "none") {
+        const h = e._display;
+        let l = h.toLocal(t.point);
+        i = h.toLocal(i);
+        let c = this._downTranslateX, f = this._downTranslateY;
+        if (Math.hypot(i.x - l.x, i.y - l.y) > 5) {
+          let p = e.get("background");
+          if (p && p.events.disableType("click"), gt(c) && gt(f)) {
+            let g = this.get("projection");
+            const d = this.get("zoomLevel", 1), m = this.get("maxPanOut", 0.4), y = this._mapBounds, P = this.width(), _ = this.height(), D = y[1][0] - y[0][0], w = y[1][1] - y[0][1];
+            if (a == "translateX") {
+              c += l.x - i.x;
+              const x = P / 2 - (P / 2 - this._centerX) * d;
+              c = Math.min(c, x + D * m * d), c = Math.max(c, x - D * m * d);
+            }
+            if (u == "translateY") {
+              f += l.y - i.y;
+              const x = _ / 2 - (_ / 2 - this._centerY) * d;
+              f = Math.min(f, x + w * m * d), f = Math.max(f, x - w * m * d);
+            }
+            if (this.set("translateX", c), this.set("translateY", f), g.invert) {
+              let x = g.invert([i.x, i.y]);
+              location && x && (a == "rotateX" && this.set("rotationX", this._downRotationX - (i.x - l.x) * this._pLon), u == "rotateY" && this.set("rotationY", this._downRotationY + (i.y - l.y) * this._pLat));
+            }
+          }
+        }
+      }
+    }
+  }
+  _handleWheelRotateY(t, e, i) {
+    this._rya = this.animate({ key: "rotationY", to: this.get("rotationY", 0) - t, duration: e, easing: i });
+  }
+  _handleWheelRotateX(t, e, i) {
+    this._rxa = this.animate({ key: "rotationX", to: this.get("rotationX", 0) - t, duration: e, easing: i });
+  }
+  _handleWheelZoom(t, e) {
+    let i = this.get("zoomStep", 2), o = this.get("zoomLevel", 1), s = o;
+    t > 0 ? s = o / i : t < 0 && (s = o * i), s != o && this.zoomToPoint(e, s);
+  }
+  /**
+   * Zoom the map to geographical bounds.
+   *
+   * @param  geoBounds  Bounds
+   * @param  duration   Animation duration in milliseconds
+   * @param  rotationX  X rotation of a map at the end of zoom
+   * @param  rotationY  Y rotation of a map at the end of zoom
+   */
+  zoomToGeoBounds(t, e, i, o) {
+    t.right < t.left && (t.right = 180, t.left = -180);
+    const r = this.getPrivate("geoPath").bounds(this._geometryColection);
+    let a = this.convert({ longitude: t.left, latitude: t.top }, i, o), u = this.convert({ longitude: t.right, latitude: t.bottom }, i, o);
+    a.y < r[0][1] && (a.y = r[0][1]), u.y > r[1][1] && (u.y = r[1][1]);
+    let h = this.get("zoomLevel", 1), l = { left: a.x, right: u.x, top: a.y, bottom: u.y }, c = this.seriesContainer, f = 0.9 * Math.min(c.innerWidth() / (l.right - l.left) * h, c.innerHeight() / (l.bottom - l.top) * h), p = l.left + (l.right - l.left) / 2, g = l.top + (l.bottom - l.top) / 2, d = this.invert({ x: p, y: g });
+    return (i != null || o != null) && this.rotate(i, o), this.zoomToGeoPoint(d, f, !0, e);
+  }
+  /**
+   * Zooms the map to specific screen point.
+   *
+   * @param  point    Point
+   * @param  level    Zoom level
+   * @param  center   Center the map
+   * @param  duration Duration of the animation in milliseconds
+   */
+  zoomToPoint(t, e, i, o) {
+    e && (e = yi(e, this.get("minZoomLevel", 1), this.get("maxZoomLevel", 32))), gt(o) || (o = this.get("animationDuration", 0));
+    const s = this.get("animationEasing"), r = this.get("zoomLevel", 1);
+    this.get("centerMapOnZoomOut") && e == this.get("homeZoomLevel", 1) && (t = this.convert(this.homeGeoPoint(), this.get("homeRotationX"), this.get("homeRotationY")), i = !0);
+    let a = t.x, u = t.y, h = this.get("translateX", 0), l = this.get("translateY", 0), c = a, f = u;
+    i && (c = this.width() / 2, f = this.height() / 2);
+    let p = c - (a - h) / r * e, g = f - (u - l) / r * e;
+    return this._txa = this.animate({ key: "translateX", to: p, duration: o, easing: s }), this._tya = this.animate({ key: "translateY", to: g, duration: o, easing: s }), this._za = this.animate({ key: "zoomLevel", to: e, duration: o, easing: s }), r != e && this._root.readerAlert(this._t("Zoom level changed to %1", this._root.locale, $n(e))), this._za;
+  }
+  /**
+   * Zooms the map to specific geographical point.
+   *
+   * @param  geoPoint  Point
+   * @param  level     Zoom level
+   * @param  center    Center the map
+   * @param  duration  Duration of the animation in milliseconds
+   * @param  rotationX  X rotation of a map at the end of zoom
+   * @param  rotationY  Y rotation of a map at the end of zoom
+   *
+   */
+  zoomToGeoPoint(t, e, i, o, s, r) {
+    let a = this.convert(t, s, r);
+    if ((s != null || r != null) && this.rotate(s, r, o), a)
+      return this.zoomToPoint(a, e, i, o);
+  }
+  rotate(t, e, i) {
+    if (this.get("projection").rotate) {
+      gt(i) || (i = this.get("animationDuration", 0));
+      const s = this.get("animationEasing");
+      t != null && this.animate({ key: "rotationX", to: t, duration: i, easing: s }), e != null && this.animate({ key: "rotationY", to: e, duration: i, easing: s });
+    }
+  }
+  /**
+   * Animates the map projection transition from the current projection to
+   * the target projection over the specified duration.
+   *
+   * Since d3-geo does not expose raw projection functions on projection
+   * instances, you must pass both the target `GeoProjection` and its
+   * corresponding `GeoRawProjection`. On the first call you must also
+   * pass `sourceRaw` so the method knows the current projection's raw
+   * function. Subsequent calls reuse the previous target's raw
+   * automatically.
+   *
+   * @param target     Target projection (e.g. `geoOrthographic()`)
+   * @param targetRaw  Raw projection function (e.g. `geoOrthographicRaw`)
+   * @param duration   Duration in milliseconds (default: `animationDuration`)
+   * @param easing     Easing function (default: `animationEasing`)
+   * @param sourceRaw  Raw function of the current projection (needed on first call)
+   *
+   * @since 5.16.0
+   */
+  animateProjection(t, e, i, o, s) {
+    this._projectionBlendAnim && (this._projectionBlendAnim.stop(), this._projectionBlendAnim = void 0, this._projectionBlendData = void 0), s && (this._projectionRaw = s);
+    const r = this._projectionRaw;
+    if (!r) {
+      this.set("projection", t), this._projectionRaw = e;
+      return;
+    }
+    if (i == null && (i = this.get("animationDuration", 0)), !i) {
+      this.set("projection", t), this._projectionRaw = e;
+      return;
+    }
+    o || (o = this.get("animationEasing")), this._za && this._za.stop(), this._txa && this._txa.stop(), this._tya && this._tya.stop(), this._rxa && this._rxa.stop(), this._rya && this._rya.stop();
+    const a = this.innerWidth(), u = this.innerHeight(), h = this.getPrivate("mapScale"), l = this.get("translateX", a / 2), c = this.get("translateY", u / 2), f = Mn(e);
+    f.fitSize([a, u], this._geometryColection);
+    const p = f.scale(), g = f.translate(), d = Tn((y) => (P, _) => {
+      const D = r(P, _), w = e(P, _);
+      return [
+        (1 - y) * D[0] + y * w[0],
+        (1 - y) * D[1] + y * w[1]
+      ];
+    }), m = d(0);
+    m.scale(h * this.get("zoomLevel", 1)), m.translate([l, c]), m.precision(0.5), m.rotate && m.rotate([
+      this.get("rotationX", 0),
+      this.get("rotationY", 0),
+      this.get("rotationZ", 0)
+    ]), this.setRaw("projection", m), this._makeGeoPath(), this._projectionBlendData = {
+      blended: m,
+      mutate: d,
+      sourceScale: h,
+      targetScale: p,
+      sourceTranslateX: l,
+      sourceTranslateY: c,
+      targetTranslateX: g[0],
+      targetTranslateY: g[1],
+      target: t,
+      targetRaw: e
+    }, this._projectionBlendAnim = this.animatePrivate({
+      key: "projectionBlend",
+      from: 0,
+      to: 1,
+      duration: i,
+      easing: o
+    });
+  }
+  /**
+   * Zooms the map in.
+   */
+  zoomIn() {
+    return this.zoomToPoint({ x: this.width() / 2, y: this.height() / 2 }, this.get("zoomLevel", 1) * this.get("zoomStep", 2));
+  }
+  /**
+   * Zooms the map out.
+   */
+  zoomOut() {
+    return this.zoomToPoint({ x: this.width() / 2, y: this.height() / 2 }, this.get("zoomLevel", 1) / this.get("zoomStep", 2));
+  }
+  _clearDirty() {
+    super._clearDirty(), this._dirtyGeometries = !1, this._mapFitted = !1;
+  }
+  /**
+   * Returns area of a mapPolygon in square pixels.
+   */
+  getArea(t) {
+    const e = this.getPrivate("geoPath"), i = t.get("geometry");
+    return i ? e.area(i) : 0;
+  }
+}
+ii.className = "MapChart";
+ii.classNames = Hi.classNames.concat([ii.className]);
+class Zt extends mt {
+  constructor() {
+    super(...arguments), this._types = ["Point", "MultiPoint"];
+  }
+  _afterNew() {
+    this.fields.push("polygonId", "lineId", "longitude", "latitude", "fixed"), super._afterNew();
+  }
+  /**
+   * @ignore
+   */
+  markDirtyProjection() {
+    this.markDirty();
+  }
+  /**
+   * Forces a repaint of the element which relies on data.
+   *
+   * @since 5.0.21
+   */
+  markDirtyValues(t) {
+    super.markDirtyValues(), t && this._positionBullets(t);
+  }
+  processDataItem(t) {
+    super.processDataItem(t);
+    let e = t.get("geometry");
+    if (!e)
+      e = { type: "Point", coordinates: [t.get("longitude", 0), t.get("latitude", 0)] }, t.set("geometry", e);
+    else if (e.type == "Point") {
+      const i = e.coordinates;
+      i && (t.set("longitude", i[0]), t.set("latitude", i[1]));
+    } else if (e.type == "MultiPoint") {
+      const i = e.coordinates;
+      i && i[0] && (t.set("longitude", i[0][0]), t.set("latitude", i[0][1]));
+    }
+    this._addGeometry(e, this);
+  }
+  _makeBullets(t) {
+    t.bullets = [], this.bullets.each((e) => {
+      const i = t.get("geometry");
+      if (i) {
+        if (i.type == "Point")
+          this._setBulletParent(this._makeBullet(t, e));
+        else if (i.type = "MultiPoint") {
+          let o = 0;
+          N(i.coordinates, () => {
+            this._setBulletParent(this._makeBullet(t, e, o)), o++;
+          });
+        }
+      }
+    });
+  }
+  _setBulletParent(t) {
+    if (t) {
+      const e = t.get("sprite"), i = this.chart;
+      if (e && i) {
+        const o = e.dataItem;
+        o && (o.get("fixed") ? e.parent != i.bulletsContainer && i.bulletsContainer.children.moveValue(e) : e.parent != this.bulletsContainer && this.bulletsContainer.children.moveValue(e));
+      }
+    }
+  }
+  _positionBullet(t) {
+    const e = t.get("sprite");
+    if (e) {
+      const i = e.dataItem;
+      if (i && i.get("fixed"))
+        return;
+      const o = i.get("latitude"), s = i.get("longitude"), r = i.get("lineDataItem"), a = i.get("fixed"), u = this.chart;
+      let h;
+      if (r)
+        h = r.get("mapLine");
+      else {
+        const d = i.get("lineId");
+        d && u && u.series.each((m) => {
+          if (m.isType("MapLineSeries")) {
+            let y = m.getDataItemById(d);
+            y && (i.set("lineDataItem", y), h = y.get("mapLine"));
+          }
+        });
+      }
+      this._lineChangedDp && this._lineChangedDp.dispose(), h && (this._lineChangedDp = h.events.on("linechanged", () => {
+        this._positionBullets(i);
+      }));
+      const l = i.get("polygonDataItem");
+      let c;
+      if (l)
+        c = l.get("mapPolygon");
+      else {
+        const d = i.get("polygonId");
+        d && u && u.series.each((m) => {
+          if (m.isType("MapPolygonSeries")) {
+            let y = m.getDataItemById(d);
+            y && (i.set("polygonDataItem", y), c = y.get("mapPolygon"));
+          }
+        });
+      }
+      const f = i.get("positionOnLine");
+      let p, g;
+      if (c) {
+        let d = c.visualCentroid();
+        p = [d.longitude, d.latitude], i.setRaw("longitude", d.longitude), i.setRaw("latitude", d.latitude);
+      } else if (h && gt(f)) {
+        let d = h.positionToGeoPoint(f);
+        if (p = [d.longitude, d.latitude], i.get("autoRotate", t.get("autoRotate")) && u) {
+          const m = h.positionToGeoPoint(f - 2e-3), y = h.positionToGeoPoint(f + 2e-3), P = u.convert(m), _ = u.convert(y);
+          g = Gn(P, _);
+        }
+        i.setRaw("longitude", d.longitude), i.setRaw("latitude", d.latitude);
+      } else if (gt(s) && gt(o))
+        p = [s, o];
+      else {
+        const d = i.get("geometry");
+        if (d) {
+          if (d.type == "Point")
+            this._positionBulletReal(t, d, d.coordinates, g);
+          else if (d.type == "MultiPoint") {
+            let m = t._index || 0;
+            p = d.coordinates[m];
+          }
+        }
+      }
+      !a && p && this._positionBulletReal(t, { type: "Point", coordinates: p }, p, g);
+    }
+  }
+  _positionBulletReal(t, e, i, o) {
+    const s = t.get("sprite"), r = this.chart;
+    if (r) {
+      const a = r.get("projection"), u = r.getPrivate("geoPath"), h = s.dataItem, l = a(i);
+      if (l) {
+        const f = { x: l[0], y: l[1] };
+        s.setAll(f), h.setRaw("point", f);
+      }
+      let c = !0;
+      u(e) ? this.get("clipFront") && (c = !1) : this.get("clipBack") && (c = !1), s.setPrivate("visible", c), h.set("clipped", !c), h && o != null && h.get("autoRotate", t.get("autoRotate")) && s.set("rotation", o + h.get("autoRotateAngle", t.get("autoRotateAngle", 0)));
+    }
+  }
+  /**
+   * Centers the map to specific series' data item and zooms to the level
+   * specified in the parameters.
+   *
+   * @param  dataItem   Map point
+   * @param  zoomLevel  Zoom level
+   * @param  rotate If it's true, the map will rotate so that this point would be in the center. Mostly usefull with geoOrthographic projection.
+   */
+  zoomToDataItem(t, e, i) {
+    const o = this.chart;
+    if (o) {
+      const s = t.get("longitude", 0), r = t.get("latitude", 0);
+      return i ? o.zoomToGeoPoint({ longitude: s, latitude: r }, e, !0, void 0, -s, -r) : o.zoomToGeoPoint({ longitude: s, latitude: r }, e, !0);
+    }
+  }
+  /**
+   * Zooms the map in so that all points in the array are visible.
+   *
+   * @param   dataItems  An array of data items of points to zoom to
+   * @param   rotate     Rotate the map so it is centered on the selected items
+   * @return             Animation
+   * @since 5.5.6
+   */
+  zoomToDataItems(t, e) {
+    let i = null, o = null, s = null, r = null;
+    if (N(t, (a) => {
+      const u = a.get("longitude", 0), h = a.get("latitude", 0);
+      (i == null || i > u) && (i = u), (o == null || o < u) && (o = u), (s == null || s < h) && (s = h), (r == null || r > h) && (r = h);
+    }), i != null && o != null && s != null && r != null) {
+      const a = this.chart;
+      if (a)
+        return e ? a.zoomToGeoBounds({ left: i, right: o, top: s, bottom: r }, void 0, -(i + (o - i) / 2), -(s + (s - r) / 2)) : a.zoomToGeoBounds({ left: i, right: o, top: s, bottom: r });
+    }
+  }
+  /**
+   * @ignore
+   */
+  disposeDataItem(t) {
+    const e = this.chart;
+    e && e.series.each((i) => {
+      i.isType("MapLineSeries") && N(i.dataItems, (o) => {
+        const s = o.get("pointsToConnect");
+        s && N(s, (r) => {
+          r == t && (ri(s, r), i.markDirtyValues(o));
+        });
+      });
+    }), super.disposeDataItem(t);
+  }
+  /**
+   * @ignore
+   */
+  _excludeDataItem(t) {
+    super._excludeDataItem(t);
+    const e = t.bullets;
+    e && N(e, (i) => {
+      const o = i.get("sprite");
+      o && o.setPrivate("visible", !1);
+    });
+  }
+  /**
+   * @ignore
+   */
+  _unexcludeDataItem(t) {
+    super._unexcludeDataItem(t);
+    const e = t.bullets;
+    e && N(e, (i) => {
+      const o = i.get("sprite");
+      o && o.setPrivate("visible", !0);
+    });
+  }
+  /**
+   * @ignore
+   */
+  _notIncludeDataItem(t) {
+    super._notIncludeDataItem(t);
+    const e = t.bullets;
+    e && N(e, (i) => {
+      const o = i.get("sprite");
+      o && o.setPrivate("visible", !1);
+    });
+  }
+  /**
+   * @ignore
+   */
+  _unNotIncludeDataItem(t) {
+    super._unNotIncludeDataItem(t);
+    const e = t.bullets;
+    e && N(e, (i) => {
+      const o = i.get("sprite");
+      o && o.setPrivate("visible", !0);
+    });
+  }
+}
+Zt.className = "MapPointSeries";
+Zt.classNames = mt.classNames.concat([Zt.className]);
+var qt = { exports: {} };
+class ss {
+  constructor(t = [], e = rs) {
+    if (this.data = t, this.length = this.data.length, this.compare = e, this.length > 0)
+      for (let i = (this.length >> 1) - 1; i >= 0; i--) this._down(i);
+  }
+  push(t) {
+    this.data.push(t), this.length++, this._up(this.length - 1);
+  }
+  pop() {
+    if (this.length === 0) return;
+    const t = this.data[0], e = this.data.pop();
+    return this.length--, this.length > 0 && (this.data[0] = e, this._down(0)), t;
+  }
+  peek() {
+    return this.data[0];
+  }
+  _up(t) {
+    const { data: e, compare: i } = this, o = e[t];
+    for (; t > 0; ) {
+      const s = t - 1 >> 1, r = e[s];
+      if (i(o, r) >= 0) break;
+      e[t] = r, t = s;
+    }
+    e[t] = o;
+  }
+  _down(t) {
+    const { data: e, compare: i } = this, o = this.length >> 1, s = e[t];
+    for (; t < o; ) {
+      let r = (t << 1) + 1, a = e[r];
+      const u = r + 1;
+      if (u < this.length && i(e[u], a) < 0 && (r = u, a = e[u]), i(a, s) >= 0) break;
+      e[t] = a, t = r;
+    }
+    e[t] = s;
+  }
+}
+function rs(n, t) {
+  return n < t ? -1 : n > t ? 1 : 0;
+}
+const as = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: ss
+}, Symbol.toStringTag, { value: "Module" })), ls = /* @__PURE__ */ Wn(as);
+var bi;
+function us() {
+  if (bi) return qt.exports;
+  bi = 1;
+  var n = ls;
+  n.default && (n = n.default), qt.exports = t, qt.exports.default = t;
+  function t(a, u, h) {
+    u = u || 1;
+    for (var l, c, f, p, g = 0; g < a[0].length; g++) {
+      var d = a[0][g];
+      (!g || d[0] < l) && (l = d[0]), (!g || d[1] < c) && (c = d[1]), (!g || d[0] > f) && (f = d[0]), (!g || d[1] > p) && (p = d[1]);
+    }
+    var m = f - l, y = p - c, P = Math.min(m, y), _ = P / 2;
+    if (P === 0) {
+      var D = [l, c];
+      return D.distance = 0, D;
+    }
+    for (var w = new n(void 0, e), x = l; x < f; x += P)
+      for (var B = c; B < p; B += P)
+        w.push(new i(x + _, B + _, _, a));
+    var M = s(a), I = new i(l + m / 2, c + y / 2, 0, a);
+    I.d > M.d && (M = I);
+    for (var j = w.length; w.length; ) {
+      var S = w.pop();
+      S.d > M.d && (M = S, h && console.log("found best %d after %d probes", Math.round(1e4 * S.d) / 1e4, j)), !(S.max - M.d <= u) && (_ = S.h / 2, w.push(new i(S.x - _, S.y - _, _, a)), w.push(new i(S.x + _, S.y - _, _, a)), w.push(new i(S.x - _, S.y + _, _, a)), w.push(new i(S.x + _, S.y + _, _, a)), j += 4);
+    }
+    h && (console.log("num probes: " + j), console.log("best distance: " + M.d));
+    var F = [M.x, M.y];
+    return F.distance = M.d, F;
+  }
+  function e(a, u) {
+    return u.max - a.max;
+  }
+  function i(a, u, h, l) {
+    this.x = a, this.y = u, this.h = h, this.d = o(a, u, l), this.max = this.d + this.h * Math.SQRT2;
+  }
+  function o(a, u, h) {
+    for (var l = !1, c = 1 / 0, f = 0; f < h.length; f++)
+      for (var p = h[f], g = 0, d = p.length, m = d - 1; g < d; m = g++) {
+        var y = p[g], P = p[m];
+        y[1] > u != P[1] > u && a < (P[0] - y[0]) * (u - y[1]) / (P[1] - y[1]) + y[0] && (l = !l), c = Math.min(c, r(a, u, y, P));
+      }
+    return c === 0 ? 0 : (l ? 1 : -1) * Math.sqrt(c);
+  }
+  function s(a) {
+    for (var u = 0, h = 0, l = 0, c = a[0], f = 0, p = c.length, g = p - 1; f < p; g = f++) {
+      var d = c[f], m = c[g], y = d[0] * m[1] - m[0] * d[1];
+      h += (d[0] + m[0]) * y, l += (d[1] + m[1]) * y, u += y * 3;
+    }
+    return u === 0 ? new i(c[0][0], c[0][1], 0, a) : new i(h / u, l / u, 0, a);
+  }
+  function r(a, u, h, l) {
+    var c = h[0], f = h[1], p = l[0] - c, g = l[1] - f;
+    if (p !== 0 || g !== 0) {
+      var d = ((a - c) * p + (u - f) * g) / (p * p + g * g);
+      d > 1 ? (c = l[0], f = l[1]) : d > 0 && (c += p * d, f += g * d);
+    }
+    return p = a - c, g = u - f, p * p + g * g;
+  }
+  return qt.exports;
+}
+var hs = us();
+const cs = /* @__PURE__ */ Jn(hs);
+class De extends we {
+  constructor() {
+    super(...arguments), this._projectionDirty = !1;
+  }
+  _afterNew() {
+    super._afterNew(), this.setPrivate("trustBounds", !0);
+  }
+  _beforeChanged() {
+    if (super._beforeChanged(), this._projectionDirty || this.isDirty("geometry") || this.isDirty("precision")) {
+      const t = this.get("geometry");
+      if (t) {
+        const e = this.series;
+        if (e) {
+          const i = e.projection();
+          i && i.precision(this.get("precision", 0.5));
+          const o = e.geoPath();
+          o && (this._clear = !0, this.set("draw", (s) => {
+            o.context(this._display), o(t), o.context(null);
+          }), this.isHover() && this.showTooltip());
+        }
+      }
+    }
+  }
+  /**
+   * @ignore
+   */
+  markDirtyProjection() {
+    this.markDirty(), this._projectionDirty = !0;
+  }
+  _clearDirty() {
+    super._clearDirty(), this._projectionDirty = !1;
+  }
+  /**
+   * Returns latitude/longitude of the geometrical center of the polygon.
+   *
+   * @return Center
+   */
+  geoCentroid() {
+    const t = this.get("geometry");
+    return t ? ci(t) : { latitude: 0, longitude: 0 };
+  }
+  /**
+   * Returns latitude/longitude of the visual center of the polygon.
+   *
+   * @return Center
+   */
+  visualCentroid() {
+    let t = 0, e = [];
+    const i = this.get("geometry");
+    if (i) {
+      if (i.type == "Polygon")
+        e = i.coordinates;
+      else if (i.type == "MultiPolygon")
+        for (let o = 0; o < i.coordinates.length; o++) {
+          let s = i.coordinates[o], r = oo({ type: "Polygon", coordinates: s });
+          r > t && (e = s, t = r);
+        }
+      if (e) {
+        let o = cs(e);
+        return { longitude: o[0], latitude: o[1] };
+      }
+    }
+    return { longitude: 0, latitude: 0 };
+  }
+  _getTooltipPoint() {
+    const t = this.series;
+    if (t) {
+      const e = t.projection();
+      if (e) {
+        const i = this.visualCentroid(), o = e([i.longitude, i.latitude]);
+        if (o)
+          return { x: o[0], y: o[1] };
+      }
+    }
+    return { x: 0, y: 0 };
+  }
+}
+De.className = "MapPolygon";
+De.classNames = we.classNames.concat([De.className]);
+class ni extends mt {
+  constructor() {
+    super(...arguments), this.mapPolygons = this.addDisposer(new Ji(Vi.new({}), () => De._new(this._root, {}, [this.mapPolygons.template]))), this._types = ["Polygon", "MultiPolygon"];
+  }
+  /**
+   * @ignore
+   */
+  makeMapPolygon(t) {
+    const e = this.children.push(this.mapPolygons.make());
+    return e._setDataItem(t), this.mapPolygons.push(e), e;
+  }
+  /**
+   * @ignore
+   */
+  markDirtyProjection() {
+    N(this.dataItems, (t) => {
+      let e = t.get("mapPolygon");
+      e && e.markDirtyProjection();
+    });
+  }
+  _prepareChildren() {
+    super._prepareChildren(), this.isDirty("fill") && this.mapPolygons.template.set("fill", this.get("fill")), this.isDirty("stroke") && this.mapPolygons.template.set("stroke", this.get("stroke"));
+  }
+  processDataItem(t) {
+    super.processDataItem(t);
+    let e = t.get("mapPolygon");
+    e || (e = this.makeMapPolygon(t)), t.set("mapPolygon", e);
+    let i = t.get("geometry");
+    if (i) {
+      if (this.get("reverseGeodata") && i.coordinates)
+        for (let s = 0; s < i.coordinates.length; s++)
+          if (i.type == "MultiPolygon")
+            for (let r = 0; r < i.coordinates[s].length; r++)
+              i.coordinates[s][r].reverse();
+          else
+            i.coordinates[s].reverse();
+      e.set("geometry", i);
+    }
+    e.series = this, this._addGeometry(t.get("geometry"), this);
+  }
+  /**
+   * @ignore
+   */
+  disposeDataItem(t) {
+    super.disposeDataItem(t);
+    const e = t.get("mapPolygon");
+    e && (this.mapPolygons.removeValue(e), e.dispose()), this._removeGeometry(t.get("geometry"));
+  }
+  /**
+   * @ignore
+   */
+  _excludeDataItem(t) {
+    super._excludeDataItem(t);
+    const e = t.get("mapPolygon");
+    e && e.setPrivate("visible", !1);
+  }
+  /**
+   * @ignore
+   */
+  _unexcludeDataItem(t) {
+    super._unexcludeDataItem(t);
+    const e = t.get("mapPolygon");
+    e && e.setPrivate("visible", !0);
+  }
+  /**
+   * @ignore
+   */
+  _notIncludeDataItem(t) {
+    super._notIncludeDataItem(t);
+    const e = t.get("mapPolygon");
+    e && e.setPrivate("visible", !1);
+  }
+  /**
+   * @ignore
+   */
+  _unNotIncludeDataItem(t) {
+    super._unNotIncludeDataItem(t);
+    const e = t.get("mapPolygon");
+    e && e.setPrivate("visible", !0);
+  }
+  /**
+   * Forces a repaint of the element which relies on data.
+   *
+   * @since 5.0.21
+   */
+  markDirtyValues(t) {
+    if (super.markDirtyValues(), t) {
+      const e = t.get("mapPolygon");
+      e && e.set("geometry", t.get("geometry"));
+    }
+  }
+  /**
+   * Centers and zooms in on the specific polygon.
+   *
+   * @param  dataItem  Target data item
+   * @see {@link https://www.amcharts.com/docs/v5/charts/map-chart/map-pan-zoom/#Zooming_to_clicked_object} for more info
+   * @param  rotate If it's true, the map will rotate so that this polygon would be in the center. Mostly usefull with geoOrthographic projection.
+   */
+  zoomToDataItem(t, e) {
+    const i = t.get("mapPolygon");
+    if (i) {
+      const o = i.get("geometry"), s = this.chart;
+      if (o && s) {
+        if (e) {
+          const r = ci(o);
+          return s.rotate(-r.longitude, -r.latitude), s.zoomToGeoBounds(te(o), void 0, -r.longitude, -r.latitude);
+        }
+        return s.zoomToGeoBounds(te(o));
+      }
+    }
+  }
+  /**
+   * Zooms the map in so that all polygons in the array are visible.
+   *
+   * @param   dataItems  An array of data items to zoom to
+   * @param   rotate     Rotate the map so it is centered on the selected items
+   * @return             Animation
+   * @since 5.9.0
+   */
+  zoomToDataItems(t, e) {
+    let i, o, s, r;
+    if (N(t, (a) => {
+      const u = a.get("mapPolygon");
+      if (u) {
+        const h = u.get("geometry");
+        if (h) {
+          let l = te(h);
+          i == null && (i = l.left), o == null && (o = l.right), s == null && (s = l.top), r == null && (r = l.bottom), i = Math.min(l.left, i), o = Math.max(l.right, o), s = Math.max(l.top, s), r = Math.min(l.bottom, r);
+        }
+      }
+    }), i != null && o != null && s != null && r != null) {
+      const a = this.chart;
+      if (a) {
+        if (e) {
+          const u = i + (o - i) / 2, h = r + (s - r) / 2;
+          return a.rotate(-u, -h), a.zoomToGeoBounds({ left: i, right: o, top: s, bottom: r }, void 0, -u, -h);
+        }
+        return a.zoomToGeoBounds({ left: i, right: o, top: s, bottom: r });
+      }
+    }
+  }
+  /**
+   * Returns a [[MapPolygon]] that is under specific X/Y point.
+   *
+   * @since 5.9.8
+   * @param   point  X/Y
+   * @return         Polygon
+   */
+  getPolygonByPoint(t) {
+    let e;
+    const o = this._display._renderer.getObjectAtPoint(t);
+    if (o)
+      return this.mapPolygons.each(function(s) {
+        s._display == o && (e = s);
+      }), e;
+  }
+  getPolygonByGeoPoint(t) {
+    return this.getPolygonByPoint(this.chart.convert(t));
+  }
+}
+ni.className = "MapPolygonSeries";
+ni.classNames = mt.classNames.concat([ni.className]);
+class oi extends Zt {
+  constructor() {
+    super(...arguments), this._dataItem = this.makeDataItem({}), this._clusterIndex = 0, this._clusters = [], this.clusteredDataItems = [], this._scatterIndex = 0, this._scatters = [], this._packLayout = Vn(), this._spiral = [], this._previousZL = 0;
+  }
+  _afterNew() {
+    this.fields.push("groupId"), this._setRawDefault("groupIdField", "groupId"), super._afterNew();
+  }
+  _afterDataChange() {
+    super._afterDataChange(), this._previousZL = 0;
+  }
+  _updateChildren() {
+    super._updateChildren(), this.isDirty("scatterRadius") && (this._spiral = Zn(0, 0, 300, 300, 0, 3, 3, 0, 0));
+    const t = this.chart;
+    if (t) {
+      const e = t.get("zoomLevel", 1);
+      if (e != this._previousZL) {
+        const i = this.get("clusterDelay", 0);
+        i ? this._clusterDP ? (this._clusterDP.dispose(), this._clusterDP = this.setTimeout(() => {
+          this._doTheCluster();
+        }, i)) : (this._doTheCluster(), this._clusterDP = this.setTimeout(() => {
+        }, 0)) : this._doTheCluster(), this._previousZL = e;
+      }
+      N(this.clusteredDataItems, (i) => {
+        const o = i.get("bullet"), s = i.get("longitude", 0), r = i.get("latitude", 0);
+        this._positionBulletReal(o, { type: "Point", coordinates: [s, r] }, [s, r]);
+      });
+    }
+  }
+  _doTheCluster() {
+    const t = {};
+    N(this.dataItems, (e) => {
+      const i = e.get("groupId", "_default");
+      t[i] || (t[i] = []), t[i].push(e);
+    }), this._scatterIndex = -1, this._scatters = [], this._clusterIndex = -1, this._clusters = [], N(this.clusteredDataItems, (e) => {
+      e.setRaw("children", void 0);
+    }), N(this.dataItems, (e) => {
+      e.setRaw("cluster", void 0);
+    }), Ee(t, (e, i) => {
+      this._scatterGroup(i);
+    }), Ee(t, (e, i) => {
+      this._clusterGroup(i);
+    }), N(this.dataItems, (e) => {
+      if (!e.get("cluster")) {
+        const i = e.bullets;
+        i && N(i, (o) => {
+          const s = o.get("sprite");
+          s && s.set("forceHidden", !1);
+        });
+      }
+    });
+  }
+  /**
+   * Zooms to the area so that all clustered data items of a cluster would be
+   * visible.
+   *
+   * Pass in `true` as a second parameter to rotate that map so that the group
+   * is in the center. This is especially useful in the maps that use
+   * Orthographic (globe) projection.
+   *
+   * @param  dataItem  Group data item
+   * @param  rotate    Rotate the map so that group is in the center?
+   * @see {@link https://www.amcharts.com/docs/v5/charts/map-chart/clustered-point-series/#Drill_down} for more info
+   */
+  zoomToCluster(t, e) {
+    this.zoomToDataItems(t.get("children", []), e);
+  }
+  _clusterGroup(t) {
+    const e = this.chart;
+    if (!(e && e.get("zoomLevel", 1) >= e.get("maxZoomLevel", 100) * this.get("stopClusterZoom", 0.95))) for (t.sort((s, r) => {
+      const a = s.get("point"), u = r.get("point");
+      return a && u ? Math.hypot(a.x - u.x, a.y - u.y) : 0;
+    }); t.length > 0; ) {
+      this._clusterIndex++, this._clusters[this._clusterIndex] = [];
+      const s = this._clusters[this._clusterIndex], r = t[0];
+      s.push(r), xe(t, r), this._clusterDataItem(r, t);
+    }
+    let i = 0;
+    const o = this.get("clusteredBullet");
+    o && N(this._clusters, (s) => {
+      let r = 0, a = 0, u = s.length;
+      if (u > 1) {
+        let h = this.clusteredDataItems[i];
+        if (!h) {
+          h = new An(this, void 0, {});
+          const d = h.set("bullet", o(this._root, this, h));
+          if (d) {
+            const m = d.get("sprite");
+            m && (this.bulletsContainer.children.push(m), m._setDataItem(h), this.root.events.once("frameended", () => {
+              m instanceof _i && m.walkChildren((y) => {
+                y instanceof On && y.markDirtyValues();
+              });
+            }));
+          }
+          this.clusteredDataItems.push(h);
+        }
+        let l;
+        N(s, (d) => {
+          d.setRaw("cluster", h);
+          const m = d.get("point");
+          m && (r += m.x, a += m.y);
+          const y = d.bullets;
+          y && N(y, (P) => {
+            const _ = P.get("sprite");
+            _ && _.set("forceHidden", !0);
+          }), l = d.get("groupId");
+        });
+        let c = r / u, f = a / u;
+        h.setRaw("children", s), h.setRaw("groupId", l);
+        const p = h.get("value");
+        h.setRaw("value", u);
+        const g = h.get("bullet");
+        if (g) {
+          let d = this.chart.invert({ x: c, y: f });
+          d && h.setAll({
+            longitude: d.longitude,
+            latitude: d.latitude
+          }), this._positionBullets(h);
+          const m = g.get("sprite");
+          m && (m.set("forceHidden", !1), p != u && m instanceof _i && m.walkChildren((y) => {
+            y instanceof Fn && y.text.markDirtyText();
+          }));
+        }
+        i++;
+      }
+    }), N(this.clusteredDataItems, (s) => {
+      let r = s.get("children");
+      if (!r || r.length == 0) {
+        const a = s.get("bullet");
+        if (a) {
+          const u = a.get("sprite");
+          u && u.set("forceHidden", !0);
+        }
+      }
+    });
+  }
+  _onDataClear() {
+    super._onDataClear(), N(this.clusteredDataItems, (t) => {
+      const e = t.get("bullet");
+      if (e) {
+        const i = e.get("sprite");
+        i && i.dispose();
+      }
+    }), this.clusteredDataItems = [];
+  }
+  _clusterDataItem(t, e) {
+    const i = t.get("point");
+    if (i) {
+      let o = this.get("minDistance", 20);
+      const s = this._clusters[this._clusterIndex];
+      for (let r = e.length - 1; r >= 0; r--) {
+        const a = e[r];
+        if (a && !a.get("clipped")) {
+          const u = a.get("point");
+          u && Math.hypot(u.x - i.x, u.y - i.y) < o && (s.push(a), xe(e, a), this._clusterDataItem(a, e));
+        }
+      }
+    }
+  }
+  _scatterGroup(t) {
+    const e = this.chart;
+    if (e && e.get("zoomLevel", 1) >= e.get("maxZoomLevel", 100) * this.get("stopClusterZoom", 0.95)) {
+      for (; t.length > 0; ) {
+        this._scatterIndex++, this._scatters[this._scatterIndex] = [];
+        const i = this._scatters[this._scatterIndex], o = t[0];
+        i.push(o), ri(t, o), this._scatterDataItem(o, t);
+      }
+      N(this._scatters, (i) => {
+        if (i.length > 1) {
+          let s = [], r = 0, a = this.get("scatterRadius", 8);
+          N(i, (u) => {
+            let h = this._spiral[r], l = !0;
+            if (s.length > 0)
+              for (; l; )
+                N(s, (g) => {
+                  for (l = !1; bn({ x: h.x, y: h.y, radius: a }, g); )
+                    r++, this._spiral[r] == null ? l = !1 : (l = !0, h = this._spiral[r]);
+                });
+            const c = h.x, f = h.y;
+            s.push({ x: c, y: f, radius: a }), u.set("dx", c), u.set("dy", f);
+            const p = u.bullets;
+            p && N(p, (g) => {
+              const d = g.get("sprite");
+              d && d.setAll({ dx: c, dy: f });
+            });
+          });
+        }
+      });
+    }
+  }
+  _scatterDataItem(t, e) {
+    const i = t.get("point");
+    if (i) {
+      const o = this.get("scatterDistance", 5), s = this._scatters[this._scatterIndex];
+      N(e, (r) => {
+        if (r && !r.get("clipped")) {
+          const a = r.get("point");
+          a && Math.hypot(a.x - i.x, a.y - i.y) < o && (s.push(r), xe(e, r), this._scatterDataItem(r, e));
+        }
+      });
+    }
+  }
+}
+oi.className = "ClusteredPointSeries";
+oi.classNames = Zt.classNames.concat([oi.className]);
+class si extends qi {
+  _afterNew() {
+    super._afterNew(), this.addTag("zoomtools");
+  }
+  _prepareChildren() {
+    super._prepareChildren(), this.isPrivateDirty("chart") && this.set("target", this.getPrivate("chart"));
+  }
+}
+si.className = "ZoomControl";
+si.classNames = qi.classNames.concat([si.className]);
+export {
+  oi as ClusteredPointSeries,
+  os as DefaultTheme,
+  ei as GraticuleSeries,
+  ii as MapChart,
+  Pe as MapLine,
+  Gt as MapLineSeries,
+  Zt as MapPointSeries,
+  De as MapPolygon,
+  ni as MapPolygonSeries,
+  mt as MapSeries,
+  si as ZoomControl,
+  is as geoMercator,
+  te as getGeoBounds,
+  ci as getGeoCentroid
+};