stargazer-ui 1.0.0

package/dist/ui.es.js

@@ -0,0 +1,1983 @@
+import me, { forwardRef as y, createContext as he, useState as B, useCallback as zt, useMemo as oe, useContext as H, useEffect as L, useLayoutEffect as Sr, useRef as qe } from "react";
+import { createPortal as Bt } from "react-dom";
+var Ke = { exports: {} }, ue = {};
+/**
+ * @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 Rt;
+function Pr() {
+  if (Rt)
+    return ue;
+  Rt = 1;
+  var e = me, t = Symbol.for("react.element"), r = Symbol.for("react.fragment"), n = Object.prototype.hasOwnProperty, s = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, i = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function c(a, l, v) {
+    var h, d = {}, p = null, E = null;
+    v !== void 0 && (p = "" + v), l.key !== void 0 && (p = "" + l.key), l.ref !== void 0 && (E = l.ref);
+    for (h in l)
+      n.call(l, h) && !i.hasOwnProperty(h) && (d[h] = l[h]);
+    if (a && a.defaultProps)
+      for (h in l = a.defaultProps, l)
+        d[h] === void 0 && (d[h] = l[h]);
+    return { $$typeof: t, type: a, key: p, ref: E, props: d, _owner: s.current };
+  }
+  return ue.Fragment = r, ue.jsx = c, ue.jsxs = c, ue;
+}
+var le = {};
+/**
+ * @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 Ot;
+function Rr() {
+  return Ot || (Ot = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = me, t = Symbol.for("react.element"), r = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), s = Symbol.for("react.strict_mode"), i = Symbol.for("react.profiler"), c = Symbol.for("react.provider"), a = Symbol.for("react.context"), l = Symbol.for("react.forward_ref"), v = Symbol.for("react.suspense"), h = Symbol.for("react.suspense_list"), d = Symbol.for("react.memo"), p = Symbol.for("react.lazy"), E = Symbol.for("react.offscreen"), C = Symbol.iterator, _ = "@@iterator";
+    function g(o) {
+      if (o === null || typeof o != "object")
+        return null;
+      var u = C && o[C] || o[_];
+      return typeof u == "function" ? u : null;
+    }
+    var j = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function w(o) {
+      {
+        for (var u = arguments.length, m = new Array(u > 1 ? u - 1 : 0), b = 1; b < u; b++)
+          m[b - 1] = arguments[b];
+        A("error", o, m);
+      }
+    }
+    function A(o, u, m) {
+      {
+        var b = j.ReactDebugCurrentFrame, P = b.getStackAddendum();
+        P !== "" && (u += "%s", m = m.concat([P]));
+        var R = m.map(function(S) {
+          return String(S);
+        });
+        R.unshift("Warning: " + u), Function.prototype.apply.call(console[o], console, R);
+      }
+    }
+    var $ = !1, M = !1, G = !1, z = !1, W = !1, Y;
+    Y = Symbol.for("react.module.reference");
+    function Ae(o) {
+      return !!(typeof o == "string" || typeof o == "function" || o === n || o === i || W || o === s || o === v || o === h || z || o === E || $ || M || G || typeof o == "object" && o !== null && (o.$$typeof === p || o.$$typeof === d || o.$$typeof === c || o.$$typeof === a || o.$$typeof === l || // 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.
+      o.$$typeof === Y || o.getModuleId !== void 0));
+    }
+    function er(o, u, m) {
+      var b = o.displayName;
+      if (b)
+        return b;
+      var P = u.displayName || u.name || "";
+      return P !== "" ? m + "(" + P + ")" : m;
+    }
+    function st(o) {
+      return o.displayName || "Context";
+    }
+    function V(o) {
+      if (o == null)
+        return null;
+      if (typeof o.tag == "number" && w("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof o == "function")
+        return o.displayName || o.name || null;
+      if (typeof o == "string")
+        return o;
+      switch (o) {
+        case n:
+          return "Fragment";
+        case r:
+          return "Portal";
+        case i:
+          return "Profiler";
+        case s:
+          return "StrictMode";
+        case v:
+          return "Suspense";
+        case h:
+          return "SuspenseList";
+      }
+      if (typeof o == "object")
+        switch (o.$$typeof) {
+          case a:
+            var u = o;
+            return st(u) + ".Consumer";
+          case c:
+            var m = o;
+            return st(m._context) + ".Provider";
+          case l:
+            return er(o, o.render, "ForwardRef");
+          case d:
+            var b = o.displayName || null;
+            return b !== null ? b : V(o.type) || "Memo";
+          case p: {
+            var P = o, R = P._payload, S = P._init;
+            try {
+              return V(S(R));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var X = Object.assign, ae = 0, it, at, ct, ut, lt, ft, dt;
+    function pt() {
+    }
+    pt.__reactDisabledLog = !0;
+    function tr() {
+      {
+        if (ae === 0) {
+          it = console.log, at = console.info, ct = console.warn, ut = console.error, lt = console.group, ft = console.groupCollapsed, dt = console.groupEnd;
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            value: pt,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: o,
+            log: o,
+            warn: o,
+            error: o,
+            group: o,
+            groupCollapsed: o,
+            groupEnd: o
+          });
+        }
+        ae++;
+      }
+    }
+    function rr() {
+      {
+        if (ae--, ae === 0) {
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: X({}, o, {
+              value: it
+            }),
+            info: X({}, o, {
+              value: at
+            }),
+            warn: X({}, o, {
+              value: ct
+            }),
+            error: X({}, o, {
+              value: ut
+            }),
+            group: X({}, o, {
+              value: lt
+            }),
+            groupCollapsed: X({}, o, {
+              value: ft
+            }),
+            groupEnd: X({}, o, {
+              value: dt
+            })
+          });
+        }
+        ae < 0 && w("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var Ne = j.ReactCurrentDispatcher, Me;
+    function be(o, u, m) {
+      {
+        if (Me === void 0)
+          try {
+            throw Error();
+          } catch (P) {
+            var b = P.stack.trim().match(/\n( *(at )?)/);
+            Me = b && b[1] || "";
+          }
+        return `
+` + Me + o;
+      }
+    }
+    var ze = !1, _e;
+    {
+      var nr = typeof WeakMap == "function" ? WeakMap : Map;
+      _e = new nr();
+    }
+    function mt(o, u) {
+      if (!o || ze)
+        return "";
+      {
+        var m = _e.get(o);
+        if (m !== void 0)
+          return m;
+      }
+      var b;
+      ze = !0;
+      var P = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var R;
+      R = Ne.current, Ne.current = null, tr();
+      try {
+        if (u) {
+          var S = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(S.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(S, []);
+            } catch (U) {
+              b = U;
+            }
+            Reflect.construct(o, [], S);
+          } else {
+            try {
+              S.call();
+            } catch (U) {
+              b = U;
+            }
+            o.call(S.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (U) {
+            b = U;
+          }
+          o();
+        }
+      } catch (U) {
+        if (U && b && typeof U.stack == "string") {
+          for (var x = U.stack.split(`
+`), k = b.stack.split(`
+`), O = x.length - 1, T = k.length - 1; O >= 1 && T >= 0 && x[O] !== k[T]; )
+            T--;
+          for (; O >= 1 && T >= 0; O--, T--)
+            if (x[O] !== k[T]) {
+              if (O !== 1 || T !== 1)
+                do
+                  if (O--, T--, T < 0 || x[O] !== k[T]) {
+                    var N = `
+` + x[O].replace(" at new ", " at ");
+                    return o.displayName && N.includes("<anonymous>") && (N = N.replace("<anonymous>", o.displayName)), typeof o == "function" && _e.set(o, N), N;
+                  }
+                while (O >= 1 && T >= 0);
+              break;
+            }
+        }
+      } finally {
+        ze = !1, Ne.current = R, rr(), Error.prepareStackTrace = P;
+      }
+      var re = o ? o.displayName || o.name : "", Pt = re ? be(re) : "";
+      return typeof o == "function" && _e.set(o, Pt), Pt;
+    }
+    function or(o, u, m) {
+      return mt(o, !1);
+    }
+    function sr(o) {
+      var u = o.prototype;
+      return !!(u && u.isReactComponent);
+    }
+    function we(o, u, m) {
+      if (o == null)
+        return "";
+      if (typeof o == "function")
+        return mt(o, sr(o));
+      if (typeof o == "string")
+        return be(o);
+      switch (o) {
+        case v:
+          return be("Suspense");
+        case h:
+          return be("SuspenseList");
+      }
+      if (typeof o == "object")
+        switch (o.$$typeof) {
+          case l:
+            return or(o.render);
+          case d:
+            return we(o.type, u, m);
+          case p: {
+            var b = o, P = b._payload, R = b._init;
+            try {
+              return we(R(P), u, m);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var Ee = Object.prototype.hasOwnProperty, ht = {}, vt = j.ReactDebugCurrentFrame;
+    function xe(o) {
+      if (o) {
+        var u = o._owner, m = we(o.type, o._source, u ? u.type : null);
+        vt.setExtraStackFrame(m);
+      } else
+        vt.setExtraStackFrame(null);
+    }
+    function ir(o, u, m, b, P) {
+      {
+        var R = Function.call.bind(Ee);
+        for (var S in o)
+          if (R(o, S)) {
+            var x = void 0;
+            try {
+              if (typeof o[S] != "function") {
+                var k = Error((b || "React class") + ": " + m + " type `" + S + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof o[S] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw k.name = "Invariant Violation", k;
+              }
+              x = o[S](u, S, b, m, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (O) {
+              x = O;
+            }
+            x && !(x instanceof Error) && (xe(P), w("%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).", b || "React class", m, S, typeof x), xe(null)), x instanceof Error && !(x.message in ht) && (ht[x.message] = !0, xe(P), w("Failed %s type: %s", m, x.message), xe(null));
+          }
+      }
+    }
+    var ar = Array.isArray;
+    function Be(o) {
+      return ar(o);
+    }
+    function cr(o) {
+      {
+        var u = typeof Symbol == "function" && Symbol.toStringTag, m = u && o[Symbol.toStringTag] || o.constructor.name || "Object";
+        return m;
+      }
+    }
+    function ur(o) {
+      try {
+        return gt(o), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function gt(o) {
+      return "" + o;
+    }
+    function yt(o) {
+      if (ur(o))
+        return w("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", cr(o)), gt(o);
+    }
+    var ce = j.ReactCurrentOwner, lr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, bt, _t, We;
+    We = {};
+    function fr(o) {
+      if (Ee.call(o, "ref")) {
+        var u = Object.getOwnPropertyDescriptor(o, "ref").get;
+        if (u && u.isReactWarning)
+          return !1;
+      }
+      return o.ref !== void 0;
+    }
+    function dr(o) {
+      if (Ee.call(o, "key")) {
+        var u = Object.getOwnPropertyDescriptor(o, "key").get;
+        if (u && u.isReactWarning)
+          return !1;
+      }
+      return o.key !== void 0;
+    }
+    function pr(o, u) {
+      if (typeof o.ref == "string" && ce.current && u && ce.current.stateNode !== u) {
+        var m = V(ce.current.type);
+        We[m] || (w('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', V(ce.current.type), o.ref), We[m] = !0);
+      }
+    }
+    function mr(o, u) {
+      {
+        var m = function() {
+          bt || (bt = !0, w("%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)", u));
+        };
+        m.isReactWarning = !0, Object.defineProperty(o, "key", {
+          get: m,
+          configurable: !0
+        });
+      }
+    }
+    function hr(o, u) {
+      {
+        var m = function() {
+          _t || (_t = !0, w("%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)", u));
+        };
+        m.isReactWarning = !0, Object.defineProperty(o, "ref", {
+          get: m,
+          configurable: !0
+        });
+      }
+    }
+    var vr = function(o, u, m, b, P, R, S) {
+      var x = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: o,
+        key: u,
+        ref: m,
+        props: S,
+        // Record the component responsible for creating this element.
+        _owner: R
+      };
+      return x._store = {}, Object.defineProperty(x._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(x, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: b
+      }), Object.defineProperty(x, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: P
+      }), Object.freeze && (Object.freeze(x.props), Object.freeze(x)), x;
+    };
+    function gr(o, u, m, b, P) {
+      {
+        var R, S = {}, x = null, k = null;
+        m !== void 0 && (yt(m), x = "" + m), dr(u) && (yt(u.key), x = "" + u.key), fr(u) && (k = u.ref, pr(u, P));
+        for (R in u)
+          Ee.call(u, R) && !lr.hasOwnProperty(R) && (S[R] = u[R]);
+        if (o && o.defaultProps) {
+          var O = o.defaultProps;
+          for (R in O)
+            S[R] === void 0 && (S[R] = O[R]);
+        }
+        if (x || k) {
+          var T = typeof o == "function" ? o.displayName || o.name || "Unknown" : o;
+          x && mr(S, T), k && hr(S, T);
+        }
+        return vr(o, x, k, P, b, ce.current, S);
+      }
+    }
+    var Le = j.ReactCurrentOwner, wt = j.ReactDebugCurrentFrame;
+    function te(o) {
+      if (o) {
+        var u = o._owner, m = we(o.type, o._source, u ? u.type : null);
+        wt.setExtraStackFrame(m);
+      } else
+        wt.setExtraStackFrame(null);
+    }
+    var Ye;
+    Ye = !1;
+    function Ve(o) {
+      return typeof o == "object" && o !== null && o.$$typeof === t;
+    }
+    function Et() {
+      {
+        if (Le.current) {
+          var o = V(Le.current.type);
+          if (o)
+            return `
+
+Check the render method of \`` + o + "`.";
+        }
+        return "";
+      }
+    }
+    function yr(o) {
+      {
+        if (o !== void 0) {
+          var u = o.fileName.replace(/^.*[\\\/]/, ""), m = o.lineNumber;
+          return `
+
+Check your code at ` + u + ":" + m + ".";
+        }
+        return "";
+      }
+    }
+    var xt = {};
+    function br(o) {
+      {
+        var u = Et();
+        if (!u) {
+          var m = typeof o == "string" ? o : o.displayName || o.name;
+          m && (u = `
+
+Check the top-level render call using <` + m + ">.");
+        }
+        return u;
+      }
+    }
+    function Ct(o, u) {
+      {
+        if (!o._store || o._store.validated || o.key != null)
+          return;
+        o._store.validated = !0;
+        var m = br(u);
+        if (xt[m])
+          return;
+        xt[m] = !0;
+        var b = "";
+        o && o._owner && o._owner !== Le.current && (b = " It was passed a child from " + V(o._owner.type) + "."), te(o), w('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', m, b), te(null);
+      }
+    }
+    function jt(o, u) {
+      {
+        if (typeof o != "object")
+          return;
+        if (Be(o))
+          for (var m = 0; m < o.length; m++) {
+            var b = o[m];
+            Ve(b) && Ct(b, u);
+          }
+        else if (Ve(o))
+          o._store && (o._store.validated = !0);
+        else if (o) {
+          var P = g(o);
+          if (typeof P == "function" && P !== o.entries)
+            for (var R = P.call(o), S; !(S = R.next()).done; )
+              Ve(S.value) && Ct(S.value, u);
+        }
+      }
+    }
+    function _r(o) {
+      {
+        var u = o.type;
+        if (u == null || typeof u == "string")
+          return;
+        var m;
+        if (typeof u == "function")
+          m = u.propTypes;
+        else if (typeof u == "object" && (u.$$typeof === l || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        u.$$typeof === d))
+          m = u.propTypes;
+        else
+          return;
+        if (m) {
+          var b = V(u);
+          ir(m, o.props, "prop", b, o);
+        } else if (u.PropTypes !== void 0 && !Ye) {
+          Ye = !0;
+          var P = V(u);
+          w("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", P || "Unknown");
+        }
+        typeof u.getDefaultProps == "function" && !u.getDefaultProps.isReactClassApproved && w("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function wr(o) {
+      {
+        for (var u = Object.keys(o.props), m = 0; m < u.length; m++) {
+          var b = u[m];
+          if (b !== "children" && b !== "key") {
+            te(o), w("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", b), te(null);
+            break;
+          }
+        }
+        o.ref !== null && (te(o), w("Invalid attribute `ref` supplied to `React.Fragment`."), te(null));
+      }
+    }
+    function St(o, u, m, b, P, R) {
+      {
+        var S = Ae(o);
+        if (!S) {
+          var x = "";
+          (o === void 0 || typeof o == "object" && o !== null && Object.keys(o).length === 0) && (x += " 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 k = yr(P);
+          k ? x += k : x += Et();
+          var O;
+          o === null ? O = "null" : Be(o) ? O = "array" : o !== void 0 && o.$$typeof === t ? (O = "<" + (V(o.type) || "Unknown") + " />", x = " Did you accidentally export a JSX literal instead of a component?") : O = typeof o, w("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", O, x);
+        }
+        var T = gr(o, u, m, P, R);
+        if (T == null)
+          return T;
+        if (S) {
+          var N = u.children;
+          if (N !== void 0)
+            if (b)
+              if (Be(N)) {
+                for (var re = 0; re < N.length; re++)
+                  jt(N[re], o);
+                Object.freeze && Object.freeze(N);
+              } else
+                w("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
+              jt(N, o);
+        }
+        return o === n ? wr(T) : _r(T), T;
+      }
+    }
+    function Er(o, u, m) {
+      return St(o, u, m, !0);
+    }
+    function xr(o, u, m) {
+      return St(o, u, m, !1);
+    }
+    var Cr = xr, jr = Er;
+    le.Fragment = n, le.jsx = Cr, le.jsxs = jr;
+  }()), le;
+}
+process.env.NODE_ENV === "production" ? Ke.exports = Pr() : Ke.exports = Rr();
+var f = Ke.exports;
+const Or = y(({ variant: e = "primary", children: t, className: r, ...n }, s) => /* @__PURE__ */ f.jsx("button", { ref: s, type: "button", className: `sg-button sg-button-${e}${r == null ? "" : " " + r}`, ...n, children: t })), se = y(({ children: e, className: t, ...r }, n) => {
+  let s = Object.keys(se), i = [], c = e.length === void 0 ? e : e.filter((a) => a != null && a != "");
+  return s.forEach((a) => {
+    me.Children.forEach(c, (l) => l.type.name === a ? i.push(l) : null);
+  }), i.length === 0 && (i = [c]), /* @__PURE__ */ f.jsx("div", { ref: n, className: "sg-card " + t, ...r, children: i.map((a) => a) });
+}), Tr = y(({ as: e, className: t, children: r, ...n }, s) => {
+  let c = ["div", "span", "h1", "h2", "h3", "h4", "h5", "h6"].find((a) => a === e) ? e : "div";
+  return /* @__PURE__ */ f.jsx(c, { ref: s, className: `sg-card-header ${t}`, ...n, children: r });
+});
+se.Header = Tr;
+const kr = ({ children: e, className: t, ...r }, n) => {
+  e = e.length ? e.filter((i) => i != null && i != "") : e;
+  let s = [];
+  return me.Children.forEach(e, (i) => {
+    s.push(i);
+  }), /* @__PURE__ */ f.jsx("div", { ref: n, className: `sg-card-body ${t}`, ...r, children: s.map((i) => i) });
+};
+se.Body = y(kr);
+const $r = y(({ as: e, className: t, children: r, ...n }, s) => {
+  let c = ["h1", "h2", "h3", "h4", "h5", "h6"].find((a) => a === e) ? e : "h5";
+  return /* @__PURE__ */ f.jsx(c, { ref: s, className: t, ...n, children: r });
+});
+se.Title = $r;
+const Dr = ({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("p", { ref: n, className: `sg-card-text ${t}`, ...r, children: e });
+se.Text = y(Dr);
+const Fr = ({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("div", { ref: n, className: `sg-card-footer ${t}`, ...r, children: e });
+se.Footer = y(Fr);
+const Ir = y(({ className: e, variant: t = !1, ...r }, n) => /* @__PURE__ */ f.jsx("button", { ref: n, className: `sg-button-close${t ? " sg-button-close-white" : ""} ${e}`, ...r, children: /* @__PURE__ */ f.jsx("span", { className: "sg-close-visually-hidden-label", children: "Close" }) })), Ar = (e, t, r = !1) => {
+  const n = r ? "top-end" : "top-start", s = r ? "top-start" : "top-end", i = r ? "bottom-end" : "bottom-start", c = r ? "bottom-start" : "bottom-end", a = r ? "right-start" : "left-start", l = r ? "right-end" : "left-end", v = r ? "left-start" : "right-start", h = r ? "left-end" : "right-end";
+  let d = e ? c : i;
+  return t === "up" ? d = e ? s : n : t === "end" ? d = e ? h : v : t === "start" ? d = e ? l : a : t === "down-centered" ? d = "bottom" : t === "up-centered" && (d = "top"), d;
+}, Tt = (e, t = "") => {
+  let r = e.target, n = !0, s = !1;
+  for (; n; )
+    r.id != t + "-menu" ? r = r.parentElement : (s = !0, n = !1), r.id === "root" && (n = !1, s = !1);
+  return s;
+}, Pe = he(null), Nr = ({ children: e, value: t, ...r }) => /* @__PURE__ */ f.jsx(Pe.Provider, { value: t, children: e }), q = y(({
+  children: e,
+  className: t,
+  onSelect: r,
+  onToggle: n,
+  controlID: s,
+  drop: i = "down",
+  align: c = "start",
+  autoClose: a = !0,
+  show: l = "default",
+  ...v
+}, h) => {
+  const [d, p] = B(l === "default" ? !1 : l), [E, C] = B({ case: "" }), _ = zt((A) => {
+    A.stopPropagation(), p(($) => !$);
+  }, []), j = Ar(c === "end", i), w = oe(() => ({
+    align: c,
+    drop: i,
+    showInternal: l != "default" && n ? l : d,
+    handleToggle: l != "default" && n ? n : _,
+    placement: j,
+    directionClasses: {
+      down: "dropdown",
+      "down-centered": "dropdown-center",
+      up: "dropup",
+      "up-centered": "dropup-center dropup",
+      end: "dropend",
+      start: "dropstart"
+    },
+    controlID: s,
+    activeDescendant: E,
+    setActiveDescendant: C
+  }), [c, i, l, d, n, _, j, s, E, C]);
+  return /* @__PURE__ */ f.jsx("div", { id: s + "-wrapper", ref: h, className: `sg-dropdown${t ? " " + t : ""}`, ...v, children: /* @__PURE__ */ f.jsx(Nr, { value: w, children: e }) });
+}), Mr = ({ children: e, className: t, navDropdown: r = !1, as: n = "button", variant: s = "primary", ...i }, c) => {
+  const { controlID: a, handleToggle: l, setActiveDescendant: v, showInternal: h } = H(Pe), d = n, p = (g) => {
+    let j = !1;
+    switch (g.key) {
+      case "ArrowDown":
+        j = !0, h ? v((w) => ({ case: "next" })) : (l(g), v((w) => ({ case: "first" })));
+        break;
+      case "ArrowUp":
+        j = !0, h ? v((w) => ({ case: "previous" })) : (l(g), v((w) => ({ case: "last" })));
+        break;
+      case "Home":
+        j = !0, h && v((w) => ({ case: "first" }));
+        break;
+      case "End":
+        j = !0, h && v((w) => ({ case: "last" }));
+        break;
+      case "Escape":
+        j = !0, h && l(g);
+        break;
+      case "Enter":
+      case " ":
+        if (h) {
+          j = !0, document.querySelector(".sg-dropdown-item-visual-focus").click(), l(g);
+          break;
+        } else {
+          v((w) => ({ case: "first" }));
+          break;
+        }
+    }
+    j && (g.stopPropagation(), g.preventDefault());
+  }, E = (g) => {
+    h && g.target.id !== a && (Tt(g, a) ? Tt(g, a) && (l(g), document.getElementById(a).focus()) : l(g));
+  };
+  L(() => {
+    const g = document.getElementById(a);
+    return g.addEventListener("keydown", p, !0), document.addEventListener("mouseup", E, !0), function() {
+      g.removeEventListener("keydown", p, !0), document.removeEventListener("mouseup", E, !0);
+    };
+  }, [p, a]);
+  const C = (g) => {
+    l(g), h || v((j) => ({ case: "first" }));
+  };
+  let _ = `sg-button sg-button${s ? "-" + s : "-primary"} sg-dropdown-toggle${t ? " " + t : ""}`;
+  return (d === "a" || r) && (_ = `sg-nav-dropdown-toggle sg-dropdown-toggle${t ? " " + t : ""}`), /* @__PURE__ */ f.jsx(
+    d,
+    {
+      tabIndex: "0",
+      type: "button",
+      "aria-haspopup": "true",
+      "aria-controls": a + "-menu",
+      "aria-expanded": h,
+      id: a,
+      ref: c,
+      className: _,
+      onClick: (g) => C(g),
+      ...i,
+      children: e
+    }
+  );
+};
+q.Toggle = y(Mr);
+const zr = ({ children: e, className: t, style: r = {}, ...n }, s) => {
+  const { controlID: i, showInternal: c, activeDescendant: a } = H(Pe), [l, v] = B(r);
+  Sr(() => {
+    if (c) {
+      const d = document.getElementById(i + "-menu");
+      console.log(d);
+      let p = {};
+      d.getBoundingClientRect().right > window.innerWidth ? p = { ...p, right: 0 } : d.getBoundingClientRect().left < 0 ? p = { ...p, left: 0 } : d.getBoundingClientRect().top < 0 ? p = { ...p, top: 0 } : d.getBoundingClientRect().bottom > window.innerHeight && (p = { ...p, bottom: 0 }), console.log(p), v((E) => ({ ...E, ...p }));
+    }
+  }, [c]), L(() => {
+    if (c) {
+      const d = document.getElementById(i + "-menu"), p = document.getElementById(i + "-menu").children, E = p.length - 1, C = document.querySelector(".sg-dropdown-item-visual-focus");
+      let _ = 0, g = p[0].children[0];
+      if (C != null) {
+        for (let j = 0; j < p.length; j++)
+          p[j] === C.parentElement && (_ = j);
+        C.classList.remove("sg-dropdown-item-visual-focus");
+      }
+      switch (a.case) {
+        case "first":
+          g = p[0].children[0], _ = 0;
+          break;
+        case "last":
+          g = p[E].children[0], _ = E;
+          break;
+        case "next":
+          _ = _ === E ? 0 : _ + 1, g = p[_].children[0];
+          break;
+        case "previous":
+          _ = _ === 0 ? E : _ - 1, g = p[_].children[0];
+          break;
+      }
+      d.setAttribute("aria-activedescendant", g.id), p[_].children[0].classList.add("sg-dropdown-item-visual-focus");
+    } else
+      document.getElementById(i + "-menu").setAttribute("aria-activedescendant", "");
+  }, [i, c, a]);
+  const h = (d) => {
+    const p = d.target;
+    p.classList.contains("sg-dropdown-item-visual-focus") || (document.querySelector(".sg-dropdown-item-visual-focus").classList.remove("sg-dropdown-item-visual-focus"), p.classList.add("sg-dropdown-item-visual-focus"));
+  };
+  return L(() => {
+    const d = document.getElementById(i + "-menu");
+    for (let p of d.children)
+      p.addEventListener("mouseover", h, !0);
+    return function() {
+      for (let E of d.children)
+        E.removeEventListener("mouseover", h, !0);
+    };
+  }, []), /* @__PURE__ */ f.jsx(
+    "ul",
+    {
+      id: i + "-menu",
+      role: "menu",
+      tabIndex: "-1",
+      "aria-labelledby": i,
+      "aria-activedescendant": a,
+      ref: s,
+      className: `sg-dropdown-list${t ? " " + t : ""}${c ? " show" : ""}`,
+      style: l,
+      ...n,
+      children: e
+    }
+  );
+};
+q.Menu = y(zr);
+const Br = ({ children: e, as: t = "button", className: r, ...n }, s) => {
+  const i = t;
+  return /* @__PURE__ */ f.jsx("li", { role: "none", children: /* @__PURE__ */ f.jsx(i, { role: "menuitem", tabIndex: "-1", ref: s, className: `sg-dropdown-item${r ? " " + r : ""}`, ...n, children: e }) });
+};
+q.Item = y(Br);
+const Wr = ({ className: e = "", ...t }, r) => /* @__PURE__ */ f.jsx("hr", { className: `.sg-dropdown-divider${e}`, ...t });
+q.Divider = y(Wr);
+const ve = he(!1), Lr = ({ children: e, value: t }) => /* @__PURE__ */ f.jsx(ve.Provider, { value: t, children: e }), ie = y(({ children: e, ...t }, r) => /* @__PURE__ */ f.jsx("form", { ref: r, ...t, children: e })), Yr = ({ as: e = "input", className: t = "", plaintext: r = !1, id: n = "", type: s = "text", autoFocus: i = !1, ...c }, a) => {
+  let l = ["input", "textarea"].find((p) => p === e) ? e : "input";
+  const { controlId: v } = H(ve);
+  let h = v || n, d = (r ? "sg-form-control-plaintext" : "sg-form-control") + (t != "" ? " " + t : "") + (s == "color" ? " sg-form-control-color" : "");
+  return /* @__PURE__ */ f.jsx(l, { autoFocus: i, ref: a, id: h, type: s, className: d, ...c });
+};
+ie.Control = y(Yr);
+const Vr = ({ children: e, className: t, id: r, ...n }, s) => {
+  const { controlId: i } = H(ve);
+  let c = i || r;
+  return /* @__PURE__ */ f.jsx("select", { ref: s, className: `sg-form-select${t ? " " + t : ""}`, id: c, ...n, children: e });
+};
+ie.Select = y(Vr);
+const Ur = ({ children: e, className: t, controlId: r, ...n }, s) => {
+  const i = oe(() => ({ controlId: r }), [r]);
+  return /* @__PURE__ */ f.jsx("div", { ref: s, className: `sg-from-group${t ? " " + t : ""}`, ...n, children: /* @__PURE__ */ f.jsx(Lr, { value: i, children: e }) });
+};
+ie.Group = y(Ur);
+const Hr = ({ children: e, className: t, htmlFor: r }, n) => {
+  const { controlId: s } = H(ve);
+  let i = r || s;
+  return /* @__PURE__ */ f.jsx("label", { ref: n, htmlFor: i, className: `sg-form-label${t ? " " + t : ""}`, children: e });
+};
+ie.Label = y(Hr);
+const qr = ({
+  classNameContainer: e,
+  containerRef: t,
+  containerId: r,
+  style: n,
+  classNameLabel: s,
+  labelRef: i,
+  label: c,
+  labelId: a,
+  className: l,
+  type: v,
+  id: h,
+  controlId: d,
+  reverse: p = !1,
+  checkStyle: E,
+  ...C
+}, _) => {
+  let g = d || h, j = v === "switch" ? "checkbox" : v;
+  return /* @__PURE__ */ f.jsx("div", { ref: t, id: r, style: n, className: `sg-form-check${p ? "-reverse" : ""}${e ? " " + e : ""}${v === "switch" ? " sg-form-switch" : ""}`, children: p ? /* @__PURE__ */ f.jsxs(f.Fragment, { children: [
+    /* @__PURE__ */ f.jsx("input", { ref: _, type: j, id: g, className: `sg-form-check-input${l ? " " + l : ""}`, ...C }),
+    /* @__PURE__ */ f.jsx("label", { ref: i, id: a, htmlFor: g, className: `sg-form-check-label${s ? " " + s : ""}`, children: c })
+  ] }) : /* @__PURE__ */ f.jsxs(f.Fragment, { children: [
+    /* @__PURE__ */ f.jsx("label", { ref: i, id: a, htmlFor: g, className: `sg-form-check-label${s ? " " + s : ""}`, children: c }),
+    /* @__PURE__ */ f.jsx("input", { ref: _, type: j, id: g, className: `sg-form-check-input${l ? " " + l : ""}`, style: E, ...C })
+  ] }) });
+};
+ie.Check = y(qr);
+const Kr = ({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("small", { className: `sg-form-text${t ? " " + t : ""}`, children: e });
+ie.Text = y(Kr);
+const oo = y(({ children: e, label: t, controlId: r, ...n }, s) => {
+  const i = oe(() => ({ controlId: r }));
+  return /* @__PURE__ */ f.jsx(ve.Provider, { value: i, children: /* @__PURE__ */ f.jsxs("div", { className: "sg-form-floating", children: [
+    e,
+    /* @__PURE__ */ f.jsx("label", { ref: s, htmlFor: i.controlId, className: "sg-form-floating-label", ...n, children: t })
+  ] }) });
+}), Gr = y(({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("div", { ref: n, className: `sg-input-group${t ? " " + t : ""}`, ...r, children: e })), Xr = ({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("span", { ref: n, className: `sg-input-group-text${t ? " " + t : ""}`, ...r, children: e });
+Gr.Text = y(Xr);
+const Wt = he(!1), Jr = ({ children: e, value: t }) => /* @__PURE__ */ f.jsx(Wt.Provider, { value: t, children: e }), Zr = () => H(Wt), K = y(({
+  children: e,
+  centered: t = !1,
+  size: r = "md",
+  show: n,
+  backdrop: s = "static",
+  onHide: i = "none",
+  className: c,
+  id: a,
+  ...l
+}, v) => {
+  const [h, d] = B(!1);
+  L(() => {
+    d(n);
+  }, [n]);
+  const p = qe(null);
+  nn(p);
+  let E = typeof n == "boolean" && typeof i == "function" ? void 0 : { show: typeof n == "boolean", onHide: typeof i == "function" };
+  E && console.error(
+    E.show ? null : "The variable 'show' must be used and must be a boolean used to decide when to show the modal!",
+    E.onHide ? null : "The variable 'onHide' must be used and must be a function which is used to set 'show' as the modal gets closed!"
+  );
+  const C = () => {
+    i && i(), d(!1);
+  };
+  L(() => {
+    const g = p.current;
+    g && (h ? g.showModal() : g.close());
+  }, [h]);
+  let _ = `sg-modal-tag sg-modal-${r}`;
+  return c && (_ += " " + c), (s === "static" || s === "true") && (_ += " sg-modal-static"), h ? Bt(
+    /* @__PURE__ */ f.jsx("dialog", { ref: p, className: _, children: /* @__PURE__ */ f.jsx(Jr, { value: i, children: E ? /* @__PURE__ */ f.jsxs(f.Fragment, { children: [
+      /* @__PURE__ */ f.jsx(K.Header, { closeButton: !0, children: /* @__PURE__ */ f.jsx(K.Title, { children: "An Error ocurred!" }) }),
+      /* @__PURE__ */ f.jsx(K.Body, { children: /* @__PURE__ */ f.jsxs("p", { children: [
+        E.show ? null : "The variable 'show' must be used and must be a boolean used to decide when to show the modal!",
+        E.onHide ? null : "The variable 'onHide' must be used and must be a function which is used to set 'show' as the modal gets closed!"
+      ] }) }),
+      /* @__PURE__ */ f.jsx(K.Footer, { children: /* @__PURE__ */ f.jsx(Or, { variant: "danger", type: "button", onClick: C, children: "Close" }) })
+    ] }) : e }) }),
+    document.body
+  ) : null;
+}), Qr = y(({ as: e = "", className: t = "", children: r, closeButton: n = !1, onClick: s = "none", ...i }, c) => {
+  let l = ["div", "span", "h1", "h2", "h3", "h4", "h5", "h6"].find((d) => d === e) ? e : "div";
+  const v = Zr(), h = (d) => {
+    s != "none" && s(d), v != "none" && v();
+  };
+  return /* @__PURE__ */ f.jsxs(l, { ref: c, className: `sg-modal-header ${t}`, ...i, children: [
+    r,
+    n ? /* @__PURE__ */ f.jsx(Ir, { variant: !0, onClick: h }) : null
+  ] });
+});
+K.Header = Qr;
+const en = ({ children: e, as: t = "h4", className: r, ...n }, s) => {
+  let c = ["div", "span", "h1", "h2", "h3", "h4", "h5", "h6"].find((a) => a === t) ? t : "h4";
+  return /* @__PURE__ */ f.jsx(c, { ref: s, className: `sg-modal-title ${r}`, ...n, children: e });
+};
+K.Title = y(en);
+const tn = ({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("div", { ref: n, className: `sg-modal-body ${t}`, ...r, children: e });
+K.Body = y(tn);
+const rn = ({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("div", { ref: n, className: `sg-modal-footer ${t}`, ...r, children: e });
+K.Footer = y(rn);
+const nn = function(e) {
+  L(() => {
+    const t = (r) => {
+      const n = 'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])', s = e.current;
+      if (s) {
+        const i = s.querySelectorAll(n)[0], c = s.querySelectorAll(n), a = c[c.length - 1];
+        if (!(r.key === "Tab" || r.keyCode === 9))
+          return;
+        r.shiftKey ? document.activeElement === i && (a.focus(), r.preventDefault()) : document.activeElement === a && (i.focus(), r.preventDefault());
+      }
+    };
+    return document.addEventListener("keydown", t, !0), function() {
+      document.removeEventListener("keydown", t, !0);
+    };
+  }, [e]);
+}, Lt = he(null), on = ({ children: e, value: t }) => /* @__PURE__ */ f.jsx(Lt.Provider, { value: t, children: e }), Yt = y(({ children: e, className: t, navbarPrefix: r = "sg-navbar-", ...n }, s) => {
+  const i = oe(() => r, [r]);
+  return /* @__PURE__ */ f.jsx("nav", { ref: s, className: `sg-navbar${t ? " " + t : ""}`, ...n, children: /* @__PURE__ */ f.jsx(on, { value: i, children: e }) });
+}), sn = ({ children: e, className: t, href: r = "#", as: n = "a", ...s }, i) => {
+  const c = n || (r && n != "Link" ? "a" : "span");
+  return /* @__PURE__ */ f.jsx(c, { ref: i, href: r, className: `sg-navbar-brand${t ? " " + t : ""}`, ...s, children: e });
+};
+Yt.Brand = y(sn);
+const an = ({ children: e, className: t, as: r = "span", ...n }, s) => {
+  const i = r;
+  return /* @__PURE__ */ f.jsx(i, { ref: s, className: `sg-navbar-text${t ? " " + t : ""}`, ...n, children: e });
+};
+Yt.Text = y(an);
+const Vt = y(({ children: e, className: t, fill: r, justify: n, as: s = "ul", ...i }, c) => {
+  const a = s;
+  let l = "";
+  return Lt && (l = "sg-navbar-"), /* @__PURE__ */ f.jsx(a, { role: "menubar", ref: c, className: `${t} ${l}nav`, ...i, children: e });
+}), cn = ({ children: e, className: t, as: r = "li", ...n }, s) => {
+  const i = r;
+  return /* @__PURE__ */ f.jsx(i, { role: "none", ref: s, className: `sg-nav-item${t ? " " + t : ""}`, ...n, children: e });
+};
+Vt.Item = y(cn);
+const un = ({ children: e, className: t, as: r = "a", ...n }, s) => {
+  const i = r;
+  return /* @__PURE__ */ f.jsx(i, { role: "menuitem", ref: s, className: `sg-nav-link${t ? " " + t : ""}`, ...n, children: e });
+};
+Vt.Link = y(un);
+function ln(e) {
+  if (typeof e != "object" || e === null)
+    return !1;
+  let t = e;
+  for (; Object.getPrototypeOf(t) !== null; )
+    t = Object.getPrototypeOf(t);
+  return Object.getPrototypeOf(e) === t || Object.getPrototypeOf(e) === null;
+}
+function fn(e) {
+  return ln(e) && "type" in e && typeof e.type == "string";
+}
+var Ut = Symbol.for("immer-nothing"), kt = Symbol.for("immer-draftable"), F = Symbol.for("immer-state"), dn = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(e) {
+    return `The plugin for '${e}' has not been loaded into Immer. To enable the plugin, import and call \`enable${e}()\` when initializing your application.`;
+  },
+  function(e) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${e}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(e) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + e;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(e) {
+    return `'current' expects a draft, got: ${e}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(e) {
+    return `'original' expects a draft, got: ${e}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function D(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = dn[e], n = typeof r == "function" ? r.apply(null, t) : r;
+    throw new Error(`[Immer] ${n}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var ne = Object.getPrototypeOf;
+function Z(e) {
+  return !!e && !!e[F];
+}
+function Q(e) {
+  var t;
+  return e ? Ht(e) || Array.isArray(e) || !!e[kt] || !!((t = e.constructor) != null && t[kt]) || Oe(e) || Te(e) : !1;
+}
+var pn = Object.prototype.constructor.toString();
+function Ht(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = ne(e);
+  if (t === null)
+    return !0;
+  const r = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  return r === Object ? !0 : typeof r == "function" && Function.toString.call(r) === pn;
+}
+function fe(e, t) {
+  Re(e) === 0 ? Object.entries(e).forEach(([r, n]) => {
+    t(r, n, e);
+  }) : e.forEach((r, n) => t(n, r, e));
+}
+function Re(e) {
+  const t = e[F];
+  return t ? t.type_ : Array.isArray(e) ? 1 : Oe(e) ? 2 : Te(e) ? 3 : 0;
+}
+function Ge(e, t) {
+  return Re(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function qt(e, t, r) {
+  const n = Re(e);
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+}
+function mn(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function Oe(e) {
+  return e instanceof Map;
+}
+function Te(e) {
+  return e instanceof Set;
+}
+function J(e) {
+  return e.copy_ || e.base_;
+}
+function Xe(e, t) {
+  if (Oe(e))
+    return new Map(e);
+  if (Te(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  if (!t && Ht(e))
+    return ne(e) ? { ...e } : Object.assign(/* @__PURE__ */ Object.create(null), e);
+  const r = Object.getOwnPropertyDescriptors(e);
+  delete r[F];
+  let n = Reflect.ownKeys(r);
+  for (let s = 0; s < n.length; s++) {
+    const i = n[s], c = r[i];
+    c.writable === !1 && (c.writable = !0, c.configurable = !0), (c.get || c.set) && (r[i] = {
+      configurable: !0,
+      writable: !0,
+      // could live with !!desc.set as well here...
+      enumerable: c.enumerable,
+      value: e[i]
+    });
+  }
+  return Object.create(ne(e), r);
+}
+function tt(e, t = !1) {
+  return ke(e) || Z(e) || !Q(e) || (Re(e) > 1 && (e.set = e.add = e.clear = e.delete = hn), Object.freeze(e), t && fe(e, (r, n) => tt(n, !0))), e;
+}
+function hn() {
+  D(2);
+}
+function ke(e) {
+  return Object.isFrozen(e);
+}
+var vn = {};
+function ee(e) {
+  const t = vn[e];
+  return t || D(0, e), t;
+}
+var de;
+function Kt() {
+  return de;
+}
+function gn(e, t) {
+  return {
+    drafts_: [],
+    parent_: e,
+    immer_: t,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: !0,
+    unfinalizedDrafts_: 0
+  };
+}
+function $t(e, t) {
+  t && (ee("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function Je(e) {
+  Ze(e), e.drafts_.forEach(yn), e.drafts_ = null;
+}
+function Ze(e) {
+  e === de && (de = e.parent_);
+}
+function Dt(e) {
+  return de = gn(de, e);
+}
+function yn(e) {
+  const t = e[F];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function Ft(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  return e !== void 0 && e !== r ? (r[F].modified_ && (Je(t), D(4)), Q(e) && (e = je(t, e), t.parent_ || Se(t, e)), t.patches_ && ee("Patches").generateReplacementPatches_(
+    r[F].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = je(t, r, []), Je(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== Ut ? e : void 0;
+}
+function je(e, t, r) {
+  if (ke(t))
+    return t;
+  const n = t[F];
+  if (!n)
+    return fe(
+      t,
+      (s, i) => It(e, n, t, s, i, r)
+    ), t;
+  if (n.scope_ !== e)
+    return t;
+  if (!n.modified_)
+    return Se(e, n.base_, !0), n.base_;
+  if (!n.finalized_) {
+    n.finalized_ = !0, n.scope_.unfinalizedDrafts_--;
+    const s = n.copy_;
+    let i = s, c = !1;
+    n.type_ === 3 && (i = new Set(s), s.clear(), c = !0), fe(
+      i,
+      (a, l) => It(e, n, s, a, l, r, c)
+    ), Se(e, s, !1), r && e.patches_ && ee("Patches").generatePatches_(
+      n,
+      r,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return n.copy_;
+}
+function It(e, t, r, n, s, i, c) {
+  if (process.env.NODE_ENV !== "production" && s === r && D(5), Z(s)) {
+    const a = i && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+    !Ge(t.assigned_, n) ? i.concat(n) : void 0, l = je(e, s, a);
+    if (qt(r, n, l), Z(l))
+      e.canAutoFreeze_ = !1;
+    else
+      return;
+  } else
+    c && r.add(s);
+  if (Q(s) && !ke(s)) {
+    if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1)
+      return;
+    je(e, s), (!t || !t.scope_.parent_) && Se(e, s);
+  }
+}
+function Se(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && tt(t, r);
+}
+function bn(e, t) {
+  const r = Array.isArray(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : Kt(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: t,
+    // The base state.
+    base_: e,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1
+  };
+  let s = n, i = rt;
+  r && (s = [n], i = pe);
+  const { revoke: c, proxy: a } = Proxy.revocable(s, i);
+  return n.draft_ = a, n.revoke_ = c, a;
+}
+var rt = {
+  get(e, t) {
+    if (t === F)
+      return e;
+    const r = J(e);
+    if (!Ge(r, t))
+      return _n(e, r, t);
+    const n = r[t];
+    return e.finalized_ || !Q(n) ? n : n === Ue(e.base_, t) ? (He(e), e.copy_[t] = et(n, e)) : n;
+  },
+  has(e, t) {
+    return t in J(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(J(e));
+  },
+  set(e, t, r) {
+    const n = Gt(J(e), t);
+    if (n != null && n.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const s = Ue(J(e), t), i = s == null ? void 0 : s[F];
+      if (i && i.base_ === r)
+        return e.copy_[t] = r, e.assigned_[t] = !1, !0;
+      if (mn(r, s) && (r !== void 0 || Ge(e.base_, t)))
+        return !0;
+      He(e), Qe(e);
+    }
+    return e.copy_[t] === r && // special case: handle new props with value 'undefined'
+    (r !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(r) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = r, e.assigned_[t] = !0), !0;
+  },
+  deleteProperty(e, t) {
+    return Ue(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, He(e), Qe(e)) : delete e.assigned_[t], e.copy_ && delete e.copy_[t], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(e, t) {
+    const r = J(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: n.enumerable,
+      value: r[t]
+    };
+  },
+  defineProperty() {
+    D(11);
+  },
+  getPrototypeOf(e) {
+    return ne(e.base_);
+  },
+  setPrototypeOf() {
+    D(12);
+  }
+}, pe = {};
+fe(rt, (e, t) => {
+  pe[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+pe.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && D(13), pe.set.call(this, e, t, void 0);
+};
+pe.set = function(e, t, r) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && D(14), rt.set.call(this, e[0], t, r, e[0]);
+};
+function Ue(e, t) {
+  const r = e[F];
+  return (r ? J(r) : e)[t];
+}
+function _n(e, t, r) {
+  var s;
+  const n = Gt(t, r);
+  return n ? "value" in n ? n.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    (s = n.get) == null ? void 0 : s.call(e.draft_)
+  ) : void 0;
+}
+function Gt(e, t) {
+  if (!(t in e))
+    return;
+  let r = ne(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = ne(r);
+  }
+}
+function Qe(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && Qe(e.parent_));
+}
+function He(e) {
+  e.copy_ || (e.copy_ = Xe(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var wn = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.produce = (t, r, n) => {
+      if (typeof t == "function" && typeof r != "function") {
+        const i = r;
+        r = t;
+        const c = this;
+        return function(l = i, ...v) {
+          return c.produce(l, (h) => r.call(this, h, ...v));
+        };
+      }
+      typeof r != "function" && D(6), n !== void 0 && typeof n != "function" && D(7);
+      let s;
+      if (Q(t)) {
+        const i = Dt(this), c = et(t, void 0);
+        let a = !0;
+        try {
+          s = r(c), a = !1;
+        } finally {
+          a ? Je(i) : Ze(i);
+        }
+        return $t(i, n), Ft(s, i);
+      } else if (!t || typeof t != "object") {
+        if (s = r(t), s === void 0 && (s = t), s === Ut && (s = void 0), this.autoFreeze_ && tt(s, !0), n) {
+          const i = [], c = [];
+          ee("Patches").generateReplacementPatches_(t, s, i, c), n(i, c);
+        }
+        return s;
+      } else
+        D(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (typeof t == "function")
+        return (c, ...a) => this.produceWithPatches(c, (l) => t(l, ...a));
+      let n, s;
+      return [this.produce(t, r, (c, a) => {
+        n = c, s = a;
+      }), n, s];
+    }, typeof (e == null ? void 0 : e.autoFreeze) == "boolean" && this.setAutoFreeze(e.autoFreeze), typeof (e == null ? void 0 : e.useStrictShallowCopy) == "boolean" && this.setUseStrictShallowCopy(e.useStrictShallowCopy);
+  }
+  createDraft(e) {
+    Q(e) || D(8), Z(e) && (e = Xt(e));
+    const t = Dt(this), r = et(e, void 0);
+    return r[F].isManual_ = !0, Ze(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[F];
+    (!r || !r.isManual_) && D(9);
+    const { scope_: n } = r;
+    return $t(n, t), Ft(void 0, n);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(e) {
+    this.autoFreeze_ = e;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(e) {
+    this.useStrictShallowCopy_ = e;
+  }
+  applyPatches(e, t) {
+    let r;
+    for (r = t.length - 1; r >= 0; r--) {
+      const s = t[r];
+      if (s.path.length === 0 && s.op === "replace") {
+        e = s.value;
+        break;
+      }
+    }
+    r > -1 && (t = t.slice(r + 1));
+    const n = ee("Patches").applyPatches_;
+    return Z(e) ? n(e, t) : this.produce(
+      e,
+      (s) => n(s, t)
+    );
+  }
+};
+function et(e, t) {
+  const r = Oe(e) ? ee("MapSet").proxyMap_(e, t) : Te(e) ? ee("MapSet").proxySet_(e, t) : bn(e, t);
+  return (t ? t.scope_ : Kt()).drafts_.push(r), r;
+}
+function Xt(e) {
+  return Z(e) || D(10, e), Jt(e);
+}
+function Jt(e) {
+  if (!Q(e) || ke(e))
+    return e;
+  const t = e[F];
+  let r;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = Xe(e, t.scope_.immer_.useStrictShallowCopy_);
+  } else
+    r = Xe(e, !0);
+  return fe(r, (n, s) => {
+    qt(r, n, Jt(s));
+  }), t && (t.finalized_ = !1), r;
+}
+var I = new wn();
+I.produce;
+I.produceWithPatches.bind(
+  I
+);
+I.setAutoFreeze.bind(I);
+I.setUseStrictShallowCopy.bind(I);
+I.applyPatches.bind(I);
+I.createDraft.bind(I);
+I.finishDraft.bind(I);
+var En = (e, t, r) => {
+  if (t.length === 1 && t[0] === r) {
+    let n = !1;
+    try {
+      const s = {};
+      e(s) === s && (n = !0);
+    } catch {
+    }
+    if (n) {
+      let s;
+      try {
+        throw new Error();
+      } catch (i) {
+        ({ stack: s } = i);
+      }
+      console.warn(
+        `The result function returned its own inputs without modification. e.g
+\`createSelector([state => state.todos], todos => todos)\`
+This could lead to inefficient memoization and unnecessary re-renders.
+Ensure transformation logic is in the result function, and extraction logic is in the input selectors.`,
+        { stack: s }
+      );
+    }
+  }
+}, xn = (e, t, r) => {
+  const { memoize: n, memoizeOptions: s } = t, { inputSelectorResults: i, inputSelectorResultsCopy: c } = e, a = n(() => ({}), ...s);
+  if (!(a.apply(null, i) === a.apply(null, c))) {
+    let v;
+    try {
+      throw new Error();
+    } catch (h) {
+      ({ stack: v } = h);
+    }
+    console.warn(
+      `An input selector returned a different result when passed same arguments.
+This means your output selector will likely run more frequently than intended.
+Avoid returning a new reference inside your input selector, e.g.
+\`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)\``,
+      {
+        arguments: r,
+        firstInputs: i,
+        secondInputs: c,
+        stack: v
+      }
+    );
+  }
+}, Cn = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+};
+function jn(e, t = `expected a function, instead received ${typeof e}`) {
+  if (typeof e != "function")
+    throw new TypeError(t);
+}
+function Sn(e, t = `expected an object, instead received ${typeof e}`) {
+  if (typeof e != "object")
+    throw new TypeError(t);
+}
+function Pn(e, t = "expected all items to be functions, instead received the following types: ") {
+  if (!e.every((r) => typeof r == "function")) {
+    const r = e.map(
+      (n) => typeof n == "function" ? `function ${n.name || "unnamed"}()` : typeof n
+    ).join(", ");
+    throw new TypeError(`${t}[${r}]`);
+  }
+}
+var At = (e) => Array.isArray(e) ? e : [e];
+function Rn(e) {
+  const t = Array.isArray(e[0]) ? e[0] : e;
+  return Pn(
+    t,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), t;
+}
+function Nt(e, t) {
+  const r = [], { length: n } = e;
+  for (let s = 0; s < n; s++)
+    r.push(e[s].apply(null, t));
+  return r;
+}
+var On = (e, t) => {
+  const { identityFunctionCheck: r, inputStabilityCheck: n } = {
+    ...Cn,
+    ...t
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: r === "always" || r === "once" && e,
+      run: En
+    },
+    inputStabilityCheck: {
+      shouldRun: n === "always" || n === "once" && e,
+      run: xn
+    }
+  };
+}, Tn = class {
+  constructor(e) {
+    this.value = e;
+  }
+  deref() {
+    return this.value;
+  }
+}, kn = typeof WeakRef < "u" ? WeakRef : Tn, $n = 0, Mt = 1;
+function Ce() {
+  return {
+    s: $n,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function nt(e, t = {}) {
+  let r = Ce();
+  const { resultEqualityCheck: n } = t;
+  let s, i = 0;
+  function c() {
+    var d;
+    let a = r;
+    const { length: l } = arguments;
+    for (let p = 0, E = l; p < E; p++) {
+      const C = arguments[p];
+      if (typeof C == "function" || typeof C == "object" && C !== null) {
+        let _ = a.o;
+        _ === null && (a.o = _ = /* @__PURE__ */ new WeakMap());
+        const g = _.get(C);
+        g === void 0 ? (a = Ce(), _.set(C, a)) : a = g;
+      } else {
+        let _ = a.p;
+        _ === null && (a.p = _ = /* @__PURE__ */ new Map());
+        const g = _.get(C);
+        g === void 0 ? (a = Ce(), _.set(C, a)) : a = g;
+      }
+    }
+    const v = a;
+    let h;
+    if (a.s === Mt ? h = a.v : (h = e.apply(null, arguments), i++), v.s = Mt, n) {
+      const p = ((d = s == null ? void 0 : s.deref) == null ? void 0 : d.call(s)) ?? s;
+      p != null && n(p, h) && (h = p, i !== 0 && i--), s = typeof h == "object" && h !== null || typeof h == "function" ? new kn(h) : h;
+    }
+    return v.v = h, h;
+  }
+  return c.clearCache = () => {
+    r = Ce(), c.resetResultsCount();
+  }, c.resultsCount = () => i, c.resetResultsCount = () => {
+    i = 0;
+  }, c;
+}
+function Zt(e, ...t) {
+  const r = typeof e == "function" ? {
+    memoize: e,
+    memoizeOptions: t
+  } : e, n = (...s) => {
+    let i = 0, c = 0, a, l = {}, v = s.pop();
+    typeof v == "object" && (l = v, v = s.pop()), jn(
+      v,
+      `createSelector expects an output function after the inputs, but received: [${typeof v}]`
+    );
+    const h = {
+      ...r,
+      ...l
+    }, {
+      memoize: d,
+      memoizeOptions: p = [],
+      argsMemoize: E = nt,
+      argsMemoizeOptions: C = [],
+      devModeChecks: _ = {}
+    } = h, g = At(p), j = At(C), w = Rn(s), A = d(function() {
+      return i++, v.apply(
+        null,
+        arguments
+      );
+    }, ...g);
+    let $ = !0;
+    const M = E(function() {
+      c++;
+      const z = Nt(
+        w,
+        arguments
+      );
+      if (a = A.apply(null, z), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: W, inputStabilityCheck: Y } = On($, _);
+        if (W.shouldRun && W.run(
+          v,
+          z,
+          a
+        ), Y.shouldRun) {
+          const Ae = Nt(
+            w,
+            arguments
+          );
+          Y.run(
+            { inputSelectorResults: z, inputSelectorResultsCopy: Ae },
+            { memoize: d, memoizeOptions: g },
+            arguments
+          );
+        }
+        $ && ($ = !1);
+      }
+      return a;
+    }, ...j);
+    return Object.assign(M, {
+      resultFunc: v,
+      memoizedResultFunc: A,
+      dependencies: w,
+      dependencyRecomputations: () => c,
+      resetDependencyRecomputations: () => {
+        c = 0;
+      },
+      lastResult: () => a,
+      recomputations: () => i,
+      resetRecomputations: () => {
+        i = 0;
+      },
+      memoize: d,
+      argsMemoize: E
+    });
+  };
+  return Object.assign(n, {
+    withTypes: () => n
+  }), n;
+}
+var Dn = /* @__PURE__ */ Zt(nt), Fn = Object.assign(
+  (e, t = Dn) => {
+    Sn(
+      e,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof e}`
+    );
+    const r = Object.keys(e), n = r.map(
+      (i) => e[i]
+    );
+    return t(
+      n,
+      (...i) => i.reduce((c, a, l) => (c[r[l]] = a, c), {})
+    );
+  },
+  { withTypes: () => Fn }
+), In = (...e) => {
+  const t = Zt(...e), r = Object.assign((...n) => {
+    const s = t(...n), i = (c, ...a) => s(Z(c) ? Xt(c) : c, ...a);
+    return Object.assign(i, s), i;
+  }, {
+    withTypes: () => r
+  });
+  return r;
+};
+In(nt);
+function $e(e, t) {
+  function r(...n) {
+    if (t) {
+      let s = t(...n);
+      if (!s)
+        throw new Error(process.env.NODE_ENV === "production" ? De(0) : "prepareAction did not return an object");
+      return {
+        type: e,
+        payload: s.payload,
+        ..."meta" in s && {
+          meta: s.meta
+        },
+        ..."error" in s && {
+          error: s.error
+        }
+      };
+    }
+    return {
+      type: e,
+      payload: n[0]
+    };
+  }
+  return r.toString = () => `${e}`, r.type = e, r.match = (n) => fn(n) && n.type === e, r;
+}
+process.env.NODE_ENV;
+var An = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW", Qt = (e = 21) => {
+  let t = "", r = e;
+  for (; r--; )
+    t += An[Math.random() * 64 | 0];
+  return t;
+}, Nn = (e, t) => {
+  if (typeof e != "function")
+    throw new Error(process.env.NODE_ENV === "production" ? De(32) : `${t} is not a function`);
+}, ot = "listenerMiddleware", Mn = (e) => {
+  let {
+    type: t,
+    actionCreator: r,
+    matcher: n,
+    predicate: s,
+    effect: i
+  } = e;
+  if (t)
+    s = $e(t).match;
+  else if (r)
+    t = r.type, s = r.match;
+  else if (n)
+    s = n;
+  else if (!s)
+    throw new Error(process.env.NODE_ENV === "production" ? De(21) : "Creating or removing a listener requires one of the known fields for matching an action");
+  return Nn(i, "options.listener"), {
+    predicate: s,
+    type: t,
+    effect: i
+  };
+}, zn = Object.assign((e) => {
+  const {
+    type: t,
+    predicate: r,
+    effect: n
+  } = Mn(e);
+  return {
+    id: Qt(),
+    effect: n,
+    type: t,
+    predicate: r,
+    pending: /* @__PURE__ */ new Set(),
+    unsubscribe: () => {
+      throw new Error(process.env.NODE_ENV === "production" ? De(22) : "Unsubscribe not initialized");
+    }
+  };
+}, {
+  withTypes: () => zn
+}), Bn = Object.assign($e(`${ot}/add`), {
+  withTypes: () => Bn
+});
+$e(`${ot}/removeAll`);
+var Wn = Object.assign($e(`${ot}/remove`), {
+  withTypes: () => Wn
+});
+function De(e) {
+  return `Minified Redux Toolkit error #${e}; visit https://redux-toolkit.js.org/Errors?code=${e} for the full message or use the non-minified dev environment for full errors. `;
+}
+const Ln = (e, t, r = !1) => {
+  const n = r ? "top-end" : "top-start", s = r ? "top-start" : "top-end", i = r ? "bottom-end" : "bottom-start", c = r ? "bottom-start" : "bottom-end", a = r ? "right-start" : "left-start", l = r ? "right-end" : "left-end", v = r ? "left-start" : "right-start", h = r ? "left-end" : "right-end";
+  let d = e ? c : i;
+  return t === "up" ? d = e ? s : n : t === "end" ? d = e ? h : v : t === "start" ? d = e ? l : a : t === "down-centered" ? d = "bottom" : t === "up-centered" && (d = "top"), d;
+}, Yn = ({ children: e, value: t, ...r }) => /* @__PURE__ */ f.jsx(Pe.Provider, { value: t, ...r, children: e }), ge = y(({
+  children: e,
+  className: t,
+  onSelect: r,
+  onToggle: n,
+  controlID: s,
+  toggleProps: i,
+  title: c,
+  menuProps: a,
+  drop: l = "down",
+  align: v = "start",
+  autoClose: h = !0,
+  show: d = "default",
+  ...p
+}, E) => {
+  const [C, _] = B(d === "default" ? !1 : d), [g, j] = B({ case: "" }), w = zt((W) => {
+    W.stopPropagation(), _((Y) => !Y);
+  }, []), $ = Ln(v === "end", l), M = {
+    down: "dropdown",
+    "down-centered": "dropdown-center",
+    up: "dropup",
+    "up-centered": "dropup-center dropup",
+    end: "dropend",
+    start: "dropstart"
+  }, G = s || "nav-dropdown-" + Qt(), z = oe(() => ({
+    align: v,
+    drop: l,
+    showInternal: d != "default" && n ? d : C,
+    handleToggle: d != "default" && n ? n : w,
+    placement: $,
+    directionClasses: M,
+    controlID: G,
+    activeDescendant: g,
+    setActiveDescendant: j
+  }), [v, l, d, C, n, w, $, M, s, g, j]);
+  return /* @__PURE__ */ f.jsx("div", { test: "true", id: s + "-wrapper", ref: E, className: `sg-dropdown${t ? " " + t : ""} sg-nav-item`, ...p, children: /* @__PURE__ */ f.jsxs(Yn, { value: z, children: [
+    /* @__PURE__ */ f.jsx(q.Toggle, { navDropdown: !0, ...i, children: c }),
+    /* @__PURE__ */ f.jsx(ge.Menu, { ...a, children: e })
+  ] }) });
+});
+ge.Toggle = q.Toggle;
+ge.Menu = q.Menu;
+ge.Item = q.Item;
+ge.Divider = q.Divider;
+const Vn = (e, t, r, n) => {
+  const s = n ? n.element : document.body;
+  L(() => {
+    if (s)
+      return s.addEventListener(e, t, r), function() {
+        s.removeEventListener(e, t, r);
+      };
+  }, [t, s]);
+}, ye = y(({ children: e, initialPosition: t, id: r, resize: n = !1, move: s = !1, ...i }, c) => {
+  const [a, l] = B({ offSetTop: 0, offSetLeft: 0, ...t });
+  console.log(a);
+  const v = n ? "true" : "false", h = s ? "true" : "false", d = qe(c || null), [p, E] = B(!1), C = qe(p);
+  L(() => {
+    C.current = p;
+  }, [p]);
+  const _ = (w) => {
+    if (s && w.target.className.includes("sg-popout-title") || w.target.className.includes("sg-popout-header")) {
+      const { top: A, left: $ } = d.current.getBoundingClientRect();
+      l((M) => ({
+        ...M,
+        offSetTop: w.clientY - A,
+        offSetLeft: w.clientX - $
+      })), d.current.style.setProperty("user-select", "none"), d.current.setPointerCapture("moveable-popup-" + r), E((M) => !0);
+    }
+  }, g = (w) => {
+    s && (d.current.style.removeProperty("user-select"), E((A) => !1));
+  }, j = (w) => {
+    if (s && C.current) {
+      const A = w.clientY - a.offSetTop < 0, $ = window.innerHeight - (w.clientY - a.offSetTop + d.current.offsetHeight) < 0, M = w.clientX - a.offSetLeft < 0, G = window.innerWidth - (w.clientX - a.offSetLeft + d.current.offsetWidth) < 0;
+      let z = A ? 0 : w.clientY - a.offSetTop;
+      z = $ ? window.innerHeight - d.current.offsetHeight : z;
+      let W = M ? 0 : w.clientX - a.offSetLeft;
+      W = G ? window.innerWidth - d.current.offsetWidth : W, l((Y) => ({
+        ...Y,
+        top: z,
+        left: W
+      }));
+    }
+  };
+  return Vn("pointerup", g, !0, { element: document.body }), Bt(
+    /* @__PURE__ */ f.jsx(
+      "dialog",
+      {
+        "data-resize": v,
+        "data-move": h,
+        ref: d,
+        id: r,
+        className: "moveable-popout",
+        style: { top: a.top, left: a.left, bottom: a.bottom, right: a.right },
+        onMouseDown: _,
+        onMouseMove: j,
+        children: e
+      }
+    ),
+    document.body
+  );
+}), Un = ({ as: e, className: t, children: r, ...n }, s) => {
+  let c = ["div", "span", "h1", "h2", "h3", "h4", "h5", "h6"].find((a) => a === e) ? e : "div";
+  return /* @__PURE__ */ f.jsx(c, { ref: s, className: `sg-popout-header ${t}`, ...n, children: r });
+};
+ye.Header = y(Un);
+const Hn = ({ children: e, className: t, ...r }, n) => {
+  e = e.length ? e.filter((i) => i != null && i != "") : e;
+  let s = [];
+  return me.Children.forEach(e, (i) => {
+    s.push(i);
+  }), /* @__PURE__ */ f.jsx("div", { ref: n, className: `sg-popout-body ${t}`, ...r, children: s.map((i) => i) });
+};
+ye.Body = y(Hn);
+const qn = ({ as: e, className: t, children: r, ...n }, s) => {
+  let c = ["h1", "h2", "h3", "h4", "h5", "h6"].find((a) => a === e) ? e : "h5";
+  return /* @__PURE__ */ f.jsx(c, { ref: s, className: `sg-popout-title ${t}`, ...n, children: r });
+};
+ye.Title = y(qn);
+const Kn = ({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("p", { ref: n, className: `sg-popout-text ${t}`, ...r, children: e });
+ye.Text = y(Kn);
+const Gn = ({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("div", { ref: n, className: `sg-popout-footer ${t}`, ...r, children: e });
+ye.Footer = y(Gn);
+const Xn = (e, t) => {
+  const r = document.getElementById(t + "-controls").children;
+  for (let n of Object.keys(r))
+    if (r[n] === e.target)
+      return n;
+}, Fe = he(null), Jn = ({ children: e, value: t }) => /* @__PURE__ */ f.jsx(Fe.Provider, { value: t, children: e }), Ie = y(({ children: e, className: t, controlID: r, activeClassName: n, defaultActive: s = 0, ...i }, c) => {
+  const [a, l] = B(s), [v, h] = B(null);
+  L(() => {
+    let p = n;
+    p || (p = "sg-active");
+    const E = document.getElementsByClassName(p)[0], C = document.getElementsByClassName(p)[1];
+    E && E.classList.remove(p), C && C.classList.remove(p);
+    const _ = document.getElementById(r + "-controls").children, g = document.getElementById(r + "-content").children;
+    _[a].classList.add(p), g[a].classList.add(p);
+  }, [a, r, n, h]);
+  const d = oe(() => ({
+    activeTab: a,
+    setActiveTab: l,
+    controlID: r,
+    pageCount: v,
+    setPageCount: h
+  }), [a, l, r, v, h]);
+  return /* @__PURE__ */ f.jsx(Jn, { value: d, children: /* @__PURE__ */ f.jsx("div", { ref: c, id: r + "-tabs", className: `sg-tabs${t ? " " + t : ""}`, ...i, children: e }) });
+}), Zn = ({ children: e, className: t, ...r }, n) => {
+  const { controlID: s, setPageCount: i } = H(Fe);
+  return L(() => {
+    i(e.length);
+  }, [e, i]), /* @__PURE__ */ f.jsx("div", { ref: n, id: s + "-controls", className: `sg-tabs-controls${t ? " " + t : ""}`, ...r, children: e });
+};
+Ie.Controls = y(Zn);
+const Qn = ({ children: e, className: t, onClick: r, ...n }, s) => {
+  const { controlID: i, setActiveTab: c } = H(Fe), a = (l) => {
+    c(Xn(l, i)), r && r(l);
+  };
+  return /* @__PURE__ */ f.jsx("button", { ref: s, onClick: a, className: `sg-tabs-button${t ? " " + t : ""}`, ...n, children: e });
+};
+Ie.Button = y(Qn);
+const eo = ({ children: e, className: t, ...r }, n) => {
+  const { controlID: s } = H(Fe);
+  return /* @__PURE__ */ f.jsx("div", { ref: n, id: s + "-content", className: `sg-tabs-content${t ? " " + t : ""}`, ...r, children: e });
+};
+Ie.Content = y(eo);
+const to = ({ children: e, className: t, ...r }, n) => /* @__PURE__ */ f.jsx("div", { ref: n, className: `sg-tabs-page${t ? " " + t : ""}`, ...r, children: e });
+Ie.Page = y(to);
+const so = y(({ children: e, toggled: t = "false", onClick: r, ...n }, s) => {
+  const [i, c] = B(t), a = (l) => {
+    c((v) => v === "true" ? "false" : "true"), r && r(l);
+  };
+  return /* @__PURE__ */ f.jsx("button", { onClick: a, toggled: i, ...n, children: e });
+});
+export {
+  Or as Button,
+  se as Card,
+  Ir as CloseButton,
+  q as Dropdown,
+  oo as FloatingLabel,
+  ie as Form,
+  Gr as InputGroup,
+  K as Modal,
+  Vt as Nav,
+  ge as NavDropdown,
+  Yt as Navbar,
+  ye as Popout,
+  Ie as Tabs,
+  so as ToggleButton
+};