vue3-google-map 0.14.1 → 0.16.0

package/dist/index.es.js

@@ -0,0 +1,1568 @@
+(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 Oe = Object.defineProperty;
+var xe = (o, e, t) => e in o ? Oe(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var V = (o, e, t) => (xe(o, typeof e != "symbol" ? e + "" : e, t), t);
+import { defineComponent as k, ref as v, provide as q, watch as b, onMounted as ge, onBeforeUnmount as S, markRaw as M, toRef as L, openBlock as F, createElementBlock as G, createElementVNode as Y, renderSlot as U, normalizeProps as Pe, guardReactiveProps as Se, inject as y, computed as z, withDirectives as Le, vShow as Ie, Comment as ve, mergeProps as ye, createCommentVNode as Ce } from "vue";
+const I = Symbol("map"), E = Symbol("api"), _e = Symbol("marker"), ke = Symbol("markerCluster"), H = Symbol("CustomMarker"), we = Symbol("mapTilesLoaded"), P = [
+  "click",
+  "dblclick",
+  "drag",
+  "dragend",
+  "dragstart",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "rightclick"
+];
+var Ee = 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 n, s, r;
+    if (Array.isArray(e)) {
+      if (n = e.length, n != t.length)
+        return !1;
+      for (s = n; s-- !== 0; )
+        if (!o(e[s], t[s]))
+          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 (r = Object.keys(e), n = r.length, n !== Object.keys(t).length)
+      return !1;
+    for (s = n; s-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(t, r[s]))
+        return !1;
+    for (s = n; s-- !== 0; ) {
+      var a = r[s];
+      if (!o(e[a], t[a]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+};
+const ne = "__googleMapsScriptId";
+class O {
+  /**
+   * 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: n, id: s = ne, libraries: r = [], language: a, region: l, version: i, mapIds: p, nonce: u, retries: c = 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 = n, this.id = s || ne, this.libraries = r, this.language = a, this.region = l, this.mapIds = p, this.nonce = u, this.retries = c, this.url = h, O.instance) {
+      if (!Ee(this.options, O.instance.options))
+        throw new Error(`Loader must not be called again with different options. ${JSON.stringify(this.options)} !== ${JSON.stringify(O.instance.options)}`);
+      return O.instance;
+    }
+    O.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((n) => {
+        n ? t(n.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 $e(o) {
+  return class extends o.OverlayView {
+    constructor(n) {
+      super();
+      V(this, "element");
+      V(this, "opts");
+      const { element: s, ...r } = n;
+      this.element = s, this.opts = r, 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 n = this.element;
+      return n.style.display !== "none" && n.style.visibility !== "hidden" && (n.style.opacity === "" || Number(n.style.opacity) > 0.01);
+    }
+    onAdd() {
+      if (!this.element)
+        return;
+      const n = this.getPanes();
+      n && n.overlayMouseTarget.appendChild(this.element);
+    }
+    draw() {
+      if (!this.element)
+        return;
+      const s = this.getProjection().fromLatLngToDivPixel(this.getPosition());
+      if (s) {
+        this.element.style.position = "absolute";
+        const r = this.element.offsetHeight, a = this.element.offsetWidth;
+        let l, i;
+        switch (this.opts.anchorPoint) {
+          case "TOP_CENTER":
+            l = s.x - a / 2, i = s.y;
+            break;
+          case "BOTTOM_CENTER":
+            l = s.x - a / 2, i = s.y - r;
+            break;
+          case "LEFT_CENTER":
+            l = s.x, i = s.y - r / 2;
+            break;
+          case "RIGHT_CENTER":
+            l = s.x - a, i = s.y - r / 2;
+            break;
+          case "TOP_LEFT":
+            l = s.x, i = s.y;
+            break;
+          case "TOP_RIGHT":
+            l = s.x - a, i = s.y;
+            break;
+          case "BOTTOM_LEFT":
+            l = s.x, i = s.y - r;
+            break;
+          case "BOTTOM_RIGHT":
+            l = s.x - a, i = s.y - r;
+            break;
+          default:
+            l = s.x - a / 2, i = s.y - r / 2;
+        }
+        this.element.style.left = l + "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(n) {
+      this.opts = n, this.draw();
+    }
+  };
+}
+let oe;
+const re = [
+  "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"
+], je = k({
+  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: re,
+  setup(o, { emit: e }) {
+    const t = v(), n = v(!1), s = v(), r = v(), a = v(!1);
+    q(I, s), q(E, r), q(we, a);
+    const l = () => {
+      const c = { ...o };
+      Object.keys(c).forEach((m) => {
+        c[m] === void 0 && delete c[m];
+      });
+      const f = (m) => {
+        var g;
+        return m ? { position: (g = r.value) == null ? void 0 : g.ControlPosition[m] } : {};
+      }, d = {
+        scaleControlOptions: o.scaleControlStyle ? { style: o.scaleControlStyle } : {},
+        panControlOptions: f(o.panControlPosition),
+        zoomControlOptions: f(o.zoomControlPosition),
+        rotateControlOptions: f(o.rotateControlPosition),
+        streetViewControlOptions: f(o.streetViewControlPosition),
+        fullscreenControlOptions: f(o.fullscreenControlPosition),
+        disableDefaultUI: o.disableDefaultUi
+      };
+      return { ...c, ...d };
+    }, i = b(
+      [r, s],
+      ([c, h]) => {
+        const f = c, d = h;
+        f && d && (f.event.addListenerOnce(d, "tilesloaded", () => {
+          a.value = !0;
+        }), setTimeout(i, 0));
+      },
+      { immediate: !0 }
+    ), p = () => {
+      try {
+        const { apiKey: c, region: h, version: f, language: d, libraries: m } = o;
+        oe = new O({ apiKey: c, region: h, version: f, language: d, libraries: m });
+      } catch (c) {
+        console.error(c);
+      }
+    }, u = (c) => {
+      r.value = M(c.maps), s.value = M(new c.maps.Map(t.value, l()));
+      const h = $e(r.value);
+      r.value[H] = h, re.forEach((d) => {
+        var m;
+        (m = s.value) == null || m.addListener(d, (g) => e(d, g));
+      }), n.value = !0;
+      const f = Object.keys(o).filter(
+        (d) => !["apiPromise", "apiKey", "version", "libraries", "region", "language", "center", "zoom"].includes(d)
+      ).map((d) => L(o, d));
+      b(
+        [() => o.center, () => o.zoom, ...f],
+        ([d, m], [g, C]) => {
+          var ee, te, se;
+          const { center: w, zoom: j, ..._ } = l();
+          (ee = s.value) == null || ee.setOptions(_), m !== void 0 && m !== C && ((te = s.value) == null || te.setZoom(m));
+          const Z = !g || d.lng !== g.lng || d.lat !== g.lat;
+          d && Z && ((se = s.value) == null || se.panTo(d));
+        }
+      );
+    };
+    return ge(() => {
+      o.apiPromise && o.apiPromise instanceof Promise ? o.apiPromise.then(u) : (p(), oe.load().then(u));
+    }), S(() => {
+      var c;
+      a.value = !1, s.value && ((c = r.value) == null || c.event.clearInstanceListeners(s.value));
+    }), { mapRef: t, ready: n, map: s, api: r, mapTilesLoaded: a };
+  }
+});
+const K = (o, e) => {
+  const t = o.__vccOpts || o;
+  for (const [n, s] of e)
+    t[n] = s;
+  return t;
+}, Te = {
+  ref: "mapRef",
+  class: "mapdiv"
+};
+function qe(o, e, t, n, s, r) {
+  return F(), G("div", null, [
+    Y("div", Te, null, 512),
+    U(o.$slots, "default", Pe(Se({ ready: o.ready, map: o.map, api: o.api, mapTilesLoaded: o.mapTilesLoaded })), void 0, !0)
+  ]);
+}
+const vt = /* @__PURE__ */ K(je, [["render", qe], ["__scopeId", "data-v-7d660dd5"]]);
+function Re(o) {
+  return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
+}
+var Ae = 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 n, s, r;
+    if (Array.isArray(e)) {
+      if (n = e.length, n != t.length)
+        return !1;
+      for (s = n; s-- !== 0; )
+        if (!o(e[s], t[s]))
+          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 (r = Object.keys(e), n = r.length, n !== Object.keys(t).length)
+      return !1;
+    for (s = n; s-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(t, r[s]))
+        return !1;
+    for (s = n; s-- !== 0; ) {
+      var a = r[s];
+      if (!o(e[a], t[a]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+};
+const A = /* @__PURE__ */ Re(Ae), Ze = (o) => o === "Marker", Be = (o) => o === H, $ = (o, e, t, n) => {
+  const s = v(), r = y(I, v()), a = y(E, v()), l = y(ke, v()), i = z(
+    () => !!(l.value && a.value && (s.value instanceof a.value.Marker || s.value instanceof a.value[H]))
+  );
+  return b(
+    [r, t],
+    (p, [u, c]) => {
+      var f, d, m;
+      const h = !A(t.value, c) || r.value !== u;
+      !r.value || !a.value || !h || (s.value ? (s.value.setOptions(t.value), i.value && ((f = l.value) == null || f.removeMarker(s.value), (d = l.value) == null || d.addMarker(s.value))) : (Ze(o) ? s.value = M(
+        new a.value[o](t.value)
+      ) : Be(o) ? s.value = M(
+        new a.value[o](t.value)
+      ) : s.value = M(
+        new a.value[o]({
+          ...t.value,
+          map: r.value
+        })
+      ), i.value ? (m = l.value) == null || m.addMarker(s.value) : s.value.setMap(r.value), e.forEach((g) => {
+        var C;
+        (C = s.value) == null || C.addListener(g, (w) => n(g, w));
+      })));
+    },
+    {
+      immediate: !0
+    }
+  ), S(() => {
+    var p, u;
+    s.value && ((p = a.value) == null || p.event.clearInstanceListeners(s.value), i.value ? (u = l.value) == null || u.removeMarker(s.value) : s.value.setMap(null));
+  }), s;
+}, ie = [
+  "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"
+], yt = k({
+  name: "Marker",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: ie,
+  setup(o, { emit: e, expose: t, slots: n }) {
+    const s = L(o, "options"), r = $("Marker", ie, s, e);
+    return q(_e, r), t({ marker: r }), () => {
+      var a;
+      return (a = n.default) == null ? void 0 : a.call(n);
+    };
+  }
+}), Ct = k({
+  name: "Polyline",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: P,
+  setup(o, { emit: e }) {
+    const t = L(o, "options");
+    return { polyline: $("Polyline", P, t, e) };
+  },
+  render: () => null
+}), _t = k({
+  name: "Polygon",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: P,
+  setup(o, { emit: e }) {
+    const t = L(o, "options");
+    return { polygon: $("Polygon", P, t, e) };
+  },
+  render: () => null
+}), ae = P.concat(["bounds_changed"]), kt = k({
+  name: "Rectangle",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: ae,
+  setup(o, { emit: e }) {
+    const t = L(o, "options");
+    return { rectangle: $("Rectangle", ae, t, e) };
+  },
+  render: () => null
+}), le = P.concat(["center_changed", "radius_changed"]), wt = k({
+  name: "Circle",
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: le,
+  setup(o, { emit: e }) {
+    const t = L(o, "options");
+    return { circle: $("Circle", le, t, e) };
+  },
+  render: () => null
+}), Ne = k({
+  props: {
+    position: {
+      type: String,
+      required: !0
+    },
+    index: {
+      type: Number,
+      default: 1
+    }
+  },
+  emits: ["content:loaded"],
+  setup(o, { emit: e }) {
+    const t = v(null), n = y(I, v()), s = y(E, v()), r = y(we, v(!1)), a = v(!1), l = b(
+      [r, s, t],
+      ([u, c, h]) => {
+        c && u && h && (i(o.position), a.value = !0, e("content:loaded"), setTimeout(l, 0));
+      },
+      { immediate: !0 }
+    ), i = (u) => {
+      if (n.value && s.value && t.value) {
+        const c = s.value.ControlPosition[u];
+        n.value.controls[c].push(t.value);
+      }
+    }, p = (u) => {
+      if (n.value && s.value) {
+        let c = null;
+        const h = s.value.ControlPosition[u];
+        n.value.controls[h].forEach((f, d) => {
+          f === t.value && (c = d);
+        }), c !== null && n.value.controls[h].removeAt(c);
+      }
+    };
+    return S(() => p(o.position)), b(
+      () => o.position,
+      (u, c) => {
+        p(c), i(u);
+      }
+    ), b(
+      () => o.index,
+      (u) => {
+        u && t.value && (t.value.index = o.index);
+      }
+    ), { controlRef: t, showContent: a };
+  }
+}), ze = { ref: "controlRef" };
+function De(o, e, t, n, s, r) {
+  return Le((F(), G("div", ze, [
+    U(o.$slots, "default")
+  ], 512)), [
+    [Ie, o.showContent]
+  ]);
+}
+const bt = /* @__PURE__ */ K(Ne, [["render", De]]), ce = ["closeclick", "content_changed", "domready", "position_changed", "visible", "zindex_changed"], Fe = k({
+  inheritAttrs: !1,
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ce,
+  setup(o, { slots: e, emit: t, expose: n }) {
+    const s = v(), r = v(), a = y(I, v()), l = y(E, v()), i = y(_e, v());
+    let p;
+    const u = z(() => {
+      var f;
+      return (f = e.default) == null ? void 0 : f.call(e).some((d) => d.type !== ve);
+    }), c = (f) => {
+      var d;
+      return (d = s.value) == null ? void 0 : d.open({ map: a.value, anchor: i.value, ...f });
+    }, h = () => {
+      var f;
+      return (f = s.value) == null ? void 0 : f.close();
+    };
+    return ge(() => {
+      b(
+        [a, () => o.options],
+        ([f, d], [m, g]) => {
+          const C = !A(d, g) || a.value !== m;
+          a.value && l.value && C && (s.value ? (s.value.setOptions({
+            ...d,
+            content: u.value ? r.value : d.content
+          }), i.value || c()) : (s.value = M(
+            new l.value.InfoWindow({
+              ...d,
+              content: u.value ? r.value : d.content
+            })
+          ), i.value ? p = i.value.addListener("click", () => {
+            c();
+          }) : c(), ce.forEach((w) => {
+            var j;
+            (j = s.value) == null || j.addListener(w, (_) => t(w, _));
+          })));
+        },
+        {
+          immediate: !0
+        }
+      );
+    }), S(() => {
+      var f;
+      p && p.remove(), s.value && ((f = l.value) == null || f.event.clearInstanceListeners(s.value), h());
+    }), n({ infoWindow: s, open: c, close: h }), { infoWindow: s, infoWindowRef: r, hasSlotContent: u, open: c, close: h };
+  }
+});
+const Ge = {
+  key: 0,
+  class: "info-window-wrapper"
+};
+function Ue(o, e, t, n, s, r) {
+  return o.hasSlotContent ? (F(), G("div", Ge, [
+    Y("div", ye({ ref: "infoWindowRef" }, o.$attrs), [
+      U(o.$slots, "default", {}, void 0, !0)
+    ], 16)
+  ])) : Ce("", !0);
+}
+const Mt = /* @__PURE__ */ K(Fe, [["render", Ue], ["__scopeId", "data-v-45a4606d"]]);
+function J(o, e, t, n, s, r) {
+  if (s - n <= t)
+    return;
+  const a = n + s >> 1;
+  be(o, e, a, n, s, r % 2), J(o, e, t, n, a - 1, r + 1), J(o, e, t, a + 1, s, r + 1);
+}
+function be(o, e, t, n, s, r) {
+  for (; s > n; ) {
+    if (s - n > 600) {
+      const p = s - n + 1, u = t - n + 1, c = Math.log(p), h = 0.5 * Math.exp(2 * c / 3), f = 0.5 * Math.sqrt(c * h * (p - h) / p) * (u - p / 2 < 0 ? -1 : 1), d = Math.max(n, Math.floor(t - u * h / p + f)), m = Math.min(s, Math.floor(t + (p - u) * h / p + f));
+      be(o, e, t, d, m, r);
+    }
+    const a = e[2 * t + r];
+    let l = n, i = s;
+    for (T(o, e, n, t), e[2 * s + r] > a && T(o, e, n, s); l < i; ) {
+      for (T(o, e, l, i), l++, i--; e[2 * l + r] < a; )
+        l++;
+      for (; e[2 * i + r] > a; )
+        i--;
+    }
+    e[2 * n + r] === a ? T(o, e, n, i) : (i++, T(o, e, i, s)), i <= t && (n = i + 1), t <= i && (s = i - 1);
+  }
+}
+function T(o, e, t, n) {
+  W(o, t, n), W(e, 2 * t, 2 * n), W(e, 2 * t + 1, 2 * n + 1);
+}
+function W(o, e, t) {
+  const n = o[e];
+  o[e] = o[t], o[t] = n;
+}
+function He(o, e, t, n, s, r, a) {
+  const l = [0, o.length - 1, 0], i = [];
+  let p, u;
+  for (; l.length; ) {
+    const c = l.pop(), h = l.pop(), f = l.pop();
+    if (h - f <= a) {
+      for (let g = f; g <= h; g++)
+        p = e[2 * g], u = e[2 * g + 1], p >= t && p <= s && u >= n && u <= r && i.push(o[g]);
+      continue;
+    }
+    const d = Math.floor((f + h) / 2);
+    p = e[2 * d], u = e[2 * d + 1], p >= t && p <= s && u >= n && u <= r && i.push(o[d]);
+    const m = (c + 1) % 2;
+    (c === 0 ? t <= p : n <= u) && (l.push(f), l.push(d - 1), l.push(m)), (c === 0 ? s >= p : r >= u) && (l.push(d + 1), l.push(h), l.push(m));
+  }
+  return i;
+}
+function Ke(o, e, t, n, s, r) {
+  const a = [0, o.length - 1, 0], l = [], i = s * s;
+  for (; a.length; ) {
+    const p = a.pop(), u = a.pop(), c = a.pop();
+    if (u - c <= r) {
+      for (let g = c; g <= u; g++)
+        ue(e[2 * g], e[2 * g + 1], t, n) <= i && l.push(o[g]);
+      continue;
+    }
+    const h = Math.floor((c + u) / 2), f = e[2 * h], d = e[2 * h + 1];
+    ue(f, d, t, n) <= i && l.push(o[h]);
+    const m = (p + 1) % 2;
+    (p === 0 ? t - s <= f : n - s <= d) && (a.push(c), a.push(h - 1), a.push(m)), (p === 0 ? t + s >= f : n + s >= d) && (a.push(h + 1), a.push(u), a.push(m));
+  }
+  return l;
+}
+function ue(o, e, t, n) {
+  const s = o - t, r = e - n;
+  return s * s + r * r;
+}
+const Ve = (o) => o[0], We = (o) => o[1];
+class pe {
+  constructor(e, t = Ve, n = We, s = 64, r = Float64Array) {
+    this.nodeSize = s, this.points = e;
+    const a = e.length < 65536 ? Uint16Array : Uint32Array, l = this.ids = new a(e.length), i = this.coords = new r(e.length * 2);
+    for (let p = 0; p < e.length; p++)
+      l[p] = p, i[2 * p] = t(e[p]), i[2 * p + 1] = n(e[p]);
+    J(l, i, s, 0, l.length - 1, 0);
+  }
+  range(e, t, n, s) {
+    return He(this.ids, this.coords, e, t, n, s, this.nodeSize);
+  }
+  within(e, t, n) {
+    return Ke(this.ids, this.coords, e, t, n, this.nodeSize);
+  }
+}
+const Je = {
+  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})
+}, D = Math.fround || ((o) => (e) => (o[0] = +e, o[0]))(new Float32Array(1));
+class Xe {
+  constructor(e) {
+    this.options = R(Object.create(Je), e), this.trees = new Array(this.options.maxZoom + 1);
+  }
+  load(e) {
+    const { log: t, minZoom: n, maxZoom: s, nodeSize: r } = this.options;
+    t && console.time("total time");
+    const a = `prepare ${e.length} points`;
+    t && console.time(a), this.points = e;
+    let l = [];
+    for (let i = 0; i < e.length; i++)
+      e[i].geometry && l.push(Qe(e[i], i));
+    this.trees[s + 1] = new pe(l, he, fe, r, Float32Array), t && console.timeEnd(a);
+    for (let i = s; i >= n; i--) {
+      const p = +Date.now();
+      l = this._cluster(l, i), this.trees[i] = new pe(l, he, fe, r, Float32Array), t && console.log("z%d: %d clusters in %dms", i, l.length, +Date.now() - p);
+    }
+    return t && console.timeEnd("total time"), this;
+  }
+  getClusters(e, t) {
+    let n = ((e[0] + 180) % 360 + 360) % 360 - 180;
+    const s = Math.max(-90, Math.min(90, e[1]));
+    let r = 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)
+      n = -180, r = 180;
+    else if (n > r) {
+      const u = this.getClusters([n, s, 180, a], t), c = this.getClusters([-180, s, r, a], t);
+      return u.concat(c);
+    }
+    const l = this.trees[this._limitZoom(t)], i = l.range(B(n), N(a), B(r), N(s)), p = [];
+    for (const u of i) {
+      const c = l.points[u];
+      p.push(c.numPoints ? de(c) : this.points[c.index]);
+    }
+    return p;
+  }
+  getChildren(e) {
+    const t = this._getOriginId(e), n = this._getOriginZoom(e), s = "No cluster with the specified id.", r = this.trees[n];
+    if (!r)
+      throw new Error(s);
+    const a = r.points[t];
+    if (!a)
+      throw new Error(s);
+    const l = this.options.radius / (this.options.extent * Math.pow(2, n - 1)), i = r.within(a.x, a.y, l), p = [];
+    for (const u of i) {
+      const c = r.points[u];
+      c.parentId === e && p.push(c.numPoints ? de(c) : this.points[c.index]);
+    }
+    if (p.length === 0)
+      throw new Error(s);
+    return p;
+  }
+  getLeaves(e, t, n) {
+    t = t || 10, n = n || 0;
+    const s = [];
+    return this._appendLeaves(s, e, t, n, 0), s;
+  }
+  getTile(e, t, n) {
+    const s = this.trees[this._limitZoom(e)], r = Math.pow(2, e), { extent: a, radius: l } = this.options, i = l / a, p = (n - i) / r, u = (n + 1 + i) / r, c = {
+      features: []
+    };
+    return this._addTileFeatures(
+      s.range((t - i) / r, p, (t + 1 + i) / r, u),
+      s.points,
+      t,
+      n,
+      r,
+      c
+    ), t === 0 && this._addTileFeatures(
+      s.range(1 - i / r, p, 1, u),
+      s.points,
+      r,
+      n,
+      r,
+      c
+    ), t === r - 1 && this._addTileFeatures(
+      s.range(0, p, i / r, u),
+      s.points,
+      -1,
+      n,
+      r,
+      c
+    ), c.features.length ? c : null;
+  }
+  getClusterExpansionZoom(e) {
+    let t = this._getOriginZoom(e) - 1;
+    for (; t <= this.options.maxZoom; ) {
+      const n = this.getChildren(e);
+      if (t++, n.length !== 1)
+        break;
+      e = n[0].properties.cluster_id;
+    }
+    return t;
+  }
+  _appendLeaves(e, t, n, s, r) {
+    const a = this.getChildren(t);
+    for (const l of a) {
+      const i = l.properties;
+      if (i && i.cluster ? r + i.point_count <= s ? r += i.point_count : r = this._appendLeaves(e, i.cluster_id, n, s, r) : r < s ? r++ : e.push(l), e.length === n)
+        break;
+    }
+    return r;
+  }
+  _addTileFeatures(e, t, n, s, r, a) {
+    for (const l of e) {
+      const i = t[l], p = i.numPoints;
+      let u, c, h;
+      if (p)
+        u = Me(i), c = i.x, h = i.y;
+      else {
+        const m = this.points[i.index];
+        u = m.properties, c = B(m.geometry.coordinates[0]), h = N(m.geometry.coordinates[1]);
+      }
+      const f = {
+        type: 1,
+        geometry: [[
+          Math.round(this.options.extent * (c * r - n)),
+          Math.round(this.options.extent * (h * r - s))
+        ]],
+        tags: u
+      };
+      let d;
+      p ? d = i.id : this.options.generateId ? d = i.index : this.points[i.index].id && (d = this.points[i.index].id), d !== void 0 && (f.id = d), a.features.push(f);
+    }
+  }
+  _limitZoom(e) {
+    return Math.max(this.options.minZoom, Math.min(Math.floor(+e), this.options.maxZoom + 1));
+  }
+  _cluster(e, t) {
+    const n = [], { radius: s, extent: r, reduce: a, minPoints: l } = this.options, i = s / (r * Math.pow(2, t));
+    for (let p = 0; p < e.length; p++) {
+      const u = e[p];
+      if (u.zoom <= t)
+        continue;
+      u.zoom = t;
+      const c = this.trees[t + 1], h = c.within(u.x, u.y, i), f = u.numPoints || 1;
+      let d = f;
+      for (const m of h) {
+        const g = c.points[m];
+        g.zoom > t && (d += g.numPoints || 1);
+      }
+      if (d > f && d >= l) {
+        let m = u.x * f, g = u.y * f, C = a && f > 1 ? this._map(u, !0) : null;
+        const w = (p << 5) + (t + 1) + this.points.length;
+        for (const j of h) {
+          const _ = c.points[j];
+          if (_.zoom <= t)
+            continue;
+          _.zoom = t;
+          const Z = _.numPoints || 1;
+          m += _.x * Z, g += _.y * Z, _.parentId = w, a && (C || (C = this._map(u, !0)), a(C, this._map(_)));
+        }
+        u.parentId = w, n.push(Ye(m / d, g / d, w, d, C));
+      } else if (n.push(u), d > 1)
+        for (const m of h) {
+          const g = c.points[m];
+          g.zoom <= t || (g.zoom = t, n.push(g));
+        }
+    }
+    return n;
+  }
+  // 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) {
+    if (e.numPoints)
+      return t ? R({}, e.properties) : e.properties;
+    const n = this.points[e.index].properties, s = this.options.map(n);
+    return t && s === n ? R({}, s) : s;
+  }
+}
+function Ye(o, e, t, n, s) {
+  return {
+    x: D(o),
+    // weighted cluster center; round for consistency with Float32Array index
+    y: D(e),
+    zoom: 1 / 0,
+    // the last zoom the cluster was processed at
+    id: t,
+    // encodes index of the first child of the cluster and its zoom level
+    parentId: -1,
+    // parent cluster id
+    numPoints: n,
+    properties: s
+  };
+}
+function Qe(o, e) {
+  const [t, n] = o.geometry.coordinates;
+  return {
+    x: D(B(t)),
+    // projected point coordinates
+    y: D(N(n)),
+    zoom: 1 / 0,
+    // the last zoom the point was processed at
+    index: e,
+    // index of the source feature in the original input array,
+    parentId: -1
+    // parent cluster id
+  };
+}
+function de(o) {
+  return {
+    type: "Feature",
+    id: o.id,
+    properties: Me(o),
+    geometry: {
+      type: "Point",
+      coordinates: [et(o.x), tt(o.y)]
+    }
+  };
+}
+function Me(o) {
+  const e = o.numPoints, t = e >= 1e4 ? `${Math.round(e / 1e3)}k` : e >= 1e3 ? `${Math.round(e / 100) / 10}k` : e;
+  return R(R({}, o.properties), {
+    cluster: !0,
+    cluster_id: o.id,
+    point_count: e,
+    point_count_abbreviated: t
+  });
+}
+function B(o) {
+  return o / 360 + 0.5;
+}
+function N(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 et(o) {
+  return (o - 0.5) * 360;
+}
+function tt(o) {
+  const e = (180 - o * 360) * Math.PI / 180;
+  return 360 * Math.atan(Math.exp(e)) / Math.PI - 90;
+}
+function R(o, e) {
+  for (const t in e)
+    o[t] = e[t];
+  return o;
+}
+function he(o) {
+  return o.x;
+}
+function fe(o) {
+  return o.y;
+}
+/*! *****************************************************************************
+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 st(o, e) {
+  var t = {};
+  for (var n in o)
+    Object.prototype.hasOwnProperty.call(o, n) && e.indexOf(n) < 0 && (t[n] = o[n]);
+  if (o != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var s = 0, n = Object.getOwnPropertySymbols(o); s < n.length; s++)
+      e.indexOf(n[s]) < 0 && Object.prototype.propertyIsEnumerable.call(o, n[s]) && (t[n[s]] = o[n[s]]);
+  return t;
+}
+class X {
+  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 this.markers.reduce((e, t) => e.extend(t.getPosition()), new google.maps.LatLngBounds(this._position, this._position));
+  }
+  get position() {
+    return this._position || this.bounds.getCenter();
+  }
+  /**
+   * Get the count of **visible** markers.
+   */
+  get count() {
+    return this.markers.filter((e) => e.getVisible()).length;
+  }
+  /**
+   * Add a marker to the cluster.
+   */
+  push(e) {
+    this.markers.push(e);
+  }
+  /**
+   * Cleanup references and remove marker from map.
+   */
+  delete() {
+    this.marker && (this.marker.setMap(null), delete this.marker), this.markers.length = 0;
+  }
+}
+class nt {
+  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, map})
+   *    }
+   * }
+   * ```
+   */
+  noop({ markers: e }) {
+    return ot(e);
+  }
+}
+const ot = (o) => o.map((t) => new X({
+  position: t.getPosition(),
+  markers: [t]
+}));
+class rt extends nt {
+  constructor(e) {
+    var { maxZoom: t, radius: n = 60 } = e, s = st(e, ["maxZoom", "radius"]);
+    super({ maxZoom: t }), this.superCluster = new Xe(Object.assign({ maxZoom: this.maxZoom, radius: n }, s)), this.state = { zoom: null };
+  }
+  calculate(e) {
+    let t = !1;
+    if (!A(e.markers, this.markers)) {
+      t = !0, this.markers = [...e.markers];
+      const s = this.markers.map((r) => ({
+        type: "Feature",
+        geometry: {
+          type: "Point",
+          coordinates: [
+            r.getPosition().lng(),
+            r.getPosition().lat()
+          ]
+        },
+        properties: { marker: r }
+      }));
+      this.superCluster.load(s);
+    }
+    const n = { zoom: e.map.getZoom() };
+    return t || this.state.zoom > this.maxZoom && n.zoom > this.maxZoom || (t = t || !A(this.state, n)), this.state = n, 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(this.transformCluster.bind(this));
+  }
+  transformCluster({ geometry: { coordinates: [e, t] }, properties: n }) {
+    if (n.cluster)
+      return new X({
+        markers: this.superCluster.getLeaves(n.cluster_id, 1 / 0).map((s) => s.properties.marker),
+        position: new google.maps.LatLng({ lat: t, lng: e })
+      });
+    {
+      const s = n.marker;
+      return new X({
+        markers: [s],
+        position: s.getPosition()
+      });
+    }
+  }
+}
+class it {
+  constructor(e, t) {
+    this.markers = { sum: e.length };
+    const n = t.map((r) => r.count), s = n.reduce((r, a) => r + a, 0);
+    this.clusters = {
+      count: t.length,
+      markers: {
+        mean: s / t.length,
+        sum: s,
+        min: Math.min(...n),
+        max: Math.max(...n)
+      }
+    };
+  }
+}
+class at {
+  /**
+   * 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 }, n) {
+    const s = e > Math.max(10, n.clusters.markers.mean) ? "#ff0000" : "#0000ff", r = window.btoa(`
+  <svg fill="${s}" 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" />
+  </svg>`);
+    return new google.maps.Marker({
+      position: t,
+      icon: {
+        url: `data:image/svg+xml;base64,${r}`,
+        scaledSize: new google.maps.Size(45, 45)
+      },
+      label: {
+        text: String(e),
+        color: "rgba(255,255,255,0.9)",
+        fontSize: "12px"
+      },
+      title: `Cluster of ${e} markers`,
+      // adjust zIndex to be above other markers
+      zIndex: Number(google.maps.Marker.MAX_ZINDEX) + e
+    });
+  }
+}
+function lt(o, e) {
+  for (let t in e.prototype)
+    o.prototype[t] = e.prototype[t];
+}
+class Q {
+  constructor() {
+    lt(Q, google.maps.OverlayView);
+  }
+}
+var x;
+(function(o) {
+  o.CLUSTERING_BEGIN = "clusteringbegin", o.CLUSTERING_END = "clusteringend", o.CLUSTER_CLICK = "click";
+})(x || (x = {}));
+const ct = (o, e, t) => {
+  t.fitBounds(e.bounds);
+};
+class ut extends Q {
+  constructor({ map: e, markers: t = [], algorithm: n = new rt({}), renderer: s = new at(), onClusterClick: r = ct }) {
+    super(), this.markers = [...t], this.clusters = [], this.algorithm = n, this.renderer = s, this.onClusterClick = r, e && this.setMap(e);
+  }
+  addMarker(e, t) {
+    this.markers.includes(e) || (this.markers.push(e), t || this.render());
+  }
+  addMarkers(e, t) {
+    e.forEach((n) => {
+      this.addMarker(n, !0);
+    }), t || this.render();
+  }
+  removeMarker(e, t) {
+    const n = this.markers.indexOf(e);
+    return n === -1 ? !1 : (e.setMap(null), this.markers.splice(n, 1), t || this.render(), !0);
+  }
+  removeMarkers(e, t) {
+    let n = !1;
+    return e.forEach((s) => {
+      n = this.removeMarker(s, !0) || n;
+    }), n && !t && this.render(), n;
+  }
+  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 && this.getProjection()) {
+      google.maps.event.trigger(this, x.CLUSTERING_BEGIN, this);
+      const { clusters: t, changed: n } = this.algorithm.calculate({
+        markers: this.markers,
+        map: e,
+        mapCanvasProjection: this.getProjection()
+      });
+      (n || n == null) && (this.reset(), this.clusters = t, this.renderClusters()), google.maps.event.trigger(this, x.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) => e.setMap(null)), this.clusters.forEach((e) => e.delete()), this.clusters = [];
+  }
+  renderClusters() {
+    const e = new it(this.markers, this.clusters), t = this.getMap();
+    this.clusters.forEach((n) => {
+      n.markers.length === 1 ? n.marker = n.markers[0] : (n.marker = this.renderer.render(n, e), this.onClusterClick && n.marker.addListener(
+        "click",
+        /* istanbul ignore next */
+        (s) => {
+          google.maps.event.trigger(this, x.CLUSTER_CLICK, n), this.onClusterClick(s, n, t);
+        }
+      )), n.marker.setMap(t);
+    });
+  }
+}
+const me = Object.values(x), Ot = k({
+  name: "MarkerCluster",
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: me,
+  setup(o, { emit: e, expose: t, slots: n }) {
+    const s = v(), r = y(I, v()), a = y(E, v());
+    return q(ke, s), b(
+      r,
+      () => {
+        r.value && (s.value = M(new ut({ map: r.value, ...o.options })), me.forEach((l) => {
+          var i;
+          (i = s.value) == null || i.addListener(l, (p) => e(l, p));
+        }));
+      },
+      {
+        immediate: !0
+      }
+    ), S(() => {
+      var l;
+      s.value && ((l = a.value) == null || l.event.clearInstanceListeners(s.value), s.value.clearMarkers(), s.value.setMap(null));
+    }), t({ markerCluster: s }), () => {
+      var l;
+      return (l = n.default) == null ? void 0 : l.call(n);
+    };
+  }
+}), pt = k({
+  inheritAttrs: !1,
+  props: {
+    options: {
+      type: Object,
+      required: !0
+    }
+  },
+  setup(o, { slots: e, emit: t, expose: n }) {
+    const s = v(), r = z(() => {
+      var i;
+      return (i = e.default) == null ? void 0 : i.call(e).some((p) => p.type !== ve);
+    }), a = z(() => ({
+      ...o.options,
+      element: s.value
+    })), l = $(H, [], a, t);
+    return n({
+      customMarker: l
+    }), { customMarkerRef: s, customMarker: l, hasSlotContent: r };
+  }
+});
+const dt = {
+  key: 0,
+  class: "custom-marker-wrapper"
+};
+function ht(o, e, t, n, s, r) {
+  return o.hasSlotContent ? (F(), G("div", dt, [
+    Y("div", ye({
+      ref: "customMarkerRef",
+      style: { cursor: o.$attrs.onClick ? "pointer" : void 0 }
+    }, o.$attrs), [
+      U(o.$slots, "default", {}, void 0, !0)
+    ], 16)
+  ])) : Ce("", !0);
+}
+const xt = /* @__PURE__ */ K(pt, [["render", ht], ["__scopeId", "data-v-c7599d50"]]), Pt = k({
+  name: "HeatmapLayer",
+  props: {
+    options: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(o) {
+    const e = v(), t = y(I, v()), n = y(E, v());
+    return b(
+      [t, () => o.options],
+      ([s, r], [a, l]) => {
+        var p;
+        const i = !A(r, l) || t.value !== a;
+        if (t.value && n.value && i) {
+          const u = structuredClone(r);
+          if (u.data && !(u.data instanceof n.value.MVCArray)) {
+            const c = n.value.LatLng;
+            u.data = (p = u.data) == null ? void 0 : p.map((h) => h instanceof c || "location" in h && (h.location instanceof c || h.location === null) ? h : "location" in h ? { ...h, location: new c(h.location) } : new c(h));
+          }
+          e.value ? e.value.setOptions(u) : e.value = M(
+            new n.value.visualization.HeatmapLayer({
+              ...u,
+              map: t.value
+            })
+          );
+        }
+      },
+      { immediate: !0 }
+    ), S(() => {
+      e.value && e.value.setMap(null);
+    }), { heatmapLayer: e };
+  },
+  render: () => null
+});
+export {
+  wt as Circle,
+  bt as CustomControl,
+  xt as CustomMarker,
+  vt as GoogleMap,
+  Pt as HeatmapLayer,
+  Mt as InfoWindow,
+  yt as Marker,
+  Ot as MarkerCluster,
+  _t as Polygon,
+  Ct as Polyline,
+  kt as Rectangle
+};