@local-logic/maps 0.0.4 → 0.0.6

package/dist/index-CXLLvdx4.js

@@ -0,0 +1,670 @@
+import { jsx as x, Fragment as nt } from "react/jsx-runtime";
+import * as F from "react";
+import st, { useContext as it, lazy as w, useMemo as L, useRef as G, useState as Q } from "react";
+const q = st.createContext(
+  {}
+), R = () => it(q), S = {
+  zoom: 16,
+  pitch: 0,
+  bearing: 0,
+  cooperativeGestures: !1
+}, ot = "w-full h-full relative overflow-hidden", at = w(() => import("./index-Bd-X-1Gd.js")), ct = w(() => import("./index-BAAE2pMq.js")), ut = w(() => import("./index-B_LO5X9C.js")), ht = w(() => import("./index-qqbvBkdn.js")), pt = ({ children: n }) => {
+  const {
+    mapProvider: t,
+    center: e,
+    zoom: r = S.zoom,
+    pitch: i = S.pitch,
+    bearing: o = S.bearing,
+    cooperativeGestures: a = S.cooperativeGestures,
+    zoomPosition: u
+  } = R(), s = L(() => {
+    switch (t == null ? void 0 : t.name) {
+      case "maptiler":
+        return at;
+      case "google":
+        return ct;
+      case "mapbox":
+        return ut;
+      default:
+        return ht;
+    }
+  }, [t]);
+  return /* @__PURE__ */ x(
+    "div",
+    {
+      className: ot,
+      "data-testid": "base-map",
+      "data-map-provider": t == null ? void 0 : t.name,
+      "data-zoom": r,
+      "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__ */ x(s, { children: n })
+    }
+  );
+};
+function lt(n, t, e = {}) {
+  const r = { type: "Feature" };
+  return (e.id === 0 || e.id) && (r.id = e.id), e.bbox && (r.bbox = e.bbox), r.properties = t || {}, r.geometry = n, r;
+}
+function ft(n, t, e = {}) {
+  if (!n)
+    throw new Error("coordinates is required");
+  if (!Array.isArray(n))
+    throw new Error("coordinates must be an Array");
+  if (n.length < 2)
+    throw new Error("coordinates must be at least 2 numbers long");
+  if (!V(n[0]) || !V(n[1]))
+    throw new Error("coordinates must contain numbers");
+  return lt({
+    type: "Point",
+    coordinates: n
+  }, t, e);
+}
+function V(n) {
+  return !isNaN(n) && n !== null && !Array.isArray(n);
+}
+const H = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array
+], C = 1, P = 8;
+class D {
+  /**
+   * 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, r] = new Uint8Array(t, 0, 2);
+    if (e !== 219)
+      throw new Error("Data does not appear to be in a KDBush format.");
+    const i = r >> 4;
+    if (i !== C)
+      throw new Error(`Got v${i} data when expected v${C}.`);
+    const o = H[r & 15];
+    if (!o)
+      throw new Error("Unrecognized array type.");
+    const [a] = new Uint16Array(t, 2, 1), [u] = new Uint32Array(t, 4, 1);
+    return new D(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, r = 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 = r, this.IndexArrayType = t < 65536 ? Uint16Array : Uint32Array;
+    const o = H.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: ${r}.`);
+    i && i instanceof ArrayBuffer ? (this.data = i, this.ids = new this.IndexArrayType(this.data, P, t), this.coords = new this.ArrayType(this.data, P + u + s, t * 2), this._pos = t * 2, this._finished = !0) : (this.data = new ArrayBuffer(P + a + u + s), this.ids = new this.IndexArrayType(this.data, P, t), this.coords = new this.ArrayType(this.data, P + u + s, t * 2), this._pos = 0, this._finished = !1, new Uint8Array(this.data, 0, 2).set([219, (C << 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 r = this._pos >> 1;
+    return this.ids[r] = r, this.coords[this._pos++] = t, this.coords[this._pos++] = e, r;
+  }
+  /**
+   * 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 j(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, r, 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], c = [];
+    for (; s.length; ) {
+      const p = s.pop() || 0, h = s.pop() || 0, l = s.pop() || 0;
+      if (h - l <= u) {
+        for (let d = l; d <= h; d++) {
+          const y = a[2 * d], M = a[2 * d + 1];
+          y >= t && y <= r && M >= e && M <= i && c.push(o[d]);
+        }
+        continue;
+      }
+      const f = l + h >> 1, g = a[2 * f], m = a[2 * f + 1];
+      g >= t && g <= r && m >= e && m <= i && c.push(o[f]), (p === 0 ? t <= g : e <= m) && (s.push(l), s.push(f - 1), s.push(1 - p)), (p === 0 ? r >= g : i >= m) && (s.push(f + 1), s.push(h), s.push(1 - p));
+    }
+    return c;
+  }
+  /**
+   * 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, r) {
+    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 = [], c = r * r;
+    for (; u.length; ) {
+      const p = u.pop() || 0, h = u.pop() || 0, l = u.pop() || 0;
+      if (h - l <= a) {
+        for (let d = l; d <= h; d++)
+          k(o[2 * d], o[2 * d + 1], t, e) <= c && s.push(i[d]);
+        continue;
+      }
+      const f = l + h >> 1, g = o[2 * f], m = o[2 * f + 1];
+      k(g, m, t, e) <= c && s.push(i[f]), (p === 0 ? t - r <= g : e - r <= m) && (u.push(l), u.push(f - 1), u.push(1 - p)), (p === 0 ? t + r >= g : e + r >= m) && (u.push(f + 1), u.push(h), u.push(1 - p));
+    }
+    return s;
+  }
+}
+function j(n, t, e, r, i, o) {
+  if (i - r <= e) return;
+  const a = r + i >> 1;
+  X(n, t, a, r, i, o), j(n, t, e, r, a - 1, 1 - o), j(n, t, e, a + 1, i, 1 - o);
+}
+function X(n, t, e, r, i, o) {
+  for (; i > r; ) {
+    if (i - r > 600) {
+      const c = i - r + 1, p = e - r + 1, h = Math.log(c), l = 0.5 * Math.exp(2 * h / 3), f = 0.5 * Math.sqrt(h * l * (c - l) / c) * (p - c / 2 < 0 ? -1 : 1), g = Math.max(r, Math.floor(e - p * l / c + f)), m = Math.min(i, Math.floor(e + (c - p) * l / c + f));
+      X(n, t, e, g, m, o);
+    }
+    const a = t[2 * e + o];
+    let u = r, s = i;
+    for (O(n, t, r, e), t[2 * i + o] > a && O(n, t, r, i); u < s; ) {
+      for (O(n, t, u, s), u++, s--; t[2 * u + o] < a; ) u++;
+      for (; t[2 * s + o] > a; ) s--;
+    }
+    t[2 * r + o] === a ? O(n, t, r, s) : (s++, O(n, t, s, i)), s <= e && (r = s + 1), e <= s && (i = s - 1);
+  }
+}
+function O(n, t, e, r) {
+  U(n, e, r), U(t, 2 * e, 2 * r), U(t, 2 * e + 1, 2 * r + 1);
+}
+function U(n, t, e) {
+  const r = n[t];
+  n[t] = n[e], n[e] = r;
+}
+function k(n, t, e, r) {
+  const i = n - e, o = t - r;
+  return i * i + o * o;
+}
+const dt = {
+  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: (n) => n
+  // props => ({sum: props.my_value})
+}, J = Math.fround || /* @__PURE__ */ ((n) => (t) => (n[0] = +t, n[0]))(new Float32Array(1)), v = 2, E = 3, z = 4, A = 5, tt = 6;
+class gt {
+  constructor(t) {
+    this.options = Object.assign(Object.create(dt), t), this.trees = new Array(this.options.maxZoom + 1), this.stride = this.options.reduce ? 7 : 6, this.clusterProps = [];
+  }
+  load(t) {
+    const { log: e, minZoom: r, 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 c = t[s];
+      if (!c.geometry) continue;
+      const [p, h] = c.geometry.coordinates, l = J(I(p)), f = J(B(h));
+      a.push(
+        l,
+        f,
+        // 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 >= r; s--) {
+      const c = +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() - c);
+    }
+    return e && console.timeEnd("total time"), this;
+  }
+  getClusters(t, e) {
+    let r = ((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)
+      r = -180, o = 180;
+    else if (r > o) {
+      const h = this.getClusters([r, i, 180, a], e), l = this.getClusters([-180, i, o, a], e);
+      return h.concat(l);
+    }
+    const u = this.trees[this._limitZoom(e)], s = u.range(I(r), B(a), I(o), B(i)), c = u.data, p = [];
+    for (const h of s) {
+      const l = this.stride * h;
+      p.push(c[l + A] > 1 ? K(c, l, this.clusterProps) : this.points[c[l + E]]);
+    }
+    return p;
+  }
+  getChildren(t) {
+    const e = this._getOriginId(t), r = this._getOriginZoom(t), i = "No cluster with the specified id.", o = this.trees[r];
+    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, r - 1)), s = a[e * this.stride], c = a[e * this.stride + 1], p = o.within(s, c, u), h = [];
+    for (const l of p) {
+      const f = l * this.stride;
+      a[f + z] === t && h.push(a[f + A] > 1 ? K(a, f, this.clusterProps) : this.points[a[f + E]]);
+    }
+    if (h.length === 0) throw new Error(i);
+    return h;
+  }
+  getLeaves(t, e, r) {
+    e = e || 10, r = r || 0;
+    const i = [];
+    return this._appendLeaves(i, t, e, r, 0), i;
+  }
+  getTile(t, e, r) {
+    const i = this.trees[this._limitZoom(t)], o = Math.pow(2, t), { extent: a, radius: u } = this.options, s = u / a, c = (r - s) / o, p = (r + 1 + s) / o, h = {
+      features: []
+    };
+    return this._addTileFeatures(
+      i.range((e - s) / o, c, (e + 1 + s) / o, p),
+      i.data,
+      e,
+      r,
+      o,
+      h
+    ), e === 0 && this._addTileFeatures(
+      i.range(1 - s / o, c, 1, p),
+      i.data,
+      o,
+      r,
+      o,
+      h
+    ), e === o - 1 && this._addTileFeatures(
+      i.range(0, c, s / o, p),
+      i.data,
+      -1,
+      r,
+      o,
+      h
+    ), h.features.length ? h : null;
+  }
+  getClusterExpansionZoom(t) {
+    let e = this._getOriginZoom(t) - 1;
+    for (; e <= this.options.maxZoom; ) {
+      const r = this.getChildren(t);
+      if (e++, r.length !== 1) break;
+      t = r[0].properties.cluster_id;
+    }
+    return e;
+  }
+  _appendLeaves(t, e, r, 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, r, i, o) : o < i ? o++ : t.push(u), t.length === r) break;
+    }
+    return o;
+  }
+  _createTree(t) {
+    const e = new D(t.length / this.stride | 0, this.options.nodeSize, Float32Array);
+    for (let r = 0; r < t.length; r += this.stride) e.add(t[r], t[r + 1]);
+    return e.finish(), e.data = t, e;
+  }
+  _addTileFeatures(t, e, r, i, o, a) {
+    for (const u of t) {
+      const s = u * this.stride, c = e[s + A] > 1;
+      let p, h, l;
+      if (c)
+        p = et(e, s, this.clusterProps), h = e[s], l = e[s + 1];
+      else {
+        const m = this.points[e[s + E]];
+        p = m.properties;
+        const [d, y] = m.geometry.coordinates;
+        h = I(d), l = B(y);
+      }
+      const f = {
+        type: 1,
+        geometry: [[
+          Math.round(this.options.extent * (h * o - r)),
+          Math.round(this.options.extent * (l * o - i))
+        ]],
+        tags: p
+      };
+      let g;
+      c || this.options.generateId ? g = e[s + E] : g = this.points[e[s + E]].id, g !== void 0 && (f.id = g), a.features.push(f);
+    }
+  }
+  _limitZoom(t) {
+    return Math.max(this.options.minZoom, Math.min(Math.floor(+t), this.options.maxZoom + 1));
+  }
+  _cluster(t, e) {
+    const { radius: r, extent: i, reduce: o, minPoints: a } = this.options, u = r / (i * Math.pow(2, e)), s = t.data, c = [], p = this.stride;
+    for (let h = 0; h < s.length; h += p) {
+      if (s[h + v] <= e) continue;
+      s[h + v] = e;
+      const l = s[h], f = s[h + 1], g = t.within(s[h], s[h + 1], u), m = s[h + A];
+      let d = m;
+      for (const y of g) {
+        const M = y * p;
+        s[M + v] > e && (d += s[M + A]);
+      }
+      if (d > m && d >= a) {
+        let y = l * m, M = f * m, _, N = -1;
+        const Z = ((h / p | 0) << 5) + (e + 1) + this.points.length;
+        for (const rt of g) {
+          const b = rt * p;
+          if (s[b + v] <= e) continue;
+          s[b + v] = e;
+          const $ = s[b + A];
+          y += s[b] * $, M += s[b + 1] * $, s[b + z] = Z, o && (_ || (_ = this._map(s, h, !0), N = this.clusterProps.length, this.clusterProps.push(_)), o(_, this._map(s, b)));
+        }
+        s[h + z] = Z, c.push(y / d, M / d, 1 / 0, Z, -1, d), o && c.push(N);
+      } else {
+        for (let y = 0; y < p; y++) c.push(s[h + y]);
+        if (d > 1)
+          for (const y of g) {
+            const M = y * p;
+            if (!(s[M + v] <= e)) {
+              s[M + v] = e;
+              for (let _ = 0; _ < p; _++) c.push(s[M + _]);
+            }
+          }
+      }
+    }
+    return c;
+  }
+  // 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, r) {
+    if (t[e + A] > 1) {
+      const a = this.clusterProps[t[e + tt]];
+      return r ? Object.assign({}, a) : a;
+    }
+    const i = this.points[t[e + E]].properties, o = this.options.map(i);
+    return r && o === i ? Object.assign({}, o) : o;
+  }
+}
+function K(n, t, e) {
+  return {
+    type: "Feature",
+    id: n[t + E],
+    properties: et(n, t, e),
+    geometry: {
+      type: "Point",
+      coordinates: [mt(n[t]), yt(n[t + 1])]
+    }
+  };
+}
+function et(n, t, e) {
+  const r = n[t + A], i = r >= 1e4 ? `${Math.round(r / 1e3)}k` : r >= 1e3 ? `${Math.round(r / 100) / 10}k` : r, o = n[t + tt], a = o === -1 ? {} : Object.assign({}, e[o]);
+  return Object.assign(a, {
+    cluster: !0,
+    cluster_id: n[t + E],
+    point_count: r,
+    point_count_abbreviated: i
+  });
+}
+function I(n) {
+  return n / 360 + 0.5;
+}
+function B(n) {
+  const t = Math.sin(n * 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 mt(n) {
+  return (n - 0.5) * 360;
+}
+function yt(n) {
+  const t = (180 - n * 360) * Math.PI / 180;
+  return 360 * Math.atan(Math.exp(t)) / Math.PI - 90;
+}
+var W = Object.prototype.hasOwnProperty;
+function Y(n, t, e) {
+  for (e of n.keys())
+    if (T(e, t)) return e;
+}
+function T(n, t) {
+  var e, r, i;
+  if (n === t) return !0;
+  if (n && t && (e = n.constructor) === t.constructor) {
+    if (e === Date) return n.getTime() === t.getTime();
+    if (e === RegExp) return n.toString() === t.toString();
+    if (e === Array) {
+      if ((r = n.length) === t.length)
+        for (; r-- && T(n[r], t[r]); ) ;
+      return r === -1;
+    }
+    if (e === Set) {
+      if (n.size !== t.size)
+        return !1;
+      for (r of n)
+        if (i = r, i && typeof i == "object" && (i = Y(t, i), !i) || !t.has(i)) return !1;
+      return !0;
+    }
+    if (e === Map) {
+      if (n.size !== t.size)
+        return !1;
+      for (r of n)
+        if (i = r[0], i && typeof i == "object" && (i = Y(t, i), !i) || !T(r[1], t.get(i)))
+          return !1;
+      return !0;
+    }
+    if (e === ArrayBuffer)
+      n = new Uint8Array(n), t = new Uint8Array(t);
+    else if (e === DataView) {
+      if ((r = n.byteLength) === t.byteLength)
+        for (; r-- && n.getInt8(r) === t.getInt8(r); ) ;
+      return r === -1;
+    }
+    if (ArrayBuffer.isView(n)) {
+      if ((r = n.byteLength) === t.byteLength)
+        for (; r-- && n[r] === t[r]; ) ;
+      return r === -1;
+    }
+    if (!e || typeof n == "object") {
+      r = 0;
+      for (e in n)
+        if (W.call(n, e) && ++r && !W.call(t, e) || !(e in t) || !T(n[e], t[e])) return !1;
+      return Object.keys(t).length === r;
+    }
+  }
+  return n !== n && t !== t;
+}
+function wt(n) {
+  var t = F.useRef(n), e = F.useRef(0);
+  return T(n, t.current) || (t.current = n, e.current += 1), F.useMemo(function() {
+    return t.current;
+  }, [e.current]);
+}
+function Mt(n, t) {
+  return F.useEffect(n, wt(t));
+}
+var xt = function(t) {
+  var e = t.points, r = t.bounds, i = t.zoom, o = t.options, a = t.disableRefresh, u = G(), s = G(), c = Q([]), p = c[0], h = c[1], l = Math.round(i);
+  return Mt(function() {
+    a !== !0 && ((!u.current || !T(s.current, e) || !T(u.current.options, o)) && (u.current = new gt(o), u.current.load(e)), r && h(u.current.getClusters(r, l)), s.current = e);
+  }, [e, r, l, o, a]), {
+    clusters: p,
+    supercluster: u.current
+  };
+};
+const Ut = `
+  cursor-pointer
+  relative
+  h-7
+  w-5
+  text-base-white
+  group
+  transition-transform
+
+  data-[is-cluster=true]:w-auto
+`, _t = `
+  cursor-pointer
+  fill-primary-100
+  stroke-1
+  box-border
+  transition-colors
+  transition-transform
+  group-hover:stroke-base-white
+  group-focus:stroke-base-white
+`, zt = `
+  absolute top-1 left-1/2 transform -translate-x-1/2
+  flex justify-center items-center rounded-full overflow-hidden
+  transition-all w-3.5 h-3.5
+
+  group-hover:bg-base-white
+`, jt = `
+  m-auto transition-all w-full h-full
+  max-w-3.5 max-h-3.5
+
+  group-hover:text-primary-100
+  group-hover:max-w-2.5
+  group-hover:max-h-2.5
+`, At = w(() => import("./index-DHw9gU4K.js")), Et = w(() => import("./index-BHjgd5HB.js")), bt = w(() => import("./index-BbrOUWDy.js")), vt = ({ markers: n, onClick: t, ...e }) => {
+  const { mapProvider: r, bounds: i } = R(), { clusters: o, supercluster: a } = xt({
+    points: n.map((c) => ft([c.longitude, c.latitude], c)),
+    bounds: i,
+    zoom: 16,
+    options: { radius: 50, maxZoom: 30 }
+  }), u = (c) => {
+    var p, h, l;
+    if (!("properties" in c))
+      throw new Error("Cluster does not have properties");
+    if ((p = c.properties) != null && p.cluster && typeof ((h = c.properties) == null ? void 0 : h.cluster_id) == "number") {
+      t == null || t({
+        id: `${c.properties.cluster_id}`,
+        latitude: c.geometry.coordinates[1],
+        longitude: c.geometry.coordinates[0],
+        markers: ((l = a == null ? void 0 : a.getChildren(c.properties.cluster_id)) == null ? void 0 : l.map((f) => f.properties)) ?? []
+      });
+      return;
+    }
+    t == null || t({
+      id: c.properties.id,
+      latitude: c.properties.latitude,
+      longitude: c.properties.longitude,
+      markers: [c.properties]
+    });
+  }, s = L(() => {
+    switch (r == null ? void 0 : r.name) {
+      case "maptiler":
+        return At;
+      case "google":
+        return Et;
+      case "mapbox":
+        return bt;
+      default:
+        return null;
+    }
+  }, [r]);
+  return s ? /* @__PURE__ */ x(nt, { children: /* @__PURE__ */ x(s, { clusters: o, onClick: u, ...e, children: /* @__PURE__ */ x("svg", { viewBox: "0 0 20 28", fill: "none", className: _t, children: /* @__PURE__ */ x(
+    "path",
+    {
+      d: "M20 10C20 15.5228 12 27.5 10 27.5C8 27.5 0 15.5228 0 10C0 4.47715 4.47715 0 10 0C15.5228 0 20 4.47715 20 10Z",
+      fill: "inherit"
+    }
+  ) }) }) }) : null;
+}, Tt = w(() => import("./index-J1MKzGEM.js")), Pt = w(() => import("./index-BZ2605rA.js")), Ot = w(() => import("./index-B43MtiHH.js"));
+function St({ children: n, ...t }) {
+  const { mapProvider: e } = R(), r = L(() => {
+    switch (e == null ? void 0 : e.name) {
+      case "maptiler":
+        return Tt;
+      case "google":
+        return Pt;
+      case "mapbox":
+        return Ot;
+      default:
+        return null;
+    }
+  }, [e]);
+  return r ? /* @__PURE__ */ x(r, { ...t, children: n }) : null;
+}
+const It = w(() => import("./index-CTk5bvm9.js")), Bt = w(() => import("./index-CPq7k7F4.js")), Ft = w(() => import("./index-DVitM43i.js"));
+function Lt(n) {
+  const { mapProvider: t } = R(), e = L(() => {
+    switch (t == null ? void 0 : t.name) {
+      case "maptiler":
+        return It;
+      case "google":
+        return Bt;
+      case "mapbox":
+        return Ft;
+      default:
+        return null;
+    }
+  }, [t]);
+  return e ? /* @__PURE__ */ x(e, { ...n }) : null;
+}
+function Rt(n) {
+  const [t, e] = Q();
+  return /* @__PURE__ */ x(q.Provider, { value: { ...n, bounds: t, setBounds: e }, children: n.children });
+}
+const Dt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BaseMap: pt,
+  Layers: Lt,
+  Markers: vt,
+  Popup: St,
+  Root: Rt
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  jt as a,
+  Dt as b,
+  Ut as c,
+  S as d,
+  zt as i,
+  R as u
+};