@local-logic/maps 0.0.5 → 0.0.7

package/dist/index.modern-EsUgbhzI.js

@@ -0,0 +1,908 @@
+import C, { useMemo as P, useContext as z, useEffect as y, useLayoutEffect as W, forwardRef as Y, useState as A, useReducer as Q, useCallback as ee, useRef as N, useImperativeHandle as te, Children as le } from "react";
+import { createPortal as $ } from "react-dom";
+import { g as ce } from "./_commonjsHelpers-C6fGbg64.js";
+var j, J;
+function ue() {
+  return J || (J = 1, j = function t(e, n) {
+    if (e === n) return !0;
+    if (e && n && typeof e == "object" && typeof n == "object") {
+      if (e.constructor !== n.constructor) return !1;
+      var o, r, i;
+      if (Array.isArray(e)) {
+        if (o = e.length, o != n.length) return !1;
+        for (r = o; r-- !== 0; )
+          if (!t(e[r], n[r])) return !1;
+        return !0;
+      }
+      if (e.constructor === RegExp) return e.source === n.source && e.flags === n.flags;
+      if (e.valueOf !== Object.prototype.valueOf) return e.valueOf() === n.valueOf();
+      if (e.toString !== Object.prototype.toString) return e.toString() === n.toString();
+      if (i = Object.keys(e), o = i.length, o !== Object.keys(n).length) return !1;
+      for (r = o; r-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(n, i[r])) return !1;
+      for (r = o; r-- !== 0; ) {
+        var a = i[r];
+        if (!t(e[a], n[a])) return !1;
+      }
+      return !0;
+    }
+    return e !== e && n !== n;
+  }), j;
+}
+var de = ue();
+const fe = /* @__PURE__ */ ce(de);
+function k() {
+  return k = Object.assign ? Object.assign.bind() : function(t) {
+    for (var e = 1; e < arguments.length; e++) {
+      var n = arguments[e];
+      for (var o in n) ({}).hasOwnProperty.call(n, o) && (t[o] = n[o]);
+    }
+    return t;
+  }, k.apply(null, arguments);
+}
+function D(t, e) {
+  if (t == null) return {};
+  var n = {};
+  for (var o in t) if ({}.hasOwnProperty.call(t, o)) {
+    if (e.indexOf(o) !== -1) continue;
+    n[o] = t[o];
+  }
+  return n;
+}
+function ge(t, e) {
+  if (typeof t != "object" || !t) return t;
+  var n = t[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var o = n.call(t, e);
+    if (typeof o != "object") return o;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+function me(t) {
+  var e = ge(t, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+const x = {
+  NOT_LOADED: "NOT_LOADED",
+  LOADING: "LOADING",
+  LOADED: "LOADED",
+  FAILED: "FAILED",
+  AUTH_FAILURE: "AUTH_FAILURE"
+}, pe = "https://maps.googleapis.com/maps/api/js";
+class R {
+  /**
+   * Loads the Maps JavaScript API with the specified parameters.
+   * Since the Maps library can only be loaded once per page, this will
+   * produce a warning when called multiple times with different
+   * parameters.
+   *
+   * The returned promise resolves when loading completes
+   * and rejects in case of an error or when the loading was aborted.
+   */
+  static async load(e, n) {
+    var o;
+    const r = e.libraries ? e.libraries.split(",") : [], i = this.serializeParams(e);
+    this.listeners.push(n), (o = window.google) != null && (o = o.maps) != null && o.importLibrary ? (this.serializedApiParams || (this.loadingStatus = x.LOADED), this.notifyLoadingStatusListeners()) : (this.serializedApiParams = i, this.initImportLibrary(e)), this.serializedApiParams && this.serializedApiParams !== i && console.warn("[google-maps-api-loader] The maps API has already been loaded with different parameters and will not be loaded again. Refresh the page for new values to have effect.");
+    const a = ["maps", ...r];
+    await Promise.all(a.map((s) => google.maps.importLibrary(s)));
+  }
+  /**
+   * Serialize the parameters used to load the library for easier comparison.
+   */
+  static serializeParams(e) {
+    return [e.v, e.key, e.language, e.region, e.authReferrerPolicy, e.solutionChannel].join("/");
+  }
+  /**
+   * Creates the global `google.maps.importLibrary` function for bootstrapping.
+   * This is essentially a formatted version of the dynamic loading script
+   * from the official documentation with some minor adjustments.
+   *
+   * The created importLibrary function will load the Google Maps JavaScript API,
+   * which will then replace the `google.maps.importLibrary` function with the full
+   * implementation.
+   *
+   * @see https://developers.google.com/maps/documentation/javascript/load-maps-js-api#dynamic-library-import
+   */
+  static initImportLibrary(e) {
+    if (window.google || (window.google = {}), window.google.maps || (window.google.maps = {}), window.google.maps.importLibrary) {
+      console.error("[google-maps-api-loader-internal]: initImportLibrary must only be called once");
+      return;
+    }
+    let n = null;
+    const o = () => n || (n = new Promise((r, i) => {
+      var a;
+      const s = document.createElement("script"), u = new URLSearchParams();
+      for (const [d, c] of Object.entries(e)) {
+        const p = d.replace(/[A-Z]/g, (f) => "_" + f[0].toLowerCase());
+        u.set(p, String(c));
+      }
+      u.set("loading", "async"), u.set("callback", "__googleMapsCallback__"), s.async = !0, s.src = pe + "?" + u.toString(), s.nonce = ((a = document.querySelector("script[nonce]")) == null ? void 0 : a.nonce) || "", s.onerror = () => {
+        this.loadingStatus = x.FAILED, this.notifyLoadingStatusListeners(), i(new Error("The Google Maps JavaScript API could not load."));
+      }, window.__googleMapsCallback__ = () => {
+        this.loadingStatus = x.LOADED, this.notifyLoadingStatusListeners(), r();
+      }, window.gm_authFailure = () => {
+        this.loadingStatus = x.AUTH_FAILURE, this.notifyLoadingStatusListeners();
+      }, this.loadingStatus = x.LOADING, this.notifyLoadingStatusListeners(), document.head.append(s);
+    }), n);
+    google.maps.importLibrary = (r) => o().then(() => google.maps.importLibrary(r));
+  }
+  /**
+   * Calls all registered loadingStatusListeners after a status update.
+   */
+  static notifyLoadingStatusListeners() {
+    for (const e of this.listeners)
+      e(this.loadingStatus);
+  }
+}
+R.loadingStatus = x.NOT_LOADED;
+R.serializedApiParams = void 0;
+R.listeners = [];
+const he = ["onLoad", "onError", "apiKey", "version", "libraries"], ve = ["children"], Ce = "GMP_visgl_rgmlibrary_v1_default", B = C.createContext(null);
+function ye() {
+  const [t, e] = A({});
+  return {
+    mapInstances: t,
+    addMapInstance: (i, a = "default") => {
+      e((s) => k({}, s, {
+        [a]: i
+      }));
+    },
+    removeMapInstance: (i = "default") => {
+      e((a) => D(a, [i].map(me)));
+    },
+    clearMapInstances: () => {
+      e({});
+    }
+  };
+}
+function be(t) {
+  const {
+    onLoad: e,
+    onError: n,
+    apiKey: o,
+    version: r,
+    libraries: i = []
+  } = t, a = D(t, he), [s, u] = A(R.loadingStatus), [d, c] = Q((l, g) => l[g.name] ? l : k({}, l, {
+    [g.name]: g.value
+  }), {}), p = P(() => i == null ? void 0 : i.join(","), [i]), f = P(() => JSON.stringify(k({
+    apiKey: o,
+    version: r
+  }, a)), [o, r, a]), m = ee(async (l) => {
+    var g;
+    if (d[l])
+      return d[l];
+    if (!((g = google) != null && (g = g.maps) != null && g.importLibrary))
+      throw new Error("[api-provider-internal] importLibrary was called before google.maps.importLibrary was defined.");
+    const L = await window.google.maps.importLibrary(l);
+    return c({
+      name: l,
+      value: L
+    }), L;
+  }, [d]);
+  return y(
+    () => {
+      (async () => {
+        try {
+          const l = k({
+            key: o
+          }, a);
+          r && (l.v = r), (p == null ? void 0 : p.length) > 0 && (l.libraries = p), (l.channel === void 0 || l.channel < 0 || l.channel > 999) && delete l.channel, l.solutionChannel === void 0 ? l.solutionChannel = Ce : l.solutionChannel === "" && delete l.solutionChannel, await R.load(l, (g) => u(g));
+          for (const g of ["core", "maps", ...i])
+            await m(g);
+          e && e();
+        } catch (l) {
+          n ? n(l) : console.error("<ApiProvider> failed to load the Google Maps JavaScript API", l);
+        }
+      })();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [o, p, f]
+  ), {
+    status: s,
+    loadedLibraries: d,
+    importLibrary: m
+  };
+}
+const nt = (t) => {
+  const {
+    children: e
+  } = t, n = D(t, ve), {
+    mapInstances: o,
+    addMapInstance: r,
+    removeMapInstance: i,
+    clearMapInstances: a
+  } = ye(), {
+    status: s,
+    loadedLibraries: u,
+    importLibrary: d
+  } = be(n), c = P(() => ({
+    mapInstances: o,
+    addMapInstance: r,
+    removeMapInstance: i,
+    clearMapInstances: a,
+    status: s,
+    loadedLibraries: u,
+    importLibrary: d
+  }), [o, r, i, a, s, u, d]);
+  return /* @__PURE__ */ C.createElement(B.Provider, {
+    value: c
+  }, e);
+};
+function Oe(t, e) {
+  for (const n of Me) {
+    const o = e[n], r = ne[n];
+    y(() => {
+      if (!t || !o) return;
+      const i = google.maps.event.addListener(t, r, (a) => {
+        o(we(r, t, a));
+      });
+      return () => i.remove();
+    }, [t, r, o]);
+  }
+}
+function we(t, e, n) {
+  const o = {
+    type: t,
+    map: e,
+    detail: {},
+    stoppable: !1,
+    stop: () => {
+    }
+  };
+  if (Ee.includes(t)) {
+    const i = o, a = e.getCenter(), s = e.getZoom(), u = e.getHeading() || 0, d = e.getTilt() || 0, c = e.getBounds();
+    return (!a || !c || !Number.isFinite(s)) && console.warn("[createEvent] at least one of the values from the map returned undefined. This is not expected to happen. Please report an issue at https://github.com/visgl/react-google-maps/issues/new"), i.detail = {
+      center: (a == null ? void 0 : a.toJSON()) || {
+        lat: 0,
+        lng: 0
+      },
+      zoom: s || 0,
+      heading: u,
+      tilt: d,
+      bounds: (c == null ? void 0 : c.toJSON()) || {
+        north: 90,
+        east: 180,
+        south: -90,
+        west: -180
+      }
+    }, i;
+  } else if (Le.includes(t)) {
+    var r;
+    if (!n) throw new Error("[createEvent] mouse events must provide a srcEvent");
+    const i = o;
+    return i.domEvent = n.domEvent, i.stoppable = !0, i.stop = () => n.stop(), i.detail = {
+      latLng: ((r = n.latLng) == null ? void 0 : r.toJSON()) || null,
+      placeId: n.placeId
+    }, i;
+  }
+  return o;
+}
+const ne = {
+  onBoundsChanged: "bounds_changed",
+  onCenterChanged: "center_changed",
+  onClick: "click",
+  onContextmenu: "contextmenu",
+  onDblclick: "dblclick",
+  onDrag: "drag",
+  onDragend: "dragend",
+  onDragstart: "dragstart",
+  onHeadingChanged: "heading_changed",
+  onIdle: "idle",
+  onIsFractionalZoomEnabledChanged: "isfractionalzoomenabled_changed",
+  onMapCapabilitiesChanged: "mapcapabilities_changed",
+  onMapTypeIdChanged: "maptypeid_changed",
+  onMousemove: "mousemove",
+  onMouseout: "mouseout",
+  onMouseover: "mouseover",
+  onProjectionChanged: "projection_changed",
+  onRenderingTypeChanged: "renderingtype_changed",
+  onTilesLoaded: "tilesloaded",
+  onTiltChanged: "tilt_changed",
+  onZoomChanged: "zoom_changed",
+  // note: onCameraChanged is an alias for the bounds_changed event,
+  // since that is going to be fired in every situation where the camera is
+  // updated.
+  onCameraChanged: "bounds_changed"
+}, Ee = ["bounds_changed", "center_changed", "heading_changed", "tilt_changed", "zoom_changed"], Le = ["click", "contextmenu", "dblclick", "mousemove", "mouseout", "mouseover"], Me = Object.keys(ne);
+function Z(t, e) {
+  const n = N(void 0);
+  (!n.current || !fe(e, n.current)) && (n.current = e), y(t, n.current);
+}
+const Ie = /* @__PURE__ */ new Set(["backgroundColor", "clickableIcons", "controlSize", "disableDefaultUI", "disableDoubleClickZoom", "draggable", "draggableCursor", "draggingCursor", "fullscreenControl", "fullscreenControlOptions", "gestureHandling", "headingInteractionEnabled", "isFractionalZoomEnabled", "keyboardShortcuts", "mapTypeControl", "mapTypeControlOptions", "mapTypeId", "maxZoom", "minZoom", "noClear", "panControl", "panControlOptions", "restriction", "rotateControl", "rotateControlOptions", "scaleControl", "scaleControlOptions", "scrollwheel", "streetView", "streetViewControl", "streetViewControlOptions", "styles", "tiltInteractionEnabled", "zoomControl", "zoomControlOptions"]);
+function Se(t, e) {
+  const n = {}, o = Object.keys(e);
+  for (const r of o)
+    Ie.has(r) && (n[r] = e[r]);
+  Z(() => {
+    t && t.setOptions(n);
+  }, [n]);
+}
+function oe() {
+  var t;
+  return ((t = z(B)) == null ? void 0 : t.status) || x.NOT_LOADED;
+}
+function _e(t, e) {
+  const {
+    viewport: n,
+    viewState: o
+  } = e, r = !!n;
+  return W(() => {
+    if (!t || !o) return;
+    const {
+      latitude: i,
+      longitude: a,
+      bearing: s,
+      pitch: u,
+      zoom: d
+    } = o;
+    t.moveCamera({
+      center: {
+        lat: i,
+        lng: a
+      },
+      heading: s,
+      tilt: u,
+      zoom: d + 1
+    });
+  }, [t, o]), r;
+}
+function ke(t) {
+  return !t || typeof t != "object" || !("lat" in t && "lng" in t) ? !1 : Number.isFinite(t.lat) && Number.isFinite(t.lng);
+}
+function re(t) {
+  return ke(t) ? t : t.toJSON();
+}
+function xe(t, e, n) {
+  const o = n.center ? re(n.center) : null;
+  let r = null, i = null;
+  o && Number.isFinite(o.lat) && Number.isFinite(o.lng) && (r = o.lat, i = o.lng);
+  const a = Number.isFinite(n.zoom) ? n.zoom : null, s = Number.isFinite(n.heading) ? n.heading : null, u = Number.isFinite(n.tilt) ? n.tilt : null;
+  W(() => {
+    if (!t) return;
+    const d = {};
+    let c = !1;
+    r !== null && i !== null && (e.current.center.lat !== r || e.current.center.lng !== i) && (d.center = {
+      lat: r,
+      lng: i
+    }, c = !0), a !== null && e.current.zoom !== a && (d.zoom = a, c = !0), s !== null && e.current.heading !== s && (d.heading = s, c = !0), u !== null && e.current.tilt !== u && (d.tilt = u, c = !0), c && t.moveCamera(d);
+  });
+}
+const Ae = () => {
+  const t = {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    bottom: 0,
+    right: 0,
+    zIndex: 999,
+    display: "flex",
+    flexFlow: "column nowrap",
+    textAlign: "center",
+    justifyContent: "center",
+    fontSize: ".8rem",
+    color: "rgba(0,0,0,0.6)",
+    background: "#dddddd",
+    padding: "1rem 1.5rem"
+  };
+  return /* @__PURE__ */ C.createElement("div", {
+    style: t
+  }, /* @__PURE__ */ C.createElement("h2", null, "Error: AuthFailure"), /* @__PURE__ */ C.createElement("p", null, "A problem with your API key prevents the map from rendering correctly. Please make sure the value of the ", /* @__PURE__ */ C.createElement("code", null, "APIProvider.apiKey"), " prop is correct. Check the error-message in the console for further details."));
+};
+function Pe() {
+  const [t, e] = A(null), n = ee((o) => e(o), [e]);
+  return [t, n];
+}
+function ie() {
+  return oe() === x.LOADED;
+}
+function De() {
+  const [, t] = Q((e) => e + 1, 0);
+  return t;
+}
+function Te(t, e) {
+  const n = t.getCenter(), o = t.getZoom(), r = t.getHeading() || 0, i = t.getTilt() || 0, a = t.getBounds();
+  (!n || !a || !Number.isFinite(o)) && console.warn("[useTrackedCameraState] at least one of the values from the map returned undefined. This is not expected to happen. Please report an issue at https://github.com/visgl/react-google-maps/issues/new"), Object.assign(e.current, {
+    center: (n == null ? void 0 : n.toJSON()) || {
+      lat: 0,
+      lng: 0
+    },
+    zoom: o || 0,
+    heading: r,
+    tilt: i
+  });
+}
+function Fe(t) {
+  const e = De(), n = N({
+    center: {
+      lat: 0,
+      lng: 0
+    },
+    heading: 0,
+    tilt: 0,
+    zoom: 0
+  });
+  return y(() => {
+    if (!t) return;
+    const o = google.maps.event.addListener(t, "bounds_changed", () => {
+      Te(t, n), e();
+    });
+    return () => o.remove();
+  }, [t, e]), n;
+}
+const Ne = ["id", "defaultBounds", "defaultCenter", "defaultZoom", "defaultHeading", "defaultTilt", "reuseMaps", "renderingType", "colorScheme"], ze = ["padding"];
+class H {
+  static has(e) {
+    return this.entries[e] && this.entries[e].length > 0;
+  }
+  static pop(e) {
+    return this.entries[e] && this.entries[e].pop() || null;
+  }
+  static push(e, n) {
+    this.entries[e] || (this.entries[e] = []), this.entries[e].push(n);
+  }
+}
+H.entries = {};
+function Re(t, e) {
+  const n = ie(), [o, r] = A(null), [i, a] = Pe(), s = Fe(o), {
+    id: u,
+    defaultBounds: d,
+    defaultCenter: c,
+    defaultZoom: p,
+    defaultHeading: f,
+    defaultTilt: m,
+    reuseMaps: l,
+    renderingType: g,
+    colorScheme: L
+  } = t, h = D(t, Ne), b = t.zoom !== void 0 || t.defaultZoom !== void 0, w = t.center !== void 0 || t.defaultCenter !== void 0;
+  !d && (!b || !w) && console.warn("<Map> component is missing configuration. You have to provide zoom and center (via the `zoom`/`defaultZoom` and `center`/`defaultCenter` props) or specify the region to show using `defaultBounds`. See https://visgl.github.io/react-google-maps/docs/api-reference/components/map#required"), !h.center && c && (h.center = c), !h.zoom && Number.isFinite(p) && (h.zoom = p), !h.heading && Number.isFinite(f) && (h.heading = f), !h.tilt && Number.isFinite(m) && (h.tilt = m);
+  for (const v of Object.keys(h)) h[v] === void 0 && delete h[v];
+  const M = N(void 0);
+  return y(
+    () => {
+      if (!i || !n) return;
+      const {
+        addMapInstance: v,
+        removeMapInstance: O
+      } = e, {
+        mapId: I
+      } = t, S = `${I || "default"}:${g || "default"}:${L || "LIGHT"}`;
+      let _, E;
+      if (l && H.has(S) ? (E = H.pop(S), _ = E.getDiv(), i.appendChild(_), E.setOptions(h), setTimeout(() => E.setCenter(E.getCenter()), 0)) : (_ = document.createElement("div"), _.style.height = "100%", i.appendChild(_), E = new google.maps.Map(_, k({}, h, g ? {
+        renderingType: g
+      } : {}, L ? {
+        colorScheme: L
+      } : {}))), r(E), v(E, u), d) {
+        const {
+          padding: T
+        } = d, U = D(d, ze);
+        E.fitBounds(U, T);
+      } else (!b || !w) && E.fitBounds({
+        east: 180,
+        west: -180,
+        south: -90,
+        north: 90
+      });
+      if (M.current) {
+        const {
+          mapId: T,
+          cameraState: U
+        } = M.current;
+        T !== I && E.setOptions(U);
+      }
+      return () => {
+        M.current = {
+          mapId: I,
+          // eslint-disable-next-line react-hooks/exhaustive-deps
+          cameraState: s.current
+        }, _.remove(), l ? H.push(S, E) : google.maps.event.clearInstanceListeners(E), r(null), O(u);
+      };
+    },
+    // some dependencies are ignored in the list below:
+    //  - defaultBounds and the default* camera props will only be used once, and
+    //    changes should be ignored
+    //  - mapOptions has special hooks that take care of updating the options
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      i,
+      n,
+      u,
+      // these props can't be changed after initialization and require a new
+      // instance to be created
+      t.mapId,
+      t.renderingType,
+      t.colorScheme
+    ]
+  ), [o, a, s];
+}
+const ae = C.createContext(null), Be = (t) => {
+  const {
+    children: e,
+    id: n,
+    className: o,
+    style: r
+  } = t, i = z(B), a = oe();
+  if (!i)
+    throw new Error("<Map> can only be used inside an <ApiProvider> component.");
+  const [s, u, d] = Re(t, i);
+  xe(s, d, t), Oe(s, t), Se(s, t);
+  const c = _e(s, t), p = !!t.controlled;
+  y(() => {
+    if (s)
+      return c && s.setOptions({
+        disableDefaultUI: !0
+      }), (c || p) && s.setOptions({
+        gestureHandling: "none",
+        keyboardShortcuts: !1
+      }), () => {
+        s.setOptions({
+          gestureHandling: t.gestureHandling,
+          keyboardShortcuts: t.keyboardShortcuts
+        });
+      };
+  }, [s, c, p, t.gestureHandling, t.keyboardShortcuts]);
+  const f = t.center ? re(t.center) : null;
+  let m = null, l = null;
+  f && Number.isFinite(f.lat) && Number.isFinite(f.lng) && (m = f.lat, l = f.lng);
+  const g = P(() => {
+    var b, w, M, v, O;
+    return {
+      center: {
+        lat: (b = m) != null ? b : 0,
+        lng: (w = l) != null ? w : 0
+      },
+      zoom: (M = t.zoom) != null ? M : 0,
+      heading: (v = t.heading) != null ? v : 0,
+      tilt: (O = t.tilt) != null ? O : 0
+    };
+  }, [m, l, t.zoom, t.heading, t.tilt]);
+  W(() => {
+    if (!s || !p) return;
+    s.moveCamera(g);
+    const b = s.addListener("bounds_changed", () => {
+      s.moveCamera(g);
+    });
+    return () => b.remove();
+  }, [s, p, g]);
+  const L = P(() => k({
+    width: "100%",
+    height: "100%",
+    position: "relative",
+    // when using deckgl, the map should be sent to the back
+    zIndex: c ? -1 : 0
+  }, r), [r, c]), h = P(() => ({
+    map: s
+  }), [s]);
+  return a === x.AUTH_FAILURE ? /* @__PURE__ */ C.createElement("div", {
+    style: k({
+      position: "relative"
+    }, o ? {} : L),
+    className: o
+  }, /* @__PURE__ */ C.createElement(Ae, null)) : /* @__PURE__ */ C.createElement("div", k({
+    ref: u,
+    "data-testid": "map",
+    style: o ? void 0 : L,
+    className: o
+  }, n ? {
+    id: n
+  } : {}), s ? /* @__PURE__ */ C.createElement(ae.Provider, {
+    value: h
+  }, e) : null);
+};
+Be.deckGLViewProps = !0;
+const V = /* @__PURE__ */ new Set();
+function Ge(...t) {
+  const e = JSON.stringify(t);
+  V.has(e) || (V.add(e), console.error(...t));
+}
+const q = (t = null) => {
+  const e = z(B), {
+    map: n
+  } = z(ae) || {};
+  if (e === null)
+    return Ge("useMap(): failed to retrieve APIProviderContext. Make sure that the <APIProvider> component exists and that the component you are calling `useMap()` from is a sibling of the <APIProvider>."), null;
+  const {
+    mapInstances: o
+  } = e;
+  return t !== null ? o[t] || null : n || o.default || null;
+};
+function se(t) {
+  const e = ie(), n = z(B);
+  return y(() => {
+    !e || !n || n.importLibrary(t);
+  }, [e, n, t]), (n == null ? void 0 : n.loadedLibraries[t]) || null;
+}
+function F(t, e, n) {
+  y(() => {
+    if (!t || !e || !n) return;
+    const o = google.maps.event.addListener(t, e, n);
+    return () => o.remove();
+  }, [t, e, n]);
+}
+function G(t, e, n) {
+  y(() => {
+    t && (t[e] = n);
+  }, [t, e, n]);
+}
+function K(t, e, n) {
+  y(() => {
+    if (!(!t || !e || !n))
+      return t.addEventListener(e, n), () => t.removeEventListener(e, n);
+  }, [t, e, n]);
+}
+function He(t) {
+  return t.content !== void 0;
+}
+function Ue(t) {
+  return t.nodeType === Node.ELEMENT_NODE;
+}
+const je = C.createContext(null), $e = {
+  BOTTOM: ["50%", "100%"]
+}, Ze = ({
+  children: t,
+  styles: e,
+  className: n,
+  anchorPoint: o
+}) => {
+  const [r, i] = o ?? $e.BOTTOM;
+  let a = `-${r}`, s = `-${i}`;
+  r.trimStart().startsWith("-") && (a = r.substring(1)), i.trimStart().startsWith("-") && (s = i.substring(1));
+  const u = `translate(50%, 100%) translate(${a}, ${s})`;
+  return (
+    // anchoring container
+    /* @__PURE__ */ C.createElement("div", {
+      style: {
+        transform: u
+      }
+    }, /* @__PURE__ */ C.createElement("div", {
+      className: n,
+      style: e
+    }, t))
+  );
+};
+function We(t) {
+  const [e, n] = A(null), [o, r] = A(null), i = q(), a = se("marker"), {
+    children: s,
+    onClick: u,
+    className: d,
+    onMouseEnter: c,
+    onMouseLeave: p,
+    onDrag: f,
+    onDragStart: m,
+    onDragEnd: l,
+    collisionBehavior: g,
+    clickable: L,
+    draggable: h,
+    position: b,
+    title: w,
+    zIndex: M
+  } = t, v = le.count(s);
+  return y(() => {
+    if (!i || !a) return;
+    const O = new a.AdvancedMarkerElement();
+    O.map = i, n(O);
+    let I = null;
+    return v > 0 && (I = document.createElement("div"), I.isCustomMarker = !0, O.content = I, r(I)), () => {
+      var S;
+      O.map = null, (S = I) == null || S.remove(), n(null), r(null);
+    };
+  }, [i, a, v]), y(() => {
+    !e || !e.content || v > 0 || (e.content.className = d || "");
+  }, [e, d, v]), G(e, "position", b), G(e, "title", w ?? ""), G(e, "zIndex", M), G(e, "collisionBehavior", g), y(() => {
+    e && (h !== void 0 ? e.gmpDraggable = h : f || m || l ? e.gmpDraggable = !0 : e.gmpDraggable = !1);
+  }, [e, h, f, l, m]), y(() => {
+    if (!e) return;
+    const O = L !== void 0 || !!u || !!c || !!p;
+    e.gmpClickable = O, O && e != null && e.content && Ue(e.content) && (e.content.style.pointerEvents = "none", e.content.firstElementChild && (e.content.firstElementChild.style.pointerEvents = "all"));
+  }, [e, L, u, c, p]), F(e, "click", u), F(e, "drag", f), F(e, "dragstart", m), F(e, "dragend", l), K(e == null ? void 0 : e.element, "mouseenter", c), K(e == null ? void 0 : e.element, "mouseleave", p), [e, o];
+}
+const ot = Y((t, e) => {
+  const {
+    children: n,
+    style: o,
+    className: r,
+    anchorPoint: i
+  } = t, [a, s] = We(t), u = P(() => a ? {
+    marker: a
+  } : null, [a]);
+  return te(e, () => a, [a]), s ? /* @__PURE__ */ C.createElement(je.Provider, {
+    value: u
+  }, $(/* @__PURE__ */ C.createElement(Ze, {
+    anchorPoint: i,
+    styles: o,
+    className: r
+  }, n), s)) : null;
+});
+function qe(t, e, n) {
+  if (e != null && typeof e != "object")
+    throw new Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");
+  const o = t.style;
+  if (n == null) {
+    if (e == null) return;
+    for (const r in e)
+      e.hasOwnProperty(r) && X(o, r, e[r]);
+    return;
+  }
+  for (const r in n)
+    n.hasOwnProperty(r) && (e == null || !e.hasOwnProperty(r)) && (r.indexOf("--") === 0 ? o.setProperty(r, "") : r === "float" ? o.cssFloat = "" : o[r] = "");
+  if (e != null)
+    for (const r in e) {
+      const i = e[r];
+      e.hasOwnProperty(r) && n[r] !== i && X(o, r, i);
+    }
+}
+function X(t, e, n) {
+  const o = e.indexOf("--") === 0;
+  n == null || typeof n == "boolean" || n === "" ? o ? t.setProperty(e, "") : e === "float" ? t.cssFloat = "" : t[e] = "" : o ? t.setProperty(e, n) : typeof n == "number" && n !== 0 && !Ve(e) ? t[e] = n + "px" : e === "float" ? t.cssFloat = n : t[e] = ("" + n).trim();
+}
+const Je = /* @__PURE__ */ new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "boxFlex",
+  "boxFlexGroup",
+  "boxOrdinalGroup",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexPositive",
+  "flexShrink",
+  "flexNegative",
+  "flexOrder",
+  "gridArea",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowSpan",
+  "gridRowStart",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnSpan",
+  "gridColumnStart",
+  "fontWeight",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  // SVG-related properties
+  "floodOpacity",
+  "stopOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "strokeWidth"
+]);
+function Ve(t) {
+  return Je.has(t);
+}
+const Ke = ["children", "headerContent", "style", "className", "pixelOffset", "anchor", "shouldFocus", "onClose", "onCloseClick"], rt = (t) => {
+  const {
+    // content options
+    children: e,
+    headerContent: n,
+    style: o,
+    className: r,
+    pixelOffset: i,
+    // open options
+    anchor: a,
+    shouldFocus: s,
+    // events
+    onClose: u,
+    onCloseClick: d
+    // other options
+  } = t, c = D(t, Ke), p = se("maps"), [f, m] = A(null), l = N(null), g = N(null);
+  y(
+    () => {
+      if (!p) return;
+      l.current = document.createElement("div"), g.current = document.createElement("div");
+      const b = c;
+      i && (b.pixelOffset = new google.maps.Size(i[0], i[1])), n && (b.headerContent = typeof n == "string" ? n : g.current);
+      const w = new google.maps.InfoWindow(c);
+      return w.setContent(l.current), m(w), () => {
+        var M, v;
+        w.setContent(null), (M = l.current) == null || M.remove(), (v = g.current) == null || v.remove(), l.current = null, g.current = null, m(null);
+      };
+    },
+    // `infoWindowOptions` and other props are missing from dependencies:
+    //
+    // We don't want to re-create the infowindow instance
+    // when the options change.
+    // Updating the options is handled in the useEffect below.
+    //
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [p]
+  );
+  const L = N(null);
+  y(() => {
+    !f || !l.current || (qe(l.current, o || null, L.current), L.current = o || null, r !== l.current.className && (l.current.className = r || ""));
+  }, [f, r, o]), Z(
+    () => {
+      if (!f) return;
+      const b = c;
+      i ? b.pixelOffset = new google.maps.Size(i[0], i[1]) : b.pixelOffset = null, n ? b.headerContent = typeof n == "string" ? n : g.current : b.headerContent = null, f.setOptions(c);
+    },
+    // dependency `infoWindow` isn't needed since options are also passed
+    // to the constructor when a new infoWindow is created.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [c, i, n]
+  ), F(f, "close", u), F(f, "closeclick", d);
+  const h = q();
+  return Z(() => {
+    if (!h || !f || a === null) return;
+    const b = !!a, w = {
+      map: h
+    };
+    if (a && (w.anchor = a, He(a) && a.content instanceof Element)) {
+      const v = a.content, O = v == null ? void 0 : v.getBoundingClientRect();
+      if (O && v != null && v.isCustomMarker) {
+        var M;
+        const I = (M = a.content.firstElementChild) == null ? void 0 : M.firstElementChild, S = I == null ? void 0 : I.getBoundingClientRect(), _ = S.x - O.x + (S.width - O.width) / 2, E = S.y - O.y, T = c;
+        T.pixelOffset = new google.maps.Size(i ? i[0] + _ : _, i ? i[1] + E : E), f.setOptions(T);
+      }
+    }
+    return s !== void 0 && (w.shouldFocus = s), f.open(w), () => {
+      b && f.set("anchor", null), f.close();
+    };
+  }, [f, a, h, s, c, i]), /* @__PURE__ */ C.createElement(C.Fragment, null, l.current && $(e, l.current), g.current !== null && $(n, g.current));
+}, it = {
+  LEFT_TOP: 5,
+  LEFT_BOTTOM: 6,
+  RIGHT_TOP: 7,
+  RIGHT_BOTTOM: 9
+}, Xe = ["onClick", "onDrag", "onDragStart", "onDragEnd", "onMouseOver", "onMouseOut"];
+function Ye(t) {
+  const [e, n] = A(null), o = q(), {
+    onClick: r,
+    onDrag: i,
+    onDragStart: a,
+    onDragEnd: s,
+    onMouseOver: u,
+    onMouseOut: d
+  } = t, c = D(t, Xe), {
+    position: p,
+    draggable: f
+  } = c;
+  return y(() => {
+    if (!o) {
+      o === void 0 && console.error("<Marker> has to be inside a Map component.");
+      return;
+    }
+    const m = new google.maps.Marker(c);
+    return m.setMap(o), n(m), () => {
+      m.setMap(null), n(null);
+    };
+  }, [o]), y(() => {
+    if (!e) return;
+    const m = e, l = google.maps.event;
+    return r && l.addListener(m, "click", r), i && l.addListener(m, "drag", i), a && l.addListener(m, "dragstart", a), s && l.addListener(m, "dragend", s), u && l.addListener(m, "mouseover", u), d && l.addListener(m, "mouseout", d), e.setDraggable(!!f), () => {
+      l.clearInstanceListeners(m);
+    };
+  }, [e, f, r, i, a, s, u, d]), y(() => {
+    e && c && e.setOptions(c);
+  }, [e, c]), y(() => {
+    f || !p || !e || e.setPosition(p);
+  }, [f, p, e]), e;
+}
+Y((t, e) => {
+  const n = Ye(t);
+  return te(e, () => n, [n]), /* @__PURE__ */ C.createElement(C.Fragment, null);
+});
+export {
+  nt as A,
+  it as C,
+  ae as G,
+  rt as I,
+  Be as M,
+  ot as a,
+  q as u
+};