@local-logic/maps 0.0.9 → 0.0.10

package/dist/index-DgHrPgsK.js

@@ -0,0 +1,772 @@
+import { jsx as T } from "react/jsx-runtime";
+import * as B from "react";
+import ot, { useContext as at, useMemo as v, lazy as _, useRef as V, useState as D, useEffect as ct } from "react";
+const X = ot.createContext({}), Z = () => at(X), R = {
+  zoom: 14,
+  pitch: 0,
+  bearing: 0,
+  cooperativeGestures: !1
+}, H = {
+  maptiler: "600d69cb-288d-445e-9839-3dfe4d76b31a",
+  mapbox: "locallogic/cmb9nz9kb011501ru8drq8fqf",
+  google: "a7ff20eb973126bb"
+}, ut = 13, ht = 22, lt = 30, pt = "w-full h-full relative overflow-hidden", ft = _(() => import("./index-JQfyhSrg.js")), dt = _(() => import("./index-CR8t37Oz.js")), gt = _(() => import("./index-BtwgeEEU.js")), mt = _(() => import("./index-qqbvBkdn.js")), yt = ({ children: r }) => {
+  const {
+    mapProvider: t,
+    center: e,
+    zoom: n = R.zoom,
+    pitch: i = R.pitch,
+    bearing: o = R.bearing,
+    cooperativeGestures: a = R.cooperativeGestures,
+    zoomPosition: u
+  } = Z(), s = v(() => {
+    switch (t == null ? void 0 : t.name) {
+      case "maptiler":
+        return ft;
+      case "google":
+        return dt;
+      case "mapbox":
+        return gt;
+      default:
+        return mt;
+    }
+  }, [t]);
+  return /* @__PURE__ */ T(
+    "div",
+    {
+      className: pt,
+      "data-testid": "base-map",
+      "data-map-provider-name": t == null ? void 0 : t.name,
+      "data-map-provider-theme": (t == null ? void 0 : t.theme) || H[t == null ? void 0 : t.name] || H.maptiler,
+      "data-zoom": n,
+      "data-pitch": i,
+      "data-bearing": o,
+      "data-cooperative-gestures": a,
+      "data-zoom-position": u,
+      "data-center-latitude": e.latitude,
+      "data-center-longitude": e.longitude,
+      children: /* @__PURE__ */ T(s, { children: r })
+    }
+  );
+}, wt = _(() => import("./index-Do_dW76Q.js")), Mt = _(() => import("./index-BCa658u4.js")), _t = _(() => import("./index-CNxLnZ8O.js"));
+function At(r) {
+  const { mapProvider: t } = Z(), e = v(() => {
+    switch (t == null ? void 0 : t.name) {
+      case "maptiler":
+        return wt;
+      case "google":
+        return Mt;
+      case "mapbox":
+        return _t;
+      default:
+        return null;
+    }
+  }, [t]);
+  return e ? /* @__PURE__ */ T(e, { ...r }) : null;
+}
+function tt(r, t, e = {}) {
+  const n = { type: "Feature" };
+  return (e.id === 0 || e.id) && (n.id = e.id), e.bbox && (n.bbox = e.bbox), n.properties = t || {}, n.geometry = r, n;
+}
+function Et(r, t, e = {}) {
+  if (!r)
+    throw new Error("coordinates is required");
+  if (!Array.isArray(r))
+    throw new Error("coordinates must be an Array");
+  if (r.length < 2)
+    throw new Error("coordinates must be at least 2 numbers long");
+  if (!J(r[0]) || !J(r[1]))
+    throw new Error("coordinates must contain numbers");
+  return tt({
+    type: "Point",
+    coordinates: r
+  }, t, e);
+}
+function bt(r, t, e = {}) {
+  return tt({
+    type: "MultiPoint",
+    coordinates: r
+  }, t, e);
+}
+function J(r) {
+  return !isNaN(r) && r !== null && !Array.isArray(r);
+}
+function et(r, t, e) {
+  if (r !== null)
+    for (var n, i, o, a, u, s, h, l = 0, c = 0, p, d = r.type, y = d === "FeatureCollection", f = d === "Feature", m = y ? r.features.length : 1, g = 0; g < m; g++) {
+      h = y ? r.features[g].geometry : f ? r.geometry : r, p = h ? h.type === "GeometryCollection" : !1, u = p ? h.geometries.length : 1;
+      for (var M = 0; M < u; M++) {
+        var w = 0, A = 0;
+        if (a = p ? h.geometries[M] : h, a !== null) {
+          s = a.coordinates;
+          var E = a.type;
+          switch (l = 0, E) {
+            case null:
+              break;
+            case "Point":
+              if (t(
+                s,
+                c,
+                g,
+                w,
+                A
+              ) === !1)
+                return !1;
+              c++, w++;
+              break;
+            case "LineString":
+            case "MultiPoint":
+              for (n = 0; n < s.length; n++) {
+                if (t(
+                  s[n],
+                  c,
+                  g,
+                  w,
+                  A
+                ) === !1)
+                  return !1;
+                c++, E === "MultiPoint" && w++;
+              }
+              E === "LineString" && w++;
+              break;
+            case "Polygon":
+            case "MultiLineString":
+              for (n = 0; n < s.length; n++) {
+                for (i = 0; i < s[n].length - l; i++) {
+                  if (t(
+                    s[n][i],
+                    c,
+                    g,
+                    w,
+                    A
+                  ) === !1)
+                    return !1;
+                  c++;
+                }
+                E === "MultiLineString" && w++, E === "Polygon" && A++;
+              }
+              E === "Polygon" && w++;
+              break;
+            case "MultiPolygon":
+              for (n = 0; n < s.length; n++) {
+                for (A = 0, i = 0; i < s[n].length; i++) {
+                  for (o = 0; o < s[n][i].length - l; o++) {
+                    if (t(
+                      s[n][i][o],
+                      c,
+                      g,
+                      w,
+                      A
+                    ) === !1)
+                      return !1;
+                    c++;
+                  }
+                  A++;
+                }
+                w++;
+              }
+              break;
+            case "GeometryCollection":
+              for (n = 0; n < a.geometries.length; n++)
+                if (et(a.geometries[n], t) === !1)
+                  return !1;
+              break;
+            default:
+              throw new Error("Unknown Geometry Type");
+          }
+        }
+      }
+    }
+}
+function St(r, t = {}) {
+  if (r.bbox != null && t.recompute !== !0)
+    return r.bbox;
+  const e = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+  return et(r, (n) => {
+    e[0] > n[0] && (e[0] = n[0]), e[1] > n[1] && (e[1] = n[1]), e[2] < n[0] && (e[2] = n[0]), e[3] < n[1] && (e[3] = n[1]);
+  }), e;
+}
+const K = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array
+], F = 1, L = 8;
+class j {
+  /**
+   * Creates an index from raw `ArrayBuffer` data.
+   * @param {ArrayBuffer} data
+   */
+  static from(t) {
+    if (!(t instanceof ArrayBuffer))
+      throw new Error("Data must be an instance of ArrayBuffer.");
+    const [e, n] = new Uint8Array(t, 0, 2);
+    if (e !== 219)
+      throw new Error("Data does not appear to be in a KDBush format.");
+    const i = n >> 4;
+    if (i !== F)
+      throw new Error(`Got v${i} data when expected v${F}.`);
+    const o = K[n & 15];
+    if (!o)
+      throw new Error("Unrecognized array type.");
+    const [a] = new Uint16Array(t, 2, 1), [u] = new Uint32Array(t, 4, 1);
+    return new j(u, a, o, t);
+  }
+  /**
+   * Creates an index that will hold a given number of items.
+   * @param {number} numItems
+   * @param {number} [nodeSize=64] Size of the KD-tree node (64 by default).
+   * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+   * @param {ArrayBuffer} [data] (For internal use only)
+   */
+  constructor(t, e = 64, n = Float64Array, i) {
+    if (isNaN(t) || t < 0) throw new Error(`Unpexpected numItems value: ${t}.`);
+    this.numItems = +t, this.nodeSize = Math.min(Math.max(+e, 2), 65535), this.ArrayType = n, this.IndexArrayType = t < 65536 ? Uint16Array : Uint32Array;
+    const o = K.indexOf(this.ArrayType), a = t * 2 * this.ArrayType.BYTES_PER_ELEMENT, u = t * this.IndexArrayType.BYTES_PER_ELEMENT, s = (8 - u % 8) % 8;
+    if (o < 0)
+      throw new Error(`Unexpected typed array class: ${n}.`);
+    i && i instanceof ArrayBuffer ? (this.data = i, this.ids = new this.IndexArrayType(this.data, L, t), this.coords = new this.ArrayType(this.data, L + u + s, t * 2), this._pos = t * 2, this._finished = !0) : (this.data = new ArrayBuffer(L + a + u + s), this.ids = new this.IndexArrayType(this.data, L, t), this.coords = new this.ArrayType(this.data, L + u + s, t * 2), this._pos = 0, this._finished = !1, new Uint8Array(this.data, 0, 2).set([219, (F << 4) + o]), new Uint16Array(this.data, 2, 1)[0] = e, new Uint32Array(this.data, 4, 1)[0] = t);
+  }
+  /**
+   * Add a point to the index.
+   * @param {number} x
+   * @param {number} y
+   * @returns {number} An incremental index associated with the added item (starting from `0`).
+   */
+  add(t, e) {
+    const n = this._pos >> 1;
+    return this.ids[n] = n, this.coords[this._pos++] = t, this.coords[this._pos++] = e, n;
+  }
+  /**
+   * Perform indexing of the added points.
+   */
+  finish() {
+    const t = this._pos >> 1;
+    if (t !== this.numItems)
+      throw new Error(`Added ${t} items when expected ${this.numItems}.`);
+    return $(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0), this._finished = !0, this;
+  }
+  /**
+   * Search the index for items within a given bounding box.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @returns {number[]} An array of indices correponding to the found items.
+   */
+  range(t, e, n, i) {
+    if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+    const { ids: o, coords: a, nodeSize: u } = this, s = [0, o.length - 1, 0], h = [];
+    for (; s.length; ) {
+      const l = s.pop() || 0, c = s.pop() || 0, p = s.pop() || 0;
+      if (c - p <= u) {
+        for (let m = p; m <= c; m++) {
+          const g = a[2 * m], M = a[2 * m + 1];
+          g >= t && g <= n && M >= e && M <= i && h.push(o[m]);
+        }
+        continue;
+      }
+      const d = p + c >> 1, y = a[2 * d], f = a[2 * d + 1];
+      y >= t && y <= n && f >= e && f <= i && h.push(o[d]), (l === 0 ? t <= y : e <= f) && (s.push(p), s.push(d - 1), s.push(1 - l)), (l === 0 ? n >= y : i >= f) && (s.push(d + 1), s.push(c), s.push(1 - l));
+    }
+    return h;
+  }
+  /**
+   * Search the index for items within a given radius.
+   * @param {number} qx
+   * @param {number} qy
+   * @param {number} r Query radius.
+   * @returns {number[]} An array of indices correponding to the found items.
+   */
+  within(t, e, n) {
+    if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+    const { ids: i, coords: o, nodeSize: a } = this, u = [0, i.length - 1, 0], s = [], h = n * n;
+    for (; u.length; ) {
+      const l = u.pop() || 0, c = u.pop() || 0, p = u.pop() || 0;
+      if (c - p <= a) {
+        for (let m = p; m <= c; m++)
+          W(o[2 * m], o[2 * m + 1], t, e) <= h && s.push(i[m]);
+        continue;
+      }
+      const d = p + c >> 1, y = o[2 * d], f = o[2 * d + 1];
+      W(y, f, t, e) <= h && s.push(i[d]), (l === 0 ? t - n <= y : e - n <= f) && (u.push(p), u.push(d - 1), u.push(1 - l)), (l === 0 ? t + n >= y : e + n >= f) && (u.push(d + 1), u.push(c), u.push(1 - l));
+    }
+    return s;
+  }
+}
+function $(r, t, e, n, i, o) {
+  if (i - n <= e) return;
+  const a = n + i >> 1;
+  nt(r, t, a, n, i, o), $(r, t, e, n, a - 1, 1 - o), $(r, t, e, a + 1, i, 1 - o);
+}
+function nt(r, t, e, n, i, o) {
+  for (; i > n; ) {
+    if (i - n > 600) {
+      const h = i - n + 1, l = e - n + 1, c = Math.log(h), p = 0.5 * Math.exp(2 * c / 3), d = 0.5 * Math.sqrt(c * p * (h - p) / h) * (l - h / 2 < 0 ? -1 : 1), y = Math.max(n, Math.floor(e - l * p / h + d)), f = Math.min(i, Math.floor(e + (h - l) * p / h + d));
+      nt(r, t, e, y, f, o);
+    }
+    const a = t[2 * e + o];
+    let u = n, s = i;
+    for (C(r, t, n, e), t[2 * i + o] > a && C(r, t, n, i); u < s; ) {
+      for (C(r, t, u, s), u++, s--; t[2 * u + o] < a; ) u++;
+      for (; t[2 * s + o] > a; ) s--;
+    }
+    t[2 * n + o] === a ? C(r, t, n, s) : (s++, C(r, t, s, i)), s <= e && (n = s + 1), e <= s && (i = s - 1);
+  }
+}
+function C(r, t, e, n) {
+  N(r, e, n), N(t, 2 * e, 2 * n), N(t, 2 * e + 1, 2 * n + 1);
+}
+function N(r, t, e) {
+  const n = r[t];
+  r[t] = r[e], r[e] = n;
+}
+function W(r, t, e, n) {
+  const i = r - e, o = t - n;
+  return i * i + o * o;
+}
+const xt = {
+  minZoom: 0,
+  // min zoom to generate clusters on
+  maxZoom: 16,
+  // max zoom level to cluster the points on
+  minPoints: 2,
+  // minimum points to form a cluster
+  radius: 40,
+  // cluster radius in pixels
+  extent: 512,
+  // tile extent (radius is calculated relative to it)
+  nodeSize: 64,
+  // size of the KD-tree leaf node, affects performance
+  log: !1,
+  // whether to log timing info
+  // whether to generate numeric ids for input features (in vector tiles)
+  generateId: !1,
+  // a reduce function for calculating custom cluster properties
+  reduce: null,
+  // (accumulated, props) => { accumulated.sum += props.sum; }
+  // properties to use for individual points when running the reducer
+  map: (r) => r
+  // props => ({sum: props.my_value})
+}, Y = Math.fround || /* @__PURE__ */ ((r) => (t) => (r[0] = +t, r[0]))(new Float32Array(1)), P = 2, S = 3, G = 4, b = 5, rt = 6;
+class Pt {
+  constructor(t) {
+    this.options = Object.assign(Object.create(xt), t), this.trees = new Array(this.options.maxZoom + 1), this.stride = this.options.reduce ? 7 : 6, this.clusterProps = [];
+  }
+  load(t) {
+    const { log: e, minZoom: n, maxZoom: i } = this.options;
+    e && console.time("total time");
+    const o = `prepare ${t.length} points`;
+    e && console.time(o), this.points = t;
+    const a = [];
+    for (let s = 0; s < t.length; s++) {
+      const h = t[s];
+      if (!h.geometry) continue;
+      const [l, c] = h.geometry.coordinates, p = Y(U(l)), d = Y(z(c));
+      a.push(
+        p,
+        d,
+        // projected point coordinates
+        1 / 0,
+        // the last zoom the point was processed at
+        s,
+        // index of the source feature in the original input array
+        -1,
+        // parent cluster id
+        1
+        // number of points in a cluster
+      ), this.options.reduce && a.push(0);
+    }
+    let u = this.trees[i + 1] = this._createTree(a);
+    e && console.timeEnd(o);
+    for (let s = i; s >= n; s--) {
+      const h = +Date.now();
+      u = this.trees[s] = this._createTree(this._cluster(u, s)), e && console.log("z%d: %d clusters in %dms", s, u.numItems, +Date.now() - h);
+    }
+    return e && console.timeEnd("total time"), this;
+  }
+  getClusters(t, e) {
+    let n = ((t[0] + 180) % 360 + 360) % 360 - 180;
+    const i = Math.max(-90, Math.min(90, t[1]));
+    let o = t[2] === 180 ? 180 : ((t[2] + 180) % 360 + 360) % 360 - 180;
+    const a = Math.max(-90, Math.min(90, t[3]));
+    if (t[2] - t[0] >= 360)
+      n = -180, o = 180;
+    else if (n > o) {
+      const c = this.getClusters([n, i, 180, a], e), p = this.getClusters([-180, i, o, a], e);
+      return c.concat(p);
+    }
+    const u = this.trees[this._limitZoom(e)], s = u.range(U(n), z(a), U(o), z(i)), h = u.data, l = [];
+    for (const c of s) {
+      const p = this.stride * c;
+      l.push(h[p + b] > 1 ? q(h, p, this.clusterProps) : this.points[h[p + S]]);
+    }
+    return l;
+  }
+  getChildren(t) {
+    const e = this._getOriginId(t), n = this._getOriginZoom(t), i = "No cluster with the specified id.", o = this.trees[n];
+    if (!o) throw new Error(i);
+    const a = o.data;
+    if (e * this.stride >= a.length) throw new Error(i);
+    const u = this.options.radius / (this.options.extent * Math.pow(2, n - 1)), s = a[e * this.stride], h = a[e * this.stride + 1], l = o.within(s, h, u), c = [];
+    for (const p of l) {
+      const d = p * this.stride;
+      a[d + G] === t && c.push(a[d + b] > 1 ? q(a, d, this.clusterProps) : this.points[a[d + S]]);
+    }
+    if (c.length === 0) throw new Error(i);
+    return c;
+  }
+  getLeaves(t, e, n) {
+    e = e || 10, n = n || 0;
+    const i = [];
+    return this._appendLeaves(i, t, e, n, 0), i;
+  }
+  getTile(t, e, n) {
+    const i = this.trees[this._limitZoom(t)], o = Math.pow(2, t), { extent: a, radius: u } = this.options, s = u / a, h = (n - s) / o, l = (n + 1 + s) / o, c = {
+      features: []
+    };
+    return this._addTileFeatures(
+      i.range((e - s) / o, h, (e + 1 + s) / o, l),
+      i.data,
+      e,
+      n,
+      o,
+      c
+    ), e === 0 && this._addTileFeatures(
+      i.range(1 - s / o, h, 1, l),
+      i.data,
+      o,
+      n,
+      o,
+      c
+    ), e === o - 1 && this._addTileFeatures(
+      i.range(0, h, s / o, l),
+      i.data,
+      -1,
+      n,
+      o,
+      c
+    ), c.features.length ? c : null;
+  }
+  getClusterExpansionZoom(t) {
+    let e = this._getOriginZoom(t) - 1;
+    for (; e <= this.options.maxZoom; ) {
+      const n = this.getChildren(t);
+      if (e++, n.length !== 1) break;
+      t = n[0].properties.cluster_id;
+    }
+    return e;
+  }
+  _appendLeaves(t, e, n, i, o) {
+    const a = this.getChildren(e);
+    for (const u of a) {
+      const s = u.properties;
+      if (s && s.cluster ? o + s.point_count <= i ? o += s.point_count : o = this._appendLeaves(t, s.cluster_id, n, i, o) : o < i ? o++ : t.push(u), t.length === n) break;
+    }
+    return o;
+  }
+  _createTree(t) {
+    const e = new j(t.length / this.stride | 0, this.options.nodeSize, Float32Array);
+    for (let n = 0; n < t.length; n += this.stride) e.add(t[n], t[n + 1]);
+    return e.finish(), e.data = t, e;
+  }
+  _addTileFeatures(t, e, n, i, o, a) {
+    for (const u of t) {
+      const s = u * this.stride, h = e[s + b] > 1;
+      let l, c, p;
+      if (h)
+        l = st(e, s, this.clusterProps), c = e[s], p = e[s + 1];
+      else {
+        const f = this.points[e[s + S]];
+        l = f.properties;
+        const [m, g] = f.geometry.coordinates;
+        c = U(m), p = z(g);
+      }
+      const d = {
+        type: 1,
+        geometry: [[
+          Math.round(this.options.extent * (c * o - n)),
+          Math.round(this.options.extent * (p * o - i))
+        ]],
+        tags: l
+      };
+      let y;
+      h || this.options.generateId ? y = e[s + S] : y = this.points[e[s + S]].id, y !== void 0 && (d.id = y), a.features.push(d);
+    }
+  }
+  _limitZoom(t) {
+    return Math.max(this.options.minZoom, Math.min(Math.floor(+t), this.options.maxZoom + 1));
+  }
+  _cluster(t, e) {
+    const { radius: n, extent: i, reduce: o, minPoints: a } = this.options, u = n / (i * Math.pow(2, e)), s = t.data, h = [], l = this.stride;
+    for (let c = 0; c < s.length; c += l) {
+      if (s[c + P] <= e) continue;
+      s[c + P] = e;
+      const p = s[c], d = s[c + 1], y = t.within(s[c], s[c + 1], u), f = s[c + b];
+      let m = f;
+      for (const g of y) {
+        const M = g * l;
+        s[M + P] > e && (m += s[M + b]);
+      }
+      if (m > f && m >= a) {
+        let g = p * f, M = d * f, w, A = -1;
+        const E = ((c / l | 0) << 5) + (e + 1) + this.points.length;
+        for (const it of y) {
+          const x = it * l;
+          if (s[x + P] <= e) continue;
+          s[x + P] = e;
+          const I = s[x + b];
+          g += s[x] * I, M += s[x + 1] * I, s[x + G] = E, o && (w || (w = this._map(s, c, !0), A = this.clusterProps.length, this.clusterProps.push(w)), o(w, this._map(s, x)));
+        }
+        s[c + G] = E, h.push(g / m, M / m, 1 / 0, E, -1, m), o && h.push(A);
+      } else {
+        for (let g = 0; g < l; g++) h.push(s[c + g]);
+        if (m > 1)
+          for (const g of y) {
+            const M = g * l;
+            if (!(s[M + P] <= e)) {
+              s[M + P] = e;
+              for (let w = 0; w < l; w++) h.push(s[M + w]);
+            }
+          }
+      }
+    }
+    return h;
+  }
+  // get index of the point from which the cluster originated
+  _getOriginId(t) {
+    return t - this.points.length >> 5;
+  }
+  // get zoom of the point from which the cluster originated
+  _getOriginZoom(t) {
+    return (t - this.points.length) % 32;
+  }
+  _map(t, e, n) {
+    if (t[e + b] > 1) {
+      const a = this.clusterProps[t[e + rt]];
+      return n ? Object.assign({}, a) : a;
+    }
+    const i = this.points[t[e + S]].properties, o = this.options.map(i);
+    return n && o === i ? Object.assign({}, o) : o;
+  }
+}
+function q(r, t, e) {
+  return {
+    type: "Feature",
+    id: r[t + S],
+    properties: st(r, t, e),
+    geometry: {
+      type: "Point",
+      coordinates: [Ot(r[t]), Tt(r[t + 1])]
+    }
+  };
+}
+function st(r, t, e) {
+  const n = r[t + b], i = n >= 1e4 ? `${Math.round(n / 1e3)}k` : n >= 1e3 ? `${Math.round(n / 100) / 10}k` : n, o = r[t + rt], a = o === -1 ? {} : Object.assign({}, e[o]);
+  return Object.assign(a, {
+    cluster: !0,
+    cluster_id: r[t + S],
+    point_count: n,
+    point_count_abbreviated: i
+  });
+}
+function U(r) {
+  return r / 360 + 0.5;
+}
+function z(r) {
+  const t = Math.sin(r * Math.PI / 180), e = 0.5 - 0.25 * Math.log((1 + t) / (1 - t)) / Math.PI;
+  return e < 0 ? 0 : e > 1 ? 1 : e;
+}
+function Ot(r) {
+  return (r - 0.5) * 360;
+}
+function Tt(r) {
+  const t = (180 - r * 360) * Math.PI / 180;
+  return 360 * Math.atan(Math.exp(t)) / Math.PI - 90;
+}
+var Q = Object.prototype.hasOwnProperty;
+function k(r, t, e) {
+  for (e of r.keys())
+    if (O(e, t)) return e;
+}
+function O(r, t) {
+  var e, n, i;
+  if (r === t) return !0;
+  if (r && t && (e = r.constructor) === t.constructor) {
+    if (e === Date) return r.getTime() === t.getTime();
+    if (e === RegExp) return r.toString() === t.toString();
+    if (e === Array) {
+      if ((n = r.length) === t.length)
+        for (; n-- && O(r[n], t[n]); ) ;
+      return n === -1;
+    }
+    if (e === Set) {
+      if (r.size !== t.size)
+        return !1;
+      for (n of r)
+        if (i = n, i && typeof i == "object" && (i = k(t, i), !i) || !t.has(i)) return !1;
+      return !0;
+    }
+    if (e === Map) {
+      if (r.size !== t.size)
+        return !1;
+      for (n of r)
+        if (i = n[0], i && typeof i == "object" && (i = k(t, i), !i) || !O(n[1], t.get(i)))
+          return !1;
+      return !0;
+    }
+    if (e === ArrayBuffer)
+      r = new Uint8Array(r), t = new Uint8Array(t);
+    else if (e === DataView) {
+      if ((n = r.byteLength) === t.byteLength)
+        for (; n-- && r.getInt8(n) === t.getInt8(n); ) ;
+      return n === -1;
+    }
+    if (ArrayBuffer.isView(r)) {
+      if ((n = r.byteLength) === t.byteLength)
+        for (; n-- && r[n] === t[n]; ) ;
+      return n === -1;
+    }
+    if (!e || typeof r == "object") {
+      n = 0;
+      for (e in r)
+        if (Q.call(r, e) && ++n && !Q.call(t, e) || !(e in t) || !O(r[e], t[e])) return !1;
+      return Object.keys(t).length === n;
+    }
+  }
+  return r !== r && t !== t;
+}
+function vt(r) {
+  var t = B.useRef(r), e = B.useRef(0);
+  return O(r, t.current) || (t.current = r, e.current += 1), B.useMemo(function() {
+    return t.current;
+  }, [e.current]);
+}
+function Lt(r, t) {
+  return B.useEffect(r, vt(t));
+}
+var Ct = function(t) {
+  var e = t.points, n = t.bounds, i = t.zoom, o = t.options, a = t.disableRefresh, u = V(), s = V(), h = D([]), l = h[0], c = h[1], p = Math.round(i);
+  return Lt(function() {
+    a !== !0 && ((!u.current || !O(s.current, e) || !O(u.current.options, o)) && (u.current = new Pt(o), u.current.load(e)), n && c(u.current.getClusters(n, p)), s.current = e);
+  }, [e, n, p, o, a]), {
+    clusters: l,
+    supercluster: u.current
+  };
+};
+const Rt = _(() => import("./index-CRQ5kxRL.js")), Zt = _(() => import("./index-DnsF5I7I.js")), Ut = _(() => import("./index-DNKXUpkv.js"));
+function zt({ markers: r, markerBoundsPadding: t = 1e-3, onClick: e, ...n }) {
+  const { mapProvider: i, center: o, bounds: a, zoom: u } = Z(), [s, h] = D(a);
+  ct(() => {
+    const f = r.length > 0 ? r.map((g) => [g.latitude, g.longitude]) : [[o.latitude, o.longitude]], m = St(bt(f));
+    h(m);
+  }, [r, o]);
+  const l = v(() => typeof t == "number" ? {
+    top: t,
+    bottom: t,
+    left: t,
+    right: t
+  } : t, [t]), { clusters: c, supercluster: p } = Ct({
+    points: r.map((f) => Et([f.longitude, f.latitude], f)),
+    bounds: a,
+    zoom: u,
+    options: { radius: lt, minZoom: ut, maxZoom: ht }
+  }), d = (f) => {
+    var m, g, M;
+    if (!("properties" in f))
+      throw new Error("Cluster does not have properties");
+    if ((m = f.properties) != null && m.cluster && typeof ((g = f.properties) == null ? void 0 : g.cluster_id) == "number") {
+      e == null || e({
+        id: `${f.properties.cluster_id}`,
+        latitude: f.geometry.coordinates[1],
+        longitude: f.geometry.coordinates[0],
+        markers: ((M = p == null ? void 0 : p.getLeaves(f.properties.cluster_id)) == null ? void 0 : M.map((w) => w.properties)) ?? []
+      });
+      return;
+    }
+    e == null || e({
+      id: f.properties.id,
+      latitude: f.properties.latitude,
+      longitude: f.properties.longitude,
+      markers: [f.properties]
+    });
+  }, y = v(() => {
+    switch (i == null ? void 0 : i.name) {
+      case "maptiler":
+        return Rt;
+      case "google":
+        return Zt;
+      case "mapbox":
+        return Ut;
+      default:
+        return null;
+    }
+  }, [i]);
+  return y ? /* @__PURE__ */ T(
+    y,
+    {
+      clusters: c,
+      markerBounds: s,
+      markerBoundsPadding: l,
+      onClick: d,
+      ...n
+    }
+  ) : null;
+}
+const Bt = _(() => import("./index-BOuko7CL.js")), Dt = _(() => import("./index-9RZYMoMG.js")), Ft = _(() => import("./index-D5uhfwEH.js"));
+function Nt({ children: r, ...t }) {
+  const { mapProvider: e } = Z(), n = v(() => {
+    switch (e == null ? void 0 : e.name) {
+      case "maptiler":
+        return Bt;
+      case "google":
+        return Dt;
+      case "mapbox":
+        return Ft;
+      default:
+        return null;
+    }
+  }, [e]);
+  return n ? /* @__PURE__ */ T(n, { ...t, children: r }) : null;
+}
+const Gt = _(() => import("./index-CTk5bvm9.js")), $t = _(() => import("./index-BsnsAUt5.js")), jt = _(() => import("./index-DVitM43i.js"));
+function It(r) {
+  const { mapProvider: t } = Z(), e = v(() => {
+    switch (t == null ? void 0 : t.name) {
+      case "maptiler":
+        return Gt;
+      case "google":
+        return $t;
+      case "mapbox":
+        return jt;
+      default:
+        return null;
+    }
+  }, [t]);
+  return e ? /* @__PURE__ */ T(e, { ...r }) : null;
+}
+function Vt(r) {
+  const [t, e] = D(r.zoom || R.zoom), [n, i] = D();
+  return /* @__PURE__ */ T(X.Provider, { value: { ...r, bounds: n, setBounds: i, zoom: t, setZoom: e }, children: r.children });
+}
+const Kt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BaseMap: yt,
+  CenterPin: At,
+  Layers: It,
+  Markers: zt,
+  Popup: Nt,
+  Root: Vt
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ut as M,
+  H as a,
+  R as d,
+  Kt as i,
+  Z as u
+};