@wix/editor-react-components 1.2153.0

package/dist/site/components/GoogleMap/component.js

@@ -0,0 +1,1925 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import * as React from "react";
+import React__default, { forwardRef, useMemo, useImperativeHandle, useState, Children, useEffect, useContext, useRef, useLayoutEffect, useReducer, useCallback, memo, Suspense } from "react";
+import { c as clsx } from "../chunks/clsx.js";
+import { f as formatClassNames } from "../chunks/classNames.js";
+import { a as getDataAttributes } from "../chunks/dataUtils.js";
+import { createPortal } from "react-dom";
+import { g as getDefaultExportFromCjs } from "../chunks/_commonjsHelpers.js";
+import { G as GOOGLE_MAPS_DIRECTIONS_BASE_URL, M as MIN_ZOOM, a as MAX_ZOOM, T as TestIds, D as DEFAULT_ZOOM, b as MAP_IDS, c as MAP_TYPES, A as API_KEY, d as DEFAULT_LOCATION, C as COMPANY_NAME_DEFAULT, e as COMPANY_NAME_KEY, f as COMPONENT_NAME_DEFAULT, g as COMPONENT_NAME_KEY } from "../chunks/consts.js";
+import { p as parse } from "../chunks/index4.js";
+import { useService } from "@wix/services-manager-react";
+import { d as definitionExports } from "../chunks/index2.js";
+import { u as useConsentPolicyProps, C as ConsentPolicyWrapper } from "../chunks/useConsentPolicyProps.js";
+const mapContainer = "mapContainer__E0LTn";
+const style = {
+  mapContainer
+};
+const semanticClassNames = { root: "google-map" };
+const GoogleMapReact = forwardRef((props, forwardedRef) => {
+  const {
+    id,
+    className,
+    skin,
+    customClassNames = [],
+    translations,
+    lang,
+    onMouseEnter,
+    onMouseLeave,
+    MapContent: MapContent2
+  } = props;
+  const domSafeProps = {
+    id,
+    className: clsx(
+      skin && style[skin],
+      className,
+      formatClassNames(semanticClassNames.root, ...customClassNames)
+    ),
+    ...getDataAttributes(props),
+    lang
+  };
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ...domSafeProps,
+      onMouseEnter,
+      onMouseLeave,
+      children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: style.mapContainer,
+          "aria-label": translations.title,
+          role: "region",
+          children: /* @__PURE__ */ jsx(MapContent2, { ...props, ref: forwardedRef })
+        }
+      )
+    }
+  );
+});
+var fastDeepEqual;
+var hasRequiredFastDeepEqual;
+function requireFastDeepEqual() {
+  if (hasRequiredFastDeepEqual) return fastDeepEqual;
+  hasRequiredFastDeepEqual = 1;
+  fastDeepEqual = function equal(a, b) {
+    if (a === b) return true;
+    if (a && b && typeof a == "object" && typeof b == "object") {
+      if (a.constructor !== b.constructor) return false;
+      var length, i, keys;
+      if (Array.isArray(a)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0; )
+          if (!equal(a[i], b[i])) return false;
+        return true;
+      }
+      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+      if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+      if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+      keys = Object.keys(a);
+      length = keys.length;
+      if (length !== Object.keys(b).length) return false;
+      for (i = length; i-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+      for (i = length; i-- !== 0; ) {
+        var key = keys[i];
+        if (!equal(a[key], b[key])) return false;
+      }
+      return true;
+    }
+    return a !== a && b !== b;
+  };
+  return fastDeepEqual;
+}
+var fastDeepEqualExports = requireFastDeepEqual();
+const isDeepEqual = /* @__PURE__ */ getDefaultExportFromCjs(fastDeepEqualExports);
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+const APILoadingStatus = {
+  NOT_LOADED: "NOT_LOADED",
+  LOADING: "LOADING",
+  LOADED: "LOADED",
+  FAILED: "FAILED",
+  AUTH_FAILURE: "AUTH_FAILURE"
+};
+const MAPS_API_BASE_URL = "https://maps.googleapis.com/maps/api/js";
+class GoogleMapsApiLoader {
+  /**
+   * 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(params, onLoadingStatusChange) {
+    var _window$google;
+    const libraries = params.libraries ? params.libraries.split(",") : [];
+    const serializedParams = this.serializeParams(params);
+    this.listeners.push(onLoadingStatusChange);
+    if ((_window$google = window.google) != null && (_window$google = _window$google.maps) != null && _window$google.importLibrary) {
+      if (!this.serializedApiParams) {
+        this.loadingStatus = APILoadingStatus.LOADED;
+      }
+      this.notifyLoadingStatusListeners();
+    } else {
+      this.serializedApiParams = serializedParams;
+      this.initImportLibrary(params);
+    }
+    if (this.serializedApiParams && this.serializedApiParams !== serializedParams) {
+      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 librariesToLoad = ["maps", ...libraries];
+    await Promise.all(librariesToLoad.map((name) => google.maps.importLibrary(name)));
+  }
+  /**
+   * Serialize the parameters used to load the library for easier comparison.
+   */
+  static serializeParams(params) {
+    return [params.v, params.key, params.language, params.region, params.authReferrerPolicy, params.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(params) {
+    if (!window.google) window.google = {};
+    if (!window.google.maps) window.google.maps = {};
+    if (window.google.maps["importLibrary"]) {
+      console.error("[google-maps-api-loader-internal]: initImportLibrary must only be called once");
+      return;
+    }
+    let apiPromise = null;
+    const loadApi = () => {
+      if (apiPromise) return apiPromise;
+      apiPromise = new Promise((resolve, reject) => {
+        var _document$querySelect;
+        const scriptElement = document.createElement("script");
+        const urlParams = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+          const urlParamName = key.replace(/[A-Z]/g, (t) => "_" + t[0].toLowerCase());
+          urlParams.set(urlParamName, String(value));
+        }
+        urlParams.set("loading", "async");
+        urlParams.set("callback", "__googleMapsCallback__");
+        scriptElement.async = true;
+        scriptElement.src = MAPS_API_BASE_URL + `?` + urlParams.toString();
+        scriptElement.nonce = ((_document$querySelect = document.querySelector("script[nonce]")) == null ? void 0 : _document$querySelect.nonce) || "";
+        scriptElement.onerror = () => {
+          this.loadingStatus = APILoadingStatus.FAILED;
+          this.notifyLoadingStatusListeners();
+          reject(new Error("The Google Maps JavaScript API could not load."));
+        };
+        window.__googleMapsCallback__ = () => {
+          this.loadingStatus = APILoadingStatus.LOADED;
+          this.notifyLoadingStatusListeners();
+          resolve();
+        };
+        window.gm_authFailure = () => {
+          this.loadingStatus = APILoadingStatus.AUTH_FAILURE;
+          this.notifyLoadingStatusListeners();
+        };
+        this.loadingStatus = APILoadingStatus.LOADING;
+        this.notifyLoadingStatusListeners();
+        document.head.append(scriptElement);
+      });
+      return apiPromise;
+    };
+    google.maps.importLibrary = (libraryName) => loadApi().then(() => google.maps.importLibrary(libraryName));
+  }
+  /**
+   * Calls all registered loadingStatusListeners after a status update.
+   */
+  static notifyLoadingStatusListeners() {
+    for (const fn of this.listeners) {
+      fn(this.loadingStatus);
+    }
+  }
+}
+GoogleMapsApiLoader.loadingStatus = APILoadingStatus.NOT_LOADED;
+GoogleMapsApiLoader.serializedApiParams = void 0;
+GoogleMapsApiLoader.listeners = [];
+const _excluded$3 = ["onLoad", "onError", "apiKey", "version", "libraries"], _excluded2$1 = ["children"];
+const DEFAULT_SOLUTION_CHANNEL = "GMP_visgl_rgmlibrary_v1_default";
+const APIProviderContext = React__default.createContext(null);
+function useMapInstances() {
+  const [mapInstances, setMapInstances] = useState({});
+  const addMapInstance = (mapInstance, id = "default") => {
+    setMapInstances((instances) => _extends({}, instances, {
+      [id]: mapInstance
+    }));
+  };
+  const removeMapInstance = (id = "default") => {
+    setMapInstances((_ref) => {
+      let remaining = _objectWithoutPropertiesLoose(_ref, [id].map(_toPropertyKey));
+      return remaining;
+    });
+  };
+  const clearMapInstances = () => {
+    setMapInstances({});
+  };
+  return {
+    mapInstances,
+    addMapInstance,
+    removeMapInstance,
+    clearMapInstances
+  };
+}
+function useGoogleMapsApiLoader(props) {
+  const {
+    onLoad,
+    onError,
+    apiKey,
+    version,
+    libraries = []
+  } = props, otherApiParams = _objectWithoutPropertiesLoose(props, _excluded$3);
+  const [status, setStatus] = useState(GoogleMapsApiLoader.loadingStatus);
+  const [loadedLibraries, addLoadedLibrary] = useReducer((loadedLibraries2, action) => {
+    return loadedLibraries2[action.name] ? loadedLibraries2 : _extends({}, loadedLibraries2, {
+      [action.name]: action.value
+    });
+  }, {});
+  const librariesString = useMemo(() => libraries == null ? void 0 : libraries.join(","), [libraries]);
+  const serializedParams = useMemo(() => JSON.stringify(_extends({
+    apiKey,
+    version
+  }, otherApiParams)), [apiKey, version, otherApiParams]);
+  const importLibrary = useCallback(async (name) => {
+    var _google;
+    if (loadedLibraries[name]) {
+      return loadedLibraries[name];
+    }
+    if (!((_google = google) != null && (_google = _google.maps) != null && _google.importLibrary)) {
+      throw new Error("[api-provider-internal] importLibrary was called before google.maps.importLibrary was defined.");
+    }
+    const res = await window.google.maps.importLibrary(name);
+    addLoadedLibrary({
+      name,
+      value: res
+    });
+    return res;
+  }, [loadedLibraries]);
+  useEffect(
+    () => {
+      (async () => {
+        try {
+          const params = _extends({
+            key: apiKey
+          }, otherApiParams);
+          if (version) params.v = version;
+          if ((librariesString == null ? void 0 : librariesString.length) > 0) params.libraries = librariesString;
+          if (params.channel === void 0 || params.channel < 0 || params.channel > 999) delete params.channel;
+          if (params.solutionChannel === void 0) params.solutionChannel = DEFAULT_SOLUTION_CHANNEL;
+          else if (params.solutionChannel === "") delete params.solutionChannel;
+          await GoogleMapsApiLoader.load(params, (status2) => setStatus(status2));
+          for (const name of ["core", "maps", ...libraries]) {
+            await importLibrary(name);
+          }
+          if (onLoad) {
+            onLoad();
+          }
+        } catch (error) {
+          if (onError) {
+            onError(error);
+          } else {
+            console.error("<ApiProvider> failed to load the Google Maps JavaScript API", error);
+          }
+        }
+      })();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [apiKey, librariesString, serializedParams]
+  );
+  return {
+    status,
+    loadedLibraries,
+    importLibrary
+  };
+}
+const APIProvider = (props) => {
+  const {
+    children
+  } = props, loaderProps = _objectWithoutPropertiesLoose(props, _excluded2$1);
+  const {
+    mapInstances,
+    addMapInstance,
+    removeMapInstance,
+    clearMapInstances
+  } = useMapInstances();
+  const {
+    status,
+    loadedLibraries,
+    importLibrary
+  } = useGoogleMapsApiLoader(loaderProps);
+  const contextValue = useMemo(() => ({
+    mapInstances,
+    addMapInstance,
+    removeMapInstance,
+    clearMapInstances,
+    status,
+    loadedLibraries,
+    importLibrary
+  }), [mapInstances, addMapInstance, removeMapInstance, clearMapInstances, status, loadedLibraries, importLibrary]);
+  return /* @__PURE__ */ React__default.createElement(APIProviderContext.Provider, {
+    value: contextValue
+  }, children);
+};
+function useMapEvents(map, props) {
+  for (const propName of eventPropNames) {
+    const handler = props[propName];
+    const eventType = propNameToEventType[propName];
+    useEffect(() => {
+      if (!map) return;
+      if (!handler) return;
+      const listener = google.maps.event.addListener(map, eventType, (ev) => {
+        handler(createMapEvent(eventType, map, ev));
+      });
+      return () => listener.remove();
+    }, [map, eventType, handler]);
+  }
+}
+function createMapEvent(type, map, srcEvent) {
+  const ev = {
+    type,
+    map,
+    detail: {},
+    stoppable: false,
+    stop: () => {
+    }
+  };
+  if (cameraEventTypes.includes(type)) {
+    const camEvent = ev;
+    const center = map.getCenter();
+    const zoom = map.getZoom();
+    const heading = map.getHeading() || 0;
+    const tilt = map.getTilt() || 0;
+    const bounds = map.getBounds();
+    if (!center || !bounds || !Number.isFinite(zoom)) {
+      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");
+    }
+    camEvent.detail = {
+      center: (center == null ? void 0 : center.toJSON()) || {
+        lat: 0,
+        lng: 0
+      },
+      zoom: zoom || 0,
+      heading,
+      tilt,
+      bounds: (bounds == null ? void 0 : bounds.toJSON()) || {
+        north: 90,
+        east: 180,
+        south: -90,
+        west: -180
+      }
+    };
+    return camEvent;
+  } else if (mouseEventTypes.includes(type)) {
+    var _srcEvent$latLng;
+    if (!srcEvent) throw new Error("[createEvent] mouse events must provide a srcEvent");
+    const mouseEvent = ev;
+    mouseEvent.domEvent = srcEvent.domEvent;
+    mouseEvent.stoppable = true;
+    mouseEvent.stop = () => srcEvent.stop();
+    mouseEvent.detail = {
+      latLng: ((_srcEvent$latLng = srcEvent.latLng) == null ? void 0 : _srcEvent$latLng.toJSON()) || null,
+      placeId: srcEvent.placeId
+    };
+    return mouseEvent;
+  }
+  return ev;
+}
+const propNameToEventType = {
+  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"
+};
+const cameraEventTypes = ["bounds_changed", "center_changed", "heading_changed", "tilt_changed", "zoom_changed"];
+const mouseEventTypes = ["click", "contextmenu", "dblclick", "mousemove", "mouseout", "mouseover"];
+const eventPropNames = Object.keys(propNameToEventType);
+function useDeepCompareEffect(effect, deps) {
+  const ref = useRef(void 0);
+  if (!ref.current || !isDeepEqual(deps, ref.current)) {
+    ref.current = deps;
+  }
+  useEffect(effect, ref.current);
+}
+const mapOptionKeys = /* @__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 useMapOptions(map, mapProps) {
+  const mapOptions = {};
+  const keys = Object.keys(mapProps);
+  for (const key of keys) {
+    if (!mapOptionKeys.has(key)) continue;
+    mapOptions[key] = mapProps[key];
+  }
+  useDeepCompareEffect(() => {
+    if (!map) return;
+    map.setOptions(mapOptions);
+  }, [mapOptions]);
+}
+function useApiLoadingStatus() {
+  var _useContext;
+  return ((_useContext = useContext(APIProviderContext)) == null ? void 0 : _useContext.status) || APILoadingStatus.NOT_LOADED;
+}
+function useDeckGLCameraUpdate(map, props) {
+  const {
+    viewport,
+    viewState
+  } = props;
+  const isDeckGlControlled = !!viewport;
+  useLayoutEffect(() => {
+    if (!map || !viewState) return;
+    const {
+      latitude,
+      longitude,
+      bearing: heading,
+      pitch: tilt,
+      zoom
+    } = viewState;
+    map.moveCamera({
+      center: {
+        lat: latitude,
+        lng: longitude
+      },
+      heading,
+      tilt,
+      zoom: zoom + 1
+    });
+  }, [map, viewState]);
+  return isDeckGlControlled;
+}
+function isLatLngLiteral(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  if (!("lat" in obj && "lng" in obj)) return false;
+  return Number.isFinite(obj.lat) && Number.isFinite(obj.lng);
+}
+function toLatLngLiteral(obj) {
+  if (isLatLngLiteral(obj)) return obj;
+  return obj.toJSON();
+}
+function useMapCameraParams(map, cameraStateRef, mapProps) {
+  const center = mapProps.center ? toLatLngLiteral(mapProps.center) : null;
+  let lat = null;
+  let lng = null;
+  if (center && Number.isFinite(center.lat) && Number.isFinite(center.lng)) {
+    lat = center.lat;
+    lng = center.lng;
+  }
+  const zoom = Number.isFinite(mapProps.zoom) ? mapProps.zoom : null;
+  const heading = Number.isFinite(mapProps.heading) ? mapProps.heading : null;
+  const tilt = Number.isFinite(mapProps.tilt) ? mapProps.tilt : null;
+  useLayoutEffect(() => {
+    if (!map) return;
+    const nextCamera = {};
+    let needsUpdate = false;
+    if (lat !== null && lng !== null && (cameraStateRef.current.center.lat !== lat || cameraStateRef.current.center.lng !== lng)) {
+      nextCamera.center = {
+        lat,
+        lng
+      };
+      needsUpdate = true;
+    }
+    if (zoom !== null && cameraStateRef.current.zoom !== zoom) {
+      nextCamera.zoom = zoom;
+      needsUpdate = true;
+    }
+    if (heading !== null && cameraStateRef.current.heading !== heading) {
+      nextCamera.heading = heading;
+      needsUpdate = true;
+    }
+    if (tilt !== null && cameraStateRef.current.tilt !== tilt) {
+      nextCamera.tilt = tilt;
+      needsUpdate = true;
+    }
+    if (needsUpdate) {
+      map.moveCamera(nextCamera);
+    }
+  });
+}
+const AuthFailureMessage = () => {
+  const style2 = {
+    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__ */ React__default.createElement("div", {
+    style: style2
+  }, /* @__PURE__ */ React__default.createElement("h2", null, "Error: AuthFailure"), /* @__PURE__ */ React__default.createElement("p", null, "A problem with your API key prevents the map from rendering correctly. Please make sure the value of the ", /* @__PURE__ */ React__default.createElement("code", null, "APIProvider.apiKey"), " prop is correct. Check the error-message in the console for further details."));
+};
+function useCallbackRef() {
+  const [el, setEl] = useState(null);
+  const ref = useCallback((value) => setEl(value), [setEl]);
+  return [el, ref];
+}
+function useApiIsLoaded() {
+  const status = useApiLoadingStatus();
+  return status === APILoadingStatus.LOADED;
+}
+function useForceUpdate() {
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  return forceUpdate;
+}
+function handleBoundsChange(map, ref) {
+  const center = map.getCenter();
+  const zoom = map.getZoom();
+  const heading = map.getHeading() || 0;
+  const tilt = map.getTilt() || 0;
+  const bounds = map.getBounds();
+  if (!center || !bounds || !Number.isFinite(zoom)) {
+    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(ref.current, {
+    center: (center == null ? void 0 : center.toJSON()) || {
+      lat: 0,
+      lng: 0
+    },
+    zoom: zoom || 0,
+    heading,
+    tilt
+  });
+}
+function useTrackedCameraStateRef(map) {
+  const forceUpdate = useForceUpdate();
+  const ref = useRef({
+    center: {
+      lat: 0,
+      lng: 0
+    },
+    heading: 0,
+    tilt: 0,
+    zoom: 0
+  });
+  useEffect(() => {
+    if (!map) return;
+    const listener = google.maps.event.addListener(map, "bounds_changed", () => {
+      handleBoundsChange(map, ref);
+      forceUpdate();
+    });
+    return () => listener.remove();
+  }, [map, forceUpdate]);
+  return ref;
+}
+const _excluded$2 = ["id", "defaultBounds", "defaultCenter", "defaultZoom", "defaultHeading", "defaultTilt", "reuseMaps", "renderingType", "colorScheme"], _excluded2 = ["padding"];
+class CachedMapStack {
+  static has(key) {
+    return this.entries[key] && this.entries[key].length > 0;
+  }
+  static pop(key) {
+    if (!this.entries[key]) return null;
+    return this.entries[key].pop() || null;
+  }
+  static push(key, value) {
+    if (!this.entries[key]) this.entries[key] = [];
+    this.entries[key].push(value);
+  }
+}
+CachedMapStack.entries = {};
+function useMapInstance(props, context) {
+  const apiIsLoaded = useApiIsLoaded();
+  const [map, setMap] = useState(null);
+  const [container, containerRef] = useCallbackRef();
+  const cameraStateRef = useTrackedCameraStateRef(map);
+  const {
+    id,
+    defaultBounds,
+    defaultCenter,
+    defaultZoom,
+    defaultHeading,
+    defaultTilt,
+    reuseMaps,
+    renderingType,
+    colorScheme
+  } = props, mapOptions = _objectWithoutPropertiesLoose(props, _excluded$2);
+  const hasZoom = props.zoom !== void 0 || props.defaultZoom !== void 0;
+  const hasCenter = props.center !== void 0 || props.defaultCenter !== void 0;
+  if (!defaultBounds && (!hasZoom || !hasCenter)) {
+    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");
+  }
+  if (!mapOptions.center && defaultCenter) mapOptions.center = defaultCenter;
+  if (!mapOptions.zoom && Number.isFinite(defaultZoom)) mapOptions.zoom = defaultZoom;
+  if (!mapOptions.heading && Number.isFinite(defaultHeading)) mapOptions.heading = defaultHeading;
+  if (!mapOptions.tilt && Number.isFinite(defaultTilt)) mapOptions.tilt = defaultTilt;
+  for (const key of Object.keys(mapOptions)) if (mapOptions[key] === void 0) delete mapOptions[key];
+  const savedMapStateRef = useRef(void 0);
+  useEffect(
+    () => {
+      if (!container || !apiIsLoaded) return;
+      const {
+        addMapInstance,
+        removeMapInstance
+      } = context;
+      const {
+        mapId
+      } = props;
+      const cacheKey = `${mapId || "default"}:${renderingType || "default"}:${colorScheme || "LIGHT"}`;
+      let mapDiv;
+      let map2;
+      if (reuseMaps && CachedMapStack.has(cacheKey)) {
+        map2 = CachedMapStack.pop(cacheKey);
+        mapDiv = map2.getDiv();
+        container.appendChild(mapDiv);
+        map2.setOptions(mapOptions);
+        setTimeout(() => map2.setCenter(map2.getCenter()), 0);
+      } else {
+        mapDiv = document.createElement("div");
+        mapDiv.style.height = "100%";
+        container.appendChild(mapDiv);
+        map2 = new google.maps.Map(mapDiv, _extends({}, mapOptions, renderingType ? {
+          renderingType
+        } : {}, colorScheme ? {
+          colorScheme
+        } : {}));
+      }
+      setMap(map2);
+      addMapInstance(map2, id);
+      if (defaultBounds) {
+        const {
+          padding
+        } = defaultBounds, defBounds = _objectWithoutPropertiesLoose(defaultBounds, _excluded2);
+        map2.fitBounds(defBounds, padding);
+      } else if (!hasZoom || !hasCenter) {
+        map2.fitBounds({
+          east: 180,
+          west: -180,
+          south: -90,
+          north: 90
+        });
+      }
+      if (savedMapStateRef.current) {
+        const {
+          mapId: savedMapId,
+          cameraState: savedCameraState
+        } = savedMapStateRef.current;
+        if (savedMapId !== mapId) {
+          map2.setOptions(savedCameraState);
+        }
+      }
+      return () => {
+        savedMapStateRef.current = {
+          mapId,
+          // eslint-disable-next-line react-hooks/exhaustive-deps
+          cameraState: cameraStateRef.current
+        };
+        mapDiv.remove();
+        if (reuseMaps) {
+          CachedMapStack.push(cacheKey, map2);
+        } else {
+          google.maps.event.clearInstanceListeners(map2);
+        }
+        setMap(null);
+        removeMapInstance(id);
+      };
+    },
+    // 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
+    [
+      container,
+      apiIsLoaded,
+      id,
+      // these props can't be changed after initialization and require a new
+      // instance to be created
+      props.mapId,
+      props.renderingType,
+      props.colorScheme
+    ]
+  );
+  return [map, containerRef, cameraStateRef];
+}
+const GoogleMapsContext = React__default.createContext(null);
+const Map = (props) => {
+  const {
+    children,
+    id,
+    className,
+    style: style2
+  } = props;
+  const context = useContext(APIProviderContext);
+  const loadingStatus = useApiLoadingStatus();
+  if (!context) {
+    throw new Error("<Map> can only be used inside an <ApiProvider> component.");
+  }
+  const [map, mapRef, cameraStateRef] = useMapInstance(props, context);
+  useMapCameraParams(map, cameraStateRef, props);
+  useMapEvents(map, props);
+  useMapOptions(map, props);
+  const isDeckGlControlled = useDeckGLCameraUpdate(map, props);
+  const isControlledExternally = !!props.controlled;
+  useEffect(() => {
+    if (!map) return;
+    if (isDeckGlControlled) {
+      map.setOptions({
+        disableDefaultUI: true
+      });
+    }
+    if (isDeckGlControlled || isControlledExternally) {
+      map.setOptions({
+        gestureHandling: "none",
+        keyboardShortcuts: false
+      });
+    }
+    return () => {
+      map.setOptions({
+        gestureHandling: props.gestureHandling,
+        keyboardShortcuts: props.keyboardShortcuts
+      });
+    };
+  }, [map, isDeckGlControlled, isControlledExternally, props.gestureHandling, props.keyboardShortcuts]);
+  const center = props.center ? toLatLngLiteral(props.center) : null;
+  let lat = null;
+  let lng = null;
+  if (center && Number.isFinite(center.lat) && Number.isFinite(center.lng)) {
+    lat = center.lat;
+    lng = center.lng;
+  }
+  const cameraOptions = useMemo(() => {
+    var _lat, _lng, _props$zoom, _props$heading, _props$tilt;
+    return {
+      center: {
+        lat: (_lat = lat) != null ? _lat : 0,
+        lng: (_lng = lng) != null ? _lng : 0
+      },
+      zoom: (_props$zoom = props.zoom) != null ? _props$zoom : 0,
+      heading: (_props$heading = props.heading) != null ? _props$heading : 0,
+      tilt: (_props$tilt = props.tilt) != null ? _props$tilt : 0
+    };
+  }, [lat, lng, props.zoom, props.heading, props.tilt]);
+  useLayoutEffect(() => {
+    if (!map || !isControlledExternally) return;
+    map.moveCamera(cameraOptions);
+    const listener = map.addListener("bounds_changed", () => {
+      map.moveCamera(cameraOptions);
+    });
+    return () => listener.remove();
+  }, [map, isControlledExternally, cameraOptions]);
+  const combinedStyle = useMemo(() => _extends({
+    width: "100%",
+    height: "100%",
+    position: "relative",
+    // when using deckgl, the map should be sent to the back
+    zIndex: isDeckGlControlled ? -1 : 0
+  }, style2), [style2, isDeckGlControlled]);
+  const contextValue = useMemo(() => ({
+    map
+  }), [map]);
+  if (loadingStatus === APILoadingStatus.AUTH_FAILURE) {
+    return /* @__PURE__ */ React__default.createElement("div", {
+      style: _extends({
+        position: "relative"
+      }, className ? {} : combinedStyle),
+      className
+    }, /* @__PURE__ */ React__default.createElement(AuthFailureMessage, null));
+  }
+  return /* @__PURE__ */ React__default.createElement("div", _extends({
+    ref: mapRef,
+    "data-testid": "map",
+    style: className ? void 0 : combinedStyle,
+    className
+  }, id ? {
+    id
+  } : {}), map ? /* @__PURE__ */ React__default.createElement(GoogleMapsContext.Provider, {
+    value: contextValue
+  }, children) : null);
+};
+Map.deckGLViewProps = true;
+const shownMessages = /* @__PURE__ */ new Set();
+function logErrorOnce(...args) {
+  const key = JSON.stringify(args);
+  if (!shownMessages.has(key)) {
+    shownMessages.add(key);
+    console.error(...args);
+  }
+}
+const useMap = (id = null) => {
+  const ctx = useContext(APIProviderContext);
+  const {
+    map
+  } = useContext(GoogleMapsContext) || {};
+  if (ctx === null) {
+    logErrorOnce("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>.");
+    return null;
+  }
+  const {
+    mapInstances
+  } = ctx;
+  if (id !== null) return mapInstances[id] || null;
+  if (map) return map;
+  return mapInstances["default"] || null;
+};
+function useMapsLibrary(name) {
+  const apiIsLoaded = useApiIsLoaded();
+  const ctx = useContext(APIProviderContext);
+  useEffect(() => {
+    if (!apiIsLoaded || !ctx) return;
+    void ctx.importLibrary(name);
+  }, [apiIsLoaded, ctx, name]);
+  return (ctx == null ? void 0 : ctx.loadedLibraries[name]) || null;
+}
+function useMapsEventListener(target, name, callback) {
+  useEffect(() => {
+    if (!target || !name || !callback) return;
+    const listener = google.maps.event.addListener(target, name, callback);
+    return () => listener.remove();
+  }, [target, name, callback]);
+}
+function usePropBinding(object, prop, value) {
+  useEffect(() => {
+    if (!object) return;
+    object[prop] = value;
+  }, [object, prop, value]);
+}
+function useDomEventListener(target, name, callback) {
+  useEffect(() => {
+    if (!target || !name || !callback) return;
+    target.addEventListener(name, callback);
+    return () => target.removeEventListener(name, callback);
+  }, [target, name, callback]);
+}
+function isAdvancedMarker(marker) {
+  return marker.content !== void 0;
+}
+function isElementNode(node) {
+  return node.nodeType === Node.ELEMENT_NODE;
+}
+const AdvancedMarkerContext = React__default.createContext(null);
+const AdvancedMarkerAnchorPoint = {
+  BOTTOM: ["50%", "100%"]
+};
+const MarkerContent = ({
+  children,
+  styles: styles2,
+  className,
+  anchorPoint
+}) => {
+  const [xTranslation, yTranslation] = anchorPoint != null ? anchorPoint : AdvancedMarkerAnchorPoint["BOTTOM"];
+  let xTranslationFlipped = `-${xTranslation}`;
+  let yTranslationFlipped = `-${yTranslation}`;
+  if (xTranslation.trimStart().startsWith("-")) {
+    xTranslationFlipped = xTranslation.substring(1);
+  }
+  if (yTranslation.trimStart().startsWith("-")) {
+    yTranslationFlipped = yTranslation.substring(1);
+  }
+  const transformStyle = `translate(50%, 100%) translate(${xTranslationFlipped}, ${yTranslationFlipped})`;
+  return (
+    // anchoring container
+    /* @__PURE__ */ React__default.createElement("div", {
+      style: {
+        transform: transformStyle
+      }
+    }, /* @__PURE__ */ React__default.createElement("div", {
+      className,
+      style: styles2
+    }, children))
+  );
+};
+function useAdvancedMarker(props) {
+  const [marker, setMarker] = useState(null);
+  const [contentContainer, setContentContainer] = useState(null);
+  const map = useMap();
+  const markerLibrary = useMapsLibrary("marker");
+  const {
+    children,
+    onClick,
+    className,
+    onMouseEnter,
+    onMouseLeave,
+    onDrag,
+    onDragStart,
+    onDragEnd,
+    collisionBehavior,
+    clickable,
+    draggable,
+    position,
+    title: title2,
+    zIndex
+  } = props;
+  const numChildren = Children.count(children);
+  useEffect(() => {
+    if (!map || !markerLibrary) return;
+    const newMarker = new markerLibrary.AdvancedMarkerElement();
+    newMarker.map = map;
+    setMarker(newMarker);
+    let contentElement = null;
+    if (numChildren > 0) {
+      contentElement = document.createElement("div");
+      contentElement.isCustomMarker = true;
+      newMarker.content = contentElement;
+      setContentContainer(contentElement);
+    }
+    return () => {
+      var _contentElement;
+      newMarker.map = null;
+      (_contentElement = contentElement) == null || _contentElement.remove();
+      setMarker(null);
+      setContentContainer(null);
+    };
+  }, [map, markerLibrary, numChildren]);
+  useEffect(() => {
+    if (!marker || !marker.content || numChildren > 0) return;
+    marker.content.className = className || "";
+  }, [marker, className, numChildren]);
+  usePropBinding(marker, "position", position);
+  usePropBinding(marker, "title", title2 != null ? title2 : "");
+  usePropBinding(marker, "zIndex", zIndex);
+  usePropBinding(marker, "collisionBehavior", collisionBehavior);
+  useEffect(() => {
+    if (!marker) return;
+    if (draggable !== void 0) marker.gmpDraggable = draggable;
+    else if (onDrag || onDragStart || onDragEnd) marker.gmpDraggable = true;
+    else marker.gmpDraggable = false;
+  }, [marker, draggable, onDrag, onDragEnd, onDragStart]);
+  useEffect(() => {
+    if (!marker) return;
+    const gmpClickable = clickable !== void 0 || Boolean(onClick) || Boolean(onMouseEnter) || Boolean(onMouseLeave);
+    marker.gmpClickable = gmpClickable;
+    if (gmpClickable && marker != null && marker.content && isElementNode(marker.content)) {
+      marker.content.style.pointerEvents = "none";
+      if (marker.content.firstElementChild) {
+        marker.content.firstElementChild.style.pointerEvents = "all";
+      }
+    }
+  }, [marker, clickable, onClick, onMouseEnter, onMouseLeave]);
+  useMapsEventListener(marker, "click", onClick);
+  useMapsEventListener(marker, "drag", onDrag);
+  useMapsEventListener(marker, "dragstart", onDragStart);
+  useMapsEventListener(marker, "dragend", onDragEnd);
+  useDomEventListener(marker == null ? void 0 : marker.element, "mouseenter", onMouseEnter);
+  useDomEventListener(marker == null ? void 0 : marker.element, "mouseleave", onMouseLeave);
+  return [marker, contentContainer];
+}
+const AdvancedMarker = forwardRef((props, ref) => {
+  const {
+    children,
+    style: style2,
+    className,
+    anchorPoint
+  } = props;
+  const [marker, contentContainer] = useAdvancedMarker(props);
+  const advancedMarkerContextValue = useMemo(() => marker ? {
+    marker
+  } : null, [marker]);
+  useImperativeHandle(ref, () => marker, [marker]);
+  if (!contentContainer) return null;
+  return /* @__PURE__ */ React__default.createElement(AdvancedMarkerContext.Provider, {
+    value: advancedMarkerContextValue
+  }, createPortal(/* @__PURE__ */ React__default.createElement(MarkerContent, {
+    anchorPoint,
+    styles: style2,
+    className
+  }, children), contentContainer));
+});
+function setValueForStyles(element, styles2, prevStyles) {
+  if (styles2 != null && typeof styles2 !== "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 elementStyle = element.style;
+  if (prevStyles == null) {
+    if (styles2 == null) return;
+    for (const styleName in styles2) {
+      if (!styles2.hasOwnProperty(styleName)) continue;
+      setValueForStyle(elementStyle, styleName, styles2[styleName]);
+    }
+    return;
+  }
+  for (const styleName in prevStyles) {
+    if (prevStyles.hasOwnProperty(styleName) && (styles2 == null || !styles2.hasOwnProperty(styleName))) {
+      const isCustomProperty = styleName.indexOf("--") === 0;
+      if (isCustomProperty) {
+        elementStyle.setProperty(styleName, "");
+      } else if (styleName === "float") {
+        elementStyle.cssFloat = "";
+      } else {
+        elementStyle[styleName] = "";
+      }
+    }
+  }
+  if (styles2 == null) return;
+  for (const styleName in styles2) {
+    const value = styles2[styleName];
+    if (styles2.hasOwnProperty(styleName) && prevStyles[styleName] !== value) {
+      setValueForStyle(elementStyle, styleName, value);
+    }
+  }
+}
+function setValueForStyle(elementStyle, styleName, value) {
+  const isCustomProperty = styleName.indexOf("--") === 0;
+  if (value == null || typeof value === "boolean" || value === "") {
+    if (isCustomProperty) {
+      elementStyle.setProperty(styleName, "");
+    } else if (styleName === "float") {
+      elementStyle.cssFloat = "";
+    } else {
+      elementStyle[styleName] = "";
+    }
+  } else if (isCustomProperty) {
+    elementStyle.setProperty(styleName, value);
+  } else if (typeof value === "number" && value !== 0 && !isUnitlessNumber(styleName)) {
+    elementStyle[styleName] = value + "px";
+  } else {
+    if (styleName === "float") {
+      elementStyle.cssFloat = value;
+    } else {
+      elementStyle[styleName] = ("" + value).trim();
+    }
+  }
+}
+const unitlessNumbers = /* @__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 isUnitlessNumber(name) {
+  return unitlessNumbers.has(name);
+}
+const _excluded$1 = ["children", "headerContent", "style", "className", "pixelOffset", "anchor", "shouldFocus", "onClose", "onCloseClick"];
+const InfoWindow = (props) => {
+  const {
+    // content options
+    children,
+    headerContent,
+    style: style2,
+    className,
+    pixelOffset,
+    // open options
+    anchor,
+    shouldFocus,
+    // events
+    onClose,
+    onCloseClick
+    // other options
+  } = props, infoWindowOptions = _objectWithoutPropertiesLoose(props, _excluded$1);
+  const mapsLibrary = useMapsLibrary("maps");
+  const [infoWindow, setInfoWindow] = useState(null);
+  const contentContainerRef = useRef(null);
+  const headerContainerRef = useRef(null);
+  useEffect(
+    () => {
+      if (!mapsLibrary) return;
+      contentContainerRef.current = document.createElement("div");
+      headerContainerRef.current = document.createElement("div");
+      const opts = infoWindowOptions;
+      if (pixelOffset) {
+        opts.pixelOffset = new google.maps.Size(pixelOffset[0], pixelOffset[1]);
+      }
+      if (headerContent) {
+        opts.headerContent = typeof headerContent === "string" ? headerContent : headerContainerRef.current;
+      }
+      const infoWindow2 = new google.maps.InfoWindow(infoWindowOptions);
+      infoWindow2.setContent(contentContainerRef.current);
+      setInfoWindow(infoWindow2);
+      return () => {
+        var _contentContainerRef$, _headerContainerRef$c;
+        infoWindow2.setContent(null);
+        (_contentContainerRef$ = contentContainerRef.current) == null || _contentContainerRef$.remove();
+        (_headerContainerRef$c = headerContainerRef.current) == null || _headerContainerRef$c.remove();
+        contentContainerRef.current = null;
+        headerContainerRef.current = null;
+        setInfoWindow(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
+    [mapsLibrary]
+  );
+  const prevStyleRef = useRef(null);
+  useEffect(() => {
+    if (!infoWindow || !contentContainerRef.current) return;
+    setValueForStyles(contentContainerRef.current, style2 || null, prevStyleRef.current);
+    prevStyleRef.current = style2 || null;
+    if (className !== contentContainerRef.current.className) contentContainerRef.current.className = className || "";
+  }, [infoWindow, className, style2]);
+  useDeepCompareEffect(
+    () => {
+      if (!infoWindow) return;
+      const opts = infoWindowOptions;
+      if (!pixelOffset) {
+        opts.pixelOffset = null;
+      } else {
+        opts.pixelOffset = new google.maps.Size(pixelOffset[0], pixelOffset[1]);
+      }
+      if (!headerContent) {
+        opts.headerContent = null;
+      } else {
+        opts.headerContent = typeof headerContent === "string" ? headerContent : headerContainerRef.current;
+      }
+      infoWindow.setOptions(infoWindowOptions);
+    },
+    // 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
+    [infoWindowOptions, pixelOffset, headerContent]
+  );
+  useMapsEventListener(infoWindow, "close", onClose);
+  useMapsEventListener(infoWindow, "closeclick", onCloseClick);
+  const map = useMap();
+  useDeepCompareEffect(() => {
+    if (!map || !infoWindow || anchor === null) return;
+    const isOpenedWithAnchor = !!anchor;
+    const openOptions = {
+      map
+    };
+    if (anchor) {
+      openOptions.anchor = anchor;
+      if (isAdvancedMarker(anchor) && anchor.content instanceof Element) {
+        const wrapper = anchor.content;
+        const wrapperBcr = wrapper == null ? void 0 : wrapper.getBoundingClientRect();
+        if (wrapperBcr && wrapper != null && wrapper.isCustomMarker) {
+          var _anchor$content$first;
+          const anchorDomContent = (_anchor$content$first = anchor.content.firstElementChild) == null ? void 0 : _anchor$content$first.firstElementChild;
+          const contentBcr = anchorDomContent == null ? void 0 : anchorDomContent.getBoundingClientRect();
+          const anchorOffsetX = contentBcr.x - wrapperBcr.x + (contentBcr.width - wrapperBcr.width) / 2;
+          const anchorOffsetY = contentBcr.y - wrapperBcr.y;
+          const opts = infoWindowOptions;
+          opts.pixelOffset = new google.maps.Size(pixelOffset ? pixelOffset[0] + anchorOffsetX : anchorOffsetX, pixelOffset ? pixelOffset[1] + anchorOffsetY : anchorOffsetY);
+          infoWindow.setOptions(opts);
+        }
+      }
+    }
+    if (shouldFocus !== void 0) {
+      openOptions.shouldFocus = shouldFocus;
+    }
+    infoWindow.open(openOptions);
+    return () => {
+      if (isOpenedWithAnchor) infoWindow.set("anchor", null);
+      infoWindow.close();
+    };
+  }, [infoWindow, anchor, map, shouldFocus, infoWindowOptions, pixelOffset]);
+  return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, contentContainerRef.current && createPortal(children, contentContainerRef.current), headerContainerRef.current !== null && createPortal(headerContent, headerContainerRef.current));
+};
+const _excluded = ["onClick", "onDrag", "onDragStart", "onDragEnd", "onMouseOver", "onMouseOut"];
+function useMarker(props) {
+  const [marker, setMarker] = useState(null);
+  const map = useMap();
+  const {
+    onClick,
+    onDrag,
+    onDragStart,
+    onDragEnd,
+    onMouseOver,
+    onMouseOut
+  } = props, markerOptions = _objectWithoutPropertiesLoose(props, _excluded);
+  const {
+    position,
+    draggable
+  } = markerOptions;
+  useEffect(() => {
+    if (!map) {
+      if (map === void 0) console.error("<Marker> has to be inside a Map component.");
+      return;
+    }
+    const newMarker = new google.maps.Marker(markerOptions);
+    newMarker.setMap(map);
+    setMarker(newMarker);
+    return () => {
+      newMarker.setMap(null);
+      setMarker(null);
+    };
+  }, [map]);
+  useEffect(() => {
+    if (!marker) return;
+    const m = marker;
+    const gme = google.maps.event;
+    if (onClick) gme.addListener(m, "click", onClick);
+    if (onDrag) gme.addListener(m, "drag", onDrag);
+    if (onDragStart) gme.addListener(m, "dragstart", onDragStart);
+    if (onDragEnd) gme.addListener(m, "dragend", onDragEnd);
+    if (onMouseOver) gme.addListener(m, "mouseover", onMouseOver);
+    if (onMouseOut) gme.addListener(m, "mouseout", onMouseOut);
+    marker.setDraggable(Boolean(draggable));
+    return () => {
+      gme.clearInstanceListeners(m);
+    };
+  }, [marker, draggable, onClick, onDrag, onDragStart, onDragEnd, onMouseOver, onMouseOut]);
+  useEffect(() => {
+    if (!marker) return;
+    if (markerOptions) marker.setOptions(markerOptions);
+  }, [marker, markerOptions]);
+  useEffect(() => {
+    if (draggable || !position || !marker) return;
+    marker.setPosition(position);
+  }, [draggable, position, marker]);
+  return marker;
+}
+forwardRef((props, ref) => {
+  const marker = useMarker(props);
+  useImperativeHandle(ref, () => marker, [marker]);
+  return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null);
+});
+const title = "title__jE00O";
+const description = "description__bjRoW";
+const link = "link__AM1ap";
+const pinIcon = "pinIcon__PgsnW";
+const srOnly = "srOnly__BD6KL";
+const styles = {
+  title,
+  description,
+  link,
+  pinIcon,
+  srOnly
+};
+const getGoogleMapsDirectionsUrl = (location) => {
+  if (!location || !location.address) {
+    return void 0;
+  }
+  const url = new URL(GOOGLE_MAPS_DIRECTIONS_BASE_URL);
+  url.searchParams.set("api", "1");
+  url.searchParams.set("destination", location.address);
+  return url.toString();
+};
+const getLinkInfo = (location) => {
+  const link2 = location == null ? void 0 : location.locationLinkAttributes;
+  const isLinkValid = link2 && typeof link2 === "object" && "href" in link2 && typeof link2.href === "string" && link2.href;
+  const anchorProps = isLinkValid ? {
+    href: link2.href,
+    ..."target" in link2 && typeof link2.target === "string" && link2.target ? { target: link2.target } : {},
+    ..."rel" in link2 && typeof link2.rel === "string" && link2.rel ? { rel: link2.rel } : {}
+  } : {};
+  return {
+    isLinkValid: Boolean(isLinkValid),
+    anchorProps
+  };
+};
+const isValidLocationParam = (loc) => {
+  if (loc === 0) {
+    return true;
+  }
+  return !!loc;
+};
+const isValidZoom = (zoom) => {
+  return zoom !== void 0 && zoom !== null && zoom >= MIN_ZOOM && zoom <= MAX_ZOOM;
+};
+function hasMarkerInfoWindowFields(location, mapData) {
+  return Boolean(
+    location.title || location.description || location.linkTitle || location.locationLinkAttributes || mapData.showDirectionsLink
+  );
+}
+const GoogleMapMarker = ({
+  location,
+  infoWindowOpen,
+  onMarkerClick,
+  onInfoWindowClose,
+  showDirectionLink,
+  allyTargetBlankDescription
+}) => {
+  var _a;
+  const directionsUrl = getGoogleMapsDirectionsUrl(location);
+  const { isLinkValid, anchorProps } = getLinkInfo(location);
+  const handleMarkerClick = () => {
+    var _a2;
+    onMarkerClick == null ? void 0 : onMarkerClick({
+      type: "markerClicked",
+      address: location.address,
+      location: {
+        latitude: location.latitude || 0,
+        longitude: location.longitude || 0
+      },
+      icon: location.pinIcon || "",
+      link: (_a2 = location.locationLinkAttributes) == null ? void 0 : _a2.href,
+      title: location.title,
+      linkTitle: location.linkTitle,
+      description: location.description
+    });
+  };
+  if (!location || !isValidLocationParam(location.longitude) || !isValidLocationParam(location.latitude)) {
+    return null;
+  }
+  const position = {
+    lat: Number(location.latitude),
+    lng: Number(location.longitude)
+  };
+  const iconSvg = location.pinIcon && /* @__PURE__ */ jsx(
+    "div",
+    {
+      "aria-hidden": true,
+      "data-testid": TestIds.markerSvg,
+      className: styles.pinIcon,
+      children: parse(location.pinIcon)
+    }
+  );
+  const infoWindowContent = /* @__PURE__ */ jsxs("div", { children: [
+    location.description && /* @__PURE__ */ jsx("p", { className: styles.description, children: location.description }),
+    location.linkTitle && isLinkValid && /* @__PURE__ */ jsxs(
+      "a",
+      {
+        className: styles.link,
+        ...anchorProps,
+        "data-testid": TestIds.markerLink,
+        children: [
+          location.linkTitle,
+          ((_a = location.locationLinkAttributes) == null ? void 0 : _a.target) === "_blank" && allyTargetBlankDescription && /* @__PURE__ */ jsx("span", { className: styles.srOnly, children: allyTargetBlankDescription })
+        ]
+      }
+    ),
+    showDirectionLink && directionsUrl && /* @__PURE__ */ jsx(
+      "a",
+      {
+        href: directionsUrl,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        className: styles.link,
+        "data-testid": TestIds.markerDirectionsLink,
+        "aria-label": `${location.directionTitle}. ${allyTargetBlankDescription}`,
+        children: location.directionTitle
+      }
+    )
+  ] });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      AdvancedMarker,
+      {
+        position,
+        title: location.title,
+        onClick: handleMarkerClick,
+        children: iconSvg
+      }
+    ),
+    infoWindowOpen && /* @__PURE__ */ jsx(
+      InfoWindow,
+      {
+        position,
+        pixelOffset: [0, -32],
+        shouldFocus: false,
+        maxWidth: 300,
+        minWidth: 228,
+        headerContent: location.title && /* @__PURE__ */ jsx("h2", { className: styles.title, children: location.title }),
+        onCloseClick: onInfoWindowClose,
+        disableAutoPan: true,
+        children: infoWindowContent
+      }
+    )
+  ] });
+};
+const GoogleMapMarker$1 = React.memo(GoogleMapMarker);
+const createSdkMethods = (mapRef, updateZoom, updateCenter) => {
+  return {
+    setMapCenter: (longitude, latitude) => {
+      const center = { lat: latitude, lng: longitude };
+      if (mapRef.current && center) {
+        mapRef.current.setCenter(center);
+        updateCenter(center);
+      }
+      return Promise.resolve();
+    },
+    setMapZoom: (zoom) => {
+      if (mapRef.current && isValidZoom(zoom)) {
+        mapRef.current.setZoom(zoom);
+        updateZoom(zoom);
+      }
+      return Promise.resolve();
+    },
+    fitBounds: (bounds) => {
+      if (mapRef.current) {
+        const googleBounds = new google.maps.LatLngBounds(
+          { lat: bounds.south, lng: bounds.west },
+          { lat: bounds.north, lng: bounds.east }
+        );
+        mapRef.current.fitBounds(googleBounds);
+        const center = mapRef.current.getCenter();
+        const zoom = mapRef.current.getZoom();
+        if (center && isValidZoom(zoom)) {
+          updateZoom(zoom);
+          updateCenter({ lat: center.lat(), lng: center.lng() });
+        }
+      }
+      return Promise.resolve();
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    setMarkers: (_locations) => {
+      return Promise.resolve();
+    },
+    getVisibleMarkers: (locations) => {
+      if (mapRef.current) {
+        const bounds = mapRef.current.getBounds();
+        if (bounds) {
+          const visibleMarkers = locations.filter((marker) => {
+            const position = new google.maps.LatLng(
+              marker.latitude,
+              marker.longitude
+            );
+            return bounds.contains(position);
+          }).map((marker) => ({
+            title: marker.title,
+            location: {
+              latitude: marker.latitude,
+              longitude: marker.longitude
+            }
+          }));
+          return Promise.resolve(visibleMarkers);
+        }
+      }
+      return Promise.resolve(
+        locations.map((loc) => ({
+          title: loc.title,
+          location: {
+            latitude: loc.latitude,
+            longitude: loc.longitude
+          }
+        }))
+      );
+    },
+    setMarkerIcon: (_updateData) => {
+      return Promise.resolve();
+    }
+  };
+};
+const createImperativeMethods = (mapRef, updateZoom, updateCenter, locations) => {
+  const sdkMethods = createSdkMethods(mapRef, updateZoom, updateCenter);
+  return {
+    setMapCenter: (longitude, latitude) => {
+      return sdkMethods.setMapCenter(longitude, latitude);
+    },
+    setMapZoom: (zoom) => {
+      return sdkMethods.setMapZoom(zoom);
+    },
+    fitBounds: (bounds) => {
+      return sdkMethods.fitBounds(bounds);
+    },
+    setMarkers: (newLocations) => {
+      return sdkMethods.setMarkers(newLocations);
+    },
+    setMarkerIcon: (updateData) => {
+      return sdkMethods.setMarkerIcon(updateData);
+    },
+    getVisibleMarkers: () => {
+      return sdkMethods.getVisibleMarkers(locations);
+    },
+    getCenter: () => {
+      if (mapRef.current && mapRef.current.getCenter) {
+        const center = mapRef.current.getCenter();
+        if (center) {
+          return {
+            lat: () => center.lat(),
+            lng: () => center.lng()
+          };
+        }
+      }
+      return {
+        lat: () => 0,
+        lng: () => 0
+      };
+    },
+    getZoom: () => {
+      if (mapRef.current && mapRef.current.getZoom) {
+        const zoom = mapRef.current.getZoom();
+        return zoom !== void 0 ? zoom : DEFAULT_ZOOM;
+      }
+      return DEFAULT_ZOOM;
+    }
+  };
+};
+const GoogleMapReactInner = forwardRef((props, forwardedRef) => {
+  const {
+    id,
+    mapData,
+    translations,
+    onUpdateCenter,
+    onUpdateZoom,
+    onMarkerClicked,
+    onMapClicked,
+    onMapMount
+  } = props;
+  const map = useMap();
+  const mapRef = useRef(map);
+  useEffect(() => {
+    mapRef.current = map;
+  }, [map]);
+  const defaultZoom = useMemo(() => {
+    return isValidZoom(mapData.zoom) && mapData.zoom || DEFAULT_ZOOM;
+  }, [mapData.zoom]);
+  useEffect(() => map == null ? void 0 : map.setZoom(defaultZoom), [defaultZoom, map]);
+  const defaultLocationIndex = useMemo(() => {
+    if (mapData.defaultLocation >= 0 && mapData.locations && mapData.defaultLocation < mapData.locations.length) {
+      return mapData.defaultLocation;
+    }
+    return 0;
+  }, [mapData.locations, mapData.defaultLocation]);
+  const defaultCenter = useMemo(() => {
+    if (!mapData.locations || mapData.locations.length === 0) {
+      return { lat: 0, lng: 0 };
+    }
+    const location = mapData.locations[defaultLocationIndex];
+    return {
+      lat: (location == null ? void 0 : location.latitude) ?? 0,
+      lng: (location == null ? void 0 : location.longitude) ?? 0
+    };
+  }, [mapData.locations, defaultLocationIndex]);
+  useEffect(() => map == null ? void 0 : map.setCenter(defaultCenter), [defaultCenter, map]);
+  const [openInfoWindowIndex, setOpenInfoWindowIndex] = useState(
+    defaultLocationIndex
+  );
+  useEffect(
+    () => setOpenInfoWindowIndex(defaultLocationIndex),
+    [defaultLocationIndex]
+  );
+  const handleZoomChange = useCallback(
+    (zoom) => {
+      if (isValidZoom(zoom)) {
+        onUpdateZoom == null ? void 0 : onUpdateZoom({ zoom });
+      }
+    },
+    [onUpdateZoom]
+  );
+  const handleCenterChanged = useCallback(
+    (center) => {
+      if (center) {
+        onUpdateCenter == null ? void 0 : onUpdateCenter({ latitude: center.lat, longitude: center.lng });
+      }
+    },
+    [onUpdateCenter]
+  );
+  const handleMapClick = useCallback(
+    (event) => {
+      try {
+        if (onMapClicked && event.detail.latLng) {
+          onMapClicked({
+            type: "mapClicked",
+            location: {
+              latitude: event.detail.latLng.lat,
+              longitude: event.detail.latLng.lng
+            }
+          });
+        }
+      } catch (error) {
+        console.error("GoogleMap: Click handler error", {
+          error: error instanceof Error ? error.message : String(error),
+          componentId: id
+        });
+      }
+    },
+    [onMapClicked, id]
+  );
+  const handleMarkerClicked = (index) => (data) => {
+    setOpenInfoWindowIndex(openInfoWindowIndex === index ? null : index);
+    onMarkerClicked == null ? void 0 : onMarkerClicked(data);
+  };
+  useImperativeHandle(
+    forwardedRef,
+    () => createImperativeMethods(
+      mapRef,
+      handleZoomChange,
+      handleCenterChanged,
+      mapData.locations
+    ),
+    [handleZoomChange, handleCenterChanged, mapData.locations]
+  );
+  useEffect(() => {
+    onMapMount == null ? void 0 : onMapMount();
+  }, [onMapMount]);
+  const mapStyleConfig = useMemo(() => {
+    const styleKey = mapData.mapStyleKey;
+    return {
+      mapId: MAP_IDS[styleKey] || MAP_IDS.CLASSIC,
+      mapTypeId: (MAP_TYPES[styleKey] || MAP_TYPES.CLASSIC).toLowerCase()
+    };
+  }, [mapData.mapStyleKey]);
+  const mapProps = useMemo(
+    () => ({
+      fullscreenControl: false,
+      clickableIcons: true,
+      keyboardShortcuts: true,
+      disableDoubleClickZoom: false,
+      disableDefaultUI: true,
+      gestureHandling: mapData.mapInteractive ? "auto" : "none",
+      mapTypeControl: mapData.showMapType,
+      zoomControl: mapData.showZoom,
+      streetViewControl: mapData.showStreetView,
+      rotateControl: false
+    }),
+    [
+      mapData.mapInteractive,
+      mapData.showMapType,
+      mapData.showZoom,
+      mapData.showStreetView
+    ]
+  );
+  return /* @__PURE__ */ jsx(
+    Map,
+    {
+      onCenterChanged: (e) => handleCenterChanged(e.detail.center),
+      onZoomChanged: (e) => handleZoomChange(e.detail.zoom),
+      onClick: handleMapClick,
+      style: { width: "100%", height: "100%" },
+      defaultCenter,
+      defaultZoom,
+      reuseMaps: true,
+      ...mapProps,
+      ...mapStyleConfig,
+      children: mapData.locations.map((location, index) => /* @__PURE__ */ jsx(
+        GoogleMapMarker$1,
+        {
+          location,
+          infoWindowOpen: openInfoWindowIndex === index && hasMarkerInfoWindowFields(location, mapData),
+          onMarkerClick: handleMarkerClicked(index),
+          onInfoWindowClose: () => setOpenInfoWindowIndex(null),
+          showDirectionLink: mapData.showDirectionsLink,
+          allyTargetBlankDescription: translations.allyTargetBlankDescription
+        },
+        `${index}-${location.latitude}-${location.longitude}`
+      ))
+    }
+  );
+});
+const GoogleMapReactInteractiveMap = forwardRef((props, forwardedRef) => {
+  return /* @__PURE__ */ jsx(APIProvider, { apiKey: API_KEY, language: props.language, children: /* @__PURE__ */ jsx(GoogleMapReactInner, { ...props, ref: forwardedRef }) });
+});
+const GoogleMapReactInteractiveMap$1 = memo(GoogleMapReactInteractiveMap);
+const DEFAULT_TRANSLATIONS = {};
+const useCookieConsent = (options) => {
+  const {
+    config,
+    isConsentPolicyActive = false,
+    isMobile = false,
+    consentPolicy,
+    openSettingModal,
+    translations = DEFAULT_TRANSLATIONS
+  } = options;
+  return useMemo(() => {
+    const requiredConsentTypes = Object.keys(config.requiredConsent || {});
+    const hasRequiredConsent = (() => {
+      if (!isConsentPolicyActive) {
+        return true;
+      }
+      if (requiredConsentTypes.length === 0) {
+        return true;
+      }
+      if (!(consentPolicy == null ? void 0 : consentPolicy.policy)) {
+        return false;
+      }
+      return requiredConsentTypes.every((consentType) => {
+        const policyKey = consentType;
+        return consentPolicy.policy[policyKey] === true;
+      });
+    })();
+    return {
+      isConsentPolicyActive,
+      isMobile,
+      consentPolicy,
+      openSettingModal,
+      translations,
+      hasRequiredConsent,
+      requiredConsentTypes,
+      componentConsentPolicy: config.requiredConsent ?? {}
+    };
+  }, [
+    config,
+    isConsentPolicyActive,
+    isMobile,
+    consentPolicy,
+    openSettingModal,
+    translations
+  ]);
+};
+const defaultManifestProps = {
+  locations: [DEFAULT_LOCATION],
+  defaultLocation: 0,
+  showDirectionsLink: true,
+  showMapType: false,
+  showZoom: true,
+  showStreetView: false,
+  mapInteractive: true,
+  zoom: 14,
+  mapStyleKey: "CLASSIC"
+};
+const defaultPinIcon = '<!--?xml version="1.0" encoding="UTF-8"?--><svg data-bbox="1.6 0 20.7 34" viewBox="0 0 24 34" height="34" width="24" xmlns="http://www.w3.org/2000/svg" data-type="color"><g><path d="M11.9 33.4c-.2 0-.5 0-.6-.2l-.2-.2c-.5-.4-.6-.9-.9-2.2-1-4.2-2.1-6.7-3.1-9-.7-1.4-1.4-2.6-2.1-3.7-1.7-2.8-2.8-4.7-2.8-8 0-2.3.9-4.7 2.5-6.5 1.9-1.8 4.6-3 7.2-3h.2c2.7 0 5.4 1.3 7.3 3.3 1.6 1.7 2.6 4.2 2.5 6.5 0 3.3-1.1 5.1-2.8 7.9-.6 1.1-1.3 2.3-2.1 3.8-.9 2.2-2 4.7-3 8.9-.3 1.3-.4 2-1.3 2.3h-.3c-.1.1-.2.2-.3.2Z" fill="#ff4646" data-color="1"></path><path d="M11.9 1.1h.2c2.5 0 5.1 1.2 6.9 3.2 1.5 1.6 2.4 3.9 2.4 6.1 0 3.1-1.1 4.9-2.7 7.7-.6 1.1-1.4 2.3-2.2 3.8-1 2.2-2 4.8-3.1 9-.3 1.2-.4 1.7-1 1.9h-.3c0 .1-.1.1-.2.1s-.2 0-.3-.1l-.2-.2c-.4-.3-.4-.6-.7-1.9-1-4.2-2.1-6.8-3.1-9.1-.8-1.5-1.5-2.7-2.1-3.7-1.6-2.8-2.7-4.6-2.7-7.7 0-2.2.9-4.5 2.4-6.1C7 2.2 9.5 1 12 1m-.1-1C9.1 0 6.3 1.4 4.3 3.5c-1.7 1.8-2.7 4.4-2.7 6.8 0 3.4 1.2 5.4 2.9 8.2.6 1 1.3 2.2 2.1 3.7 1 2.2 2 4.7 3 8.9.3 1.3.4 1.9 1.1 2.4l.2.2q.45.3.9.3h.8c1.1-.5 1.4-1.4 1.7-2.7 1-4.1 2.1-6.6 3-8.8.8-1.5 1.5-2.7 2.1-3.8 1.6-2.8 2.8-4.8 2.9-8.2 0-2.4-1-5-2.7-6.8C17.7 1.5 14.8.1 12 0h-.2Z" fill="#ffffff" data-color="2"></path><path fill="#590000" d="M15.2 10.4a3.2 3.2 0 1 1-6.4 0 3.2 3.2 0 0 1 6.4 0" data-color="3"></path></g></svg>';
+const directionTitle = "Directions";
+const useGoogleMapProps = (props) => {
+  const consentPolicyProps = useConsentPolicyProps();
+  const cookieConsent = useCookieConsent({
+    config: {
+      componentNameKey: COMPONENT_NAME_KEY,
+      componentNameDefault: COMPONENT_NAME_DEFAULT,
+      companyNameKey: COMPANY_NAME_KEY,
+      companyNameDefault: COMPANY_NAME_DEFAULT,
+      requiredConsent: { analytics: true, functional: true }
+    },
+    isConsentPolicyActive: consentPolicyProps.isConsentPolicyActive,
+    consentPolicy: consentPolicyProps.consentPolicy,
+    isMobile: consentPolicyProps.isMobile,
+    openSettingModal: consentPolicyProps.openSettingModal,
+    translations: consentPolicyProps.translations
+  });
+  const mapData = useMemo(() => {
+    const locations = [
+      ...props.locations && props.locations.length ? props.locations : defaultManifestProps.locations
+    ].map((location) => {
+      var _a;
+      return {
+        ...location,
+        pinIcon: ((_a = props.pinIcon) == null ? void 0 : _a.svgContent) || defaultPinIcon,
+        directionTitle
+      };
+    });
+    return {
+      locations,
+      showDirectionsLink: props.showDirectionsLink ?? defaultManifestProps.showDirectionsLink,
+      showMapType: props.showMapType ?? defaultManifestProps.showMapType,
+      showZoom: props.showZoom ?? defaultManifestProps.showZoom,
+      showStreetView: props.showStreetView ?? defaultManifestProps.showStreetView,
+      mapInteractive: props.mapInteractive ?? defaultManifestProps.mapInteractive,
+      zoom: props.zoom ?? defaultManifestProps.zoom,
+      mapStyleKey: props.mapStyleKey ?? defaultManifestProps.mapStyleKey,
+      defaultLocation: props.defaultLocation ?? defaultManifestProps.defaultLocation
+    };
+  }, [
+    props.locations,
+    props.showDirectionsLink,
+    props.showMapType,
+    props.showZoom,
+    props.showStreetView,
+    props.mapInteractive,
+    props.zoom,
+    props.pinIcon,
+    props.mapStyleKey,
+    props.defaultLocation
+  ]);
+  const componentProps = useMemo(() => {
+    return {
+      skin: "GoogleMapDefault",
+      id: props.id,
+      className: `${props.className || ""} google-map`,
+      customClassNames: [],
+      translations: {
+        title: "Google Map",
+        allyTargetBlankDescription: "Opens in a new tab",
+        ...cookieConsent.translations
+      },
+      language: "en",
+      lang: "en",
+      onMouseEnter: props.onMouseIn,
+      onMouseLeave: props.onMouseOut,
+      isConsentPolicyActive: cookieConsent.isConsentPolicyActive,
+      isMobile: cookieConsent.isMobile,
+      consentPolicy: cookieConsent.consentPolicy,
+      openSettingModal: cookieConsent.openSettingModal,
+      hasRequiredConsent: cookieConsent.hasRequiredConsent,
+      componentConsentPolicy: cookieConsent.componentConsentPolicy
+    };
+  }, [
+    props.id,
+    props.className,
+    props.onMouseIn,
+    props.onMouseOut,
+    cookieConsent.hasRequiredConsent,
+    cookieConsent.isConsentPolicyActive,
+    cookieConsent.consentPolicy,
+    cookieConsent.componentConsentPolicy,
+    cookieConsent.translations,
+    cookieConsent.isMobile,
+    cookieConsent.openSettingModal
+  ]);
+  return { componentProps, mapData };
+};
+const MapContent = forwardRef((props, forwardedRef) => {
+  var _a;
+  const environment = useService(definitionExports.EnvironmentDefinition);
+  const isSSR = ((_a = environment == null ? void 0 : environment.isSSR) == null ? void 0 : _a.call(environment)) ?? false;
+  return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Fragment, {}), children: !isSSR && /* @__PURE__ */ jsx(GoogleMapReactInteractiveMap$1, { ...props, ref: forwardedRef }) });
+});
+function GoogleMapComponent(props) {
+  const { componentProps, mapData } = useGoogleMapProps(props);
+  const googleMapElement = /* @__PURE__ */ jsx(
+    GoogleMapReact,
+    {
+      ...componentProps,
+      mapData,
+      MapContent
+    }
+  );
+  if (componentProps.isConsentPolicyActive && !componentProps.hasRequiredConsent) {
+    return /* @__PURE__ */ jsx(
+      ConsentPolicyWrapper,
+      {
+        ...componentProps,
+        className: clsx(
+          componentProps.className,
+          "google-map-consent-wrapper"
+        ),
+        children: googleMapElement
+      }
+    );
+  }
+  return googleMapElement;
+}
+export {
+  GoogleMapComponent as default
+};