enerdot-front-system 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/index-pJQGIusq.js

@@ -0,0 +1,864 @@
+import * as vr from "react";
+function _r(_) {
+  if (_.__esModule) return _;
+  var p = _.default;
+  if (typeof p == "function") {
+    var y = function l() {
+      return this instanceof l ? Reflect.construct(p, arguments, this.constructor) : p.apply(this, arguments);
+    };
+    y.prototype = p.prototype;
+  } else y = {};
+  return Object.defineProperty(y, "__esModule", { value: !0 }), Object.keys(_).forEach(function(l) {
+    var k = Object.getOwnPropertyDescriptor(_, l);
+    Object.defineProperty(y, l, k.get ? k : {
+      enumerable: !0,
+      get: function() {
+        return _[l];
+      }
+    });
+  }), y;
+}
+var N = { exports: {} }, B = {};
+const De = /* @__PURE__ */ _r(vr);
+/**
+ * @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 we;
+function pr() {
+  if (we) return B;
+  we = 1;
+  var _ = De, p = Symbol.for("react.element"), y = Symbol.for("react.fragment"), l = Object.prototype.hasOwnProperty, k = _.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, D = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function h(m, d, R) {
+    var c, v = {}, w = null, I = null;
+    R !== void 0 && (w = "" + R), d.key !== void 0 && (w = "" + d.key), d.ref !== void 0 && (I = d.ref);
+    for (c in d) l.call(d, c) && !D.hasOwnProperty(c) && (v[c] = d[c]);
+    if (m && m.defaultProps) for (c in d = m.defaultProps, d) v[c] === void 0 && (v[c] = d[c]);
+    return { $$typeof: p, type: m, key: w, ref: I, props: v, _owner: k.current };
+  }
+  return B.Fragment = y, B.jsx = h, B.jsxs = h, B;
+}
+var $ = {};
+/**
+ * @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 xe;
+function gr() {
+  return xe || (xe = 1, process.env.NODE_ENV !== "production" && function() {
+    var _ = De, p = Symbol.for("react.element"), y = Symbol.for("react.portal"), l = Symbol.for("react.fragment"), k = Symbol.for("react.strict_mode"), D = Symbol.for("react.profiler"), h = Symbol.for("react.provider"), m = Symbol.for("react.context"), d = Symbol.for("react.forward_ref"), R = Symbol.for("react.suspense"), c = Symbol.for("react.suspense_list"), v = Symbol.for("react.memo"), w = Symbol.for("react.lazy"), I = Symbol.for("react.offscreen"), ee = Symbol.iterator, Oe = "@@iterator";
+    function Te(e) {
+      if (e === null || typeof e != "object")
+        return null;
+      var r = ee && e[ee] || e[Oe];
+      return typeof r == "function" ? r : null;
+    }
+    var O = _.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function g(e) {
+      {
+        for (var r = arguments.length, a = new Array(r > 1 ? r - 1 : 0), t = 1; t < r; t++)
+          a[t - 1] = arguments[t];
+        Pe("error", e, a);
+      }
+    }
+    function Pe(e, r, a) {
+      {
+        var t = O.ReactDebugCurrentFrame, i = t.getStackAddendum();
+        i !== "" && (r += "%s", a = a.concat([i]));
+        var u = a.map(function(o) {
+          return String(o);
+        });
+        u.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, u);
+      }
+    }
+    var Se = !1, je = !1, Be = !1, $e = !1, Ie = !1, re;
+    re = Symbol.for("react.module.reference");
+    function We(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === l || e === D || Ie || e === k || e === R || e === c || $e || e === I || Se || je || Be || typeof e == "object" && e !== null && (e.$$typeof === w || e.$$typeof === v || e.$$typeof === h || e.$$typeof === m || e.$$typeof === d || // 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.
+      e.$$typeof === re || e.getModuleId !== void 0));
+    }
+    function Ye(e, r, a) {
+      var t = e.displayName;
+      if (t)
+        return t;
+      var i = r.displayName || r.name || "";
+      return i !== "" ? a + "(" + i + ")" : a;
+    }
+    function ae(e) {
+      return e.displayName || "Context";
+    }
+    function C(e) {
+      if (e == null)
+        return null;
+      if (typeof e.tag == "number" && g("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+        return e.displayName || e.name || null;
+      if (typeof e == "string")
+        return e;
+      switch (e) {
+        case l:
+          return "Fragment";
+        case y:
+          return "Portal";
+        case D:
+          return "Profiler";
+        case k:
+          return "StrictMode";
+        case R:
+          return "Suspense";
+        case c:
+          return "SuspenseList";
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case m:
+            var r = e;
+            return ae(r) + ".Consumer";
+          case h:
+            var a = e;
+            return ae(a._context) + ".Provider";
+          case d:
+            return Ye(e, e.render, "ForwardRef");
+          case v:
+            var t = e.displayName || null;
+            return t !== null ? t : C(e.type) || "Memo";
+          case w: {
+            var i = e, u = i._payload, o = i._init;
+            try {
+              return C(o(u));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var x = Object.assign, S = 0, te, ne, oe, ie, ue, le, se;
+    function ce() {
+    }
+    ce.__reactDisabledLog = !0;
+    function Le() {
+      {
+        if (S === 0) {
+          te = console.log, ne = console.info, oe = console.warn, ie = console.error, ue = console.group, le = console.groupCollapsed, se = console.groupEnd;
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            value: ce,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: e,
+            log: e,
+            warn: e,
+            error: e,
+            group: e,
+            groupCollapsed: e,
+            groupEnd: e
+          });
+        }
+        S++;
+      }
+    }
+    function Me() {
+      {
+        if (S--, S === 0) {
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: x({}, e, {
+              value: te
+            }),
+            info: x({}, e, {
+              value: ne
+            }),
+            warn: x({}, e, {
+              value: oe
+            }),
+            error: x({}, e, {
+              value: ie
+            }),
+            group: x({}, e, {
+              value: ue
+            }),
+            groupCollapsed: x({}, e, {
+              value: le
+            }),
+            groupEnd: x({}, e, {
+              value: se
+            })
+          });
+        }
+        S < 0 && g("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var U = O.ReactCurrentDispatcher, J;
+    function W(e, r, a) {
+      {
+        if (J === void 0)
+          try {
+            throw Error();
+          } catch (i) {
+            var t = i.stack.trim().match(/\n( *(at )?)/);
+            J = t && t[1] || "";
+          }
+        return `
+` + J + e;
+      }
+    }
+    var q = !1, Y;
+    {
+      var Ne = typeof WeakMap == "function" ? WeakMap : Map;
+      Y = new Ne();
+    }
+    function fe(e, r) {
+      if (!e || q)
+        return "";
+      {
+        var a = Y.get(e);
+        if (a !== void 0)
+          return a;
+      }
+      var t;
+      q = !0;
+      var i = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var u;
+      u = U.current, U.current = null, Le();
+      try {
+        if (r) {
+          var o = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(o.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(o, []);
+            } catch (E) {
+              t = E;
+            }
+            Reflect.construct(e, [], o);
+          } else {
+            try {
+              o.call();
+            } catch (E) {
+              t = E;
+            }
+            e.call(o.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (E) {
+            t = E;
+          }
+          e();
+        }
+      } catch (E) {
+        if (E && t && typeof E.stack == "string") {
+          for (var n = E.stack.split(`
+`), F = t.stack.split(`
+`), s = n.length - 1, f = F.length - 1; s >= 1 && f >= 0 && n[s] !== F[f]; )
+            f--;
+          for (; s >= 1 && f >= 0; s--, f--)
+            if (n[s] !== F[f]) {
+              if (s !== 1 || f !== 1)
+                do
+                  if (s--, f--, f < 0 || n[s] !== F[f]) {
+                    var b = `
+` + n[s].replace(" at new ", " at ");
+                    return e.displayName && b.includes("<anonymous>") && (b = b.replace("<anonymous>", e.displayName)), typeof e == "function" && Y.set(e, b), b;
+                  }
+                while (s >= 1 && f >= 0);
+              break;
+            }
+        }
+      } finally {
+        q = !1, U.current = u, Me(), Error.prepareStackTrace = i;
+      }
+      var P = e ? e.displayName || e.name : "", A = P ? W(P) : "";
+      return typeof e == "function" && Y.set(e, A), A;
+    }
+    function Ve(e, r, a) {
+      return fe(e, !1);
+    }
+    function Ue(e) {
+      var r = e.prototype;
+      return !!(r && r.isReactComponent);
+    }
+    function L(e, r, a) {
+      if (e == null)
+        return "";
+      if (typeof e == "function")
+        return fe(e, Ue(e));
+      if (typeof e == "string")
+        return W(e);
+      switch (e) {
+        case R:
+          return W("Suspense");
+        case c:
+          return W("SuspenseList");
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case d:
+            return Ve(e.render);
+          case v:
+            return L(e.type, r, a);
+          case w: {
+            var t = e, i = t._payload, u = t._init;
+            try {
+              return L(u(i), r, a);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var j = Object.prototype.hasOwnProperty, de = {}, ve = O.ReactDebugCurrentFrame;
+    function M(e) {
+      if (e) {
+        var r = e._owner, a = L(e.type, e._source, r ? r.type : null);
+        ve.setExtraStackFrame(a);
+      } else
+        ve.setExtraStackFrame(null);
+    }
+    function Je(e, r, a, t, i) {
+      {
+        var u = Function.call.bind(j);
+        for (var o in e)
+          if (u(e, o)) {
+            var n = void 0;
+            try {
+              if (typeof e[o] != "function") {
+                var F = Error((t || "React class") + ": " + a + " type `" + o + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[o] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw F.name = "Invariant Violation", F;
+              }
+              n = e[o](r, o, t, a, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (s) {
+              n = s;
+            }
+            n && !(n instanceof Error) && (M(i), g("%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).", t || "React class", a, o, typeof n), M(null)), n instanceof Error && !(n.message in de) && (de[n.message] = !0, M(i), g("Failed %s type: %s", a, n.message), M(null));
+          }
+      }
+    }
+    var qe = Array.isArray;
+    function K(e) {
+      return qe(e);
+    }
+    function Ke(e) {
+      {
+        var r = typeof Symbol == "function" && Symbol.toStringTag, a = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return a;
+      }
+    }
+    function Ge(e) {
+      try {
+        return _e(e), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function _e(e) {
+      return "" + e;
+    }
+    function pe(e) {
+      if (Ge(e))
+        return g("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Ke(e)), _e(e);
+    }
+    var ge = O.ReactCurrentOwner, Xe = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Fe, ye;
+    function ze(e) {
+      if (j.call(e, "ref")) {
+        var r = Object.getOwnPropertyDescriptor(e, "ref").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.ref !== void 0;
+    }
+    function He(e) {
+      if (j.call(e, "key")) {
+        var r = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.key !== void 0;
+    }
+    function Ze(e, r) {
+      typeof e.ref == "string" && ge.current;
+    }
+    function Qe(e, r) {
+      {
+        var a = function() {
+          Fe || (Fe = !0, g("%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)", r));
+        };
+        a.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: a,
+          configurable: !0
+        });
+      }
+    }
+    function er(e, r) {
+      {
+        var a = function() {
+          ye || (ye = !0, g("%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)", r));
+        };
+        a.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: a,
+          configurable: !0
+        });
+      }
+    }
+    var rr = function(e, r, a, t, i, u, o) {
+      var n = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: p,
+        // Built-in properties that belong on the element
+        type: e,
+        key: r,
+        ref: a,
+        props: o,
+        // Record the component responsible for creating this element.
+        _owner: u
+      };
+      return n._store = {}, Object.defineProperty(n._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(n, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: t
+      }), Object.defineProperty(n, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: i
+      }), Object.freeze && (Object.freeze(n.props), Object.freeze(n)), n;
+    };
+    function ar(e, r, a, t, i) {
+      {
+        var u, o = {}, n = null, F = null;
+        a !== void 0 && (pe(a), n = "" + a), He(r) && (pe(r.key), n = "" + r.key), ze(r) && (F = r.ref, Ze(r, i));
+        for (u in r)
+          j.call(r, u) && !Xe.hasOwnProperty(u) && (o[u] = r[u]);
+        if (e && e.defaultProps) {
+          var s = e.defaultProps;
+          for (u in s)
+            o[u] === void 0 && (o[u] = s[u]);
+        }
+        if (n || F) {
+          var f = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          n && Qe(o, f), F && er(o, f);
+        }
+        return rr(e, n, F, i, t, ge.current, o);
+      }
+    }
+    var G = O.ReactCurrentOwner, Ee = O.ReactDebugCurrentFrame;
+    function T(e) {
+      if (e) {
+        var r = e._owner, a = L(e.type, e._source, r ? r.type : null);
+        Ee.setExtraStackFrame(a);
+      } else
+        Ee.setExtraStackFrame(null);
+    }
+    var X;
+    X = !1;
+    function z(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === p;
+    }
+    function be() {
+      {
+        if (G.current) {
+          var e = C(G.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+    }
+    function tr(e) {
+      return "";
+    }
+    var he = {};
+    function nr(e) {
+      {
+        var r = be();
+        if (!r) {
+          var a = typeof e == "string" ? e : e.displayName || e.name;
+          a && (r = `
+
+Check the top-level render call using <` + a + ">.");
+        }
+        return r;
+      }
+    }
+    function me(e, r) {
+      {
+        if (!e._store || e._store.validated || e.key != null)
+          return;
+        e._store.validated = !0;
+        var a = nr(r);
+        if (he[a])
+          return;
+        he[a] = !0;
+        var t = "";
+        e && e._owner && e._owner !== G.current && (t = " It was passed a child from " + C(e._owner.type) + "."), T(e), g('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', a, t), T(null);
+      }
+    }
+    function ke(e, r) {
+      {
+        if (typeof e != "object")
+          return;
+        if (K(e))
+          for (var a = 0; a < e.length; a++) {
+            var t = e[a];
+            z(t) && me(t, r);
+          }
+        else if (z(e))
+          e._store && (e._store.validated = !0);
+        else if (e) {
+          var i = Te(e);
+          if (typeof i == "function" && i !== e.entries)
+            for (var u = i.call(e), o; !(o = u.next()).done; )
+              z(o.value) && me(o.value, r);
+        }
+      }
+    }
+    function or(e) {
+      {
+        var r = e.type;
+        if (r == null || typeof r == "string")
+          return;
+        var a;
+        if (typeof r == "function")
+          a = r.propTypes;
+        else if (typeof r == "object" && (r.$$typeof === d || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        r.$$typeof === v))
+          a = r.propTypes;
+        else
+          return;
+        if (a) {
+          var t = C(r);
+          Je(a, e.props, "prop", t, e);
+        } else if (r.PropTypes !== void 0 && !X) {
+          X = !0;
+          var i = C(r);
+          g("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", i || "Unknown");
+        }
+        typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && g("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function ir(e) {
+      {
+        for (var r = Object.keys(e.props), a = 0; a < r.length; a++) {
+          var t = r[a];
+          if (t !== "children" && t !== "key") {
+            T(e), g("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", t), T(null);
+            break;
+          }
+        }
+        e.ref !== null && (T(e), g("Invalid attribute `ref` supplied to `React.Fragment`."), T(null));
+      }
+    }
+    var Re = {};
+    function Ce(e, r, a, t, i, u) {
+      {
+        var o = We(e);
+        if (!o) {
+          var n = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (n += " 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 F = tr();
+          F ? n += F : n += be();
+          var s;
+          e === null ? s = "null" : K(e) ? s = "array" : e !== void 0 && e.$$typeof === p ? (s = "<" + (C(e.type) || "Unknown") + " />", n = " Did you accidentally export a JSX literal instead of a component?") : s = typeof e, g("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", s, n);
+        }
+        var f = ar(e, r, a, i, u);
+        if (f == null)
+          return f;
+        if (o) {
+          var b = r.children;
+          if (b !== void 0)
+            if (t)
+              if (K(b)) {
+                for (var P = 0; P < b.length; P++)
+                  ke(b[P], e);
+                Object.freeze && Object.freeze(b);
+              } else
+                g("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
+              ke(b, e);
+        }
+        if (j.call(r, "key")) {
+          var A = C(e), E = Object.keys(r).filter(function(dr) {
+            return dr !== "key";
+          }), H = E.length > 0 ? "{key: someKey, " + E.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Re[A + H]) {
+            var fr = E.length > 0 ? "{" + E.join(": ..., ") + ": ...}" : "{}";
+            g(`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} />`, H, A, fr, A), Re[A + H] = !0;
+          }
+        }
+        return e === l ? ir(f) : or(f), f;
+      }
+    }
+    function ur(e, r, a) {
+      return Ce(e, r, a, !0);
+    }
+    function lr(e, r, a) {
+      return Ce(e, r, a, !1);
+    }
+    var sr = lr, cr = ur;
+    $.Fragment = l, $.jsx = sr, $.jsxs = cr;
+  }()), $;
+}
+var Ae;
+function Fr() {
+  return Ae || (Ae = 1, process.env.NODE_ENV === "production" ? N.exports = pr() : N.exports = gr()), N.exports;
+}
+var Q = Fr();
+const yr = {
+  white: "#FFFFFF",
+  black: "#222222",
+  dark_black: "#030A18",
+  gray50: "#FBFBFB",
+  gray100: "#F7F8F9",
+  gray200: "#EBEDF2",
+  gray300: "#DADEE5",
+  gray400: "#C6CBD3",
+  gray500: "#BABFC9",
+  gray600: "#A3A8B4",
+  gray700: "#8A8F9D",
+  gray800: "#6D717D",
+  gray900: "#4A515D",
+  blue100: "#F1F5FE",
+  blue150: "#E4EBFF",
+  blue200: "#CEDBFF",
+  blue300: "#A7BFFF",
+  blue400: "#7EA1FF",
+  blue500: "#5884FF",
+  blue600: "#3369FF",
+  blue700: "#2B59D9",
+  blue800: "#244BB5",
+  blue900: "#1D3C91",
+  cyan50: "#E2FBFF",
+  cyan100: "#A3F1FF",
+  cyan200: "#7BEBFF",
+  cyan300: "#40E3FF",
+  cyan400: "#00ABC9",
+  cyan500: "#217C8C",
+  red50: "#FFF1EF",
+  red100: "#FFACAD",
+  red200: "#FF8182",
+  red300: "#FA4549",
+  red400: "#CF222E",
+  red500: "#82071E",
+  orange50: "#FFF1E5",
+  orange100: "#FFD0AA",
+  orange200: "#FFB37D",
+  orange300: "#FF8E40",
+  orange400: "#E16F24",
+  orange500: "#953800",
+  green50: "#EFFDEE",
+  green100: "#8AE3A1",
+  green200: "#4DD470",
+  green300: "#1CB854",
+  green400: "#149E53",
+  green500: "#086A49",
+  yellow50: "#FEF9E6",
+  yellow100: "#FADD78",
+  yellow200: "#F7CC33",
+  yellow300: "#F7B200",
+  yellow400: "#CB9D26",
+  yellow500: "#956B00",
+  violet50: "#F1E2FF",
+  violet100: "#D1A0FF",
+  violet200: "#AC5EFF",
+  violet300: "#A748FF",
+  violet400: "#831FDF",
+  violet500: "#58208C",
+  dark_gray50: "#F7F8FA",
+  dark_gray100: "#E4E8EF",
+  dark_gray200: "#C7D0DE",
+  dark_gray250: "#A0B0C5",
+  dark_gray300: "#7E8EA2",
+  dark_gray400: "#5C6B80",
+  dark_gray500: "#4F5E72",
+  dark_gray600: "#334050",
+  dark_gray700: "#2F3A4F",
+  dark_gray750: "#212B3E",
+  dark_gray800: "#1C2736",
+  dark_gray850: "#141F2D",
+  dark_gray900: "#0B111D",
+  dark_blue100: "#EEF8FF",
+  dark_blue150: "#222222",
+  dark_blue200: "#C2E8FF",
+  dark_blue300: "#8ED3FF",
+  dark_blue400: "#61C2FF",
+  dark_blue500: "#2DAEFF",
+  dark_blue600: "#1B8CE3",
+  dark_blue700: "#2356A3",
+  dark_blue800: "#193C70",
+  dark_blue900: "#132B51",
+  dark_cyan50: "#E2FBFF",
+  dark_cyan100: "#A3F1FF",
+  dark_cyan200: "#7BEBFF",
+  dark_cyan300: "#40E3FF",
+  dark_cyan400: "#1FC0DC",
+  dark_cyan500: "#217C8C",
+  dark_red50: "#FFE5EB",
+  dark_red100: "#FFA3B9",
+  dark_red200: "#FF7B9A",
+  dark_red300: "#FF4577",
+  dark_red400: "#D51F4A",
+  dark_red500: "#831F36",
+  dark_green50: "#C4F5CF",
+  dark_green100: "#8AEC99",
+  dark_green200: "#65E679",
+  dark_green300: "#34D64B",
+  dark_green400: "#35873D",
+  dark_green500: "#114410",
+  dark_yellow50: "#FFF9B8",
+  dark_yellow100: "#FFE975",
+  dark_yellow200: "#FFE34A",
+  dark_yellow300: "#FFD509",
+  dark_yellow400: "#A58515",
+  dark_yellow500: "#503602",
+  dark_orange50: "#FFEABB",
+  dark_orange100: "#FFCC78",
+  dark_orange200: "#FFBC4D",
+  dark_orange300: "#FDA00E",
+  dark_orange400: "#A66817",
+  dark_orange500: "#522603",
+  dark_violet50: "#F1E2FF",
+  dark_violet100: "#D1A0FF",
+  dark_violet200: "#BF7AFF",
+  dark_violet300: "#B164FF",
+  dark_violet400: "#831FDF",
+  dark_violet500: "#58208C"
+}, Er = "_chip_a5ovv_1", br = "_small_a5ovv_11", hr = "_regular_a5ovv_23", mr = "_large_a5ovv_35", kr = "_x-large_a5ovv_47", Rr = "_full_a5ovv_59", Cr = "_dot_a5ovv_67", V = {
+  chip: Er,
+  small: br,
+  regular: hr,
+  large: mr,
+  "x-large": "_x-large_a5ovv_47",
+  xLarge: kr,
+  full: Rr,
+  dot: Cr
+}, Dr = ({
+  children: _,
+  level: p = "regular",
+  borderRadius: y = "round",
+  colorTheme: l = "primary",
+  isWhiteBg: k = !1,
+  //deprecated
+  gap: D = 4,
+  isDot: h
+}) => {
+  const m = l === "primary" ? "blue" : l, d = l === "gray" ? "var(--color-palette-background-gray)" : `color-mix(in srgb, var(--color-palette-${m}) 16%, transparent 84%)`, R = y === "full";
+  let c, v;
+  switch (p) {
+    case "small":
+      c = `2px 8px 2px ${h ? 6 : 8}px`, v = "135%";
+      break;
+    case "regular":
+      c = `2px 8px 2px ${h ? 6 : 8}px`, v = "140%";
+      break;
+    case "large":
+      c = `2px 10px 2px ${h ? 8 : 10}px`, v = "150%";
+      break;
+    case "x-large":
+      c = `2px 16px 2px ${h ? 12 : 16}px`, v = "150%";
+      break;
+    default: {
+      c = "4px 8px", v = "135%";
+      break;
+    }
+  }
+  return /* @__PURE__ */ Q.jsxs(
+    "div",
+    {
+      className: `${V.chip} ${V[p]} 
+      ${R && V.full}
+`,
+      style: {
+        backgroundColor: k ? yr.white : d,
+        color: `var(--color-palette-${m})`,
+        gap: `${D}px`,
+        padding: c,
+        lineHeight: v
+      },
+      children: [
+        h && /* @__PURE__ */ Q.jsx(
+          "div",
+          {
+            className: V.dot,
+            style: {
+              backgroundColor: `var(--color-palette-${m})`
+            }
+          }
+        ),
+        _
+      ]
+    }
+  );
+}, wr = "_divider_6kbwo_1", xr = "_row_6kbwo_5", Ar = "_column_6kbwo_9", Z = {
+  divider: wr,
+  row: xr,
+  column: Ar
+}, Or = ({
+  size: _ = 1,
+  direction: p = "row",
+  color: y
+}) => {
+  const l = p === "row";
+  return /* @__PURE__ */ Q.jsx(
+    "div",
+    {
+      className: `${Z.divider} ${l ? Z.row : Z.column}`,
+      style: {
+        borderBottom: l && `${_}px solid ${y || "var(--color-line-normal-muted)"}`,
+        borderRight: !l && `${_}px solid ${y || "var(--color-line-normal-muted)"}`,
+        width: l && "100%",
+        height: !l && "100%"
+      }
+    }
+  );
+};
+export {
+  Dr as C,
+  Or as D,
+  Q as j,
+  yr as t
+};