@neshan-maps-platform/mapbox-gl-react 1.0.5-alpha.1 → 1.0.6-alpha.1

package/dist/neshan-mapbox-sdk-react.es.js

@@ -1,6 +1,5 @@
-import ee, { useRef as I, useEffect as re } from "react";
-import te from "@neshan-maps-platform/mapbox-gl";
-var b = { exports: {} }, p = {};
+import Fe from "@neshan-maps-platform/mapbox-gl";
+var me = { exports: {} }, ie = {};
 /**
  * @license React
  * react-jsx-runtime.production.js
@@ -10,29 +9,1262 @@ var b = { exports: {} }, p = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var F;
-function ne() {
-  if (F) return p;
-  F = 1;
-  var a = Symbol.for("react.transitional.element"), l = Symbol.for("react.fragment");
-  function i(c, s, u) {
-    var f = null;
-    if (u !== void 0 && (f = "" + u), s.key !== void 0 && (f = "" + s.key), "key" in s) {
-      u = {};
-      for (var m in s)
-        m !== "key" && (u[m] = s[m]);
-    } else u = s;
-    return s = u.ref, {
-      $$typeof: a,
-      type: c,
-      key: f,
-      ref: s !== void 0 ? s : null,
-      props: u
+var Ye;
+function Qe() {
+  if (Ye) return ie;
+  Ye = 1;
+  var T = Symbol.for("react.transitional.element"), i = Symbol.for("react.fragment");
+  function P(k, b, R) {
+    var j = null;
+    if (R !== void 0 && (j = "" + R), b.key !== void 0 && (j = "" + b.key), "key" in b) {
+      R = {};
+      for (var C in b)
+        C !== "key" && (R[C] = b[C]);
+    } else R = b;
+    return b = R.ref, {
+      $$typeof: T,
+      type: k,
+      key: j,
+      ref: b !== void 0 ? b : null,
+      props: R
     };
   }
-  return p.Fragment = l, p.jsx = i, p.jsxs = i, p;
+  return ie.Fragment = i, ie.jsx = P, ie.jsxs = P, ie;
+}
+var ce = {}, Ee = { exports: {} }, l = {};
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Le;
+function Ke() {
+  if (Le) return l;
+  Le = 1;
+  var T = Symbol.for("react.transitional.element"), i = Symbol.for("react.portal"), P = Symbol.for("react.fragment"), k = Symbol.for("react.strict_mode"), b = Symbol.for("react.profiler"), R = Symbol.for("react.consumer"), j = Symbol.for("react.context"), C = Symbol.for("react.forward_ref"), N = Symbol.for("react.suspense"), oe = Symbol.for("react.memo"), D = Symbol.for("react.lazy"), H = Symbol.for("react.activity"), z = Symbol.iterator;
+  function q(t) {
+    return t === null || typeof t != "object" ? null : (t = z && t[z] || t["@@iterator"], typeof t == "function" ? t : null);
+  }
+  var G = {
+    isMounted: function() {
+      return !1;
+    },
+    enqueueForceUpdate: function() {
+    },
+    enqueueReplaceState: function() {
+    },
+    enqueueSetState: function() {
+    }
+  }, J = Object.assign, B = {};
+  function I(t, n, s) {
+    this.props = t, this.context = n, this.refs = B, this.updater = s || G;
+  }
+  I.prototype.isReactComponent = {}, I.prototype.setState = function(t, n) {
+    if (typeof t != "object" && typeof t != "function" && t != null)
+      throw Error(
+        "takes an object of state variables to update or a function which returns an object of state variables."
+      );
+    this.updater.enqueueSetState(this, t, n, "setState");
+  }, I.prototype.forceUpdate = function(t) {
+    this.updater.enqueueForceUpdate(this, t, "forceUpdate");
+  };
+  function F() {
+  }
+  F.prototype = I.prototype;
+  function ee(t, n, s) {
+    this.props = t, this.context = n, this.refs = B, this.updater = s || G;
+  }
+  var Q = ee.prototype = new F();
+  Q.constructor = ee, J(Q, I.prototype), Q.isPureReactComponent = !0;
+  var M = Array.isArray;
+  function te() {
+  }
+  var y = { H: null, A: null, T: null, S: null }, ue = Object.prototype.hasOwnProperty;
+  function S(t, n, s) {
+    var a = s.ref;
+    return {
+      $$typeof: T,
+      type: t,
+      key: n,
+      ref: a !== void 0 ? a : null,
+      props: s
+    };
+  }
+  function K(t, n) {
+    return S(t.type, n, t.props);
+  }
+  function re(t) {
+    return typeof t == "object" && t !== null && t.$$typeof === T;
+  }
+  function h(t) {
+    var n = { "=": "=0", ":": "=2" };
+    return "$" + t.replace(/[=:]/g, function(s) {
+      return n[s];
+    });
+  }
+  var V = /\/+/g;
+  function U(t, n) {
+    return typeof t == "object" && t !== null && t.key != null ? h("" + t.key) : n.toString(36);
+  }
+  function Y(t) {
+    switch (t.status) {
+      case "fulfilled":
+        return t.value;
+      case "rejected":
+        throw t.reason;
+      default:
+        switch (typeof t.status == "string" ? t.then(te, te) : (t.status = "pending", t.then(
+          function(n) {
+            t.status === "pending" && (t.status = "fulfilled", t.value = n);
+          },
+          function(n) {
+            t.status === "pending" && (t.status = "rejected", t.reason = n);
+          }
+        )), t.status) {
+          case "fulfilled":
+            return t.value;
+          case "rejected":
+            throw t.reason;
+        }
+    }
+    throw t;
+  }
+  function A(t, n, s, a, d) {
+    var v = typeof t;
+    (v === "undefined" || v === "boolean") && (t = null);
+    var f = !1;
+    if (t === null) f = !0;
+    else
+      switch (v) {
+        case "bigint":
+        case "string":
+        case "number":
+          f = !0;
+          break;
+        case "object":
+          switch (t.$$typeof) {
+            case T:
+            case i:
+              f = !0;
+              break;
+            case D:
+              return f = t._init, A(
+                f(t._payload),
+                n,
+                s,
+                a,
+                d
+              );
+          }
+      }
+    if (f)
+      return d = d(t), f = a === "" ? "." + U(t, 0) : a, M(d) ? (s = "", f != null && (s = f.replace(V, "$&/") + "/"), A(d, n, s, "", function(W) {
+        return W;
+      })) : d != null && (re(d) && (d = K(
+        d,
+        s + (d.key == null || t && t.key === d.key ? "" : ("" + d.key).replace(
+          V,
+          "$&/"
+        ) + "/") + f
+      )), n.push(d)), 1;
+    f = 0;
+    var O = a === "" ? "." : a + ":";
+    if (M(t))
+      for (var w = 0; w < t.length; w++)
+        a = t[w], v = O + U(a, w), f += A(
+          a,
+          n,
+          s,
+          v,
+          d
+        );
+    else if (w = q(t), typeof w == "function")
+      for (t = w.call(t), w = 0; !(a = t.next()).done; )
+        a = a.value, v = O + U(a, w++), f += A(
+          a,
+          n,
+          s,
+          v,
+          d
+        );
+    else if (v === "object") {
+      if (typeof t.then == "function")
+        return A(
+          Y(t),
+          n,
+          s,
+          a,
+          d
+        );
+      throw n = String(t), Error(
+        "Objects are not valid as a React child (found: " + (n === "[object Object]" ? "object with keys {" + Object.keys(t).join(", ") + "}" : n) + "). If you meant to render a collection of children, use an array instead."
+      );
+    }
+    return f;
+  }
+  function L(t, n, s) {
+    if (t == null) return t;
+    var a = [], d = 0;
+    return A(t, a, "", "", function(v) {
+      return n.call(s, v, d++);
+    }), a;
+  }
+  function X(t) {
+    if (t._status === -1) {
+      var n = t._result;
+      n = n(), n.then(
+        function(s) {
+          (t._status === 0 || t._status === -1) && (t._status = 1, t._result = s);
+        },
+        function(s) {
+          (t._status === 0 || t._status === -1) && (t._status = 2, t._result = s);
+        }
+      ), t._status === -1 && (t._status = 0, t._result = n);
+    }
+    if (t._status === 1) return t._result.default;
+    throw t._result;
+  }
+  var x = typeof reportError == "function" ? reportError : function(t) {
+    if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+      var n = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: typeof t == "object" && t !== null && typeof t.message == "string" ? String(t.message) : String(t),
+        error: t
+      });
+      if (!window.dispatchEvent(n)) return;
+    } else if (typeof process == "object" && typeof process.emit == "function") {
+      process.emit("uncaughtException", t);
+      return;
+    }
+    console.error(t);
+  }, ne = {
+    map: L,
+    forEach: function(t, n, s) {
+      L(
+        t,
+        function() {
+          n.apply(this, arguments);
+        },
+        s
+      );
+    },
+    count: function(t) {
+      var n = 0;
+      return L(t, function() {
+        n++;
+      }), n;
+    },
+    toArray: function(t) {
+      return L(t, function(n) {
+        return n;
+      }) || [];
+    },
+    only: function(t) {
+      if (!re(t))
+        throw Error(
+          "React.Children.only expected to receive a single React element child."
+        );
+      return t;
+    }
+  };
+  return l.Activity = H, l.Children = ne, l.Component = I, l.Fragment = P, l.Profiler = b, l.PureComponent = ee, l.StrictMode = k, l.Suspense = N, l.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = y, l.__COMPILER_RUNTIME = {
+    __proto__: null,
+    c: function(t) {
+      return y.H.useMemoCache(t);
+    }
+  }, l.cache = function(t) {
+    return function() {
+      return t.apply(null, arguments);
+    };
+  }, l.cacheSignal = function() {
+    return null;
+  }, l.cloneElement = function(t, n, s) {
+    if (t == null)
+      throw Error(
+        "The argument must be a React element, but you passed " + t + "."
+      );
+    var a = J({}, t.props), d = t.key;
+    if (n != null)
+      for (v in n.key !== void 0 && (d = "" + n.key), n)
+        !ue.call(n, v) || v === "key" || v === "__self" || v === "__source" || v === "ref" && n.ref === void 0 || (a[v] = n[v]);
+    var v = arguments.length - 2;
+    if (v === 1) a.children = s;
+    else if (1 < v) {
+      for (var f = Array(v), O = 0; O < v; O++)
+        f[O] = arguments[O + 2];
+      a.children = f;
+    }
+    return S(t.type, d, a);
+  }, l.createContext = function(t) {
+    return t = {
+      $$typeof: j,
+      _currentValue: t,
+      _currentValue2: t,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null
+    }, t.Provider = t, t.Consumer = {
+      $$typeof: R,
+      _context: t
+    }, t;
+  }, l.createElement = function(t, n, s) {
+    var a, d = {}, v = null;
+    if (n != null)
+      for (a in n.key !== void 0 && (v = "" + n.key), n)
+        ue.call(n, a) && a !== "key" && a !== "__self" && a !== "__source" && (d[a] = n[a]);
+    var f = arguments.length - 2;
+    if (f === 1) d.children = s;
+    else if (1 < f) {
+      for (var O = Array(f), w = 0; w < f; w++)
+        O[w] = arguments[w + 2];
+      d.children = O;
+    }
+    if (t && t.defaultProps)
+      for (a in f = t.defaultProps, f)
+        d[a] === void 0 && (d[a] = f[a]);
+    return S(t, v, d);
+  }, l.createRef = function() {
+    return { current: null };
+  }, l.forwardRef = function(t) {
+    return { $$typeof: C, render: t };
+  }, l.isValidElement = re, l.lazy = function(t) {
+    return {
+      $$typeof: D,
+      _payload: { _status: -1, _result: t },
+      _init: X
+    };
+  }, l.memo = function(t, n) {
+    return {
+      $$typeof: oe,
+      type: t,
+      compare: n === void 0 ? null : n
+    };
+  }, l.startTransition = function(t) {
+    var n = y.T, s = {};
+    y.T = s;
+    try {
+      var a = t(), d = y.S;
+      d !== null && d(s, a), typeof a == "object" && a !== null && typeof a.then == "function" && a.then(te, x);
+    } catch (v) {
+      x(v);
+    } finally {
+      n !== null && s.types !== null && (n.types = s.types), y.T = n;
+    }
+  }, l.unstable_useCacheRefresh = function() {
+    return y.H.useCacheRefresh();
+  }, l.use = function(t) {
+    return y.H.use(t);
+  }, l.useActionState = function(t, n, s) {
+    return y.H.useActionState(t, n, s);
+  }, l.useCallback = function(t, n) {
+    return y.H.useCallback(t, n);
+  }, l.useContext = function(t) {
+    return y.H.useContext(t);
+  }, l.useDebugValue = function() {
+  }, l.useDeferredValue = function(t, n) {
+    return y.H.useDeferredValue(t, n);
+  }, l.useEffect = function(t, n) {
+    return y.H.useEffect(t, n);
+  }, l.useEffectEvent = function(t) {
+    return y.H.useEffectEvent(t);
+  }, l.useId = function() {
+    return y.H.useId();
+  }, l.useImperativeHandle = function(t, n, s) {
+    return y.H.useImperativeHandle(t, n, s);
+  }, l.useInsertionEffect = function(t, n) {
+    return y.H.useInsertionEffect(t, n);
+  }, l.useLayoutEffect = function(t, n) {
+    return y.H.useLayoutEffect(t, n);
+  }, l.useMemo = function(t, n) {
+    return y.H.useMemo(t, n);
+  }, l.useOptimistic = function(t, n) {
+    return y.H.useOptimistic(t, n);
+  }, l.useReducer = function(t, n, s) {
+    return y.H.useReducer(t, n, s);
+  }, l.useRef = function(t) {
+    return y.H.useRef(t);
+  }, l.useState = function(t) {
+    return y.H.useState(t);
+  }, l.useSyncExternalStore = function(t, n, s) {
+    return y.H.useSyncExternalStore(
+      t,
+      n,
+      s
+    );
+  }, l.useTransition = function() {
+    return y.H.useTransition();
+  }, l.version = "19.2.3", l;
+}
+var fe = { exports: {} };
+/**
+ * @license React
+ * react.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+fe.exports;
+var De;
+function Ve() {
+  return De || (De = 1, function(T, i) {
+    process.env.NODE_ENV !== "production" && function() {
+      function P(e, r) {
+        Object.defineProperty(R.prototype, e, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              r[0],
+              r[1]
+            );
+          }
+        });
+      }
+      function k(e) {
+        return e === null || typeof e != "object" ? null : (e = Re && e[Re] || e["@@iterator"], typeof e == "function" ? e : null);
+      }
+      function b(e, r) {
+        e = (e = e.constructor) && (e.displayName || e.name) || "ReactClass";
+        var o = e + "." + r;
+        Te[o] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          r,
+          e
+        ), Te[o] = !0);
+      }
+      function R(e, r, o) {
+        this.props = e, this.context = r, this.refs = ve, this.updater = o || we;
+      }
+      function j() {
+      }
+      function C(e, r, o) {
+        this.props = e, this.context = r, this.refs = ve, this.updater = o || we;
+      }
+      function N() {
+      }
+      function oe(e) {
+        return "" + e;
+      }
+      function D(e) {
+        try {
+          oe(e);
+          var r = !1;
+        } catch {
+          r = !0;
+        }
+        if (r) {
+          r = console;
+          var o = r.error, u = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
+          return o.call(
+            r,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            u
+          ), oe(e);
+        }
+      }
+      function H(e) {
+        if (e == null) return null;
+        if (typeof e == "function")
+          return e.$$typeof === xe ? null : e.displayName || e.name || null;
+        if (typeof e == "string") return e;
+        switch (e) {
+          case t:
+            return "Fragment";
+          case s:
+            return "Profiler";
+          case n:
+            return "StrictMode";
+          case f:
+            return "Suspense";
+          case O:
+            return "SuspenseList";
+          case ge:
+            return "Activity";
+        }
+        if (typeof e == "object")
+          switch (typeof e.tag == "number" && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), e.$$typeof) {
+            case ne:
+              return "Portal";
+            case d:
+              return e.displayName || "Context";
+            case a:
+              return (e._context.displayName || "Context") + ".Consumer";
+            case v:
+              var r = e.render;
+              return e = e.displayName, e || (e = r.displayName || r.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
+            case w:
+              return r = e.displayName || null, r !== null ? r : H(e.type) || "Memo";
+            case W:
+              r = e._payload, e = e._init;
+              try {
+                return H(e(r));
+              } catch {
+              }
+          }
+        return null;
+      }
+      function z(e) {
+        if (e === t) return "<>";
+        if (typeof e == "object" && e !== null && e.$$typeof === W)
+          return "<...>";
+        try {
+          var r = H(e);
+          return r ? "<" + r + ">" : "<...>";
+        } catch {
+          return "<...>";
+        }
+      }
+      function q() {
+        var e = _.A;
+        return e === null ? null : e.getOwner();
+      }
+      function G() {
+        return Error("react-stack-top-frame");
+      }
+      function J(e) {
+        if (le.call(e, "key")) {
+          var r = Object.getOwnPropertyDescriptor(e, "key").get;
+          if (r && r.isReactWarning) return !1;
+        }
+        return e.key !== void 0;
+      }
+      function B(e, r) {
+        function o() {
+          Se || (Se = !0, console.error(
+            "%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://react.dev/link/special-props)",
+            r
+          ));
+        }
+        o.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: o,
+          configurable: !0
+        });
+      }
+      function I() {
+        var e = H(this.type);
+        return Ce[e] || (Ce[e] = !0, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        )), e = this.props.ref, e !== void 0 ? e : null;
+      }
+      function F(e, r, o, u, c, m) {
+        var p = o.ref;
+        return e = {
+          $$typeof: x,
+          type: e,
+          key: r,
+          props: o,
+          _owner: u
+        }, (p !== void 0 ? p : null) !== null ? Object.defineProperty(e, "ref", {
+          enumerable: !1,
+          get: I
+        }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: 0
+        }), Object.defineProperty(e, "_debugInfo", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: null
+        }), Object.defineProperty(e, "_debugStack", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: c
+        }), Object.defineProperty(e, "_debugTask", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: m
+        }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+      }
+      function ee(e, r) {
+        return r = F(
+          e.type,
+          r,
+          e.props,
+          e._owner,
+          e._debugStack,
+          e._debugTask
+        ), e._store && (r._store.validated = e._store.validated), r;
+      }
+      function Q(e) {
+        M(e) ? e._store && (e._store.validated = 1) : typeof e == "object" && e !== null && e.$$typeof === W && (e._payload.status === "fulfilled" ? M(e._payload.value) && e._payload.value._store && (e._payload.value._store.validated = 1) : e._store && (e._store.validated = 1));
+      }
+      function M(e) {
+        return typeof e == "object" && e !== null && e.$$typeof === x;
+      }
+      function te(e) {
+        var r = { "=": "=0", ":": "=2" };
+        return "$" + e.replace(/[=:]/g, function(o) {
+          return r[o];
+        });
+      }
+      function y(e, r) {
+        return typeof e == "object" && e !== null && e.key != null ? (D(e.key), te("" + e.key)) : r.toString(36);
+      }
+      function ue(e) {
+        switch (e.status) {
+          case "fulfilled":
+            return e.value;
+          case "rejected":
+            throw e.reason;
+          default:
+            switch (typeof e.status == "string" ? e.then(N, N) : (e.status = "pending", e.then(
+              function(r) {
+                e.status === "pending" && (e.status = "fulfilled", e.value = r);
+              },
+              function(r) {
+                e.status === "pending" && (e.status = "rejected", e.reason = r);
+              }
+            )), e.status) {
+              case "fulfilled":
+                return e.value;
+              case "rejected":
+                throw e.reason;
+            }
+        }
+        throw e;
+      }
+      function S(e, r, o, u, c) {
+        var m = typeof e;
+        (m === "undefined" || m === "boolean") && (e = null);
+        var p = !1;
+        if (e === null) p = !0;
+        else
+          switch (m) {
+            case "bigint":
+            case "string":
+            case "number":
+              p = !0;
+              break;
+            case "object":
+              switch (e.$$typeof) {
+                case x:
+                case ne:
+                  p = !0;
+                  break;
+                case W:
+                  return p = e._init, S(
+                    p(e._payload),
+                    r,
+                    o,
+                    u,
+                    c
+                  );
+              }
+          }
+        if (p) {
+          p = e, c = c(p);
+          var g = u === "" ? "." + y(p, 0) : u;
+          return Oe(c) ? (o = "", g != null && (o = g.replace(je, "$&/") + "/"), S(c, r, o, "", function(Z) {
+            return Z;
+          })) : c != null && (M(c) && (c.key != null && (p && p.key === c.key || D(c.key)), o = ee(
+            c,
+            o + (c.key == null || p && p.key === c.key ? "" : ("" + c.key).replace(
+              je,
+              "$&/"
+            ) + "/") + g
+          ), u !== "" && p != null && M(p) && p.key == null && p._store && !p._store.validated && (o._store.validated = 2), c = o), r.push(c)), 1;
+        }
+        if (p = 0, g = u === "" ? "." : u + ":", Oe(e))
+          for (var E = 0; E < e.length; E++)
+            u = e[E], m = g + y(u, E), p += S(
+              u,
+              r,
+              o,
+              m,
+              c
+            );
+        else if (E = k(e), typeof E == "function")
+          for (E === e.entries && (Pe || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), Pe = !0), e = E.call(e), E = 0; !(u = e.next()).done; )
+            u = u.value, m = g + y(u, E++), p += S(
+              u,
+              r,
+              o,
+              m,
+              c
+            );
+        else if (m === "object") {
+          if (typeof e.then == "function")
+            return S(
+              ue(e),
+              r,
+              o,
+              u,
+              c
+            );
+          throw r = String(e), Error(
+            "Objects are not valid as a React child (found: " + (r === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : r) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return p;
+      }
+      function K(e, r, o) {
+        if (e == null) return e;
+        var u = [], c = 0;
+        return S(e, u, "", "", function(m) {
+          return r.call(o, m, c++);
+        }), u;
+      }
+      function re(e) {
+        if (e._status === -1) {
+          var r = e._ioInfo;
+          r != null && (r.start = r.end = performance.now()), r = e._result;
+          var o = r();
+          if (o.then(
+            function(c) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 1, e._result = c;
+                var m = e._ioInfo;
+                m != null && (m.end = performance.now()), o.status === void 0 && (o.status = "fulfilled", o.value = c);
+              }
+            },
+            function(c) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 2, e._result = c;
+                var m = e._ioInfo;
+                m != null && (m.end = performance.now()), o.status === void 0 && (o.status = "rejected", o.reason = c);
+              }
+            }
+          ), r = e._ioInfo, r != null) {
+            r.value = o;
+            var u = o.displayName;
+            typeof u == "string" && (r.name = u);
+          }
+          e._status === -1 && (e._status = 0, e._result = o);
+        }
+        if (e._status === 1)
+          return r = e._result, r === void 0 && console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`,
+            r
+          ), "default" in r || console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`,
+            r
+          ), r.default;
+        throw e._result;
+      }
+      function h() {
+        var e = _.H;
+        return e === null && console.error(
+          `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+        ), e;
+      }
+      function V() {
+        _.asyncTransitions--;
+      }
+      function U(e) {
+        if (pe === null)
+          try {
+            var r = ("require" + Math.random()).slice(0, 7);
+            pe = (T && T[r]).call(
+              T,
+              "timers"
+            ).setImmediate;
+          } catch {
+            pe = function(u) {
+              $e === !1 && ($e = !0, typeof MessageChannel > "u" && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var c = new MessageChannel();
+              c.port1.onmessage = u, c.port2.postMessage(void 0);
+            };
+          }
+        return pe(e);
+      }
+      function Y(e) {
+        return 1 < e.length && typeof AggregateError == "function" ? new AggregateError(e) : e[0];
+      }
+      function A(e, r) {
+        r !== de - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        ), de = r;
+      }
+      function L(e, r, o) {
+        var u = _.actQueue;
+        if (u !== null)
+          if (u.length !== 0)
+            try {
+              X(u), U(function() {
+                return L(e, r, o);
+              });
+              return;
+            } catch (c) {
+              _.thrownErrors.push(c);
+            }
+          else _.actQueue = null;
+        0 < _.thrownErrors.length ? (u = Y(_.thrownErrors), _.thrownErrors.length = 0, o(u)) : r(e);
+      }
+      function X(e) {
+        if (!ye) {
+          ye = !0;
+          var r = 0;
+          try {
+            for (; r < e.length; r++) {
+              var o = e[r];
+              do {
+                _.didUsePromise = !1;
+                var u = o(!1);
+                if (u !== null) {
+                  if (_.didUsePromise) {
+                    e[r] = o, e.splice(0, r);
+                    return;
+                  }
+                  o = u;
+                } else break;
+              } while (!0);
+            }
+            e.length = 0;
+          } catch (c) {
+            e.splice(0, r + 1), _.thrownErrors.push(c);
+          } finally {
+            ye = !1;
+          }
+        }
+      }
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var x = Symbol.for("react.transitional.element"), ne = Symbol.for("react.portal"), t = Symbol.for("react.fragment"), n = Symbol.for("react.strict_mode"), s = Symbol.for("react.profiler"), a = Symbol.for("react.consumer"), d = Symbol.for("react.context"), v = Symbol.for("react.forward_ref"), f = Symbol.for("react.suspense"), O = Symbol.for("react.suspense_list"), w = Symbol.for("react.memo"), W = Symbol.for("react.lazy"), ge = Symbol.for("react.activity"), Re = Symbol.iterator, Te = {}, we = {
+        isMounted: function() {
+          return !1;
+        },
+        enqueueForceUpdate: function(e) {
+          b(e, "forceUpdate");
+        },
+        enqueueReplaceState: function(e) {
+          b(e, "replaceState");
+        },
+        enqueueSetState: function(e) {
+          b(e, "setState");
+        }
+      }, be = Object.assign, ve = {};
+      Object.freeze(ve), R.prototype.isReactComponent = {}, R.prototype.setState = function(e, r) {
+        if (typeof e != "object" && typeof e != "function" && e != null)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, e, r, "setState");
+      }, R.prototype.forceUpdate = function(e) {
+        this.updater.enqueueForceUpdate(this, e, "forceUpdate");
+      };
+      var $ = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      };
+      for (ae in $)
+        $.hasOwnProperty(ae) && P(ae, $[ae]);
+      j.prototype = R.prototype, $ = C.prototype = new j(), $.constructor = C, be($, R.prototype), $.isPureReactComponent = !0;
+      var Oe = Array.isArray, xe = Symbol.for("react.client.reference"), _ = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        actQueue: null,
+        asyncTransitions: 0,
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1,
+        didUsePromise: !1,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, le = Object.prototype.hasOwnProperty, ke = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      $ = {
+        react_stack_bottom_frame: function(e) {
+          return e();
+        }
+      };
+      var Se, Ae, Ce = {}, We = $.react_stack_bottom_frame.bind(
+        $,
+        G
+      )(), ze = ke(z(G)), Pe = !1, je = /\/+/g, Ne = typeof reportError == "function" ? reportError : function(e) {
+        if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+          var r = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: typeof e == "object" && e !== null && typeof e.message == "string" ? String(e.message) : String(e),
+            error: e
+          });
+          if (!window.dispatchEvent(r)) return;
+        } else if (typeof process == "object" && typeof process.emit == "function") {
+          process.emit("uncaughtException", e);
+          return;
+        }
+        console.error(e);
+      }, $e = !1, pe = null, de = 0, _e = !1, ye = !1, Me = typeof queueMicrotask == "function" ? function(e) {
+        queueMicrotask(function() {
+          return queueMicrotask(e);
+        });
+      } : U;
+      $ = Object.freeze({
+        __proto__: null,
+        c: function(e) {
+          return h().useMemoCache(e);
+        }
+      });
+      var ae = {
+        map: K,
+        forEach: function(e, r, o) {
+          K(
+            e,
+            function() {
+              r.apply(this, arguments);
+            },
+            o
+          );
+        },
+        count: function(e) {
+          var r = 0;
+          return K(e, function() {
+            r++;
+          }), r;
+        },
+        toArray: function(e) {
+          return K(e, function(r) {
+            return r;
+          }) || [];
+        },
+        only: function(e) {
+          if (!M(e))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return e;
+        }
+      };
+      i.Activity = ge, i.Children = ae, i.Component = R, i.Fragment = t, i.Profiler = s, i.PureComponent = C, i.StrictMode = n, i.Suspense = f, i.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = _, i.__COMPILER_RUNTIME = $, i.act = function(e) {
+        var r = _.actQueue, o = de;
+        de++;
+        var u = _.actQueue = r !== null ? r : [], c = !1;
+        try {
+          var m = e();
+        } catch (E) {
+          _.thrownErrors.push(E);
+        }
+        if (0 < _.thrownErrors.length)
+          throw A(r, o), e = Y(_.thrownErrors), _.thrownErrors.length = 0, e;
+        if (m !== null && typeof m == "object" && typeof m.then == "function") {
+          var p = m;
+          return Me(function() {
+            c || _e || (_e = !0, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          }), {
+            then: function(E, Z) {
+              c = !0, p.then(
+                function(se) {
+                  if (A(r, o), o === 0) {
+                    try {
+                      X(u), U(function() {
+                        return L(
+                          se,
+                          E,
+                          Z
+                        );
+                      });
+                    } catch (Be) {
+                      _.thrownErrors.push(Be);
+                    }
+                    if (0 < _.thrownErrors.length) {
+                      var Ge = Y(
+                        _.thrownErrors
+                      );
+                      _.thrownErrors.length = 0, Z(Ge);
+                    }
+                  } else E(se);
+                },
+                function(se) {
+                  A(r, o), 0 < _.thrownErrors.length && (se = Y(
+                    _.thrownErrors
+                  ), _.thrownErrors.length = 0), Z(se);
+                }
+              );
+            }
+          };
+        }
+        var g = m;
+        if (A(r, o), o === 0 && (X(u), u.length !== 0 && Me(function() {
+          c || _e || (_e = !0, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), _.actQueue = null), 0 < _.thrownErrors.length)
+          throw e = Y(_.thrownErrors), _.thrownErrors.length = 0, e;
+        return {
+          then: function(E, Z) {
+            c = !0, o === 0 ? (_.actQueue = u, U(function() {
+              return L(
+                g,
+                E,
+                Z
+              );
+            })) : E(g);
+          }
+        };
+      }, i.cache = function(e) {
+        return function() {
+          return e.apply(null, arguments);
+        };
+      }, i.cacheSignal = function() {
+        return null;
+      }, i.captureOwnerStack = function() {
+        var e = _.getCurrentStack;
+        return e === null ? null : e();
+      }, i.cloneElement = function(e, r, o) {
+        if (e == null)
+          throw Error(
+            "The argument must be a React element, but you passed " + e + "."
+          );
+        var u = be({}, e.props), c = e.key, m = e._owner;
+        if (r != null) {
+          var p;
+          e: {
+            if (le.call(r, "ref") && (p = Object.getOwnPropertyDescriptor(
+              r,
+              "ref"
+            ).get) && p.isReactWarning) {
+              p = !1;
+              break e;
+            }
+            p = r.ref !== void 0;
+          }
+          p && (m = q()), J(r) && (D(r.key), c = "" + r.key);
+          for (g in r)
+            !le.call(r, g) || g === "key" || g === "__self" || g === "__source" || g === "ref" && r.ref === void 0 || (u[g] = r[g]);
+        }
+        var g = arguments.length - 2;
+        if (g === 1) u.children = o;
+        else if (1 < g) {
+          p = Array(g);
+          for (var E = 0; E < g; E++)
+            p[E] = arguments[E + 2];
+          u.children = p;
+        }
+        for (u = F(
+          e.type,
+          c,
+          u,
+          m,
+          e._debugStack,
+          e._debugTask
+        ), c = 2; c < arguments.length; c++)
+          Q(arguments[c]);
+        return u;
+      }, i.createContext = function(e) {
+        return e = {
+          $$typeof: d,
+          _currentValue: e,
+          _currentValue2: e,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        }, e.Provider = e, e.Consumer = {
+          $$typeof: a,
+          _context: e
+        }, e._currentRenderer = null, e._currentRenderer2 = null, e;
+      }, i.createElement = function(e, r, o) {
+        for (var u = 2; u < arguments.length; u++)
+          Q(arguments[u]);
+        u = {};
+        var c = null;
+        if (r != null)
+          for (E in Ae || !("__self" in r) || "key" in r || (Ae = !0, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), J(r) && (D(r.key), c = "" + r.key), r)
+            le.call(r, E) && E !== "key" && E !== "__self" && E !== "__source" && (u[E] = r[E]);
+        var m = arguments.length - 2;
+        if (m === 1) u.children = o;
+        else if (1 < m) {
+          for (var p = Array(m), g = 0; g < m; g++)
+            p[g] = arguments[g + 2];
+          Object.freeze && Object.freeze(p), u.children = p;
+        }
+        if (e && e.defaultProps)
+          for (E in m = e.defaultProps, m)
+            u[E] === void 0 && (u[E] = m[E]);
+        c && B(
+          u,
+          typeof e == "function" ? e.displayName || e.name || "Unknown" : e
+        );
+        var E = 1e4 > _.recentlyCreatedOwnerStacks++;
+        return F(
+          e,
+          c,
+          u,
+          q(),
+          E ? Error("react-stack-top-frame") : We,
+          E ? ke(z(e)) : ze
+        );
+      }, i.createRef = function() {
+        var e = { current: null };
+        return Object.seal(e), e;
+      }, i.forwardRef = function(e) {
+        e != null && e.$$typeof === w ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : typeof e != "function" ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          e === null ? "null" : typeof e
+        ) : e.length !== 0 && e.length !== 2 && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          e.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        ), e != null && e.defaultProps != null && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var r = { $$typeof: v, render: e }, o;
+        return Object.defineProperty(r, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return o;
+          },
+          set: function(u) {
+            o = u, e.name || e.displayName || (Object.defineProperty(e, "name", { value: u }), e.displayName = u);
+          }
+        }), r;
+      }, i.isValidElement = M, i.lazy = function(e) {
+        e = { _status: -1, _result: e };
+        var r = {
+          $$typeof: W,
+          _payload: e,
+          _init: re
+        }, o = {
+          name: "lazy",
+          start: -1,
+          end: -1,
+          value: null,
+          owner: null,
+          debugStack: Error("react-stack-top-frame"),
+          debugTask: console.createTask ? console.createTask("lazy()") : null
+        };
+        return e._ioInfo = o, r._debugInfo = [{ awaited: o }], r;
+      }, i.memo = function(e, r) {
+        e == null && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          e === null ? "null" : typeof e
+        ), r = {
+          $$typeof: w,
+          type: e,
+          compare: r === void 0 ? null : r
+        };
+        var o;
+        return Object.defineProperty(r, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return o;
+          },
+          set: function(u) {
+            o = u, e.name || e.displayName || (Object.defineProperty(e, "name", { value: u }), e.displayName = u);
+          }
+        }), r;
+      }, i.startTransition = function(e) {
+        var r = _.T, o = {};
+        o._updatedFibers = /* @__PURE__ */ new Set(), _.T = o;
+        try {
+          var u = e(), c = _.S;
+          c !== null && c(o, u), typeof u == "object" && u !== null && typeof u.then == "function" && (_.asyncTransitions++, u.then(V, V), u.then(N, Ne));
+        } catch (m) {
+          Ne(m);
+        } finally {
+          r === null && o._updatedFibers && (e = o._updatedFibers.size, o._updatedFibers.clear(), 10 < e && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), r !== null && o.types !== null && (r.types !== null && r.types !== o.types && console.error(
+            "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
+          ), r.types = o.types), _.T = r;
+        }
+      }, i.unstable_useCacheRefresh = function() {
+        return h().useCacheRefresh();
+      }, i.use = function(e) {
+        return h().use(e);
+      }, i.useActionState = function(e, r, o) {
+        return h().useActionState(
+          e,
+          r,
+          o
+        );
+      }, i.useCallback = function(e, r) {
+        return h().useCallback(e, r);
+      }, i.useContext = function(e) {
+        var r = h();
+        return e.$$typeof === a && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        ), r.useContext(e);
+      }, i.useDebugValue = function(e, r) {
+        return h().useDebugValue(e, r);
+      }, i.useDeferredValue = function(e, r) {
+        return h().useDeferredValue(e, r);
+      }, i.useEffect = function(e, r) {
+        return e == null && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), h().useEffect(e, r);
+      }, i.useEffectEvent = function(e) {
+        return h().useEffectEvent(e);
+      }, i.useId = function() {
+        return h().useId();
+      }, i.useImperativeHandle = function(e, r, o) {
+        return h().useImperativeHandle(e, r, o);
+      }, i.useInsertionEffect = function(e, r) {
+        return e == null && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), h().useInsertionEffect(e, r);
+      }, i.useLayoutEffect = function(e, r) {
+        return e == null && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), h().useLayoutEffect(e, r);
+      }, i.useMemo = function(e, r) {
+        return h().useMemo(e, r);
+      }, i.useOptimistic = function(e, r) {
+        return h().useOptimistic(e, r);
+      }, i.useReducer = function(e, r, o) {
+        return h().useReducer(e, r, o);
+      }, i.useRef = function(e) {
+        return h().useRef(e);
+      }, i.useState = function(e) {
+        return h().useState(e);
+      }, i.useSyncExternalStore = function(e, r, o) {
+        return h().useSyncExternalStore(
+          e,
+          r,
+          o
+        );
+      }, i.useTransition = function() {
+        return h().useTransition();
+      }, i.version = "19.2.3", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    }();
+  }(fe, fe.exports)), fe.exports;
+}
+var Ie;
+function qe() {
+  return Ie || (Ie = 1, process.env.NODE_ENV === "production" ? Ee.exports = Ke() : Ee.exports = Ve()), Ee.exports;
 }
-var E = {};
 /**
  * @license React
  * react-jsx-runtime.development.js
@@ -42,276 +1274,276 @@ var E = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var D;
-function oe() {
-  return D || (D = 1, process.env.NODE_ENV !== "production" && function() {
-    function a(e) {
-      if (e == null) return null;
-      if (typeof e == "function")
-        return e.$$typeof === Z ? null : e.displayName || e.name || null;
-      if (typeof e == "string") return e;
-      switch (e) {
-        case T:
+var Ue;
+function Xe() {
+  return Ue || (Ue = 1, process.env.NODE_ENV !== "production" && function() {
+    function T(t) {
+      if (t == null) return null;
+      if (typeof t == "function")
+        return t.$$typeof === re ? null : t.displayName || t.name || null;
+      if (typeof t == "string") return t;
+      switch (t) {
+        case B:
           return "Fragment";
-        case U:
+        case F:
           return "Profiler";
-        case M:
+        case I:
           return "StrictMode";
-        case G:
+        case te:
           return "Suspense";
-        case X:
+        case y:
           return "SuspenseList";
-        case H:
+        case K:
           return "Activity";
       }
-      if (typeof e == "object")
-        switch (typeof e.tag == "number" && console.error(
+      if (typeof t == "object")
+        switch (typeof t.tag == "number" && console.error(
           "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
-        ), e.$$typeof) {
-          case W:
-            return "Portal";
-          case z:
-            return e.displayName || "Context";
-          case q:
-            return (e._context.displayName || "Context") + ".Consumer";
+        ), t.$$typeof) {
           case J:
-            var r = e.render;
-            return e = e.displayName, e || (e = r.displayName || r.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
-          case B:
-            return r = e.displayName || null, r !== null ? r : a(e.type) || "Memo";
-          case h:
-            r = e._payload, e = e._init;
+            return "Portal";
+          case Q:
+            return t.displayName || "Context";
+          case ee:
+            return (t._context.displayName || "Context") + ".Consumer";
+          case M:
+            var n = t.render;
+            return t = t.displayName, t || (t = n.displayName || n.name || "", t = t !== "" ? "ForwardRef(" + t + ")" : "ForwardRef"), t;
+          case ue:
+            return n = t.displayName || null, n !== null ? n : T(t.type) || "Memo";
+          case S:
+            n = t._payload, t = t._init;
             try {
-              return a(e(r));
+              return T(t(n));
             } catch {
             }
         }
       return null;
     }
-    function l(e) {
-      return "" + e;
+    function i(t) {
+      return "" + t;
     }
-    function i(e) {
+    function P(t) {
       try {
-        l(e);
-        var r = !1;
+        i(t);
+        var n = !1;
       } catch {
-        r = !0;
+        n = !0;
       }
-      if (r) {
-        r = console;
-        var t = r.error, n = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
-        return t.call(
-          r,
+      if (n) {
+        n = console;
+        var s = n.error, a = typeof Symbol == "function" && Symbol.toStringTag && t[Symbol.toStringTag] || t.constructor.name || "Object";
+        return s.call(
+          n,
           "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
-          n
-        ), l(e);
+          a
+        ), i(t);
       }
     }
-    function c(e) {
-      if (e === T) return "<>";
-      if (typeof e == "object" && e !== null && e.$$typeof === h)
+    function k(t) {
+      if (t === B) return "<>";
+      if (typeof t == "object" && t !== null && t.$$typeof === S)
         return "<...>";
       try {
-        var r = a(e);
-        return r ? "<" + r + ">" : "<...>";
+        var n = T(t);
+        return n ? "<" + n + ">" : "<...>";
       } catch {
         return "<...>";
       }
     }
-    function s() {
-      var e = k.A;
-      return e === null ? null : e.getOwner();
+    function b() {
+      var t = h.A;
+      return t === null ? null : t.getOwner();
     }
-    function u() {
+    function R() {
       return Error("react-stack-top-frame");
     }
-    function f(e) {
-      if (x.call(e, "key")) {
-        var r = Object.getOwnPropertyDescriptor(e, "key").get;
-        if (r && r.isReactWarning) return !1;
+    function j(t) {
+      if (V.call(t, "key")) {
+        var n = Object.getOwnPropertyDescriptor(t, "key").get;
+        if (n && n.isReactWarning) return !1;
       }
-      return e.key !== void 0;
+      return t.key !== void 0;
     }
-    function m(e, r) {
-      function t() {
-        j || (j = !0, console.error(
+    function C(t, n) {
+      function s() {
+        A || (A = !0, console.error(
           "%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://react.dev/link/special-props)",
-          r
+          n
         ));
       }
-      t.isReactWarning = !0, Object.defineProperty(e, "key", {
-        get: t,
+      s.isReactWarning = !0, Object.defineProperty(t, "key", {
+        get: s,
         configurable: !0
       });
     }
-    function d() {
-      var e = a(this.type);
-      return N[e] || (N[e] = !0, console.error(
+    function N() {
+      var t = T(this.type);
+      return L[t] || (L[t] = !0, console.error(
         "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
-      )), e = this.props.ref, e !== void 0 ? e : null;
+      )), t = this.props.ref, t !== void 0 ? t : null;
     }
-    function L(e, r, t, n, v, S) {
-      var o = t.ref;
-      return e = {
-        $$typeof: w,
-        type: e,
-        key: r,
-        props: t,
-        _owner: n
-      }, (o !== void 0 ? o : null) !== null ? Object.defineProperty(e, "ref", {
+    function oe(t, n, s, a, d, v) {
+      var f = s.ref;
+      return t = {
+        $$typeof: G,
+        type: t,
+        key: n,
+        props: s,
+        _owner: a
+      }, (f !== void 0 ? f : null) !== null ? Object.defineProperty(t, "ref", {
         enumerable: !1,
-        get: d
-      }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+        get: N
+      }) : Object.defineProperty(t, "ref", { enumerable: !1, value: null }), t._store = {}, Object.defineProperty(t._store, "validated", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
         value: 0
-      }), Object.defineProperty(e, "_debugInfo", {
+      }), Object.defineProperty(t, "_debugInfo", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
         value: null
-      }), Object.defineProperty(e, "_debugStack", {
+      }), Object.defineProperty(t, "_debugStack", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
-        value: v
-      }), Object.defineProperty(e, "_debugTask", {
+        value: d
+      }), Object.defineProperty(t, "_debugTask", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
-        value: S
-      }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+        value: v
+      }), Object.freeze && (Object.freeze(t.props), Object.freeze(t)), t;
     }
-    function A(e, r, t, n, v, S) {
-      var o = r.children;
-      if (o !== void 0)
-        if (n)
-          if (K(o)) {
-            for (n = 0; n < o.length; n++)
-              P(o[n]);
-            Object.freeze && Object.freeze(o);
+    function D(t, n, s, a, d, v) {
+      var f = n.children;
+      if (f !== void 0)
+        if (a)
+          if (U(f)) {
+            for (a = 0; a < f.length; a++)
+              H(f[a]);
+            Object.freeze && Object.freeze(f);
           } else
             console.error(
               "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 P(o);
-      if (x.call(r, "key")) {
-        o = a(e);
-        var _ = Object.keys(r).filter(function(Q) {
-          return Q !== "key";
+        else H(f);
+      if (V.call(n, "key")) {
+        f = T(t);
+        var O = Object.keys(n).filter(function(W) {
+          return W !== "key";
         });
-        n = 0 < _.length ? "{key: someKey, " + _.join(": ..., ") + ": ...}" : "{key: someKey}", $[o + n] || (_ = 0 < _.length ? "{" + _.join(": ..., ") + ": ...}" : "{}", console.error(
+        a = 0 < O.length ? "{key: someKey, " + O.join(": ..., ") + ": ...}" : "{key: someKey}", ne[f + a] || (O = 0 < O.length ? "{" + O.join(": ..., ") + ": ...}" : "{}", console.error(
           `A props object containing a "key" prop is being spread into JSX:
   let props = %s;
   <%s {...props} />
 React keys must be passed directly to JSX without using spread:
   let props = %s;
   <%s key={someKey} {...props} />`,
-          n,
-          o,
-          _,
-          o
-        ), $[o + n] = !0);
-      }
-      if (o = null, t !== void 0 && (i(t), o = "" + t), f(r) && (i(r.key), o = "" + r.key), "key" in r) {
-        t = {};
-        for (var g in r)
-          g !== "key" && (t[g] = r[g]);
-      } else t = r;
-      return o && m(
-        t,
-        typeof e == "function" ? e.displayName || e.name || "Unknown" : e
-      ), L(
-        e,
-        o,
+          a,
+          f,
+          O,
+          f
+        ), ne[f + a] = !0);
+      }
+      if (f = null, s !== void 0 && (P(s), f = "" + s), j(n) && (P(n.key), f = "" + n.key), "key" in n) {
+        s = {};
+        for (var w in n)
+          w !== "key" && (s[w] = n[w]);
+      } else s = n;
+      return f && C(
+        s,
+        typeof t == "function" ? t.displayName || t.name || "Unknown" : t
+      ), oe(
         t,
-        s(),
-        v,
-        S
+        f,
+        s,
+        b(),
+        d,
+        v
       );
     }
-    function P(e) {
-      y(e) ? e._store && (e._store.validated = 1) : typeof e == "object" && e !== null && e.$$typeof === h && (e._payload.status === "fulfilled" ? y(e._payload.value) && e._payload.value._store && (e._payload.value._store.validated = 1) : e._store && (e._store.validated = 1));
+    function H(t) {
+      z(t) ? t._store && (t._store.validated = 1) : typeof t == "object" && t !== null && t.$$typeof === S && (t._payload.status === "fulfilled" ? z(t._payload.value) && t._payload.value._store && (t._payload.value._store.validated = 1) : t._store && (t._store.validated = 1));
     }
-    function y(e) {
-      return typeof e == "object" && e !== null && e.$$typeof === w;
+    function z(t) {
+      return typeof t == "object" && t !== null && t.$$typeof === G;
     }
-    var R = ee, w = Symbol.for("react.transitional.element"), W = Symbol.for("react.portal"), T = Symbol.for("react.fragment"), M = Symbol.for("react.strict_mode"), U = Symbol.for("react.profiler"), q = Symbol.for("react.consumer"), z = Symbol.for("react.context"), J = Symbol.for("react.forward_ref"), G = Symbol.for("react.suspense"), X = Symbol.for("react.suspense_list"), B = Symbol.for("react.memo"), h = Symbol.for("react.lazy"), H = Symbol.for("react.activity"), Z = Symbol.for("react.client.reference"), k = R.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, x = Object.prototype.hasOwnProperty, K = Array.isArray, O = console.createTask ? console.createTask : function() {
+    var q = qe(), G = Symbol.for("react.transitional.element"), J = Symbol.for("react.portal"), B = Symbol.for("react.fragment"), I = Symbol.for("react.strict_mode"), F = Symbol.for("react.profiler"), ee = Symbol.for("react.consumer"), Q = Symbol.for("react.context"), M = Symbol.for("react.forward_ref"), te = Symbol.for("react.suspense"), y = Symbol.for("react.suspense_list"), ue = Symbol.for("react.memo"), S = Symbol.for("react.lazy"), K = Symbol.for("react.activity"), re = Symbol.for("react.client.reference"), h = q.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, V = Object.prototype.hasOwnProperty, U = Array.isArray, Y = console.createTask ? console.createTask : function() {
       return null;
     };
-    R = {
-      react_stack_bottom_frame: function(e) {
-        return e();
+    q = {
+      react_stack_bottom_frame: function(t) {
+        return t();
       }
     };
-    var j, N = {}, C = R.react_stack_bottom_frame.bind(
-      R,
-      u
-    )(), Y = O(c(u)), $ = {};
-    E.Fragment = T, E.jsx = function(e, r, t) {
-      var n = 1e4 > k.recentlyCreatedOwnerStacks++;
-      return A(
-        e,
-        r,
+    var A, L = {}, X = q.react_stack_bottom_frame.bind(
+      q,
+      R
+    )(), x = Y(k(R)), ne = {};
+    ce.Fragment = B, ce.jsx = function(t, n, s) {
+      var a = 1e4 > h.recentlyCreatedOwnerStacks++;
+      return D(
         t,
+        n,
+        s,
         !1,
-        n ? Error("react-stack-top-frame") : C,
-        n ? O(c(e)) : Y
+        a ? Error("react-stack-top-frame") : X,
+        a ? Y(k(t)) : x
       );
-    }, E.jsxs = function(e, r, t) {
-      var n = 1e4 > k.recentlyCreatedOwnerStacks++;
-      return A(
-        e,
-        r,
+    }, ce.jsxs = function(t, n, s) {
+      var a = 1e4 > h.recentlyCreatedOwnerStacks++;
+      return D(
         t,
+        n,
+        s,
         !0,
-        n ? Error("react-stack-top-frame") : C,
-        n ? O(c(e)) : Y
+        a ? Error("react-stack-top-frame") : X,
+        a ? Y(k(t)) : x
       );
     };
-  }()), E;
+  }()), ce;
 }
-var V;
-function ae() {
-  return V || (V = 1, process.env.NODE_ENV === "production" ? b.exports = ne() : b.exports = oe()), b.exports;
+var He;
+function Ze() {
+  return He || (He = 1, process.env.NODE_ENV === "production" ? me.exports = Qe() : me.exports = Xe()), me.exports;
 }
-var se = ae();
-const ue = {
+var Je = Ze(), he = qe();
+const et = {
   center: [54.145464, 32.527699],
   zoom: 5,
   poi: !1,
   traffic: !1
 };
-function fe(a) {
-  const l = I(null), i = I(null), {
-    options: c,
-    mapSetter: s,
-    containerElementSetter: u,
-    className: f,
-    ...m
-  } = a;
-  return re(() => {
-    if (!c.mapKey) {
+function nt(T) {
+  const i = he.useRef(null), P = he.useRef(null), {
+    options: k,
+    mapSetter: b,
+    containerElementSetter: R,
+    className: j,
+    ...C
+  } = T;
+  return he.useEffect(() => {
+    if (!k.mapKey) {
       console.error("Please provide a mapKey in options!");
       return;
     }
-    if (l.current && !i.current)
+    if (i.current && !P.current)
       try {
-        const d = new te.Map({
-          ...ue,
-          ...c,
-          container: l.current
+        const N = new Fe.Map({
+          ...et,
+          ...k,
+          container: i.current
         });
-        i.current = d, typeof s == "function" && s(d), typeof u == "function" && u(l.current);
-      } catch (d) {
-        console.group("Error in constructing map:"), console.error(d), console.groupEnd();
+        P.current = N, typeof b == "function" && b(N), typeof R == "function" && R(i.current);
+      } catch (N) {
+        console.group("Error in constructing map:"), console.error(N), console.groupEnd();
       }
-  }, [u, s, c]), c.mapKey ? /* @__PURE__ */ se.jsx("div", { className: `map-container ${f || ""}`, ref: l, ...m }) : null;
+  }, [R, b, k]), k.mapKey ? /* @__PURE__ */ Je.jsx("div", { className: `map-container ${j || ""}`, ref: i, ...C }) : null;
 }
-var ce = /* @__PURE__ */ ((a) => (a.neshanVector = "neshanVector", a.neshanVectorNight = "neshanVectorNight", a.neshanRaster = "neshanRaster", a.neshanRasterNight = "neshanRasterNight", a))(ce || {});
+var tt = /* @__PURE__ */ ((T) => (T.neshanVector = "neshanVector", T.neshanVectorNight = "neshanVectorNight", T.neshanRaster = "neshanRaster", T.neshanRasterNight = "neshanRasterNight", T))(tt || {});
 export {
-  fe as MapComponent,
-  ce as MapTypes
+  nt as MapComponent,
+  tt as MapTypes
 };