@stachelock/ui 0.2.14 → 0.3.0

package/dist/index-Dca39bYA.js

@@ -0,0 +1,2167 @@
+import { defineComponent as j, toRef as I, provide as U, ref as b, inject as O, computed as V, watch as P, markRaw as q, onBeforeUnmount as Z, createElementBlock as de, openBlock as me, Fragment as ct, createCommentVNode as pt, renderSlot as fe, createElementVNode as Ye, mergeProps as dt, Comment as be, onMounted as Je, normalizeProps as mt, guardReactiveProps as ft } from "vue";
+(function() {
+  try {
+    if (typeof document < "u") {
+      var t = document.createElement("style");
+      t.appendChild(document.createTextNode(".mapdiv[data-v-c63ff230]{width:100%;height:100%}.advanced-marker-wrapper{display:none}.mapdiv .advanced-marker-wrapper{display:inline-block}.custom-control-wrapper[data-v-ab9120cd]{display:none}.mapdiv .custom-control-wrapper[data-v-ab9120cd]{display:inline-block}.info-window-wrapper[data-v-d182c1f9]{display:none}.mapdiv .info-window-wrapper[data-v-d182c1f9]{display:inline-block}.custom-marker-wrapper[data-v-2d2d343a]{display:none}.mapdiv .custom-marker-wrapper[data-v-2d2d343a]{display:inline-block}")), document.head.appendChild(t);
+    }
+  } catch (e) {
+    console.error("vite-plugin-css-injected-by-js", e);
+  }
+})();
+var ht = Object.defineProperty, vt = (t, e, r) => e in t ? ht(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, he = (t, e, r) => (vt(t, typeof e != "symbol" ? e + "" : e, r), r);
+const z = Symbol("map"), D = Symbol("api"), ke = Symbol("marker"), we = Symbol("markerCluster"), ne = Symbol("CustomMarker"), Qe = Symbol("mapTilesLoaded"), F = [
+  "click",
+  "dblclick",
+  "drag",
+  "dragend",
+  "dragstart",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "rightclick"
+];
+function gt(t, e) {
+  t.src = e;
+}
+const yt = (t) => {
+  var e, r, o, a = "The Google Maps JavaScript API", n = "google", i = "importLibrary", l = "__ib__", s = document, c = window, d = c[n] || (c[n] = {}), u = d.maps || (d.maps = {}), m = /* @__PURE__ */ new Set(), p = new URLSearchParams(), h = () => e || (e = new Promise(async (f, v) => {
+    var g;
+    await (r = s.createElement("script")), p.set("libraries", [...m] + "");
+    for (o in t)
+      p.set(o.replace(/[A-Z]/g, (y) => "_" + y[0].toLowerCase()), t[o]);
+    p.set("callback", n + ".maps." + l), gt(r, "https://maps.googleapis.com/maps/api/js?" + p), u[l] = f, r.onerror = () => e = v(Error(a + " could not load.")), r.nonce = ((g = s.querySelector("script[nonce]")) == null ? void 0 : g.nonce) || "", s.head.append(r);
+  }));
+  u[i] ? console.warn(a + " only loads once. Ignoring:", t) : u[i] = (f, ...v) => m.add(f) && h().then(() => u[i](f, ...v));
+}, bt = (t) => `The setOptions() function should only be called once. The options passed to the additional call (${JSON.stringify(t)}) will be ignored.`, kt = (t) => `The google.maps.importLibrary() function is already defined, and @googlemaps/js-api-loader will use the existing function instead of overwriting it. The options passed to setOptions (${JSON.stringify(t)}) will be ignored.`, wt = "No options were set before calling importLibrary. Make sure to configure the loader using setOptions().", Mt = "There already is a script loading the Google Maps JavaScript API, and no google.maps.importLibrary function is defined. @googlemaps/js-api-loader will proceed to bootstrap the API with the specified options, but the existing script might cause problems using the API. Make sure to remove the script loading the API.", Me = process.env.NODE_ENV !== "production" ? (t) => {
+  console.warn(`[@googlemaps/js-api-loader] ${t}`);
+} : () => {
+}, Et = process.env.NODE_ENV !== "production" ? (t) => {
+  console.info(`[@googlemaps/js-api-loader] ${t}`);
+} : () => {
+};
+let ve = !1;
+function Ot(t) {
+  if (ve) {
+    Me(bt(t));
+    return;
+  }
+  xt(t), ve = !0;
+}
+async function Ct(t) {
+  var e, r;
+  if (ve || Me(wt), !((r = (e = window?.google) == null ? void 0 : e.maps) != null && r.importLibrary))
+    throw new Error("google.maps.importLibrary is not installed.");
+  return await google.maps.importLibrary(t);
+}
+function xt(t) {
+  var e, r;
+  const o = !!((r = (e = window.google) == null ? void 0 : e.maps) != null && r.importLibrary);
+  o ? Et(kt(t)) : process.env.NODE_ENV !== "production" && document.querySelector('script[src*="maps.googleapis.com/maps/api/js"]') && Me(Mt), o || yt(t);
+}
+function _t(t) {
+  return class extends t.OverlayView {
+    constructor(e) {
+      super(), he(this, "element"), he(this, "opts");
+      const { element: r, ...o } = e;
+      this.element = r, this.opts = o, this.opts.map && this.setMap(this.opts.map);
+    }
+    getPosition() {
+      return this.opts.position ? this.opts.position instanceof t.LatLng ? this.opts.position : new t.LatLng(this.opts.position) : null;
+    }
+    getVisible() {
+      if (!this.element)
+        return !1;
+      const e = this.element;
+      return e.style.display !== "none" && e.style.visibility !== "hidden" && (e.style.opacity === "" || Number(e.style.opacity) > 0.01);
+    }
+    onAdd() {
+      if (!this.element)
+        return;
+      const e = this.getPanes();
+      e && e.overlayMouseTarget.appendChild(this.element);
+    }
+    draw() {
+      if (!this.element)
+        return;
+      const e = this.getProjection(), r = e?.fromLatLngToDivPixel(this.getPosition());
+      if (r) {
+        this.element.style.position = "absolute";
+        let o, a;
+        switch (this.opts.anchorPoint) {
+          case "TOP_CENTER":
+            o = "-50%", a = "-100%";
+            break;
+          case "BOTTOM_CENTER":
+            o = "-50%", a = "0";
+            break;
+          case "LEFT_CENTER":
+            o = "-100%", a = "-50%";
+            break;
+          case "RIGHT_CENTER":
+            o = "0", a = "-50%";
+            break;
+          case "TOP_LEFT":
+            o = "-100%", a = "-100%";
+            break;
+          case "TOP_RIGHT":
+            o = "0", a = "-100%";
+            break;
+          case "BOTTOM_LEFT":
+            o = "-100%", a = "0";
+            break;
+          case "BOTTOM_RIGHT":
+            o = "0", a = "0";
+            break;
+          default:
+            o = "-50%", a = "-50%";
+        }
+        const n = r.x + (this.opts.offsetX || 0) + "px", i = r.y + (this.opts.offsetY || 0) + "px";
+        this.element.style.transform = `translateX(${o}) translateX(${n}) translateY(${a}) translateY(${i})`, this.opts.zIndex && (this.element.style.zIndex = this.opts.zIndex.toString());
+      }
+    }
+    onRemove() {
+      this.element && this.element.remove();
+    }
+    setOptions(e) {
+      const { element: r, ...o } = e;
+      this.element = r, this.opts = o, this.draw();
+    }
+  };
+}
+let xe = !1;
+const _e = [
+  "bounds_changed",
+  "center_changed",
+  "click",
+  "contextmenu",
+  "dblclick",
+  "drag",
+  "dragend",
+  "dragstart",
+  "heading_changed",
+  "idle",
+  "isfractionalzoomenabled_changed",
+  "mapcapabilities_changed",
+  "maptypeid_changed",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "projection_changed",
+  "renderingtype_changed",
+  "rightclick",
+  "tilesloaded",
+  "tilt_changed",
+  "zoom_changed"
+], Pt = j({
+  props: {
+    apiPromise: {
+      type: Promise
+    },
+    apiKey: {
+      type: String,
+      default: ""
+    },
+    version: {
+      type: String,
+      default: "weekly"
+    },
+    libraries: {
+      type: Array,
+      default: () => ["places", "marker"]
+    },
+    region: {
+      type: String,
+      required: !1
+    },
+    language: {
+      type: String,
+      required: !1
+    },
+    backgroundColor: {
+      type: String,
+      required: !1
+    },
+    center: {
+      type: Object,
+      default: () => ({ lat: 0, lng: 0 })
+    },
+    clickableIcons: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    colorScheme: {
+      type: String,
+      required: !1
+    },
+    controlSize: {
+      type: Number,
+      required: !1
+    },
+    disableDefaultUi: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    disableDoubleClickZoom: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    draggable: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    draggableCursor: {
+      type: String,
+      required: !1
+    },
+    draggingCursor: {
+      type: String,
+      required: !1
+    },
+    fullscreenControl: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    fullscreenControlPosition: {
+      type: String,
+      required: !1
+    },
+    gestureHandling: {
+      type: String,
+      required: !1
+    },
+    heading: {
+      type: Number,
+      required: !1
+    },
+    isFractionalZoomEnabled: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    keyboardShortcuts: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    mapTypeControl: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    mapTypeControlOptions: {
+      type: Object,
+      required: !1
+    },
+    mapTypeId: {
+      type: [Number, String],
+      required: !1
+    },
+    mapId: {
+      type: String,
+      required: !1
+    },
+    maxZoom: {
+      type: Number,
+      required: !1
+    },
+    minZoom: {
+      type: Number,
+      required: !1
+    },
+    noClear: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    panControl: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    panControlPosition: {
+      type: String,
+      required: !1
+    },
+    restriction: {
+      type: Object,
+      required: !1
+    },
+    rotateControl: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    rotateControlPosition: {
+      type: String,
+      required: !1
+    },
+    scaleControl: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    scaleControlStyle: {
+      type: Number,
+      required: !1
+    },
+    scrollwheel: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    streetView: {
+      type: Object,
+      required: !1
+    },
+    streetViewControl: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    streetViewControlPosition: {
+      type: String,
+      required: !1
+    },
+    styles: {
+      type: Array,
+      required: !1
+    },
+    tilt: {
+      type: Number,
+      required: !1
+    },
+    zoom: {
+      type: Number,
+      required: !1
+    },
+    zoomControl: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    zoomControlPosition: {
+      type: String,
+      required: !1
+    },
+    cameraControl: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    cameraControlPosition: {
+      type: String,
+      required: !1
+    }
+  },
+  emits: _e,
+  setup(t, { emit: e }) {
+    const r = b(), o = b(!1), a = b(), n = b(), i = b(!1);
+    U(z, a), U(D, n), U(Qe, i);
+    const l = () => {
+      const u = { ...t };
+      Object.keys(u).forEach((h) => {
+        u[h] === void 0 && delete u[h];
+      });
+      const m = (h) => {
+        var f;
+        return h ? { position: (f = n.value) == null ? void 0 : f.ControlPosition[h] } : {};
+      }, p = {
+        scaleControlOptions: t.scaleControlStyle ? { style: t.scaleControlStyle } : {},
+        panControlOptions: m(t.panControlPosition),
+        zoomControlOptions: m(t.zoomControlPosition),
+        rotateControlOptions: m(t.rotateControlPosition),
+        streetViewControlOptions: m(t.streetViewControlPosition),
+        fullscreenControlOptions: m(t.fullscreenControlPosition),
+        cameraControlOptions: m(t.cameraControlPosition),
+        disableDefaultUI: t.disableDefaultUi
+      };
+      return { ...u, ...p };
+    }, s = P(
+      [n, a],
+      ([u, m]) => {
+        const p = u, h = m;
+        p && h && (p.event.addListenerOnce(h, "tilesloaded", () => {
+          i.value = !0;
+        }), setTimeout(s, 0));
+      },
+      { immediate: !0 }
+    ), c = () => {
+      const { apiKey: u, region: m, version: p, language: h, libraries: f } = t;
+      Ot({ key: u, region: m, v: p, language: h, libraries: f });
+    }, d = (u) => {
+      const m = u ? u.maps : google.maps;
+      n.value = q(m), a.value = q(new m.Map(r.value, l()));
+      const p = _t(n.value);
+      n.value[ne] = p, _e.forEach((f) => {
+        var v;
+        (v = a.value) == null || v.addListener(f, (g) => e(f, g));
+      }), o.value = !0;
+      const h = Object.keys(t).filter(
+        (f) => !["apiPromise", "apiKey", "version", "libraries", "region", "language", "center", "zoom"].includes(f)
+      ).map((f) => I(t, f));
+      P(
+        [() => t.center, () => t.zoom, ...h],
+        ([f, v], [g, y]) => {
+          var M, x, C;
+          const { center: k, zoom: w, ..._ } = l();
+          (M = a.value) == null || M.setOptions(_), v !== void 0 && v !== y && ((x = a.value) == null || x.setZoom(v));
+          const R = !g || f.lng !== g.lng || f.lat !== g.lat;
+          f && R && ((C = a.value) == null || C.panTo(f));
+        }
+      );
+    };
+    return Je(() => {
+      if (t.apiPromise && t.apiPromise instanceof Promise)
+        t.apiPromise.then(d);
+      else {
+        xe || (c(), xe = !0);
+        const u = t.libraries && t.libraries.length > 0 ? t.libraries : ["maps", "marker"];
+        Promise.all(u.map((m) => Ct(m))).then(() => d());
+      }
+    }), Z(() => {
+      var u;
+      i.value = !1, a.value && ((u = n.value) == null || u.event.clearInstanceListeners(a.value));
+    }), { mapRef: r, ready: o, map: a, api: n, mapTilesLoaded: i };
+  }
+}), et = (t, e) => {
+  const r = t.__vccOpts || t;
+  for (const [o, a] of e)
+    r[o] = a;
+  return r;
+}, jt = {
+  ref: "mapRef",
+  class: "mapdiv"
+};
+function qt(t, e, r, o, a, n) {
+  return me(), de("div", null, [
+    Ye("div", jt, null, 512),
+    fe(t.$slots, "default", mt(ft({ ready: t.ready, map: t.map, api: t.api, mapTilesLoaded: t.mapTilesLoaded })), void 0, !0)
+  ]);
+}
+const po = /* @__PURE__ */ et(Pt, [["render", qt], ["__scopeId", "data-v-c63ff230"]]);
+function Lt(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var St = function t(e, r) {
+  if (e === r)
+    return !0;
+  if (e && r && typeof e == "object" && typeof r == "object") {
+    if (e.constructor !== r.constructor)
+      return !1;
+    var o, a, n;
+    if (Array.isArray(e)) {
+      if (o = e.length, o != r.length)
+        return !1;
+      for (a = o; a-- !== 0; )
+        if (!t(e[a], r[a]))
+          return !1;
+      return !0;
+    }
+    if (e.constructor === RegExp)
+      return e.source === r.source && e.flags === r.flags;
+    if (e.valueOf !== Object.prototype.valueOf)
+      return e.valueOf() === r.valueOf();
+    if (e.toString !== Object.prototype.toString)
+      return e.toString() === r.toString();
+    if (n = Object.keys(e), o = n.length, o !== Object.keys(r).length)
+      return !1;
+    for (a = o; a-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(r, n[a]))
+        return !1;
+    for (a = o; a-- !== 0; ) {
+      var i = n[a];
+      if (!t(e[i], r[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && r !== r;
+};
+const Y = /* @__PURE__ */ Lt(St), Pe = ["click", "drag", "dragend", "dragstart", "gmp-click"], At = j({
+  name: "AdvancedMarker",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    },
+    pinOptions: {
+      type: Object,
+      required: !1
+    }
+  },
+  emits: Pe,
+  setup(t, { emit: e, expose: r, slots: o }) {
+    const a = b(), n = V(() => {
+      var p;
+      return (p = o.content) == null ? void 0 : p.call(o).some((h) => h.type !== be);
+    }), i = I(t, "options"), l = I(t, "pinOptions"), s = b(), c = O(z, b()), d = O(D, b()), u = O(we, b()), m = V(
+      () => !!(u.value && d.value && s.value instanceof google.maps.marker.AdvancedMarkerElement)
+    );
+    return P(
+      [c, i, l, a],
+      async (p, [h, f, v, g]) => {
+        var y, M, x;
+        const C = !Y(i.value, f) || !Y(l.value, v), k = a.value !== g, w = C || k || c.value !== h;
+        if (!c.value || !d.value || !w || n.value && !a.value)
+          return;
+        const { AdvancedMarkerElement: _, PinElement: R } = d.value.marker;
+        if (s.value) {
+          const { map: se, content: Q, ...ie } = i.value;
+          Object.assign(s.value, {
+            content: n.value ? a.value : l.value ? new R(l.value).element : Q,
+            ...ie
+          }), m.value && ((y = u.value) == null || y.removeMarker(s.value), (M = u.value) == null || M.addMarker(s.value));
+        } else
+          n.value ? i.value.content = a.value : l.value && (i.value.content = new R(l.value).element), s.value = q(new _(i.value)), m.value ? (x = u.value) == null || x.addMarker(s.value) : s.value.map = c.value, Pe.forEach((se) => {
+            var Q;
+            (Q = s.value) == null || Q.addListener(se, (ie) => e(se, ie));
+          });
+      },
+      {
+        immediate: !0,
+        flush: "post"
+        // Ensure DOM updates happen before this watcher runs
+      }
+    ), Z(() => {
+      var p, h;
+      s.value && ((p = d.value) == null || p.event.clearInstanceListeners(s.value), m.value ? (h = u.value) == null || h.removeMarker(s.value) : s.value.map = null);
+    }), U(ke, s), r({ marker: s }), { hasCustomSlotContent: n, markerRef: a };
+  }
+}), Tt = {
+  key: 0,
+  class: "advanced-marker-wrapper"
+};
+function It(t, e, r, o, a, n) {
+  return me(), de(ct, null, [
+    t.hasCustomSlotContent ? (me(), de("div", Tt, [
+      Ye("div", dt({ ref: "markerRef" }, t.$attrs), [
+        fe(t.$slots, "content")
+      ], 16)
+    ])) : pt("", !0),
+    fe(t.$slots, "default")
+  ], 64);
+}
+const mo = /* @__PURE__ */ et(At, [["render", It]]), je = (t) => t === "Marker", qe = (t) => t === ne, W = (t, e, r, o) => {
+  const a = b(), n = O(z, b()), i = O(D, b()), l = O(we, b()), s = V(
+    () => !!(l.value && i.value && (a.value instanceof i.value.Marker || a.value instanceof i.value[ne]))
+  );
+  return P(
+    [n, r],
+    (c, [d, u]) => {
+      var m, p, h;
+      const f = !Y(r.value, u) || n.value !== d;
+      if (!(!n.value || !i.value || !f))
+        if (a.value)
+          a.value.setOptions(r.value), s.value && ((m = l.value) == null || m.removeMarker(a.value), (p = l.value) == null || p.addMarker(a.value));
+        else {
+          if (je(t))
+            a.value = q(
+              new i.value[t](r.value)
+            );
+          else if (qe(t)) {
+            const v = r.value;
+            v.element && (a.value = q(new i.value[t](v)));
+          } else
+            a.value = q(
+              new i.value[t]({
+                ...r.value,
+                map: n.value
+              })
+            );
+          a.value && (s.value ? (h = l.value) == null || h.addMarker(a.value) : (je(t) || qe(t)) && a.value.setMap(n.value)), e.forEach((v) => {
+            var g;
+            (g = a.value) == null || g.addListener(v, (y) => o(v, y));
+          });
+        }
+    },
+    {
+      immediate: !0,
+      flush: "post"
+    }
+  ), Z(() => {
+    var c, d;
+    a.value && ((c = i.value) == null || c.event.clearInstanceListeners(a.value), s.value ? (d = l.value) == null || d.removeMarker(a.value) : a.value.setMap(null));
+  }), a;
+}, Le = [
+  "animation_changed",
+  "click",
+  "dblclick",
+  "rightclick",
+  "dragstart",
+  "dragend",
+  "drag",
+  "mouseover",
+  "mousedown",
+  "mouseout",
+  "mouseup",
+  "draggable_changed",
+  "clickable_changed",
+  "contextmenu",
+  "cursor_changed",
+  "flat_changed",
+  "zindex_changed",
+  "icon_changed",
+  "position_changed",
+  "shape_changed",
+  "title_changed",
+  "visible_changed"
+], fo = j({
+  name: "Marker",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: Le,
+  setup(t, { emit: e, expose: r, slots: o }) {
+    const a = I(t, "options"), n = W("Marker", Le, a, e);
+    return U(ke, n), r({ marker: n }), () => {
+      var i;
+      return (i = o.default) == null ? void 0 : i.call(o);
+    };
+  }
+});
+j({
+  name: "Polyline",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: F,
+  setup(t, { emit: e }) {
+    const r = I(t, "options");
+    return { polyline: W("Polyline", F, r, e) };
+  },
+  render: () => null
+});
+j({
+  name: "Polygon",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: F,
+  setup(t, { emit: e }) {
+    const r = I(t, "options");
+    return { polygon: W("Polygon", F, r, e) };
+  },
+  render: () => null
+});
+const Se = F.concat(["bounds_changed"]);
+j({
+  name: "Rectangle",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: Se,
+  setup(t, { emit: e }) {
+    const r = I(t, "options");
+    return { rectangle: W("Rectangle", Se, r, e) };
+  },
+  render: () => null
+});
+const Ae = F.concat(["center_changed", "radius_changed"]);
+j({
+  name: "Circle",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: Ae,
+  setup(t, { emit: e }) {
+    const r = I(t, "options");
+    return { circle: W("Circle", Ae, r, e) };
+  },
+  render: () => null
+});
+j({
+  props: {
+    position: {
+      type: String,
+      required: !0
+    },
+    index: {
+      type: Number,
+      default: 1
+    }
+  },
+  emits: ["content:loaded"],
+  setup(t, { emit: e }) {
+    const r = b(null), o = O(z, b()), a = O(D, b()), n = O(Qe, b(!1)), i = P(
+      [n, a, r],
+      ([c, d, u]) => {
+        d && c && u && (l(t.position), e("content:loaded"), setTimeout(i, 0));
+      },
+      { immediate: !0 }
+    ), l = (c) => {
+      if (o.value && a.value && r.value) {
+        const d = a.value.ControlPosition[c];
+        r.value.index = t.index, o.value.controls[d].push(r.value);
+      }
+    }, s = (c) => {
+      if (o.value && a.value) {
+        let d = null;
+        const u = a.value.ControlPosition[c];
+        o.value.controls[u].forEach((m, p) => {
+          m === r.value && (d = p);
+        }), d !== null && o.value.controls[u].removeAt(d);
+      }
+    };
+    return Z(() => s(t.position)), P(
+      () => t.position,
+      (c, d) => {
+        s(d), l(c);
+      }
+    ), P(
+      () => t.index,
+      (c) => {
+        r.value && (r.value.index = c);
+      }
+    ), { controlRef: r };
+  }
+});
+const Te = [
+  "closeclick",
+  "content_changed",
+  "domready",
+  "position_changed",
+  "visible",
+  "zindex_changed"
+];
+j({
+  inheritAttrs: !1,
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    },
+    modelValue: {
+      type: Boolean
+    }
+  },
+  emits: [...Te, "update:modelValue"],
+  setup(t, { slots: e, emit: r, expose: o }) {
+    const a = b(), n = b(), i = O(z, b()), l = O(D, b()), s = O(ke, b());
+    let c, d = t.modelValue;
+    const u = V(() => {
+      var f;
+      return (f = e.default) == null ? void 0 : f.call(e).some((v) => v.type !== be);
+    }), m = (f) => {
+      d = f, r("update:modelValue", f);
+    }, p = (f) => {
+      a.value && (a.value.open({ map: i.value, anchor: s.value, ...f }), m(!0));
+    }, h = () => {
+      a.value && (a.value.close(), m(!1));
+    };
+    return Je(() => {
+      P(
+        [i, () => t.options],
+        ([f, v], [g, y]) => {
+          var M;
+          const x = !Y(v, y) || i.value !== g;
+          i.value && l.value && x && (a.value ? (a.value.setOptions({
+            ...v,
+            content: u.value ? n.value : v.content
+          }), s.value || p()) : (a.value = q(
+            new l.value.InfoWindow({
+              ...v,
+              content: u.value ? n.value : v.content
+            })
+          ), s.value && (c = s.value.addListener("click", () => p())), (!s.value || d) && p(), Te.forEach((C) => {
+            var k;
+            (k = a.value) == null || k.addListener(C, (w) => r(C, w));
+          }), (M = a.value) == null || M.addListener("closeclick", () => m(!1))));
+        },
+        {
+          immediate: !0,
+          flush: "post"
+        }
+      ), P(
+        s,
+        (f, v) => {
+          !a.value || f === v || (c && (c.remove(), c = void 0), f && (c = f.addListener("click", () => p())));
+        },
+        {
+          flush: "post"
+        }
+      ), P(
+        () => t.modelValue,
+        (f) => {
+          f !== d && (f ? p() : h());
+        }
+      );
+    }), Z(() => {
+      var f;
+      c && c.remove(), a.value && ((f = l.value) == null || f.event.clearInstanceListeners(a.value), h());
+    }), o({ infoWindow: a, open: p, close: h }), { infoWindow: a, infoWindowRef: n, hasSlotContent: u, open: p, close: h };
+  }
+});
+var Nt = Object.getOwnPropertyNames, Rt = Object.getOwnPropertySymbols, Bt = Object.prototype.hasOwnProperty;
+function Ie(t, e) {
+  return function(r, o, a) {
+    return t(r, o, a) && e(r, o, a);
+  };
+}
+function ee(t) {
+  return function(e, r, o) {
+    if (!e || !r || typeof e != "object" || typeof r != "object")
+      return t(e, r, o);
+    var a = o.cache, n = a.get(e), i = a.get(r);
+    if (n && i)
+      return n === r && i === e;
+    a.set(e, r), a.set(r, e);
+    var l = t(e, r, o);
+    return a.delete(e), a.delete(r), l;
+  };
+}
+function Ne(t) {
+  return Nt(t).concat(Rt(t));
+}
+var Zt = Object.hasOwn || function(t, e) {
+  return Bt.call(t, e);
+};
+function $(t, e) {
+  return t === e || !t && !e && t !== t && e !== e;
+}
+var zt = "__v", Dt = "__o", $t = "_owner", Re = Object.getOwnPropertyDescriptor, Be = Object.keys;
+function Ut(t, e, r) {
+  var o = t.length;
+  if (e.length !== o)
+    return !1;
+  for (; o-- > 0; )
+    if (!r.equals(t[o], e[o], o, o, t, e, r))
+      return !1;
+  return !0;
+}
+function Vt(t, e) {
+  return $(t.getTime(), e.getTime());
+}
+function Ft(t, e) {
+  return t.name === e.name && t.message === e.message && t.cause === e.cause && t.stack === e.stack;
+}
+function Wt(t, e) {
+  return t === e;
+}
+function Ze(t, e, r) {
+  var o = t.size;
+  if (o !== e.size)
+    return !1;
+  if (!o)
+    return !0;
+  for (var a = new Array(o), n = t.entries(), i, l, s = 0; (i = n.next()) && !i.done; ) {
+    for (var c = e.entries(), d = !1, u = 0; (l = c.next()) && !l.done; ) {
+      if (a[u]) {
+        u++;
+        continue;
+      }
+      var m = i.value, p = l.value;
+      if (r.equals(m[0], p[0], s, u, t, e, r) && r.equals(m[1], p[1], m[0], p[0], t, e, r)) {
+        d = a[u] = !0;
+        break;
+      }
+      u++;
+    }
+    if (!d)
+      return !1;
+    s++;
+  }
+  return !0;
+}
+var Gt = $;
+function Kt(t, e, r) {
+  var o = Be(t), a = o.length;
+  if (Be(e).length !== a)
+    return !1;
+  for (; a-- > 0; )
+    if (!tt(t, e, r, o[a]))
+      return !1;
+  return !0;
+}
+function G(t, e, r) {
+  var o = Ne(t), a = o.length;
+  if (Ne(e).length !== a)
+    return !1;
+  for (var n, i, l; a-- > 0; )
+    if (n = o[a], !tt(t, e, r, n) || (i = Re(t, n), l = Re(e, n), (i || l) && (!i || !l || i.configurable !== l.configurable || i.enumerable !== l.enumerable || i.writable !== l.writable)))
+      return !1;
+  return !0;
+}
+function Ht(t, e) {
+  return $(t.valueOf(), e.valueOf());
+}
+function Xt(t, e) {
+  return t.source === e.source && t.flags === e.flags;
+}
+function ze(t, e, r) {
+  var o = t.size;
+  if (o !== e.size)
+    return !1;
+  if (!o)
+    return !0;
+  for (var a = new Array(o), n = t.values(), i, l; (i = n.next()) && !i.done; ) {
+    for (var s = e.values(), c = !1, d = 0; (l = s.next()) && !l.done; ) {
+      if (!a[d] && r.equals(i.value, l.value, i.value, l.value, t, e, r)) {
+        c = a[d] = !0;
+        break;
+      }
+      d++;
+    }
+    if (!c)
+      return !1;
+  }
+  return !0;
+}
+function Yt(t, e) {
+  var r = t.length;
+  if (e.length !== r)
+    return !1;
+  for (; r-- > 0; )
+    if (t[r] !== e[r])
+      return !1;
+  return !0;
+}
+function Jt(t, e) {
+  return t.hostname === e.hostname && t.pathname === e.pathname && t.protocol === e.protocol && t.port === e.port && t.hash === e.hash && t.username === e.username && t.password === e.password;
+}
+function tt(t, e, r, o) {
+  return (o === $t || o === Dt || o === zt) && (t.$$typeof || e.$$typeof) ? !0 : Zt(e, o) && r.equals(t[o], e[o], o, o, t, e, r);
+}
+var Qt = "[object Arguments]", er = "[object Boolean]", tr = "[object Date]", rr = "[object Error]", or = "[object Map]", ar = "[object Number]", nr = "[object Object]", sr = "[object RegExp]", ir = "[object Set]", lr = "[object String]", ur = "[object URL]", cr = Array.isArray, De = typeof ArrayBuffer == "function" && ArrayBuffer.isView ? ArrayBuffer.isView : null, $e = Object.assign, pr = Object.prototype.toString.call.bind(Object.prototype.toString);
+function dr(t) {
+  var e = t.areArraysEqual, r = t.areDatesEqual, o = t.areErrorsEqual, a = t.areFunctionsEqual, n = t.areMapsEqual, i = t.areNumbersEqual, l = t.areObjectsEqual, s = t.arePrimitiveWrappersEqual, c = t.areRegExpsEqual, d = t.areSetsEqual, u = t.areTypedArraysEqual, m = t.areUrlsEqual;
+  return function(p, h, f) {
+    if (p === h)
+      return !0;
+    if (p == null || h == null)
+      return !1;
+    var v = typeof p;
+    if (v !== typeof h)
+      return !1;
+    if (v !== "object")
+      return v === "number" ? i(p, h, f) : v === "function" ? a(p, h, f) : !1;
+    var g = p.constructor;
+    if (g !== h.constructor)
+      return !1;
+    if (g === Object)
+      return l(p, h, f);
+    if (cr(p))
+      return e(p, h, f);
+    if (De != null && De(p))
+      return u(p, h, f);
+    if (g === Date)
+      return r(p, h, f);
+    if (g === RegExp)
+      return c(p, h, f);
+    if (g === Map)
+      return n(p, h, f);
+    if (g === Set)
+      return d(p, h, f);
+    var y = pr(p);
+    return y === tr ? r(p, h, f) : y === sr ? c(p, h, f) : y === or ? n(p, h, f) : y === ir ? d(p, h, f) : y === nr ? typeof p.then != "function" && typeof h.then != "function" && l(p, h, f) : y === ur ? m(p, h, f) : y === rr ? o(p, h, f) : y === Qt ? l(p, h, f) : y === er || y === ar || y === lr ? s(p, h, f) : !1;
+  };
+}
+function mr(t) {
+  var e = t.circular, r = t.createCustomConfig, o = t.strict, a = {
+    areArraysEqual: o ? G : Ut,
+    areDatesEqual: Vt,
+    areErrorsEqual: Ft,
+    areFunctionsEqual: Wt,
+    areMapsEqual: o ? Ie(Ze, G) : Ze,
+    areNumbersEqual: Gt,
+    areObjectsEqual: o ? G : Kt,
+    arePrimitiveWrappersEqual: Ht,
+    areRegExpsEqual: Xt,
+    areSetsEqual: o ? Ie(ze, G) : ze,
+    areTypedArraysEqual: o ? G : Yt,
+    areUrlsEqual: Jt
+  };
+  if (r && (a = $e({}, a, r(a))), e) {
+    var n = ee(a.areArraysEqual), i = ee(a.areMapsEqual), l = ee(a.areObjectsEqual), s = ee(a.areSetsEqual);
+    a = $e({}, a, {
+      areArraysEqual: n,
+      areMapsEqual: i,
+      areObjectsEqual: l,
+      areSetsEqual: s
+    });
+  }
+  return a;
+}
+function fr(t) {
+  return function(e, r, o, a, n, i, l) {
+    return t(e, r, l);
+  };
+}
+function hr(t) {
+  var e = t.circular, r = t.comparator, o = t.createState, a = t.equals, n = t.strict;
+  if (o)
+    return function(l, s) {
+      var c = o(), d = c.cache, u = d === void 0 ? e ? /* @__PURE__ */ new WeakMap() : void 0 : d, m = c.meta;
+      return r(l, s, {
+        cache: u,
+        equals: a,
+        meta: m,
+        strict: n
+      });
+    };
+  if (e)
+    return function(l, s) {
+      return r(l, s, {
+        cache: /* @__PURE__ */ new WeakMap(),
+        equals: a,
+        meta: void 0,
+        strict: n
+      });
+    };
+  var i = {
+    cache: void 0,
+    equals: a,
+    meta: void 0,
+    strict: n
+  };
+  return function(l, s) {
+    return r(l, s, i);
+  };
+}
+var oe = N();
+N({ strict: !0 });
+N({ circular: !0 });
+N({
+  circular: !0,
+  strict: !0
+});
+N({
+  createInternalComparator: function() {
+    return $;
+  }
+});
+N({
+  strict: !0,
+  createInternalComparator: function() {
+    return $;
+  }
+});
+N({
+  circular: !0,
+  createInternalComparator: function() {
+    return $;
+  }
+});
+N({
+  circular: !0,
+  createInternalComparator: function() {
+    return $;
+  },
+  strict: !0
+});
+function N(t) {
+  t === void 0 && (t = {});
+  var e = t.circular, r = e === void 0 ? !1 : e, o = t.createInternalComparator, a = t.createState, n = t.strict, i = n === void 0 ? !1 : n, l = mr(t), s = dr(l), c = o ? o(s) : fr(s);
+  return hr({ circular: r, comparator: s, createState: a, equals: c, strict: i });
+}
+const Ue = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array
+], le = 1, K = 8;
+class Ee {
+  /**
+   * Creates an index from raw `ArrayBuffer` data.
+   * @param {ArrayBuffer} data
+   */
+  static from(e) {
+    if (!(e instanceof ArrayBuffer))
+      throw new Error("Data must be an instance of ArrayBuffer.");
+    const [r, o] = new Uint8Array(e, 0, 2);
+    if (r !== 219)
+      throw new Error("Data does not appear to be in a KDBush format.");
+    const a = o >> 4;
+    if (a !== le)
+      throw new Error(`Got v${a} data when expected v${le}.`);
+    const n = Ue[o & 15];
+    if (!n)
+      throw new Error("Unrecognized array type.");
+    const [i] = new Uint16Array(e, 2, 1), [l] = new Uint32Array(e, 4, 1);
+    return new Ee(l, i, n, e);
+  }
+  /**
+   * 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(e, r = 64, o = Float64Array, a) {
+    if (isNaN(e) || e < 0)
+      throw new Error(`Unpexpected numItems value: ${e}.`);
+    this.numItems = +e, this.nodeSize = Math.min(Math.max(+r, 2), 65535), this.ArrayType = o, this.IndexArrayType = e < 65536 ? Uint16Array : Uint32Array;
+    const n = Ue.indexOf(this.ArrayType), i = e * 2 * this.ArrayType.BYTES_PER_ELEMENT, l = e * this.IndexArrayType.BYTES_PER_ELEMENT, s = (8 - l % 8) % 8;
+    if (n < 0)
+      throw new Error(`Unexpected typed array class: ${o}.`);
+    a && a instanceof ArrayBuffer ? (this.data = a, this.ids = new this.IndexArrayType(this.data, K, e), this.coords = new this.ArrayType(this.data, K + l + s, e * 2), this._pos = e * 2, this._finished = !0) : (this.data = new ArrayBuffer(K + i + l + s), this.ids = new this.IndexArrayType(this.data, K, e), this.coords = new this.ArrayType(this.data, K + l + s, e * 2), this._pos = 0, this._finished = !1, new Uint8Array(this.data, 0, 2).set([219, (le << 4) + n]), new Uint16Array(this.data, 2, 1)[0] = r, new Uint32Array(this.data, 4, 1)[0] = e);
+  }
+  /**
+   * 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(e, r) {
+    const o = this._pos >> 1;
+    return this.ids[o] = o, this.coords[this._pos++] = e, this.coords[this._pos++] = r, o;
+  }
+  /**
+   * Perform indexing of the added points.
+   */
+  finish() {
+    const e = this._pos >> 1;
+    if (e !== this.numItems)
+      throw new Error(`Added ${e} items when expected ${this.numItems}.`);
+    return ge(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(e, r, o, a) {
+    if (!this._finished)
+      throw new Error("Data not yet indexed - call index.finish().");
+    const { ids: n, coords: i, nodeSize: l } = this, s = [0, n.length - 1, 0], c = [];
+    for (; s.length; ) {
+      const d = s.pop() || 0, u = s.pop() || 0, m = s.pop() || 0;
+      if (u - m <= l) {
+        for (let v = m; v <= u; v++) {
+          const g = i[2 * v], y = i[2 * v + 1];
+          g >= e && g <= o && y >= r && y <= a && c.push(n[v]);
+        }
+        continue;
+      }
+      const p = m + u >> 1, h = i[2 * p], f = i[2 * p + 1];
+      h >= e && h <= o && f >= r && f <= a && c.push(n[p]), (d === 0 ? e <= h : r <= f) && (s.push(m), s.push(p - 1), s.push(1 - d)), (d === 0 ? o >= h : a >= f) && (s.push(p + 1), s.push(u), s.push(1 - d));
+    }
+    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(e, r, o) {
+    if (!this._finished)
+      throw new Error("Data not yet indexed - call index.finish().");
+    const { ids: a, coords: n, nodeSize: i } = this, l = [0, a.length - 1, 0], s = [], c = o * o;
+    for (; l.length; ) {
+      const d = l.pop() || 0, u = l.pop() || 0, m = l.pop() || 0;
+      if (u - m <= i) {
+        for (let v = m; v <= u; v++)
+          Ve(n[2 * v], n[2 * v + 1], e, r) <= c && s.push(a[v]);
+        continue;
+      }
+      const p = m + u >> 1, h = n[2 * p], f = n[2 * p + 1];
+      Ve(h, f, e, r) <= c && s.push(a[p]), (d === 0 ? e - o <= h : r - o <= f) && (l.push(m), l.push(p - 1), l.push(1 - d)), (d === 0 ? e + o >= h : r + o >= f) && (l.push(p + 1), l.push(u), l.push(1 - d));
+    }
+    return s;
+  }
+}
+function ge(t, e, r, o, a, n) {
+  if (a - o <= r)
+    return;
+  const i = o + a >> 1;
+  rt(t, e, i, o, a, n), ge(t, e, r, o, i - 1, 1 - n), ge(t, e, r, i + 1, a, 1 - n);
+}
+function rt(t, e, r, o, a, n) {
+  for (; a > o; ) {
+    if (a - o > 600) {
+      const c = a - o + 1, d = r - o + 1, u = Math.log(c), m = 0.5 * Math.exp(2 * u / 3), p = 0.5 * Math.sqrt(u * m * (c - m) / c) * (d - c / 2 < 0 ? -1 : 1), h = Math.max(o, Math.floor(r - d * m / c + p)), f = Math.min(a, Math.floor(r + (c - d) * m / c + p));
+      rt(t, e, r, h, f, n);
+    }
+    const i = e[2 * r + n];
+    let l = o, s = a;
+    for (H(t, e, o, r), e[2 * a + n] > i && H(t, e, o, a); l < s; ) {
+      for (H(t, e, l, s), l++, s--; e[2 * l + n] < i; )
+        l++;
+      for (; e[2 * s + n] > i; )
+        s--;
+    }
+    e[2 * o + n] === i ? H(t, e, o, s) : (s++, H(t, e, s, a)), s <= r && (o = s + 1), r <= s && (a = s - 1);
+  }
+}
+function H(t, e, r, o) {
+  ue(t, r, o), ue(e, 2 * r, 2 * o), ue(e, 2 * r + 1, 2 * o + 1);
+}
+function ue(t, e, r) {
+  const o = t[e];
+  t[e] = t[r], t[r] = o;
+}
+function Ve(t, e, r, o) {
+  const a = t - r, n = e - o;
+  return a * a + n * n;
+}
+const vr = {
+  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: (t) => t
+  // props => ({sum: props.my_value})
+}, Fe = Math.fround || /* @__PURE__ */ ((t) => (e) => (t[0] = +e, t[0]))(new Float32Array(1)), B = 2, A = 3, ce = 4, S = 5, ot = 6;
+class at {
+  constructor(e) {
+    this.options = Object.assign(Object.create(vr), e), this.trees = new Array(this.options.maxZoom + 1), this.stride = this.options.reduce ? 7 : 6, this.clusterProps = [];
+  }
+  load(e) {
+    const { log: r, minZoom: o, maxZoom: a } = this.options;
+    r && console.time("total time");
+    const n = `prepare ${e.length} points`;
+    r && console.time(n), this.points = e;
+    const i = [];
+    for (let s = 0; s < e.length; s++) {
+      const c = e[s];
+      if (!c.geometry)
+        continue;
+      const [d, u] = c.geometry.coordinates, m = Fe(te(d)), p = Fe(re(u));
+      i.push(
+        m,
+        p,
+        // 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 && i.push(0);
+    }
+    let l = this.trees[a + 1] = this._createTree(i);
+    r && console.timeEnd(n);
+    for (let s = a; s >= o; s--) {
+      const c = +Date.now();
+      l = this.trees[s] = this._createTree(this._cluster(l, s)), r && console.log("z%d: %d clusters in %dms", s, l.numItems, +Date.now() - c);
+    }
+    return r && console.timeEnd("total time"), this;
+  }
+  getClusters(e, r) {
+    let o = ((e[0] + 180) % 360 + 360) % 360 - 180;
+    const a = Math.max(-90, Math.min(90, e[1]));
+    let n = e[2] === 180 ? 180 : ((e[2] + 180) % 360 + 360) % 360 - 180;
+    const i = Math.max(-90, Math.min(90, e[3]));
+    if (e[2] - e[0] >= 360)
+      o = -180, n = 180;
+    else if (o > n) {
+      const u = this.getClusters([o, a, 180, i], r), m = this.getClusters([-180, a, n, i], r);
+      return u.concat(m);
+    }
+    const l = this.trees[this._limitZoom(r)], s = l.range(te(o), re(i), te(n), re(a)), c = l.data, d = [];
+    for (const u of s) {
+      const m = this.stride * u;
+      d.push(c[m + S] > 1 ? We(c, m, this.clusterProps) : this.points[c[m + A]]);
+    }
+    return d;
+  }
+  getChildren(e) {
+    const r = this._getOriginId(e), o = this._getOriginZoom(e), a = "No cluster with the specified id.", n = this.trees[o];
+    if (!n)
+      throw new Error(a);
+    const i = n.data;
+    if (r * this.stride >= i.length)
+      throw new Error(a);
+    const l = this.options.radius / (this.options.extent * Math.pow(2, o - 1)), s = i[r * this.stride], c = i[r * this.stride + 1], d = n.within(s, c, l), u = [];
+    for (const m of d) {
+      const p = m * this.stride;
+      i[p + ce] === e && u.push(i[p + S] > 1 ? We(i, p, this.clusterProps) : this.points[i[p + A]]);
+    }
+    if (u.length === 0)
+      throw new Error(a);
+    return u;
+  }
+  getLeaves(e, r, o) {
+    r = r || 10, o = o || 0;
+    const a = [];
+    return this._appendLeaves(a, e, r, o, 0), a;
+  }
+  getTile(e, r, o) {
+    const a = this.trees[this._limitZoom(e)], n = Math.pow(2, e), { extent: i, radius: l } = this.options, s = l / i, c = (o - s) / n, d = (o + 1 + s) / n, u = {
+      features: []
+    };
+    return this._addTileFeatures(
+      a.range((r - s) / n, c, (r + 1 + s) / n, d),
+      a.data,
+      r,
+      o,
+      n,
+      u
+    ), r === 0 && this._addTileFeatures(
+      a.range(1 - s / n, c, 1, d),
+      a.data,
+      n,
+      o,
+      n,
+      u
+    ), r === n - 1 && this._addTileFeatures(
+      a.range(0, c, s / n, d),
+      a.data,
+      -1,
+      o,
+      n,
+      u
+    ), u.features.length ? u : null;
+  }
+  getClusterExpansionZoom(e) {
+    let r = this._getOriginZoom(e) - 1;
+    for (; r <= this.options.maxZoom; ) {
+      const o = this.getChildren(e);
+      if (r++, o.length !== 1)
+        break;
+      e = o[0].properties.cluster_id;
+    }
+    return r;
+  }
+  _appendLeaves(e, r, o, a, n) {
+    const i = this.getChildren(r);
+    for (const l of i) {
+      const s = l.properties;
+      if (s && s.cluster ? n + s.point_count <= a ? n += s.point_count : n = this._appendLeaves(e, s.cluster_id, o, a, n) : n < a ? n++ : e.push(l), e.length === o)
+        break;
+    }
+    return n;
+  }
+  _createTree(e) {
+    const r = new Ee(e.length / this.stride | 0, this.options.nodeSize, Float32Array);
+    for (let o = 0; o < e.length; o += this.stride)
+      r.add(e[o], e[o + 1]);
+    return r.finish(), r.data = e, r;
+  }
+  _addTileFeatures(e, r, o, a, n, i) {
+    for (const l of e) {
+      const s = l * this.stride, c = r[s + S] > 1;
+      let d, u, m;
+      if (c)
+        d = nt(r, s, this.clusterProps), u = r[s], m = r[s + 1];
+      else {
+        const f = this.points[r[s + A]];
+        d = f.properties;
+        const [v, g] = f.geometry.coordinates;
+        u = te(v), m = re(g);
+      }
+      const p = {
+        type: 1,
+        geometry: [[
+          Math.round(this.options.extent * (u * n - o)),
+          Math.round(this.options.extent * (m * n - a))
+        ]],
+        tags: d
+      };
+      let h;
+      c || this.options.generateId ? h = r[s + A] : h = this.points[r[s + A]].id, h !== void 0 && (p.id = h), i.features.push(p);
+    }
+  }
+  _limitZoom(e) {
+    return Math.max(this.options.minZoom, Math.min(Math.floor(+e), this.options.maxZoom + 1));
+  }
+  _cluster(e, r) {
+    const { radius: o, extent: a, reduce: n, minPoints: i } = this.options, l = o / (a * Math.pow(2, r)), s = e.data, c = [], d = this.stride;
+    for (let u = 0; u < s.length; u += d) {
+      if (s[u + B] <= r)
+        continue;
+      s[u + B] = r;
+      const m = s[u], p = s[u + 1], h = e.within(s[u], s[u + 1], l), f = s[u + S];
+      let v = f;
+      for (const g of h) {
+        const y = g * d;
+        s[y + B] > r && (v += s[y + S]);
+      }
+      if (v > f && v >= i) {
+        let g = m * f, y = p * f, M, x = -1;
+        const C = ((u / d | 0) << 5) + (r + 1) + this.points.length;
+        for (const k of h) {
+          const w = k * d;
+          if (s[w + B] <= r)
+            continue;
+          s[w + B] = r;
+          const _ = s[w + S];
+          g += s[w] * _, y += s[w + 1] * _, s[w + ce] = C, n && (M || (M = this._map(s, u, !0), x = this.clusterProps.length, this.clusterProps.push(M)), n(M, this._map(s, w)));
+        }
+        s[u + ce] = C, c.push(g / v, y / v, 1 / 0, C, -1, v), n && c.push(x);
+      } else {
+        for (let g = 0; g < d; g++)
+          c.push(s[u + g]);
+        if (v > 1)
+          for (const g of h) {
+            const y = g * d;
+            if (!(s[y + B] <= r)) {
+              s[y + B] = r;
+              for (let M = 0; M < d; M++)
+                c.push(s[y + M]);
+            }
+          }
+      }
+    }
+    return c;
+  }
+  // get index of the point from which the cluster originated
+  _getOriginId(e) {
+    return e - this.points.length >> 5;
+  }
+  // get zoom of the point from which the cluster originated
+  _getOriginZoom(e) {
+    return (e - this.points.length) % 32;
+  }
+  _map(e, r, o) {
+    if (e[r + S] > 1) {
+      const i = this.clusterProps[e[r + ot]];
+      return o ? Object.assign({}, i) : i;
+    }
+    const a = this.points[e[r + A]].properties, n = this.options.map(a);
+    return o && n === a ? Object.assign({}, n) : n;
+  }
+}
+function We(t, e, r) {
+  return {
+    type: "Feature",
+    id: t[e + A],
+    properties: nt(t, e, r),
+    geometry: {
+      type: "Point",
+      coordinates: [gr(t[e]), yr(t[e + 1])]
+    }
+  };
+}
+function nt(t, e, r) {
+  const o = t[e + S], a = o >= 1e4 ? `${Math.round(o / 1e3)}k` : o >= 1e3 ? `${Math.round(o / 100) / 10}k` : o, n = t[e + ot], i = n === -1 ? {} : Object.assign({}, r[n]);
+  return Object.assign(i, {
+    cluster: !0,
+    cluster_id: t[e + A],
+    point_count: o,
+    point_count_abbreviated: a
+  });
+}
+function te(t) {
+  return t / 360 + 0.5;
+}
+function re(t) {
+  const e = Math.sin(t * Math.PI / 180), r = 0.5 - 0.25 * Math.log((1 + e) / (1 - e)) / Math.PI;
+  return r < 0 ? 0 : r > 1 ? 1 : r;
+}
+function gr(t) {
+  return (t - 0.5) * 360;
+}
+function yr(t) {
+  const e = (180 - t * 360) * Math.PI / 180;
+  return 360 * Math.atan(Math.exp(e)) / Math.PI - 90;
+}
+function Oe(t, e) {
+  var r = {};
+  for (var o in t)
+    Object.prototype.hasOwnProperty.call(t, o) && e.indexOf(o) < 0 && (r[o] = t[o]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var a = 0, o = Object.getOwnPropertySymbols(t); a < o.length; a++)
+      e.indexOf(o[a]) < 0 && Object.prototype.propertyIsEnumerable.call(t, o[a]) && (r[o[a]] = t[o[a]]);
+  return r;
+}
+class E {
+  static isAdvancedMarkerAvailable(e) {
+    return google.maps.marker && e.getMapCapabilities().isAdvancedMarkersAvailable === !0;
+  }
+  static isAdvancedMarker(e) {
+    return google.maps.marker && e instanceof google.maps.marker.AdvancedMarkerElement;
+  }
+  static setMap(e, r) {
+    this.isAdvancedMarker(e) ? e.map = r : e.setMap(r);
+  }
+  static getPosition(e) {
+    if (this.isAdvancedMarker(e)) {
+      if (e.position) {
+        if (e.position instanceof google.maps.LatLng)
+          return e.position;
+        if (Number.isFinite(e.position.lat) && Number.isFinite(e.position.lng))
+          return new google.maps.LatLng(e.position.lat, e.position.lng);
+      }
+      return new google.maps.LatLng(null);
+    }
+    return e.getPosition();
+  }
+  static getVisible(e) {
+    return this.isAdvancedMarker(e) ? !0 : e.getVisible();
+  }
+}
+class J {
+  constructor({ markers: e, position: r }) {
+    this.markers = [], e && (this.markers = e), r && (r instanceof google.maps.LatLng ? this._position = r : this._position = new google.maps.LatLng(r));
+  }
+  get bounds() {
+    if (this.markers.length === 0 && !this._position)
+      return;
+    const e = new google.maps.LatLngBounds(this._position, this._position);
+    for (const r of this.markers)
+      e.extend(E.getPosition(r));
+    return e;
+  }
+  get position() {
+    return this._position || this.bounds.getCenter();
+  }
+  /**
+   * Get the count of **visible** markers.
+   */
+  get count() {
+    return this.markers.filter((e) => E.getVisible(e)).length;
+  }
+  /**
+   * Add a marker to the cluster.
+   */
+  push(e) {
+    this.markers.push(e);
+  }
+  /**
+   * Cleanup references and remove marker from map.
+   */
+  delete() {
+    this.marker && (E.setMap(this.marker, null), this.marker = void 0), this.markers.length = 0;
+  }
+}
+function L(t, e = "assertion failed") {
+  if (t == null)
+    throw Error(e);
+}
+const br = (t, e, r, o) => {
+  const a = t.getBounds();
+  L(a);
+  const n = st(a, e, o);
+  return r.filter((i) => n.contains(E.getPosition(i)));
+}, st = (t, e, r) => {
+  const { northEast: o, southWest: a } = wr(t, e), n = Mr({ northEast: o, southWest: a }, r);
+  return Er(n, e);
+}, kr = (t, e, r) => {
+  const o = st(t, e, r), a = o.getNorthEast(), n = o.getSouthWest();
+  return [n.lng(), n.lat(), a.lng(), a.lat()];
+}, wr = (t, e) => {
+  const r = e.fromLatLngToDivPixel(t.getNorthEast()), o = e.fromLatLngToDivPixel(t.getSouthWest());
+  return L(r), L(o), { northEast: r, southWest: o };
+}, Mr = ({ northEast: t, southWest: e }, r) => (t.x += r, t.y -= r, e.x -= r, e.y += r, { northEast: t, southWest: e }), Er = ({ northEast: t, southWest: e }, r) => {
+  const o = r.fromDivPixelToLatLng(e), a = r.fromDivPixelToLatLng(t);
+  return new google.maps.LatLngBounds(o, a);
+};
+class it {
+  constructor({ maxZoom: e = 16 }) {
+    this.maxZoom = e;
+  }
+  /**
+   * Helper function to bypass clustering based upon some map state such as
+   * zoom, number of markers, etc.
+   *
+   * ```typescript
+   *  cluster({markers, map}: AlgorithmInput): Cluster[] {
+   *    if (shouldBypassClustering(map)) {
+   *      return this.noop({markers})
+   *    }
+   * }
+   * ```
+   */
+  noop({ markers: e }) {
+    return Cr(e);
+  }
+}
+class Or extends it {
+  constructor(e) {
+    var { viewportPadding: r = 60 } = e, o = Oe(e, ["viewportPadding"]);
+    super(o), this.viewportPadding = 60, this.viewportPadding = r;
+  }
+  calculate({ markers: e, map: r, mapCanvasProjection: o }) {
+    const a = r.getZoom();
+    return L(a), a >= this.maxZoom ? {
+      clusters: this.noop({
+        markers: e
+      }),
+      changed: !1
+    } : {
+      clusters: this.cluster({
+        markers: br(r, o, e, this.viewportPadding),
+        map: r,
+        mapCanvasProjection: o
+      })
+    };
+  }
+}
+const Cr = (t) => t.map((e) => new J({
+  position: E.getPosition(e),
+  markers: [e]
+}));
+class xr extends it {
+  constructor(e) {
+    var { maxZoom: r, radius: o = 60 } = e, a = Oe(e, ["maxZoom", "radius"]);
+    super({ maxZoom: r }), this.markers = [], this.clusters = [], this.state = { zoom: -1 }, this.superCluster = new at(Object.assign({ maxZoom: this.maxZoom, radius: o }, a));
+  }
+  calculate(e) {
+    let r = !1, o = e.map.getZoom();
+    L(o), o = Math.round(o);
+    const a = { zoom: o };
+    if (!oe(e.markers, this.markers)) {
+      r = !0, this.markers = [...e.markers];
+      const n = this.markers.map((i) => {
+        const l = E.getPosition(i);
+        return {
+          type: "Feature",
+          geometry: { type: "Point", coordinates: [l.lng(), l.lat()] },
+          properties: { marker: i }
+        };
+      });
+      this.superCluster.load(n);
+    }
+    return r || (this.state.zoom <= this.maxZoom || a.zoom <= this.maxZoom) && (r = !oe(this.state, a)), this.state = a, e.markers.length === 0 ? (this.clusters = [], { clusters: this.clusters, changed: r }) : (r && (this.clusters = this.cluster(e)), { clusters: this.clusters, changed: r });
+  }
+  cluster({ map: e }) {
+    const r = e.getZoom();
+    return L(r), this.superCluster.getClusters([-180, -90, 180, 90], Math.round(r)).map((o) => this.transformCluster(o));
+  }
+  transformCluster({ geometry: { coordinates: [e, r] }, properties: o }) {
+    if (o.cluster)
+      return new J({
+        markers: this.superCluster.getLeaves(o.cluster_id, 1 / 0).map((n) => n.properties.marker),
+        position: { lat: r, lng: e }
+      });
+    const a = o.marker;
+    return new J({
+      markers: [a],
+      position: E.getPosition(a)
+    });
+  }
+}
+class _r extends Or {
+  constructor(e) {
+    var { maxZoom: r, radius: o = 60, viewportPadding: a = 60 } = e, n = Oe(e, ["maxZoom", "radius", "viewportPadding"]);
+    super({ maxZoom: r, viewportPadding: a }), this.markers = [], this.clusters = [], this.superCluster = new at(Object.assign({ maxZoom: this.maxZoom, radius: o }, n)), this.state = { zoom: -1, view: [0, 0, 0, 0] };
+  }
+  calculate(e) {
+    const r = this.getViewportState(e);
+    let o = !oe(this.state, r);
+    if (!oe(e.markers, this.markers)) {
+      o = !0, this.markers = [...e.markers];
+      const a = this.markers.map((n) => {
+        const i = E.getPosition(n);
+        return {
+          type: "Feature",
+          geometry: {
+            type: "Point",
+            coordinates: [i.lng(), i.lat()]
+          },
+          properties: { marker: n }
+        };
+      });
+      this.superCluster.load(a);
+    }
+    return o && (this.clusters = this.cluster(e), this.state = r), { clusters: this.clusters, changed: o };
+  }
+  cluster(e) {
+    const r = this.getViewportState(e);
+    return this.superCluster.getClusters(r.view, r.zoom).map((o) => this.transformCluster(o));
+  }
+  transformCluster({ geometry: { coordinates: [e, r] }, properties: o }) {
+    if (o.cluster)
+      return new J({
+        markers: this.superCluster.getLeaves(o.cluster_id, 1 / 0).map((n) => n.properties.marker),
+        position: { lat: r, lng: e }
+      });
+    const a = o.marker;
+    return new J({
+      markers: [a],
+      position: E.getPosition(a)
+    });
+  }
+  getViewportState(e) {
+    const r = e.map.getZoom(), o = e.map.getBounds();
+    return L(r), L(o), {
+      zoom: Math.round(r),
+      view: kr(o, e.mapCanvasProjection, this.viewportPadding)
+    };
+  }
+}
+class Pr {
+  constructor(e, r) {
+    this.markers = { sum: e.length };
+    const o = r.map((n) => n.count), a = o.reduce((n, i) => n + i, 0);
+    this.clusters = {
+      count: r.length,
+      markers: {
+        mean: a / r.length,
+        sum: a,
+        min: Math.min(...o),
+        max: Math.max(...o)
+      }
+    };
+  }
+}
+class jr {
+  /**
+   * The default render function for the library used by {@link MarkerClusterer}.
+   *
+   * Currently set to use the following:
+   *
+   * ```typescript
+   * // change color if this cluster has more markers than the mean cluster
+   * const color =
+   *   count > Math.max(10, stats.clusters.markers.mean)
+   *     ? "#ff0000"
+   *     : "#0000ff";
+   *
+   * // create svg url with fill color
+   * const svg = window.btoa(`
+   * <svg fill="${color}" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 240 240">
+   *   <circle cx="120" cy="120" opacity=".6" r="70" />
+   *   <circle cx="120" cy="120" opacity=".3" r="90" />
+   *   <circle cx="120" cy="120" opacity=".2" r="110" />
+   *   <circle cx="120" cy="120" opacity=".1" r="130" />
+   * </svg>`);
+   *
+   * // create marker using svg icon
+   * return new google.maps.Marker({
+   *   position,
+   *   icon: {
+   *     url: `data:image/svg+xml;base64,${svg}`,
+   *     scaledSize: new google.maps.Size(45, 45),
+   *   },
+   *   label: {
+   *     text: String(count),
+   *     color: "rgba(255,255,255,0.9)",
+   *     fontSize: "12px",
+   *   },
+   *   // adjust zIndex to be above other markers
+   *   zIndex: 1000 + count,
+   * });
+   * ```
+   */
+  render({ count: e, position: r }, o, a) {
+    const n = `<svg fill="${e > Math.max(10, o.clusters.markers.mean) ? "#ff0000" : "#0000ff"}" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 240 240" width="50" height="50">
+<circle cx="120" cy="120" opacity=".6" r="70" />
+<circle cx="120" cy="120" opacity=".3" r="90" />
+<circle cx="120" cy="120" opacity=".2" r="110" />
+<text x="50%" y="50%" style="fill:#fff" text-anchor="middle" font-size="50" dominant-baseline="middle" font-family="roboto,arial,sans-serif">${e}</text>
+</svg>`, i = `Cluster of ${e} markers`, l = Number(google.maps.Marker.MAX_ZINDEX) + e;
+    if (E.isAdvancedMarkerAvailable(a)) {
+      const c = new DOMParser().parseFromString(n, "image/svg+xml").documentElement;
+      c.setAttribute("transform", "translate(0 25)");
+      const d = {
+        map: a,
+        position: r,
+        zIndex: l,
+        title: i,
+        content: c
+      };
+      return new google.maps.marker.AdvancedMarkerElement(d);
+    }
+    const s = {
+      position: r,
+      zIndex: l,
+      title: i,
+      icon: {
+        url: `data:image/svg+xml;base64,${btoa(n)}`,
+        anchor: new google.maps.Point(25, 25)
+      }
+    };
+    return new google.maps.Marker(s);
+  }
+}
+function qr(t, e) {
+  for (let r in e.prototype)
+    t.prototype[r] = e.prototype[r];
+}
+class Ce {
+  constructor() {
+    qr(Ce, google.maps.OverlayView);
+  }
+}
+var T;
+(function(t) {
+  t.CLUSTERING_BEGIN = "clusteringbegin", t.CLUSTERING_END = "clusteringend", t.CLUSTER_CLICK = "click", t.GMP_CLICK = "gmp-click";
+})(T || (T = {}));
+const Lr = (t, e, r) => {
+  e.bounds && r.fitBounds(e.bounds);
+};
+class Sr extends Ce {
+  constructor({ map: e, markers: r = [], algorithmOptions: o = {}, algorithm: a = new xr(o), renderer: n = new jr(), onClusterClick: i = Lr }) {
+    super(), this.map = null, this.idleListener = null, this.markers = [...r], this.clusters = [], this.algorithm = a, this.renderer = n, this.onClusterClick = i, e && this.setMap(e);
+  }
+  addMarker(e, r) {
+    this.markers.includes(e) || (this.markers.push(e), r || this.render());
+  }
+  addMarkers(e, r) {
+    e.forEach((o) => {
+      this.addMarker(o, !0);
+    }), r || this.render();
+  }
+  removeMarker(e, r) {
+    const o = this.markers.indexOf(e);
+    return o === -1 ? !1 : (E.setMap(e, null), this.markers.splice(o, 1), r || this.render(), !0);
+  }
+  removeMarkers(e, r) {
+    let o = !1;
+    return e.forEach((a) => {
+      o = this.removeMarker(a, !0) || o;
+    }), o && !r && this.render(), o;
+  }
+  clearMarkers(e) {
+    this.markers.length = 0, e || this.render();
+  }
+  /**
+   * Recalculates and draws all the marker clusters.
+   */
+  render() {
+    const e = this.getMap();
+    if (e instanceof google.maps.Map && e.getProjection()) {
+      google.maps.event.trigger(this, T.CLUSTERING_BEGIN, this);
+      const { clusters: r, changed: o } = this.algorithm.calculate({
+        markers: this.markers,
+        map: e,
+        mapCanvasProjection: this.getProjection()
+      });
+      if (o || o == null) {
+        const a = /* @__PURE__ */ new Set();
+        for (const i of r)
+          i.markers.length == 1 && a.add(i.markers[0]);
+        const n = [];
+        for (const i of this.clusters)
+          i.marker != null && (i.markers.length == 1 ? a.has(i.marker) || E.setMap(i.marker, null) : n.push(i.marker));
+        this.clusters = r, this.renderClusters(), requestAnimationFrame(() => n.forEach((i) => E.setMap(i, null)));
+      }
+      google.maps.event.trigger(this, T.CLUSTERING_END, this);
+    }
+  }
+  onAdd() {
+    const e = this.getMap();
+    L(e), this.idleListener = e.addListener("idle", this.render.bind(this)), this.render();
+  }
+  onRemove() {
+    this.idleListener && google.maps.event.removeListener(this.idleListener), this.reset();
+  }
+  reset() {
+    this.markers.forEach((e) => E.setMap(e, null)), this.clusters.forEach((e) => e.delete()), this.clusters = [];
+  }
+  renderClusters() {
+    const e = new Pr(this.markers, this.clusters), r = this.getMap();
+    this.clusters.forEach((o) => {
+      if (o.markers.length === 1)
+        o.marker = o.markers[0];
+      else if (o.marker = this.renderer.render(o, e, r), o.markers.forEach((a) => E.setMap(a, null)), this.onClusterClick) {
+        const a = E.isAdvancedMarker(o.marker) ? T.GMP_CLICK : T.CLUSTER_CLICK;
+        o.marker.addListener(
+          a,
+          /* istanbul ignore next */
+          (n) => {
+            google.maps.event.trigger(this, T.CLUSTER_CLICK, o), this.onClusterClick(n, o, r);
+          }
+        );
+      }
+      E.setMap(o.marker, r);
+    });
+  }
+}
+function ye(t) {
+  var e = typeof t;
+  return t != null && (e == "object" || e == "function");
+}
+var Ar = typeof global == "object" && global && global.Object === Object && global;
+const Tr = Ar;
+var Ir = typeof self == "object" && self && self.Object === Object && self, Nr = Tr || Ir || Function("return this")();
+const lt = Nr;
+var Rr = function() {
+  return lt.Date.now();
+};
+const pe = Rr;
+var Br = /\s/;
+function Zr(t) {
+  for (var e = t.length; e-- && Br.test(t.charAt(e)); )
+    ;
+  return e;
+}
+var zr = /^\s+/;
+function Dr(t) {
+  return t && t.slice(0, Zr(t) + 1).replace(zr, "");
+}
+var $r = lt.Symbol;
+const ae = $r;
+var ut = Object.prototype, Ur = ut.hasOwnProperty, Vr = ut.toString, X = ae ? ae.toStringTag : void 0;
+function Fr(t) {
+  var e = Ur.call(t, X), r = t[X];
+  try {
+    t[X] = void 0;
+    var o = !0;
+  } catch {
+  }
+  var a = Vr.call(t);
+  return o && (e ? t[X] = r : delete t[X]), a;
+}
+var Wr = Object.prototype, Gr = Wr.toString;
+function Kr(t) {
+  return Gr.call(t);
+}
+var Hr = "[object Null]", Xr = "[object Undefined]", Ge = ae ? ae.toStringTag : void 0;
+function Yr(t) {
+  return t == null ? t === void 0 ? Xr : Hr : Ge && Ge in Object(t) ? Fr(t) : Kr(t);
+}
+function Jr(t) {
+  return t != null && typeof t == "object";
+}
+var Qr = "[object Symbol]";
+function eo(t) {
+  return typeof t == "symbol" || Jr(t) && Yr(t) == Qr;
+}
+var Ke = NaN, to = /^[-+]0x[0-9a-f]+$/i, ro = /^0b[01]+$/i, oo = /^0o[0-7]+$/i, ao = parseInt;
+function He(t) {
+  if (typeof t == "number")
+    return t;
+  if (eo(t))
+    return Ke;
+  if (ye(t)) {
+    var e = typeof t.valueOf == "function" ? t.valueOf() : t;
+    t = ye(e) ? e + "" : e;
+  }
+  if (typeof t != "string")
+    return t === 0 ? t : +t;
+  t = Dr(t);
+  var r = ro.test(t);
+  return r || oo.test(t) ? ao(t.slice(2), r ? 2 : 8) : to.test(t) ? Ke : +t;
+}
+var no = "Expected a function", so = Math.max, io = Math.min;
+function lo(t, e, r) {
+  var o, a, n, i, l, s, c = 0, d = !1, u = !1, m = !0;
+  if (typeof t != "function")
+    throw new TypeError(no);
+  e = He(e) || 0, ye(r) && (d = !0, u = "maxWait" in r, n = u ? so(He(r.maxWait) || 0, e) : n, m = "trailing" in r ? !0 : m);
+  function p(k) {
+    var w = o, _ = a;
+    return o = a = void 0, c = k, i = t.apply(_, w), i;
+  }
+  function h(k) {
+    return c = k, l = setTimeout(g, e), d ? p(k) : i;
+  }
+  function f(k) {
+    var w = k - s, _ = k - c, R = e - w;
+    return u ? io(R, n - _) : R;
+  }
+  function v(k) {
+    var w = k - s, _ = k - c;
+    return s === void 0 || w >= e || w < 0 || u && _ >= n;
+  }
+  function g() {
+    var k = pe();
+    if (v(k))
+      return y(k);
+    l = setTimeout(g, f(k));
+  }
+  function y(k) {
+    return l = void 0, m && o ? p(k) : (o = a = void 0, i);
+  }
+  function M() {
+    l !== void 0 && clearTimeout(l), c = 0, o = s = a = l = void 0;
+  }
+  function x() {
+    return l === void 0 ? i : y(pe());
+  }
+  function C() {
+    var k = pe(), w = v(k);
+    if (o = arguments, a = this, s = k, w) {
+      if (l === void 0)
+        return h(s);
+      if (u)
+        return clearTimeout(l), l = setTimeout(g, e), p(s);
+    }
+    return l === void 0 && (l = setTimeout(g, e)), i;
+  }
+  return C.cancel = M, C.flush = x, C;
+}
+class uo extends Sr {
+  constructor(e, r = 10) {
+    super(e), he(this, "debouncedRender"), this.debouncedRender = lo(
+      () => {
+        super.render();
+      },
+      r,
+      { leading: !0, trailing: !0 }
+    );
+  }
+  addMarker(e, r) {
+    super.addMarker(e, !0), r || this.debouncedRender();
+  }
+  removeMarker(e, r) {
+    const o = super.removeMarker(e, !0);
+    return r || this.debouncedRender(), o;
+  }
+  addMarkers(e, r) {
+    super.addMarkers(e, !0), r || this.debouncedRender();
+  }
+  removeMarkers(e, r) {
+    const o = super.removeMarkers(e, !0);
+    return r || this.debouncedRender(), o;
+  }
+  clearMarkers(e) {
+    super.clearMarkers(!0), e || this.debouncedRender();
+  }
+  /** Renders immediately, canceling any pending debounced render. */
+  render() {
+    this.debouncedRender.cancel(), super.render();
+  }
+  destroy() {
+    this.debouncedRender.cancel();
+  }
+}
+const Xe = Object.values(T);
+j({
+  name: "MarkerCluster",
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    },
+    renderDebounceDelay: {
+      type: Number,
+      default: 10
+    }
+  },
+  emits: Xe,
+  setup(t, { emit: e, expose: r, slots: o }) {
+    const a = b(), n = O(z, b()), i = O(D, b());
+    return U(we, a), P(
+      n,
+      () => {
+        n.value && (a.value = q(
+          new uo(
+            {
+              map: n.value,
+              // Better perf than the default `SuperClusterAlgorithm`. See:
+              // https://github.com/googlemaps/js-markerclusterer/pull/640
+              algorithm: new _r(t.options.algorithmOptions ?? {}),
+              ...t.options
+            },
+            t.renderDebounceDelay
+          )
+        ), Xe.forEach((l) => {
+          var s;
+          (s = a.value) == null || s.addListener(l, (c) => e(l, c));
+        }));
+      },
+      {
+        immediate: !0
+      }
+    ), Z(() => {
+      var l;
+      a.value && ((l = i.value) == null || l.event.clearInstanceListeners(a.value), a.value.clearMarkers(!0), a.value.setMap(null), a.value.destroy());
+    }), r({ markerCluster: a }), () => {
+      var l;
+      return (l = o.default) == null ? void 0 : l.call(o);
+    };
+  }
+});
+j({
+  inheritAttrs: !1,
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  setup(t, { slots: e, emit: r, expose: o }) {
+    const a = b(), n = V(() => {
+      var s;
+      return (s = e.default) == null ? void 0 : s.call(e).some((c) => c.type !== be);
+    }), i = V(() => ({
+      ...t.options,
+      element: a.value
+    })), l = W(ne, [], i, r);
+    return o({
+      customMarker: l
+    }), { customMarkerRef: a, customMarker: l, hasSlotContent: n };
+  }
+});
+j({
+  name: "HeatmapLayer",
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(t) {
+    const e = b(), r = O(z, b()), o = O(D, b());
+    return P(
+      [r, () => t.options],
+      ([a, n], [i, l]) => {
+        const s = !Y(n, l) || r.value !== i;
+        if (r.value && o.value && s) {
+          let c;
+          if (n.data && !(n.data instanceof o.value.MVCArray)) {
+            const d = o.value.LatLng, u = n.data.map((m) => m instanceof d || "location" in m && (m.location instanceof d || m.location === null) ? m : "location" in m ? { ...m, location: new d(m.location) } : new d(m));
+            c = {
+              ...n,
+              data: u
+            };
+          } else
+            c = n;
+          e.value ? e.value.setOptions(c) : e.value = q(
+            new o.value.visualization.HeatmapLayer({
+              ...c,
+              map: r.value
+            })
+          );
+        }
+      },
+      { immediate: !0 }
+    ), Z(() => {
+      e.value && e.value.setMap(null);
+    }), { heatmapLayer: e };
+  },
+  render: () => null
+});
+export {
+  mo as AdvancedMarker,
+  po as GoogleMap,
+  fo as Marker,
+  D as apiSymbol,
+  z as mapSymbol,
+  Qe as mapTilesLoadedSymbol
+};
+//# sourceMappingURL=index-Dca39bYA.js.map