react-three-map 0.0.0

package/dist/my-lib.es.js

@@ -0,0 +1,1538 @@
+import * as W from "react";
+import ot, { useContext as U, useMemo as z, useLayoutEffect as It, useEffect as M, useState as _e, useRef as D, useImperativeHandle as oe, memo as I, forwardRef as Ee, useCallback as Nt, useId as Wt } from "react";
+import { createEvents as Ut, createRoot as Vt, extend as $t } from "@react-three/fiber";
+import { createPortal as at } from "react-dom";
+import * as Yt from "three";
+import { Quaternion as Bt, Euler as Ht, Vector3 as it, Matrix4 as qt } from "three";
+import { MercatorCoordinate as Zt } from "maplibre-gl";
+var pe = { exports: {} }, G = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Be;
+function Gt() {
+  if (Be)
+    return G;
+  Be = 1;
+  var e = ot, n = Symbol.for("react.element"), o = Symbol.for("react.fragment"), r = Object.prototype.hasOwnProperty, a = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, i = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function s(f, u, d) {
+    var m, h = {}, C = null, T = null;
+    d !== void 0 && (C = "" + d), u.key !== void 0 && (C = "" + u.key), u.ref !== void 0 && (T = u.ref);
+    for (m in u)
+      r.call(u, m) && !i.hasOwnProperty(m) && (h[m] = u[m]);
+    if (f && f.defaultProps)
+      for (m in u = f.defaultProps, u)
+        h[m] === void 0 && (h[m] = u[m]);
+    return { $$typeof: n, type: f, key: C, ref: T, props: h, _owner: a.current };
+  }
+  return G.Fragment = o, G.jsx = s, G.jsxs = s, G;
+}
+var J = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var He;
+function Jt() {
+  return He || (He = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = ot, n = Symbol.for("react.element"), o = Symbol.for("react.portal"), r = Symbol.for("react.fragment"), a = Symbol.for("react.strict_mode"), i = Symbol.for("react.profiler"), s = Symbol.for("react.provider"), f = Symbol.for("react.context"), u = Symbol.for("react.forward_ref"), d = Symbol.for("react.suspense"), m = Symbol.for("react.suspense_list"), h = Symbol.for("react.memo"), C = Symbol.for("react.lazy"), T = Symbol.for("react.offscreen"), S = Symbol.iterator, Q = "@@iterator";
+    function ae(t) {
+      if (t === null || typeof t != "object")
+        return null;
+      var c = S && t[S] || t[Q];
+      return typeof c == "function" ? c : null;
+    }
+    var L = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function E(t) {
+      {
+        for (var c = arguments.length, l = new Array(c > 1 ? c - 1 : 0), v = 1; v < c; v++)
+          l[v - 1] = arguments[v];
+        O("error", t, l);
+      }
+    }
+    function O(t, c, l) {
+      {
+        var v = L.ReactDebugCurrentFrame, y = v.getStackAddendum();
+        y !== "" && (c += "%s", l = l.concat([y]));
+        var _ = l.map(function(p) {
+          return String(p);
+        });
+        _.unshift("Warning: " + c), Function.prototype.apply.call(console[t], console, _);
+      }
+    }
+    var w = !1, j = !1, ct = !1, ut = !1, lt = !1, be;
+    be = Symbol.for("react.module.reference");
+    function ft(t) {
+      return !!(typeof t == "string" || typeof t == "function" || t === r || t === i || lt || t === a || t === d || t === m || ut || t === T || w || j || ct || typeof t == "object" && t !== null && (t.$$typeof === C || t.$$typeof === h || t.$$typeof === s || t.$$typeof === f || t.$$typeof === u || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      t.$$typeof === be || t.getModuleId !== void 0));
+    }
+    function dt(t, c, l) {
+      var v = t.displayName;
+      if (v)
+        return v;
+      var y = c.displayName || c.name || "";
+      return y !== "" ? l + "(" + y + ")" : l;
+    }
+    function Re(t) {
+      return t.displayName || "Context";
+    }
+    function A(t) {
+      if (t == null)
+        return null;
+      if (typeof t.tag == "number" && E("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof t == "function")
+        return t.displayName || t.name || null;
+      if (typeof t == "string")
+        return t;
+      switch (t) {
+        case r:
+          return "Fragment";
+        case o:
+          return "Portal";
+        case i:
+          return "Profiler";
+        case a:
+          return "StrictMode";
+        case d:
+          return "Suspense";
+        case m:
+          return "SuspenseList";
+      }
+      if (typeof t == "object")
+        switch (t.$$typeof) {
+          case f:
+            var c = t;
+            return Re(c) + ".Consumer";
+          case s:
+            var l = t;
+            return Re(l._context) + ".Provider";
+          case u:
+            return dt(t, t.render, "ForwardRef");
+          case h:
+            var v = t.displayName || null;
+            return v !== null ? v : A(t.type) || "Memo";
+          case C: {
+            var y = t, _ = y._payload, p = y._init;
+            try {
+              return A(p(_));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var N = Object.assign, q = 0, Ce, we, Te, Se, xe, Le, Me;
+    function Oe() {
+    }
+    Oe.__reactDisabledLog = !0;
+    function mt() {
+      {
+        if (q === 0) {
+          Ce = console.log, we = console.info, Te = console.warn, Se = console.error, xe = console.group, Le = console.groupCollapsed, Me = console.groupEnd;
+          var t = {
+            configurable: !0,
+            enumerable: !0,
+            value: Oe,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: t,
+            log: t,
+            warn: t,
+            error: t,
+            group: t,
+            groupCollapsed: t,
+            groupEnd: t
+          });
+        }
+        q++;
+      }
+    }
+    function vt() {
+      {
+        if (q--, q === 0) {
+          var t = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: N({}, t, {
+              value: Ce
+            }),
+            info: N({}, t, {
+              value: we
+            }),
+            warn: N({}, t, {
+              value: Te
+            }),
+            error: N({}, t, {
+              value: Se
+            }),
+            group: N({}, t, {
+              value: xe
+            }),
+            groupCollapsed: N({}, t, {
+              value: Le
+            }),
+            groupEnd: N({}, t, {
+              value: Me
+            })
+          });
+        }
+        q < 0 && E("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ie = L.ReactCurrentDispatcher, se;
+    function X(t, c, l) {
+      {
+        if (se === void 0)
+          try {
+            throw Error();
+          } catch (y) {
+            var v = y.stack.trim().match(/\n( *(at )?)/);
+            se = v && v[1] || "";
+          }
+        return `
+` + se + t;
+      }
+    }
+    var ce = !1, ee;
+    {
+      var ht = typeof WeakMap == "function" ? WeakMap : Map;
+      ee = new ht();
+    }
+    function ke(t, c) {
+      if (!t || ce)
+        return "";
+      {
+        var l = ee.get(t);
+        if (l !== void 0)
+          return l;
+      }
+      var v;
+      ce = !0;
+      var y = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var _;
+      _ = ie.current, ie.current = null, mt();
+      try {
+        if (c) {
+          var p = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(p.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(p, []);
+            } catch (F) {
+              v = F;
+            }
+            Reflect.construct(t, [], p);
+          } else {
+            try {
+              p.call();
+            } catch (F) {
+              v = F;
+            }
+            t.call(p.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (F) {
+            v = F;
+          }
+          t();
+        }
+      } catch (F) {
+        if (F && v && typeof F.stack == "string") {
+          for (var g = F.stack.split(`
+`), x = v.stack.split(`
+`), b = g.length - 1, R = x.length - 1; b >= 1 && R >= 0 && g[b] !== x[R]; )
+            R--;
+          for (; b >= 1 && R >= 0; b--, R--)
+            if (g[b] !== x[R]) {
+              if (b !== 1 || R !== 1)
+                do
+                  if (b--, R--, R < 0 || g[b] !== x[R]) {
+                    var k = `
+` + g[b].replace(" at new ", " at ");
+                    return t.displayName && k.includes("<anonymous>") && (k = k.replace("<anonymous>", t.displayName)), typeof t == "function" && ee.set(t, k), k;
+                  }
+                while (b >= 1 && R >= 0);
+              break;
+            }
+        }
+      } finally {
+        ce = !1, ie.current = _, vt(), Error.prepareStackTrace = y;
+      }
+      var Y = t ? t.displayName || t.name : "", Ye = Y ? X(Y) : "";
+      return typeof t == "function" && ee.set(t, Ye), Ye;
+    }
+    function gt(t, c, l) {
+      return ke(t, !1);
+    }
+    function pt(t) {
+      var c = t.prototype;
+      return !!(c && c.isReactComponent);
+    }
+    function te(t, c, l) {
+      if (t == null)
+        return "";
+      if (typeof t == "function")
+        return ke(t, pt(t));
+      if (typeof t == "string")
+        return X(t);
+      switch (t) {
+        case d:
+          return X("Suspense");
+        case m:
+          return X("SuspenseList");
+      }
+      if (typeof t == "object")
+        switch (t.$$typeof) {
+          case u:
+            return gt(t.render);
+          case h:
+            return te(t.type, c, l);
+          case C: {
+            var v = t, y = v._payload, _ = v._init;
+            try {
+              return te(_(y), c, l);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var ne = Object.prototype.hasOwnProperty, Pe = {}, je = L.ReactDebugCurrentFrame;
+    function re(t) {
+      if (t) {
+        var c = t._owner, l = te(t.type, t._source, c ? c.type : null);
+        je.setExtraStackFrame(l);
+      } else
+        je.setExtraStackFrame(null);
+    }
+    function yt(t, c, l, v, y) {
+      {
+        var _ = Function.call.bind(ne);
+        for (var p in t)
+          if (_(t, p)) {
+            var g = void 0;
+            try {
+              if (typeof t[p] != "function") {
+                var x = Error((v || "React class") + ": " + l + " type `" + p + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof t[p] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw x.name = "Invariant Violation", x;
+              }
+              g = t[p](c, p, v, l, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (b) {
+              g = b;
+            }
+            g && !(g instanceof Error) && (re(y), E("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", v || "React class", l, p, typeof g), re(null)), g instanceof Error && !(g.message in Pe) && (Pe[g.message] = !0, re(y), E("Failed %s type: %s", l, g.message), re(null));
+          }
+      }
+    }
+    var _t = Array.isArray;
+    function ue(t) {
+      return _t(t);
+    }
+    function Et(t) {
+      {
+        var c = typeof Symbol == "function" && Symbol.toStringTag, l = c && t[Symbol.toStringTag] || t.constructor.name || "Object";
+        return l;
+      }
+    }
+    function bt(t) {
+      try {
+        return Ae(t), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Ae(t) {
+      return "" + t;
+    }
+    function Fe(t) {
+      if (bt(t))
+        return E("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Et(t)), Ae(t);
+    }
+    var Z = L.ReactCurrentOwner, Rt = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, De, ze, le;
+    le = {};
+    function Ct(t) {
+      if (ne.call(t, "ref")) {
+        var c = Object.getOwnPropertyDescriptor(t, "ref").get;
+        if (c && c.isReactWarning)
+          return !1;
+      }
+      return t.ref !== void 0;
+    }
+    function wt(t) {
+      if (ne.call(t, "key")) {
+        var c = Object.getOwnPropertyDescriptor(t, "key").get;
+        if (c && c.isReactWarning)
+          return !1;
+      }
+      return t.key !== void 0;
+    }
+    function Tt(t, c) {
+      if (typeof t.ref == "string" && Z.current && c && Z.current.stateNode !== c) {
+        var l = A(Z.current.type);
+        le[l] || (E('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', A(Z.current.type), t.ref), le[l] = !0);
+      }
+    }
+    function St(t, c) {
+      {
+        var l = function() {
+          De || (De = !0, E("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", c));
+        };
+        l.isReactWarning = !0, Object.defineProperty(t, "key", {
+          get: l,
+          configurable: !0
+        });
+      }
+    }
+    function xt(t, c) {
+      {
+        var l = function() {
+          ze || (ze = !0, E("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", c));
+        };
+        l.isReactWarning = !0, Object.defineProperty(t, "ref", {
+          get: l,
+          configurable: !0
+        });
+      }
+    }
+    var Lt = function(t, c, l, v, y, _, p) {
+      var g = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: n,
+        // Built-in properties that belong on the element
+        type: t,
+        key: c,
+        ref: l,
+        props: p,
+        // Record the component responsible for creating this element.
+        _owner: _
+      };
+      return g._store = {}, Object.defineProperty(g._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(g, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: v
+      }), Object.defineProperty(g, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: y
+      }), Object.freeze && (Object.freeze(g.props), Object.freeze(g)), g;
+    };
+    function Mt(t, c, l, v, y) {
+      {
+        var _, p = {}, g = null, x = null;
+        l !== void 0 && (Fe(l), g = "" + l), wt(c) && (Fe(c.key), g = "" + c.key), Ct(c) && (x = c.ref, Tt(c, y));
+        for (_ in c)
+          ne.call(c, _) && !Rt.hasOwnProperty(_) && (p[_] = c[_]);
+        if (t && t.defaultProps) {
+          var b = t.defaultProps;
+          for (_ in b)
+            p[_] === void 0 && (p[_] = b[_]);
+        }
+        if (g || x) {
+          var R = typeof t == "function" ? t.displayName || t.name || "Unknown" : t;
+          g && St(p, R), x && xt(p, R);
+        }
+        return Lt(t, g, x, y, v, Z.current, p);
+      }
+    }
+    var fe = L.ReactCurrentOwner, Ie = L.ReactDebugCurrentFrame;
+    function $(t) {
+      if (t) {
+        var c = t._owner, l = te(t.type, t._source, c ? c.type : null);
+        Ie.setExtraStackFrame(l);
+      } else
+        Ie.setExtraStackFrame(null);
+    }
+    var de;
+    de = !1;
+    function me(t) {
+      return typeof t == "object" && t !== null && t.$$typeof === n;
+    }
+    function Ne() {
+      {
+        if (fe.current) {
+          var t = A(fe.current.type);
+          if (t)
+            return `
+
+Check the render method of \`` + t + "`.";
+        }
+        return "";
+      }
+    }
+    function Ot(t) {
+      {
+        if (t !== void 0) {
+          var c = t.fileName.replace(/^.*[\\\/]/, ""), l = t.lineNumber;
+          return `
+
+Check your code at ` + c + ":" + l + ".";
+        }
+        return "";
+      }
+    }
+    var We = {};
+    function kt(t) {
+      {
+        var c = Ne();
+        if (!c) {
+          var l = typeof t == "string" ? t : t.displayName || t.name;
+          l && (c = `
+
+Check the top-level render call using <` + l + ">.");
+        }
+        return c;
+      }
+    }
+    function Ue(t, c) {
+      {
+        if (!t._store || t._store.validated || t.key != null)
+          return;
+        t._store.validated = !0;
+        var l = kt(c);
+        if (We[l])
+          return;
+        We[l] = !0;
+        var v = "";
+        t && t._owner && t._owner !== fe.current && (v = " It was passed a child from " + A(t._owner.type) + "."), $(t), E('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', l, v), $(null);
+      }
+    }
+    function Ve(t, c) {
+      {
+        if (typeof t != "object")
+          return;
+        if (ue(t))
+          for (var l = 0; l < t.length; l++) {
+            var v = t[l];
+            me(v) && Ue(v, c);
+          }
+        else if (me(t))
+          t._store && (t._store.validated = !0);
+        else if (t) {
+          var y = ae(t);
+          if (typeof y == "function" && y !== t.entries)
+            for (var _ = y.call(t), p; !(p = _.next()).done; )
+              me(p.value) && Ue(p.value, c);
+        }
+      }
+    }
+    function Pt(t) {
+      {
+        var c = t.type;
+        if (c == null || typeof c == "string")
+          return;
+        var l;
+        if (typeof c == "function")
+          l = c.propTypes;
+        else if (typeof c == "object" && (c.$$typeof === u || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        c.$$typeof === h))
+          l = c.propTypes;
+        else
+          return;
+        if (l) {
+          var v = A(c);
+          yt(l, t.props, "prop", v, t);
+        } else if (c.PropTypes !== void 0 && !de) {
+          de = !0;
+          var y = A(c);
+          E("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", y || "Unknown");
+        }
+        typeof c.getDefaultProps == "function" && !c.getDefaultProps.isReactClassApproved && E("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function jt(t) {
+      {
+        for (var c = Object.keys(t.props), l = 0; l < c.length; l++) {
+          var v = c[l];
+          if (v !== "children" && v !== "key") {
+            $(t), E("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", v), $(null);
+            break;
+          }
+        }
+        t.ref !== null && ($(t), E("Invalid attribute `ref` supplied to `React.Fragment`."), $(null));
+      }
+    }
+    function $e(t, c, l, v, y, _) {
+      {
+        var p = ft(t);
+        if (!p) {
+          var g = "";
+          (t === void 0 || typeof t == "object" && t !== null && Object.keys(t).length === 0) && (g += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var x = Ot(y);
+          x ? g += x : g += Ne();
+          var b;
+          t === null ? b = "null" : ue(t) ? b = "array" : t !== void 0 && t.$$typeof === n ? (b = "<" + (A(t.type) || "Unknown") + " />", g = " Did you accidentally export a JSX literal instead of a component?") : b = typeof t, E("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", b, g);
+        }
+        var R = Mt(t, c, l, y, _);
+        if (R == null)
+          return R;
+        if (p) {
+          var k = c.children;
+          if (k !== void 0)
+            if (v)
+              if (ue(k)) {
+                for (var Y = 0; Y < k.length; Y++)
+                  Ve(k[Y], t);
+                Object.freeze && Object.freeze(k);
+              } else
+                E("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Ve(k, t);
+        }
+        return t === r ? jt(R) : Pt(R), R;
+      }
+    }
+    function At(t, c, l) {
+      return $e(t, c, l, !0);
+    }
+    function Ft(t, c, l) {
+      return $e(t, c, l, !1);
+    }
+    var Dt = Ft, zt = At;
+    J.Fragment = r, J.jsx = Dt, J.jsxs = zt;
+  }()), J;
+}
+process.env.NODE_ENV === "production" ? pe.exports = Gt() : pe.exports = Jt();
+var ve = pe.exports;
+const st = W.createContext(null);
+function Kt() {
+  var e;
+  const n = (e = U(st)) === null || e === void 0 ? void 0 : e.maps, o = U(H);
+  return z(() => ({ ...n, current: o == null ? void 0 : o.map }), [n, o]);
+}
+function Qt(e) {
+  const n = e.clone();
+  return n.pixelsToGLUnits = e.pixelsToGLUnits, n;
+}
+function qe(e) {
+  return {
+    longitude: e.center.lng,
+    latitude: e.center.lat,
+    zoom: e.zoom,
+    pitch: e.pitch,
+    bearing: e.bearing,
+    padding: e.padding
+  };
+}
+function Ze(e, n) {
+  const o = n.viewState || n;
+  let r = !1;
+  if ("longitude" in o && "latitude" in o) {
+    const a = e.center;
+    e.center = new a.constructor(o.longitude, o.latitude), r = r || a !== e.center;
+  }
+  if ("zoom" in o) {
+    const a = e.zoom;
+    e.zoom = o.zoom, r = r || a !== e.zoom;
+  }
+  if ("bearing" in o) {
+    const a = e.bearing;
+    e.bearing = o.bearing, r = r || a !== e.bearing;
+  }
+  if ("pitch" in o) {
+    const a = e.pitch;
+    e.pitch = o.pitch, r = r || a !== e.pitch;
+  }
+  return o.padding && !e.isPaddingEqual(o.padding) && (r = !0, e.padding = o.padding), r;
+}
+const Xt = ["type", "source", "source-layer", "minzoom", "maxzoom", "filter", "layout"];
+function Ge(e) {
+  if (!e)
+    return null;
+  if (typeof e == "string" || ("toJS" in e && (e = e.toJS()), !e.layers))
+    return e;
+  const n = {};
+  for (const r of e.layers)
+    n[r.id] = r;
+  const o = e.layers.map((r) => {
+    let a = null;
+    "interactive" in r && (a = Object.assign({}, r), delete a.interactive);
+    const i = n[r.ref];
+    if (i) {
+      a = a || Object.assign({}, r), delete a.ref;
+      for (const s of Xt)
+        s in i && (a[s] = i[s]);
+    }
+    return a || r;
+  });
+  return { ...e, layers: o };
+}
+function en(e, n) {
+  const o = Array.isArray(e) ? e[0] : e ? e.x : 0, r = Array.isArray(e) ? e[1] : e ? e.y : 0, a = Array.isArray(n) ? n[0] : n ? n.x : 0, i = Array.isArray(n) ? n[1] : n ? n.y : 0;
+  return o === a && r === i;
+}
+function P(e, n) {
+  if (e === n)
+    return !0;
+  if (!e || !n)
+    return !1;
+  if (Array.isArray(e)) {
+    if (!Array.isArray(n) || e.length !== n.length)
+      return !1;
+    for (let o = 0; o < e.length; o++)
+      if (!P(e[o], n[o]))
+        return !1;
+    return !0;
+  } else if (Array.isArray(n))
+    return !1;
+  if (typeof e == "object" && typeof n == "object") {
+    const o = Object.keys(e), r = Object.keys(n);
+    if (o.length !== r.length)
+      return !1;
+    for (const a of o)
+      if (!n.hasOwnProperty(a) || !P(e[a], n[a]))
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+const Je = { version: 8, sources: {}, layers: [] }, Ke = {
+  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"
+}, he = {
+  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"
+}, Qe = {
+  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"
+}, tn = [
+  "minZoom",
+  "maxZoom",
+  "minPitch",
+  "maxPitch",
+  "maxBounds",
+  "projection",
+  "renderWorldCopies"
+], nn = [
+  "scrollZoom",
+  "boxZoom",
+  "dragRotate",
+  "dragPan",
+  "keyboard",
+  "doubleClickZoom",
+  "touchZoomRotate",
+  "touchPitch"
+];
+class B {
+  constructor(n, o, 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 = (a) => {
+      const i = this.props[Qe[a.type]];
+      i ? i(a) : a.type === "error" && console.error(a.error);
+    }, this._onPointerEvent = (a) => {
+      (a.type === "mousemove" || a.type === "mouseout") && this._updateHover(a);
+      const i = this.props[Ke[a.type]];
+      i && (this.props.interactiveLayerIds && a.type !== "mouseover" && a.type !== "mouseout" && (a.features = this._hoveredFeatures || this._queryRenderedFeatures(a.point)), i(a), delete a.features);
+    }, this._onCameraEvent = (a) => {
+      if (!this._internalUpdate) {
+        const i = this.props[he[a.type]];
+        i && i(a);
+      }
+      a.type in this._deferredEvents && (this._deferredEvents[a.type] = !1);
+    }, this._MapClass = n, this.props = o, this._initialize(r);
+  }
+  get map() {
+    return this._map;
+  }
+  get transform() {
+    return this._renderTransform;
+  }
+  setProps(n) {
+    const o = this.props;
+    this.props = n;
+    const r = this._updateSettings(n, o);
+    r && this._createShadowTransform(this._map);
+    const a = this._updateSize(n), i = this._updateViewState(n, !0);
+    this._updateStyle(n, o), this._updateStyleComponents(n, o), this._updateHandlers(n, o), (r || a || i && !this._map.isMoving()) && this.redraw();
+  }
+  static reuse(n, o) {
+    const r = B.savedMaps.pop();
+    if (!r)
+      return null;
+    const a = r.map, i = a.getContainer();
+    for (o.className = i.className; i.childNodes.length > 0; )
+      o.appendChild(i.childNodes[0]);
+    a._container = o;
+    const s = a._resizeObserver;
+    s && (s.disconnect(), s.observe(o)), r.setProps({ ...n, styleDiffing: !1 }), a.resize();
+    const { initialViewState: f } = n;
+    return f && (f.bounds ? a.fitBounds(f.bounds, { ...f.fitBoundsOptions, duration: 0 }) : r._updateViewState(f, !1)), a.isStyleLoaded() ? a.fire("load") : a.once("styledata", () => a.fire("load")), a._update(), r;
+  }
+  /* eslint-disable complexity,max-statements */
+  _initialize(n) {
+    const { props: o } = this, { mapStyle: r = Je } = o, a = {
+      ...o,
+      ...o.initialViewState,
+      accessToken: o.mapboxAccessToken || rn() || null,
+      container: n,
+      style: Ge(r)
+    }, i = a.initialViewState || a.viewState || a;
+    if (Object.assign(a, {
+      center: [i.longitude || 0, i.latitude || 0],
+      zoom: i.zoom || 0,
+      pitch: i.pitch || 0,
+      bearing: i.bearing || 0
+    }), o.gl) {
+      const m = HTMLCanvasElement.prototype.getContext;
+      HTMLCanvasElement.prototype.getContext = () => (HTMLCanvasElement.prototype.getContext = m, o.gl);
+    }
+    const s = new this._MapClass(a);
+    i.padding && s.setPadding(i.padding), o.cursor && (s.getCanvas().style.cursor = o.cursor), this._createShadowTransform(s);
+    const f = s._render;
+    s._render = (m) => {
+      this._inRender = !0, f.call(s, m), this._inRender = !1;
+    };
+    const u = s._renderTaskQueue.run;
+    s._renderTaskQueue.run = (m) => {
+      u.call(s._renderTaskQueue, m), this._onBeforeRepaint();
+    }, s.on("render", () => this._onAfterRepaint());
+    const d = s.fire;
+    s.fire = this._fireEvent.bind(this, d), s.on("resize", () => {
+      this._renderTransform.resize(s.transform.width, s.transform.height);
+    }), s.on("styledata", () => this._updateStyleComponents(this.props, {})), s.on("sourcedata", () => this._updateStyleComponents(this.props, {}));
+    for (const m in Ke)
+      s.on(m, this._onPointerEvent);
+    for (const m in he)
+      s.on(m, this._onCameraEvent);
+    for (const m in Qe)
+      s.on(m, this._onEvent);
+    this._map = s;
+  }
+  /* eslint-enable complexity,max-statements */
+  recycle() {
+    const o = this.map.getContainer().querySelector("[mapboxgl-children]");
+    o == null || o.remove(), B.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 n = this._map;
+    !this._inRender && n.style && (n._frame && (n._frame.cancel(), n._frame = null), n._render());
+  }
+  _createShadowTransform(n) {
+    const o = Qt(n.transform);
+    n.painter.transform = o, this._renderTransform = o;
+  }
+  /* Trigger map resize if size is controlled
+     @param {object} nextProps
+     @returns {bool} true if size has changed
+   */
+  _updateSize(n) {
+    const { viewState: o } = n;
+    if (o) {
+      const r = this._map;
+      if (o.width !== r.transform.width || o.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(n, o) {
+    if (this._internalUpdate)
+      return !1;
+    const r = this._map, a = this._renderTransform, { zoom: i, pitch: s, bearing: f } = a, u = r.isMoving();
+    u && (a.cameraElevationReference = "sea");
+    const d = Ze(a, {
+      ...qe(r.transform),
+      ...n
+    });
+    if (u && (a.cameraElevationReference = "ground"), d && o) {
+      const m = this._deferredEvents;
+      m.move = !0, m.zoom || (m.zoom = i !== a.zoom), m.rotate || (m.rotate = f !== a.bearing), m.pitch || (m.pitch = s !== a.pitch);
+    }
+    return u || Ze(r.transform, n), d;
+  }
+  /* Update camera constraints and projection settings to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateSettings(n, o) {
+    const r = this._map;
+    let a = !1;
+    for (const i of tn)
+      if (i in n && !P(n[i], o[i])) {
+        a = !0;
+        const s = r[`set${i[0].toUpperCase()}${i.slice(1)}`];
+        s == null || s(n[i]);
+      }
+    return a;
+  }
+  /* Update map style to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if style is changed
+   */
+  _updateStyle(n, o) {
+    if (n.cursor !== o.cursor && (this._map.getCanvas().style.cursor = n.cursor), n.mapStyle !== o.mapStyle) {
+      const { mapStyle: r = Je, styleDiffing: a = !0 } = n, i = {
+        diff: a
+      };
+      return "localIdeographFontFamily" in n && (i.localIdeographFontFamily = n.localIdeographFontFamily), this._map.setStyle(Ge(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(n, o) {
+    const r = this._map;
+    let a = !1;
+    return r.isStyleLoaded() && ("light" in n && r.setLight && !P(n.light, o.light) && (a = !0, r.setLight(n.light)), "fog" in n && r.setFog && !P(n.fog, o.fog) && (a = !0, r.setFog(n.fog)), "terrain" in n && r.setTerrain && !P(n.terrain, o.terrain) && (!n.terrain || r.getSource(n.terrain.source)) && (a = !0, r.setTerrain(n.terrain))), a;
+  }
+  /* Update interaction handlers to match props
+     @param {object} nextProps
+     @param {object} currProps
+     @returns {bool} true if anything is changed
+   */
+  _updateHandlers(n, o) {
+    var r, a;
+    const i = this._map;
+    let s = !1;
+    for (const f of nn) {
+      const u = (r = n[f]) !== null && r !== void 0 ? r : !0, d = (a = o[f]) !== null && a !== void 0 ? a : !0;
+      P(u, d) || (s = !0, u ? i[f].enable(u) : i[f].disable());
+    }
+    return s;
+  }
+  _queryRenderedFeatures(n) {
+    const o = this._map, { interactiveLayerIds: r = [] } = this.props;
+    try {
+      return o.queryRenderedFeatures(n, {
+        layers: r.filter(o.getLayer.bind(o))
+      });
+    } catch {
+      return [];
+    }
+  }
+  _updateHover(n) {
+    var o;
+    const { props: r } = this;
+    if (r.interactiveLayerIds && (r.onMouseMove || r.onMouseEnter || r.onMouseLeave)) {
+      const i = n.type, s = ((o = this._hoveredFeatures) === null || o === void 0 ? void 0 : o.length) > 0, f = this._queryRenderedFeatures(n.point), u = f.length > 0;
+      !u && s && (n.type = "mouseleave", this._onPointerEvent(n)), this._hoveredFeatures = f, u && !s && (n.type = "mouseenter", this._onPointerEvent(n)), n.type = i;
+    } else
+      this._hoveredFeatures = null;
+  }
+  _fireEvent(n, o, r) {
+    const a = this._map, i = a.transform, s = typeof o == "string" ? o : o.type;
+    return s === "move" && this._updateViewState(this.props, !1), s in he && (typeof o == "object" && (o.viewState = qe(i)), this._map.isMoving()) ? (a.transform = this._renderTransform, n.call(a, o, r), a.transform = i, a) : (n.call(a, o, r), a);
+  }
+  // All camera manipulations are complete, ready to repaint
+  _onBeforeRepaint() {
+    const n = this._map;
+    this._internalUpdate = !0;
+    for (const r in this._deferredEvents)
+      this._deferredEvents[r] && n.fire(r);
+    this._internalUpdate = !1;
+    const o = this._map.transform;
+    this._map.transform = this._renderTransform, this._onAfterRepaint = () => {
+      this._map.transform = o;
+    };
+  }
+}
+B.savedMaps = [];
+function rn() {
+  let e = null;
+  if (typeof location < "u") {
+    const n = /access_token=([^&\/]*)/.exec(location.search);
+    e = n && n[1];
+  }
+  try {
+    e = e || process.env.MapboxAccessToken;
+  } catch {
+  }
+  try {
+    e = e || process.env.REACT_APP_MAPBOX_ACCESS_TOKEN;
+  } catch {
+  }
+  return e;
+}
+const on = [
+  "setMaxBounds",
+  "setMinZoom",
+  "setMaxZoom",
+  "setMinPitch",
+  "setMaxPitch",
+  "setRenderWorldCopies",
+  "setProjection",
+  "setStyle",
+  "addSource",
+  "removeSource",
+  "addLayer",
+  "removeLayer",
+  "setLayerZoomRange",
+  "setFilter",
+  "setPaintProperty",
+  "setLayoutProperty",
+  "setLight",
+  "setTerrain",
+  "setFog",
+  "remove"
+];
+function an(e) {
+  if (!e)
+    return null;
+  const n = e.map, o = {
+    getMap: () => n,
+    // 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: (r) => {
+      const a = n.transform;
+      n.transform = e.transform;
+      const i = n.project(r);
+      return n.transform = a, i;
+    },
+    unproject: (r) => {
+      const a = n.transform;
+      n.transform = e.transform;
+      const i = n.unproject(r);
+      return n.transform = a, i;
+    },
+    // options diverge between mapbox and maplibre
+    queryTerrainElevation: (r, a) => {
+      const i = n.transform;
+      n.transform = e.transform;
+      const s = n.queryTerrainElevation(r, a);
+      return n.transform = i, s;
+    }
+  };
+  for (const r of sn(n))
+    !(r in o) && !on.includes(r) && (o[r] = n[r].bind(n));
+  return o;
+}
+function sn(e) {
+  const n = /* @__PURE__ */ new Set();
+  let o = e;
+  for (; o; ) {
+    for (const r of Object.getOwnPropertyNames(o))
+      r[0] !== "_" && typeof e[r] == "function" && r !== "fire" && r !== "setEventedParent" && n.add(r);
+    o = Object.getPrototypeOf(o);
+  }
+  return Array.from(n);
+}
+const cn = typeof document < "u" ? It : M, un = [
+  "baseApiUrl",
+  "maxParallelImageRequests",
+  "workerClass",
+  "workerCount",
+  "workerUrl"
+];
+function ln(e, n) {
+  for (const r of un)
+    r in n && (e[r] = n[r]);
+  const { RTLTextPlugin: o = "https://api.mapbox.com/mapbox-gl-js/plugins/mapbox-gl-rtl-text/v0.2.3/mapbox-gl-rtl-text.js" } = n;
+  o && e.getRTLTextPluginStatus && e.getRTLTextPluginStatus() === "unavailable" && e.setRTLTextPlugin(o, (r) => {
+    r && console.error(r);
+  }, !1);
+}
+const H = W.createContext(null);
+function fn(e, n, o) {
+  const r = U(st), [a, i] = _e(null), s = D(), { current: f } = D({ mapLib: null, map: null });
+  M(() => {
+    const m = e.mapLib;
+    let h = !0, C;
+    return Promise.resolve(m || o).then((T) => {
+      if (!h)
+        return;
+      if (!T)
+        throw new Error("Invalid mapLib");
+      const S = "Map" in T ? T : T.default;
+      if (!S.Map)
+        throw new Error("Invalid mapLib");
+      if (ln(S, e), !S.supported || S.supported(e))
+        e.reuseMaps && (C = B.reuse(e, s.current)), C || (C = new B(S.Map, e, s.current)), f.map = an(C), f.mapLib = S, i(C), r == null || r.onMapMount(f.map, e.id);
+      else
+        throw new Error("Map is not supported by this browser");
+    }).catch((T) => {
+      const { onError: S } = e;
+      S ? S({
+        type: "error",
+        target: null,
+        originalEvent: null,
+        error: T
+      }) : console.error(T);
+    }), () => {
+      h = !1, C && (r == null || r.onMapUnmount(e.id), e.reuseMaps ? C.recycle() : C.destroy());
+    };
+  }, []), cn(() => {
+    a && a.setProps(e);
+  }), oe(n, () => f.map, [a]);
+  const u = z(() => ({
+    position: "relative",
+    width: "100%",
+    height: "100%",
+    ...e.style
+  }), [e.style]), d = {
+    height: "100%"
+  };
+  return W.createElement("div", { id: e.id, ref: s, style: u }, a && W.createElement(
+    H.Provider,
+    { value: f },
+    W.createElement("div", { "mapboxgl-children": "", style: d }, e.children)
+  ));
+}
+const dn = /box|flex|grid|column|lineHeight|fontWeight|opacity|order|tabSize|zIndex/;
+function V(e, n) {
+  if (!e || !n)
+    return;
+  const o = e.style;
+  for (const r in n) {
+    const a = n[r];
+    Number.isFinite(a) && !dn.test(r) ? o[r] = `${a}px` : o[r] = a;
+  }
+}
+function mn(e, n) {
+  const { map: o, mapLib: r } = U(H), a = D({ props: e });
+  a.current.props = e;
+  const i = z(() => {
+    let Q = !1;
+    W.Children.forEach(e.children, (E) => {
+      E && (Q = !0);
+    });
+    const ae = {
+      ...e,
+      element: Q ? document.createElement("div") : null
+    }, L = new r.Marker(ae);
+    return L.setLngLat([e.longitude, e.latitude]), L.getElement().addEventListener("click", (E) => {
+      var O, w;
+      (w = (O = a.current.props).onClick) === null || w === void 0 || w.call(O, {
+        type: "click",
+        target: L,
+        originalEvent: E
+      });
+    }), L.on("dragstart", (E) => {
+      var O, w;
+      const j = E;
+      j.lngLat = i.getLngLat(), (w = (O = a.current.props).onDragStart) === null || w === void 0 || w.call(O, j);
+    }), L.on("drag", (E) => {
+      var O, w;
+      const j = E;
+      j.lngLat = i.getLngLat(), (w = (O = a.current.props).onDrag) === null || w === void 0 || w.call(O, j);
+    }), L.on("dragend", (E) => {
+      var O, w;
+      const j = E;
+      j.lngLat = i.getLngLat(), (w = (O = a.current.props).onDragEnd) === null || w === void 0 || w.call(O, j);
+    }), L;
+  }, []);
+  M(() => (i.addTo(o.getMap()), () => {
+    i.remove();
+  }), []);
+  const { longitude: s, latitude: f, offset: u, style: d, draggable: m = !1, popup: h = null, rotation: C = 0, rotationAlignment: T = "auto", pitchAlignment: S = "auto" } = e;
+  return M(() => {
+    V(i.getElement(), d);
+  }, [d]), oe(n, () => i, []), (i.getLngLat().lng !== s || i.getLngLat().lat !== f) && i.setLngLat([s, f]), u && !en(i.getOffset(), u) && i.setOffset(u), i.isDraggable() !== m && i.setDraggable(m), i.getRotation() !== C && i.setRotation(C), i.getRotationAlignment() !== T && i.setRotationAlignment(T), i.getPitchAlignment() !== S && i.setPitchAlignment(S), i.getPopup() !== h && i.setPopup(h), at(e.children, i.getElement());
+}
+I(Ee(mn));
+function Xe(e) {
+  return new Set(e ? e.trim().split(/\s+/) : []);
+}
+function vn(e, n) {
+  const { map: o, mapLib: r } = U(H), a = z(() => document.createElement("div"), []), i = D({ props: e });
+  i.current.props = e;
+  const s = z(() => {
+    const f = { ...e }, u = new r.Popup(f);
+    return u.setLngLat([e.longitude, e.latitude]), u.once("open", (d) => {
+      var m, h;
+      (h = (m = i.current.props).onOpen) === null || h === void 0 || h.call(m, d);
+    }), u;
+  }, []);
+  if (M(() => {
+    const f = (u) => {
+      var d, m;
+      (m = (d = i.current.props).onClose) === null || m === void 0 || m.call(d, u);
+    };
+    return s.on("close", f), s.setDOMContent(a).addTo(o.getMap()), () => {
+      s.off("close", f), s.isOpen() && s.remove();
+    };
+  }, []), M(() => {
+    V(s.getElement(), e.style);
+  }, [e.style]), oe(n, () => s, []), s.isOpen() && ((s.getLngLat().lng !== e.longitude || s.getLngLat().lat !== e.latitude) && s.setLngLat([e.longitude, e.latitude]), e.offset && !P(s.options.offset, e.offset) && s.setOffset(e.offset), (s.options.anchor !== e.anchor || s.options.maxWidth !== e.maxWidth) && (s.options.anchor = e.anchor, s.setMaxWidth(e.maxWidth)), s.options.className !== e.className)) {
+    const f = Xe(s.options.className), u = Xe(e.className);
+    for (const d of f)
+      u.has(d) || s.removeClassName(d);
+    for (const d of u)
+      f.has(d) || s.addClassName(d);
+    s.options.className = e.className;
+  }
+  return at(e.children, a);
+}
+I(Ee(vn));
+function K(e, n, o, r) {
+  const a = U(H), i = z(() => e(a), []);
+  return M(() => {
+    const s = r || o || n, f = typeof n == "function" && typeof o == "function" ? n : null, u = typeof o == "function" ? o : typeof n == "function" ? n : null, { map: d } = a;
+    return d.hasControl(i) || (d.addControl(i, s == null ? void 0 : s.position), f && f(a)), () => {
+      u && u(a), d.hasControl(i) && d.removeControl(i);
+    };
+  }, []), i;
+}
+function hn(e) {
+  const n = K(({ mapLib: o }) => new o.AttributionControl(e), {
+    position: e.position
+  });
+  return M(() => {
+    V(n._container, e.style);
+  }, [e.style]), null;
+}
+I(hn);
+function gn(e) {
+  const n = K(({ mapLib: o }) => new o.FullscreenControl({
+    container: e.containerId && document.getElementById(e.containerId)
+  }), { position: e.position });
+  return M(() => {
+    V(n._controlContainer, e.style);
+  }, [e.style]), null;
+}
+I(gn);
+function pn(e, n) {
+  const o = D({ props: e }), r = K(({ mapLib: a }) => {
+    const i = new a.GeolocateControl(e), s = i._setupUI;
+    return i._setupUI = (f) => {
+      i._container.hasChildNodes() || s(f);
+    }, i.on("geolocate", (f) => {
+      var u, d;
+      (d = (u = o.current.props).onGeolocate) === null || d === void 0 || d.call(u, f);
+    }), i.on("error", (f) => {
+      var u, d;
+      (d = (u = o.current.props).onError) === null || d === void 0 || d.call(u, f);
+    }), i.on("outofmaxbounds", (f) => {
+      var u, d;
+      (d = (u = o.current.props).onOutOfMaxBounds) === null || d === void 0 || d.call(u, f);
+    }), i.on("trackuserlocationstart", (f) => {
+      var u, d;
+      (d = (u = o.current.props).onTrackUserLocationStart) === null || d === void 0 || d.call(u, f);
+    }), i.on("trackuserlocationend", (f) => {
+      var u, d;
+      (d = (u = o.current.props).onTrackUserLocationEnd) === null || d === void 0 || d.call(u, f);
+    }), i;
+  }, { position: e.position });
+  return o.current.props = e, oe(n, () => r, []), M(() => {
+    V(r._container, e.style);
+  }, [e.style]), null;
+}
+I(Ee(pn));
+function yn(e) {
+  const n = K(({ mapLib: o }) => new o.NavigationControl(e), {
+    position: e.position
+  });
+  return M(() => {
+    V(n._container, e.style);
+  }, [e.style]), null;
+}
+I(yn);
+function _n(e) {
+  const n = K(({ mapLib: i }) => new i.ScaleControl(e), {
+    position: e.position
+  }), o = D(e), r = o.current;
+  o.current = e;
+  const { style: a } = e;
+  return e.maxWidth !== void 0 && e.maxWidth !== r.maxWidth && (n.options.maxWidth = e.maxWidth), e.unit !== void 0 && e.unit !== r.unit && n.setUnit(e.unit), M(() => {
+    V(n._container, a);
+  }, [a]), null;
+}
+I(_n);
+function et(e, n) {
+  if (!e)
+    throw new Error(n);
+}
+function En(e, n, o, r) {
+  if (et(o.id === r.id, "layer id changed"), et(o.type === r.type, "layer type changed"), o.type === "custom" || r.type === "custom")
+    return;
+  const {
+    layout: a = {},
+    paint: i = {},
+    // @ts-expect-error filter is not defined on some layer types
+    filter: s,
+    minzoom: f,
+    maxzoom: u,
+    beforeId: d
+  } = o;
+  if (d !== r.beforeId && e.moveLayer(n, d), a !== r.layout) {
+    const m = r.layout || {};
+    for (const h in a)
+      P(a[h], m[h]) || e.setLayoutProperty(n, h, a[h]);
+    for (const h in m)
+      a.hasOwnProperty(h) || e.setLayoutProperty(n, h, void 0);
+  }
+  if (i !== r.paint) {
+    const m = r.paint || {};
+    for (const h in i)
+      P(i[h], m[h]) || e.setPaintProperty(n, h, i[h]);
+    for (const h in m)
+      i.hasOwnProperty(h) || e.setPaintProperty(n, h, void 0);
+  }
+  P(s, r.filter) || e.setFilter(n, s), (f !== r.minzoom || u !== r.maxzoom) && e.setLayerZoomRange(n, f, u);
+}
+function bn(e, n, o) {
+  if (e.style && e.style._loaded && (!("source" in o) || e.getSource(o.source))) {
+    const r = { ...o, id: n };
+    delete r.beforeId, e.addLayer(r, o.beforeId);
+  }
+}
+let Rn = 0;
+function Cn(e) {
+  const n = U(H).map.getMap(), o = D(e), [, r] = _e(0), a = z(() => e.id || `jsx-layer-${Rn++}`, []);
+  if (M(() => {
+    if (n) {
+      const s = () => r((f) => f + 1);
+      return n.on("styledata", s), s(), () => {
+        n.off("styledata", s), n.style && n.style._loaded && n.getLayer(a) && n.removeLayer(a);
+      };
+    }
+  }, [n]), n && n.style && n.getLayer(a))
+    try {
+      En(n, a, e, o.current);
+    } catch (s) {
+      console.warn(s);
+    }
+  else
+    bn(n, a, e);
+  return o.current = e, null;
+}
+function wn() {
+  return Kt();
+}
+const Tn = import("maplibre-gl");
+W.forwardRef(function(n, o) {
+  return fn(n, o, Tn);
+});
+const tt = new Bt(), Sn = new Ht(), nt = new it(), rt = new it(), xn = new qt();
+function Ln({ longitude: e, latitude: n, altitude: o }) {
+  const r = Zt.fromLngLat([e, n], o), a = r.meterInMercatorCoordinateUnits();
+  return nt.set(r.x, r.y, r.z || 0), rt.set(a, -a, a), tt.setFromEuler(Sn.set(-Math.PI * 0.5, 0, 0)), xn.compose(nt, tt, rt);
+}
+const ge = {
+  onClick: ["click", !1],
+  onContextMenu: ["contextmenu", !1],
+  onDoubleClick: ["dblclick", !1],
+  onWheel: ["wheel", !0],
+  onPointerDown: ["pointerdown", !0],
+  onPointerUp: ["pointerup", !0],
+  onPointerLeave: ["pointerleave", !0],
+  onPointerMove: ["pointermove", !0],
+  onPointerCancel: ["pointercancel", !0],
+  onLostPointerCapture: ["lostpointercapture", !0]
+};
+function Mn() {
+  return (e) => {
+    const { handlePointer: n } = Ut(e);
+    return {
+      priority: 1,
+      enabled: !0,
+      compute(o, r) {
+        r.size.width = r.gl.domElement.width, r.size.height = r.gl.domElement.height, r.pointer.x = o.offsetX / (r.size.width / window.devicePixelRatio) * 2 - 1, r.pointer.y = 1 - o.offsetY / (r.size.height / window.devicePixelRatio) * 2, r.raycaster.camera = r.camera, r.raycaster.ray.origin.setScalar(0).applyMatrix4(r.camera.projectionMatrixInverse), r.raycaster.ray.direction.set(r.pointer.x, r.pointer.y, 1).applyMatrix4(r.camera.projectionMatrixInverse).sub(r.raycaster.ray.origin).normalize();
+      },
+      connected: void 0,
+      handlers: Object.keys(ge).reduce(
+        (o, r) => ({ ...o, [r]: n(r) }),
+        {}
+      ),
+      update: () => {
+        var a;
+        const { events: o, internal: r } = e.getState();
+        (a = r.lastEvent) != null && a.current && o.handlers && o.handlers.onPointerMove(r.lastEvent.current);
+      },
+      connect: (o) => {
+        var i;
+        const { set: r, events: a } = e.getState();
+        (i = a.disconnect) == null || i.call(a), r((s) => ({ events: { ...s.events, connected: o } })), Object.entries(a.handlers ?? []).forEach(([s, f]) => {
+          const [u, d] = ge[s];
+          o.addEventListener(u, f, { passive: d });
+        });
+      },
+      disconnect: () => {
+        const { set: o, events: r } = e.getState();
+        r.connected && (Object.entries(r.handlers ?? []).forEach(([a, i]) => {
+          if (r && r.connected instanceof HTMLElement) {
+            const [s] = ge[a];
+            r.connected.removeEventListener(s, i);
+          }
+        }), o((a) => ({ events: { ...a.events, connected: void 0 } })));
+      }
+    };
+  };
+}
+const ye = (e) => {
+  const n = D(e);
+  return n.current = e, Nt((...o) => n.current(...o), []);
+};
+function On(e, n) {
+  const [o, r] = _e(!1), a = ye((s, f) => {
+    const u = s.getCanvas(), d = Vt(u);
+    d.configure({
+      frameloop: "never",
+      dpr: window.devicePixelRatio,
+      shadows: !0,
+      events: Mn(),
+      ...n,
+      gl: {
+        context: f,
+        depth: !0,
+        autoClear: !1,
+        antialias: !0,
+        ...n == null ? void 0 : n.gl
+      },
+      onCreated: (m) => {
+        e.current = {
+          state: m,
+          map: s,
+          root: d
+        }, m.gl.forceContextLoss = () => {
+        };
+      },
+      camera: {
+        matrixAutoUpdate: !1
+      },
+      size: {
+        width: u.clientWidth,
+        height: u.clientHeight,
+        top: 0,
+        left: 0,
+        ...n == null ? void 0 : n.size
+      }
+    }), e.current = {
+      map: s,
+      root: d
+    }, setTimeout(() => r(!0));
+  }), i = ye(() => {
+    setTimeout(() => {
+      e.current && e.current.root.unmount();
+    });
+  });
+  return { onAdd: a, onRemove: i, mounted: o };
+}
+function kn(e, n) {
+  const o = wn();
+  return ye((a, i) => {
+    var d;
+    if (!o.current || !((d = n.current) != null && d.state))
+      return;
+    const s = n.current.state.camera, f = n.current.state.gl, u = n.current.state.advance;
+    s.projectionMatrix.fromArray(i).multiply(e), s.projectionMatrixInverse.copy(s.projectionMatrix).invert(), f.resetState(), u(Date.now(), !0), o.current.triggerRepaint();
+  });
+}
+$t(Yt);
+const zn = I(({
+  longitude: e,
+  latitude: n,
+  altitude: o = 0,
+  children: r,
+  ...a
+}) => {
+  const i = Wt(), s = D(), f = z(() => Ln({
+    latitude: n,
+    longitude: e,
+    altitude: o
+  }), [n, e, o]), { onAdd: u, onRemove: d, mounted: m } = On(s, a), h = kn(f, s);
+  return M(() => {
+    m && s.current && s.current.root.render(/* @__PURE__ */ ve.jsx(ve.Fragment, { children: r }));
+  }, [s, m, r]), /* @__PURE__ */ ve.jsx(
+    Cn,
+    {
+      id: i,
+      type: "custom",
+      renderingMode: "3d",
+      onAdd: u,
+      onRemove: d,
+      render: h
+    }
+  );
+});
+export {
+  zn as Canvas
+};