react-three-map 0.8.2 → 1.0.0-next.0

package/dist/es/main33.mjs

@@ -0,0 +1,501 @@
+import { syncProjection, cloneTransform, applyViewStateToTransform, transformToViewState } from "./main41.mjs";
+import { normalizeStyle } from "./main42.mjs";
+import { deepEqual } from "./main38.mjs";
+const DEFAULT_STYLE = { version: 8, sources: {}, layers: [] };
+const pointerEvents = {
+  mousedown: "onMouseDown",
+  mouseup: "onMouseUp",
+  mouseover: "onMouseOver",
+  mousemove: "onMouseMove",
+  click: "onClick",
+  dblclick: "onDblClick",
+  mouseenter: "onMouseEnter",
+  mouseleave: "onMouseLeave",
+  mouseout: "onMouseOut",
+  contextmenu: "onContextMenu",
+  touchstart: "onTouchStart",
+  touchend: "onTouchEnd",
+  touchmove: "onTouchMove",
+  touchcancel: "onTouchCancel"
+};
+const cameraEvents = {
+  movestart: "onMoveStart",
+  move: "onMove",
+  moveend: "onMoveEnd",
+  dragstart: "onDragStart",
+  drag: "onDrag",
+  dragend: "onDragEnd",
+  zoomstart: "onZoomStart",
+  zoom: "onZoom",
+  zoomend: "onZoomEnd",
+  rotatestart: "onRotateStart",
+  rotate: "onRotate",
+  rotateend: "onRotateEnd",
+  pitchstart: "onPitchStart",
+  pitch: "onPitch",
+  pitchend: "onPitchEnd"
+};
+const otherEvents = {
+  wheel: "onWheel",
+  boxzoomstart: "onBoxZoomStart",
+  boxzoomend: "onBoxZoomEnd",
+  boxzoomcancel: "onBoxZoomCancel",
+  resize: "onResize",
+  load: "onLoad",
+  render: "onRender",
+  idle: "onIdle",
+  remove: "onRemove",
+  data: "onData",
+  styledata: "onStyleData",
+  sourcedata: "onSourceData",
+  error: "onError"
+};
+const settingNames = [
+  "minZoom",
+  "maxZoom",
+  "minPitch",
+  "maxPitch",
+  "maxBounds",
+  "projection",
+  "renderWorldCopies"
+];
+const handlerNames = [
+  "scrollZoom",
+  "boxZoom",
+  "dragRotate",
+  "dragPan",
+  "keyboard",
+  "doubleClickZoom",
+  "touchZoomRotate",
+  "touchPitch"
+];
+class Mapbox {
+  constructor(MapClass, props, container) {
+    this._map = null;
+    this._internalUpdate = false;
+    this._inRender = false;
+    this._hoveredFeatures = null;
+    this._deferredEvents = {
+      move: false,
+      zoom: false,
+      pitch: false,
+      rotate: false
+    };
+    this._onEvent = (e) => {
+      const cb = this.props[otherEvents[e.type]];
+      if (cb) {
+        cb(e);
+      } else if (e.type === "error") {
+        console.error(e.error);
+      }
+    };
+    this._onPointerEvent = (e) => {
+      if (e.type === "mousemove" || e.type === "mouseout") {
+        this._updateHover(e);
+      }
+      const cb = this.props[pointerEvents[e.type]];
+      if (cb) {
+        if (this.props.interactiveLayerIds && e.type !== "mouseover" && e.type !== "mouseout") {
+          e.features = this._hoveredFeatures || this._queryRenderedFeatures(e.point);
+        }
+        cb(e);
+        delete e.features;
+      }
+    };
+    this._onCameraEvent = (e) => {
+      if (!this._internalUpdate) {
+        const cb = this.props[cameraEvents[e.type]];
+        if (cb) {
+          cb(e);
+        }
+      }
+      if (e.type in this._deferredEvents) {
+        this._deferredEvents[e.type] = false;
+      }
+    };
+    this._MapClass = MapClass;
+    this.props = props;
+    this._initialize(container);
+  }
+  get map() {
+    return this._map;
+  }
+  get transform() {
+    return this._renderTransform;
+  }
+  setProps(props) {
+    const oldProps = this.props;
+    this.props = props;
+    const settingsChanged = this._updateSettings(props, oldProps);
+    if (settingsChanged) {
+      this._createShadowTransform(this._map);
+    }
+    const sizeChanged = this._updateSize(props);
+    const viewStateChanged = this._updateViewState(props, true);
+    this._updateStyle(props, oldProps);
+    this._updateStyleComponents(props, oldProps);
+    this._updateHandlers(props, oldProps);
+    if (settingsChanged || sizeChanged || viewStateChanged && !this._map.isMoving()) {
+      this.redraw();
+    }
+  }
+  static reuse(props, container) {
+    const that = Mapbox.savedMaps.pop();
+    if (!that) {
+      return null;
+    }
+    const map = that.map;
+    const oldContainer = map.getContainer();
+    container.className = oldContainer.className;
+    while (oldContainer.childNodes.length > 0) {
+      container.appendChild(oldContainer.childNodes[0]);
+    }
+    map._container = container;
+    that.setProps({ ...props, styleDiffing: false });
+    map.resize();
+    const { initialViewState } = props;
+    if (initialViewState) {
+      if (initialViewState.bounds) {
+        map.fitBounds(initialViewState.bounds, { ...initialViewState.fitBoundsOptions, duration: 0 });
+      } else {
+        that._updateViewState(initialViewState, false);
+      }
+    }
+    if (map.isStyleLoaded()) {
+      map.fire("load");
+    } else {
+      map.once("styledata", () => map.fire("load"));
+    }
+    map._update();
+    return that;
+  }
+  /* eslint-disable complexity,max-statements */
+  _initialize(container) {
+    const { props } = this;
+    const { mapStyle = DEFAULT_STYLE } = props;
+    const mapOptions = {
+      ...props,
+      ...props.initialViewState,
+      accessToken: props.mapboxAccessToken || getAccessTokenFromEnv() || null,
+      container,
+      style: normalizeStyle(mapStyle)
+    };
+    const viewState = mapOptions.initialViewState || mapOptions.viewState || mapOptions;
+    Object.assign(mapOptions, {
+      center: [viewState.longitude || 0, viewState.latitude || 0],
+      zoom: viewState.zoom || 0,
+      pitch: viewState.pitch || 0,
+      bearing: viewState.bearing || 0
+    });
+    if (props.gl) {
+      const getContext = HTMLCanvasElement.prototype.getContext;
+      HTMLCanvasElement.prototype.getContext = () => {
+        HTMLCanvasElement.prototype.getContext = getContext;
+        return props.gl;
+      };
+    }
+    const map = new this._MapClass(mapOptions);
+    if (viewState.padding) {
+      map.setPadding(viewState.padding);
+    }
+    if (props.cursor) {
+      map.getCanvas().style.cursor = props.cursor;
+    }
+    this._createShadowTransform(map);
+    const renderMap = map._render;
+    map._render = (arg) => {
+      this._inRender = true;
+      renderMap.call(map, arg);
+      this._inRender = false;
+    };
+    const runRenderTaskQueue = map._renderTaskQueue.run;
+    map._renderTaskQueue.run = (arg) => {
+      runRenderTaskQueue.call(map._renderTaskQueue, arg);
+      this._onBeforeRepaint();
+    };
+    map.on("render", () => this._onAfterRepaint());
+    const fireEvent = map.fire;
+    map.fire = this._fireEvent.bind(this, fireEvent);
+    map.on("resize", () => {
+      this._renderTransform.resize(map.transform.width, map.transform.height);
+    });
+    map.on("styledata", () => {
+      this._updateStyleComponents(this.props, {});
+      syncProjection(map.transform, this._renderTransform);
+    });
+    map.on("sourcedata", () => this._updateStyleComponents(this.props, {}));
+    for (const eventName in pointerEvents) {
+      map.on(eventName, this._onPointerEvent);
+    }
+    for (const eventName in cameraEvents) {
+      map.on(eventName, this._onCameraEvent);
+    }
+    for (const eventName in otherEvents) {
+      map.on(eventName, this._onEvent);
+    }
+    this._map = map;
+  }
+  /* eslint-enable complexity,max-statements */
+  recycle() {
+    const container = this.map.getContainer();
+    const children = container.querySelector("[mapboxgl-children]");
+    children == null ? void 0 : children.remove();
+    Mapbox.savedMaps.push(this);
+  }
+  destroy() {
+    this._map.remove();
+  }
+  // Force redraw the map now. Typically resize() and jumpTo() is reflected in the next
+  // render cycle, which is managed by Mapbox's animation loop.
+  // This removes the synchronization issue caused by requestAnimationFrame.
+  redraw() {
+    const map = this._map;
+    if (!this._inRender && map.style) {
+      if (map._frame) {
+        map._frame.cancel();
+        map._frame = null;
+      }
+      map._render();
+    }
+  }
+  _createShadowTransform(map) {
+    const renderTransform = cloneTransform(map.transform);
+    map.painter.transform = renderTransform;
+    this._renderTransform = renderTransform;
+  }
+  /* Trigger map resize if size is controlled
+     @param {object} nextProps
+     @returns {bool} true if size has changed
+   */
+  _updateSize(nextProps) {
+    const { viewState } = nextProps;
+    if (viewState) {
+      const map = this._map;
+      if (viewState.width !== map.transform.width || viewState.height !== map.transform.height) {
+        map.resize();
+        return true;
+      }
+    }
+    return false;
+  }
+  // Adapted from map.jumpTo
+  /* Update camera to match props
+     @param {object} nextProps
+     @param {bool} triggerEvents - should fire camera events
+     @returns {bool} true if anything is changed
+   */
+  _updateViewState(nextProps, triggerEvents) {
+    if (this._internalUpdate) {
+      return false;
+    }
+    const map = this._map;
+    const tr = this._renderTransform;
+    const { zoom, pitch, bearing } = tr;
+    const isMoving = map.isMoving();
+    if (isMoving) {
+      tr.cameraElevationReference = "sea";
+    }
+    const changed = applyViewStateToTransform(tr, {
+      ...transformToViewState(map.transform),
+      ...nextProps
+    });
+    if (isMoving) {
+      tr.cameraElevationReference = "ground";
+    }
+    if (changed && triggerEvents) {
+      const deferredEvents = this._deferredEvents;
+      deferredEvents.move = true;
+      deferredEvents.zoom || (deferredEvents.zoom = zoom !== tr.zoom);
+      deferredEvents.rotate || (deferredEvents.rotate = bearing !== tr.bearing);
+      deferredEvents.pitch || (deferredEvents.pitch = pitch !== tr.pitch);
+    }
+    if (!isMoving) {
+      applyViewStateToTransform(map.transform, nextProps);
+    }
+    return changed;
+  }
+  /* Update camera constraints and projection settings to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateSettings(nextProps, currProps) {
+    const map = this._map;
+    let changed = false;
+    for (const propName of settingNames) {
+      if (propName in nextProps && !deepEqual(nextProps[propName], currProps[propName])) {
+        changed = true;
+        const setter = map[`set${propName[0].toUpperCase()}${propName.slice(1)}`];
+        setter == null ? void 0 : setter.call(map, nextProps[propName]);
+      }
+    }
+    return changed;
+  }
+  /* Update map style to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if style is changed
+   */
+  _updateStyle(nextProps, currProps) {
+    if (nextProps.cursor !== currProps.cursor) {
+      this._map.getCanvas().style.cursor = nextProps.cursor || "";
+    }
+    if (nextProps.mapStyle !== currProps.mapStyle) {
+      const { mapStyle = DEFAULT_STYLE, styleDiffing = true } = nextProps;
+      const options = {
+        diff: styleDiffing
+      };
+      if ("localIdeographFontFamily" in nextProps) {
+        options.localIdeographFontFamily = nextProps.localIdeographFontFamily;
+      }
+      this._map.setStyle(normalizeStyle(mapStyle), options);
+      return true;
+    }
+    return false;
+  }
+  /* Update fog, light and terrain to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateStyleComponents(nextProps, currProps) {
+    const map = this._map;
+    let changed = false;
+    if (map.isStyleLoaded()) {
+      if ("light" in nextProps && map.setLight && !deepEqual(nextProps.light, currProps.light)) {
+        changed = true;
+        map.setLight(nextProps.light);
+      }
+      if ("fog" in nextProps && map.setFog && !deepEqual(nextProps.fog, currProps.fog)) {
+        changed = true;
+        map.setFog(nextProps.fog);
+      }
+      if ("terrain" in nextProps && map.setTerrain && !deepEqual(nextProps.terrain, currProps.terrain)) {
+        if (!nextProps.terrain || map.getSource(nextProps.terrain.source)) {
+          changed = true;
+          map.setTerrain(nextProps.terrain);
+        }
+      }
+    }
+    return changed;
+  }
+  /* Update interaction handlers to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateHandlers(nextProps, currProps) {
+    const map = this._map;
+    let changed = false;
+    for (const propName of handlerNames) {
+      const newValue = nextProps[propName] ?? true;
+      const oldValue = currProps[propName] ?? true;
+      if (!deepEqual(newValue, oldValue)) {
+        changed = true;
+        if (newValue) {
+          map[propName].enable(newValue);
+        } else {
+          map[propName].disable();
+        }
+      }
+    }
+    return changed;
+  }
+  _queryRenderedFeatures(point) {
+    const map = this._map;
+    const tr = map.transform;
+    const { interactiveLayerIds = [] } = this.props;
+    try {
+      map.transform = this._renderTransform;
+      return map.queryRenderedFeatures(point, {
+        layers: interactiveLayerIds.filter(map.getLayer.bind(map))
+      });
+    } catch {
+      return [];
+    } finally {
+      map.transform = tr;
+    }
+  }
+  _updateHover(e) {
+    var _a;
+    const { props } = this;
+    const shouldTrackHoveredFeatures = props.interactiveLayerIds && (props.onMouseMove || props.onMouseEnter || props.onMouseLeave);
+    if (shouldTrackHoveredFeatures) {
+      const eventType = e.type;
+      const wasHovering = ((_a = this._hoveredFeatures) == null ? void 0 : _a.length) > 0;
+      const features = this._queryRenderedFeatures(e.point);
+      const isHovering = features.length > 0;
+      if (!isHovering && wasHovering) {
+        e.type = "mouseleave";
+        this._onPointerEvent(e);
+      }
+      this._hoveredFeatures = features;
+      if (isHovering && !wasHovering) {
+        e.type = "mouseenter";
+        this._onPointerEvent(e);
+      }
+      e.type = eventType;
+    } else {
+      this._hoveredFeatures = null;
+    }
+  }
+  _fireEvent(baseFire, event, properties) {
+    const map = this._map;
+    const tr = map.transform;
+    const eventType = typeof event === "string" ? event : event.type;
+    if (eventType === "move") {
+      this._updateViewState(this.props, false);
+    }
+    if (eventType in cameraEvents) {
+      if (typeof event === "object") {
+        event.viewState = transformToViewState(tr);
+      }
+      if (this._map.isMoving()) {
+        map.transform = this._renderTransform;
+        baseFire.call(map, event, properties);
+        map.transform = tr;
+        return map;
+      }
+    }
+    baseFire.call(map, event, properties);
+    return map;
+  }
+  // All camera manipulations are complete, ready to repaint
+  _onBeforeRepaint() {
+    const map = this._map;
+    this._internalUpdate = true;
+    for (const eventType in this._deferredEvents) {
+      if (this._deferredEvents[eventType]) {
+        map.fire(eventType);
+      }
+    }
+    this._internalUpdate = false;
+    const tr = this._map.transform;
+    map.transform = this._renderTransform;
+    this._onAfterRepaint = () => {
+      syncProjection(this._renderTransform, tr);
+      map.transform = tr;
+    };
+  }
+}
+Mapbox.savedMaps = [];
+function getAccessTokenFromEnv() {
+  let accessToken = null;
+  if (typeof location !== "undefined") {
+    const match = /access_token=([^&\/]*)/.exec(location.search);
+    accessToken = match && match[1];
+  }
+  try {
+    accessToken = accessToken || process.env.MapboxAccessToken;
+  } catch {
+  }
+  try {
+    accessToken = accessToken || process.env.REACT_APP_MAPBOX_ACCESS_TOKEN;
+  } catch {
+  }
+  return accessToken;
+}
+export {
+  Mapbox as default
+};
+//# sourceMappingURL=main33.mjs.map

package/dist/es/main33.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main33.mjs","sources":["../../node_modules/@vis.gl/react-mapbox/dist/mapbox/mapbox.js"],"sourcesContent":["import { transformToViewState, applyViewStateToTransform, cloneTransform, syncProjection } from \"../utils/transform.js\";\nimport { normalizeStyle } from \"../utils/style-utils.js\";\nimport { deepEqual } from \"../utils/deep-equal.js\";\nconst DEFAULT_STYLE = { version: 8, sources: {}, layers: [] };\nconst pointerEvents = {\n    mousedown: 'onMouseDown',\n    mouseup: 'onMouseUp',\n    mouseover: 'onMouseOver',\n    mousemove: 'onMouseMove',\n    click: 'onClick',\n    dblclick: 'onDblClick',\n    mouseenter: 'onMouseEnter',\n    mouseleave: 'onMouseLeave',\n    mouseout: 'onMouseOut',\n    contextmenu: 'onContextMenu',\n    touchstart: 'onTouchStart',\n    touchend: 'onTouchEnd',\n    touchmove: 'onTouchMove',\n    touchcancel: 'onTouchCancel'\n};\nconst cameraEvents = {\n    movestart: 'onMoveStart',\n    move: 'onMove',\n    moveend: 'onMoveEnd',\n    dragstart: 'onDragStart',\n    drag: 'onDrag',\n    dragend: 'onDragEnd',\n    zoomstart: 'onZoomStart',\n    zoom: 'onZoom',\n    zoomend: 'onZoomEnd',\n    rotatestart: 'onRotateStart',\n    rotate: 'onRotate',\n    rotateend: 'onRotateEnd',\n    pitchstart: 'onPitchStart',\n    pitch: 'onPitch',\n    pitchend: 'onPitchEnd'\n};\nconst otherEvents = {\n    wheel: 'onWheel',\n    boxzoomstart: 'onBoxZoomStart',\n    boxzoomend: 'onBoxZoomEnd',\n    boxzoomcancel: 'onBoxZoomCancel',\n    resize: 'onResize',\n    load: 'onLoad',\n    render: 'onRender',\n    idle: 'onIdle',\n    remove: 'onRemove',\n    data: 'onData',\n    styledata: 'onStyleData',\n    sourcedata: 'onSourceData',\n    error: 'onError'\n};\nconst settingNames = [\n    'minZoom',\n    'maxZoom',\n    'minPitch',\n    'maxPitch',\n    'maxBounds',\n    'projection',\n    'renderWorldCopies'\n];\nconst handlerNames = [\n    'scrollZoom',\n    'boxZoom',\n    'dragRotate',\n    'dragPan',\n    'keyboard',\n    'doubleClickZoom',\n    'touchZoomRotate',\n    'touchPitch'\n];\n/**\n * A wrapper for mapbox-gl's Map class\n */\nclass Mapbox {\n    constructor(MapClass, props, container) {\n        // mapboxgl.Map instance\n        this._map = null;\n        // Internal states\n        this._internalUpdate = false;\n        this._inRender = false;\n        this._hoveredFeatures = null;\n        this._deferredEvents = {\n            move: false,\n            zoom: false,\n            pitch: false,\n            rotate: false\n        };\n        this._onEvent = (e) => {\n            // @ts-ignore\n            const cb = this.props[otherEvents[e.type]];\n            if (cb) {\n                cb(e);\n            }\n            else if (e.type === 'error') {\n                console.error(e.error); // eslint-disable-line\n            }\n        };\n        this._onPointerEvent = (e) => {\n            if (e.type === 'mousemove' || e.type === 'mouseout') {\n                this._updateHover(e);\n            }\n            // @ts-ignore\n            const cb = this.props[pointerEvents[e.type]];\n            if (cb) {\n                if (this.props.interactiveLayerIds && e.type !== 'mouseover' && e.type !== 'mouseout') {\n                    e.features = this._hoveredFeatures || this._queryRenderedFeatures(e.point);\n                }\n                cb(e);\n                delete e.features;\n            }\n        };\n        this._onCameraEvent = (e) => {\n            if (!this._internalUpdate) {\n                // @ts-ignore\n                const cb = this.props[cameraEvents[e.type]];\n                if (cb) {\n                    cb(e);\n                }\n            }\n            if (e.type in this._deferredEvents) {\n                this._deferredEvents[e.type] = false;\n            }\n        };\n        this._MapClass = MapClass;\n        this.props = props;\n        this._initialize(container);\n    }\n    get map() {\n        return this._map;\n    }\n    get transform() {\n        return this._renderTransform;\n    }\n    setProps(props) {\n        const oldProps = this.props;\n        this.props = props;\n        const settingsChanged = this._updateSettings(props, oldProps);\n        if (settingsChanged) {\n            this._createShadowTransform(this._map);\n        }\n        const sizeChanged = this._updateSize(props);\n        const viewStateChanged = this._updateViewState(props, true);\n        this._updateStyle(props, oldProps);\n        this._updateStyleComponents(props, oldProps);\n        this._updateHandlers(props, oldProps);\n        // If 1) view state has changed to match props and\n        //    2) the props change is not triggered by map events,\n        // it's driven by an external state change. Redraw immediately\n        if (settingsChanged || sizeChanged || (viewStateChanged && !this._map.isMoving())) {\n            this.redraw();\n        }\n    }\n    static reuse(props, container) {\n        const that = Mapbox.savedMaps.pop();\n        if (!that) {\n            return null;\n        }\n        const map = that.map;\n        // When reusing the saved map, we need to reparent the map(canvas) and other child nodes\n        // intoto the new container from the props.\n        // Step 1: reparenting child nodes from old container to new container\n        const oldContainer = map.getContainer();\n        container.className = oldContainer.className;\n        while (oldContainer.childNodes.length > 0) {\n            container.appendChild(oldContainer.childNodes[0]);\n        }\n        // Step 2: replace the internal container with new container from the react component\n        // @ts-ignore\n        map._container = container;\n        // Step 4: apply new props\n        that.setProps({ ...props, styleDiffing: false });\n        map.resize();\n        const { initialViewState } = props;\n        if (initialViewState) {\n            if (initialViewState.bounds) {\n                map.fitBounds(initialViewState.bounds, { ...initialViewState.fitBoundsOptions, duration: 0 });\n            }\n            else {\n                that._updateViewState(initialViewState, false);\n            }\n        }\n        // Simulate load event\n        if (map.isStyleLoaded()) {\n            map.fire('load');\n        }\n        else {\n            map.once('styledata', () => map.fire('load'));\n        }\n        // Force reload\n        // @ts-ignore\n        map._update();\n        return that;\n    }\n    /* eslint-disable complexity,max-statements */\n    _initialize(container) {\n        const { props } = this;\n        const { mapStyle = DEFAULT_STYLE } = props;\n        const mapOptions = {\n            ...props,\n            ...props.initialViewState,\n            accessToken: props.mapboxAccessToken || getAccessTokenFromEnv() || null,\n            container,\n            style: normalizeStyle(mapStyle)\n        };\n        const viewState = mapOptions.initialViewState || mapOptions.viewState || mapOptions;\n        Object.assign(mapOptions, {\n            center: [viewState.longitude || 0, viewState.latitude || 0],\n            zoom: viewState.zoom || 0,\n            pitch: viewState.pitch || 0,\n            bearing: viewState.bearing || 0\n        });\n        if (props.gl) {\n            // eslint-disable-next-line\n            const getContext = HTMLCanvasElement.prototype.getContext;\n            // Hijack canvas.getContext to return our own WebGLContext\n            // This will be called inside the mapboxgl.Map constructor\n            // @ts-expect-error\n            HTMLCanvasElement.prototype.getContext = () => {\n                // Unhijack immediately\n                HTMLCanvasElement.prototype.getContext = getContext;\n                return props.gl;\n            };\n        }\n        const map = new this._MapClass(mapOptions);\n        // Props that are not part of constructor options\n        if (viewState.padding) {\n            map.setPadding(viewState.padding);\n        }\n        if (props.cursor) {\n            map.getCanvas().style.cursor = props.cursor;\n        }\n        this._createShadowTransform(map);\n        // Hack\n        // Insert code into map's render cycle\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        const renderMap = map._render;\n        map._render = (arg) => {\n            this._inRender = true;\n            renderMap.call(map, arg);\n            this._inRender = false;\n        };\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        const runRenderTaskQueue = map._renderTaskQueue.run;\n        map._renderTaskQueue.run = (arg) => {\n            runRenderTaskQueue.call(map._renderTaskQueue, arg);\n            this._onBeforeRepaint();\n        };\n        map.on('render', () => this._onAfterRepaint());\n        // Insert code into map's event pipeline\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        const fireEvent = map.fire;\n        map.fire = this._fireEvent.bind(this, fireEvent);\n        // add listeners\n        map.on('resize', () => {\n            this._renderTransform.resize(map.transform.width, map.transform.height);\n        });\n        map.on('styledata', () => {\n            this._updateStyleComponents(this.props, {});\n            // Projection can be set in stylesheet\n            syncProjection(map.transform, this._renderTransform);\n        });\n        map.on('sourcedata', () => this._updateStyleComponents(this.props, {}));\n        for (const eventName in pointerEvents) {\n            map.on(eventName, this._onPointerEvent);\n        }\n        for (const eventName in cameraEvents) {\n            map.on(eventName, this._onCameraEvent);\n        }\n        for (const eventName in otherEvents) {\n            map.on(eventName, this._onEvent);\n        }\n        this._map = map;\n    }\n    /* eslint-enable complexity,max-statements */\n    recycle() {\n        // Clean up unnecessary elements before storing for reuse.\n        const container = this.map.getContainer();\n        const children = container.querySelector('[mapboxgl-children]');\n        children?.remove();\n        Mapbox.savedMaps.push(this);\n    }\n    destroy() {\n        this._map.remove();\n    }\n    // Force redraw the map now. Typically resize() and jumpTo() is reflected in the next\n    // render cycle, which is managed by Mapbox's animation loop.\n    // This removes the synchronization issue caused by requestAnimationFrame.\n    redraw() {\n        const map = this._map;\n        // map._render will throw error if style does not exist\n        // https://github.com/mapbox/mapbox-gl-js/blob/fb9fc316da14e99ff4368f3e4faa3888fb43c513\n        //   /src/ui/map.js#L1834\n        if (!this._inRender && map.style) {\n            // cancel the scheduled update\n            if (map._frame) {\n                map._frame.cancel();\n                map._frame = null;\n            }\n            // the order is important - render() may schedule another update\n            map._render();\n        }\n    }\n    _createShadowTransform(map) {\n        const renderTransform = cloneTransform(map.transform);\n        map.painter.transform = renderTransform;\n        this._renderTransform = renderTransform;\n    }\n    /* Trigger map resize if size is controlled\n       @param {object} nextProps\n       @returns {bool} true if size has changed\n     */\n    _updateSize(nextProps) {\n        // Check if size is controlled\n        const { viewState } = nextProps;\n        if (viewState) {\n            const map = this._map;\n            if (viewState.width !== map.transform.width || viewState.height !== map.transform.height) {\n                map.resize();\n                return true;\n            }\n        }\n        return false;\n    }\n    // Adapted from map.jumpTo\n    /* Update camera to match props\n       @param {object} nextProps\n       @param {bool} triggerEvents - should fire camera events\n       @returns {bool} true if anything is changed\n     */\n    _updateViewState(nextProps, triggerEvents) {\n        if (this._internalUpdate) {\n            return false;\n        }\n        const map = this._map;\n        const tr = this._renderTransform;\n        // Take a snapshot of the transform before mutation\n        const { zoom, pitch, bearing } = tr;\n        const isMoving = map.isMoving();\n        if (isMoving) {\n            // All movement of the camera is done relative to the sea level\n            tr.cameraElevationReference = 'sea';\n        }\n        const changed = applyViewStateToTransform(tr, {\n            ...transformToViewState(map.transform),\n            ...nextProps\n        });\n        if (isMoving) {\n            // Reset camera reference\n            tr.cameraElevationReference = 'ground';\n        }\n        if (changed && triggerEvents) {\n            const deferredEvents = this._deferredEvents;\n            // Delay DOM control updates to the next render cycle\n            deferredEvents.move = true;\n            deferredEvents.zoom || (deferredEvents.zoom = zoom !== tr.zoom);\n            deferredEvents.rotate || (deferredEvents.rotate = bearing !== tr.bearing);\n            deferredEvents.pitch || (deferredEvents.pitch = pitch !== tr.pitch);\n        }\n        // Avoid manipulating the real transform when interaction/animation is ongoing\n        // as it would interfere with Mapbox's handlers\n        if (!isMoving) {\n            applyViewStateToTransform(map.transform, nextProps);\n        }\n        return changed;\n    }\n    /* Update camera constraints and projection settings to match props\n       @param {object} nextProps\n       @param {object} currProps\n       @returns {bool} true if anything is changed\n     */\n    _updateSettings(nextProps, currProps) {\n        const map = this._map;\n        let changed = false;\n        for (const propName of settingNames) {\n            if (propName in nextProps && !deepEqual(nextProps[propName], currProps[propName])) {\n                changed = true;\n                const setter = map[`set${propName[0].toUpperCase()}${propName.slice(1)}`];\n                setter?.call(map, nextProps[propName]);\n            }\n        }\n        return changed;\n    }\n    /* Update map style to match props\n       @param {object} nextProps\n       @param {object} currProps\n       @returns {bool} true if style is changed\n     */\n    _updateStyle(nextProps, currProps) {\n        if (nextProps.cursor !== currProps.cursor) {\n            this._map.getCanvas().style.cursor = nextProps.cursor || '';\n        }\n        if (nextProps.mapStyle !== currProps.mapStyle) {\n            const { mapStyle = DEFAULT_STYLE, styleDiffing = true } = nextProps;\n            const options = {\n                diff: styleDiffing\n            };\n            if ('localIdeographFontFamily' in nextProps) {\n                // @ts-ignore Mapbox specific prop\n                options.localIdeographFontFamily = nextProps.localIdeographFontFamily;\n            }\n            this._map.setStyle(normalizeStyle(mapStyle), options);\n            return true;\n        }\n        return false;\n    }\n    /* Update fog, light and terrain to match props\n       @param {object} nextProps\n       @param {object} currProps\n       @returns {bool} true if anything is changed\n     */\n    _updateStyleComponents(nextProps, currProps) {\n        const map = this._map;\n        let changed = false;\n        if (map.isStyleLoaded()) {\n            if ('light' in nextProps && map.setLight && !deepEqual(nextProps.light, currProps.light)) {\n                changed = true;\n                map.setLight(nextProps.light);\n            }\n            if ('fog' in nextProps && map.setFog && !deepEqual(nextProps.fog, currProps.fog)) {\n                changed = true;\n                map.setFog(nextProps.fog);\n            }\n            if ('terrain' in nextProps &&\n                map.setTerrain &&\n                !deepEqual(nextProps.terrain, currProps.terrain)) {\n                if (!nextProps.terrain || map.getSource(nextProps.terrain.source)) {\n                    changed = true;\n                    map.setTerrain(nextProps.terrain);\n                }\n            }\n        }\n        return changed;\n    }\n    /* Update interaction handlers to match props\n       @param {object} nextProps\n       @param {object} currProps\n       @returns {bool} true if anything is changed\n     */\n    _updateHandlers(nextProps, currProps) {\n        const map = this._map;\n        let changed = false;\n        for (const propName of handlerNames) {\n            const newValue = nextProps[propName] ?? true;\n            const oldValue = currProps[propName] ?? true;\n            if (!deepEqual(newValue, oldValue)) {\n                changed = true;\n                if (newValue) {\n                    map[propName].enable(newValue);\n                }\n                else {\n                    map[propName].disable();\n                }\n            }\n        }\n        return changed;\n    }\n    _queryRenderedFeatures(point) {\n        const map = this._map;\n        const tr = map.transform;\n        const { interactiveLayerIds = [] } = this.props;\n        try {\n            map.transform = this._renderTransform;\n            return map.queryRenderedFeatures(point, {\n                layers: interactiveLayerIds.filter(map.getLayer.bind(map))\n            });\n        }\n        catch {\n            // May fail if style is not loaded\n            return [];\n        }\n        finally {\n            map.transform = tr;\n        }\n    }\n    _updateHover(e) {\n        const { props } = this;\n        const shouldTrackHoveredFeatures = props.interactiveLayerIds && (props.onMouseMove || props.onMouseEnter || props.onMouseLeave);\n        if (shouldTrackHoveredFeatures) {\n            const eventType = e.type;\n            const wasHovering = this._hoveredFeatures?.length > 0;\n            const features = this._queryRenderedFeatures(e.point);\n            const isHovering = features.length > 0;\n            if (!isHovering && wasHovering) {\n                e.type = 'mouseleave';\n                this._onPointerEvent(e);\n            }\n            this._hoveredFeatures = features;\n            if (isHovering && !wasHovering) {\n                e.type = 'mouseenter';\n                this._onPointerEvent(e);\n            }\n            e.type = eventType;\n        }\n        else {\n            this._hoveredFeatures = null;\n        }\n    }\n    _fireEvent(baseFire, event, properties) {\n        const map = this._map;\n        const tr = map.transform;\n        const eventType = typeof event === 'string' ? event : event.type;\n        if (eventType === 'move') {\n            this._updateViewState(this.props, false);\n        }\n        if (eventType in cameraEvents) {\n            if (typeof event === 'object') {\n                event.viewState = transformToViewState(tr);\n            }\n            if (this._map.isMoving()) {\n                // Replace map.transform with ours during the callbacks\n                map.transform = this._renderTransform;\n                baseFire.call(map, event, properties);\n                map.transform = tr;\n                return map;\n            }\n        }\n        baseFire.call(map, event, properties);\n        return map;\n    }\n    // All camera manipulations are complete, ready to repaint\n    _onBeforeRepaint() {\n        const map = this._map;\n        // If there are camera changes driven by props, invoke camera events so that DOM controls are synced\n        this._internalUpdate = true;\n        for (const eventType in this._deferredEvents) {\n            if (this._deferredEvents[eventType]) {\n                map.fire(eventType);\n            }\n        }\n        this._internalUpdate = false;\n        const tr = this._map.transform;\n        // Make sure camera matches the current props\n        map.transform = this._renderTransform;\n        this._onAfterRepaint = () => {\n            // Mapbox transitions between non-mercator projection and mercator during render time\n            // Copy it back to the other\n            syncProjection(this._renderTransform, tr);\n            // Restores camera state before render/load events are fired\n            map.transform = tr;\n        };\n    }\n}\nMapbox.savedMaps = [];\nexport default Mapbox;\n/**\n * Access token can be provided via one of:\n *   mapboxAccessToken prop\n *   access_token query parameter\n *   MapboxAccessToken environment variable\n *   REACT_APP_MAPBOX_ACCESS_TOKEN environment variable\n * @returns access token\n */\nfunction getAccessTokenFromEnv() {\n    let accessToken = null;\n    /* global location, process */\n    if (typeof location !== 'undefined') {\n        const match = /access_token=([^&\\/]*)/.exec(location.search);\n        accessToken = match && match[1];\n    }\n    // Note: This depends on bundler plugins (e.g. webpack) importing environment correctly\n    try {\n        // eslint-disable-next-line no-process-env\n        accessToken = accessToken || process.env.MapboxAccessToken;\n    }\n    catch {\n        // ignore\n    }\n    try {\n        // eslint-disable-next-line no-process-env\n        accessToken = accessToken || process.env.REACT_APP_MAPBOX_ACCESS_TOKEN;\n    }\n    catch {\n        // ignore\n    }\n    return accessToken;\n}\n//# sourceMappingURL=mapbox.js.map"],"names":[],"mappings":";;;AAGA,MAAM,gBAAgB,EAAE,SAAS,GAAG,SAAS,IAAI,QAAQ,CAAA;AACzD,MAAM,gBAAgB;AAAA,EAClB,WAAW;AAAA,EACX,SAAS;AAAA,EACT,WAAW;AAAA,EACX,WAAW;AAAA,EACX,OAAO;AAAA,EACP,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,WAAW;AAAA,EACX,aAAa;AACjB;AACA,MAAM,eAAe;AAAA,EACjB,WAAW;AAAA,EACX,MAAM;AAAA,EACN,SAAS;AAAA,EACT,WAAW;AAAA,EACX,MAAM;AAAA,EACN,SAAS;AAAA,EACT,WAAW;AAAA,EACX,MAAM;AAAA,EACN,SAAS;AAAA,EACT,aAAa;AAAA,EACb,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,UAAU;AACd;AACA,MAAM,cAAc;AAAA,EAChB,OAAO;AAAA,EACP,cAAc;AAAA,EACd,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,OAAO;AACX;AACA,MAAM,eAAe;AAAA,EACjB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ;AACA,MAAM,eAAe;AAAA,EACjB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ;AAIA,MAAM,OAAO;AAAA,EACT,YAAY,UAAU,OAAO,WAAW;AAEpC,SAAK,OAAO;AAEZ,SAAK,kBAAkB;AACvB,SAAK,YAAY;AACjB,SAAK,mBAAmB;AACxB,SAAK,kBAAkB;AAAA,MACnB,MAAM;AAAA,MACN,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,IACpB;AACQ,SAAK,WAAW,CAAC,MAAM;AAEnB,YAAM,KAAK,KAAK,MAAM,YAAY,EAAE,IAAI,CAAC;AACzC,UAAI,IAAI;AACJ,WAAG,CAAC;AAAA,MACP,WACQ,EAAE,SAAS,SAAS;AACzB,gBAAQ,MAAM,EAAE,KAAK;AAAA,MACxB;AAAA,IACb;AACQ,SAAK,kBAAkB,CAAC,MAAM;AAC1B,UAAI,EAAE,SAAS,eAAe,EAAE,SAAS,YAAY;AACjD,aAAK,aAAa,CAAC;AAAA,MACtB;AAED,YAAM,KAAK,KAAK,MAAM,cAAc,EAAE,IAAI,CAAC;AAC3C,UAAI,IAAI;AACJ,YAAI,KAAK,MAAM,uBAAuB,EAAE,SAAS,eAAe,EAAE,SAAS,YAAY;AACnF,YAAE,WAAW,KAAK,oBAAoB,KAAK,uBAAuB,EAAE,KAAK;AAAA,QAC5E;AACD,WAAG,CAAC;AACJ,eAAO,EAAE;AAAA,MACZ;AAAA,IACb;AACQ,SAAK,iBAAiB,CAAC,MAAM;AACzB,UAAI,CAAC,KAAK,iBAAiB;AAEvB,cAAM,KAAK,KAAK,MAAM,aAAa,EAAE,IAAI,CAAC;AAC1C,YAAI,IAAI;AACJ,aAAG,CAAC;AAAA,QACP;AAAA,MACJ;AACD,UAAI,EAAE,QAAQ,KAAK,iBAAiB;AAChC,aAAK,gBAAgB,EAAE,IAAI,IAAI;AAAA,MAClC;AAAA,IACb;AACQ,SAAK,YAAY;AACjB,SAAK,QAAQ;AACb,SAAK,YAAY,SAAS;AAAA,EAC7B;AAAA,EACD,IAAI,MAAM;AACN,WAAO,KAAK;AAAA,EACf;AAAA,EACD,IAAI,YAAY;AACZ,WAAO,KAAK;AAAA,EACf;AAAA,EACD,SAAS,OAAO;AACZ,UAAM,WAAW,KAAK;AACtB,SAAK,QAAQ;AACb,UAAM,kBAAkB,KAAK,gBAAgB,OAAO,QAAQ;AAC5D,QAAI,iBAAiB;AACjB,WAAK,uBAAuB,KAAK,IAAI;AAAA,IACxC;AACD,UAAM,cAAc,KAAK,YAAY,KAAK;AAC1C,UAAM,mBAAmB,KAAK,iBAAiB,OAAO,IAAI;AAC1D,SAAK,aAAa,OAAO,QAAQ;AACjC,SAAK,uBAAuB,OAAO,QAAQ;AAC3C,SAAK,gBAAgB,OAAO,QAAQ;AAIpC,QAAI,mBAAmB,eAAgB,oBAAoB,CAAC,KAAK,KAAK,SAAQ,GAAK;AAC/E,WAAK,OAAM;AAAA,IACd;AAAA,EACJ;AAAA,EACD,OAAO,MAAM,OAAO,WAAW;AAC3B,UAAM,OAAO,OAAO,UAAU,IAAG;AACjC,QAAI,CAAC,MAAM;AACP,aAAO;AAAA,IACV;AACD,UAAM,MAAM,KAAK;AAIjB,UAAM,eAAe,IAAI;AACzB,cAAU,YAAY,aAAa;AACnC,WAAO,aAAa,WAAW,SAAS,GAAG;AACvC,gBAAU,YAAY,aAAa,WAAW,CAAC,CAAC;AAAA,IACnD;AAGD,QAAI,aAAa;AAEjB,SAAK,SAAS,EAAE,GAAG,OAAO,cAAc,MAAK,CAAE;AAC/C,QAAI,OAAM;AACV,UAAM,EAAE,iBAAkB,IAAG;AAC7B,QAAI,kBAAkB;AAClB,UAAI,iBAAiB,QAAQ;AACzB,YAAI,UAAU,iBAAiB,QAAQ,EAAE,GAAG,iBAAiB,kBAAkB,UAAU,EAAC,CAAE;AAAA,MAC/F,OACI;AACD,aAAK,iBAAiB,kBAAkB,KAAK;AAAA,MAChD;AAAA,IACJ;AAED,QAAI,IAAI,iBAAiB;AACrB,UAAI,KAAK,MAAM;AAAA,IAClB,OACI;AACD,UAAI,KAAK,aAAa,MAAM,IAAI,KAAK,MAAM,CAAC;AAAA,IAC/C;AAGD,QAAI,QAAO;AACX,WAAO;AAAA,EACV;AAAA;AAAA,EAED,YAAY,WAAW;AACnB,UAAM,EAAE,MAAO,IAAG;AAClB,UAAM,EAAE,WAAW,cAAe,IAAG;AACrC,UAAM,aAAa;AAAA,MACf,GAAG;AAAA,MACH,GAAG,MAAM;AAAA,MACT,aAAa,MAAM,qBAAqB,sBAAuB,KAAI;AAAA,MACnE;AAAA,MACA,OAAO,eAAe,QAAQ;AAAA,IAC1C;AACQ,UAAM,YAAY,WAAW,oBAAoB,WAAW,aAAa;AACzE,WAAO,OAAO,YAAY;AAAA,MACtB,QAAQ,CAAC,UAAU,aAAa,GAAG,UAAU,YAAY,CAAC;AAAA,MAC1D,MAAM,UAAU,QAAQ;AAAA,MACxB,OAAO,UAAU,SAAS;AAAA,MAC1B,SAAS,UAAU,WAAW;AAAA,IAC1C,CAAS;AACD,QAAI,MAAM,IAAI;AAEV,YAAM,aAAa,kBAAkB,UAAU;AAI/C,wBAAkB,UAAU,aAAa,MAAM;AAE3C,0BAAkB,UAAU,aAAa;AACzC,eAAO,MAAM;AAAA,MAC7B;AAAA,IACS;AACD,UAAM,MAAM,IAAI,KAAK,UAAU,UAAU;AAEzC,QAAI,UAAU,SAAS;AACnB,UAAI,WAAW,UAAU,OAAO;AAAA,IACnC;AACD,QAAI,MAAM,QAAQ;AACd,UAAI,UAAS,EAAG,MAAM,SAAS,MAAM;AAAA,IACxC;AACD,SAAK,uBAAuB,GAAG;AAI/B,UAAM,YAAY,IAAI;AACtB,QAAI,UAAU,CAAC,QAAQ;AACnB,WAAK,YAAY;AACjB,gBAAU,KAAK,KAAK,GAAG;AACvB,WAAK,YAAY;AAAA,IAC7B;AAEQ,UAAM,qBAAqB,IAAI,iBAAiB;AAChD,QAAI,iBAAiB,MAAM,CAAC,QAAQ;AAChC,yBAAmB,KAAK,IAAI,kBAAkB,GAAG;AACjD,WAAK,iBAAgB;AAAA,IACjC;AACQ,QAAI,GAAG,UAAU,MAAM,KAAK,gBAAiB,CAAA;AAG7C,UAAM,YAAY,IAAI;AACtB,QAAI,OAAO,KAAK,WAAW,KAAK,MAAM,SAAS;AAE/C,QAAI,GAAG,UAAU,MAAM;AACnB,WAAK,iBAAiB,OAAO,IAAI,UAAU,OAAO,IAAI,UAAU,MAAM;AAAA,IAClF,CAAS;AACD,QAAI,GAAG,aAAa,MAAM;AACtB,WAAK,uBAAuB,KAAK,OAAO,CAAE,CAAA;AAE1C,qBAAe,IAAI,WAAW,KAAK,gBAAgB;AAAA,IAC/D,CAAS;AACD,QAAI,GAAG,cAAc,MAAM,KAAK,uBAAuB,KAAK,OAAO,CAAE,CAAA,CAAC;AACtE,eAAW,aAAa,eAAe;AACnC,UAAI,GAAG,WAAW,KAAK,eAAe;AAAA,IACzC;AACD,eAAW,aAAa,cAAc;AAClC,UAAI,GAAG,WAAW,KAAK,cAAc;AAAA,IACxC;AACD,eAAW,aAAa,aAAa;AACjC,UAAI,GAAG,WAAW,KAAK,QAAQ;AAAA,IAClC;AACD,SAAK,OAAO;AAAA,EACf;AAAA;AAAA,EAED,UAAU;AAEN,UAAM,YAAY,KAAK,IAAI,aAAY;AACvC,UAAM,WAAW,UAAU,cAAc,qBAAqB;AAC9D,yCAAU;AACV,WAAO,UAAU,KAAK,IAAI;AAAA,EAC7B;AAAA,EACD,UAAU;AACN,SAAK,KAAK;EACb;AAAA;AAAA;AAAA;AAAA,EAID,SAAS;AACL,UAAM,MAAM,KAAK;AAIjB,QAAI,CAAC,KAAK,aAAa,IAAI,OAAO;AAE9B,UAAI,IAAI,QAAQ;AACZ,YAAI,OAAO;AACX,YAAI,SAAS;AAAA,MAChB;AAED,UAAI,QAAO;AAAA,IACd;AAAA,EACJ;AAAA,EACD,uBAAuB,KAAK;AACxB,UAAM,kBAAkB,eAAe,IAAI,SAAS;AACpD,QAAI,QAAQ,YAAY;AACxB,SAAK,mBAAmB;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA,EAKD,YAAY,WAAW;AAEnB,UAAM,EAAE,UAAW,IAAG;AACtB,QAAI,WAAW;AACX,YAAM,MAAM,KAAK;AACjB,UAAI,UAAU,UAAU,IAAI,UAAU,SAAS,UAAU,WAAW,IAAI,UAAU,QAAQ;AACtF,YAAI,OAAM;AACV,eAAO;AAAA,MACV;AAAA,IACJ;AACD,WAAO;AAAA,EACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOD,iBAAiB,WAAW,eAAe;AACvC,QAAI,KAAK,iBAAiB;AACtB,aAAO;AAAA,IACV;AACD,UAAM,MAAM,KAAK;AACjB,UAAM,KAAK,KAAK;AAEhB,UAAM,EAAE,MAAM,OAAO,QAAO,IAAK;AACjC,UAAM,WAAW,IAAI;AACrB,QAAI,UAAU;AAEV,SAAG,2BAA2B;AAAA,IACjC;AACD,UAAM,UAAU,0BAA0B,IAAI;AAAA,MAC1C,GAAG,qBAAqB,IAAI,SAAS;AAAA,MACrC,GAAG;AAAA,IACf,CAAS;AACD,QAAI,UAAU;AAEV,SAAG,2BAA2B;AAAA,IACjC;AACD,QAAI,WAAW,eAAe;AAC1B,YAAM,iBAAiB,KAAK;AAE5B,qBAAe,OAAO;AACtB,qBAAe,SAAS,eAAe,OAAO,SAAS,GAAG;AAC1D,qBAAe,WAAW,eAAe,SAAS,YAAY,GAAG;AACjE,qBAAe,UAAU,eAAe,QAAQ,UAAU,GAAG;AAAA,IAChE;AAGD,QAAI,CAAC,UAAU;AACX,gCAA0B,IAAI,WAAW,SAAS;AAAA,IACrD;AACD,WAAO;AAAA,EACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMD,gBAAgB,WAAW,WAAW;AAClC,UAAM,MAAM,KAAK;AACjB,QAAI,UAAU;AACd,eAAW,YAAY,cAAc;AACjC,UAAI,YAAY,aAAa,CAAC,UAAU,UAAU,QAAQ,GAAG,UAAU,QAAQ,CAAC,GAAG;AAC/E,kBAAU;AACV,cAAM,SAAS,IAAI,MAAM,SAAS,CAAC,EAAE,YAAa,CAAA,GAAG,SAAS,MAAM,CAAC,CAAC,EAAE;AACxE,yCAAQ,KAAK,KAAK,UAAU,QAAQ;AAAA,MACvC;AAAA,IACJ;AACD,WAAO;AAAA,EACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMD,aAAa,WAAW,WAAW;AAC/B,QAAI,UAAU,WAAW,UAAU,QAAQ;AACvC,WAAK,KAAK,YAAY,MAAM,SAAS,UAAU,UAAU;AAAA,IAC5D;AACD,QAAI,UAAU,aAAa,UAAU,UAAU;AAC3C,YAAM,EAAE,WAAW,eAAe,eAAe,KAAI,IAAK;AAC1D,YAAM,UAAU;AAAA,QACZ,MAAM;AAAA,MACtB;AACY,UAAI,8BAA8B,WAAW;AAEzC,gBAAQ,2BAA2B,UAAU;AAAA,MAChD;AACD,WAAK,KAAK,SAAS,eAAe,QAAQ,GAAG,OAAO;AACpD,aAAO;AAAA,IACV;AACD,WAAO;AAAA,EACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMD,uBAAuB,WAAW,WAAW;AACzC,UAAM,MAAM,KAAK;AACjB,QAAI,UAAU;AACd,QAAI,IAAI,iBAAiB;AACrB,UAAI,WAAW,aAAa,IAAI,YAAY,CAAC,UAAU,UAAU,OAAO,UAAU,KAAK,GAAG;AACtF,kBAAU;AACV,YAAI,SAAS,UAAU,KAAK;AAAA,MAC/B;AACD,UAAI,SAAS,aAAa,IAAI,UAAU,CAAC,UAAU,UAAU,KAAK,UAAU,GAAG,GAAG;AAC9E,kBAAU;AACV,YAAI,OAAO,UAAU,GAAG;AAAA,MAC3B;AACD,UAAI,aAAa,aACb,IAAI,cACJ,CAAC,UAAU,UAAU,SAAS,UAAU,OAAO,GAAG;AAClD,YAAI,CAAC,UAAU,WAAW,IAAI,UAAU,UAAU,QAAQ,MAAM,GAAG;AAC/D,oBAAU;AACV,cAAI,WAAW,UAAU,OAAO;AAAA,QACnC;AAAA,MACJ;AAAA,IACJ;AACD,WAAO;AAAA,EACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMD,gBAAgB,WAAW,WAAW;AAClC,UAAM,MAAM,KAAK;AACjB,QAAI,UAAU;AACd,eAAW,YAAY,cAAc;AACjC,YAAM,WAAW,UAAU,QAAQ,KAAK;AACxC,YAAM,WAAW,UAAU,QAAQ,KAAK;AACxC,UAAI,CAAC,UAAU,UAAU,QAAQ,GAAG;AAChC,kBAAU;AACV,YAAI,UAAU;AACV,cAAI,QAAQ,EAAE,OAAO,QAAQ;AAAA,QAChC,OACI;AACD,cAAI,QAAQ,EAAE;QACjB;AAAA,MACJ;AAAA,IACJ;AACD,WAAO;AAAA,EACV;AAAA,EACD,uBAAuB,OAAO;AAC1B,UAAM,MAAM,KAAK;AACjB,UAAM,KAAK,IAAI;AACf,UAAM,EAAE,sBAAsB,CAAA,MAAO,KAAK;AAC1C,QAAI;AACA,UAAI,YAAY,KAAK;AACrB,aAAO,IAAI,sBAAsB,OAAO;AAAA,QACpC,QAAQ,oBAAoB,OAAO,IAAI,SAAS,KAAK,GAAG,CAAC;AAAA,MACzE,CAAa;AAAA,IACJ,QACK;AAEF,aAAO;IACV,UACO;AACJ,UAAI,YAAY;AAAA,IACnB;AAAA,EACJ;AAAA,EACD,aAAa,GAAG;;AACZ,UAAM,EAAE,MAAO,IAAG;AAClB,UAAM,6BAA6B,MAAM,wBAAwB,MAAM,eAAe,MAAM,gBAAgB,MAAM;AAClH,QAAI,4BAA4B;AAC5B,YAAM,YAAY,EAAE;AACpB,YAAM,gBAAc,UAAK,qBAAL,mBAAuB,UAAS;AACpD,YAAM,WAAW,KAAK,uBAAuB,EAAE,KAAK;AACpD,YAAM,aAAa,SAAS,SAAS;AACrC,UAAI,CAAC,cAAc,aAAa;AAC5B,UAAE,OAAO;AACT,aAAK,gBAAgB,CAAC;AAAA,MACzB;AACD,WAAK,mBAAmB;AACxB,UAAI,cAAc,CAAC,aAAa;AAC5B,UAAE,OAAO;AACT,aAAK,gBAAgB,CAAC;AAAA,MACzB;AACD,QAAE,OAAO;AAAA,IACZ,OACI;AACD,WAAK,mBAAmB;AAAA,IAC3B;AAAA,EACJ;AAAA,EACD,WAAW,UAAU,OAAO,YAAY;AACpC,UAAM,MAAM,KAAK;AACjB,UAAM,KAAK,IAAI;AACf,UAAM,YAAY,OAAO,UAAU,WAAW,QAAQ,MAAM;AAC5D,QAAI,cAAc,QAAQ;AACtB,WAAK,iBAAiB,KAAK,OAAO,KAAK;AAAA,IAC1C;AACD,QAAI,aAAa,cAAc;AAC3B,UAAI,OAAO,UAAU,UAAU;AAC3B,cAAM,YAAY,qBAAqB,EAAE;AAAA,MAC5C;AACD,UAAI,KAAK,KAAK,YAAY;AAEtB,YAAI,YAAY,KAAK;AACrB,iBAAS,KAAK,KAAK,OAAO,UAAU;AACpC,YAAI,YAAY;AAChB,eAAO;AAAA,MACV;AAAA,IACJ;AACD,aAAS,KAAK,KAAK,OAAO,UAAU;AACpC,WAAO;AAAA,EACV;AAAA;AAAA,EAED,mBAAmB;AACf,UAAM,MAAM,KAAK;AAEjB,SAAK,kBAAkB;AACvB,eAAW,aAAa,KAAK,iBAAiB;AAC1C,UAAI,KAAK,gBAAgB,SAAS,GAAG;AACjC,YAAI,KAAK,SAAS;AAAA,MACrB;AAAA,IACJ;AACD,SAAK,kBAAkB;AACvB,UAAM,KAAK,KAAK,KAAK;AAErB,QAAI,YAAY,KAAK;AACrB,SAAK,kBAAkB,MAAM;AAGzB,qBAAe,KAAK,kBAAkB,EAAE;AAExC,UAAI,YAAY;AAAA,IAC5B;AAAA,EACK;AACL;AACA,OAAO,YAAY,CAAA;AAUnB,SAAS,wBAAwB;AAC7B,MAAI,cAAc;AAElB,MAAI,OAAO,aAAa,aAAa;AACjC,UAAM,QAAQ,yBAAyB,KAAK,SAAS,MAAM;AAC3D,kBAAc,SAAS,MAAM,CAAC;AAAA,EACjC;AAED,MAAI;AAEA,kBAAc,eAAe,QAAQ,IAAI;AAAA,EAC5C,QACK;AAAA,EAEL;AACD,MAAI;AAEA,kBAAc,eAAe,QAAQ,IAAI;AAAA,EAC5C,QACK;AAAA,EAEL;AACD,SAAO;AACX;","x_google_ignoreList":[0]}

package/dist/es/main34.mjs

@@ -0,0 +1,90 @@
+const skipMethods = [
+  "setMaxBounds",
+  "setMinZoom",
+  "setMaxZoom",
+  "setMinPitch",
+  "setMaxPitch",
+  "setRenderWorldCopies",
+  "setProjection",
+  "setStyle",
+  "addSource",
+  "removeSource",
+  "addLayer",
+  "removeLayer",
+  "setLayerZoomRange",
+  "setFilter",
+  "setPaintProperty",
+  "setLayoutProperty",
+  "setLight",
+  "setTerrain",
+  "setFog",
+  "remove"
+];
+function createRef(mapInstance) {
+  if (!mapInstance) {
+    return null;
+  }
+  const map = mapInstance.map;
+  const ref = {
+    getMap: () => map,
+    // Overwrite getters to use our shadow transform
+    getCenter: () => mapInstance.transform.center,
+    getZoom: () => mapInstance.transform.zoom,
+    getBearing: () => mapInstance.transform.bearing,
+    getPitch: () => mapInstance.transform.pitch,
+    getPadding: () => mapInstance.transform.padding,
+    getBounds: () => mapInstance.transform.getBounds(),
+    project: (lnglat) => {
+      const tr = map.transform;
+      map.transform = mapInstance.transform;
+      const result = map.project(lnglat);
+      map.transform = tr;
+      return result;
+    },
+    unproject: (point) => {
+      const tr = map.transform;
+      map.transform = mapInstance.transform;
+      const result = map.unproject(point);
+      map.transform = tr;
+      return result;
+    },
+    // options diverge between mapbox and maplibre
+    queryTerrainElevation: (lnglat, options) => {
+      const tr = map.transform;
+      map.transform = mapInstance.transform;
+      const result = map.queryTerrainElevation(lnglat, options);
+      map.transform = tr;
+      return result;
+    },
+    queryRenderedFeatures: (geometry, options) => {
+      const tr = map.transform;
+      map.transform = mapInstance.transform;
+      const result = map.queryRenderedFeatures(geometry, options);
+      map.transform = tr;
+      return result;
+    }
+  };
+  for (const key of getMethodNames(map)) {
+    if (!(key in ref) && !skipMethods.includes(key)) {
+      ref[key] = map[key].bind(map);
+    }
+  }
+  return ref;
+}
+function getMethodNames(obj) {
+  const result = /* @__PURE__ */ new Set();
+  let proto = obj;
+  while (proto) {
+    for (const key of Object.getOwnPropertyNames(proto)) {
+      if (key[0] !== "_" && typeof obj[key] === "function" && key !== "fire" && key !== "setEventedParent") {
+        result.add(key);
+      }
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Array.from(result);
+}
+export {
+  createRef as default
+};
+//# sourceMappingURL=main34.mjs.map

package/dist/es/main34.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main34.mjs","sources":["../../node_modules/@vis.gl/react-mapbox/dist/mapbox/create-ref.js"],"sourcesContent":["/** These methods may break the react binding if called directly */\nconst skipMethods = [\n    'setMaxBounds',\n    'setMinZoom',\n    'setMaxZoom',\n    'setMinPitch',\n    'setMaxPitch',\n    'setRenderWorldCopies',\n    'setProjection',\n    'setStyle',\n    'addSource',\n    'removeSource',\n    'addLayer',\n    'removeLayer',\n    'setLayerZoomRange',\n    'setFilter',\n    'setPaintProperty',\n    'setLayoutProperty',\n    'setLight',\n    'setTerrain',\n    'setFog',\n    'remove'\n];\nexport default function createRef(mapInstance) {\n    if (!mapInstance) {\n        return null;\n    }\n    const map = mapInstance.map;\n    const ref = {\n        getMap: () => map,\n        // Overwrite getters to use our shadow transform\n        getCenter: () => mapInstance.transform.center,\n        getZoom: () => mapInstance.transform.zoom,\n        getBearing: () => mapInstance.transform.bearing,\n        getPitch: () => mapInstance.transform.pitch,\n        getPadding: () => mapInstance.transform.padding,\n        getBounds: () => mapInstance.transform.getBounds(),\n        project: (lnglat) => {\n            const tr = map.transform;\n            map.transform = mapInstance.transform;\n            const result = map.project(lnglat);\n            map.transform = tr;\n            return result;\n        },\n        unproject: (point) => {\n            const tr = map.transform;\n            map.transform = mapInstance.transform;\n            const result = map.unproject(point);\n            map.transform = tr;\n            return result;\n        },\n        // options diverge between mapbox and maplibre\n        queryTerrainElevation: (lnglat, options) => {\n            const tr = map.transform;\n            map.transform = mapInstance.transform;\n            const result = map.queryTerrainElevation(lnglat, options);\n            map.transform = tr;\n            return result;\n        },\n        queryRenderedFeatures: (geometry, options) => {\n            const tr = map.transform;\n            map.transform = mapInstance.transform;\n            const result = map.queryRenderedFeatures(geometry, options);\n            map.transform = tr;\n            return result;\n        }\n    };\n    for (const key of getMethodNames(map)) {\n        // @ts-expect-error\n        if (!(key in ref) && !skipMethods.includes(key)) {\n            ref[key] = map[key].bind(map);\n        }\n    }\n    return ref;\n}\nfunction getMethodNames(obj) {\n    const result = new Set();\n    let proto = obj;\n    while (proto) {\n        for (const key of Object.getOwnPropertyNames(proto)) {\n            if (key[0] !== '_' &&\n                typeof obj[key] === 'function' &&\n                key !== 'fire' &&\n                key !== 'setEventedParent') {\n                result.add(key);\n            }\n        }\n        proto = Object.getPrototypeOf(proto);\n    }\n    return Array.from(result);\n}\n//# sourceMappingURL=create-ref.js.map"],"names":[],"mappings":"AACA,MAAM,cAAc;AAAA,EAChB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ;AACe,SAAS,UAAU,aAAa;AAC3C,MAAI,CAAC,aAAa;AACd,WAAO;AAAA,EACV;AACD,QAAM,MAAM,YAAY;AACxB,QAAM,MAAM;AAAA,IACR,QAAQ,MAAM;AAAA;AAAA,IAEd,WAAW,MAAM,YAAY,UAAU;AAAA,IACvC,SAAS,MAAM,YAAY,UAAU;AAAA,IACrC,YAAY,MAAM,YAAY,UAAU;AAAA,IACxC,UAAU,MAAM,YAAY,UAAU;AAAA,IACtC,YAAY,MAAM,YAAY,UAAU;AAAA,IACxC,WAAW,MAAM,YAAY,UAAU,UAAW;AAAA,IAClD,SAAS,CAAC,WAAW;AACjB,YAAM,KAAK,IAAI;AACf,UAAI,YAAY,YAAY;AAC5B,YAAM,SAAS,IAAI,QAAQ,MAAM;AACjC,UAAI,YAAY;AAChB,aAAO;AAAA,IACV;AAAA,IACD,WAAW,CAAC,UAAU;AAClB,YAAM,KAAK,IAAI;AACf,UAAI,YAAY,YAAY;AAC5B,YAAM,SAAS,IAAI,UAAU,KAAK;AAClC,UAAI,YAAY;AAChB,aAAO;AAAA,IACV;AAAA;AAAA,IAED,uBAAuB,CAAC,QAAQ,YAAY;AACxC,YAAM,KAAK,IAAI;AACf,UAAI,YAAY,YAAY;AAC5B,YAAM,SAAS,IAAI,sBAAsB,QAAQ,OAAO;AACxD,UAAI,YAAY;AAChB,aAAO;AAAA,IACV;AAAA,IACD,uBAAuB,CAAC,UAAU,YAAY;AAC1C,YAAM,KAAK,IAAI;AACf,UAAI,YAAY,YAAY;AAC5B,YAAM,SAAS,IAAI,sBAAsB,UAAU,OAAO;AAC1D,UAAI,YAAY;AAChB,aAAO;AAAA,IACV;AAAA,EACT;AACI,aAAW,OAAO,eAAe,GAAG,GAAG;AAEnC,QAAI,EAAE,OAAO,QAAQ,CAAC,YAAY,SAAS,GAAG,GAAG;AAC7C,UAAI,GAAG,IAAI,IAAI,GAAG,EAAE,KAAK,GAAG;AAAA,IAC/B;AAAA,EACJ;AACD,SAAO;AACX;AACA,SAAS,eAAe,KAAK;AACzB,QAAM,SAAS,oBAAI;AACnB,MAAI,QAAQ;AACZ,SAAO,OAAO;AACV,eAAW,OAAO,OAAO,oBAAoB,KAAK,GAAG;AACjD,UAAI,IAAI,CAAC,MAAM,OACX,OAAO,IAAI,GAAG,MAAM,cACpB,QAAQ,UACR,QAAQ,oBAAoB;AAC5B,eAAO,IAAI,GAAG;AAAA,MACjB;AAAA,IACJ;AACD,YAAQ,OAAO,eAAe,KAAK;AAAA,EACtC;AACD,SAAO,MAAM,KAAK,MAAM;AAC5B;","x_google_ignoreList":[0]}

package/dist/es/main35.mjs

@@ -0,0 +1,6 @@
+import { useLayoutEffect, useEffect } from "react";
+const useIsomorphicLayoutEffect = typeof document !== "undefined" ? useLayoutEffect : useEffect;
+export {
+  useIsomorphicLayoutEffect as default
+};
+//# sourceMappingURL=main35.mjs.map

package/dist/es/main35.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main35.mjs","sources":["../../node_modules/@vis.gl/react-mapbox/dist/utils/use-isomorphic-layout-effect.js"],"sourcesContent":["// From https://github.com/streamich/react-use/blob/master/src/useIsomorphicLayoutEffect.ts\n// useLayoutEffect but does not trigger warning in server-side rendering\nimport { useEffect, useLayoutEffect } from 'react';\nconst useIsomorphicLayoutEffect = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\nexport default useIsomorphicLayoutEffect;\n//# sourceMappingURL=use-isomorphic-layout-effect.js.map"],"names":[],"mappings":";AAGK,MAAC,4BAA4B,OAAO,aAAa,cAAc,kBAAkB;","x_google_ignoreList":[0]}