vue3-google-map 0.15.0 → 0.17.0

package/dist/index.es.js

@@ -0,0 +1,1767 @@
+(function(){"use strict";try{if(typeof document<"u"){var d=document.createElement("style");d.appendChild(document.createTextNode(".mapdiv[data-v-7d660dd5]{width:100%;height:100%}.info-window-wrapper[data-v-45a4606d]{display:none}.mapdiv .info-window-wrapper[data-v-45a4606d]{display:inline-block}.custom-marker-wrapper[data-v-c7599d50]{display:none}.mapdiv .custom-marker-wrapper[data-v-c7599d50]{display:inline-block}")),document.head.appendChild(d)}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}})();
+var Be = Object.defineProperty;
+var qe = (o, e, t) => e in o ? Be(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var te = (o, e, t) => (qe(o, typeof e != "symbol" ? e + "" : e, t), t);
+import { defineComponent as M, ref as v, provide as z, watch as O, onMounted as Me, onBeforeUnmount as j, markRaw as E, toRef as B, openBlock as J, createElementBlock as Y, createElementVNode as ie, renderSlot as X, normalizeProps as Re, guardReactiveProps as Ze, inject as _, computed as K, withDirectives as Ne, vShow as Fe, Comment as be, mergeProps as Oe, createCommentVNode as Pe } from "vue";
+const q = Symbol("map"), R = Symbol("api"), xe = Symbol("marker"), Ee = Symbol("markerCluster"), Q = Symbol("CustomMarker"), Le = Symbol("mapTilesLoaded"), $ = [
+  "click",
+  "dblclick",
+  "drag",
+  "dragend",
+  "dragstart",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "rightclick"
+];
+var De = function o(e, t) {
+  if (e === t)
+    return !0;
+  if (e && t && typeof e == "object" && typeof t == "object") {
+    if (e.constructor !== t.constructor)
+      return !1;
+    var s, r, n;
+    if (Array.isArray(e)) {
+      if (s = e.length, s != t.length)
+        return !1;
+      for (r = s; r-- !== 0; )
+        if (!o(e[r], t[r]))
+          return !1;
+      return !0;
+    }
+    if (e.constructor === RegExp)
+      return e.source === t.source && e.flags === t.flags;
+    if (e.valueOf !== Object.prototype.valueOf)
+      return e.valueOf() === t.valueOf();
+    if (e.toString !== Object.prototype.toString)
+      return e.toString() === t.toString();
+    if (n = Object.keys(e), s = n.length, s !== Object.keys(t).length)
+      return !1;
+    for (r = s; r-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(t, n[r]))
+        return !1;
+    for (r = s; r-- !== 0; ) {
+      var a = n[r];
+      if (!o(e[a], t[a]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+};
+const ue = "__googleMapsScriptId";
+class S {
+  /**
+   * Creates an instance of Loader using [[LoaderOptions]]. No defaults are set
+   * using this library, instead the defaults are set by the Google Maps
+   * JavaScript API server.
+   *
+   * ```
+   * const loader = Loader({apiKey, version: 'weekly', libraries: ['places']});
+   * ```
+   */
+  constructor({ apiKey: e, channel: t, client: s, id: r = ue, libraries: n = [], language: a, region: c, version: i, mapIds: d, nonce: u, retries: l = 3, url: h = "https://maps.googleapis.com/maps/api/js" }) {
+    if (this.CALLBACK = "__googleMapsCallback", this.callbacks = [], this.done = !1, this.loading = !1, this.errors = [], this.version = i, this.apiKey = e, this.channel = t, this.client = s, this.id = r || ue, this.libraries = n, this.language = a, this.region = c, this.mapIds = d, this.nonce = u, this.retries = l, this.url = h, S.instance) {
+      if (!De(this.options, S.instance.options))
+        throw new Error(`Loader must not be called again with different options. ${JSON.stringify(this.options)} !== ${JSON.stringify(S.instance.options)}`);
+      return S.instance;
+    }
+    S.instance = this;
+  }
+  get options() {
+    return {
+      version: this.version,
+      apiKey: this.apiKey,
+      channel: this.channel,
+      client: this.client,
+      id: this.id,
+      libraries: this.libraries,
+      language: this.language,
+      region: this.region,
+      mapIds: this.mapIds,
+      nonce: this.nonce,
+      url: this.url
+    };
+  }
+  get failed() {
+    return this.done && !this.loading && this.errors.length >= this.retries + 1;
+  }
+  /**
+   * CreateUrl returns the Google Maps JavaScript API script url given the [[LoaderOptions]].
+   *
+   * @ignore
+   */
+  createUrl() {
+    let e = this.url;
+    return e += `?callback=${this.CALLBACK}`, this.apiKey && (e += `&key=${this.apiKey}`), this.channel && (e += `&channel=${this.channel}`), this.client && (e += `&client=${this.client}`), this.libraries.length > 0 && (e += `&libraries=${this.libraries.join(",")}`), this.language && (e += `&language=${this.language}`), this.region && (e += `&region=${this.region}`), this.version && (e += `&v=${this.version}`), this.mapIds && (e += `&map_ids=${this.mapIds.join(",")}`), e;
+  }
+  deleteScript() {
+    const e = document.getElementById(this.id);
+    e && e.remove();
+  }
+  /**
+   * Load the Google Maps JavaScript API script and return a Promise.
+   */
+  load() {
+    return this.loadPromise();
+  }
+  /**
+   * Load the Google Maps JavaScript API script and return a Promise.
+   *
+   * @ignore
+   */
+  loadPromise() {
+    return new Promise((e, t) => {
+      this.loadCallback((s) => {
+        s ? t(s.error) : e(window.google);
+      });
+    });
+  }
+  /**
+   * Load the Google Maps JavaScript API script with a callback.
+   */
+  loadCallback(e) {
+    this.callbacks.push(e), this.execute();
+  }
+  /**
+   * Set the script on document.
+   */
+  setScript() {
+    if (document.getElementById(this.id)) {
+      this.callback();
+      return;
+    }
+    const e = this.createUrl(), t = document.createElement("script");
+    t.id = this.id, t.type = "text/javascript", t.src = e, t.onerror = this.loadErrorCallback.bind(this), t.defer = !0, t.async = !0, this.nonce && (t.nonce = this.nonce), document.head.appendChild(t);
+  }
+  /**
+   * Reset the loader state.
+   */
+  reset() {
+    this.deleteScript(), this.done = !1, this.loading = !1, this.errors = [], this.onerrorEvent = null;
+  }
+  resetIfRetryingFailed() {
+    this.failed && this.reset();
+  }
+  loadErrorCallback(e) {
+    if (this.errors.push(e), this.errors.length <= this.retries) {
+      const t = this.errors.length * Math.pow(2, this.errors.length);
+      console.log(`Failed to load Google Maps script, retrying in ${t} ms.`), setTimeout(() => {
+        this.deleteScript(), this.setScript();
+      }, t);
+    } else
+      this.onerrorEvent = e, this.callback();
+  }
+  setCallback() {
+    window.__googleMapsCallback = this.callback.bind(this);
+  }
+  callback() {
+    this.done = !0, this.loading = !1, this.callbacks.forEach((e) => {
+      e(this.onerrorEvent);
+    }), this.callbacks = [];
+  }
+  execute() {
+    if (this.resetIfRetryingFailed(), this.done)
+      this.callback();
+    else {
+      if (window.google && window.google.maps && window.google.maps.version) {
+        console.warn("Google Maps already loaded outside @googlemaps/js-api-loader.This may result in undesirable behavior as options and script parameters may not match."), this.callback();
+        return;
+      }
+      this.loading || (this.loading = !0, this.setCallback(), this.setScript());
+    }
+  }
+}
+function Ue(o) {
+  return class extends o.OverlayView {
+    constructor(s) {
+      super();
+      te(this, "element");
+      te(this, "opts");
+      const { element: r, ...n } = s;
+      this.element = r, this.opts = n, this.opts.map && this.setMap(this.opts.map);
+    }
+    getPosition() {
+      return this.opts.position ? this.opts.position instanceof o.LatLng ? this.opts.position : new o.LatLng(this.opts.position) : null;
+    }
+    getVisible() {
+      if (!this.element)
+        return !1;
+      const s = this.element;
+      return s.style.display !== "none" && s.style.visibility !== "hidden" && (s.style.opacity === "" || Number(s.style.opacity) > 0.01);
+    }
+    onAdd() {
+      if (!this.element)
+        return;
+      const s = this.getPanes();
+      s && s.overlayMouseTarget.appendChild(this.element);
+    }
+    draw() {
+      if (!this.element)
+        return;
+      const r = this.getProjection().fromLatLngToDivPixel(this.getPosition());
+      if (r) {
+        this.element.style.position = "absolute";
+        const n = this.element.offsetHeight, a = this.element.offsetWidth;
+        let c, i;
+        switch (this.opts.anchorPoint) {
+          case "TOP_CENTER":
+            c = r.x - a / 2, i = r.y;
+            break;
+          case "BOTTOM_CENTER":
+            c = r.x - a / 2, i = r.y - n;
+            break;
+          case "LEFT_CENTER":
+            c = r.x, i = r.y - n / 2;
+            break;
+          case "RIGHT_CENTER":
+            c = r.x - a, i = r.y - n / 2;
+            break;
+          case "TOP_LEFT":
+            c = r.x, i = r.y;
+            break;
+          case "TOP_RIGHT":
+            c = r.x - a, i = r.y;
+            break;
+          case "BOTTOM_LEFT":
+            c = r.x, i = r.y - n;
+            break;
+          case "BOTTOM_RIGHT":
+            c = r.x - a, i = r.y - n;
+            break;
+          default:
+            c = r.x - a / 2, i = r.y - n / 2;
+        }
+        this.element.style.left = c + "px", this.element.style.top = i + "px", this.element.style.transform = `translateX(${this.opts.offsetX || 0}px) translateY(${this.opts.offsetY || 0}px)`, this.opts.zIndex && (this.element.style.zIndex = this.opts.zIndex.toString());
+      }
+    }
+    onRemove() {
+      this.element && this.element.remove();
+    }
+    setOptions(s) {
+      this.opts = s, this.draw();
+    }
+  };
+}
+let de;
+const he = [
+  "bounds_changed",
+  "center_changed",
+  "click",
+  "dblclick",
+  "drag",
+  "dragend",
+  "dragstart",
+  "heading_changed",
+  "idle",
+  "maptypeid_changed",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "projection_changed",
+  "resize",
+  "rightclick",
+  "tilesloaded",
+  "tilt_changed",
+  "zoom_changed"
+], ze = M({
+  props: {
+    apiPromise: {
+      type: Promise
+    },
+    apiKey: {
+      type: String,
+      default: ""
+    },
+    version: {
+      type: String,
+      default: "weekly"
+    },
+    libraries: {
+      type: Array,
+      default: () => ["places"]
+    },
+    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
+    },
+    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
+    },
+    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
+    }
+  },
+  emits: he,
+  setup(o, { emit: e }) {
+    const t = v(), s = v(!1), r = v(), n = v(), a = v(!1);
+    z(q, r), z(R, n), z(Le, a);
+    const c = () => {
+      const l = { ...o };
+      Object.keys(l).forEach((m) => {
+        l[m] === void 0 && delete l[m];
+      });
+      const p = (m) => {
+        var g;
+        return m ? { position: (g = n.value) == null ? void 0 : g.ControlPosition[m] } : {};
+      }, f = {
+        scaleControlOptions: o.scaleControlStyle ? { style: o.scaleControlStyle } : {},
+        panControlOptions: p(o.panControlPosition),
+        zoomControlOptions: p(o.zoomControlPosition),
+        rotateControlOptions: p(o.rotateControlPosition),
+        streetViewControlOptions: p(o.streetViewControlPosition),
+        fullscreenControlOptions: p(o.fullscreenControlPosition),
+        disableDefaultUI: o.disableDefaultUi
+      };
+      return { ...l, ...f };
+    }, i = O(
+      [n, r],
+      ([l, h]) => {
+        const p = l, f = h;
+        p && f && (p.event.addListenerOnce(f, "tilesloaded", () => {
+          a.value = !0;
+        }), setTimeout(i, 0));
+      },
+      { immediate: !0 }
+    ), d = () => {
+      try {
+        const { apiKey: l, region: h, version: p, language: f, libraries: m } = o;
+        de = new S({ apiKey: l, region: h, version: p, language: f, libraries: m });
+      } catch (l) {
+        console.error(l);
+      }
+    }, u = (l) => {
+      n.value = E(l.maps), r.value = E(new l.maps.Map(t.value, c()));
+      const h = Ue(n.value);
+      n.value[Q] = h, he.forEach((f) => {
+        var m;
+        (m = r.value) == null || m.addListener(f, (g) => e(f, g));
+      }), s.value = !0;
+      const p = Object.keys(o).filter(
+        (f) => !["apiPromise", "apiKey", "version", "libraries", "region", "language", "center", "zoom"].includes(f)
+      ).map((f) => B(o, f));
+      O(
+        [() => o.center, () => o.zoom, ...p],
+        ([f, m], [g, y]) => {
+          var G, b, F;
+          const { center: w, zoom: C, ...T } = c();
+          (G = r.value) == null || G.setOptions(T), m !== void 0 && m !== y && ((b = r.value) == null || b.setZoom(m));
+          const N = !g || f.lng !== g.lng || f.lat !== g.lat;
+          f && N && ((F = r.value) == null || F.panTo(f));
+        }
+      );
+    };
+    return Me(() => {
+      o.apiPromise && o.apiPromise instanceof Promise ? o.apiPromise.then(u) : (d(), de.load().then(u));
+    }), j(() => {
+      var l;
+      a.value = !1, r.value && ((l = n.value) == null || l.event.clearInstanceListeners(r.value));
+    }), { mapRef: t, ready: s, map: r, api: n, mapTilesLoaded: a };
+  }
+});
+const ee = (o, e) => {
+  const t = o.__vccOpts || o;
+  for (const [s, r] of e)
+    t[s] = r;
+  return t;
+}, Ve = {
+  ref: "mapRef",
+  class: "mapdiv"
+};
+function Ge(o, e, t, s, r, n) {
+  return J(), Y("div", null, [
+    ie("div", Ve, null, 512),
+    X(o.$slots, "default", Re(Ze({ ready: o.ready, map: o.map, api: o.api, mapTilesLoaded: o.mapTilesLoaded })), void 0, !0)
+  ]);
+}
+const Ot = /* @__PURE__ */ ee(ze, [["render", Ge], ["__scopeId", "data-v-7d660dd5"]]);
+function He(o) {
+  return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
+}
+var We = function o(e, t) {
+  if (e === t)
+    return !0;
+  if (e && t && typeof e == "object" && typeof t == "object") {
+    if (e.constructor !== t.constructor)
+      return !1;
+    var s, r, n;
+    if (Array.isArray(e)) {
+      if (s = e.length, s != t.length)
+        return !1;
+      for (r = s; r-- !== 0; )
+        if (!o(e[r], t[r]))
+          return !1;
+      return !0;
+    }
+    if (e.constructor === RegExp)
+      return e.source === t.source && e.flags === t.flags;
+    if (e.valueOf !== Object.prototype.valueOf)
+      return e.valueOf() === t.valueOf();
+    if (e.toString !== Object.prototype.toString)
+      return e.toString() === t.toString();
+    if (n = Object.keys(e), s = n.length, s !== Object.keys(t).length)
+      return !1;
+    for (r = s; r-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(t, n[r]))
+        return !1;
+    for (r = s; r-- !== 0; ) {
+      var a = n[r];
+      if (!o(e[a], t[a]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+};
+const A = /* @__PURE__ */ He(We), Ke = (o) => o === "Marker", Je = (o) => o === Q, Z = (o, e, t, s) => {
+  const r = v(), n = _(q, v()), a = _(R, v()), c = _(Ee, v()), i = K(
+    () => !!(c.value && a.value && (r.value instanceof a.value.Marker || r.value instanceof a.value[Q]))
+  );
+  return O(
+    [n, t],
+    (d, [u, l]) => {
+      var p, f, m;
+      const h = !A(t.value, l) || n.value !== u;
+      !n.value || !a.value || !h || (r.value ? (r.value.setOptions(t.value), i.value && ((p = c.value) == null || p.removeMarker(r.value), (f = c.value) == null || f.addMarker(r.value))) : (Ke(o) ? r.value = E(
+        new a.value[o](t.value)
+      ) : Je(o) ? r.value = E(
+        new a.value[o](t.value)
+      ) : r.value = E(
+        new a.value[o]({
+          ...t.value,
+          map: n.value
+        })
+      ), i.value ? (m = c.value) == null || m.addMarker(r.value) : r.value.setMap(n.value), e.forEach((g) => {
+        var y;
+        (y = r.value) == null || y.addListener(g, (w) => s(g, w));
+      })));
+    },
+    {
+      immediate: !0
+    }
+  ), j(() => {
+    var d, u;
+    r.value && ((d = a.value) == null || d.event.clearInstanceListeners(r.value), i.value ? (u = c.value) == null || u.removeMarker(r.value) : r.value.setMap(null));
+  }), r;
+}, pe = [
+  "animation_changed",
+  "click",
+  "dblclick",
+  "rightclick",
+  "dragstart",
+  "dragend",
+  "drag",
+  "mouseover",
+  "mousedown",
+  "mouseout",
+  "mouseup",
+  "draggable_changed",
+  "clickable_changed",
+  "contextmenu",
+  "cursor_changed",
+  "flat_changed",
+  "rightclick",
+  "zindex_changed",
+  "icon_changed",
+  "position_changed",
+  "shape_changed",
+  "title_changed",
+  "visible_changed"
+], Pt = M({
+  name: "Marker",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: pe,
+  setup(o, { emit: e, expose: t, slots: s }) {
+    const r = B(o, "options"), n = Z("Marker", pe, r, e);
+    return z(xe, n), t({ marker: n }), () => {
+      var a;
+      return (a = s.default) == null ? void 0 : a.call(s);
+    };
+  }
+}), xt = M({
+  name: "Polyline",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: $,
+  setup(o, { emit: e }) {
+    const t = B(o, "options");
+    return { polyline: Z("Polyline", $, t, e) };
+  },
+  render: () => null
+}), Et = M({
+  name: "Polygon",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: $,
+  setup(o, { emit: e }) {
+    const t = B(o, "options");
+    return { polygon: Z("Polygon", $, t, e) };
+  },
+  render: () => null
+}), fe = $.concat(["bounds_changed"]), Lt = M({
+  name: "Rectangle",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: fe,
+  setup(o, { emit: e }) {
+    const t = B(o, "options");
+    return { rectangle: Z("Rectangle", fe, t, e) };
+  },
+  render: () => null
+}), me = $.concat(["center_changed", "radius_changed"]), St = M({
+  name: "Circle",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: me,
+  setup(o, { emit: e }) {
+    const t = B(o, "options");
+    return { circle: Z("Circle", me, t, e) };
+  },
+  render: () => null
+}), Ye = M({
+  props: {
+    position: {
+      type: String,
+      required: !0
+    },
+    index: {
+      type: Number,
+      default: 1
+    }
+  },
+  emits: ["content:loaded"],
+  setup(o, { emit: e }) {
+    const t = v(null), s = _(q, v()), r = _(R, v()), n = _(Le, v(!1)), a = v(!1), c = O(
+      [n, r, t],
+      ([u, l, h]) => {
+        l && u && h && (i(o.position), a.value = !0, e("content:loaded"), setTimeout(c, 0));
+      },
+      { immediate: !0 }
+    ), i = (u) => {
+      if (s.value && r.value && t.value) {
+        const l = r.value.ControlPosition[u];
+        s.value.controls[l].push(t.value);
+      }
+    }, d = (u) => {
+      if (s.value && r.value) {
+        let l = null;
+        const h = r.value.ControlPosition[u];
+        s.value.controls[h].forEach((p, f) => {
+          p === t.value && (l = f);
+        }), l !== null && s.value.controls[h].removeAt(l);
+      }
+    };
+    return j(() => d(o.position)), O(
+      () => o.position,
+      (u, l) => {
+        d(l), i(u);
+      }
+    ), O(
+      () => o.index,
+      (u) => {
+        u && t.value && (t.value.index = o.index);
+      }
+    ), { controlRef: t, showContent: a };
+  }
+}), Xe = { ref: "controlRef" };
+function Qe(o, e, t, s, r, n) {
+  return Ne((J(), Y("div", Xe, [
+    X(o.$slots, "default")
+  ], 512)), [
+    [Fe, o.showContent]
+  ]);
+}
+const At = /* @__PURE__ */ ee(Ye, [["render", Qe]]), ge = ["closeclick", "content_changed", "domready", "position_changed", "visible", "zindex_changed"], et = M({
+  inheritAttrs: !1,
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ge,
+  setup(o, { slots: e, emit: t, expose: s }) {
+    const r = v(), n = v(), a = _(q, v()), c = _(R, v()), i = _(xe, v());
+    let d;
+    const u = K(() => {
+      var p;
+      return (p = e.default) == null ? void 0 : p.call(e).some((f) => f.type !== be);
+    }), l = (p) => {
+      var f;
+      return (f = r.value) == null ? void 0 : f.open({ map: a.value, anchor: i.value, ...p });
+    }, h = () => {
+      var p;
+      return (p = r.value) == null ? void 0 : p.close();
+    };
+    return Me(() => {
+      O(
+        [a, () => o.options],
+        ([p, f], [m, g]) => {
+          const y = !A(f, g) || a.value !== m;
+          a.value && c.value && y && (r.value ? (r.value.setOptions({
+            ...f,
+            content: u.value ? n.value : f.content
+          }), i.value || l()) : (r.value = E(
+            new c.value.InfoWindow({
+              ...f,
+              content: u.value ? n.value : f.content
+            })
+          ), i.value ? d = i.value.addListener("click", () => {
+            l();
+          }) : l(), ge.forEach((w) => {
+            var C;
+            (C = r.value) == null || C.addListener(w, (T) => t(w, T));
+          })));
+        },
+        {
+          immediate: !0
+        }
+      );
+    }), j(() => {
+      var p;
+      d && d.remove(), r.value && ((p = c.value) == null || p.event.clearInstanceListeners(r.value), h());
+    }), s({ infoWindow: r, open: l, close: h }), { infoWindow: r, infoWindowRef: n, hasSlotContent: u, open: l, close: h };
+  }
+});
+const tt = {
+  key: 0,
+  class: "info-window-wrapper"
+};
+function st(o, e, t, s, r, n) {
+  return o.hasSlotContent ? (J(), Y("div", tt, [
+    ie("div", Oe({ ref: "infoWindowRef" }, o.$attrs), [
+      X(o.$slots, "default", {}, void 0, !0)
+    ], 16)
+  ])) : Pe("", !0);
+}
+const Tt = /* @__PURE__ */ ee(et, [["render", st], ["__scopeId", "data-v-45a4606d"]]), ve = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array
+], se = 1, D = 8;
+class ae {
+  /**
+   * 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 [t, s] = new Uint8Array(e, 0, 2);
+    if (t !== 219)
+      throw new Error("Data does not appear to be in a KDBush format.");
+    const r = s >> 4;
+    if (r !== se)
+      throw new Error(`Got v${r} data when expected v${se}.`);
+    const n = ve[s & 15];
+    if (!n)
+      throw new Error("Unrecognized array type.");
+    const [a] = new Uint16Array(e, 2, 1), [c] = new Uint32Array(e, 4, 1);
+    return new ae(c, a, 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, t = 64, s = Float64Array, r) {
+    if (isNaN(e) || e < 0)
+      throw new Error(`Unpexpected numItems value: ${e}.`);
+    this.numItems = +e, this.nodeSize = Math.min(Math.max(+t, 2), 65535), this.ArrayType = s, this.IndexArrayType = e < 65536 ? Uint16Array : Uint32Array;
+    const n = ve.indexOf(this.ArrayType), a = e * 2 * this.ArrayType.BYTES_PER_ELEMENT, c = e * this.IndexArrayType.BYTES_PER_ELEMENT, i = (8 - c % 8) % 8;
+    if (n < 0)
+      throw new Error(`Unexpected typed array class: ${s}.`);
+    r && r instanceof ArrayBuffer ? (this.data = r, this.ids = new this.IndexArrayType(this.data, D, e), this.coords = new this.ArrayType(this.data, D + c + i, e * 2), this._pos = e * 2, this._finished = !0) : (this.data = new ArrayBuffer(D + a + c + i), this.ids = new this.IndexArrayType(this.data, D, e), this.coords = new this.ArrayType(this.data, D + c + i, e * 2), this._pos = 0, this._finished = !1, new Uint8Array(this.data, 0, 2).set([219, (se << 4) + n]), new Uint16Array(this.data, 2, 1)[0] = t, 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, t) {
+    const s = this._pos >> 1;
+    return this.ids[s] = s, this.coords[this._pos++] = e, this.coords[this._pos++] = t, s;
+  }
+  /**
+   * 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 ne(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, t, s, r) {
+    if (!this._finished)
+      throw new Error("Data not yet indexed - call index.finish().");
+    const { ids: n, coords: a, nodeSize: c } = this, i = [0, n.length - 1, 0], d = [];
+    for (; i.length; ) {
+      const u = i.pop() || 0, l = i.pop() || 0, h = i.pop() || 0;
+      if (l - h <= c) {
+        for (let g = h; g <= l; g++) {
+          const y = a[2 * g], w = a[2 * g + 1];
+          y >= e && y <= s && w >= t && w <= r && d.push(n[g]);
+        }
+        continue;
+      }
+      const p = h + l >> 1, f = a[2 * p], m = a[2 * p + 1];
+      f >= e && f <= s && m >= t && m <= r && d.push(n[p]), (u === 0 ? e <= f : t <= m) && (i.push(h), i.push(p - 1), i.push(1 - u)), (u === 0 ? s >= f : r >= m) && (i.push(p + 1), i.push(l), i.push(1 - u));
+    }
+    return d;
+  }
+  /**
+   * 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, t, s) {
+    if (!this._finished)
+      throw new Error("Data not yet indexed - call index.finish().");
+    const { ids: r, coords: n, nodeSize: a } = this, c = [0, r.length - 1, 0], i = [], d = s * s;
+    for (; c.length; ) {
+      const u = c.pop() || 0, l = c.pop() || 0, h = c.pop() || 0;
+      if (l - h <= a) {
+        for (let g = h; g <= l; g++)
+          ye(n[2 * g], n[2 * g + 1], e, t) <= d && i.push(r[g]);
+        continue;
+      }
+      const p = h + l >> 1, f = n[2 * p], m = n[2 * p + 1];
+      ye(f, m, e, t) <= d && i.push(r[p]), (u === 0 ? e - s <= f : t - s <= m) && (c.push(h), c.push(p - 1), c.push(1 - u)), (u === 0 ? e + s >= f : t + s >= m) && (c.push(p + 1), c.push(l), c.push(1 - u));
+    }
+    return i;
+  }
+}
+function ne(o, e, t, s, r, n) {
+  if (r - s <= t)
+    return;
+  const a = s + r >> 1;
+  Se(o, e, a, s, r, n), ne(o, e, t, s, a - 1, 1 - n), ne(o, e, t, a + 1, r, 1 - n);
+}
+function Se(o, e, t, s, r, n) {
+  for (; r > s; ) {
+    if (r - s > 600) {
+      const d = r - s + 1, u = t - s + 1, l = Math.log(d), h = 0.5 * Math.exp(2 * l / 3), p = 0.5 * Math.sqrt(l * h * (d - h) / d) * (u - d / 2 < 0 ? -1 : 1), f = Math.max(s, Math.floor(t - u * h / d + p)), m = Math.min(r, Math.floor(t + (d - u) * h / d + p));
+      Se(o, e, t, f, m, n);
+    }
+    const a = e[2 * t + n];
+    let c = s, i = r;
+    for (U(o, e, s, t), e[2 * r + n] > a && U(o, e, s, r); c < i; ) {
+      for (U(o, e, c, i), c++, i--; e[2 * c + n] < a; )
+        c++;
+      for (; e[2 * i + n] > a; )
+        i--;
+    }
+    e[2 * s + n] === a ? U(o, e, s, i) : (i++, U(o, e, i, r)), i <= t && (s = i + 1), t <= i && (r = i - 1);
+  }
+}
+function U(o, e, t, s) {
+  re(o, t, s), re(e, 2 * t, 2 * s), re(e, 2 * t + 1, 2 * s + 1);
+}
+function re(o, e, t) {
+  const s = o[e];
+  o[e] = o[t], o[t] = s;
+}
+function ye(o, e, t, s) {
+  const r = o - t, n = e - s;
+  return r * r + n * n;
+}
+const rt = {
+  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: (o) => o
+  // props => ({sum: props.my_value})
+}, we = Math.fround || ((o) => (e) => (o[0] = +e, o[0]))(new Float32Array(1)), L = 2, x = 3, oe = 4, P = 5, Ae = 6;
+class Te {
+  constructor(e) {
+    this.options = Object.assign(Object.create(rt), e), this.trees = new Array(this.options.maxZoom + 1), this.stride = this.options.reduce ? 7 : 6, this.clusterProps = [];
+  }
+  load(e) {
+    const { log: t, minZoom: s, maxZoom: r } = this.options;
+    t && console.time("total time");
+    const n = `prepare ${e.length} points`;
+    t && console.time(n), this.points = e;
+    const a = [];
+    for (let i = 0; i < e.length; i++) {
+      const d = e[i];
+      if (!d.geometry)
+        continue;
+      const [u, l] = d.geometry.coordinates, h = we(H(u)), p = we(W(l));
+      a.push(
+        h,
+        p,
+        // projected point coordinates
+        1 / 0,
+        // the last zoom the point was processed at
+        i,
+        // 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 c = this.trees[r + 1] = this._createTree(a);
+    t && console.timeEnd(n);
+    for (let i = r; i >= s; i--) {
+      const d = +Date.now();
+      c = this.trees[i] = this._createTree(this._cluster(c, i)), t && console.log("z%d: %d clusters in %dms", i, c.numItems, +Date.now() - d);
+    }
+    return t && console.timeEnd("total time"), this;
+  }
+  getClusters(e, t) {
+    let s = ((e[0] + 180) % 360 + 360) % 360 - 180;
+    const r = Math.max(-90, Math.min(90, e[1]));
+    let n = e[2] === 180 ? 180 : ((e[2] + 180) % 360 + 360) % 360 - 180;
+    const a = Math.max(-90, Math.min(90, e[3]));
+    if (e[2] - e[0] >= 360)
+      s = -180, n = 180;
+    else if (s > n) {
+      const l = this.getClusters([s, r, 180, a], t), h = this.getClusters([-180, r, n, a], t);
+      return l.concat(h);
+    }
+    const c = this.trees[this._limitZoom(t)], i = c.range(H(s), W(a), H(n), W(r)), d = c.data, u = [];
+    for (const l of i) {
+      const h = this.stride * l;
+      u.push(d[h + P] > 1 ? ke(d, h, this.clusterProps) : this.points[d[h + x]]);
+    }
+    return u;
+  }
+  getChildren(e) {
+    const t = this._getOriginId(e), s = this._getOriginZoom(e), r = "No cluster with the specified id.", n = this.trees[s];
+    if (!n)
+      throw new Error(r);
+    const a = n.data;
+    if (t * this.stride >= a.length)
+      throw new Error(r);
+    const c = this.options.radius / (this.options.extent * Math.pow(2, s - 1)), i = a[t * this.stride], d = a[t * this.stride + 1], u = n.within(i, d, c), l = [];
+    for (const h of u) {
+      const p = h * this.stride;
+      a[p + oe] === e && l.push(a[p + P] > 1 ? ke(a, p, this.clusterProps) : this.points[a[p + x]]);
+    }
+    if (l.length === 0)
+      throw new Error(r);
+    return l;
+  }
+  getLeaves(e, t, s) {
+    t = t || 10, s = s || 0;
+    const r = [];
+    return this._appendLeaves(r, e, t, s, 0), r;
+  }
+  getTile(e, t, s) {
+    const r = this.trees[this._limitZoom(e)], n = Math.pow(2, e), { extent: a, radius: c } = this.options, i = c / a, d = (s - i) / n, u = (s + 1 + i) / n, l = {
+      features: []
+    };
+    return this._addTileFeatures(
+      r.range((t - i) / n, d, (t + 1 + i) / n, u),
+      r.data,
+      t,
+      s,
+      n,
+      l
+    ), t === 0 && this._addTileFeatures(
+      r.range(1 - i / n, d, 1, u),
+      r.data,
+      n,
+      s,
+      n,
+      l
+    ), t === n - 1 && this._addTileFeatures(
+      r.range(0, d, i / n, u),
+      r.data,
+      -1,
+      s,
+      n,
+      l
+    ), l.features.length ? l : null;
+  }
+  getClusterExpansionZoom(e) {
+    let t = this._getOriginZoom(e) - 1;
+    for (; t <= this.options.maxZoom; ) {
+      const s = this.getChildren(e);
+      if (t++, s.length !== 1)
+        break;
+      e = s[0].properties.cluster_id;
+    }
+    return t;
+  }
+  _appendLeaves(e, t, s, r, n) {
+    const a = this.getChildren(t);
+    for (const c of a) {
+      const i = c.properties;
+      if (i && i.cluster ? n + i.point_count <= r ? n += i.point_count : n = this._appendLeaves(e, i.cluster_id, s, r, n) : n < r ? n++ : e.push(c), e.length === s)
+        break;
+    }
+    return n;
+  }
+  _createTree(e) {
+    const t = new ae(e.length / this.stride | 0, this.options.nodeSize, Float32Array);
+    for (let s = 0; s < e.length; s += this.stride)
+      t.add(e[s], e[s + 1]);
+    return t.finish(), t.data = e, t;
+  }
+  _addTileFeatures(e, t, s, r, n, a) {
+    for (const c of e) {
+      const i = c * this.stride, d = t[i + P] > 1;
+      let u, l, h;
+      if (d)
+        u = Ie(t, i, this.clusterProps), l = t[i], h = t[i + 1];
+      else {
+        const m = this.points[t[i + x]];
+        u = m.properties;
+        const [g, y] = m.geometry.coordinates;
+        l = H(g), h = W(y);
+      }
+      const p = {
+        type: 1,
+        geometry: [[
+          Math.round(this.options.extent * (l * n - s)),
+          Math.round(this.options.extent * (h * n - r))
+        ]],
+        tags: u
+      };
+      let f;
+      d || this.options.generateId ? f = t[i + x] : f = this.points[t[i + x]].id, f !== void 0 && (p.id = f), a.features.push(p);
+    }
+  }
+  _limitZoom(e) {
+    return Math.max(this.options.minZoom, Math.min(Math.floor(+e), this.options.maxZoom + 1));
+  }
+  _cluster(e, t) {
+    const { radius: s, extent: r, reduce: n, minPoints: a } = this.options, c = s / (r * Math.pow(2, t)), i = e.data, d = [], u = this.stride;
+    for (let l = 0; l < i.length; l += u) {
+      if (i[l + L] <= t)
+        continue;
+      i[l + L] = t;
+      const h = i[l], p = i[l + 1], f = e.within(i[l], i[l + 1], c), m = i[l + P];
+      let g = m;
+      for (const y of f) {
+        const w = y * u;
+        i[w + L] > t && (g += i[w + P]);
+      }
+      if (g > m && g >= a) {
+        let y = h * m, w = p * m, C, T = -1;
+        const N = ((l / u | 0) << 5) + (t + 1) + this.points.length;
+        for (const G of f) {
+          const b = G * u;
+          if (i[b + L] <= t)
+            continue;
+          i[b + L] = t;
+          const F = i[b + P];
+          y += i[b] * F, w += i[b + 1] * F, i[b + oe] = N, n && (C || (C = this._map(i, l, !0), T = this.clusterProps.length, this.clusterProps.push(C)), n(C, this._map(i, b)));
+        }
+        i[l + oe] = N, d.push(y / g, w / g, 1 / 0, N, -1, g), n && d.push(T);
+      } else {
+        for (let y = 0; y < u; y++)
+          d.push(i[l + y]);
+        if (g > 1)
+          for (const y of f) {
+            const w = y * u;
+            if (!(i[w + L] <= t)) {
+              i[w + L] = t;
+              for (let C = 0; C < u; C++)
+                d.push(i[w + C]);
+            }
+          }
+      }
+    }
+    return d;
+  }
+  // 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, t, s) {
+    if (e[t + P] > 1) {
+      const a = this.clusterProps[e[t + Ae]];
+      return s ? Object.assign({}, a) : a;
+    }
+    const r = this.points[e[t + x]].properties, n = this.options.map(r);
+    return s && n === r ? Object.assign({}, n) : n;
+  }
+}
+function ke(o, e, t) {
+  return {
+    type: "Feature",
+    id: o[e + x],
+    properties: Ie(o, e, t),
+    geometry: {
+      type: "Point",
+      coordinates: [ot(o[e]), nt(o[e + 1])]
+    }
+  };
+}
+function Ie(o, e, t) {
+  const s = o[e + P], r = s >= 1e4 ? `${Math.round(s / 1e3)}k` : s >= 1e3 ? `${Math.round(s / 100) / 10}k` : s, n = o[e + Ae], a = n === -1 ? {} : Object.assign({}, t[n]);
+  return Object.assign(a, {
+    cluster: !0,
+    cluster_id: o[e + x],
+    point_count: s,
+    point_count_abbreviated: r
+  });
+}
+function H(o) {
+  return o / 360 + 0.5;
+}
+function W(o) {
+  const e = Math.sin(o * Math.PI / 180), t = 0.5 - 0.25 * Math.log((1 + e) / (1 - e)) / Math.PI;
+  return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+function ot(o) {
+  return (o - 0.5) * 360;
+}
+function nt(o) {
+  const e = (180 - o * 360) * Math.PI / 180;
+  return 360 * Math.atan(Math.exp(e)) / Math.PI - 90;
+}
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+function le(o, e) {
+  var t = {};
+  for (var s in o)
+    Object.prototype.hasOwnProperty.call(o, s) && e.indexOf(s) < 0 && (t[s] = o[s]);
+  if (o != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var r = 0, s = Object.getOwnPropertySymbols(o); r < s.length; r++)
+      e.indexOf(s[r]) < 0 && Object.prototype.propertyIsEnumerable.call(o, s[r]) && (t[s[r]] = o[s[r]]);
+  return t;
+}
+class k {
+  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, t) {
+    this.isAdvancedMarker(e) ? e.map = t : e.setMap(t);
+  }
+  static getPosition(e) {
+    if (this.isAdvancedMarker(e)) {
+      if (e.position) {
+        if (e.position instanceof google.maps.LatLng)
+          return e.position;
+        if (e.position.lat && 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 V {
+  constructor({ markers: e, position: t }) {
+    this.markers = e, t && (t instanceof google.maps.LatLng ? this._position = t : this._position = new google.maps.LatLng(t));
+  }
+  get bounds() {
+    if (this.markers.length === 0 && !this._position)
+      return;
+    const e = new google.maps.LatLngBounds(this._position, this._position);
+    for (const t of this.markers)
+      e.extend(k.getPosition(t));
+    return e;
+  }
+  get position() {
+    return this._position || this.bounds.getCenter();
+  }
+  /**
+   * Get the count of **visible** markers.
+   */
+  get count() {
+    return this.markers.filter((e) => k.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 && (k.setMap(this.marker, null), this.marker = void 0), this.markers.length = 0;
+  }
+}
+const it = (o, e, t, s) => {
+  const r = $e(o.getBounds(), e, s);
+  return t.filter((n) => r.contains(k.getPosition(n)));
+}, $e = (o, e, t) => {
+  const { northEast: s, southWest: r } = at(o, e), n = lt({ northEast: s, southWest: r }, t);
+  return ct(n, e);
+}, _e = (o, e, t) => {
+  const s = $e(o, e, t), r = s.getNorthEast(), n = s.getSouthWest();
+  return [n.lng(), n.lat(), r.lng(), r.lat()];
+}, at = (o, e) => ({
+  northEast: e.fromLatLngToDivPixel(o.getNorthEast()),
+  southWest: e.fromLatLngToDivPixel(o.getSouthWest())
+}), lt = ({ northEast: o, southWest: e }, t) => (o.x += t, o.y -= t, e.x -= t, e.y += t, { northEast: o, southWest: e }), ct = ({ northEast: o, southWest: e }, t) => {
+  const s = t.fromDivPixelToLatLng(e), r = t.fromDivPixelToLatLng(o);
+  return new google.maps.LatLngBounds(s, r);
+};
+class je {
+  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 dt(e);
+  }
+}
+class ut extends je {
+  constructor(e) {
+    var { viewportPadding: t = 60 } = e, s = le(e, ["viewportPadding"]);
+    super(s), this.viewportPadding = 60, this.viewportPadding = t;
+  }
+  calculate({ markers: e, map: t, mapCanvasProjection: s }) {
+    return t.getZoom() >= this.maxZoom ? {
+      clusters: this.noop({
+        markers: e
+      }),
+      changed: !1
+    } : {
+      clusters: this.cluster({
+        markers: it(t, s, e, this.viewportPadding),
+        map: t,
+        mapCanvasProjection: s
+      })
+    };
+  }
+}
+const dt = (o) => o.map((t) => new V({
+  position: k.getPosition(t),
+  markers: [t]
+}));
+class ht extends je {
+  constructor(e) {
+    var { maxZoom: t, radius: s = 60 } = e, r = le(e, ["maxZoom", "radius"]);
+    super({ maxZoom: t }), this.state = { zoom: -1 }, this.superCluster = new Te(Object.assign({ maxZoom: this.maxZoom, radius: s }, r));
+  }
+  calculate(e) {
+    let t = !1;
+    const s = { zoom: e.map.getZoom() };
+    if (!A(e.markers, this.markers)) {
+      t = !0, this.markers = [...e.markers];
+      const r = this.markers.map((n) => {
+        const a = k.getPosition(n);
+        return {
+          type: "Feature",
+          geometry: {
+            type: "Point",
+            coordinates: [a.lng(), a.lat()]
+          },
+          properties: { marker: n }
+        };
+      });
+      this.superCluster.load(r);
+    }
+    return t || (this.state.zoom <= this.maxZoom || s.zoom <= this.maxZoom) && (t = !A(this.state, s)), this.state = s, t && (this.clusters = this.cluster(e)), { clusters: this.clusters, changed: t };
+  }
+  cluster({ map: e }) {
+    return this.superCluster.getClusters([-180, -90, 180, 90], Math.round(e.getZoom())).map((t) => this.transformCluster(t));
+  }
+  transformCluster({ geometry: { coordinates: [e, t] }, properties: s }) {
+    if (s.cluster)
+      return new V({
+        markers: this.superCluster.getLeaves(s.cluster_id, 1 / 0).map((n) => n.properties.marker),
+        position: { lat: t, lng: e }
+      });
+    const r = s.marker;
+    return new V({
+      markers: [r],
+      position: k.getPosition(r)
+    });
+  }
+}
+class pt extends ut {
+  constructor(e) {
+    var { maxZoom: t, radius: s = 60, viewportPadding: r = 60 } = e, n = le(e, ["maxZoom", "radius", "viewportPadding"]);
+    super({ maxZoom: t, viewportPadding: r }), this.superCluster = new Te(Object.assign({ maxZoom: this.maxZoom, radius: s }, n)), this.state = { zoom: -1, view: [0, 0, 0, 0] };
+  }
+  calculate(e) {
+    const t = {
+      zoom: Math.round(e.map.getZoom()),
+      view: _e(e.map.getBounds(), e.mapCanvasProjection, this.viewportPadding)
+    };
+    let s = !A(this.state, t);
+    if (!A(e.markers, this.markers)) {
+      s = !0, this.markers = [...e.markers];
+      const r = this.markers.map((n) => {
+        const a = k.getPosition(n);
+        return {
+          type: "Feature",
+          geometry: {
+            type: "Point",
+            coordinates: [a.lng(), a.lat()]
+          },
+          properties: { marker: n }
+        };
+      });
+      this.superCluster.load(r);
+    }
+    return s && (this.clusters = this.cluster(e), this.state = t), { clusters: this.clusters, changed: s };
+  }
+  cluster({ map: e, mapCanvasProjection: t }) {
+    const s = {
+      zoom: Math.round(e.getZoom()),
+      view: _e(e.getBounds(), t, this.viewportPadding)
+    };
+    return this.superCluster.getClusters(s.view, s.zoom).map((r) => this.transformCluster(r));
+  }
+  transformCluster({ geometry: { coordinates: [e, t] }, properties: s }) {
+    if (s.cluster)
+      return new V({
+        markers: this.superCluster.getLeaves(s.cluster_id, 1 / 0).map((n) => n.properties.marker),
+        position: { lat: t, lng: e }
+      });
+    const r = s.marker;
+    return new V({
+      markers: [r],
+      position: k.getPosition(r)
+    });
+  }
+}
+class ft {
+  constructor(e, t) {
+    this.markers = { sum: e.length };
+    const s = t.map((n) => n.count), r = s.reduce((n, a) => n + a, 0);
+    this.clusters = {
+      count: t.length,
+      markers: {
+        mean: r / t.length,
+        sum: r,
+        min: Math.min(...s),
+        max: Math.max(...s)
+      }
+    };
+  }
+}
+class mt {
+  /**
+   * 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: t }, s, r) {
+    const a = `<svg fill="${e > Math.max(10, s.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>`, c = `Cluster of ${e} markers`, i = Number(google.maps.Marker.MAX_ZINDEX) + e;
+    if (k.isAdvancedMarkerAvailable(r)) {
+      const u = document.createElement("div");
+      u.innerHTML = a;
+      const l = u.firstElementChild;
+      l.setAttribute("transform", "translate(0 25)");
+      const h = {
+        map: r,
+        position: t,
+        zIndex: i,
+        title: c,
+        content: l
+      };
+      return new google.maps.marker.AdvancedMarkerElement(h);
+    }
+    const d = {
+      position: t,
+      zIndex: i,
+      title: c,
+      icon: {
+        url: `data:image/svg+xml;base64,${btoa(a)}`,
+        anchor: new google.maps.Point(25, 25)
+      }
+    };
+    return new google.maps.Marker(d);
+  }
+}
+function gt(o, e) {
+  for (let t in e.prototype)
+    o.prototype[t] = e.prototype[t];
+}
+class ce {
+  constructor() {
+    gt(ce, google.maps.OverlayView);
+  }
+}
+var I;
+(function(o) {
+  o.CLUSTERING_BEGIN = "clusteringbegin", o.CLUSTERING_END = "clusteringend", o.CLUSTER_CLICK = "click";
+})(I || (I = {}));
+const vt = (o, e, t) => {
+  t.fitBounds(e.bounds);
+};
+class yt extends ce {
+  constructor({ map: e, markers: t = [], algorithmOptions: s = {}, algorithm: r = new ht(s), renderer: n = new mt(), onClusterClick: a = vt }) {
+    super(), this.markers = [...t], this.clusters = [], this.algorithm = r, this.renderer = n, this.onClusterClick = a, e && this.setMap(e);
+  }
+  addMarker(e, t) {
+    this.markers.includes(e) || (this.markers.push(e), t || this.render());
+  }
+  addMarkers(e, t) {
+    e.forEach((s) => {
+      this.addMarker(s, !0);
+    }), t || this.render();
+  }
+  removeMarker(e, t) {
+    const s = this.markers.indexOf(e);
+    return s === -1 ? !1 : (k.setMap(e, null), this.markers.splice(s, 1), t || this.render(), !0);
+  }
+  removeMarkers(e, t) {
+    let s = !1;
+    return e.forEach((r) => {
+      s = this.removeMarker(r, !0) || s;
+    }), s && !t && this.render(), s;
+  }
+  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, I.CLUSTERING_BEGIN, this);
+      const { clusters: t, changed: s } = this.algorithm.calculate({
+        markers: this.markers,
+        map: e,
+        mapCanvasProjection: this.getProjection()
+      });
+      if (s || s == null) {
+        const r = /* @__PURE__ */ new Set();
+        for (const a of t)
+          a.markers.length == 1 && r.add(a.markers[0]);
+        const n = [];
+        for (const a of this.clusters)
+          a.marker != null && (a.markers.length == 1 ? r.has(a.marker) || k.setMap(a.marker, null) : n.push(a.marker));
+        this.clusters = t, this.renderClusters(), requestAnimationFrame(() => n.forEach((a) => k.setMap(a, null)));
+      }
+      google.maps.event.trigger(this, I.CLUSTERING_END, this);
+    }
+  }
+  onAdd() {
+    this.idleListener = this.getMap().addListener("idle", this.render.bind(this)), this.render();
+  }
+  onRemove() {
+    google.maps.event.removeListener(this.idleListener), this.reset();
+  }
+  reset() {
+    this.markers.forEach((e) => k.setMap(e, null)), this.clusters.forEach((e) => e.delete()), this.clusters = [];
+  }
+  renderClusters() {
+    const e = new ft(this.markers, this.clusters), t = this.getMap();
+    this.clusters.forEach((s) => {
+      s.markers.length === 1 ? s.marker = s.markers[0] : (s.marker = this.renderer.render(s, e, t), s.markers.forEach((r) => k.setMap(r, null)), this.onClusterClick && s.marker.addListener(
+        "click",
+        /* istanbul ignore next */
+        (r) => {
+          google.maps.event.trigger(this, I.CLUSTER_CLICK, s), this.onClusterClick(r, s, t);
+        }
+      )), k.setMap(s.marker, t);
+    });
+  }
+}
+const Ce = Object.values(I), It = M({
+  name: "MarkerCluster",
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: Ce,
+  setup(o, { emit: e, expose: t, slots: s }) {
+    const r = v(), n = _(q, v()), a = _(R, v());
+    return z(Ee, r), O(
+      n,
+      () => {
+        n.value && (r.value = E(
+          new yt({
+            map: n.value,
+            // Better perf than the default `SuperClusterAlgorithm`. See:
+            // https://github.com/googlemaps/js-markerclusterer/pull/640
+            algorithm: new pt(o.options.algorithmOptions ?? {}),
+            ...o.options
+          })
+        ), Ce.forEach((c) => {
+          var i;
+          (i = r.value) == null || i.addListener(c, (d) => e(c, d));
+        }));
+      },
+      {
+        immediate: !0
+      }
+    ), j(() => {
+      var c;
+      r.value && ((c = a.value) == null || c.event.clearInstanceListeners(r.value), r.value.clearMarkers(), r.value.setMap(null));
+    }), t({ markerCluster: r }), () => {
+      var c;
+      return (c = s.default) == null ? void 0 : c.call(s);
+    };
+  }
+}), wt = M({
+  inheritAttrs: !1,
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  setup(o, { slots: e, emit: t, expose: s }) {
+    const r = v(), n = K(() => {
+      var i;
+      return (i = e.default) == null ? void 0 : i.call(e).some((d) => d.type !== be);
+    }), a = K(() => ({
+      ...o.options,
+      element: r.value
+    })), c = Z(Q, [], a, t);
+    return s({
+      customMarker: c
+    }), { customMarkerRef: r, customMarker: c, hasSlotContent: n };
+  }
+});
+const kt = {
+  key: 0,
+  class: "custom-marker-wrapper"
+};
+function _t(o, e, t, s, r, n) {
+  return o.hasSlotContent ? (J(), Y("div", kt, [
+    ie("div", Oe({
+      ref: "customMarkerRef",
+      style: { cursor: o.$attrs.onClick ? "pointer" : void 0 }
+    }, o.$attrs), [
+      X(o.$slots, "default", {}, void 0, !0)
+    ], 16)
+  ])) : Pe("", !0);
+}
+const $t = /* @__PURE__ */ ee(wt, [["render", _t], ["__scopeId", "data-v-c7599d50"]]), jt = M({
+  name: "HeatmapLayer",
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(o) {
+    const e = v(), t = _(q, v()), s = _(R, v());
+    return O(
+      [t, () => o.options],
+      ([r, n], [a, c]) => {
+        var d;
+        const i = !A(n, c) || t.value !== a;
+        if (t.value && s.value && i) {
+          const u = structuredClone(n);
+          if (u.data && !(u.data instanceof s.value.MVCArray)) {
+            const l = s.value.LatLng;
+            u.data = (d = u.data) == null ? void 0 : d.map((h) => h instanceof l || "location" in h && (h.location instanceof l || h.location === null) ? h : "location" in h ? { ...h, location: new l(h.location) } : new l(h));
+          }
+          e.value ? e.value.setOptions(u) : e.value = E(
+            new s.value.visualization.HeatmapLayer({
+              ...u,
+              map: t.value
+            })
+          );
+        }
+      },
+      { immediate: !0 }
+    ), j(() => {
+      e.value && e.value.setMap(null);
+    }), { heatmapLayer: e };
+  },
+  render: () => null
+});
+export {
+  St as Circle,
+  At as CustomControl,
+  $t as CustomMarker,
+  Ot as GoogleMap,
+  jt as HeatmapLayer,
+  Tt as InfoWindow,
+  Pt as Marker,
+  It as MarkerCluster,
+  Et as Polygon,
+  xt as Polyline,
+  Lt as Rectangle
+};