@undp/data-viz 1.5.4 → 1.5.6

package/dist/index-9tDEUqOZ.js

@@ -0,0 +1,752 @@
+import { a as Cr, g as Er } from "./_commonjsHelpers-ByX85dGu.js";
+var Wr = 63710088e-1;
+function Xr(l, c, s = {}) {
+  const f = { type: "Feature" };
+  return (s.id === 0 || s.id) && (f.id = s.id), s.bbox && (f.bbox = s.bbox), f.properties = c || {}, f.geometry = l, f;
+}
+function hr(l, c, s = {}) {
+  if (!l)
+    throw new Error("coordinates is required");
+  if (!Array.isArray(l))
+    throw new Error("coordinates must be an Array");
+  if (l.length < 2)
+    throw new Error("coordinates must be at least 2 numbers long");
+  if (!mr(l[0]) || !mr(l[1]))
+    throw new Error("coordinates must contain numbers");
+  return Xr({
+    type: "Point",
+    coordinates: l
+  }, c, s);
+}
+function Sr(l, c, s = {}) {
+  for (const g of l) {
+    if (g.length < 4)
+      throw new Error(
+        "Each LinearRing of a Polygon must have 4 or more Positions."
+      );
+    if (g[g.length - 1].length !== g[0].length)
+      throw new Error("First and last Position are not equivalent.");
+    for (let v = 0; v < g[g.length - 1].length; v++)
+      if (g[g.length - 1][v] !== g[0][v])
+        throw new Error("First and last Position are not equivalent.");
+  }
+  return Xr({
+    type: "Polygon",
+    coordinates: l
+  }, c, s);
+}
+function mr(l) {
+  return !isNaN(l) && l !== null && !Array.isArray(l);
+}
+function or(l, c, s) {
+  if (l !== null)
+    for (var f, g, v, _, B, X, C, E = 0, F = 0, A, L = l.type, w = L === "FeatureCollection", q = L === "Feature", $ = w ? l.features.length : 1, H = 0; H < $; H++) {
+      C = w ? l.features[H].geometry : q ? l.geometry : l, A = C ? C.type === "GeometryCollection" : !1, B = A ? C.geometries.length : 1;
+      for (var e = 0; e < B; e++) {
+        var i = 0, r = 0;
+        if (_ = A ? C.geometries[e] : C, _ !== null) {
+          X = _.coordinates;
+          var t = _.type;
+          switch (E = s && (t === "Polygon" || t === "MultiPolygon") ? 1 : 0, t) {
+            case null:
+              break;
+            case "Point":
+              if (c(
+                X,
+                F,
+                H,
+                i,
+                r
+              ) === !1)
+                return !1;
+              F++, i++;
+              break;
+            case "LineString":
+            case "MultiPoint":
+              for (f = 0; f < X.length; f++) {
+                if (c(
+                  X[f],
+                  F,
+                  H,
+                  i,
+                  r
+                ) === !1)
+                  return !1;
+                F++, t === "MultiPoint" && i++;
+              }
+              t === "LineString" && i++;
+              break;
+            case "Polygon":
+            case "MultiLineString":
+              for (f = 0; f < X.length; f++) {
+                for (g = 0; g < X[f].length - E; g++) {
+                  if (c(
+                    X[f][g],
+                    F,
+                    H,
+                    i,
+                    r
+                  ) === !1)
+                    return !1;
+                  F++;
+                }
+                t === "MultiLineString" && i++, t === "Polygon" && r++;
+              }
+              t === "Polygon" && i++;
+              break;
+            case "MultiPolygon":
+              for (f = 0; f < X.length; f++) {
+                for (r = 0, g = 0; g < X[f].length; g++) {
+                  for (v = 0; v < X[f][g].length - E; v++) {
+                    if (c(
+                      X[f][g][v],
+                      F,
+                      H,
+                      i,
+                      r
+                    ) === !1)
+                      return !1;
+                    F++;
+                  }
+                  r++;
+                }
+                i++;
+              }
+              break;
+            case "GeometryCollection":
+              for (f = 0; f < _.geometries.length; f++)
+                if (or(_.geometries[f], c, s) === !1)
+                  return !1;
+              break;
+            default:
+              throw new Error("Unknown Geometry Type");
+          }
+        }
+      }
+    }
+}
+function qr(l, c) {
+  var s, f, g, v, _, B, X, C, E, F, A = 0, L = l.type === "FeatureCollection", w = l.type === "Feature", q = L ? l.features.length : 1;
+  for (s = 0; s < q; s++) {
+    for (B = L ? l.features[s].geometry : w ? l.geometry : l, C = L ? l.features[s].properties : w ? l.properties : {}, E = L ? l.features[s].bbox : w ? l.bbox : void 0, F = L ? l.features[s].id : w ? l.id : void 0, X = B ? B.type === "GeometryCollection" : !1, _ = X ? B.geometries.length : 1, g = 0; g < _; g++) {
+      if (v = X ? B.geometries[g] : B, v === null) {
+        if (c(
+          null,
+          A,
+          C,
+          E,
+          F
+        ) === !1)
+          return !1;
+        continue;
+      }
+      switch (v.type) {
+        case "Point":
+        case "LineString":
+        case "MultiPoint":
+        case "Polygon":
+        case "MultiLineString":
+        case "MultiPolygon": {
+          if (c(
+            v,
+            A,
+            C,
+            E,
+            F
+          ) === !1)
+            return !1;
+          break;
+        }
+        case "GeometryCollection": {
+          for (f = 0; f < v.geometries.length; f++)
+            if (c(
+              v.geometries[f],
+              A,
+              C,
+              E,
+              F
+            ) === !1)
+              return !1;
+          break;
+        }
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
+    }
+    A++;
+  }
+}
+function Tr(l, c, s) {
+  var f = s;
+  return qr(
+    l,
+    function(g, v, _, B, X) {
+      v === 0 && s === void 0 ? f = g : f = c(
+        f,
+        g,
+        v,
+        _,
+        B,
+        X
+      );
+    }
+  ), f;
+}
+var ir = { exports: {} }, ar = { exports: {} }, Ar = ar.exports, vr;
+function Nr() {
+  return vr || (vr = 1, function(l, c) {
+    (function(s, f) {
+      l.exports = f();
+    })(Ar, function() {
+      function s(e, i, r, t, n) {
+        (function a(o, u, h, m, d) {
+          for (; m > h; ) {
+            if (m - h > 600) {
+              var M = m - h + 1, S = u - h + 1, z = Math.log(M), Y = 0.5 * Math.exp(2 * z / 3), N = 0.5 * Math.sqrt(z * Y * (M - Y) / M) * (S - M / 2 < 0 ? -1 : 1), R = Math.max(h, Math.floor(u - S * Y / M + N)), k = Math.min(m, Math.floor(u + (M - S) * Y / M + N));
+              a(o, u, R, k, d);
+            }
+            var p = o[u], y = h, x = m;
+            for (f(o, h, u), d(o[m], p) > 0 && f(o, h, m); y < x; ) {
+              for (f(o, y, x), y++, x--; d(o[y], p) < 0; ) y++;
+              for (; d(o[x], p) > 0; ) x--;
+            }
+            d(o[h], p) === 0 ? f(o, h, x) : f(o, ++x, m), x <= u && (h = x + 1), u <= x && (m = x - 1);
+          }
+        })(e, i, r || 0, t || e.length - 1, n || g);
+      }
+      function f(e, i, r) {
+        var t = e[i];
+        e[i] = e[r], e[r] = t;
+      }
+      function g(e, i) {
+        return e < i ? -1 : e > i ? 1 : 0;
+      }
+      var v = function(e) {
+        e === void 0 && (e = 9), this._maxEntries = Math.max(4, e), this._minEntries = Math.max(2, Math.ceil(0.4 * this._maxEntries)), this.clear();
+      };
+      function _(e, i, r) {
+        if (!r) return i.indexOf(e);
+        for (var t = 0; t < i.length; t++) if (r(e, i[t])) return t;
+        return -1;
+      }
+      function B(e, i) {
+        X(e, 0, e.children.length, i, e);
+      }
+      function X(e, i, r, t, n) {
+        n || (n = $(null)), n.minX = 1 / 0, n.minY = 1 / 0, n.maxX = -1 / 0, n.maxY = -1 / 0;
+        for (var a = i; a < r; a++) {
+          var o = e.children[a];
+          C(n, e.leaf ? t(o) : o);
+        }
+        return n;
+      }
+      function C(e, i) {
+        return e.minX = Math.min(e.minX, i.minX), e.minY = Math.min(e.minY, i.minY), e.maxX = Math.max(e.maxX, i.maxX), e.maxY = Math.max(e.maxY, i.maxY), e;
+      }
+      function E(e, i) {
+        return e.minX - i.minX;
+      }
+      function F(e, i) {
+        return e.minY - i.minY;
+      }
+      function A(e) {
+        return (e.maxX - e.minX) * (e.maxY - e.minY);
+      }
+      function L(e) {
+        return e.maxX - e.minX + (e.maxY - e.minY);
+      }
+      function w(e, i) {
+        return e.minX <= i.minX && e.minY <= i.minY && i.maxX <= e.maxX && i.maxY <= e.maxY;
+      }
+      function q(e, i) {
+        return i.minX <= e.maxX && i.minY <= e.maxY && i.maxX >= e.minX && i.maxY >= e.minY;
+      }
+      function $(e) {
+        return { children: e, height: 1, leaf: !0, minX: 1 / 0, minY: 1 / 0, maxX: -1 / 0, maxY: -1 / 0 };
+      }
+      function H(e, i, r, t, n) {
+        for (var a = [i, r]; a.length; ) if (!((r = a.pop()) - (i = a.pop()) <= t)) {
+          var o = i + Math.ceil((r - i) / t / 2) * t;
+          s(e, o, i, r, n), a.push(i, o, o, r);
+        }
+      }
+      return v.prototype.all = function() {
+        return this._all(this.data, []);
+      }, v.prototype.search = function(e) {
+        var i = this.data, r = [];
+        if (!q(e, i)) return r;
+        for (var t = this.toBBox, n = []; i; ) {
+          for (var a = 0; a < i.children.length; a++) {
+            var o = i.children[a], u = i.leaf ? t(o) : o;
+            q(e, u) && (i.leaf ? r.push(o) : w(e, u) ? this._all(o, r) : n.push(o));
+          }
+          i = n.pop();
+        }
+        return r;
+      }, v.prototype.collides = function(e) {
+        var i = this.data;
+        if (!q(e, i)) return !1;
+        for (var r = []; i; ) {
+          for (var t = 0; t < i.children.length; t++) {
+            var n = i.children[t], a = i.leaf ? this.toBBox(n) : n;
+            if (q(e, a)) {
+              if (i.leaf || w(e, a)) return !0;
+              r.push(n);
+            }
+          }
+          i = r.pop();
+        }
+        return !1;
+      }, v.prototype.load = function(e) {
+        if (!e || !e.length) return this;
+        if (e.length < this._minEntries) {
+          for (var i = 0; i < e.length; i++) this.insert(e[i]);
+          return this;
+        }
+        var r = this._build(e.slice(), 0, e.length - 1, 0);
+        if (this.data.children.length) if (this.data.height === r.height) this._splitRoot(this.data, r);
+        else {
+          if (this.data.height < r.height) {
+            var t = this.data;
+            this.data = r, r = t;
+          }
+          this._insert(r, this.data.height - r.height - 1, !0);
+        }
+        else this.data = r;
+        return this;
+      }, v.prototype.insert = function(e) {
+        return e && this._insert(e, this.data.height - 1), this;
+      }, v.prototype.clear = function() {
+        return this.data = $([]), this;
+      }, v.prototype.remove = function(e, i) {
+        if (!e) return this;
+        for (var r, t, n, a = this.data, o = this.toBBox(e), u = [], h = []; a || u.length; ) {
+          if (a || (a = u.pop(), t = u[u.length - 1], r = h.pop(), n = !0), a.leaf) {
+            var m = _(e, a.children, i);
+            if (m !== -1) return a.children.splice(m, 1), u.push(a), this._condense(u), this;
+          }
+          n || a.leaf || !w(a, o) ? t ? (r++, a = t.children[r], n = !1) : a = null : (u.push(a), h.push(r), r = 0, t = a, a = a.children[0]);
+        }
+        return this;
+      }, v.prototype.toBBox = function(e) {
+        return e;
+      }, v.prototype.compareMinX = function(e, i) {
+        return e.minX - i.minX;
+      }, v.prototype.compareMinY = function(e, i) {
+        return e.minY - i.minY;
+      }, v.prototype.toJSON = function() {
+        return this.data;
+      }, v.prototype.fromJSON = function(e) {
+        return this.data = e, this;
+      }, v.prototype._all = function(e, i) {
+        for (var r = []; e; ) e.leaf ? i.push.apply(i, e.children) : r.push.apply(r, e.children), e = r.pop();
+        return i;
+      }, v.prototype._build = function(e, i, r, t) {
+        var n, a = r - i + 1, o = this._maxEntries;
+        if (a <= o) return B(n = $(e.slice(i, r + 1)), this.toBBox), n;
+        t || (t = Math.ceil(Math.log(a) / Math.log(o)), o = Math.ceil(a / Math.pow(o, t - 1))), (n = $([])).leaf = !1, n.height = t;
+        var u = Math.ceil(a / o), h = u * Math.ceil(Math.sqrt(o));
+        H(e, i, r, h, this.compareMinX);
+        for (var m = i; m <= r; m += h) {
+          var d = Math.min(m + h - 1, r);
+          H(e, m, d, u, this.compareMinY);
+          for (var M = m; M <= d; M += u) {
+            var S = Math.min(M + u - 1, d);
+            n.children.push(this._build(e, M, S, t - 1));
+          }
+        }
+        return B(n, this.toBBox), n;
+      }, v.prototype._chooseSubtree = function(e, i, r, t) {
+        for (; t.push(i), !i.leaf && t.length - 1 !== r; ) {
+          for (var n = 1 / 0, a = 1 / 0, o = void 0, u = 0; u < i.children.length; u++) {
+            var h = i.children[u], m = A(h), d = (M = e, S = h, (Math.max(S.maxX, M.maxX) - Math.min(S.minX, M.minX)) * (Math.max(S.maxY, M.maxY) - Math.min(S.minY, M.minY)) - m);
+            d < a ? (a = d, n = m < n ? m : n, o = h) : d === a && m < n && (n = m, o = h);
+          }
+          i = o || i.children[0];
+        }
+        var M, S;
+        return i;
+      }, v.prototype._insert = function(e, i, r) {
+        var t = r ? e : this.toBBox(e), n = [], a = this._chooseSubtree(t, this.data, i, n);
+        for (a.children.push(e), C(a, t); i >= 0 && n[i].children.length > this._maxEntries; ) this._split(n, i), i--;
+        this._adjustParentBBoxes(t, n, i);
+      }, v.prototype._split = function(e, i) {
+        var r = e[i], t = r.children.length, n = this._minEntries;
+        this._chooseSplitAxis(r, n, t);
+        var a = this._chooseSplitIndex(r, n, t), o = $(r.children.splice(a, r.children.length - a));
+        o.height = r.height, o.leaf = r.leaf, B(r, this.toBBox), B(o, this.toBBox), i ? e[i - 1].children.push(o) : this._splitRoot(r, o);
+      }, v.prototype._splitRoot = function(e, i) {
+        this.data = $([e, i]), this.data.height = e.height + 1, this.data.leaf = !1, B(this.data, this.toBBox);
+      }, v.prototype._chooseSplitIndex = function(e, i, r) {
+        for (var t, n, a, o, u, h, m, d = 1 / 0, M = 1 / 0, S = i; S <= r - i; S++) {
+          var z = X(e, 0, S, this.toBBox), Y = X(e, S, r, this.toBBox), N = (n = z, a = Y, o = void 0, u = void 0, h = void 0, m = void 0, o = Math.max(n.minX, a.minX), u = Math.max(n.minY, a.minY), h = Math.min(n.maxX, a.maxX), m = Math.min(n.maxY, a.maxY), Math.max(0, h - o) * Math.max(0, m - u)), R = A(z) + A(Y);
+          N < d ? (d = N, t = S, M = R < M ? R : M) : N === d && R < M && (M = R, t = S);
+        }
+        return t || r - i;
+      }, v.prototype._chooseSplitAxis = function(e, i, r) {
+        var t = e.leaf ? this.compareMinX : E, n = e.leaf ? this.compareMinY : F;
+        this._allDistMargin(e, i, r, t) < this._allDistMargin(e, i, r, n) && e.children.sort(t);
+      }, v.prototype._allDistMargin = function(e, i, r, t) {
+        e.children.sort(t);
+        for (var n = this.toBBox, a = X(e, 0, i, n), o = X(e, r - i, r, n), u = L(a) + L(o), h = i; h < r - i; h++) {
+          var m = e.children[h];
+          C(a, e.leaf ? n(m) : m), u += L(a);
+        }
+        for (var d = r - i - 1; d >= i; d--) {
+          var M = e.children[d];
+          C(o, e.leaf ? n(M) : M), u += L(o);
+        }
+        return u;
+      }, v.prototype._adjustParentBBoxes = function(e, i, r) {
+        for (var t = r; t >= 0; t--) C(i[t], e);
+      }, v.prototype._condense = function(e) {
+        for (var i = e.length - 1, r = void 0; i >= 0; i--) e[i].children.length === 0 ? i > 0 ? (r = e[i - 1].children).splice(r.indexOf(e[i]), 1) : this.clear() : B(e[i], this.toBBox);
+      }, v;
+    });
+  }(ar)), ar.exports;
+}
+class Rr {
+  constructor(c = [], s = Dr) {
+    if (this.data = c, this.length = this.data.length, this.compare = s, this.length > 0)
+      for (let f = (this.length >> 1) - 1; f >= 0; f--) this._down(f);
+  }
+  push(c) {
+    this.data.push(c), this.length++, this._up(this.length - 1);
+  }
+  pop() {
+    if (this.length === 0) return;
+    const c = this.data[0], s = this.data.pop();
+    return this.length--, this.length > 0 && (this.data[0] = s, this._down(0)), c;
+  }
+  peek() {
+    return this.data[0];
+  }
+  _up(c) {
+    const { data: s, compare: f } = this, g = s[c];
+    for (; c > 0; ) {
+      const v = c - 1 >> 1, _ = s[v];
+      if (f(g, _) >= 0) break;
+      s[c] = _, c = v;
+    }
+    s[c] = g;
+  }
+  _down(c) {
+    const { data: s, compare: f } = this, g = this.length >> 1, v = s[c];
+    for (; c < g; ) {
+      let _ = (c << 1) + 1, B = s[_];
+      const X = _ + 1;
+      if (X < this.length && f(s[X], B) < 0 && (_ = X, B = s[X]), f(B, v) >= 0) break;
+      s[c] = B, c = _;
+    }
+    s[c] = v;
+  }
+}
+function Dr(l, c) {
+  return l < c ? -1 : l > c ? 1 : 0;
+}
+const Gr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: Rr
+}, Symbol.toStringTag, { value: "Module" })), Fr = /* @__PURE__ */ Cr(Gr);
+var er = { exports: {} }, fr, pr;
+function Or() {
+  return pr || (pr = 1, fr = function(c, s, f, g) {
+    var v = c[0], _ = c[1], B = !1;
+    f === void 0 && (f = 0), g === void 0 && (g = s.length);
+    for (var X = (g - f) / 2, C = 0, E = X - 1; C < X; E = C++) {
+      var F = s[f + C * 2 + 0], A = s[f + C * 2 + 1], L = s[f + E * 2 + 0], w = s[f + E * 2 + 1], q = A > _ != w > _ && v < (L - F) * (_ - A) / (w - A) + F;
+      q && (B = !B);
+    }
+    return B;
+  }), fr;
+}
+var lr, gr;
+function kr() {
+  return gr || (gr = 1, lr = function(c, s, f, g) {
+    var v = c[0], _ = c[1], B = !1;
+    f === void 0 && (f = 0), g === void 0 && (g = s.length);
+    for (var X = g - f, C = 0, E = X - 1; C < X; E = C++) {
+      var F = s[C + f][0], A = s[C + f][1], L = s[E + f][0], w = s[E + f][1], q = A > _ != w > _ && v < (L - F) * (_ - A) / (w - A) + F;
+      q && (B = !B);
+    }
+    return B;
+  }), lr;
+}
+var dr;
+function Lr() {
+  if (dr) return er.exports;
+  dr = 1;
+  var l = Or(), c = kr();
+  return er.exports = function(f, g, v, _) {
+    return g.length > 0 && Array.isArray(g[0]) ? c(f, g, v, _) : l(f, g, v, _);
+  }, er.exports.nested = c, er.exports.flat = l, er.exports;
+}
+var nr = { exports: {} }, $r = nr.exports, yr;
+function Hr() {
+  return yr || (yr = 1, function(l, c) {
+    (function(s, f) {
+      f(c);
+    })($r, function(s) {
+      const g = 33306690738754706e-32;
+      function v(q, $, H, e, i) {
+        let r, t, n, a, o = $[0], u = e[0], h = 0, m = 0;
+        u > o == u > -o ? (r = o, o = $[++h]) : (r = u, u = e[++m]);
+        let d = 0;
+        if (h < q && m < H) for (u > o == u > -o ? (n = r - ((t = o + r) - o), o = $[++h]) : (n = r - ((t = u + r) - u), u = e[++m]), r = t, n !== 0 && (i[d++] = n); h < q && m < H; ) u > o == u > -o ? (n = r - ((t = r + o) - (a = t - r)) + (o - a), o = $[++h]) : (n = r - ((t = r + u) - (a = t - r)) + (u - a), u = e[++m]), r = t, n !== 0 && (i[d++] = n);
+        for (; h < q; ) n = r - ((t = r + o) - (a = t - r)) + (o - a), o = $[++h], r = t, n !== 0 && (i[d++] = n);
+        for (; m < H; ) n = r - ((t = r + u) - (a = t - r)) + (u - a), u = e[++m], r = t, n !== 0 && (i[d++] = n);
+        return r === 0 && d !== 0 || (i[d++] = r), d;
+      }
+      function _(q) {
+        return new Float64Array(q);
+      }
+      const B = 33306690738754716e-32, X = 22204460492503146e-32, C = 11093356479670487e-47, E = _(4), F = _(8), A = _(12), L = _(16), w = _(4);
+      s.orient2d = function(q, $, H, e, i, r) {
+        const t = ($ - r) * (H - i), n = (q - i) * (e - r), a = t - n;
+        if (t === 0 || n === 0 || t > 0 != n > 0) return a;
+        const o = Math.abs(t + n);
+        return Math.abs(a) >= B * o ? a : -function(u, h, m, d, M, S, z) {
+          let Y, N, R, k, p, y, x, J, O, D, P, G, U, Q, K, V, j, Z;
+          const W = u - M, T = m - M, I = h - S, b = d - S;
+          p = (K = (J = W - (x = (y = 134217729 * W) - (y - W))) * (D = b - (O = (y = 134217729 * b) - (y - b))) - ((Q = W * b) - x * O - J * O - x * D)) - (P = K - (j = (J = I - (x = (y = 134217729 * I) - (y - I))) * (D = T - (O = (y = 134217729 * T) - (y - T))) - ((V = I * T) - x * O - J * O - x * D))), E[0] = K - (P + p) + (p - j), p = (U = Q - ((G = Q + P) - (p = G - Q)) + (P - p)) - (P = U - V), E[1] = U - (P + p) + (p - V), p = (Z = G + P) - G, E[2] = G - (Z - p) + (P - p), E[3] = Z;
+          let rr = function(Pr, sr) {
+            let cr = sr[0];
+            for (let ur = 1; ur < Pr; ur++) cr += sr[ur];
+            return cr;
+          }(4, E), tr = X * z;
+          if (rr >= tr || -rr >= tr || (Y = u - (W + (p = u - W)) + (p - M), R = m - (T + (p = m - T)) + (p - M), N = h - (I + (p = h - I)) + (p - S), k = d - (b + (p = d - b)) + (p - S), Y === 0 && N === 0 && R === 0 && k === 0) || (tr = C * z + g * Math.abs(rr), (rr += W * k + b * Y - (I * R + T * N)) >= tr || -rr >= tr)) return rr;
+          p = (K = (J = Y - (x = (y = 134217729 * Y) - (y - Y))) * (D = b - (O = (y = 134217729 * b) - (y - b))) - ((Q = Y * b) - x * O - J * O - x * D)) - (P = K - (j = (J = N - (x = (y = 134217729 * N) - (y - N))) * (D = T - (O = (y = 134217729 * T) - (y - T))) - ((V = N * T) - x * O - J * O - x * D))), w[0] = K - (P + p) + (p - j), p = (U = Q - ((G = Q + P) - (p = G - Q)) + (P - p)) - (P = U - V), w[1] = U - (P + p) + (p - V), p = (Z = G + P) - G, w[2] = G - (Z - p) + (P - p), w[3] = Z;
+          const Yr = v(4, E, 4, w, F);
+          p = (K = (J = W - (x = (y = 134217729 * W) - (y - W))) * (D = k - (O = (y = 134217729 * k) - (y - k))) - ((Q = W * k) - x * O - J * O - x * D)) - (P = K - (j = (J = I - (x = (y = 134217729 * I) - (y - I))) * (D = R - (O = (y = 134217729 * R) - (y - R))) - ((V = I * R) - x * O - J * O - x * D))), w[0] = K - (P + p) + (p - j), p = (U = Q - ((G = Q + P) - (p = G - Q)) + (P - p)) - (P = U - V), w[1] = U - (P + p) + (p - V), p = (Z = G + P) - G, w[2] = G - (Z - p) + (P - p), w[3] = Z;
+          const wr = v(Yr, F, 4, w, A);
+          p = (K = (J = Y - (x = (y = 134217729 * Y) - (y - Y))) * (D = k - (O = (y = 134217729 * k) - (y - k))) - ((Q = Y * k) - x * O - J * O - x * D)) - (P = K - (j = (J = N - (x = (y = 134217729 * N) - (y - N))) * (D = R - (O = (y = 134217729 * R) - (y - R))) - ((V = N * R) - x * O - J * O - x * D))), w[0] = K - (P + p) + (p - j), p = (U = Q - ((G = Q + P) - (p = G - Q)) + (P - p)) - (P = U - V), w[1] = U - (P + p) + (p - V), p = (Z = G + P) - G, w[2] = G - (Z - p) + (P - p), w[3] = Z;
+          const Br = v(wr, A, 4, w, L);
+          return L[Br - 1];
+        }(q, $, H, e, i, r, o);
+      }, s.orient2dfast = function(q, $, H, e, i, r) {
+        return ($ - r) * (H - i) - (q - i) * (e - r);
+      }, Object.defineProperty(s, "__esModule", { value: !0 });
+    });
+  }(nr, nr.exports)), nr.exports;
+}
+var xr;
+function Jr() {
+  if (xr) return ir.exports;
+  xr = 1;
+  var l = Nr(), c = Fr, s = Lr(), f = Hr().orient2d;
+  c.default && (c = c.default), ir.exports = g, ir.exports.default = g;
+  function g(r, t, n) {
+    t = Math.max(0, t === void 0 ? 2 : t), n = n || 0;
+    var a = L(r), o = new l(16);
+    o.toBBox = function(x) {
+      return {
+        minX: x[0],
+        minY: x[1],
+        maxX: x[0],
+        maxY: x[1]
+      };
+    }, o.compareMinX = function(x, J) {
+      return x[0] - J[0];
+    }, o.compareMinY = function(x, J) {
+      return x[1] - J[1];
+    }, o.load(r);
+    for (var u = [], h = 0, m; h < a.length; h++) {
+      var d = a[h];
+      o.remove(d), m = w(d, m), u.push(m);
+    }
+    var M = new l(16);
+    for (h = 0; h < u.length; h++) M.insert(A(u[h]));
+    for (var S = t * t, z = n * n; u.length; ) {
+      var Y = u.shift(), N = Y.p, R = Y.next.p, k = q(N, R);
+      if (!(k < z)) {
+        var p = k / S;
+        d = v(o, Y.prev.p, N, R, Y.next.next.p, p, M), d && Math.min(q(d, N), q(d, R)) <= p && (u.push(Y), u.push(w(d, Y)), o.remove(d), M.remove(Y), M.insert(A(Y)), M.insert(A(Y.next)));
+      }
+    }
+    Y = m;
+    var y = [];
+    do
+      y.push(Y.p), Y = Y.next;
+    while (Y !== m);
+    return y.push(Y.p), y;
+  }
+  function v(r, t, n, a, o, u, h) {
+    for (var m = new c([], _), d = r.data; d; ) {
+      for (var M = 0; M < d.children.length; M++) {
+        var S = d.children[M], z = d.leaf ? $(S, n, a) : B(n, a, S);
+        z > u || m.push({
+          node: S,
+          dist: z
+        });
+      }
+      for (; m.length && !m.peek().node.children; ) {
+        var Y = m.pop(), N = Y.node, R = $(N, t, n), k = $(N, a, o);
+        if (Y.dist < R && Y.dist < k && C(n, N, h) && C(a, N, h)) return N;
+      }
+      d = m.pop(), d && (d = d.node);
+    }
+    return null;
+  }
+  function _(r, t) {
+    return r.dist - t.dist;
+  }
+  function B(r, t, n) {
+    if (X(r, n) || X(t, n)) return 0;
+    var a = H(r[0], r[1], t[0], t[1], n.minX, n.minY, n.maxX, n.minY);
+    if (a === 0) return 0;
+    var o = H(r[0], r[1], t[0], t[1], n.minX, n.minY, n.minX, n.maxY);
+    if (o === 0) return 0;
+    var u = H(r[0], r[1], t[0], t[1], n.maxX, n.minY, n.maxX, n.maxY);
+    if (u === 0) return 0;
+    var h = H(r[0], r[1], t[0], t[1], n.minX, n.maxY, n.maxX, n.maxY);
+    return h === 0 ? 0 : Math.min(a, o, u, h);
+  }
+  function X(r, t) {
+    return r[0] >= t.minX && r[0] <= t.maxX && r[1] >= t.minY && r[1] <= t.maxY;
+  }
+  function C(r, t, n) {
+    for (var a = Math.min(r[0], t[0]), o = Math.min(r[1], t[1]), u = Math.max(r[0], t[0]), h = Math.max(r[1], t[1]), m = n.search({ minX: a, minY: o, maxX: u, maxY: h }), d = 0; d < m.length; d++)
+      if (F(m[d].p, m[d].next.p, r, t)) return !1;
+    return !0;
+  }
+  function E(r, t, n) {
+    return f(r[0], r[1], t[0], t[1], n[0], n[1]);
+  }
+  function F(r, t, n, a) {
+    return r !== a && t !== n && E(r, t, n) > 0 != E(r, t, a) > 0 && E(n, a, r) > 0 != E(n, a, t) > 0;
+  }
+  function A(r) {
+    var t = r.p, n = r.next.p;
+    return r.minX = Math.min(t[0], n[0]), r.minY = Math.min(t[1], n[1]), r.maxX = Math.max(t[0], n[0]), r.maxY = Math.max(t[1], n[1]), r;
+  }
+  function L(r) {
+    for (var t = r[0], n = r[0], a = r[0], o = r[0], u = 0; u < r.length; u++) {
+      var h = r[u];
+      h[0] < t[0] && (t = h), h[0] > a[0] && (a = h), h[1] < n[1] && (n = h), h[1] > o[1] && (o = h);
+    }
+    var m = [t, n, a, o], d = m.slice();
+    for (u = 0; u < r.length; u++)
+      s(r[u], m) || d.push(r[u]);
+    return i(d);
+  }
+  function w(r, t) {
+    var n = {
+      p: r,
+      prev: null,
+      next: null,
+      minX: 0,
+      minY: 0,
+      maxX: 0,
+      maxY: 0
+    };
+    return t ? (n.next = t.next, n.prev = t, t.next.prev = n, t.next = n) : (n.prev = n, n.next = n), n;
+  }
+  function q(r, t) {
+    var n = r[0] - t[0], a = r[1] - t[1];
+    return n * n + a * a;
+  }
+  function $(r, t, n) {
+    var a = t[0], o = t[1], u = n[0] - a, h = n[1] - o;
+    if (u !== 0 || h !== 0) {
+      var m = ((r[0] - a) * u + (r[1] - o) * h) / (u * u + h * h);
+      m > 1 ? (a = n[0], o = n[1]) : m > 0 && (a += u * m, o += h * m);
+    }
+    return u = r[0] - a, h = r[1] - o, u * u + h * h;
+  }
+  function H(r, t, n, a, o, u, h, m) {
+    var d = n - r, M = a - t, S = h - o, z = m - u, Y = r - o, N = t - u, R = d * d + M * M, k = d * S + M * z, p = S * S + z * z, y = d * Y + M * N, x = S * Y + z * N, J = R * p - k * k, O, D, P, G, U = J, Q = J;
+    J === 0 ? (D = 0, U = 1, G = x, Q = p) : (D = k * x - p * y, G = R * x - k * y, D < 0 ? (D = 0, G = x, Q = p) : D > U && (D = U, G = x + k, Q = p)), G < 0 ? (G = 0, -y < 0 ? D = 0 : -y > R ? D = U : (D = -y, U = R)) : G > Q && (G = Q, -y + k < 0 ? D = 0 : -y + k > R ? D = U : (D = -y + k, U = R)), O = D === 0 ? 0 : D / U, P = G === 0 ? 0 : G / Q;
+    var K = (1 - O) * r + O * n, V = (1 - O) * t + O * a, j = (1 - P) * o + P * h, Z = (1 - P) * u + P * m, W = j - K, T = Z - V;
+    return W * W + T * T;
+  }
+  function e(r, t) {
+    return r[0] === t[0] ? r[1] - t[1] : r[0] - t[0];
+  }
+  function i(r) {
+    r.sort(e);
+    for (var t = [], n = 0; n < r.length; n++) {
+      for (; t.length >= 2 && E(t[t.length - 2], t[t.length - 1], r[n]) <= 0; )
+        t.pop();
+      t.push(r[n]);
+    }
+    for (var a = [], o = r.length - 1; o >= 0; o--) {
+      for (; a.length >= 2 && E(a[a.length - 2], a[a.length - 1], r[o]) <= 0; )
+        a.pop();
+      a.push(r[o]);
+    }
+    return a.pop(), t.pop(), t.concat(a);
+  }
+  return ir.exports;
+}
+var Qr = Jr();
+const Ur = /* @__PURE__ */ Er(Qr);
+function zr(l, c = {}) {
+  c.concavity = c.concavity || 1 / 0;
+  const s = [];
+  if (or(l, (g) => {
+    s.push([g[0], g[1]]);
+  }), !s.length)
+    return null;
+  const f = Ur(s, c.concavity);
+  return f.length > 3 ? Sr([f]) : null;
+}
+function Mr(l, c = {}) {
+  let s = 0, f = 0, g = 0;
+  return or(
+    l,
+    function(v) {
+      s += v[0], f += v[1], g++;
+    },
+    !0
+  ), hr([s / g, f / g], c.properties);
+}
+function Kr(l) {
+  if (!l)
+    throw new Error("coord is required");
+  if (!Array.isArray(l)) {
+    if (l.type === "Feature" && l.geometry !== null && l.geometry.type === "Point")
+      return [...l.geometry.coordinates];
+    if (l.type === "Point")
+      return [...l.coordinates];
+  }
+  if (Array.isArray(l) && l.length >= 2 && !Array.isArray(l[0]) && !Array.isArray(l[1]))
+    return [...l];
+  throw new Error("coord must be GeoJSON Point or an Array of numbers");
+}
+function Vr(l, c) {
+  return l.type === "FeatureCollection" ? "FeatureCollection" : l.type === "GeometryCollection" ? "GeometryCollection" : l.type === "Feature" && l.geometry !== null ? l.geometry.type : l.type;
+}
+function _r(l, c = {}) {
+  switch (Vr(l)) {
+    case "Point":
+      return hr(Kr(l), c.properties);
+    case "Polygon":
+      var s = [];
+      or(l, function(r) {
+        s.push(r);
+      });
+      var f = Mr(l, { properties: c.properties }), g = f.geometry.coordinates, v = 0, _ = 0, B = 0, X, C, E, F, A, L, w, q, $ = s.map(function(r) {
+        return [r[0] - g[0], r[1] - g[1]];
+      });
+      for (X = 0; X < s.length - 1; X++)
+        C = $[X], F = C[0], L = C[1], E = $[X + 1], A = E[0], w = E[1], q = F * w - A * L, B += q, v += (F + A) * q, _ += (L + w) * q;
+      if (B === 0)
+        return f;
+      var H = B * 0.5, e = 1 / (6 * H);
+      return hr(
+        [g[0] + e * v, g[1] + e * _],
+        c.properties
+      );
+    default:
+      var i = zr(l);
+      return i ? _r(i, { properties: c.properties }) : Mr(l, { properties: c.properties });
+  }
+}
+var Ir = _r;
+export {
+  or as c,
+  Wr as e,
+  Tr as g,
+  Ir as t
+};
+//# sourceMappingURL=index-9tDEUqOZ.js.map