{"version":3,"sources":["jsdelivr-header.js","/npm/@vis.gl/react-google-maps@1.7.1/dist/index.umd.js"],"names":[],"mappings":"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","file":"/npm/@vis.gl/react-google-maps@1.7.1/dist/index.umd.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@vis.gl/react-google-maps@1.7.1/dist/index.umd.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react-dom'), require('fast-deep-equal')) :\n    typeof define === 'function' && define.amd ? define(['exports', 'react', 'react-dom', 'fast-deep-equal'], factory) :\n    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactGoogleMaps = {}, global.React, global.ReactDOM, global.fastDeepEqual));\n})(this, (function (exports, React, reactDom, isDeepEqual) { 'use strict';\n\n    // This file is automatically updated by the build process.\n    const VERSION = '1.7.1';\n\n    /******************************************************************************\r\n    Copyright (c) Microsoft Corporation.\r\n\r\n    Permission to use, copy, modify, and/or distribute this software for any\r\n    purpose with or without fee is hereby granted.\r\n\r\n    THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\n    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\n    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\n    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\n    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\n    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\n    PERFORMANCE OF THIS SOFTWARE.\r\n    ***************************************************************************** */\r\n    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\n\r\n    function __rest(s, e) {\r\n        var t = {};\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n            t[p] = s[p];\r\n        if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                    t[p[i]] = s[p[i]];\r\n            }\r\n        return t;\r\n    }\r\n\r\n    function __awaiter(thisArg, _arguments, P, generator) {\r\n        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n        return new (P || (P = Promise))(function (resolve, reject) {\r\n            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n            function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n            step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n        });\r\n    }\r\n\r\n    typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n        var e = new Error(message);\r\n        return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n    };\n\n    const APILoadingStatus = {\n        NOT_LOADED: 'NOT_LOADED',\n        LOADING: 'LOADING',\n        LOADED: 'LOADED',\n        FAILED: 'FAILED',\n        AUTH_FAILURE: 'AUTH_FAILURE'\n    };\n\n    const 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     */\n    class 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 load(params, onLoadingStatusChange) {\n            return __awaiter(this, void 0, void 0, function* () {\n                var _a, _b;\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 ((_b = (_a = window.google) === null || _a === void 0 ? void 0 : _a.maps) === null || _b === void 0 ? void 0 : _b.importLibrary) {\n                    // no serialized parameters means it was loaded externally\n                    if (!this.serializedApiParams) {\n                        this.loadingStatus = APILoadingStatus.LOADED;\n                    }\n                    this.notifyLoadingStatusListeners();\n                }\n                else {\n                    this.serializedApiParams = serializedParams;\n                    this.initImportLibrary(params);\n                }\n                if (this.serializedApiParams &&\n                    this.serializedApiParams !== serializedParams) {\n                    console.warn(`[google-maps-api-loader] The maps API has already been loaded ` +\n                        `with different parameters and will not be loaded again. Refresh the ` +\n                        `page for new values to have effect.`);\n                }\n                const librariesToLoad = ['maps', ...libraries];\n                yield Promise.all(librariesToLoad.map(name => google.maps.importLibrary(name)));\n            });\n        }\n        /**\n         * Serialize the parameters used to load the library for easier comparison.\n         */\n        static serializeParams(params) {\n            return [\n                params.v,\n                params.key,\n                params.language,\n                params.region,\n                params.authReferrerPolicy,\n                params.solutionChannel\n            ].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)\n                window.google = {};\n            if (!window.google.maps)\n                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)\n                    return apiPromise;\n                apiPromise = new Promise((resolve, reject) => {\n                    var _a;\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 =\n                        ((_a = document.querySelector('script[nonce]')) === null || _a === void 0 ? void 0 : _a.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     */\n    GoogleMapsApiLoader.loadingStatus = APILoadingStatus.NOT_LOADED;\n    /**\n     * A list of functions to be notified when the loading status changes.\n     */\n    GoogleMapsApiLoader.listeners = [];\n\n    const DEFAULT_SOLUTION_CHANNEL = 'GMP_visgl_rgmlibrary_v1_default';\n    const DEFAULT_INTERNAL_USAGE_ATTRIBUTION_IDS = [\n        `gmp_visgl_reactgooglemaps_v${VERSION}`\n    ];\n    const APIProviderContext = React.createContext(null);\n    /**\n     * local hook to set up the map-instance management context.\n     */\n    function useMapInstances() {\n        const [mapInstances, setMapInstances] = React.useState({});\n        const addMapInstance = (mapInstance, id = 'default') => {\n            setMapInstances(instances => (Object.assign(Object.assign({}, instances), { [id]: mapInstance })));\n        };\n        const removeMapInstance = (id = 'default') => {\n            setMapInstances((_a) => {\n                var _b = id; _a[_b]; var remaining = __rest(_a, [typeof _b === \"symbol\" ? _b : _b + \"\"]);\n                return remaining;\n            });\n        };\n        const clearMapInstances = () => {\n            setMapInstances({});\n        };\n        return { mapInstances, addMapInstance, removeMapInstance, clearMapInstances };\n    }\n    /**\n     * local hook to handle the loading of the maps API, returns the current loading status\n     * @param props\n     */\n    function useGoogleMapsApiLoader(props) {\n        const { onLoad, onError, apiKey, version, libraries = [] } = props, otherApiParams = __rest(props, [\"onLoad\", \"onError\", \"apiKey\", \"version\", \"libraries\"]);\n        const [status, setStatus] = React.useState(GoogleMapsApiLoader.loadingStatus);\n        const [loadedLibraries, addLoadedLibrary] = React.useReducer((loadedLibraries, action) => {\n            return loadedLibraries[action.name]\n                ? loadedLibraries\n                : Object.assign(Object.assign({}, loadedLibraries), { [action.name]: action.value });\n        }, {});\n        const librariesString = React.useMemo(() => libraries === null || libraries === void 0 ? void 0 : libraries.join(','), [libraries]);\n        const serializedParams = React.useMemo(() => JSON.stringify(Object.assign({ apiKey, version }, otherApiParams)), [apiKey, version, otherApiParams]);\n        const importLibrary = React.useCallback((name) => __awaiter(this, void 0, void 0, function* () {\n            var _a;\n            if (loadedLibraries[name]) {\n                return loadedLibraries[name];\n            }\n            if (!((_a = google === null || google === void 0 ? void 0 : google.maps) === null || _a === void 0 ? void 0 : _a.importLibrary)) {\n                throw new Error('[api-provider-internal] importLibrary was called before ' +\n                    'google.maps.importLibrary was defined.');\n            }\n            const res = yield window.google.maps.importLibrary(name);\n            addLoadedLibrary({ name, value: res });\n            return res;\n        }), [loadedLibraries]);\n        React.useEffect(() => {\n            (() => __awaiter(this, void 0, void 0, function* () {\n                try {\n                    const params = Object.assign({ key: apiKey }, otherApiParams);\n                    if (version)\n                        params.v = version;\n                    if ((librariesString === null || librariesString === void 0 ? void 0 : librariesString.length) > 0)\n                        params.libraries = librariesString;\n                    if (params.channel === undefined ||\n                        params.channel < 0 ||\n                        params.channel > 999)\n                        delete params.channel;\n                    if (params.solutionChannel === undefined)\n                        params.solutionChannel = DEFAULT_SOLUTION_CHANNEL;\n                    else if (params.solutionChannel === '')\n                        delete params.solutionChannel;\n                    yield GoogleMapsApiLoader.load(params, status => setStatus(status));\n                    for (const name of ['core', 'maps', ...libraries]) {\n                        yield importLibrary(name);\n                    }\n                    if (onLoad) {\n                        onLoad();\n                    }\n                }\n                catch (error) {\n                    if (onError) {\n                        onError(error);\n                    }\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    function useInternalUsageAttributionIds(props) {\n        const internalUsageAttributionIds = React.useMemo(() => props.disableUsageAttribution\n            ? null\n            : DEFAULT_INTERNAL_USAGE_ATTRIBUTION_IDS, [props.disableUsageAttribution]);\n        return internalUsageAttributionIds;\n    }\n    /**\n     * Component to wrap the components from this library and load the Google Maps JavaScript API\n     */\n    const APIProvider = props => {\n        const { children } = props, loaderProps = __rest(props, [\"children\"]);\n        const { mapInstances, addMapInstance, removeMapInstance, clearMapInstances } = useMapInstances();\n        const { status, loadedLibraries, importLibrary } = useGoogleMapsApiLoader(loaderProps);\n        const internalUsageAttributionIds = useInternalUsageAttributionIds(loaderProps);\n        const contextValue = React.useMemo(() => ({\n            mapInstances,\n            addMapInstance,\n            removeMapInstance,\n            clearMapInstances,\n            status,\n            loadedLibraries,\n            importLibrary,\n            internalUsageAttributionIds\n        }), [\n            mapInstances,\n            addMapInstance,\n            removeMapInstance,\n            clearMapInstances,\n            status,\n            loadedLibraries,\n            importLibrary,\n            internalUsageAttributionIds\n        ]);\n        return (React.createElement(APIProviderContext.Provider, { value: contextValue }, children));\n    };\n\n    /**\n     * Sets up effects to bind event-handlers for all event-props in MapEventProps.\n     * @internal\n     */\n    function 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            React.useEffect(() => {\n                if (!map)\n                    return;\n                if (!handler)\n                    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     */\n    function createMapEvent(type, map, srcEvent) {\n        var _a;\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 ' +\n                    'returned undefined. This is not expected to happen. Please ' +\n                    'report an issue at https://github.com/visgl/react-google-maps/issues/new');\n            }\n            camEvent.detail = {\n                center: (center === null || center === void 0 ? void 0 : center.toJSON()) || { lat: 0, lng: 0 },\n                zoom: zoom || 0,\n                heading: heading,\n                tilt: tilt,\n                bounds: (bounds === null || bounds === void 0 ? void 0 : bounds.toJSON()) || {\n                    north: 90,\n                    east: 180,\n                    south: -90,\n                    west: -180\n                }\n            };\n            return camEvent;\n        }\n        else if (mouseEventTypes.includes(type)) {\n            if (!srcEvent)\n                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: ((_a = srcEvent.latLng) === null || _a === void 0 ? void 0 : _a.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     */\n    const 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    };\n    const cameraEventTypes = [\n        'bounds_changed',\n        'center_changed',\n        'heading_changed',\n        'tilt_changed',\n        'zoom_changed'\n    ];\n    const mouseEventTypes = [\n        'click',\n        'contextmenu',\n        'dblclick',\n        'mousemove',\n        'mouseout',\n        'mouseover'\n    ];\n    const eventPropNames = Object.keys(propNameToEventType);\n\n    /**\n     * A hook to store the previous value of a variable.\n     * @param value The value to store\n     * @returns The previous value\n     */\n    function usePrevious(value) {\n        const ref = React.useRef(undefined);\n        React.useEffect(() => {\n            ref.current = value;\n        });\n        // eslint-disable-next-line react-hooks/refs\n        return ref.current;\n    }\n\n    function useMemoized(value, isEqual) {\n        const previous = usePrevious(value);\n        return React.useMemo(() => {\n            if (previous && isEqual(previous, value)) {\n                return previous;\n            }\n            return value;\n        }, [value, previous, isEqual]);\n    }\n\n    function useCustomCompareEffect(effect, dependencies, isEqual) {\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        React.useEffect(effect, [useMemoized(dependencies, isEqual)]);\n    }\n\n    function useDeepCompareEffect(effect, dependencies) {\n        useCustomCompareEffect(effect, dependencies, isDeepEqual);\n    }\n\n    const mapOptionKeys = new Set([\n        'backgroundColor',\n        'clickableIcons',\n        'controlSize',\n        'disableDefaultUI',\n        'disableDoubleClickZoom',\n        'draggable',\n        'draggableCursor',\n        'draggingCursor',\n        'fullscreenControl',\n        'fullscreenControlOptions',\n        'gestureHandling',\n        'headingInteractionEnabled',\n        'isFractionalZoomEnabled',\n        'keyboardShortcuts',\n        'mapTypeControl',\n        'mapTypeControlOptions',\n        'mapTypeId',\n        'maxZoom',\n        'minZoom',\n        'noClear',\n        'panControl',\n        'panControlOptions',\n        'restriction',\n        'rotateControl',\n        'rotateControlOptions',\n        'scaleControl',\n        'scaleControlOptions',\n        'scrollwheel',\n        'streetView',\n        'streetViewControl',\n        'streetViewControlOptions',\n        'styles',\n        'tiltInteractionEnabled',\n        'zoomControl',\n        'zoomControlOptions'\n    ]);\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     */\n    function 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))\n                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)\n                return;\n            map.setOptions(mapOptions);\n        }, [mapOptions]);\n        /* eslint-enable react-hooks/exhaustive-deps */\n    }\n\n    function useApiLoadingStatus() {\n        var _a;\n        return ((_a = React.useContext(APIProviderContext)) === null || _a === void 0 ? void 0 : _a.status) || APILoadingStatus.NOT_LOADED;\n    }\n\n    /**\n     * Internal hook that updates the camera when deck.gl viewState changes.\n     * @internal\n     */\n    function useDeckGLCameraUpdate(map, props) {\n        const { viewport, viewState } = props;\n        const isDeckGlControlled = !!viewport;\n        React.useLayoutEffect(() => {\n            if (!map || !viewState)\n                return;\n            const { latitude, longitude, bearing: heading, pitch: tilt, zoom } = viewState;\n            map.moveCamera({\n                center: { lat: latitude, lng: longitude },\n                heading,\n                tilt,\n                zoom: zoom + 1\n            });\n        }, [map, viewState]);\n        return isDeckGlControlled;\n    }\n\n    function isLatLngLiteral(obj) {\n        if (!obj || typeof obj !== 'object')\n            return false;\n        if (!('lat' in obj && 'lng' in obj))\n            return false;\n        return Number.isFinite(obj.lat) && Number.isFinite(obj.lng);\n    }\n    function latLngEquals(a, b) {\n        if (!a || !b)\n            return false;\n        const A = toLatLngLiteral(a);\n        const B = toLatLngLiteral(b);\n        if (A.lat !== B.lat || A.lng !== B.lng)\n            return false;\n        return true;\n    }\n    function toLatLngLiteral(obj) {\n        if (isLatLngLiteral(obj))\n            return obj;\n        return obj.toJSON();\n    }\n\n    function 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)\n            ? mapProps.zoom\n            : null;\n        const heading = Number.isFinite(mapProps.heading)\n            ? mapProps.heading\n            : null;\n        const tilt = Number.isFinite(mapProps.tilt)\n            ? mapProps.tilt\n            : 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        React.useLayoutEffect(() => {\n            if (!map)\n                return;\n            const nextCamera = {};\n            let needsUpdate = false;\n            if (lat !== null &&\n                lng !== null &&\n                (cameraStateRef.current.center.lat !== lat ||\n                    cameraStateRef.current.center.lng !== lng)) {\n                nextCamera.center = { lat, lng };\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\n    const 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 (React.createElement(\"div\", { style: style },\n            React.createElement(\"h2\", null, \"Error: AuthFailure\"),\n            React.createElement(\"p\", null,\n                \"A problem with your API key prevents the map from rendering correctly. Please make sure the value of the \",\n                React.createElement(\"code\", null, \"APIProvider.apiKey\"),\n                \" prop is correct. Check the error-message in the console for further details.\")));\n    };\n\n    function useCallbackRef() {\n        const [el, setEl] = React.useState(null);\n        const ref = React.useCallback((value) => setEl(value), [setEl]);\n        return [el, ref];\n    }\n\n    /**\n     * Hook to check if the Maps JavaScript API is loaded\n     */\n    function useApiIsLoaded() {\n        const status = useApiLoadingStatus();\n        return status === APILoadingStatus.LOADED;\n    }\n\n    function useForceUpdate() {\n        const [, forceUpdate] = React.useReducer(x => x + 1, 0);\n        return forceUpdate;\n    }\n\n    function 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 ' +\n                'returned undefined. This is not expected to happen. Please ' +\n                '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 || center === void 0 ? void 0 : center.toJSON()) || { lat: 0, lng: 0 },\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     */\n    function useTrackedCameraStateRef(map) {\n        const forceUpdate = useForceUpdate();\n        const ref = React.useRef({\n            center: { lat: 0, lng: 0 },\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        React.useEffect(() => {\n            if (!map)\n                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\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     */\n    class 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])\n                return null;\n            return this.entries[key].pop() || null;\n        }\n        static push(key, value) {\n            if (!this.entries[key])\n                this.entries[key] = [];\n            this.entries[key].push(value);\n        }\n    }\n    CachedMapStack.entries = {};\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     */\n    function useMapInstance(props, context) {\n        const apiIsLoaded = useApiIsLoaded();\n        const [map, setMap] = React.useState(null);\n        const [container, containerRef] = useCallbackRef();\n        const cameraStateRef = useTrackedCameraStateRef(map);\n        const { id, defaultBounds, defaultCenter, defaultZoom, defaultHeading, defaultTilt, reuseMaps, renderingType, colorScheme } = props, mapOptions = __rest(props, [\"id\", \"defaultBounds\", \"defaultCenter\", \"defaultZoom\", \"defaultHeading\", \"defaultTilt\", \"reuseMaps\", \"renderingType\", \"colorScheme\"]);\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. ' +\n                'You have to provide zoom and center (via the `zoom`/`defaultZoom` and ' +\n                '`center`/`defaultCenter` props) or specify the region to show using ' +\n                '`defaultBounds`. See ' +\n                '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)\n            mapOptions.center = defaultCenter;\n        if (!mapOptions.zoom && Number.isFinite(defaultZoom))\n            mapOptions.zoom = defaultZoom;\n        if (!mapOptions.heading && Number.isFinite(defaultHeading))\n            mapOptions.heading = defaultHeading;\n        if (!mapOptions.tilt && Number.isFinite(defaultTilt))\n            mapOptions.tilt = defaultTilt;\n        // Handle internalUsageAttributionIds\n        const customIds = mapOptions.internalUsageAttributionIds;\n        if (customIds == null) {\n            // Not specified - use context default (which may be null if disabled)\n            mapOptions.internalUsageAttributionIds =\n                context.internalUsageAttributionIds;\n        }\n        else {\n            // Merge context defaults with custom IDs\n            mapOptions.internalUsageAttributionIds = [\n                ...(context.internalUsageAttributionIds || []),\n                ...customIds\n            ];\n        }\n        for (const key of Object.keys(mapOptions))\n            if (mapOptions[key] === undefined)\n                delete mapOptions[key];\n        const savedMapStateRef = React.useRef(undefined);\n        // create the map instance and register it in the context\n        React.useEffect(() => {\n            if (!container || !apiIsLoaded)\n                return;\n            const { addMapInstance, removeMapInstance } = context;\n            // note: colorScheme (upcoming feature) isn't yet in the typings, remove once that is fixed:\n            const { mapId } = 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            }\n            else {\n                mapDiv = document.createElement('div');\n                mapDiv.style.height = '100%';\n                container.appendChild(mapDiv);\n                map = new google.maps.Map(mapDiv, Object.assign(Object.assign(Object.assign({}, mapOptions), (renderingType\n                    ? { renderingType: renderingType }\n                    : {})), (colorScheme\n                    ? { colorScheme: colorScheme }\n                    : {})));\n            }\n            setMap(map);\n            addMapInstance(map, id);\n            if (defaultBounds) {\n                const { padding } = defaultBounds, defBounds = __rest(defaultBounds, [\"padding\"]);\n                map.fitBounds(defBounds, padding);\n            }\n            // prevent map not rendering due to missing configuration\n            else if (!hasZoom || !hasCenter) {\n                map.fitBounds({ east: 180, west: -180, south: -90, north: 90 });\n            }\n            // the savedMapState is used to restore the camera parameters when the mapId is changed\n            if (savedMapStateRef.current) {\n                const { mapId: savedMapId, cameraState: savedCameraState } = 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                }\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        [\n            container,\n            apiIsLoaded,\n            id,\n            // these props can't be changed after initialization and require a new\n            // instance to be created\n            props.mapId,\n            props.renderingType,\n            props.colorScheme\n        ]);\n        return [map, containerRef, cameraStateRef];\n    }\n\n    const GoogleMapsContext = React.createContext(null);\n    // ColorScheme and RenderingType are redefined here to make them usable before the\n    // maps API has been fully loaded.\n    const ColorScheme = {\n        DARK: 'DARK',\n        LIGHT: 'LIGHT',\n        FOLLOW_SYSTEM: 'FOLLOW_SYSTEM'\n    };\n    const RenderingType = {\n        VECTOR: 'VECTOR',\n        RASTER: 'RASTER',\n        UNINITIALIZED: 'UNINITIALIZED'\n    };\n    const Map = (props) => {\n        const { children, id, className, style } = props;\n        const context = React.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        React.useEffect(() => {\n            if (!map)\n                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({ disableDefaultUI: true });\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        }, [\n            map,\n            isDeckGlControlled,\n            isControlledExternally,\n            props.gestureHandling,\n            props.keyboardShortcuts\n        ]);\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 = React.useMemo(() => {\n            var _a, _b, _c;\n            return {\n                center: { lat: lat !== null && lat !== void 0 ? lat : 0, lng: lng !== null && lng !== void 0 ? lng : 0 },\n                zoom: (_a = props.zoom) !== null && _a !== void 0 ? _a : 0,\n                heading: (_b = props.heading) !== null && _b !== void 0 ? _b : 0,\n                tilt: (_c = props.tilt) !== null && _c !== void 0 ? _c : 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        React.useLayoutEffect(() => {\n            if (!map || !isControlledExternally)\n                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 = React.useMemo(() => (Object.assign({ width: '100%', height: '100%', position: 'relative', \n            // when using deckgl, the map should be sent to the back\n            zIndex: isDeckGlControlled ? -1 : 0 }, style)), [style, isDeckGlControlled]);\n        const contextValue = React.useMemo(() => ({ map }), [map]);\n        if (loadingStatus === APILoadingStatus.AUTH_FAILURE) {\n            return (React.createElement(\"div\", { style: Object.assign({ position: 'relative' }, (className ? {} : combinedStyle)), className: className },\n                React.createElement(AuthFailureMessage, null)));\n        }\n        return (React.createElement(\"div\", Object.assign({ ref: mapRef, \"data-testid\": 'map', style: className ? undefined : combinedStyle, className: className }, (id ? { id } : {})), map ? (React.createElement(GoogleMapsContext.Provider, { value: contextValue }, 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\n    Map.deckGLViewProps = true;\n\n    const shownMessages = new Set();\n    function 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     */\n    const useMap = (id = null) => {\n        const ctx = React.useContext(APIProviderContext);\n        const { map } = React.useContext(GoogleMapsContext) || {};\n        if (ctx === null) {\n            logErrorOnce('useMap(): failed to retrieve APIProviderContext. ' +\n                'Make sure that the <APIProvider> component exists and that the ' +\n                'component you are calling `useMap()` from is a sibling of the ' +\n                '<APIProvider>.');\n            return null;\n        }\n        const { mapInstances } = ctx;\n        // if an id is specified, the corresponding map or null is returned\n        if (id !== null)\n            return mapInstances[id] || null;\n        // otherwise, return the closest ancestor\n        if (map)\n            return map;\n        // finally, return the default map instance\n        return mapInstances['default'] || null;\n    };\n\n    function useMapsLibrary(name) {\n        const apiIsLoaded = useApiIsLoaded();\n        const ctx = React.useContext(APIProviderContext);\n        React.useEffect(() => {\n            if (!apiIsLoaded || !ctx)\n                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 || ctx === void 0 ? 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     */\n    function useMapsEventListener(target, name, callback) {\n        React.useEffect(() => {\n            if (!target || !name || !callback)\n                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     */\n    function usePropBinding(object, prop, value) {\n        React.useEffect(() => {\n            if (!object)\n                return;\n            // eslint-disable-next-line react-hooks/immutability\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     */\n    function useDomEventListener(target, name, callback) {\n        React.useEffect(() => {\n            if (!target || !name || !callback)\n                return;\n            target.addEventListener(name, callback);\n            return () => target.removeEventListener(name, callback);\n        }, [target, name, callback]);\n    }\n\n    // Global style manager to track rendered styles and avoid duplicates\n    class GlobalStyleManager {\n        constructor() {\n            this.renderedStyles = new Set();\n            this.styleElement = null;\n        }\n        getStyleElement() {\n            if (!this.styleElement) {\n                this.styleElement = document.createElement('style');\n                this.styleElement.setAttribute('data-rgm-anchor-styles', '');\n                document.head.appendChild(this.styleElement);\n            }\n            return this.styleElement;\n        }\n        addAdvancedMarkerPointerEventsOverwrite() {\n            if (this.renderedStyles.has('marker-pointer-events')) {\n                return;\n            }\n            const styleElement = this.getStyleElement();\n            styleElement.textContent += `\n      gmp-advanced-marker[data-origin='rgm'] {\n        pointer-events: none !important;\n      }\n    `;\n            this.renderedStyles.add('marker-pointer-events');\n        }\n        cleanup() {\n            if (this.styleElement) {\n                this.styleElement.remove();\n                this.styleElement = null;\n                this.renderedStyles.clear();\n            }\n        }\n    }\n    const globalStyleManager = new GlobalStyleManager();\n\n    function isVersionGreaterEqual(major, minor) {\n        var _a;\n        if (!((_a = google === null || google === void 0 ? void 0 : google.maps) === null || _a === void 0 ? void 0 : _a.version))\n            return undefined;\n        const version = google.maps.version.split('.');\n        const currentMajor = parseInt(version[0], 10);\n        const currentMinor = parseInt(version[1], 10);\n        return (currentMajor > major || (currentMajor === major && currentMinor >= minor));\n    }\n\n    /* eslint-disable react-hooks/immutability */\n    // The `react-hooks/immutability` rule is disabled in this file because the\n    // google.maps.marker.AdvancedMarkerElement object is designed to be mutated\n    // directly. This is a common pattern when working with imperative APIs like\n    // the Google Maps JavaScript API. While this goes against the principles of\n    // immutable state in React, it is a necessary evil to integrate with the\n    // Google Maps API. The mutations are carefully managed within the `useEffect`\n    // hooks to ensure that they only happen when the props change.\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     */\n    const 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    };\n    const AdvancedMarkerContext = React.createContext(null);\n    // [xPosition, yPosition] when the top left corner is [0, 0]\n    /**\n     * @deprecated Using `anchorPosition` is deprecated.\n     *   Use `anchorLeft` and `anchorTop` instead.\n     */\n    const 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    };\n    const AdvancedMarker = React.forwardRef((props, ref) => {\n        const { children, style, className, anchorPoint } = props;\n        const [marker, contentContainer] = useAdvancedMarker(props);\n        const advancedMarkerContextValue = React.useMemo(() => (marker ? { marker } : null), [marker]);\n        React.useImperativeHandle(ref, () => marker, [marker]);\n        if (!contentContainer)\n            return null;\n        return (React.createElement(AdvancedMarkerContext.Provider, { value: advancedMarkerContextValue }, reactDom.createPortal(React.createElement(MarkerContent, { anchorPoint: anchorPoint, styles: style, className: className }, children), contentContainer)));\n    });\n    AdvancedMarker.displayName = 'AdvancedMarker';\n    function useAdvancedMarkerRef() {\n        const [marker, setMarker] = React.useState(null);\n        const refCallback = React.useCallback((m) => {\n            setMarker(m);\n        }, []);\n        return [refCallback, marker];\n    }\n    function isAdvancedMarker(marker) {\n        return (marker.content !== undefined);\n    }\n    function isElementNode(node) {\n        return node.nodeType === Node.ELEMENT_NODE;\n    }\n    const MarkerContent = ({ children, styles, className }) => {\n        /* AdvancedMarker div that user can give styles and classes */\n        return (React.createElement(\"div\", { className: className, style: styles }, children));\n    };\n    function useAdvancedMarker(props) {\n        const [marker, setMarker] = React.useState(null);\n        const [contentContainer, setContentContainer] = React.useState(null);\n        const map = useMap();\n        const markerLibrary = useMapsLibrary('marker');\n        const { children, onClick, className, onMouseEnter, onMouseLeave, onDrag, onDragStart, onDragEnd, collisionBehavior, clickable, draggable, position, title, zIndex, anchorPoint, anchorLeft, anchorTop } = props;\n        const numChildren = React.Children.count(children);\n        // create an AdvancedMarkerElement instance and add it to the map once available\n        React.useEffect(() => {\n            if (!map || !markerLibrary)\n                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                newMarker.content = contentElement;\n                setContentContainer(contentElement);\n            }\n            return () => {\n                newMarker.map = null;\n                contentElement === null || contentElement === void 0 ? void 0 : 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        React.useEffect(() => {\n            if (!(marker === null || marker === void 0 ? void 0 : marker.content) || !isElementNode(marker.content) || numChildren > 0)\n                return;\n            marker.content.className = className !== null && className !== void 0 ? className : '';\n        }, [marker, className, numChildren]);\n        useAdvancedMarkerAnchoring(marker, anchorPoint, anchorLeft, anchorTop, numChildren > 0);\n        // copy other props\n        usePropBinding(marker, 'position', position);\n        usePropBinding(marker, 'title', title !== null && title !== void 0 ? 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        React.useEffect(() => {\n            if (!marker)\n                return;\n            if (draggable !== undefined)\n                marker.gmpDraggable = draggable;\n            else if (onDrag || onDragStart || onDragEnd)\n                marker.gmpDraggable = true;\n            else\n                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        React.useEffect(() => {\n            if (!marker)\n                return;\n            const gmpClickable = clickable !== undefined ||\n                Boolean(onClick) ||\n                Boolean(onMouseEnter) ||\n                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 === void 0 ? void 0 : marker.content) && isElementNode(marker.content)) {\n                marker.content.style.pointerEvents = 'all';\n                if (onClick) {\n                    marker.content.style.cursor = 'pointer';\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 || marker === void 0 ? void 0 : marker.element, 'mouseenter', onMouseEnter);\n        useDomEventListener(marker === null || marker === void 0 ? void 0 : marker.element, 'mouseleave', onMouseLeave);\n        return [marker, contentContainer];\n    }\n    function useAdvancedMarkerAnchoring(marker, anchorPoint, anchorLeft, anchorTop, hasChildren) {\n        React.useEffect(() => {\n            if (!marker || !hasChildren)\n                return;\n            // The anchorLeft and anchorTop options are available since version 3.62.9c\n            // With the release of 3.65 (~May 2026) there will no longer be a version\n            // that doesn't support it.\n            const anchorOptionsSupported = isVersionGreaterEqual(3, 62);\n            const contentElement = marker.content;\n            if (!contentElement || !isElementNode(contentElement))\n                return;\n            if (anchorLeft !== undefined || anchorTop !== undefined) {\n                if (!anchorOptionsSupported) {\n                    console.warn('AdvancedMarker: The anchorLeft and anchorTop props are only supported ' +\n                        'in Google Maps API version 3.62 and above. ' +\n                        `The current version is ${google.maps.version}.`);\n                }\n                marker.anchorLeft = anchorLeft;\n                marker.anchorTop = anchorTop;\n                // when anchorLeft and/or anchorTop are set, we'll ignore the anchorPoint\n                if (anchorPoint !== undefined) {\n                    console.warn('AdvancedMarker: the anchorPoint prop is ignored when anchorLeft ' +\n                        'and/or anchorTop are set.');\n                }\n                return;\n            }\n            if (anchorPoint !== undefined) {\n                // TODO: add console.warn in a future version to inform about deprecation\n                const [x, y] = anchorPoint !== null && anchorPoint !== void 0 ? anchorPoint : AdvancedMarkerAnchorPoint['BOTTOM'];\n                // NOTE: since x and y can be any valid CSS length-percentage\n                //   value, we need to use calc() to negate them.\n                const translateX = `calc(-1 * ${x})`;\n                const translateY = `calc(-1 * ${y})`;\n                if (anchorOptionsSupported) {\n                    // implement anchorPoint using the new anchorLeft and anchorTop options\n                    marker.anchorLeft = translateX;\n                    marker.anchorTop = translateY;\n                    // reset transform from legacy implementation\n                    contentElement.style.transform = '';\n                }\n                else {\n                    // The \"translate(50%, 100%)\" counters and resets the default\n                    // anchoring of the advanced marker element from the api\n                    contentElement.style.transform = `translate(50%, 100%) translate(${translateX}, ${translateY})`;\n                    // data-origin is needed to identify the custom marker content in the\n                    // InfoWindow component as well as in the global CSS used to disable\n                    // the pointer event when anchor points are used in older Google Maps\n                    // versions.\n                    marker.dataset.origin = 'rgm';\n                    globalStyleManager.addAdvancedMarkerPointerEventsOverwrite();\n                }\n            }\n        }, [marker, anchorPoint, anchorLeft, anchorTop, hasChildren]);\n    }\n\n    function 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, ' +\n                \"not a string. For example, style={{marginRight: spacing + 'em'}} when \" +\n                'using JSX.');\n        }\n        const elementStyle = element.style;\n        // without `prevStyles`, just set all values\n        if (prevStyles == null) {\n            if (styles == null)\n                return;\n            for (const styleName in styles) {\n                if (!styles.hasOwnProperty(styleName))\n                    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) &&\n                (styles == null || !styles.hasOwnProperty(styleName))) {\n                // Clear style\n                const isCustomProperty = styleName.indexOf('--') === 0;\n                if (isCustomProperty) {\n                    elementStyle.setProperty(styleName, '');\n                }\n                else if (styleName === 'float') {\n                    elementStyle.cssFloat = '';\n                }\n                else {\n                    elementStyle[styleName] = '';\n                }\n            }\n        }\n        // only assign values from `styles` that are different from `prevStyles`\n        if (styles == null)\n            return;\n        for (const styleName in styles) {\n            const value = styles[styleName];\n            if (styles.hasOwnProperty(styleName) &&\n                prevStyles[styleName] !== value) {\n                setValueForStyle(elementStyle, styleName, value);\n            }\n        }\n    }\n    function 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            }\n            else if (styleName === 'float') {\n                elementStyle.cssFloat = '';\n            }\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' &&\n            value !== 0 &&\n            !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            }\n            else {\n                elementStyle[styleName] = ('' + value).trim();\n            }\n        }\n    }\n    // CSS properties which accept numbers but are not in units of \"px\".\n    const unitlessNumbers = new Set([\n        'animationIterationCount',\n        'aspectRatio',\n        'borderImageOutset',\n        'borderImageSlice',\n        'borderImageWidth',\n        'boxFlex',\n        'boxFlexGroup',\n        'boxOrdinalGroup',\n        'columnCount',\n        'columns',\n        'flex',\n        'flexGrow',\n        'flexPositive',\n        'flexShrink',\n        'flexNegative',\n        'flexOrder',\n        'gridArea',\n        'gridRow',\n        'gridRowEnd',\n        'gridRowSpan',\n        'gridRowStart',\n        'gridColumn',\n        'gridColumnEnd',\n        'gridColumnSpan',\n        'gridColumnStart',\n        'fontWeight',\n        'lineClamp',\n        'lineHeight',\n        'opacity',\n        'order',\n        'orphans',\n        'scale',\n        'tabSize',\n        'widows',\n        'zIndex',\n        'zoom',\n        'fillOpacity', // SVG-related properties\n        'floodOpacity',\n        'stopOpacity',\n        'strokeDasharray',\n        'strokeDashoffset',\n        'strokeMiterlimit',\n        'strokeOpacity',\n        'strokeWidth'\n    ]);\n    function isUnitlessNumber(name) {\n        return unitlessNumbers.has(name);\n    }\n\n    /**\n     * Component to render an Info Window with the Maps JavaScript API\n     */\n    const InfoWindow = props => {\n        const { \n        // content options\n        children, headerContent, style, className, pixelOffset, \n        // open options\n        anchor, shouldFocus, \n        // events\n        onClose, onCloseClick } = props, \n        // other options\n        volatileInfoWindowOptions = __rest(props, [\"children\", \"headerContent\", \"style\", \"className\", \"pixelOffset\", \"anchor\", \"shouldFocus\", \"onClose\", \"onCloseClick\"]);\n        // ## create infowindow instance once the mapsLibrary is available.\n        const mapsLibrary = useMapsLibrary('maps');\n        const [infoWindow, setInfoWindow] = React.useState(null);\n        const contentContainerRef = React.useRef(null);\n        const headerContainerRef = React.useRef(null);\n        const infoWindowOptions = useMemoized(volatileInfoWindowOptions, isDeepEqual);\n        React.useEffect(() => {\n            if (!mapsLibrary)\n                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 =\n                    typeof headerContent === 'string'\n                        ? headerContent\n                        : 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 _a, _b;\n                infoWindow.setContent(null);\n                (_a = contentContainerRef.current) === null || _a === void 0 ? void 0 : _a.remove();\n                (_b = headerContainerRef.current) === null || _b === void 0 ? void 0 : _b.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        // prevStyleRef stores previously applied style properties, so they can be\n        // removed when unset\n        const prevStyleRef = React.useRef(null);\n        React.useEffect(() => {\n            if (!infoWindow || !contentContainerRef.current)\n                return;\n            setValueForStyles(contentContainerRef.current, style || null, prevStyleRef.current);\n            prevStyleRef.current = style || null;\n            if (className !== contentContainerRef.current.className)\n                contentContainerRef.current.className = className || '';\n        }, [infoWindow, className, style]);\n        // ---- update options\n        React.useEffect(() => {\n            if (!infoWindow)\n                return;\n            const opts = infoWindowOptions;\n            if (!pixelOffset) {\n                opts.pixelOffset = null;\n            }\n            else {\n                opts.pixelOffset = new google.maps.Size(pixelOffset[0], pixelOffset[1]);\n            }\n            if (!headerContent) {\n                opts.headerContent = null;\n            }\n            else {\n                opts.headerContent =\n                    typeof headerContent === 'string'\n                        ? headerContent\n                        : 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        React.useEffect(() => {\n            var _a;\n            // `anchor === null` means an anchor is defined but not ready yet.\n            if (!map || !infoWindow || anchor === null)\n                return;\n            const isOpenedWithAnchor = !!anchor;\n            const openOptions = { map };\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 anchorBcr = anchor === null || anchor === void 0 ? void 0 : anchor.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\n                    // children, or an AdvancedMarker that uses the anchorLeft/anchorTop props.\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 (anchorBcr && anchor.dataset.origin === 'rgm') {\n                        // We can safely typecast here since we control that element and we know that\n                        // it is a div\n                        const anchorDomContent = (_a = anchor.content.firstElementChild) === null || _a === void 0 ? void 0 : _a.firstElementChild;\n                        const contentBcr = anchorDomContent === null || anchorDomContent === void 0 ? void 0 : anchorDomContent.getBoundingClientRect();\n                        // center infowindow above marker\n                        const anchorOffsetX = contentBcr.x -\n                            anchorBcr.x +\n                            (contentBcr.width - anchorBcr.width) / 2;\n                        const anchorOffsetY = contentBcr.y - anchorBcr.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)\n                    infoWindow.set('anchor', null);\n                infoWindow.close();\n            };\n        }, [infoWindow, anchor, map, shouldFocus, infoWindowOptions, pixelOffset]);\n        return (React.createElement(React.Fragment, null,\n            contentContainerRef.current &&\n                reactDom.createPortal(children, contentContainerRef.current),\n            headerContainerRef.current !== null &&\n                reactDom.createPortal(headerContent, headerContainerRef.current)));\n    };\n\n    /**\n     * Formats a location into a string representation suitable for Google Static Maps API.\n     *\n     * @param location - The location to format, can be either a string or an object with lat/lng properties\n     * @returns A string representation of the location in the format \"lat,lng\" or the original string\n     *\n     * @example\n     * // Returns \"40.714728,-73.998672\"\n     * formatLocation({ lat: 40.714728, lng: -73.998672 })\n     *\n     * @example\n     * // Returns \"New York, NY\"\n     * formatLocation(\"New York, NY\")\n     */\n    function formatLocation(location) {\n        return typeof location === 'string'\n            ? location\n            : `${location.lat},${location.lng}`;\n    }\n    // Used for removing the leading pipe from the param string\n    function formatParam(string) {\n        return string.slice(1);\n    }\n\n    /**\n     * Assembles marker parameters for static maps.\n     *\n     * This function takes an array of markers and groups them by their style properties.\n     * It then creates a string representation of these markers, including their styles and locations,\n     * which can be used as parameters for static map APIs.\n     *\n     * @param {StaticMapsMarker[]} [markers=[]] - An array of markers to be processed. Each marker can have properties such as color, label, size, scale, icon, anchor, and location.\n     * @returns {string[]} An array of strings, each representing a group of markers with their styles and locations.\n     *\n     * @example\n     * const markers = [\n     *   { color: 'blue', label: 'A', size: 'mid', location: '40.714728,-73.998672' },\n     *   { color: 'blue', label: 'B', size: 'mid', location: '40.714728,-73.998672' },\n     *   { icon: 'http://example.com/icon.png', location: { lat: 40.714728, lng: -73.998672 } }\n     * ];\n     * const params = assembleMarkerParams(markers);\n     * // Params will be an array of strings representing the marker parameters\n     * Example output: [\n     *   \"color:blue|label:A|size:mid|40.714728,-73.998672|40.714728,-73.998672\",\n     *   \"color:blue|label:B|size:mid|40.714728,-73.998672|40.714728,-73.998672\",\n     *   \"icon:http://example.com/icon.png|40.714728,-73.998672\"\n     * ]\n     */\n    function assembleMarkerParams(markers = []) {\n        const markerParams = [];\n        // Group markers by style\n        const markersByStyle = markers === null || markers === void 0 ? void 0 : markers.reduce((styles, marker) => {\n            const { color = 'red', label, size, scale, icon, anchor } = marker;\n            // Create a unique style key based on either icon properties or standard marker properties\n            const relevantProps = icon ? [icon, anchor, scale] : [color, label, size];\n            const key = relevantProps.filter(Boolean).join('-');\n            styles[key] = styles[key] || [];\n            styles[key].push(marker);\n            return styles;\n        }, {});\n        Object.values(markersByStyle !== null && markersByStyle !== void 0 ? markersByStyle : {}).forEach(markers => {\n            let markerParam = '';\n            const { icon } = markers[0];\n            // Create marker style from first marker in group since all markers share the same style.\n            Object.entries(markers[0]).forEach(([key, value]) => {\n                // Determine which properties to include based on whether marker uses custom icon\n                const relevantKeys = icon\n                    ? ['icon', 'anchor', 'scale']\n                    : ['color', 'label', 'size'];\n                if (relevantKeys.includes(key)) {\n                    markerParam += `|${key}:${value}`;\n                }\n            });\n            // Add location coordinates for each marker in the style group\n            // Handles both string locations and lat/lng object formats.\n            for (const marker of markers) {\n                const location = typeof marker.location === 'string'\n                    ? marker.location\n                    : `${marker.location.lat},${marker.location.lng}`;\n                markerParam += `|${location}`;\n            }\n            markerParams.push(markerParam);\n        });\n        return markerParams.map(formatParam);\n    }\n\n    // Style properties that can be applied to paths in the Static Maps API\n    const PATH_STYLE_KEYS = ['color', 'weight', 'fillcolor', 'geodesic'];\n    /**\n     * Builds the style portion of a path parameter string.\n     * @param path - The path object containing style properties\n     * @returns A string with style parameters in the format \"|key:value\"\n     */\n    function buildStyleParams(path) {\n        let styleParams = '';\n        PATH_STYLE_KEYS.forEach(key => {\n            if (path[key] !== undefined) {\n                styleParams += `|${key}:${path[key]}`;\n            }\n        });\n        return styleParams;\n    }\n    /**\n     * Builds the coordinates portion of a path parameter string.\n     * @param coordinates - Either a string or array of location objects\n     * @returns A string with coordinates in the format \"|lat,lng|lat,lng\"\n     */\n    function buildCoordinateParams(coordinates) {\n        if (typeof coordinates === 'string') {\n            return `|${decodeURIComponent(coordinates)}`;\n        }\n        return coordinates.map(location => `|${formatLocation(location)}`).join('');\n    }\n    /**\n     * Assembles path parameters for the Static Maps API from an array of paths.\n     *\n     * This function constructs a string of path parameters for each path. Each path parameter string\n     * includes the style properties and the coordinates of the paths.\n     *\n     * @param {Array<StaticMapsPath>} [paths=[]] - An array of paths to be assembled into path parameters.\n     * @returns {Array<string>} An array of path parameter strings.\n     *\n     * @example\n     * ```typescript\n     * const paths = [\n     *   {\n     *     color: 'red',\n     *     weight: 5,\n     *     coordinates: [\n     *       { lat: 40.714728, lng: -73.998672 },\n     *       { lat: 40.718217, lng: -73.998284 }\n     *     ]\n     *   }\n     * ];\n     *\n     * const pathParams = assemblePathParams(paths);\n     * // Output: ['color:red|weight:5|40.714728,-73.998672|40.718217,-73.998284']\n     * ```\n     */\n    function assemblePathParams(paths = []) {\n        return paths.map(path => {\n            const styleParams = buildStyleParams(path);\n            const coordinateParams = buildCoordinateParams(path.coordinates);\n            const pathParam = styleParams + coordinateParams;\n            return formatParam(pathParam);\n        });\n    }\n\n    /**\n     * Converts an array of Google Maps style objects into an array of style strings\n     * compatible with the Google Static Maps API.\n     *\n     * @param styles - An array of Google Maps MapTypeStyle objects that define the styling rules\n     * @returns An array of formatted style strings ready to be used with the Static Maps API\n     *\n     * @example\n     * const styles = [{\n     *   featureType: \"road\",\n     *   elementType: \"geometry\",\n     *   stylers: [{color: \"#ff0000\"}, {weight: 1}]\n     * }];\n     *\n     * const styleStrings = assembleMapTypeStyles(styles);\n     * // Returns: [\"|feature:road|element:geometry|color:0xff0000|weight:1\"]\n     *\n     * Each style string follows the format:\n     * \"feature:{featureType}|element:{elementType}|{stylerName}:{stylerValue}\"\n     *\n     * Note: Color values with hexadecimal notation (#) are automatically converted\n     * to the required 0x format for the Static Maps API.\n     */\n    function assembleMapTypeStyles(styles) {\n        return styles\n            .map((mapTypeStyle) => {\n            const { featureType, elementType, stylers = [] } = mapTypeStyle;\n            let styleString = '';\n            if (featureType) {\n                styleString += `|feature:${featureType}`;\n            }\n            if (elementType) {\n                styleString += `|element:${elementType}`;\n            }\n            for (const styler of stylers) {\n                Object.entries(styler).forEach(([name, value]) => {\n                    styleString += `|${name}:${String(value).replace('#', '0x')}`;\n                });\n            }\n            return styleString;\n        })\n            .map(formatParam);\n    }\n\n    const STATIC_MAPS_BASE = 'https://maps.googleapis.com/maps/api/staticmap';\n    /**\n     * Creates a URL for the Google Static Maps API with the specified parameters.\n     *\n     * @param {Object} options - The configuration options for the static map\n     * @param {string} options.apiKey - Your Google Maps API key (required)\n     * @param {number} options.width - The width of the map image in pixels (required)\n     * @param {number} options.height - The height of the map image in pixels (required)\n     * @param {StaticMapsLocation} [options.center] - The center point of the map (lat/lng or address).\n     *  Required if no markers or paths or \"visible locations\" are provided.\n     * @param {number} [options.zoom] - The zoom level of the map. Required if no markers or paths or \"visible locations\" are provided.\n     * @param {1|2|4} [options.scale] - The resolution of the map (1, 2, or 4)\n     * @param {string} [options.format] - The image format (png, png8, png32, gif, jpg, jpg-baseline)\n     * @param {string} [options.mapType] - The type of map (roadmap, satellite, terrain, hybrid)\n     * @param {string} [options.language] - The language of the map labels\n     * @param {string} [options.region] - The region code for the map\n     * @param {string} [options.map_id] - The Cloud-based map style ID\n     * @param {StaticMapsMarker[]} [options.markers=[]] - Array of markers to display on the map\n     * @param {StaticMapsPath[]} [options.paths=[]] - Array of paths to display on the map\n     * @param {StaticMapsLocation[]} [options.visible=[]] - Array of locations that should be visible on the map\n     * @param {MapTypeStyle[]} [options.style=[]] - Array of style objects to customize the map appearance\n     *\n     * @returns {string} The complete Google Static Maps API URL\n     *\n     * @throws {Error} If API key is not provided\n     * @throws {Error} If width or height is not provided\n     *\n     * @example\n     * const url = createStaticMapsUrl({\n     *   apiKey: 'YOUR_API_KEY',\n     *   width: 600,\n     *   height: 400,\n     *   center: { lat: 40.714728, lng: -73.998672 },\n     *   zoom: 12,\n     *   markers: [\n     *     {\n     *       location: { lat: 40.714728, lng: -73.998672 },\n     *       color: 'red',\n     *       label: 'A'\n     *     }\n     *   ],\n     *   paths: [\n     *     {\n     *       coordinates: [\n     *         { lat: 40.714728, lng: -73.998672 },\n     *         { lat: 40.719728, lng: -73.991672 }\n     *       ],\n     *       color: '0x0000ff',\n     *       weight: 5\n     *     }\n     *   ],\n     *   style: [\n     *     {\n     *       featureType: 'road',\n     *       elementType: 'geometry',\n     *       stylers: [{color: '#00ff00'}]\n     *     }\n     *   ]\n     * });\n     *\n     * // Results in URL similar to:\n     * // https://maps.googleapis.com/maps/api/staticmap?key=YOUR_API_KEY\n     * // &size=600x400\n     * // &center=40.714728,-73.998672&zoom=12\n     * // &markers=color:red|label:A|40.714728,-73.998672\n     * // &path=color:0x0000ff|weight:5|40.714728,-73.998672|40.719728,-73.991672\n     * // &style=feature:road|element:geometry|color:0x00ff00\n     */\n    function createStaticMapsUrl({ apiKey, width, height, center, zoom, scale, format, mapType, language, region, mapId, markers = [], paths = [], visible = [], style = [] }) {\n        if (!apiKey) {\n            console.warn('API key is required');\n        }\n        if (!width || !height) {\n            console.warn('Width and height are required');\n        }\n        const params = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ key: apiKey, size: `${width}x${height}` }, (center && { center: formatLocation(center) })), (zoom && { zoom })), (scale && { scale })), (format && { format })), (mapType && { maptype: mapType })), (language && { language })), (region && { region })), (mapId && { map_id: mapId }));\n        const url = new URL(STATIC_MAPS_BASE);\n        // Params that don't need special handling\n        Object.entries(params).forEach(([key, value]) => {\n            url.searchParams.append(key, String(value));\n        });\n        // Assemble Markers\n        for (const markerParam of assembleMarkerParams(markers)) {\n            url.searchParams.append('markers', markerParam);\n        }\n        // Assemble Paths\n        for (const pathParam of assemblePathParams(paths)) {\n            url.searchParams.append('path', pathParam);\n        }\n        // Assemble visible locations\n        if (visible.length) {\n            url.searchParams.append('visible', visible.map(location => formatLocation(location)).join('|'));\n        }\n        // Assemble Map Type Styles\n        for (const styleString of assembleMapTypeStyles(style)) {\n            url.searchParams.append('style', styleString);\n        }\n        return url.toString();\n    }\n\n    const StaticMap = (props) => {\n        const { url, className } = props;\n        if (!url)\n            throw new Error('URL is required');\n        return React.createElement(\"img\", { className: className, src: url, width: \"100%\" });\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     */\n    const 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    };\n    const MapControl = ({ children, position }) => {\n        const controlContainer = React.useMemo(() => document.createElement('div'), []);\n        const map = useMap();\n        React.useEffect(() => {\n            if (!map)\n                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)\n                    return;\n                const index = controlsArray.indexOf(controlContainer);\n                controls.removeAt(index);\n            };\n        }, [controlContainer, map, position]);\n        return reactDom.createPortal(children, controlContainer);\n    };\n\n    function useMarker(props) {\n        const [marker, setMarker] = React.useState(null);\n        const map = useMap();\n        const { onClick, onDrag, onDragStart, onDragEnd, onMouseOver, onMouseOut } = props, markerOptions = __rest(props, [\"onClick\", \"onDrag\", \"onDragStart\", \"onDragEnd\", \"onMouseOver\", \"onMouseOut\"]);\n        const { position, draggable } = markerOptions;\n        // create marker instance and add to the map once the map is available\n        React.useEffect(() => {\n            if (!map) {\n                if (map === undefined)\n                    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        React.useEffect(() => {\n            if (!marker)\n                return;\n            const m = marker;\n            // Add event listeners\n            const gme = google.maps.event;\n            if (onClick)\n                gme.addListener(m, 'click', onClick);\n            if (onDrag)\n                gme.addListener(m, 'drag', onDrag);\n            if (onDragStart)\n                gme.addListener(m, 'dragstart', onDragStart);\n            if (onDragEnd)\n                gme.addListener(m, 'dragend', onDragEnd);\n            if (onMouseOver)\n                gme.addListener(m, 'mouseover', onMouseOver);\n            if (onMouseOut)\n                gme.addListener(m, 'mouseout', onMouseOut);\n            marker.setDraggable(Boolean(draggable));\n            return () => {\n                gme.clearInstanceListeners(m);\n            };\n        }, [\n            marker,\n            draggable,\n            onClick,\n            onDrag,\n            onDragStart,\n            onDragEnd,\n            onMouseOver,\n            onMouseOut\n        ]);\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        React.useEffect(() => {\n            if (!marker)\n                return;\n            if (markerOptions)\n                marker.setOptions(markerOptions);\n        }, [marker, markerOptions]);\n        // update position when changed\n        React.useEffect(() => {\n            // Should not update position when draggable\n            if (draggable || !position || !marker)\n                return;\n            marker.setPosition(position);\n        }, [draggable, position, marker]);\n        return marker;\n    }\n    /**\n     * Component to render a marker on a map\n     */\n    const Marker = React.forwardRef((props, ref) => {\n        const marker = useMarker(props);\n        React.useImperativeHandle(ref, () => marker, [marker]);\n        return React.createElement(React.Fragment, null);\n    });\n    Marker.displayName = 'Marker';\n    function useMarkerRef() {\n        const [marker, setMarker] = React.useState(null);\n        const refCallback = React.useCallback((m) => {\n            setMarker(m);\n        }, []);\n        return [refCallback, marker];\n    }\n\n    /**\n     * Component to configure the appearance of an AdvancedMarker\n     */\n    const Pin = props => {\n        var _a;\n        const advancedMarker = (_a = React.useContext(AdvancedMarkerContext)) === null || _a === void 0 ? void 0 : _a.marker;\n        const glyphContainer = React.useMemo(() => document.createElement('div'), []);\n        // Create Pin View instance\n        React.useEffect(() => {\n            var _a;\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 (React.Children.count(props.children) > 1) {\n                logErrorOnce('Passing multiple children to the <Pin> component might lead to unexpected results.');\n            }\n            const pinViewOptions = Object.assign({}, 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) -> \"anchor container\"\n            const markerContent = (_a = advancedMarker.content) === null || _a === void 0 ? void 0 : _a.firstChild;\n            while (markerContent === null || markerContent === void 0 ? void 0 : markerContent.firstChild) {\n                markerContent.removeChild(markerContent.firstChild);\n            }\n            if (markerContent) {\n                markerContent.appendChild(pinElement.element);\n            }\n        }, [advancedMarker, glyphContainer, props]);\n        return reactDom.createPortal(props.children, glyphContainer);\n    };\n\n    const mapLinear = (x, a1, a2, b1, b2) => b1 + ((x - a1) * (b2 - b1)) / (a2 - a1);\n    const 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\n    const limitTiltRange = ({ viewState }) => {\n        const pitch = viewState.pitch;\n        const gmZoom = viewState.zoom + 1;\n        const maxTilt = getMapMaxTilt(gmZoom);\n        return Object.assign(Object.assign({}, viewState), { fovy: 25, pitch: Math.min(maxTilt, pitch) });\n    };\n\n    exports.APILoadingStatus = APILoadingStatus;\n    exports.APIProvider = APIProvider;\n    exports.APIProviderContext = APIProviderContext;\n    exports.AdvancedMarker = AdvancedMarker;\n    exports.AdvancedMarkerAnchorPoint = AdvancedMarkerAnchorPoint;\n    exports.AdvancedMarkerContext = AdvancedMarkerContext;\n    exports.CollisionBehavior = CollisionBehavior;\n    exports.ColorScheme = ColorScheme;\n    exports.ControlPosition = ControlPosition;\n    exports.GoogleMapsContext = GoogleMapsContext;\n    exports.InfoWindow = InfoWindow;\n    exports.Map = Map;\n    exports.MapControl = MapControl;\n    exports.Marker = Marker;\n    exports.Pin = Pin;\n    exports.RenderingType = RenderingType;\n    exports.StaticMap = StaticMap;\n    exports.VERSION = VERSION;\n    exports.createStaticMapsUrl = createStaticMapsUrl;\n    exports.isAdvancedMarker = isAdvancedMarker;\n    exports.isLatLngLiteral = isLatLngLiteral;\n    exports.latLngEquals = latLngEquals;\n    exports.limitTiltRange = limitTiltRange;\n    exports.toLatLngLiteral = toLatLngLiteral;\n    exports.useAdvancedMarkerRef = useAdvancedMarkerRef;\n    exports.useApiIsLoaded = useApiIsLoaded;\n    exports.useApiLoadingStatus = useApiLoadingStatus;\n    exports.useMap = useMap;\n    exports.useMapsLibrary = useMapsLibrary;\n    exports.useMarkerRef = useMarkerRef;\n\n}));\n\n"]}