@ztwoint/z-ui 0.1.122 → 0.1.124

package/dist/node_modules/@vis.gl/react-mapbox/dist/components/geolocate-control.js

@@ -0,0 +1,30 @@
+import { memo as l, forwardRef as f, useRef as p, useImperativeHandle as m, useEffect as d } from "react";
+import { applyReactStyle as U } from "../utils/apply-react-style.js";
+import { useControl as _ } from "./use-control.js";
+function k(n, a) {
+  const c = p({ props: n }), s = _(({ mapLib: u }) => {
+    const e = new u.GeolocateControl(n), i = e._setupUI.bind(e);
+    return e._setupUI = (r) => {
+      e._container.hasChildNodes() || i(r);
+    }, e.on("geolocate", (r) => {
+      var o, t;
+      (t = (o = c.current.props).onGeolocate) == null || t.call(o, r);
+    }), e.on("error", (r) => {
+      var o, t;
+      (t = (o = c.current.props).onError) == null || t.call(o, r);
+    }), e.on("outofmaxbounds", (r) => {
+      var o, t;
+      (t = (o = c.current.props).onOutOfMaxBounds) == null || t.call(o, r);
+    }), e.on("trackuserlocationstart", (r) => {
+      var o, t;
+      (t = (o = c.current.props).onTrackUserLocationStart) == null || t.call(o, r);
+    }), e.on("trackuserlocationend", (r) => {
+      var o, t;
+      (t = (o = c.current.props).onTrackUserLocationEnd) == null || t.call(o, r);
+    }), e;
+  }, { position: n.position });
+  return c.current.props = n, m(a, () => s, []), d(() => {
+    U(s._container, n.style);
+  }, [n.style]), null;
+}
+l(f(k));

package/dist/node_modules/@vis.gl/react-mapbox/dist/components/map.js

@@ -0,0 +1,54 @@
+import * as o from "react";
+import { useContext as b, useState as E, useRef as s, useEffect as v, useImperativeHandle as y, useMemo as L } from "react";
+import { MountedMapsContext as I } from "./use-map.js";
+import f from "../mapbox/mapbox.js";
+import w from "../mapbox/create-ref.js";
+import x from "../utils/use-isomorphic-layout-effect.js";
+import R from "../utils/set-globals.js";
+const g = o.createContext(null);
+function C(e, u) {
+  const a = b(I), [l, M] = E(null), c = s(), { current: i } = s({ mapLib: null, map: null });
+  v(() => {
+    const p = e.mapLib;
+    let m = !0, t;
+    return Promise.resolve(p || import("mapbox-gl")).then((r) => {
+      if (!m)
+        return;
+      if (!r)
+        throw new Error("Invalid mapLib");
+      const n = "Map" in r ? r : r.default;
+      if (!n.Map)
+        throw new Error("Invalid mapLib");
+      R(n, e), e.reuseMaps && (t = f.reuse(e, c.current)), t || (t = new f(n.Map, e, c.current)), i.map = w(t), i.mapLib = n, M(t), a == null || a.onMapMount(i.map, e.id);
+    }).catch((r) => {
+      const { onError: n } = e;
+      n ? n({
+        type: "error",
+        target: null,
+        error: r
+      }) : console.error(r);
+    }), () => {
+      m = !1, t && (a == null || a.onMapUnmount(e.id), e.reuseMaps ? t.recycle() : t.destroy());
+    };
+  }, []), x(() => {
+    l && l.setProps(e);
+  }), y(u, () => i.map, [l]);
+  const d = L(() => ({
+    position: "relative",
+    width: "100%",
+    height: "100%",
+    ...e.style
+  }), [e.style]), h = {
+    height: "100%"
+  };
+  return o.createElement("div", { id: e.id, ref: c, style: d }, l && o.createElement(
+    g.Provider,
+    { value: i },
+    o.createElement("div", { "mapboxgl-children": "", style: h }, e.children)
+  ));
+}
+const A = o.forwardRef(C);
+export {
+  A as Map,
+  g as MapContext
+};

package/dist/node_modules/@vis.gl/react-mapbox/dist/components/marker.js

@@ -0,0 +1,56 @@
+import * as D from "react";
+import { memo as M, forwardRef as N, useContext as b, useRef as y, useMemo as x, useEffect as R, useImperativeHandle as w } from "react";
+import { createPortal as O } from "react-dom";
+import { applyReactStyle as S } from "../utils/apply-react-style.js";
+import { MapContext as q } from "./map.js";
+import { arePointsEqual as H } from "../utils/deep-equal.js";
+import { compareClassNames as I } from "../utils/compare-class-names.js";
+const J = M(N((a, v) => {
+  const { map: k, mapLib: C } = b(q), l = y({ props: a }), t = x(() => {
+    let s = !1;
+    D.Children.forEach(a.children, (o) => {
+      o && (s = !0);
+    });
+    const A = {
+      ...a,
+      element: s ? document.createElement("div") : null
+    }, i = new C.Marker(A);
+    return i.setLngLat([a.longitude, a.latitude]), i.getElement().addEventListener("click", (o) => {
+      var e, n;
+      (n = (e = l.current.props).onClick) == null || n.call(e, {
+        type: "click",
+        target: i,
+        originalEvent: o
+      });
+    }), i.on("dragstart", (o) => {
+      var n, r;
+      const e = o;
+      e.lngLat = t.getLngLat(), (r = (n = l.current.props).onDragStart) == null || r.call(n, e);
+    }), i.on("drag", (o) => {
+      var n, r;
+      const e = o;
+      e.lngLat = t.getLngLat(), (r = (n = l.current.props).onDrag) == null || r.call(n, e);
+    }), i.on("dragend", (o) => {
+      var n, r;
+      const e = o;
+      e.lngLat = t.getLngLat(), (r = (n = l.current.props).onDragEnd) == null || r.call(n, e);
+    }), i;
+  }, []);
+  R(() => (t.addTo(k.getMap()), () => {
+    t.remove();
+  }), []);
+  const { longitude: c, latitude: m, offset: g, style: f, draggable: u = !1, popup: d = null, rotation: p = 0, rotationAlignment: L = "auto", pitchAlignment: h = "auto" } = a;
+  R(() => {
+    S(t.getElement(), f);
+  }, [f]), w(v, () => t, []);
+  const P = l.current.props;
+  (t.getLngLat().lng !== c || t.getLngLat().lat !== m) && t.setLngLat([c, m]), g && !H(t.getOffset(), g) && t.setOffset(g), t.isDraggable() !== u && t.setDraggable(u), t.getRotation() !== p && t.setRotation(p), t.getRotationAlignment() !== L && t.setRotationAlignment(L), t.getPitchAlignment() !== h && t.setPitchAlignment(h), t.getPopup() !== d && t.setPopup(d);
+  const E = I(P.className, a.className);
+  if (E)
+    for (const s of E)
+      t.toggleClassName(s);
+  return l.current.props = a, O(a.children, t.getElement());
+}));
+export {
+  J as Marker
+};

package/dist/node_modules/@vis.gl/react-mapbox/dist/components/navigation-control.js

@@ -0,0 +1,12 @@
+import { memo as i, useEffect as e } from "react";
+import { applyReactStyle as l } from "../utils/apply-react-style.js";
+import { useControl as r } from "./use-control.js";
+function m(t) {
+  const o = r(({ mapLib: n }) => new n.NavigationControl(t), {
+    position: t.position
+  });
+  return e(() => {
+    l(o._container, t.style);
+  }, [t.style]), null;
+}
+i(m);

package/dist/node_modules/@vis.gl/react-mapbox/dist/components/popup.js

@@ -0,0 +1,35 @@
+import { createPortal as g } from "react-dom";
+import { memo as h, forwardRef as L, useContext as C, useMemo as m, useRef as x, useEffect as l, useImperativeHandle as M } from "react";
+import { applyReactStyle as N } from "../utils/apply-react-style.js";
+import { MapContext as O } from "./map.js";
+import { deepEqual as y } from "../utils/deep-equal.js";
+import { compareClassNames as E } from "../utils/compare-class-names.js";
+h(L((e, r) => {
+  const { map: u, mapLib: d } = C(O), i = m(() => document.createElement("div"), []), c = x({ props: e }), t = m(() => {
+    const n = { ...e }, o = new d.Popup(n);
+    return o.setLngLat([e.longitude, e.latitude]), o.once("open", (a) => {
+      var f, s;
+      (s = (f = c.current.props).onOpen) == null || s.call(f, a);
+    }), o;
+  }, []);
+  if (l(() => {
+    const n = (o) => {
+      var a, f;
+      (f = (a = c.current.props).onClose) == null || f.call(a, o);
+    };
+    return t.on("close", n), t.setDOMContent(i).addTo(u.getMap()), () => {
+      t.off("close", n), t.isOpen() && t.remove();
+    };
+  }, []), l(() => {
+    N(t.getElement(), e.style);
+  }, [e.style]), M(r, () => t, []), t.isOpen()) {
+    const n = c.current.props;
+    (t.getLngLat().lng !== e.longitude || t.getLngLat().lat !== e.latitude) && t.setLngLat([e.longitude, e.latitude]), e.offset && !y(n.offset, e.offset) && (t.options.anchor = e.anchor, t.setOffset(e.offset)), (n.anchor !== e.anchor || n.maxWidth !== e.maxWidth) && t.setMaxWidth(e.maxWidth);
+    const o = E(n.className, e.className);
+    if (o)
+      for (const a of o)
+        t.toggleClassName(a);
+    c.current.props = e;
+  }
+  return g(e.children, i);
+}));

package/dist/node_modules/@vis.gl/react-mapbox/dist/components/scale-control.js

@@ -0,0 +1,14 @@
+import { memo as c, useRef as m, useEffect as f } from "react";
+import { applyReactStyle as l } from "../utils/apply-react-style.js";
+import { useControl as a } from "./use-control.js";
+function r(t) {
+  const n = a(({ mapLib: u }) => new u.ScaleControl(t), {
+    position: t.position
+  }), i = m(t), e = i.current;
+  i.current = t;
+  const { style: o } = t;
+  return t.maxWidth !== void 0 && t.maxWidth !== e.maxWidth && (n.options.maxWidth = t.maxWidth), t.unit !== void 0 && t.unit !== e.unit && n.setUnit(t.unit), f(() => {
+    l(n._container, o);
+  }, [o]), null;
+}
+c(r);

package/dist/node_modules/@vis.gl/react-mapbox/dist/components/use-control.js

@@ -0,0 +1,14 @@
+import { useContext as u, useMemo as s, useEffect as l } from "react";
+import { MapContext as m } from "./map.js";
+function x(i, n, p, C) {
+  const t = u(m), o = s(() => i(t), []);
+  return l(() => {
+    const r = n, f = null, c = typeof n == "function" ? n : null, { map: e } = t;
+    return e.hasControl(o) || (e.addControl(o, r == null ? void 0 : r.position), f && f(t)), () => {
+      c && c(t), e.hasControl(o) && e.removeControl(o);
+    };
+  }, []), o;
+}
+export {
+  x as useControl
+};

package/dist/node_modules/@vis.gl/react-mapbox/dist/components/use-map.js

@@ -0,0 +1,6 @@
+import * as t from "react";
+import "./map.js";
+const e = t.createContext(null);
+export {
+  e as MountedMapsContext
+};

package/dist/node_modules/@vis.gl/react-mapbox/dist/mapbox/create-ref.js

@@ -0,0 +1,77 @@
+const a = [
+  "setMaxBounds",
+  "setMinZoom",
+  "setMaxZoom",
+  "setMinPitch",
+  "setMaxPitch",
+  "setRenderWorldCopies",
+  "setProjection",
+  "setStyle",
+  "addSource",
+  "removeSource",
+  "addLayer",
+  "removeLayer",
+  "setLayerZoomRange",
+  "setFilter",
+  "setPaintProperty",
+  "setLayoutProperty",
+  "setLight",
+  "setTerrain",
+  "setFog",
+  "remove"
+];
+function u(e) {
+  if (!e)
+    return null;
+  const r = e.map, o = {
+    getMap: () => r,
+    // Overwrite getters to use our shadow transform
+    getCenter: () => e.transform.center,
+    getZoom: () => e.transform.zoom,
+    getBearing: () => e.transform.bearing,
+    getPitch: () => e.transform.pitch,
+    getPadding: () => e.transform.padding,
+    getBounds: () => e.transform.getBounds(),
+    project: (t) => {
+      const n = r.transform;
+      r.transform = e.transform;
+      const s = r.project(t);
+      return r.transform = n, s;
+    },
+    unproject: (t) => {
+      const n = r.transform;
+      r.transform = e.transform;
+      const s = r.unproject(t);
+      return r.transform = n, s;
+    },
+    // options diverge between mapbox and maplibre
+    queryTerrainElevation: (t, n) => {
+      const s = r.transform;
+      r.transform = e.transform;
+      const f = r.queryTerrainElevation(t, n);
+      return r.transform = s, f;
+    },
+    queryRenderedFeatures: (t, n) => {
+      const s = r.transform;
+      r.transform = e.transform;
+      const f = r.queryRenderedFeatures(t, n);
+      return r.transform = s, f;
+    }
+  };
+  for (const t of i(r))
+    !(t in o) && !a.includes(t) && (o[t] = r[t].bind(r));
+  return o;
+}
+function i(e) {
+  const r = /* @__PURE__ */ new Set();
+  let o = e;
+  for (; o; ) {
+    for (const t of Object.getOwnPropertyNames(o))
+      t[0] !== "_" && typeof e[t] == "function" && t !== "fire" && t !== "setEventedParent" && r.add(t);
+    o = Object.getPrototypeOf(o);
+  }
+  return Array.from(r);
+}
+export {
+  u as default
+};

package/dist/node_modules/@vis.gl/react-mapbox/dist/mapbox/mapbox.js

@@ -0,0 +1,315 @@
+import { transformToViewState as g, compareViewStateWithTransform as S } from "../utils/transform.js";
+import { createProxyTransform as T } from "./proxy-transform.js";
+import { normalizeStyle as m } from "../utils/style-utils.js";
+import { deepEqual as u } from "../utils/deep-equal.js";
+const p = { version: 8, sources: {}, layers: [] }, f = {
+  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"
+}, _ = {
+  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"
+}, v = {
+  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"
+}, E = [
+  "minZoom",
+  "maxZoom",
+  "minPitch",
+  "maxPitch",
+  "maxBounds",
+  "projection",
+  "renderWorldCopies"
+], C = [
+  "scrollZoom",
+  "boxZoom",
+  "dragRotate",
+  "dragPan",
+  "keyboard",
+  "doubleClickZoom",
+  "touchZoomRotate",
+  "touchPitch"
+];
+class h {
+  constructor(e, o, s) {
+    this._map = null, this._internalUpdate = !1, this._inRender = !1, this._hoveredFeatures = null, this._deferredEvents = {
+      move: !1,
+      zoom: !1,
+      pitch: !1,
+      rotate: !1
+    }, this._onEvent = (t) => {
+      const r = this.props[v[t.type]];
+      r ? r(t) : t.type === "error" && console.error(t.error);
+    }, this._onPointerEvent = (t) => {
+      (t.type === "mousemove" || t.type === "mouseout") && this._updateHover(t);
+      const r = this.props[f[t.type]];
+      r && (this.props.interactiveLayerIds && t.type !== "mouseover" && t.type !== "mouseout" && (t.features = this._hoveredFeatures || this._queryRenderedFeatures(t.point)), r(t), delete t.features);
+    }, this._onCameraEvent = (t) => {
+      if (!this._internalUpdate) {
+        const r = this.props[_[t.type]], n = this._proxyTransform;
+        r && (t.viewState = g(n.$proposedTransform ?? n), r(t)), t.type === "moveend" && (n.$proposedTransform = null);
+      }
+      t.type in this._deferredEvents && (this._deferredEvents[t.type] = !1);
+    }, this._MapClass = e, this.props = o, this._initialize(s);
+  }
+  get map() {
+    return this._map;
+  }
+  get transform() {
+    return this._map.transform;
+  }
+  setProps(e) {
+    const o = this.props;
+    this.props = e;
+    const s = this._updateSettings(e, o);
+    s && this._createProxyTransform(this._map);
+    const t = this._updateSize(e), r = this._updateViewState(e, !0);
+    this._updateStyle(e, o), this._updateStyleComponents(e, o), this._updateHandlers(e, o), (s || t || r && !this._map.isMoving()) && this.redraw();
+  }
+  static reuse(e, o) {
+    const s = h.savedMaps.pop();
+    if (!s)
+      return null;
+    const t = s.map, r = t.getContainer();
+    for (o.className = r.className; r.childNodes.length > 0; )
+      o.appendChild(r.childNodes[0]);
+    t._container = o, s.setProps({ ...e, styleDiffing: !1 }), t.resize();
+    const { initialViewState: n } = e;
+    return n && (n.bounds ? t.fitBounds(n.bounds, { ...n.fitBoundsOptions, duration: 0 }) : s._updateViewState(n, !1)), t.isStyleLoaded() ? t.fire("load") : t.once("styledata", () => t.fire("load")), t._update(), s;
+  }
+  /* eslint-disable complexity,max-statements */
+  _initialize(e) {
+    const { props: o } = this, { mapStyle: s = p } = o, t = {
+      ...o,
+      ...o.initialViewState,
+      accessToken: o.mapboxAccessToken || M() || null,
+      container: e,
+      style: m(s)
+    }, r = t.initialViewState || t.viewState || t;
+    if (Object.assign(t, {
+      center: [r.longitude || 0, r.latitude || 0],
+      zoom: r.zoom || 0,
+      pitch: r.pitch || 0,
+      bearing: r.bearing || 0
+    }), o.gl) {
+      const a = HTMLCanvasElement.prototype.getContext;
+      HTMLCanvasElement.prototype.getContext = () => (HTMLCanvasElement.prototype.getContext = a, o.gl);
+    }
+    const n = new this._MapClass(t);
+    r.padding && n.setPadding(r.padding), o.cursor && (n.getCanvas().style.cursor = o.cursor), this._createProxyTransform(n);
+    const c = n._render;
+    n._render = (a) => {
+      this._inRender = !0, c.call(n, a), this._inRender = !1;
+    };
+    const l = n._renderTaskQueue.run;
+    n._renderTaskQueue.run = (a) => {
+      this._proxyTransform.$internalUpdate = !0, l.call(n._renderTaskQueue, a), this._proxyTransform.$internalUpdate = !1, this._fireDefferedEvents();
+    };
+    const i = n.jumpTo;
+    n.jumpTo = (...a) => (this._proxyTransform.$internalUpdate = !0, i.apply(n, a), this._proxyTransform.$internalUpdate = !1, n);
+    const y = n.fire;
+    n.fire = this._fireEvent.bind(this, y), n.on("styledata", () => {
+      this._updateStyleComponents(this.props, {});
+    }), n.on("sourcedata", () => {
+      this._updateStyleComponents(this.props, {});
+    });
+    for (const a in f)
+      n.on(a, this._onPointerEvent);
+    for (const a in _)
+      n.on(a, this._onCameraEvent);
+    for (const a in v)
+      n.on(a, this._onEvent);
+    this._map = n;
+  }
+  /* eslint-enable complexity,max-statements */
+  recycle() {
+    const o = this.map.getContainer().querySelector("[mapboxgl-children]");
+    o == null || o.remove(), h.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 e = this._map;
+    !this._inRender && e.style && (e._frame && (e._frame.cancel(), e._frame = null), e._render());
+  }
+  _createProxyTransform(e) {
+    const o = T(e.transform);
+    e.transform = o, e.painter.transform = o, this._proxyTransform = o;
+  }
+  /* Trigger map resize if size is controlled
+     @param {object} nextProps
+     @returns {bool} true if size has changed
+   */
+  _updateSize(e) {
+    const { viewState: o } = e;
+    if (o) {
+      const s = this._map;
+      if (o.width !== s.transform.width || o.height !== s.transform.height)
+        return s.resize(), !0;
+    }
+    return !1;
+  }
+  // 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(e, o) {
+    const s = e.viewState || e, t = this._proxyTransform, { zoom: r, pitch: n, bearing: c } = t, l = S(this._proxyTransform, s);
+    if (t.$reactViewState = s, l && o) {
+      const i = this._deferredEvents;
+      i.move = !0, i.zoom || (i.zoom = r !== t.zoom), i.rotate || (i.rotate = c !== t.bearing), i.pitch || (i.pitch = n !== t.pitch);
+    }
+    return l;
+  }
+  /* Update camera constraints and projection settings to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateSettings(e, o) {
+    const s = this._map;
+    let t = !1;
+    for (const r of E)
+      if (r in e && !u(e[r], o[r])) {
+        t = !0;
+        const n = s[`set${r[0].toUpperCase()}${r.slice(1)}`];
+        n == null || n.call(s, e[r]);
+      }
+    return t;
+  }
+  /* Update map style to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if style is changed
+   */
+  _updateStyle(e, o) {
+    if (e.cursor !== o.cursor && (this._map.getCanvas().style.cursor = e.cursor || ""), e.mapStyle !== o.mapStyle) {
+      const { mapStyle: s = p, styleDiffing: t = !0 } = e, r = {
+        diff: t
+      };
+      return "localIdeographFontFamily" in e && (r.localIdeographFontFamily = e.localIdeographFontFamily), this._map.setStyle(m(s), r), !0;
+    }
+    return !1;
+  }
+  /* Update fog, light and terrain to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateStyleComponents(e, o) {
+    const s = this._map;
+    let t = !1;
+    return s.isStyleLoaded() && ("light" in e && s.setLight && !u(e.light, o.light) && (t = !0, s.setLight(e.light)), "fog" in e && s.setFog && !u(e.fog, o.fog) && (t = !0, s.setFog(e.fog)), "terrain" in e && s.setTerrain && !u(e.terrain, o.terrain) && (!e.terrain || s.getSource(e.terrain.source)) && (t = !0, s.setTerrain(e.terrain))), t;
+  }
+  /* Update interaction handlers to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateHandlers(e, o) {
+    const s = this._map;
+    let t = !1;
+    for (const r of C) {
+      const n = e[r] ?? !0, c = o[r] ?? !0;
+      u(n, c) || (t = !0, n ? s[r].enable(n) : s[r].disable());
+    }
+    return t;
+  }
+  _queryRenderedFeatures(e) {
+    const o = this._map, { interactiveLayerIds: s = [] } = this.props;
+    try {
+      return o.queryRenderedFeatures(e, {
+        layers: s.filter(o.getLayer.bind(o))
+      });
+    } catch {
+      return [];
+    }
+  }
+  _updateHover(e) {
+    var t;
+    const { props: o } = this;
+    if (o.interactiveLayerIds && (o.onMouseMove || o.onMouseEnter || o.onMouseLeave)) {
+      const r = e.type, n = ((t = this._hoveredFeatures) == null ? void 0 : t.length) > 0, c = this._queryRenderedFeatures(e.point), l = c.length > 0;
+      !l && n && (e.type = "mouseleave", this._onPointerEvent(e)), this._hoveredFeatures = c, l && !n && (e.type = "mouseenter", this._onPointerEvent(e)), e.type = r;
+    } else
+      this._hoveredFeatures = null;
+  }
+  _fireEvent(e, o, s) {
+    const t = this._map, r = this._proxyTransform, n = r.$internalUpdate;
+    try {
+      r.$internalUpdate = !1, e.call(t, o, s);
+    } finally {
+      r.$internalUpdate = n;
+    }
+    return t;
+  }
+  // If there are camera changes driven by props, invoke camera events so that DOM controls are synced
+  _fireDefferedEvents() {
+    const e = this._map;
+    this._internalUpdate = !0;
+    for (const o in this._deferredEvents)
+      this._deferredEvents[o] && e.fire(o);
+    this._internalUpdate = !1;
+  }
+}
+h.savedMaps = [];
+function M() {
+  let d = null;
+  if (typeof location < "u") {
+    const e = /access_token=([^&\/]*)/.exec(location.search);
+    d = e && e[1];
+  }
+  try {
+    d = d || process.env.MapboxAccessToken;
+  } catch {
+  }
+  try {
+    d = d || process.env.REACT_APP_MAPBOX_ACCESS_TOKEN;
+  } catch {
+  }
+  return d;
+}
+export {
+  h as default
+};

package/dist/node_modules/@vis.gl/react-mapbox/dist/mapbox/proxy-transform.js

@@ -0,0 +1,35 @@
+import { applyViewStateToTransform as s, isViewStateControlled as m } from "../utils/transform.js";
+const d = /* @__PURE__ */ new Set([
+  "_calcMatrices",
+  "_calcFogMatrices",
+  "_updateCameraState",
+  "_updateSeaLevelZoom"
+]);
+function _(f) {
+  let r = !1, n = {};
+  const a = f;
+  let t = null;
+  const u = {
+    get(c, e) {
+      return e === "$reactViewState" ? n : e === "$proposedTransform" ? t : e === "$internalUpdate" ? r : e === "_setZoom" ? (i) => {
+        r && (t == null || t[e](i)), Number.isFinite(n.zoom) || a[e](i);
+      } : (r && e === "_translateCameraConstrained" && m(n) && (t = t || a.clone()), d.has(e) ? function(...i) {
+        t == null || t[e](...i), a[e](...i);
+      } : r && t ? t[e] : a[e]);
+    },
+    set(c, e, i) {
+      if (e === "$reactViewState")
+        return n = i, s(a, n), !0;
+      if (e === "$proposedTransform")
+        return t = i, !0;
+      if (e === "$internalUpdate")
+        return r = i, !0;
+      let l = i;
+      return e === "center" || e === "_center" ? (Number.isFinite(n.longitude) || Number.isFinite(n.latitude)) && (l = new i.constructor(n.longitude ?? i.lng, n.latitude ?? i.lat)) : e === "zoom" || e === "_zoom" || e === "_seaLevelZoom" ? Number.isFinite(n.zoom) && (l = a[e]) : e === "_centerAltitude" ? Number.isFinite(n.elevation) && (l = a[e]) : e === "pitch" || e === "_pitch" ? Number.isFinite(n.pitch) && (l = a[e]) : (e === "bearing" || e === "rotation" || e === "angle") && Number.isFinite(n.bearing) && (l = a[e]), r && l !== i && (t = t || a.clone()), r && t && (t[e] = i), a[e] = l, !0;
+    }
+  };
+  return new Proxy(f, u);
+}
+export {
+  _ as createProxyTransform
+};

package/dist/node_modules/@vis.gl/react-mapbox/dist/utils/apply-react-style.js

@@ -0,0 +1,13 @@
+const r = /box|flex|grid|column|lineHeight|fontWeight|opacity|order|tabSize|zIndex/;
+function c(n, t) {
+  if (!n || !t)
+    return;
+  const o = n.style;
+  for (const e in t) {
+    const i = t[e];
+    Number.isFinite(i) && !r.test(e) ? o[e] = `${i}px` : o[e] = i;
+  }
+}
+export {
+  c as applyReactStyle
+};