@local-logic/maps 0.0.4 → 0.0.6

package/dist/scale-control-CyJd4u6j.js

@@ -0,0 +1,716 @@
+import * as E from "react";
+import { useContext as T, useMemo as M, useLayoutEffect as V, useEffect as h, useState as G, useRef as b, useImperativeHandle as k, memo as L, forwardRef as A } from "react";
+import { createPortal as H } from "react-dom";
+const q = E.createContext(null);
+function gt() {
+  var r;
+  const t = (r = T(q)) == null ? void 0 : r.maps, e = T(R);
+  return M(() => ({ ...t, current: e == null ? void 0 : e.map }), [t, e]);
+}
+function Q(t, e) {
+  const n = Array.isArray(t) ? t[0] : t ? t.x : 0, r = Array.isArray(t) ? t[1] : t ? t.y : 0, o = Array.isArray(e) ? e[0] : e ? e.x : 0, i = Array.isArray(e) ? e[1] : e ? e.y : 0;
+  return n === o && r === i;
+}
+function v(t, e) {
+  if (t === e)
+    return !0;
+  if (!t || !e)
+    return !1;
+  if (Array.isArray(t)) {
+    if (!Array.isArray(e) || t.length !== e.length)
+      return !1;
+    for (let n = 0; n < t.length; n++)
+      if (!v(t[n], e[n]))
+        return !1;
+    return !0;
+  } else if (Array.isArray(e))
+    return !1;
+  if (typeof t == "object" && typeof e == "object") {
+    const n = Object.keys(t), r = Object.keys(e);
+    if (n.length !== r.length)
+      return !1;
+    for (const o of n)
+      if (!e.hasOwnProperty(o) || !v(t[o], e[o]))
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+function K(t) {
+  const e = t.clone();
+  return e.pixelsToGLUnits = t.pixelsToGLUnits, e;
+}
+function F(t, e) {
+  if (!t.getProjection)
+    return;
+  const n = t.getProjection(), r = e.getProjection();
+  v(n, r) || e.setProjection(n);
+}
+function O(t) {
+  return {
+    longitude: t.center.lng,
+    latitude: t.center.lat,
+    zoom: t.zoom,
+    pitch: t.pitch,
+    bearing: t.bearing,
+    padding: t.padding
+  };
+}
+function j(t, e) {
+  const n = e.viewState || e;
+  let r = !1;
+  if ("zoom" in n) {
+    const o = t.zoom;
+    t.zoom = n.zoom, r = r || o !== t.zoom;
+  }
+  if ("bearing" in n) {
+    const o = t.bearing;
+    t.bearing = n.bearing, r = r || o !== t.bearing;
+  }
+  if ("pitch" in n) {
+    const o = t.pitch;
+    t.pitch = n.pitch, r = r || o !== t.pitch;
+  }
+  if (n.padding && !t.isPaddingEqual(n.padding) && (r = !0, t.padding = n.padding), "longitude" in n && "latitude" in n) {
+    const o = t.center;
+    t.center = new o.constructor(n.longitude, n.latitude), r = r || o !== t.center;
+  }
+  return r;
+}
+const $ = ["type", "source", "source-layer", "minzoom", "maxzoom", "filter", "layout"];
+function U(t) {
+  if (!t)
+    return null;
+  if (typeof t == "string" || ("toJS" in t && (t = t.toJS()), !t.layers))
+    return t;
+  const e = {};
+  for (const r of t.layers)
+    e[r.id] = r;
+  const n = t.layers.map((r) => {
+    let o = null;
+    "interactive" in r && (o = Object.assign({}, r), delete o.interactive);
+    const i = e[r.ref];
+    if (i) {
+      o = o || Object.assign({}, r), delete o.ref;
+      for (const s of $)
+        s in i && (o[s] = i[s]);
+    }
+    return o || r;
+  });
+  return { ...t, layers: n };
+}
+const D = { version: 8, sources: {}, layers: [] }, Z = {
+  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"
+}, z = {
+  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"
+}, B = {
+  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"
+}, J = [
+  "minZoom",
+  "maxZoom",
+  "minPitch",
+  "maxPitch",
+  "maxBounds",
+  "projection",
+  "renderWorldCopies"
+], Y = [
+  "scrollZoom",
+  "boxZoom",
+  "dragRotate",
+  "dragPan",
+  "keyboard",
+  "doubleClickZoom",
+  "touchZoomRotate",
+  "touchPitch"
+];
+class w {
+  constructor(e, n, r) {
+    this._map = null, this._internalUpdate = !1, this._inRender = !1, this._hoveredFeatures = null, this._deferredEvents = {
+      move: !1,
+      zoom: !1,
+      pitch: !1,
+      rotate: !1
+    }, this._onEvent = (o) => {
+      const i = this.props[B[o.type]];
+      i ? i(o) : o.type === "error" && console.error(o.error);
+    }, this._onPointerEvent = (o) => {
+      (o.type === "mousemove" || o.type === "mouseout") && this._updateHover(o);
+      const i = this.props[Z[o.type]];
+      i && (this.props.interactiveLayerIds && o.type !== "mouseover" && o.type !== "mouseout" && (o.features = this._hoveredFeatures || this._queryRenderedFeatures(o.point)), i(o), delete o.features);
+    }, this._onCameraEvent = (o) => {
+      if (!this._internalUpdate) {
+        const i = this.props[z[o.type]];
+        i && i(o);
+      }
+      o.type in this._deferredEvents && (this._deferredEvents[o.type] = !1);
+    }, this._MapClass = e, this.props = n, this._initialize(r);
+  }
+  get map() {
+    return this._map;
+  }
+  get transform() {
+    return this._renderTransform;
+  }
+  setProps(e) {
+    const n = this.props;
+    this.props = e;
+    const r = this._updateSettings(e, n);
+    r && this._createShadowTransform(this._map);
+    const o = this._updateSize(e), i = this._updateViewState(e, !0);
+    this._updateStyle(e, n), this._updateStyleComponents(e, n), this._updateHandlers(e, n), (r || o || i && !this._map.isMoving()) && this.redraw();
+  }
+  static reuse(e, n) {
+    const r = w.savedMaps.pop();
+    if (!r)
+      return null;
+    const o = r.map, i = o.getContainer();
+    for (n.className = i.className; i.childNodes.length > 0; )
+      n.appendChild(i.childNodes[0]);
+    o._container = n, r.setProps({ ...e, styleDiffing: !1 }), o.resize();
+    const { initialViewState: s } = e;
+    return s && (s.bounds ? o.fitBounds(s.bounds, { ...s.fitBoundsOptions, duration: 0 }) : r._updateViewState(s, !1)), o.isStyleLoaded() ? o.fire("load") : o.once("styledata", () => o.fire("load")), o._update(), r;
+  }
+  /* eslint-disable complexity,max-statements */
+  _initialize(e) {
+    const { props: n } = this, { mapStyle: r = D } = n, o = {
+      ...n,
+      ...n.initialViewState,
+      accessToken: n.mapboxAccessToken || X() || null,
+      container: e,
+      style: U(r)
+    }, i = o.initialViewState || o.viewState || o;
+    if (Object.assign(o, {
+      center: [i.longitude || 0, i.latitude || 0],
+      zoom: i.zoom || 0,
+      pitch: i.pitch || 0,
+      bearing: i.bearing || 0
+    }), n.gl) {
+      const u = HTMLCanvasElement.prototype.getContext;
+      HTMLCanvasElement.prototype.getContext = () => (HTMLCanvasElement.prototype.getContext = u, n.gl);
+    }
+    const s = new this._MapClass(o);
+    i.padding && s.setPadding(i.padding), n.cursor && (s.getCanvas().style.cursor = n.cursor), this._createShadowTransform(s);
+    const l = s._render;
+    s._render = (u) => {
+      this._inRender = !0, l.call(s, u), this._inRender = !1;
+    };
+    const a = s._renderTaskQueue.run;
+    s._renderTaskQueue.run = (u) => {
+      a.call(s._renderTaskQueue, u), this._onBeforeRepaint();
+    }, s.on("render", () => this._onAfterRepaint());
+    const c = s.fire;
+    s.fire = this._fireEvent.bind(this, c), s.on("resize", () => {
+      this._renderTransform.resize(s.transform.width, s.transform.height);
+    }), s.on("styledata", () => {
+      this._updateStyleComponents(this.props, {}), F(s.transform, this._renderTransform);
+    }), s.on("sourcedata", () => this._updateStyleComponents(this.props, {}));
+    for (const u in Z)
+      s.on(u, this._onPointerEvent);
+    for (const u in z)
+      s.on(u, this._onCameraEvent);
+    for (const u in B)
+      s.on(u, this._onEvent);
+    this._map = s;
+  }
+  /* eslint-enable complexity,max-statements */
+  recycle() {
+    const n = this.map.getContainer().querySelector("[mapboxgl-children]");
+    n == null || n.remove(), w.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());
+  }
+  _createShadowTransform(e) {
+    const n = K(e.transform);
+    e.painter.transform = n, this._renderTransform = n;
+  }
+  /* Trigger map resize if size is controlled
+     @param {object} nextProps
+     @returns {bool} true if size has changed
+   */
+  _updateSize(e) {
+    const { viewState: n } = e;
+    if (n) {
+      const r = this._map;
+      if (n.width !== r.transform.width || n.height !== r.transform.height)
+        return r.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, n) {
+    if (this._internalUpdate)
+      return !1;
+    const r = this._map, o = this._renderTransform, { zoom: i, pitch: s, bearing: l } = o, a = r.isMoving();
+    a && (o.cameraElevationReference = "sea");
+    const c = j(o, {
+      ...O(r.transform),
+      ...e
+    });
+    if (a && (o.cameraElevationReference = "ground"), c && n) {
+      const u = this._deferredEvents;
+      u.move = !0, u.zoom || (u.zoom = i !== o.zoom), u.rotate || (u.rotate = l !== o.bearing), u.pitch || (u.pitch = s !== o.pitch);
+    }
+    return a || j(r.transform, e), c;
+  }
+  /* Update camera constraints and projection settings to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateSettings(e, n) {
+    const r = this._map;
+    let o = !1;
+    for (const i of J)
+      if (i in e && !v(e[i], n[i])) {
+        o = !0;
+        const s = r[`set${i[0].toUpperCase()}${i.slice(1)}`];
+        s == null || s.call(r, e[i]);
+      }
+    return o;
+  }
+  /* Update map style to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if style is changed
+   */
+  _updateStyle(e, n) {
+    if (e.cursor !== n.cursor && (this._map.getCanvas().style.cursor = e.cursor || ""), e.mapStyle !== n.mapStyle) {
+      const { mapStyle: r = D, styleDiffing: o = !0 } = e, i = {
+        diff: o
+      };
+      return "localIdeographFontFamily" in e && (i.localIdeographFontFamily = e.localIdeographFontFamily), this._map.setStyle(U(r), i), !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, n) {
+    const r = this._map;
+    let o = !1;
+    return r.isStyleLoaded() && ("light" in e && r.setLight && !v(e.light, n.light) && (o = !0, r.setLight(e.light)), "fog" in e && r.setFog && !v(e.fog, n.fog) && (o = !0, r.setFog(e.fog)), "terrain" in e && r.setTerrain && !v(e.terrain, n.terrain) && (!e.terrain || r.getSource(e.terrain.source)) && (o = !0, r.setTerrain(e.terrain))), o;
+  }
+  /* Update interaction handlers to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateHandlers(e, n) {
+    const r = this._map;
+    let o = !1;
+    for (const i of Y) {
+      const s = e[i] ?? !0, l = n[i] ?? !0;
+      v(s, l) || (o = !0, s ? r[i].enable(s) : r[i].disable());
+    }
+    return o;
+  }
+  _queryRenderedFeatures(e) {
+    const n = this._map, r = n.transform, { interactiveLayerIds: o = [] } = this.props;
+    try {
+      return n.transform = this._renderTransform, n.queryRenderedFeatures(e, {
+        layers: o.filter(n.getLayer.bind(n))
+      });
+    } catch {
+      return [];
+    } finally {
+      n.transform = r;
+    }
+  }
+  _updateHover(e) {
+    var o;
+    const { props: n } = this;
+    if (n.interactiveLayerIds && (n.onMouseMove || n.onMouseEnter || n.onMouseLeave)) {
+      const i = e.type, s = ((o = this._hoveredFeatures) == null ? void 0 : o.length) > 0, l = this._queryRenderedFeatures(e.point), a = l.length > 0;
+      !a && s && (e.type = "mouseleave", this._onPointerEvent(e)), this._hoveredFeatures = l, a && !s && (e.type = "mouseenter", this._onPointerEvent(e)), e.type = i;
+    } else
+      this._hoveredFeatures = null;
+  }
+  _fireEvent(e, n, r) {
+    const o = this._map, i = o.transform, s = typeof n == "string" ? n : n.type;
+    return s === "move" && this._updateViewState(this.props, !1), s in z && (typeof n == "object" && (n.viewState = O(i)), this._map.isMoving()) ? (o.transform = this._renderTransform, e.call(o, n, r), o.transform = i, o) : (e.call(o, n, r), o);
+  }
+  // All camera manipulations are complete, ready to repaint
+  _onBeforeRepaint() {
+    const e = this._map;
+    this._internalUpdate = !0;
+    for (const r in this._deferredEvents)
+      this._deferredEvents[r] && e.fire(r);
+    this._internalUpdate = !1;
+    const n = this._map.transform;
+    e.transform = this._renderTransform, this._onAfterRepaint = () => {
+      F(this._renderTransform, n), e.transform = n;
+    };
+  }
+}
+w.savedMaps = [];
+function X() {
+  let t = null;
+  if (typeof location < "u") {
+    const e = /access_token=([^&\/]*)/.exec(location.search);
+    t = e && e[1];
+  }
+  try {
+    t = t || process.env.MapboxAccessToken;
+  } catch {
+  }
+  try {
+    t = t || process.env.REACT_APP_MAPBOX_ACCESS_TOKEN;
+  } catch {
+  }
+  return t;
+}
+const tt = [
+  "setMaxBounds",
+  "setMinZoom",
+  "setMaxZoom",
+  "setMinPitch",
+  "setMaxPitch",
+  "setRenderWorldCopies",
+  "setProjection",
+  "setStyle",
+  "addSource",
+  "removeSource",
+  "addLayer",
+  "removeLayer",
+  "setLayerZoomRange",
+  "setFilter",
+  "setPaintProperty",
+  "setLayoutProperty",
+  "setLight",
+  "setTerrain",
+  "setFog",
+  "remove"
+];
+function et(t) {
+  if (!t)
+    return null;
+  const e = t.map, n = {
+    getMap: () => e,
+    // Overwrite getters to use our shadow transform
+    getCenter: () => t.transform.center,
+    getZoom: () => t.transform.zoom,
+    getBearing: () => t.transform.bearing,
+    getPitch: () => t.transform.pitch,
+    getPadding: () => t.transform.padding,
+    getBounds: () => t.transform.getBounds(),
+    project: (r) => {
+      const o = e.transform;
+      e.transform = t.transform;
+      const i = e.project(r);
+      return e.transform = o, i;
+    },
+    unproject: (r) => {
+      const o = e.transform;
+      e.transform = t.transform;
+      const i = e.unproject(r);
+      return e.transform = o, i;
+    },
+    // options diverge between mapbox and maplibre
+    queryTerrainElevation: (r, o) => {
+      const i = e.transform;
+      e.transform = t.transform;
+      const s = e.queryTerrainElevation(r, o);
+      return e.transform = i, s;
+    },
+    queryRenderedFeatures: (r, o) => {
+      const i = e.transform;
+      e.transform = t.transform;
+      const s = e.queryRenderedFeatures(r, o);
+      return e.transform = i, s;
+    }
+  };
+  for (const r of nt(e))
+    !(r in n) && !tt.includes(r) && (n[r] = e[r].bind(e));
+  return n;
+}
+function nt(t) {
+  const e = /* @__PURE__ */ new Set();
+  let n = t;
+  for (; n; ) {
+    for (const r of Object.getOwnPropertyNames(n))
+      r[0] !== "_" && typeof t[r] == "function" && r !== "fire" && r !== "setEventedParent" && e.add(r);
+    n = Object.getPrototypeOf(n);
+  }
+  return Array.from(e);
+}
+const ot = typeof document < "u" ? V : h, rt = [
+  "baseApiUrl",
+  "maxParallelImageRequests",
+  "workerClass",
+  "workerCount",
+  "workerUrl"
+];
+function it(t, e) {
+  for (const r of rt)
+    r in e && (t[r] = e[r]);
+  const { RTLTextPlugin: n = "https://api.mapbox.com/mapbox-gl-js/plugins/mapbox-gl-rtl-text/v0.2.3/mapbox-gl-rtl-text.js" } = e;
+  n && t.getRTLTextPluginStatus && t.getRTLTextPluginStatus() === "unavailable" && t.setRTLTextPlugin(n, (r) => {
+    r && console.error(r);
+  }, !0);
+}
+const R = E.createContext(null);
+function st(t, e) {
+  const n = T(q), [r, o] = G(null), i = b(), { current: s } = b({ mapLib: null, map: null });
+  h(() => {
+    const c = t.mapLib;
+    let u = !0, f;
+    return Promise.resolve(c || import("./mapbox-gl-D58OubwB.js").then((d) => d.m)).then((d) => {
+      if (!u)
+        return;
+      if (!d)
+        throw new Error("Invalid mapLib");
+      const m = "Map" in d ? d : d.default;
+      if (!m.Map)
+        throw new Error("Invalid mapLib");
+      if (it(m, t), !m.supported || m.supported(t))
+        t.reuseMaps && (f = w.reuse(t, i.current)), f || (f = new w(m.Map, t, i.current)), s.map = et(f), s.mapLib = m, o(f), n == null || n.onMapMount(s.map, t.id);
+      else
+        throw new Error("Map is not supported by this browser");
+    }).catch((d) => {
+      const { onError: m } = t;
+      m ? m({
+        type: "error",
+        target: null,
+        error: d
+      }) : console.error(d);
+    }), () => {
+      u = !1, f && (n == null || n.onMapUnmount(t.id), t.reuseMaps ? f.recycle() : f.destroy());
+    };
+  }, []), ot(() => {
+    r && r.setProps(t);
+  }), k(e, () => s.map, [r]);
+  const l = M(() => ({
+    position: "relative",
+    width: "100%",
+    height: "100%",
+    ...t.style
+  }), [t.style]), a = {
+    height: "100%"
+  };
+  return E.createElement("div", { id: t.id, ref: i, style: l }, r && E.createElement(
+    R.Provider,
+    { value: s },
+    E.createElement("div", { "mapboxgl-children": "", style: a }, t.children)
+  ));
+}
+const pt = E.forwardRef(st), at = /box|flex|grid|column|lineHeight|fontWeight|opacity|order|tabSize|zIndex/;
+function S(t, e) {
+  if (!t || !e)
+    return;
+  const n = t.style;
+  for (const r in e) {
+    const o = e[r];
+    Number.isFinite(o) && !at.test(r) ? n[r] = `${o}px` : n[r] = o;
+  }
+}
+const yt = L(A((t, e) => {
+  const { map: n, mapLib: r } = T(R), o = b({ props: t });
+  o.current.props = t;
+  const i = M(() => {
+    let N = !1;
+    E.Children.forEach(t.children, (y) => {
+      y && (N = !0);
+    });
+    const I = {
+      ...t,
+      element: N ? document.createElement("div") : null
+    }, C = new r.Marker(I);
+    return C.setLngLat([t.longitude, t.latitude]), C.getElement().addEventListener("click", (y) => {
+      var g, p;
+      (p = (g = o.current.props).onClick) == null || p.call(g, {
+        type: "click",
+        target: C,
+        originalEvent: y
+      });
+    }), C.on("dragstart", (y) => {
+      var p, _;
+      const g = y;
+      g.lngLat = i.getLngLat(), (_ = (p = o.current.props).onDragStart) == null || _.call(p, g);
+    }), C.on("drag", (y) => {
+      var p, _;
+      const g = y;
+      g.lngLat = i.getLngLat(), (_ = (p = o.current.props).onDrag) == null || _.call(p, g);
+    }), C.on("dragend", (y) => {
+      var p, _;
+      const g = y;
+      g.lngLat = i.getLngLat(), (_ = (p = o.current.props).onDragEnd) == null || _.call(p, g);
+    }), C;
+  }, []);
+  h(() => (i.addTo(n.getMap()), () => {
+    i.remove();
+  }), []);
+  const { longitude: s, latitude: l, offset: a, style: c, draggable: u = !1, popup: f = null, rotation: d = 0, rotationAlignment: m = "auto", pitchAlignment: P = "auto" } = t;
+  return h(() => {
+    S(i.getElement(), c);
+  }, [c]), k(e, () => i, []), (i.getLngLat().lng !== s || i.getLngLat().lat !== l) && i.setLngLat([s, l]), a && !Q(i.getOffset(), a) && i.setOffset(a), i.isDraggable() !== u && i.setDraggable(u), i.getRotation() !== d && i.setRotation(d), i.getRotationAlignment() !== m && i.setRotationAlignment(m), i.getPitchAlignment() !== P && i.setPitchAlignment(P), i.getPopup() !== f && i.setPopup(f), H(t.children, i.getElement());
+}));
+function W(t) {
+  return new Set(t ? t.trim().split(/\s+/) : []);
+}
+const vt = L(A((t, e) => {
+  const { map: n, mapLib: r } = T(R), o = M(() => document.createElement("div"), []), i = b({ props: t });
+  i.current.props = t;
+  const s = M(() => {
+    const l = { ...t }, a = new r.Popup(l);
+    return a.setLngLat([t.longitude, t.latitude]), a.once("open", (c) => {
+      var u, f;
+      (f = (u = i.current.props).onOpen) == null || f.call(u, c);
+    }), a;
+  }, []);
+  if (h(() => {
+    const l = (a) => {
+      var c, u;
+      (u = (c = i.current.props).onClose) == null || u.call(c, a);
+    };
+    return s.on("close", l), s.setDOMContent(o).addTo(n.getMap()), () => {
+      s.off("close", l), s.isOpen() && s.remove();
+    };
+  }, []), h(() => {
+    S(s.getElement(), t.style);
+  }, [t.style]), k(e, () => s, []), s.isOpen() && ((s.getLngLat().lng !== t.longitude || s.getLngLat().lat !== t.latitude) && s.setLngLat([t.longitude, t.latitude]), t.offset && !v(s.options.offset, t.offset) && s.setOffset(t.offset), (s.options.anchor !== t.anchor || s.options.maxWidth !== t.maxWidth) && (s.options.anchor = t.anchor, s.setMaxWidth(t.maxWidth)), s.options.className !== t.className)) {
+    const l = W(s.options.className), a = W(t.className);
+    for (const c of l)
+      a.has(c) || s.removeClassName(c);
+    for (const c of a)
+      l.has(c) || s.addClassName(c);
+    s.options.className = t.className;
+  }
+  return H(t.children, o);
+}));
+function x(t, e, n, r) {
+  const o = T(R), i = M(() => t(o), []);
+  return h(() => {
+    const s = e, l = null, a = typeof e == "function" ? e : null, { map: c } = o;
+    return c.hasControl(i) || (c.addControl(i, s == null ? void 0 : s.position), l && l(o)), () => {
+      a && a(o), c.hasControl(i) && c.removeControl(i);
+    };
+  }, []), i;
+}
+function ct(t) {
+  const e = x(({ mapLib: n }) => new n.AttributionControl(t), {
+    position: t.position
+  });
+  return h(() => {
+    S(e._container, t.style);
+  }, [t.style]), null;
+}
+L(ct);
+function lt(t) {
+  const e = x(({ mapLib: n }) => new n.FullscreenControl({
+    container: t.containerId && document.getElementById(t.containerId)
+  }), { position: t.position });
+  return h(() => {
+    S(e._controlContainer, t.style);
+  }, [t.style]), null;
+}
+L(lt);
+function ut(t, e) {
+  const n = b({ props: t }), r = x(({ mapLib: o }) => {
+    const i = new o.GeolocateControl(t), s = i._setupUI.bind(i);
+    return i._setupUI = (l) => {
+      i._container.hasChildNodes() || s(l);
+    }, i.on("geolocate", (l) => {
+      var a, c;
+      (c = (a = n.current.props).onGeolocate) == null || c.call(a, l);
+    }), i.on("error", (l) => {
+      var a, c;
+      (c = (a = n.current.props).onError) == null || c.call(a, l);
+    }), i.on("outofmaxbounds", (l) => {
+      var a, c;
+      (c = (a = n.current.props).onOutOfMaxBounds) == null || c.call(a, l);
+    }), i.on("trackuserlocationstart", (l) => {
+      var a, c;
+      (c = (a = n.current.props).onTrackUserLocationStart) == null || c.call(a, l);
+    }), i.on("trackuserlocationend", (l) => {
+      var a, c;
+      (c = (a = n.current.props).onTrackUserLocationEnd) == null || c.call(a, l);
+    }), i;
+  }, { position: t.position });
+  return n.current.props = t, k(e, () => r, []), h(() => {
+    S(r._container, t.style);
+  }, [t.style]), null;
+}
+L(A(ut));
+function ft(t) {
+  const e = x(({ mapLib: n }) => new n.NavigationControl(t), {
+    position: t.position
+  });
+  return h(() => {
+    S(e._container, t.style);
+  }, [t.style]), null;
+}
+const _t = L(ft);
+function dt(t) {
+  const e = x(({ mapLib: i }) => new i.ScaleControl(t), {
+    position: t.position
+  }), n = b(t), r = n.current;
+  n.current = t;
+  const { style: o } = t;
+  return t.maxWidth !== void 0 && t.maxWidth !== r.maxWidth && (e.options.maxWidth = t.maxWidth), t.unit !== void 0 && t.unit !== r.unit && e.setUnit(t.unit), h(() => {
+    S(e._container, o);
+  }, [o]), null;
+}
+L(dt);
+export {
+  pt as M,
+  _t as N,
+  vt as P,
+  yt as a,
+  R as b,
+  v as d,
+  gt as u
+};