{"version":3,"file":"564.b6f7451d152c3e09cace.js","mappings":"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","sources":["webpack://eleven-miles-erebus/./node_modules/fast-deep-equal/index.js","webpack://eleven-miles-erebus/./node_modules/use-debounce/dist/index.module.js","webpack://eleven-miles-erebus/./node_modules/@vis.gl/react-google-maps/dist/index.modern.mjs"],"sourcesContent":["'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","import{useRef as r,useEffect as n,useMemo as t,useState as e,useCallback as u}from\"react\";function c(e,u,c){var i=this,a=r(null),o=r(0),f=r(null),l=r([]),v=r(),m=r(),d=r(e),g=r(!0);d.current=e;var p=\"undefined\"!=typeof window,w=!u&&0!==u&&p;if(\"function\"!=typeof e)throw new TypeError(\"Expected a function\");u=+u||0;var s=!!(c=c||{}).leading,x=!(\"trailing\"in c)||!!c.trailing,h=\"maxWait\"in c,y=\"debounceOnServer\"in c&&!!c.debounceOnServer,F=h?Math.max(+c.maxWait||0,u):null;n(function(){return g.current=!0,function(){g.current=!1}},[]);var A=t(function(){var r=function(r){var n=l.current,t=v.current;return l.current=v.current=null,o.current=r,m.current=d.current.apply(t,n)},n=function(r,n){w&&cancelAnimationFrame(f.current),f.current=w?requestAnimationFrame(r):setTimeout(r,n)},t=function(r){if(!g.current)return!1;var n=r-a.current;return!a.current||n>=u||n<0||h&&r-o.current>=F},e=function(n){return f.current=null,x&&l.current?r(n):(l.current=v.current=null,m.current)},c=function r(){var c=Date.now();if(t(c))return e(c);if(g.current){var i=u-(c-a.current),f=h?Math.min(i,F-(c-o.current)):i;n(r,f)}},A=function(){if(p||y){var e=Date.now(),d=t(e);if(l.current=[].slice.call(arguments),v.current=i,a.current=e,d){if(!f.current&&g.current)return o.current=a.current,n(c,u),s?r(a.current):m.current;if(h)return n(c,u),r(a.current)}return f.current||n(c,u),m.current}};return A.cancel=function(){f.current&&(w?cancelAnimationFrame(f.current):clearTimeout(f.current)),o.current=0,l.current=a.current=v.current=f.current=null},A.isPending=function(){return!!f.current},A.flush=function(){return f.current?e(Date.now()):m.current},A},[s,h,u,F,x,w,p,y]);return A}function i(r,n){return r===n}function a(n,t,a){var o=a&&a.equalityFn||i,f=r(n),l=e({})[1],v=c(u(function(r){f.current=r,l({})},[l]),t,a),m=r(n);return o(m.current,n)||(v(n),m.current=n),[f.current,v]}function o(r,n,t){var e=void 0===t?{}:t,u=e.leading,i=e.trailing;return c(r,n,{maxWait:n,leading:void 0===u||u,trailing:void 0===i||i})}export{a as useDebounce,c as useDebouncedCallback,o as useThrottledCallback};\n//# sourceMappingURL=index.module.js.map\n","import React, { useMemo, useState, useReducer, useCallback, useEffect, useRef, useContext, useLayoutEffect, forwardRef, useImperativeHandle, Children } from 'react';\nimport { createPortal } from 'react-dom';\nimport isDeepEqual from 'fast-deep-equal';\n\nfunction _extends() {\n  return _extends = Object.assign ? Object.assign.bind() : function (n) {\n    for (var e = 1; e < arguments.length; e++) {\n      var t = arguments[e];\n      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);\n    }\n    return n;\n  }, _extends.apply(null, arguments);\n}\nfunction _objectWithoutPropertiesLoose(r, e) {\n  if (null == r) return {};\n  var t = {};\n  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n    if (e.includes(n)) continue;\n    t[n] = r[n];\n  }\n  return t;\n}\nfunction _toPrimitive(t, r) {\n  if (\"object\" != typeof t || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != typeof i) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nfunction _toPropertyKey(t) {\n  var i = _toPrimitive(t, \"string\");\n  return \"symbol\" == typeof i ? i : i + \"\";\n}\n\nconst APILoadingStatus = {\n  NOT_LOADED: 'NOT_LOADED',\n  LOADING: 'LOADING',\n  LOADED: 'LOADED',\n  FAILED: 'FAILED',\n  AUTH_FAILURE: 'AUTH_FAILURE'\n};\n\nconst MAPS_API_BASE_URL = 'https://maps.googleapis.com/maps/api/js';\n/**\n * A GoogleMapsApiLoader to reliably load and unload the Google Maps JavaScript API.\n *\n * The actual loading and unloading is delayed into the microtask queue, to\n * allow using the API in an useEffect hook, without worrying about multiple API loads.\n */\nclass GoogleMapsApiLoader {\n  /**\n   * Loads the Maps JavaScript API with the specified parameters.\n   * Since the Maps library can only be loaded once per page, this will\n   * produce a warning when called multiple times with different\n   * parameters.\n   *\n   * The returned promise resolves when loading completes\n   * and rejects in case of an error or when the loading was aborted.\n   */\n  static async load(params, onLoadingStatusChange) {\n    var _window$google;\n    const libraries = params.libraries ? params.libraries.split(',') : [];\n    const serializedParams = this.serializeParams(params);\n    this.listeners.push(onLoadingStatusChange);\n    // Note: if `google.maps.importLibrary` has been defined externally, we\n    //   assume that loading is complete and successful.\n    //   If it was defined by a previous call to this method, a warning\n    //   message is logged if there are differences in api-parameters used\n    //   for both calls.\n    if ((_window$google = window.google) != null && (_window$google = _window$google.maps) != null && _window$google.importLibrary) {\n      // no serialized parameters means it was loaded externally\n      if (!this.serializedApiParams) {\n        this.loadingStatus = APILoadingStatus.LOADED;\n      }\n      this.notifyLoadingStatusListeners();\n    } else {\n      this.serializedApiParams = serializedParams;\n      this.initImportLibrary(params);\n    }\n    if (this.serializedApiParams && this.serializedApiParams !== serializedParams) {\n      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.`);\n    }\n    const librariesToLoad = ['maps', ...libraries];\n    await Promise.all(librariesToLoad.map(name => google.maps.importLibrary(name)));\n  }\n  /**\n   * Serialize the paramters used to load the library for easier comparison.\n   */\n  static serializeParams(params) {\n    return [params.v, params.key, params.language, params.region, params.authReferrerPolicy, params.solutionChannel].join('/');\n  }\n  /**\n   * Creates the global `google.maps.importLibrary` function for bootstrapping.\n   * This is essentially a formatted version of the dynamic loading script\n   * from the official documentation with some minor adjustments.\n   *\n   * The created importLibrary function will load the Google Maps JavaScript API,\n   * which will then replace the `google.maps.importLibrary` function with the full\n   * implementation.\n   *\n   * @see https://developers.google.com/maps/documentation/javascript/load-maps-js-api#dynamic-library-import\n   */\n  static initImportLibrary(params) {\n    if (!window.google) window.google = {};\n    if (!window.google.maps) window.google.maps = {};\n    if (window.google.maps['importLibrary']) {\n      console.error('[google-maps-api-loader-internal]: initImportLibrary must only be called once');\n      return;\n    }\n    let apiPromise = null;\n    const loadApi = () => {\n      if (apiPromise) return apiPromise;\n      apiPromise = new Promise((resolve, reject) => {\n        var _document$querySelect;\n        const scriptElement = document.createElement('script');\n        const urlParams = new URLSearchParams();\n        for (const [key, value] of Object.entries(params)) {\n          const urlParamName = key.replace(/[A-Z]/g, t => '_' + t[0].toLowerCase());\n          urlParams.set(urlParamName, String(value));\n        }\n        urlParams.set('loading', 'async');\n        urlParams.set('callback', '__googleMapsCallback__');\n        scriptElement.async = true;\n        scriptElement.src = MAPS_API_BASE_URL + `?` + urlParams.toString();\n        scriptElement.nonce = ((_document$querySelect = document.querySelector('script[nonce]')) == null ? void 0 : _document$querySelect.nonce) || '';\n        scriptElement.onerror = () => {\n          this.loadingStatus = APILoadingStatus.FAILED;\n          this.notifyLoadingStatusListeners();\n          reject(new Error('The Google Maps JavaScript API could not load.'));\n        };\n        window.__googleMapsCallback__ = () => {\n          this.loadingStatus = APILoadingStatus.LOADED;\n          this.notifyLoadingStatusListeners();\n          resolve();\n        };\n        window.gm_authFailure = () => {\n          this.loadingStatus = APILoadingStatus.AUTH_FAILURE;\n          this.notifyLoadingStatusListeners();\n        };\n        this.loadingStatus = APILoadingStatus.LOADING;\n        this.notifyLoadingStatusListeners();\n        document.head.append(scriptElement);\n      });\n      return apiPromise;\n    };\n    // for the first load, we declare an importLibrary function that will\n    // be overwritten once the api is loaded.\n    google.maps.importLibrary = libraryName => loadApi().then(() => google.maps.importLibrary(libraryName));\n  }\n  /**\n   * Calls all registered loadingStatusListeners after a status update.\n   */\n  static notifyLoadingStatusListeners() {\n    for (const fn of this.listeners) {\n      fn(this.loadingStatus);\n    }\n  }\n}\n/**\n * The current loadingStatus of the API.\n */\nGoogleMapsApiLoader.loadingStatus = APILoadingStatus.NOT_LOADED;\n/**\n * The parameters used for first loading the API.\n */\nGoogleMapsApiLoader.serializedApiParams = void 0;\n/**\n * A list of functions to be notified when the loading status changes.\n */\nGoogleMapsApiLoader.listeners = [];\n\nconst _excluded$3 = [\"onLoad\", \"onError\", \"apiKey\", \"version\", \"libraries\"],\n  _excluded2$1 = [\"children\"];\nconst DEFAULT_SOLUTION_CHANNEL = 'GMP_visgl_rgmlibrary_v1_default';\nconst APIProviderContext = React.createContext(null);\n/**\n * local hook to set up the map-instance management context.\n */\nfunction useMapInstances() {\n  const [mapInstances, setMapInstances] = useState({});\n  const addMapInstance = (mapInstance, id = 'default') => {\n    setMapInstances(instances => _extends({}, instances, {\n      [id]: mapInstance\n    }));\n  };\n  const removeMapInstance = (id = 'default') => {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    setMapInstances(_ref => {\n      let remaining = _objectWithoutPropertiesLoose(_ref, [id].map(_toPropertyKey));\n      return remaining;\n    });\n  };\n  const clearMapInstances = () => {\n    setMapInstances({});\n  };\n  return {\n    mapInstances,\n    addMapInstance,\n    removeMapInstance,\n    clearMapInstances\n  };\n}\n/**\n * local hook to handle the loading of the maps API, returns the current loading status\n * @param props\n */\nfunction useGoogleMapsApiLoader(props) {\n  const {\n      onLoad,\n      onError,\n      apiKey,\n      version,\n      libraries = []\n    } = props,\n    otherApiParams = _objectWithoutPropertiesLoose(props, _excluded$3);\n  const [status, setStatus] = useState(GoogleMapsApiLoader.loadingStatus);\n  const [loadedLibraries, addLoadedLibrary] = useReducer((loadedLibraries, action) => {\n    return loadedLibraries[action.name] ? loadedLibraries : _extends({}, loadedLibraries, {\n      [action.name]: action.value\n    });\n  }, {});\n  const librariesString = useMemo(() => libraries == null ? void 0 : libraries.join(','), [libraries]);\n  const serializedParams = useMemo(() => JSON.stringify(_extends({\n    apiKey,\n    version\n  }, otherApiParams)), [apiKey, version, otherApiParams]);\n  const importLibrary = useCallback(async name => {\n    var _google;\n    if (loadedLibraries[name]) {\n      return loadedLibraries[name];\n    }\n    if (!((_google = google) != null && (_google = _google.maps) != null && _google.importLibrary)) {\n      throw new Error('[api-provider-internal] importLibrary was called before ' + 'google.maps.importLibrary was defined.');\n    }\n    const res = await window.google.maps.importLibrary(name);\n    addLoadedLibrary({\n      name,\n      value: res\n    });\n    return res;\n  }, [loadedLibraries]);\n  useEffect(() => {\n    (async () => {\n      try {\n        const params = _extends({\n          key: apiKey\n        }, otherApiParams);\n        if (version) params.v = version;\n        if ((librariesString == null ? void 0 : librariesString.length) > 0) params.libraries = librariesString;\n        if (params.channel === undefined || params.channel < 0 || params.channel > 999) delete params.channel;\n        if (params.solutionChannel === undefined) params.solutionChannel = DEFAULT_SOLUTION_CHANNEL;else if (params.solutionChannel === '') delete params.solutionChannel;\n        await GoogleMapsApiLoader.load(params, status => setStatus(status));\n        for (const name of ['core', 'maps', ...libraries]) {\n          await importLibrary(name);\n        }\n        if (onLoad) {\n          onLoad();\n        }\n      } catch (error) {\n        if (onError) {\n          onError(error);\n        } else {\n          console.error('<ApiProvider> failed to load the Google Maps JavaScript API', error);\n        }\n      }\n    })();\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [apiKey, librariesString, serializedParams]);\n  return {\n    status,\n    loadedLibraries,\n    importLibrary\n  };\n}\n/**\n * Component to wrap the components from this library and load the Google Maps JavaScript API\n */\nconst APIProvider = props => {\n  const {\n      children\n    } = props,\n    loaderProps = _objectWithoutPropertiesLoose(props, _excluded2$1);\n  const {\n    mapInstances,\n    addMapInstance,\n    removeMapInstance,\n    clearMapInstances\n  } = useMapInstances();\n  const {\n    status,\n    loadedLibraries,\n    importLibrary\n  } = useGoogleMapsApiLoader(loaderProps);\n  const contextValue = useMemo(() => ({\n    mapInstances,\n    addMapInstance,\n    removeMapInstance,\n    clearMapInstances,\n    status,\n    loadedLibraries,\n    importLibrary\n  }), [mapInstances, addMapInstance, removeMapInstance, clearMapInstances, status, loadedLibraries, importLibrary]);\n  return /*#__PURE__*/React.createElement(APIProviderContext.Provider, {\n    value: contextValue\n  }, children);\n};\n\n/**\n * Sets up effects to bind event-handlers for all event-props in MapEventProps.\n * @internal\n */\nfunction useMapEvents(map, props) {\n  // note: calling a useEffect hook from within a loop is prohibited by the\n  // rules of hooks, but it's ok here since it's unconditional and the number\n  // and order of iterations is always strictly the same.\n  // (see https://legacy.reactjs.org/docs/hooks-rules.html)\n  for (const propName of eventPropNames) {\n    // fixme: this cast is essentially a 'trust me, bro' for typescript, but\n    //   a proper solution seems way too complicated right now\n    const handler = props[propName];\n    const eventType = propNameToEventType[propName];\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEffect(() => {\n      if (!map) return;\n      if (!handler) return;\n      const listener = google.maps.event.addListener(map, eventType, ev => {\n        handler(createMapEvent(eventType, map, ev));\n      });\n      return () => listener.remove();\n    }, [map, eventType, handler]);\n  }\n}\n/**\n * Create the wrapped map-events used for the event-props.\n * @param type the event type as it is specified to the maps api\n * @param map the map instance the event originates from\n * @param srcEvent the source-event if there is one.\n */\nfunction createMapEvent(type, map, srcEvent) {\n  const ev = {\n    type,\n    map,\n    detail: {},\n    stoppable: false,\n    stop: () => {}\n  };\n  if (cameraEventTypes.includes(type)) {\n    const camEvent = ev;\n    const center = map.getCenter();\n    const zoom = map.getZoom();\n    const heading = map.getHeading() || 0;\n    const tilt = map.getTilt() || 0;\n    const bounds = map.getBounds();\n    if (!center || !bounds || !Number.isFinite(zoom)) {\n      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');\n    }\n    camEvent.detail = {\n      center: (center == null ? void 0 : center.toJSON()) || {\n        lat: 0,\n        lng: 0\n      },\n      zoom: zoom || 0,\n      heading: heading,\n      tilt: tilt,\n      bounds: (bounds == null ? void 0 : bounds.toJSON()) || {\n        north: 90,\n        east: 180,\n        south: -90,\n        west: -180\n      }\n    };\n    return camEvent;\n  } else if (mouseEventTypes.includes(type)) {\n    var _srcEvent$latLng;\n    if (!srcEvent) throw new Error('[createEvent] mouse events must provide a srcEvent');\n    const mouseEvent = ev;\n    mouseEvent.domEvent = srcEvent.domEvent;\n    mouseEvent.stoppable = true;\n    mouseEvent.stop = () => srcEvent.stop();\n    mouseEvent.detail = {\n      latLng: ((_srcEvent$latLng = srcEvent.latLng) == null ? void 0 : _srcEvent$latLng.toJSON()) || null,\n      placeId: srcEvent.placeId\n    };\n    return mouseEvent;\n  }\n  return ev;\n}\n/**\n * maps the camelCased names of event-props to the corresponding event-types\n * used in the maps API.\n */\nconst propNameToEventType = {\n  onBoundsChanged: 'bounds_changed',\n  onCenterChanged: 'center_changed',\n  onClick: 'click',\n  onContextmenu: 'contextmenu',\n  onDblclick: 'dblclick',\n  onDrag: 'drag',\n  onDragend: 'dragend',\n  onDragstart: 'dragstart',\n  onHeadingChanged: 'heading_changed',\n  onIdle: 'idle',\n  onIsFractionalZoomEnabledChanged: 'isfractionalzoomenabled_changed',\n  onMapCapabilitiesChanged: 'mapcapabilities_changed',\n  onMapTypeIdChanged: 'maptypeid_changed',\n  onMousemove: 'mousemove',\n  onMouseout: 'mouseout',\n  onMouseover: 'mouseover',\n  onProjectionChanged: 'projection_changed',\n  onRenderingTypeChanged: 'renderingtype_changed',\n  onTilesLoaded: 'tilesloaded',\n  onTiltChanged: 'tilt_changed',\n  onZoomChanged: 'zoom_changed',\n  // note: onCameraChanged is an alias for the bounds_changed event,\n  // since that is going to be fired in every situation where the camera is\n  // updated.\n  onCameraChanged: 'bounds_changed'\n};\nconst cameraEventTypes = ['bounds_changed', 'center_changed', 'heading_changed', 'tilt_changed', 'zoom_changed'];\nconst mouseEventTypes = ['click', 'contextmenu', 'dblclick', 'mousemove', 'mouseout', 'mouseover'];\nconst eventPropNames = Object.keys(propNameToEventType);\n\nfunction useDeepCompareEffect(effect, deps) {\n  const ref = useRef(undefined);\n  if (!ref.current || !isDeepEqual(deps, ref.current)) {\n    ref.current = deps;\n  }\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  useEffect(effect, ref.current);\n}\n\nconst mapOptionKeys = 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']);\n/**\n * Internal hook to update the map-options when props are changed.\n *\n * @param map the map instance\n * @param mapProps the props to update the map-instance with\n * @internal\n */\nfunction useMapOptions(map, mapProps) {\n  /* eslint-disable react-hooks/exhaustive-deps --\n   *\n   * The following effects aren't triggered when the map is changed.\n   * In that case, the values will be or have been passed to the map\n   * constructor via mapOptions.\n   */\n  const mapOptions = {};\n  const keys = Object.keys(mapProps);\n  for (const key of keys) {\n    if (!mapOptionKeys.has(key)) continue;\n    mapOptions[key] = mapProps[key];\n  }\n  // update the map options when mapOptions is changed\n  // Note: due to the destructuring above, mapOptions will be seen as changed\n  //   with every re-render, so we're assuming the maps-api will properly\n  //   deal with unchanged option-values passed into setOptions.\n  useDeepCompareEffect(() => {\n    if (!map) return;\n    map.setOptions(mapOptions);\n  }, [mapOptions]);\n  /* eslint-enable react-hooks/exhaustive-deps */\n}\n\nfunction useApiLoadingStatus() {\n  var _useContext;\n  return ((_useContext = useContext(APIProviderContext)) == null ? void 0 : _useContext.status) || APILoadingStatus.NOT_LOADED;\n}\n\n/**\n * Internal hook that updates the camera when deck.gl viewState changes.\n * @internal\n */\nfunction useDeckGLCameraUpdate(map, props) {\n  const {\n    viewport,\n    viewState\n  } = props;\n  const isDeckGlControlled = !!viewport;\n  useLayoutEffect(() => {\n    if (!map || !viewState) return;\n    const {\n      latitude,\n      longitude,\n      bearing: heading,\n      pitch: tilt,\n      zoom\n    } = viewState;\n    map.moveCamera({\n      center: {\n        lat: latitude,\n        lng: longitude\n      },\n      heading,\n      tilt,\n      zoom: zoom + 1\n    });\n  }, [map, viewState]);\n  return isDeckGlControlled;\n}\n\nfunction isLatLngLiteral(obj) {\n  if (!obj || typeof obj !== 'object') return false;\n  if (!('lat' in obj && 'lng' in obj)) return false;\n  return Number.isFinite(obj.lat) && Number.isFinite(obj.lng);\n}\nfunction latLngEquals(a, b) {\n  if (!a || !b) return false;\n  const A = toLatLngLiteral(a);\n  const B = toLatLngLiteral(b);\n  if (A.lat !== B.lat || A.lng !== B.lng) return false;\n  return true;\n}\nfunction toLatLngLiteral(obj) {\n  if (isLatLngLiteral(obj)) return obj;\n  return obj.toJSON();\n}\n\nfunction useMapCameraParams(map, cameraStateRef, mapProps) {\n  const center = mapProps.center ? toLatLngLiteral(mapProps.center) : null;\n  let lat = null;\n  let lng = null;\n  if (center && Number.isFinite(center.lat) && Number.isFinite(center.lng)) {\n    lat = center.lat;\n    lng = center.lng;\n  }\n  const zoom = Number.isFinite(mapProps.zoom) ? mapProps.zoom : null;\n  const heading = Number.isFinite(mapProps.heading) ? mapProps.heading : null;\n  const tilt = Number.isFinite(mapProps.tilt) ? mapProps.tilt : null;\n  // the following effect runs for every render of the map component and checks\n  // if there are differences between the known state of the map instance\n  // (cameraStateRef, which is updated by all bounds_changed events) and the\n  // desired state in the props.\n  useLayoutEffect(() => {\n    if (!map) return;\n    const nextCamera = {};\n    let needsUpdate = false;\n    if (lat !== null && lng !== null && (cameraStateRef.current.center.lat !== lat || cameraStateRef.current.center.lng !== lng)) {\n      nextCamera.center = {\n        lat,\n        lng\n      };\n      needsUpdate = true;\n    }\n    if (zoom !== null && cameraStateRef.current.zoom !== zoom) {\n      nextCamera.zoom = zoom;\n      needsUpdate = true;\n    }\n    if (heading !== null && cameraStateRef.current.heading !== heading) {\n      nextCamera.heading = heading;\n      needsUpdate = true;\n    }\n    if (tilt !== null && cameraStateRef.current.tilt !== tilt) {\n      nextCamera.tilt = tilt;\n      needsUpdate = true;\n    }\n    if (needsUpdate) {\n      map.moveCamera(nextCamera);\n    }\n  });\n}\n\nconst AuthFailureMessage = () => {\n  const style = {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    bottom: 0,\n    right: 0,\n    zIndex: 999,\n    display: 'flex',\n    flexFlow: 'column nowrap',\n    textAlign: 'center',\n    justifyContent: 'center',\n    fontSize: '.8rem',\n    color: 'rgba(0,0,0,0.6)',\n    background: '#dddddd',\n    padding: '1rem 1.5rem'\n  };\n  return /*#__PURE__*/React.createElement(\"div\", {\n    style: style\n  }, /*#__PURE__*/React.createElement(\"h2\", null, \"Error: AuthFailure\"), /*#__PURE__*/React.createElement(\"p\", null, \"A problem with your API key prevents the map from rendering correctly. Please make sure the value of the \", /*#__PURE__*/React.createElement(\"code\", null, \"APIProvider.apiKey\"), \" prop is correct. Check the error-message in the console for further details.\"));\n};\n\nfunction useCallbackRef() {\n  const [el, setEl] = useState(null);\n  const ref = useCallback(value => setEl(value), [setEl]);\n  return [el, ref];\n}\n\n/**\n * Hook to check if the Maps JavaScript API is loaded\n */\nfunction useApiIsLoaded() {\n  const status = useApiLoadingStatus();\n  return status === APILoadingStatus.LOADED;\n}\n\nfunction useForceUpdate() {\n  const [, forceUpdate] = useReducer(x => x + 1, 0);\n  return forceUpdate;\n}\n\nfunction handleBoundsChange(map, ref) {\n  const center = map.getCenter();\n  const zoom = map.getZoom();\n  const heading = map.getHeading() || 0;\n  const tilt = map.getTilt() || 0;\n  const bounds = map.getBounds();\n  if (!center || !bounds || !Number.isFinite(zoom)) {\n    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');\n  }\n  // fixme: do we need the `undefined` cases for the camera-params? When are they used in the maps API?\n  Object.assign(ref.current, {\n    center: (center == null ? void 0 : center.toJSON()) || {\n      lat: 0,\n      lng: 0\n    },\n    zoom: zoom || 0,\n    heading: heading,\n    tilt: tilt\n  });\n}\n/**\n * Creates a mutable ref object to track the last known state of the map camera.\n * This is used in `useMapCameraParams` to reduce stuttering in normal operation\n * by avoiding updates of the map camera with values that have already been processed.\n */\nfunction useTrackedCameraStateRef(map) {\n  const forceUpdate = useForceUpdate();\n  const ref = useRef({\n    center: {\n      lat: 0,\n      lng: 0\n    },\n    heading: 0,\n    tilt: 0,\n    zoom: 0\n  });\n  // Record camera state with every bounds_changed event dispatched by the map.\n  // This data is used to prevent feeding these values back to the\n  // map-instance when a typical \"controlled component\" setup (state variable is\n  // fed into and updated by the map).\n  useEffect(() => {\n    if (!map) return;\n    const listener = google.maps.event.addListener(map, 'bounds_changed', () => {\n      handleBoundsChange(map, ref);\n      // When an event is occured, we have to update during the next cycle.\n      // The application could decide to ignore the event and not update any\n      // camera props of the map, meaning that in that case we will have to\n      // 'undo' the change to the camera.\n      forceUpdate();\n    });\n    return () => listener.remove();\n  }, [map, forceUpdate]);\n  return ref;\n}\n\nconst _excluded$2 = [\"id\", \"defaultBounds\", \"defaultCenter\", \"defaultZoom\", \"defaultHeading\", \"defaultTilt\", \"reuseMaps\", \"renderingType\", \"colorScheme\"],\n  _excluded2 = [\"padding\"];\n/**\n * Stores a stack of map-instances for each mapId. Whenever an\n * instance is used, it is removed from the stack while in use,\n * and returned to the stack when the component unmounts.\n * This allows us to correctly implement caching for multiple\n * maps om the same page, while reusing as much as possible.\n *\n * FIXME: while it should in theory be possible to reuse maps solely\n *   based on the mapId (as all other parameters can be changed at\n *   runtime), we don't yet have good enough tracking of options to\n *   reliably unset all the options that have been set.\n */\nclass CachedMapStack {\n  static has(key) {\n    return this.entries[key] && this.entries[key].length > 0;\n  }\n  static pop(key) {\n    if (!this.entries[key]) return null;\n    return this.entries[key].pop() || null;\n  }\n  static push(key, value) {\n    if (!this.entries[key]) this.entries[key] = [];\n    this.entries[key].push(value);\n  }\n}\n/**\n * The main hook takes care of creating map-instances and registering them in\n * the api-provider context.\n * @return a tuple of the map-instance created (or null) and the callback\n *   ref that will be used to pass the map-container into this hook.\n * @internal\n */\nCachedMapStack.entries = {};\nfunction useMapInstance(props, context) {\n  const apiIsLoaded = useApiIsLoaded();\n  const [map, setMap] = useState(null);\n  const [container, containerRef] = useCallbackRef();\n  const cameraStateRef = useTrackedCameraStateRef(map);\n  const {\n      id,\n      defaultBounds,\n      defaultCenter,\n      defaultZoom,\n      defaultHeading,\n      defaultTilt,\n      reuseMaps,\n      renderingType,\n      colorScheme\n    } = props,\n    mapOptions = _objectWithoutPropertiesLoose(props, _excluded$2);\n  const hasZoom = props.zoom !== undefined || props.defaultZoom !== undefined;\n  const hasCenter = props.center !== undefined || props.defaultCenter !== undefined;\n  if (!defaultBounds && (!hasZoom || !hasCenter)) {\n    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');\n  }\n  // apply default camera props if available and not overwritten by controlled props\n  if (!mapOptions.center && defaultCenter) mapOptions.center = defaultCenter;\n  if (!mapOptions.zoom && Number.isFinite(defaultZoom)) mapOptions.zoom = defaultZoom;\n  if (!mapOptions.heading && Number.isFinite(defaultHeading)) mapOptions.heading = defaultHeading;\n  if (!mapOptions.tilt && Number.isFinite(defaultTilt)) mapOptions.tilt = defaultTilt;\n  for (const key of Object.keys(mapOptions)) if (mapOptions[key] === undefined) delete mapOptions[key];\n  const savedMapStateRef = useRef();\n  // create the map instance and register it in the context\n  useEffect(() => {\n    if (!container || !apiIsLoaded) return;\n    const {\n      addMapInstance,\n      removeMapInstance\n    } = context;\n    // note: colorScheme (upcoming feature) isn't yet in the typings, remove once that is fixed:\n    const {\n      mapId\n    } = props;\n    const cacheKey = `${mapId || 'default'}:${renderingType || 'default'}:${colorScheme || 'LIGHT'}`;\n    let mapDiv;\n    let map;\n    if (reuseMaps && CachedMapStack.has(cacheKey)) {\n      map = CachedMapStack.pop(cacheKey);\n      mapDiv = map.getDiv();\n      container.appendChild(mapDiv);\n      map.setOptions(mapOptions);\n      // detaching the element from the DOM lets the map fall back to its default\n      // size, setting the center will trigger reloading the map.\n      setTimeout(() => map.setCenter(map.getCenter()), 0);\n    } else {\n      mapDiv = document.createElement('div');\n      mapDiv.style.height = '100%';\n      container.appendChild(mapDiv);\n      map = new google.maps.Map(mapDiv, _extends({}, mapOptions, renderingType ? {\n        renderingType: renderingType\n      } : {}, colorScheme ? {\n        colorScheme: colorScheme\n      } : {}));\n    }\n    setMap(map);\n    addMapInstance(map, id);\n    if (defaultBounds) {\n      const {\n          padding\n        } = defaultBounds,\n        defBounds = _objectWithoutPropertiesLoose(defaultBounds, _excluded2);\n      map.fitBounds(defBounds, padding);\n    }\n    // prevent map not rendering due to missing configuration\n    else if (!hasZoom || !hasCenter) {\n      map.fitBounds({\n        east: 180,\n        west: -180,\n        south: -90,\n        north: 90\n      });\n    }\n    // the savedMapState is used to restore the camera parameters when the mapId is changed\n    if (savedMapStateRef.current) {\n      const {\n        mapId: savedMapId,\n        cameraState: savedCameraState\n      } = savedMapStateRef.current;\n      if (savedMapId !== mapId) {\n        map.setOptions(savedCameraState);\n      }\n    }\n    return () => {\n      savedMapStateRef.current = {\n        mapId,\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        cameraState: cameraStateRef.current\n      };\n      // detach the map-div from the dom\n      mapDiv.remove();\n      if (reuseMaps) {\n        // push back on the stack\n        CachedMapStack.push(cacheKey, map);\n      } else {\n        // remove all event-listeners to minimize the possibility of memory-leaks\n        google.maps.event.clearInstanceListeners(map);\n      }\n      setMap(null);\n      removeMapInstance(id);\n    };\n  },\n  // some dependencies are ignored in the list below:\n  //  - defaultBounds and the default* camera props will only be used once, and\n  //    changes should be ignored\n  //  - mapOptions has special hooks that take care of updating the options\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [container, apiIsLoaded, id,\n  // these props can't be changed after initialization and require a new\n  // instance to be created\n  props.mapId, props.renderingType, props.colorScheme]);\n  return [map, containerRef, cameraStateRef];\n}\n\nconst GoogleMapsContext = React.createContext(null);\n// ColorScheme and RenderingType are redefined here to make them usable before the\n// maps API has been fully loaded.\nconst ColorScheme = {\n  DARK: 'DARK',\n  LIGHT: 'LIGHT',\n  FOLLOW_SYSTEM: 'FOLLOW_SYSTEM'\n};\nconst RenderingType = {\n  VECTOR: 'VECTOR',\n  RASTER: 'RASTER',\n  UNINITIALIZED: 'UNINITIALIZED'\n};\nconst Map = props => {\n  const {\n    children,\n    id,\n    className,\n    style\n  } = props;\n  const context = useContext(APIProviderContext);\n  const loadingStatus = useApiLoadingStatus();\n  if (!context) {\n    throw new Error('<Map> can only be used inside an <ApiProvider> component.');\n  }\n  const [map, mapRef, cameraStateRef] = useMapInstance(props, context);\n  useMapCameraParams(map, cameraStateRef, props);\n  useMapEvents(map, props);\n  useMapOptions(map, props);\n  const isDeckGlControlled = useDeckGLCameraUpdate(map, props);\n  const isControlledExternally = !!props.controlled;\n  // disable interactions with the map for externally controlled maps\n  useEffect(() => {\n    if (!map) return;\n    // fixme: this doesn't seem to belong here (and it's mostly there for convenience anyway).\n    //   The reasoning is that a deck.gl canvas will be put on top of the map, rendering\n    //   any default map controls pretty much useless\n    if (isDeckGlControlled) {\n      map.setOptions({\n        disableDefaultUI: true\n      });\n    }\n    // disable all control-inputs when the map is controlled externally\n    if (isDeckGlControlled || isControlledExternally) {\n      map.setOptions({\n        gestureHandling: 'none',\n        keyboardShortcuts: false\n      });\n    }\n    return () => {\n      map.setOptions({\n        gestureHandling: props.gestureHandling,\n        keyboardShortcuts: props.keyboardShortcuts\n      });\n    };\n  }, [map, isDeckGlControlled, isControlledExternally, props.gestureHandling, props.keyboardShortcuts]);\n  // setup a stable cameraOptions object that can be used as dependency\n  const center = props.center ? toLatLngLiteral(props.center) : null;\n  let lat = null;\n  let lng = null;\n  if (center && Number.isFinite(center.lat) && Number.isFinite(center.lng)) {\n    lat = center.lat;\n    lng = center.lng;\n  }\n  const cameraOptions = useMemo(() => {\n    var _lat, _lng, _props$zoom, _props$heading, _props$tilt;\n    return {\n      center: {\n        lat: (_lat = lat) != null ? _lat : 0,\n        lng: (_lng = lng) != null ? _lng : 0\n      },\n      zoom: (_props$zoom = props.zoom) != null ? _props$zoom : 0,\n      heading: (_props$heading = props.heading) != null ? _props$heading : 0,\n      tilt: (_props$tilt = props.tilt) != null ? _props$tilt : 0\n    };\n  }, [lat, lng, props.zoom, props.heading, props.tilt]);\n  // externally controlled mode: reject all camera changes that don't correspond to changes in props\n  useLayoutEffect(() => {\n    if (!map || !isControlledExternally) return;\n    map.moveCamera(cameraOptions);\n    const listener = map.addListener('bounds_changed', () => {\n      map.moveCamera(cameraOptions);\n    });\n    return () => listener.remove();\n  }, [map, isControlledExternally, cameraOptions]);\n  const combinedStyle = useMemo(() => _extends({\n    width: '100%',\n    height: '100%',\n    position: 'relative',\n    // when using deckgl, the map should be sent to the back\n    zIndex: isDeckGlControlled ? -1 : 0\n  }, style), [style, isDeckGlControlled]);\n  const contextValue = useMemo(() => ({\n    map\n  }), [map]);\n  if (loadingStatus === APILoadingStatus.AUTH_FAILURE) {\n    return /*#__PURE__*/React.createElement(\"div\", {\n      style: _extends({\n        position: 'relative'\n      }, className ? {} : combinedStyle),\n      className: className\n    }, /*#__PURE__*/React.createElement(AuthFailureMessage, null));\n  }\n  return /*#__PURE__*/React.createElement(\"div\", _extends({\n    ref: mapRef,\n    \"data-testid\": 'map',\n    style: className ? undefined : combinedStyle,\n    className: className\n  }, id ? {\n    id\n  } : {}), map ? /*#__PURE__*/React.createElement(GoogleMapsContext.Provider, {\n    value: contextValue\n  }, children) : null);\n};\n// The deckGLViewProps flag here indicates to deck.gl that the Map component is\n// able to handle viewProps from deck.gl when deck.gl is used to control the map.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMap.deckGLViewProps = true;\n\nconst shownMessages = new Set();\nfunction logErrorOnce(...args) {\n  const key = JSON.stringify(args);\n  if (!shownMessages.has(key)) {\n    shownMessages.add(key);\n    console.error(...args);\n  }\n}\n\n/**\n * Retrieves a map-instance from the context. This is either an instance\n * identified by id or the parent map instance if no id is specified.\n * Returns null if neither can be found.\n */\nconst useMap = (id = null) => {\n  const ctx = useContext(APIProviderContext);\n  const {\n    map\n  } = useContext(GoogleMapsContext) || {};\n  if (ctx === null) {\n    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>.');\n    return null;\n  }\n  const {\n    mapInstances\n  } = ctx;\n  // if an id is specified, the corresponding map or null is returned\n  if (id !== null) return mapInstances[id] || null;\n  // otherwise, return the closest ancestor\n  if (map) return map;\n  // finally, return the default map instance\n  return mapInstances['default'] || null;\n};\n\nfunction useMapsLibrary(name) {\n  const apiIsLoaded = useApiIsLoaded();\n  const ctx = useContext(APIProviderContext);\n  useEffect(() => {\n    if (!apiIsLoaded || !ctx) return;\n    // Trigger loading the libraries via our proxy-method.\n    // The returned promise is ignored, since importLibrary will update loadedLibraries\n    // list in the context, triggering a re-render.\n    void ctx.importLibrary(name);\n  }, [apiIsLoaded, ctx, name]);\n  return (ctx == null ? void 0 : ctx.loadedLibraries[name]) || null;\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/**\n * Internally used to bind events to Maps JavaScript API objects.\n * @internal\n */\nfunction useMapsEventListener(target, name, callback) {\n  useEffect(() => {\n    if (!target || !name || !callback) return;\n    const listener = google.maps.event.addListener(target, name, callback);\n    return () => listener.remove();\n  }, [target, name, callback]);\n}\n\n/**\n * Internally used to copy values from props into API-Objects\n * whenever they change.\n *\n * @example\n *   usePropBinding(marker, 'position', position);\n *\n * @internal\n */\nfunction usePropBinding(object, prop, value) {\n  useEffect(() => {\n    if (!object) return;\n    object[prop] = value;\n  }, [object, prop, value]);\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/**\n * Internally used to bind events to DOM nodes.\n * @internal\n */\nfunction useDomEventListener(target, name, callback) {\n  useEffect(() => {\n    if (!target || !name || !callback) return;\n    target.addEventListener(name, callback);\n    return () => target.removeEventListener(name, callback);\n  }, [target, name, callback]);\n}\n\n/* eslint-disable complexity */\nfunction isAdvancedMarker(marker) {\n  return marker.content !== undefined;\n}\nfunction isElementNode(node) {\n  return node.nodeType === Node.ELEMENT_NODE;\n}\n/**\n * Copy of the `google.maps.CollisionBehavior` constants.\n * They have to be duplicated here since we can't wait for the maps API to load to be able to use them.\n */\nconst CollisionBehavior = {\n  REQUIRED: 'REQUIRED',\n  REQUIRED_AND_HIDES_OPTIONAL: 'REQUIRED_AND_HIDES_OPTIONAL',\n  OPTIONAL_AND_HIDES_LOWER_PRIORITY: 'OPTIONAL_AND_HIDES_LOWER_PRIORITY'\n};\nconst AdvancedMarkerContext = React.createContext(null);\n// [xPosition, yPosition] when the top left corner is [0, 0]\nconst AdvancedMarkerAnchorPoint = {\n  TOP_LEFT: ['0%', '0%'],\n  TOP_CENTER: ['50%', '0%'],\n  TOP: ['50%', '0%'],\n  TOP_RIGHT: ['100%', '0%'],\n  LEFT_CENTER: ['0%', '50%'],\n  LEFT_TOP: ['0%', '0%'],\n  LEFT: ['0%', '50%'],\n  LEFT_BOTTOM: ['0%', '100%'],\n  RIGHT_TOP: ['100%', '0%'],\n  RIGHT: ['100%', '50%'],\n  RIGHT_CENTER: ['100%', '50%'],\n  RIGHT_BOTTOM: ['100%', '100%'],\n  BOTTOM_LEFT: ['0%', '100%'],\n  BOTTOM_CENTER: ['50%', '100%'],\n  BOTTOM: ['50%', '100%'],\n  BOTTOM_RIGHT: ['100%', '100%'],\n  CENTER: ['50%', '50%']\n};\nconst MarkerContent = ({\n  children,\n  styles,\n  className,\n  anchorPoint\n}) => {\n  const [xTranslation, yTranslation] = anchorPoint != null ? anchorPoint : AdvancedMarkerAnchorPoint['BOTTOM'];\n  // The \"translate(50%, 100%)\" is here to counter and reset the default anchoring of the advanced marker element\n  // that comes from the api\n  const transformStyle = `translate(50%, 100%) translate(-${xTranslation}, -${yTranslation})`;\n  return (\n    /*#__PURE__*/\n    // anchoring container\n    React.createElement(\"div\", {\n      style: {\n        transform: transformStyle\n      }\n    }, /*#__PURE__*/React.createElement(\"div\", {\n      className: className,\n      style: styles\n    }, children))\n  );\n};\nfunction useAdvancedMarker(props) {\n  const [marker, setMarker] = useState(null);\n  const [contentContainer, setContentContainer] = useState(null);\n  const map = useMap();\n  const markerLibrary = useMapsLibrary('marker');\n  const {\n    children,\n    onClick,\n    className,\n    onMouseEnter,\n    onMouseLeave,\n    onDrag,\n    onDragStart,\n    onDragEnd,\n    collisionBehavior,\n    clickable,\n    draggable,\n    position,\n    title,\n    zIndex\n  } = props;\n  const numChildren = Children.count(children);\n  // create an AdvancedMarkerElement instance and add it to the map once available\n  useEffect(() => {\n    if (!map || !markerLibrary) return;\n    const newMarker = new markerLibrary.AdvancedMarkerElement();\n    newMarker.map = map;\n    setMarker(newMarker);\n    // create the container for marker content if there are children\n    let contentElement = null;\n    if (numChildren > 0) {\n      contentElement = document.createElement('div');\n      // We need some kind of flag to identify the custom marker content\n      // in the infowindow component. Choosing a custom property instead of a className\n      // to not encourage users to style the marker content directly.\n      contentElement.isCustomMarker = true;\n      newMarker.content = contentElement;\n      setContentContainer(contentElement);\n    }\n    return () => {\n      var _contentElement;\n      newMarker.map = null;\n      (_contentElement = contentElement) == null || _contentElement.remove();\n      setMarker(null);\n      setContentContainer(null);\n    };\n  }, [map, markerLibrary, numChildren]);\n  // When no children are present we don't have our own wrapper div\n  // which usually gets the user provided className. In this case\n  // we set the className directly on the marker.content element that comes\n  // with the AdvancedMarker.\n  useEffect(() => {\n    if (!marker || !marker.content || numChildren > 0) return;\n    marker.content.className = className || '';\n  }, [marker, className, numChildren]);\n  // copy other props\n  usePropBinding(marker, 'position', position);\n  usePropBinding(marker, 'title', title != null ? title : '');\n  usePropBinding(marker, 'zIndex', zIndex);\n  usePropBinding(marker, 'collisionBehavior', collisionBehavior);\n  // set gmpDraggable from props (when unspecified, it's true if any drag-event\n  // callbacks are specified)\n  useEffect(() => {\n    if (!marker) return;\n    if (draggable !== undefined) marker.gmpDraggable = draggable;else if (onDrag || onDragStart || onDragEnd) marker.gmpDraggable = true;else marker.gmpDraggable = false;\n  }, [marker, draggable, onDrag, onDragEnd, onDragStart]);\n  // set gmpClickable from props (when unspecified, it's true if the onClick or one of\n  // the hover events callbacks are specified)\n  useEffect(() => {\n    if (!marker) return;\n    const gmpClickable = clickable !== undefined || Boolean(onClick) || Boolean(onMouseEnter) || Boolean(onMouseLeave);\n    // gmpClickable is only available in beta version of the\n    // maps api (as of 2024-10-10)\n    marker.gmpClickable = gmpClickable;\n    // enable pointer events for the markers with custom content\n    if (gmpClickable && marker != null && marker.content && isElementNode(marker.content)) {\n      marker.content.style.pointerEvents = 'none';\n      if (marker.content.firstElementChild) {\n        marker.content.firstElementChild.style.pointerEvents = 'all';\n      }\n    }\n  }, [marker, clickable, onClick, onMouseEnter, onMouseLeave]);\n  useMapsEventListener(marker, 'click', onClick);\n  useMapsEventListener(marker, 'drag', onDrag);\n  useMapsEventListener(marker, 'dragstart', onDragStart);\n  useMapsEventListener(marker, 'dragend', onDragEnd);\n  useDomEventListener(marker == null ? void 0 : marker.element, 'mouseenter', onMouseEnter);\n  useDomEventListener(marker == null ? void 0 : marker.element, 'mouseleave', onMouseLeave);\n  return [marker, contentContainer];\n}\nconst AdvancedMarker = forwardRef((props, ref) => {\n  const {\n    children,\n    style,\n    className,\n    anchorPoint\n  } = props;\n  const [marker, contentContainer] = useAdvancedMarker(props);\n  const advancedMarkerContextValue = useMemo(() => marker ? {\n    marker\n  } : null, [marker]);\n  useImperativeHandle(ref, () => marker, [marker]);\n  if (!contentContainer) return null;\n  return /*#__PURE__*/React.createElement(AdvancedMarkerContext.Provider, {\n    value: advancedMarkerContextValue\n  }, createPortal(/*#__PURE__*/React.createElement(MarkerContent, {\n    anchorPoint: anchorPoint,\n    styles: style,\n    className: className\n  }, children), contentContainer));\n});\nfunction useAdvancedMarkerRef() {\n  const [marker, setMarker] = useState(null);\n  const refCallback = useCallback(m => {\n    setMarker(m);\n  }, []);\n  return [refCallback, marker];\n}\n\nfunction setValueForStyles(element, styles, prevStyles) {\n  if (styles != null && typeof styles !== 'object') {\n    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.');\n  }\n  const elementStyle = element.style;\n  // without `prevStyles`, just set all values\n  if (prevStyles == null) {\n    if (styles == null) return;\n    for (const styleName in styles) {\n      if (!styles.hasOwnProperty(styleName)) continue;\n      setValueForStyle(elementStyle, styleName, styles[styleName]);\n    }\n    return;\n  }\n  // unset all styles in `prevStyles` that aren't in `styles`\n  for (const styleName in prevStyles) {\n    if (prevStyles.hasOwnProperty(styleName) && (styles == null || !styles.hasOwnProperty(styleName))) {\n      // Clear style\n      const isCustomProperty = styleName.indexOf('--') === 0;\n      if (isCustomProperty) {\n        elementStyle.setProperty(styleName, '');\n      } else if (styleName === 'float') {\n        elementStyle.cssFloat = '';\n      } else {\n        elementStyle[styleName] = '';\n      }\n    }\n  }\n  // only assign values from `styles` that are different from `prevStyles`\n  if (styles == null) return;\n  for (const styleName in styles) {\n    const value = styles[styleName];\n    if (styles.hasOwnProperty(styleName) && prevStyles[styleName] !== value) {\n      setValueForStyle(elementStyle, styleName, value);\n    }\n  }\n}\nfunction setValueForStyle(elementStyle, styleName, value) {\n  const isCustomProperty = styleName.indexOf('--') === 0;\n  // falsy values will unset the style property\n  if (value == null || typeof value === 'boolean' || value === '') {\n    if (isCustomProperty) {\n      elementStyle.setProperty(styleName, '');\n    } else if (styleName === 'float') {\n      elementStyle.cssFloat = '';\n    } else {\n      elementStyle[styleName] = '';\n    }\n  }\n  // custom properties can't be directly assigned\n  else if (isCustomProperty) {\n    elementStyle.setProperty(styleName, value);\n  }\n  // numeric values are treated as 'px' unless the style property expects unitless numbers\n  else if (typeof value === 'number' && value !== 0 && !isUnitlessNumber(styleName)) {\n    elementStyle[styleName] = value + 'px'; // Presumes implicit 'px' suffix for unitless numbers\n  }\n  // everything else can just be assigned\n  else {\n    if (styleName === 'float') {\n      elementStyle.cssFloat = value;\n    } else {\n      elementStyle[styleName] = ('' + value).trim();\n    }\n  }\n}\n// CSS properties which accept numbers but are not in units of \"px\".\nconst unitlessNumbers = 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',\n// SVG-related properties\n'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth']);\nfunction isUnitlessNumber(name) {\n  return unitlessNumbers.has(name);\n}\n\nconst _excluded$1 = [\"children\", \"headerContent\", \"style\", \"className\", \"pixelOffset\", \"anchor\", \"shouldFocus\", \"onClose\", \"onCloseClick\"];\n/**\n * Component to render an Info Window with the Maps JavaScript API\n */\nconst InfoWindow = props => {\n  const {\n      // content options\n      children,\n      headerContent,\n      style,\n      className,\n      pixelOffset,\n      // open options\n      anchor,\n      shouldFocus,\n      // events\n      onClose,\n      onCloseClick\n      // other options\n    } = props,\n    infoWindowOptions = _objectWithoutPropertiesLoose(props, _excluded$1);\n  // ## create infowindow instance once the mapsLibrary is available.\n  const mapsLibrary = useMapsLibrary('maps');\n  const [infoWindow, setInfoWindow] = useState(null);\n  const contentContainerRef = useRef(null);\n  const headerContainerRef = useRef(null);\n  useEffect(() => {\n    if (!mapsLibrary) return;\n    contentContainerRef.current = document.createElement('div');\n    headerContainerRef.current = document.createElement('div');\n    const opts = infoWindowOptions;\n    if (pixelOffset) {\n      opts.pixelOffset = new google.maps.Size(pixelOffset[0], pixelOffset[1]);\n    }\n    if (headerContent) {\n      // if headerContent is specified as string we can directly forward it,\n      // otherwise we'll pass the element the portal will render into\n      opts.headerContent = typeof headerContent === 'string' ? headerContent : headerContainerRef.current;\n    }\n    // intentionally shadowing the state variables here\n    const infoWindow = new google.maps.InfoWindow(infoWindowOptions);\n    infoWindow.setContent(contentContainerRef.current);\n    setInfoWindow(infoWindow);\n    // unmount: remove infoWindow and content elements (note: close is called in a different effect-cleanup)\n    return () => {\n      var _contentContainerRef$, _headerContainerRef$c;\n      infoWindow.setContent(null);\n      (_contentContainerRef$ = contentContainerRef.current) == null || _contentContainerRef$.remove();\n      (_headerContainerRef$c = headerContainerRef.current) == null || _headerContainerRef$c.remove();\n      contentContainerRef.current = null;\n      headerContainerRef.current = null;\n      setInfoWindow(null);\n    };\n  },\n  // `infoWindowOptions` and other props are missing from dependencies:\n  //\n  // We don't want to re-create the infowindow instance\n  // when the options change.\n  // Updating the options is handled in the useEffect below.\n  //\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [mapsLibrary]);\n  // ## update className and styles for `contentContainer`\n  // stores previously applied style properties, so they can be removed when unset\n  const prevStyleRef = useRef(null);\n  useEffect(() => {\n    if (!infoWindow || !contentContainerRef.current) return;\n    setValueForStyles(contentContainerRef.current, style || null, prevStyleRef.current);\n    prevStyleRef.current = style || null;\n    if (className !== contentContainerRef.current.className) contentContainerRef.current.className = className || '';\n  }, [infoWindow, className, style]);\n  // ## update options\n  useDeepCompareEffect(() => {\n    if (!infoWindow) return;\n    const opts = infoWindowOptions;\n    if (!pixelOffset) {\n      opts.pixelOffset = null;\n    } else {\n      opts.pixelOffset = new google.maps.Size(pixelOffset[0], pixelOffset[1]);\n    }\n    if (!headerContent) {\n      opts.headerContent = null;\n    } else {\n      opts.headerContent = typeof headerContent === 'string' ? headerContent : headerContainerRef.current;\n    }\n    infoWindow.setOptions(infoWindowOptions);\n  },\n  // dependency `infoWindow` isn't needed since options are also passed\n  // to the constructor when a new infoWindow is created.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [infoWindowOptions, pixelOffset, headerContent]);\n  // ## bind event handlers\n  useMapsEventListener(infoWindow, 'close', onClose);\n  useMapsEventListener(infoWindow, 'closeclick', onCloseClick);\n  // ## open info window when content and map are available\n  const map = useMap();\n  useEffect(() => {\n    // `anchor === null` means an anchor is defined but not ready yet.\n    if (!map || !infoWindow || anchor === null) return;\n    const isOpenedWithAnchor = !!anchor;\n    const openOptions = {\n      map\n    };\n    if (anchor) {\n      openOptions.anchor = anchor;\n      // Only do the infowindow adjusting when dealing with an AdvancedMarker\n      if (isAdvancedMarker(anchor) && anchor.content instanceof Element) {\n        const wrapper = anchor.content;\n        const wrapperBcr = wrapper == null ? void 0 : wrapper.getBoundingClientRect();\n        // This checks whether or not the anchor has custom content with our own\n        // div wrapper. If not, that means we have a regular AdvancedMarker without any children.\n        // In that case we do not want to adjust the infowindow since it is all handled correctly\n        // by the Google Maps API.\n        if (wrapperBcr && wrapper != null && wrapper.isCustomMarker) {\n          var _anchor$content$first;\n          // We can safely typecast here since we control that element and we know that\n          // it is a div\n          const anchorDomContent = (_anchor$content$first = anchor.content.firstElementChild) == null ? void 0 : _anchor$content$first.firstElementChild;\n          const contentBcr = anchorDomContent == null ? void 0 : anchorDomContent.getBoundingClientRect();\n          // center infowindow above marker\n          const anchorOffsetX = contentBcr.x - wrapperBcr.x + (contentBcr.width - wrapperBcr.width) / 2;\n          const anchorOffsetY = contentBcr.y - wrapperBcr.y;\n          const opts = infoWindowOptions;\n          opts.pixelOffset = new google.maps.Size(pixelOffset ? pixelOffset[0] + anchorOffsetX : anchorOffsetX, pixelOffset ? pixelOffset[1] + anchorOffsetY : anchorOffsetY);\n          infoWindow.setOptions(opts);\n        }\n      }\n    }\n    if (shouldFocus !== undefined) {\n      openOptions.shouldFocus = shouldFocus;\n    }\n    infoWindow.open(openOptions);\n    return () => {\n      // Note: when the infowindow has an anchor, it will automatically show up again when the\n      // anchor was removed from the map before infoWindow.close() is called but the it gets\n      // added back to the map after that.\n      // More information here: https://issuetracker.google.com/issues/343750849\n      if (isOpenedWithAnchor) infoWindow.set('anchor', null);\n      infoWindow.close();\n    };\n  }, [infoWindow, anchor, map, shouldFocus, infoWindowOptions, pixelOffset]);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, contentContainerRef.current && createPortal(children, contentContainerRef.current), headerContainerRef.current !== null && createPortal(headerContent, headerContainerRef.current));\n};\n\n/**\n * Copy of the `google.maps.ControlPosition` constants.\n * They have to be duplicated here since we can't wait for the maps API to load to be able to use them.\n */\nconst ControlPosition = {\n  TOP_LEFT: 1,\n  TOP_CENTER: 2,\n  TOP: 2,\n  TOP_RIGHT: 3,\n  LEFT_CENTER: 4,\n  LEFT_TOP: 5,\n  LEFT: 5,\n  LEFT_BOTTOM: 6,\n  RIGHT_TOP: 7,\n  RIGHT: 7,\n  RIGHT_CENTER: 8,\n  RIGHT_BOTTOM: 9,\n  BOTTOM_LEFT: 10,\n  BOTTOM_CENTER: 11,\n  BOTTOM: 11,\n  BOTTOM_RIGHT: 12,\n  CENTER: 13,\n  BLOCK_START_INLINE_START: 14,\n  BLOCK_START_INLINE_CENTER: 15,\n  BLOCK_START_INLINE_END: 16,\n  INLINE_START_BLOCK_CENTER: 17,\n  INLINE_START_BLOCK_START: 18,\n  INLINE_START_BLOCK_END: 19,\n  INLINE_END_BLOCK_START: 20,\n  INLINE_END_BLOCK_CENTER: 21,\n  INLINE_END_BLOCK_END: 22,\n  BLOCK_END_INLINE_START: 23,\n  BLOCK_END_INLINE_CENTER: 24,\n  BLOCK_END_INLINE_END: 25\n};\nconst MapControl = ({\n  children,\n  position\n}) => {\n  const controlContainer = useMemo(() => document.createElement('div'), []);\n  const map = useMap();\n  useEffect(() => {\n    if (!map) return;\n    const controls = map.controls[position];\n    controls.push(controlContainer);\n    return () => {\n      const controlsArray = controls.getArray();\n      // controlsArray could be undefined if the map is in an undefined state (e.g. invalid API-key, see #276\n      if (!controlsArray) return;\n      const index = controlsArray.indexOf(controlContainer);\n      controls.removeAt(index);\n    };\n  }, [controlContainer, map, position]);\n  return createPortal(children, controlContainer);\n};\n\nconst _excluded = [\"onClick\", \"onDrag\", \"onDragStart\", \"onDragEnd\", \"onMouseOver\", \"onMouseOut\"];\nfunction useMarker(props) {\n  const [marker, setMarker] = useState(null);\n  const map = useMap();\n  const {\n      onClick,\n      onDrag,\n      onDragStart,\n      onDragEnd,\n      onMouseOver,\n      onMouseOut\n    } = props,\n    markerOptions = _objectWithoutPropertiesLoose(props, _excluded);\n  const {\n    position,\n    draggable\n  } = markerOptions;\n  // create marker instance and add to the map once the map is available\n  useEffect(() => {\n    if (!map) {\n      if (map === undefined) console.error('<Marker> has to be inside a Map component.');\n      return;\n    }\n    const newMarker = new google.maps.Marker(markerOptions);\n    newMarker.setMap(map);\n    setMarker(newMarker);\n    return () => {\n      newMarker.setMap(null);\n      setMarker(null);\n    };\n    // We do not want to re-render the whole marker when the options change.\n    // Marker options update is handled in a useEffect below.\n    // Excluding markerOptions from dependency array on purpose here.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [map]);\n  // attach and re-attach event-handlers when any of the properties change\n  useEffect(() => {\n    if (!marker) return;\n    const m = marker;\n    // Add event listeners\n    const gme = google.maps.event;\n    if (onClick) gme.addListener(m, 'click', onClick);\n    if (onDrag) gme.addListener(m, 'drag', onDrag);\n    if (onDragStart) gme.addListener(m, 'dragstart', onDragStart);\n    if (onDragEnd) gme.addListener(m, 'dragend', onDragEnd);\n    if (onMouseOver) gme.addListener(m, 'mouseover', onMouseOver);\n    if (onMouseOut) gme.addListener(m, 'mouseout', onMouseOut);\n    marker.setDraggable(Boolean(draggable));\n    return () => {\n      gme.clearInstanceListeners(m);\n    };\n  }, [marker, draggable, onClick, onDrag, onDragStart, onDragEnd, onMouseOver, onMouseOut]);\n  // update markerOptions (note the dependencies aren't properly checked\n  // here, we just assume that setOptions is smart enough to not waste a\n  // lot of time updating values that didn't change)\n  useEffect(() => {\n    if (!marker) return;\n    if (markerOptions) marker.setOptions(markerOptions);\n  }, [marker, markerOptions]);\n  // update position when changed\n  useEffect(() => {\n    // Should not update position when draggable\n    if (draggable || !position || !marker) return;\n    marker.setPosition(position);\n  }, [draggable, position, marker]);\n  return marker;\n}\n/**\n * Component to render a marker on a map\n */\nconst Marker = forwardRef((props, ref) => {\n  const marker = useMarker(props);\n  useImperativeHandle(ref, () => marker, [marker]);\n  return /*#__PURE__*/React.createElement(React.Fragment, null);\n});\nfunction useMarkerRef() {\n  const [marker, setMarker] = useState(null);\n  const refCallback = useCallback(m => {\n    setMarker(m);\n  }, []);\n  return [refCallback, marker];\n}\n\n/**\n * Component to configure the appearance of an AdvancedMarker\n */\nconst Pin = props => {\n  var _useContext;\n  const advancedMarker = (_useContext = useContext(AdvancedMarkerContext)) == null ? void 0 : _useContext.marker;\n  const glyphContainer = useMemo(() => document.createElement('div'), []);\n  // Create Pin View instance\n  useEffect(() => {\n    var _advancedMarker$conte;\n    if (!advancedMarker) {\n      if (advancedMarker === undefined) {\n        console.error('The <Pin> component can only be used inside <AdvancedMarker>.');\n      }\n      return;\n    }\n    if (props.glyph && props.children) {\n      logErrorOnce('The <Pin> component only uses children to render the glyph if both the glyph property and children are present.');\n    }\n    if (Children.count(props.children) > 1) {\n      logErrorOnce('Passing multiple children to the <Pin> component might lead to unexpected results.');\n    }\n    const pinViewOptions = _extends({}, props);\n    const pinElement = new google.maps.marker.PinElement(pinViewOptions);\n    // Set glyph to glyph container if children are present (rendered via portal).\n    // If both props.glyph and props.children are present, props.children takes priority.\n    if (props.children) {\n      pinElement.glyph = glyphContainer;\n    }\n    // Set content of Advanced Marker View to the Pin View element\n    // Here we are selecting the anchor container.\n    // The hierarchy is as follows:\n    // \"advancedMarker.content\" (from google) -> \"pointer events reset div\" -> \"anchor container\"\n    const markerContent = (_advancedMarker$conte = advancedMarker.content) == null || (_advancedMarker$conte = _advancedMarker$conte.firstChild) == null ? void 0 : _advancedMarker$conte.firstChild;\n    while (markerContent != null && markerContent.firstChild) {\n      markerContent.removeChild(markerContent.firstChild);\n    }\n    if (markerContent) {\n      markerContent.appendChild(pinElement.element);\n    }\n  }, [advancedMarker, glyphContainer, props]);\n  return createPortal(props.children, glyphContainer);\n};\n\nconst mapLinear = (x, a1, a2, b1, b2) => b1 + (x - a1) * (b2 - b1) / (a2 - a1);\nconst getMapMaxTilt = zoom => {\n  if (zoom <= 10) {\n    return 30;\n  }\n  if (zoom >= 15.5) {\n    return 67.5;\n  }\n  // range [10...14]\n  if (zoom <= 14) {\n    return mapLinear(zoom, 10, 14, 30, 45);\n  }\n  // range [14...15.5]\n  return mapLinear(zoom, 14, 15.5, 45, 67.5);\n};\n/**\n * Function to limit the tilt range of the Google map when updating the view state\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst limitTiltRange = ({\n  viewState\n}) => {\n  const pitch = viewState.pitch;\n  const gmZoom = viewState.zoom + 1;\n  const maxTilt = getMapMaxTilt(gmZoom);\n  return _extends({}, viewState, {\n    fovy: 25,\n    pitch: Math.min(maxTilt, pitch)\n  });\n};\n\nexport { APILoadingStatus, APIProvider, APIProviderContext, AdvancedMarker, AdvancedMarkerAnchorPoint, AdvancedMarkerContext, CollisionBehavior, ColorScheme, ControlPosition, GoogleMapsContext, InfoWindow, Map, MapControl, Marker, Pin, RenderingType, isAdvancedMarker, isLatLngLiteral, latLngEquals, limitTiltRange, toLatLngLiteral, useAdvancedMarkerRef, useApiIsLoaded, useApiLoadingStatus, useMap, useMapsLibrary, useMarkerRef };\n//# sourceMappingURL=index.modern.mjs.map\n"],"names":["module","exports","equal","a","b","constructor","length","i","keys","Array","isArray","RegExp","source","flags","valueOf","Object","prototype","toString","hasOwnProperty","call","key","c","e","u","this","o","f","l","v","m","d","g","current","p","window","w","TypeError","s","leading","x","trailing","h","y","debounceOnServer","F","Math","max","maxWait","A","r","n","t","apply","cancelAnimationFrame","requestAnimationFrame","setTimeout","Date","now","min","slice","arguments","cancel","clearTimeout","isPending","flush","equalityFn","_extends","assign","bind","_objectWithoutPropertiesLoose","includes","_toPropertyKey","Symbol","toPrimitive","String","Number","_toPrimitive","APILoadingStatus","NOT_LOADED","LOADING","LOADED","FAILED","AUTH_FAILURE","GoogleMapsApiLoader","load","params","onLoadingStatusChange","_window$google","libraries","split","serializedParams","serializeParams","listeners","push","google","maps","importLibrary","serializedApiParams","loadingStatus","notifyLoadingStatusListeners","initImportLibrary","console","warn","librariesToLoad","Promise","all","map","name","language","region","authReferrerPolicy","solutionChannel","join","error","apiPromise","loadApi","resolve","reject","_document$querySelect","scriptElement","document","createElement","urlParams","URLSearchParams","value","entries","urlParamName","replace","toLowerCase","set","async","src","MAPS_API_BASE_URL","nonce","querySelector","onerror","Error","__googleMapsCallback__","gm_authFailure","head","append","libraryName","then","fn","_excluded$3","_excluded2$1","APIProviderContext","APIProvider","props","children","loaderProps","mapInstances","addMapInstance","removeMapInstance","clearMapInstances","setMapInstances","useState","mapInstance","id","instances","_ref","useMapInstances","status","loadedLibraries","onLoad","onError","apiKey","version","otherApiParams","setStatus","addLoadedLibrary","useReducer","action","librariesString","useMemo","JSON","stringify","useCallback","_google","res","useEffect","undefined","channel","useGoogleMapsApiLoader","contextValue","Provider","createMapEvent","type","srcEvent","ev","detail","stoppable","stop","cameraEventTypes","camEvent","center","getCenter","zoom","getZoom","heading","getHeading","tilt","getTilt","bounds","getBounds","isFinite","toJSON","lat","lng","north","east","south","west","mouseEventTypes","_srcEvent$latLng","mouseEvent","domEvent","latLng","placeId","propNameToEventType","onBoundsChanged","onCenterChanged","onClick","onContextmenu","onDblclick","onDrag","onDragend","onDragstart","onHeadingChanged","onIdle","onIsFractionalZoomEnabledChanged","onMapCapabilitiesChanged","onMapTypeIdChanged","onMousemove","onMouseout","onMouseover","onProjectionChanged","onRenderingTypeChanged","onTilesLoaded","onTiltChanged","onZoomChanged","onCameraChanged","eventPropNames","useDeepCompareEffect","effect","deps","ref","useRef","mapOptionKeys","Set","useApiLoadingStatus","_useContext","useContext","toLatLngLiteral","obj","isLatLngLiteral","AuthFailureMessage","style","position","top","left","bottom","right","zIndex","display","flexFlow","textAlign","justifyContent","fontSize","color","background","padding","useApiIsLoaded","useTrackedCameraStateRef","forceUpdate","useForceUpdate","listener","event","addListener","handleBoundsChange","remove","_excluded$2","_excluded2","CachedMapStack","has","pop","useMapInstance","context","apiIsLoaded","setMap","container","containerRef","el","setEl","useCallbackRef","cameraStateRef","defaultBounds","defaultCenter","defaultZoom","defaultHeading","defaultTilt","reuseMaps","renderingType","colorScheme","mapOptions","hasZoom","hasCenter","savedMapStateRef","mapId","cacheKey","mapDiv","getDiv","appendChild","setOptions","setCenter","height","Map","defBounds","fitBounds","savedMapId","cameraState","savedCameraState","clearInstanceListeners","GoogleMapsContext","className","mapRef","mapProps","useLayoutEffect","nextCamera","needsUpdate","moveCamera","useMapCameraParams","propName","handler","eventType","useMapEvents","useMapOptions","isDeckGlControlled","viewport","viewState","latitude","longitude","bearing","pitch","useDeckGLCameraUpdate","isControlledExternally","controlled","disableDefaultUI","gestureHandling","keyboardShortcuts","cameraOptions","_lat","_lng","_props$zoom","_props$heading","_props$tilt","combinedStyle","width","deckGLViewProps","shownMessages","logErrorOnce","args","add","useMap","ctx","useMapsLibrary","useMapsEventListener","target","callback","usePropBinding","object","prop","useDomEventListener","addEventListener","removeEventListener","AdvancedMarkerContext","AdvancedMarkerAnchorPoint","TOP_LEFT","TOP_CENTER","TOP","TOP_RIGHT","LEFT_CENTER","LEFT_TOP","LEFT","LEFT_BOTTOM","RIGHT_TOP","RIGHT","RIGHT_CENTER","RIGHT_BOTTOM","BOTTOM_LEFT","BOTTOM_CENTER","BOTTOM","BOTTOM_RIGHT","CENTER","MarkerContent","styles","anchorPoint","xTranslation","yTranslation","transformStyle","transform","useAdvancedMarker","marker","setMarker","contentContainer","setContentContainer","markerLibrary","onMouseEnter","onMouseLeave","onDragStart","onDragEnd","collisionBehavior","clickable","draggable","title","numChildren","Children","count","newMarker","AdvancedMarkerElement","contentElement","isCustomMarker","content","_contentElement","gmpDraggable","gmpClickable","Boolean","nodeType","Node","ELEMENT_NODE","pointerEvents","firstElementChild","element","AdvancedMarker","forwardRef","advancedMarkerContextValue","useImperativeHandle","createPortal","useAdvancedMarkerRef","_excluded","onMouseOver","onMouseOut","markerOptions","Marker","gme","setDraggable","setPosition","useMarker"],"sourceRoot":""}