xmirror-components 1.0.8 → 1.0.9

package/build/dist/index.mjs

@@ -0,0 +1,1382 @@
+import { message as Nr, notification as kr, Modal as qr, App as Mr, Checkbox as Wr, Switch as $r } from "antd";
+import Fr, { forwardRef as Ir, useRef as _, useMemo as pr, useEffect as X, useState as Lr, useCallback as Yr } from "react";
+let Er = Nr, Gr = kr, Ur = qr;
+function Wt({ children: r }) {
+  const e = Mr.useApp();
+  return Er = e.message, Ur = e.modal, Gr = e.notification, r;
+}
+var fe = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function Tr(r) {
+  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
+}
+var se = { exports: {} }, re = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var er;
+function Br() {
+  if (er) return re;
+  er = 1;
+  var r = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function n(a, i, o) {
+    var c = null;
+    if (o !== void 0 && (c = "" + o), i.key !== void 0 && (c = "" + i.key), "key" in i) {
+      o = {};
+      for (var f in i)
+        f !== "key" && (o[f] = i[f]);
+    } else o = i;
+    return i = o.ref, {
+      $$typeof: r,
+      type: a,
+      key: c,
+      ref: i !== void 0 ? i : null,
+      props: o
+    };
+  }
+  return re.Fragment = e, re.jsx = n, re.jsxs = n, re;
+}
+var te = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var rr;
+function Hr() {
+  return rr || (rr = 1, process.env.NODE_ENV !== "production" && function() {
+    function r(t) {
+      if (t == null) return null;
+      if (typeof t == "function")
+        return t.$$typeof === Pr ? null : t.displayName || t.name || null;
+      if (typeof t == "string") return t;
+      switch (t) {
+        case L:
+          return "Fragment";
+        case G:
+          return "Portal";
+        case P:
+          return "Profiler";
+        case W:
+          return "StrictMode";
+        case U:
+          return "Suspense";
+        case T:
+          return "SuspenseList";
+      }
+      if (typeof t == "object")
+        switch (typeof t.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), t.$$typeof) {
+          case oe:
+            return (t.displayName || "Context") + ".Provider";
+          case Z:
+            return (t._context.displayName || "Context") + ".Consumer";
+          case Q:
+            var l = t.render;
+            return t = t.displayName, t || (t = l.displayName || l.name || "", t = t !== "" ? "ForwardRef(" + t + ")" : "ForwardRef"), t;
+          case C:
+            return l = t.displayName || null, l !== null ? l : r(t.type) || "Memo";
+          case $:
+            l = t._payload, t = t._init;
+            try {
+              return r(t(l));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function e(t) {
+      return "" + t;
+    }
+    function n(t) {
+      try {
+        e(t);
+        var l = !1;
+      } catch {
+        l = !0;
+      }
+      if (l) {
+        l = console;
+        var d = l.error, y = typeof Symbol == "function" && Symbol.toStringTag && t[Symbol.toStringTag] || t.constructor.name || "Object";
+        return d.call(
+          l,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          y
+        ), e(t);
+      }
+    }
+    function a() {
+    }
+    function i() {
+      if (K === 0) {
+        Ge = console.log, Ue = console.info, Be = console.warn, He = console.error, ze = console.group, De = console.groupCollapsed, Ve = console.groupEnd;
+        var t = {
+          configurable: !0,
+          enumerable: !0,
+          value: a,
+          writable: !0
+        };
+        Object.defineProperties(console, {
+          info: t,
+          log: t,
+          warn: t,
+          error: t,
+          group: t,
+          groupCollapsed: t,
+          groupEnd: t
+        });
+      }
+      K++;
+    }
+    function o() {
+      if (K--, K === 0) {
+        var t = { configurable: !0, enumerable: !0, writable: !0 };
+        Object.defineProperties(console, {
+          log: H({}, t, { value: Ge }),
+          info: H({}, t, { value: Ue }),
+          warn: H({}, t, { value: Be }),
+          error: H({}, t, { value: He }),
+          group: H({}, t, { value: ze }),
+          groupCollapsed: H({}, t, { value: De }),
+          groupEnd: H({}, t, { value: Ve })
+        });
+      }
+      0 > K && console.error(
+        "disabledDepth fell below zero. This is a bug in React. Please file an issue."
+      );
+    }
+    function c(t) {
+      if (he === void 0)
+        try {
+          throw Error();
+        } catch (d) {
+          var l = d.stack.trim().match(/\n( *(at )?)/);
+          he = l && l[1] || "", Je = -1 < d.stack.indexOf(`
+    at`) ? " (<anonymous>)" : -1 < d.stack.indexOf("@") ? "@unknown:0:0" : "";
+        }
+      return `
+` + he + t + Je;
+    }
+    function f(t, l) {
+      if (!t || ye) return "";
+      var d = pe.get(t);
+      if (d !== void 0) return d;
+      ye = !0, d = Error.prepareStackTrace, Error.prepareStackTrace = void 0;
+      var y = null;
+      y = B.H, B.H = null, i();
+      try {
+        var j = {
+          DetermineComponentFrameRoot: function() {
+            try {
+              if (l) {
+                var Y = function() {
+                  throw Error();
+                };
+                if (Object.defineProperty(Y.prototype, "props", {
+                  set: function() {
+                    throw Error();
+                  }
+                }), typeof Reflect == "object" && Reflect.construct) {
+                  try {
+                    Reflect.construct(Y, []);
+                  } catch (I) {
+                    var ce = I;
+                  }
+                  Reflect.construct(t, [], Y);
+                } else {
+                  try {
+                    Y.call();
+                  } catch (I) {
+                    ce = I;
+                  }
+                  t.call(Y.prototype);
+                }
+              } else {
+                try {
+                  throw Error();
+                } catch (I) {
+                  ce = I;
+                }
+                (Y = t()) && typeof Y.catch == "function" && Y.catch(function() {
+                });
+              }
+            } catch (I) {
+              if (I && ce && typeof I.stack == "string")
+                return [I.stack, ce.stack];
+            }
+            return [null, null];
+          }
+        };
+        j.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
+        var w = Object.getOwnPropertyDescriptor(
+          j.DetermineComponentFrameRoot,
+          "name"
+        );
+        w && w.configurable && Object.defineProperty(
+          j.DetermineComponentFrameRoot,
+          "name",
+          { value: "DetermineComponentFrameRoot" }
+        );
+        var h = j.DetermineComponentFrameRoot(), F = h[0], V = h[1];
+        if (F && V) {
+          var S = F.split(`
+`), z = V.split(`
+`);
+          for (h = w = 0; w < S.length && !S[w].includes(
+            "DetermineComponentFrameRoot"
+          ); )
+            w++;
+          for (; h < z.length && !z[h].includes(
+            "DetermineComponentFrameRoot"
+          ); )
+            h++;
+          if (w === S.length || h === z.length)
+            for (w = S.length - 1, h = z.length - 1; 1 <= w && 0 <= h && S[w] !== z[h]; )
+              h--;
+          for (; 1 <= w && 0 <= h; w--, h--)
+            if (S[w] !== z[h]) {
+              if (w !== 1 || h !== 1)
+                do
+                  if (w--, h--, 0 > h || S[w] !== z[h]) {
+                    var ee = `
+` + S[w].replace(
+                      " at new ",
+                      " at "
+                    );
+                    return t.displayName && ee.includes("<anonymous>") && (ee = ee.replace("<anonymous>", t.displayName)), typeof t == "function" && pe.set(t, ee), ee;
+                  }
+                while (1 <= w && 0 <= h);
+              break;
+            }
+        }
+      } finally {
+        ye = !1, B.H = y, o(), Error.prepareStackTrace = d;
+      }
+      return S = (S = t ? t.displayName || t.name : "") ? c(S) : "", typeof t == "function" && pe.set(t, S), S;
+    }
+    function s(t) {
+      if (t == null) return "";
+      if (typeof t == "function") {
+        var l = t.prototype;
+        return f(
+          t,
+          !(!l || !l.isReactComponent)
+        );
+      }
+      if (typeof t == "string") return c(t);
+      switch (t) {
+        case U:
+          return c("Suspense");
+        case T:
+          return c("SuspenseList");
+      }
+      if (typeof t == "object")
+        switch (t.$$typeof) {
+          case Q:
+            return t = f(t.render, !1), t;
+          case C:
+            return s(t.type);
+          case $:
+            l = t._payload, t = t._init;
+            try {
+              return s(t(l));
+            } catch {
+            }
+        }
+      return "";
+    }
+    function u() {
+      var t = B.A;
+      return t === null ? null : t.getOwner();
+    }
+    function m(t) {
+      if (Ye.call(t, "key")) {
+        var l = Object.getOwnPropertyDescriptor(t, "key").get;
+        if (l && l.isReactWarning) return !1;
+      }
+      return t.key !== void 0;
+    }
+    function v(t, l) {
+      function d() {
+        Xe || (Xe = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          l
+        ));
+      }
+      d.isReactWarning = !0, Object.defineProperty(t, "key", {
+        get: d,
+        configurable: !0
+      });
+    }
+    function p() {
+      var t = r(this.type);
+      return Ze[t] || (Ze[t] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), t = this.props.ref, t !== void 0 ? t : null;
+    }
+    function g(t, l, d, y, j, w) {
+      return d = w.ref, t = {
+        $$typeof: k,
+        type: t,
+        key: l,
+        props: w,
+        _owner: j
+      }, (d !== void 0 ? d : null) !== null ? Object.defineProperty(t, "ref", {
+        enumerable: !1,
+        get: p
+      }) : Object.defineProperty(t, "ref", { enumerable: !1, value: null }), t._store = {}, Object.defineProperty(t._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(t, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.freeze && (Object.freeze(t.props), Object.freeze(t)), t;
+    }
+    function b(t, l, d, y, j, w) {
+      if (typeof t == "string" || typeof t == "function" || t === L || t === P || t === W || t === U || t === T || t === ue || typeof t == "object" && t !== null && (t.$$typeof === $ || t.$$typeof === C || t.$$typeof === oe || t.$$typeof === Z || t.$$typeof === Q || t.$$typeof === Cr || t.getModuleId !== void 0)) {
+        var h = l.children;
+        if (h !== void 0)
+          if (y)
+            if (ge(h)) {
+              for (y = 0; y < h.length; y++)
+                E(h[y], t);
+              Object.freeze && Object.freeze(h);
+            } else
+              console.error(
+                "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+              );
+          else E(h, t);
+      } else
+        h = "", (t === void 0 || typeof t == "object" && t !== null && Object.keys(t).length === 0) && (h += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports."), t === null ? y = "null" : ge(t) ? y = "array" : t !== void 0 && t.$$typeof === k ? (y = "<" + (r(t.type) || "Unknown") + " />", h = " Did you accidentally export a JSX literal instead of a component?") : y = typeof t, console.error(
+          "React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s",
+          y,
+          h
+        );
+      if (Ye.call(l, "key")) {
+        h = r(t);
+        var F = Object.keys(l).filter(function(S) {
+          return S !== "key";
+        });
+        y = 0 < F.length ? "{key: someKey, " + F.join(": ..., ") + ": ...}" : "{key: someKey}", Qe[h + y] || (F = 0 < F.length ? "{" + F.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          y,
+          h,
+          F,
+          h
+        ), Qe[h + y] = !0);
+      }
+      if (h = null, d !== void 0 && (n(d), h = "" + d), m(l) && (n(l.key), h = "" + l.key), "key" in l) {
+        d = {};
+        for (var V in l)
+          V !== "key" && (d[V] = l[V]);
+      } else d = l;
+      return h && v(
+        d,
+        typeof t == "function" ? t.displayName || t.name || "Unknown" : t
+      ), g(t, h, w, j, u(), d);
+    }
+    function E(t, l) {
+      if (typeof t == "object" && t && t.$$typeof !== Ar) {
+        if (ge(t))
+          for (var d = 0; d < t.length; d++) {
+            var y = t[d];
+            x(y) && q(y, l);
+          }
+        else if (x(t))
+          t._store && (t._store.validated = 1);
+        else if (t === null || typeof t != "object" ? d = null : (d = Le && t[Le] || t["@@iterator"], d = typeof d == "function" ? d : null), typeof d == "function" && d !== t.entries && (d = d.call(t), d !== t))
+          for (; !(t = d.next()).done; )
+            x(t.value) && q(t.value, l);
+      }
+    }
+    function x(t) {
+      return typeof t == "object" && t !== null && t.$$typeof === k;
+    }
+    function q(t, l) {
+      if (t._store && !t._store.validated && t.key == null && (t._store.validated = 1, l = N(l), !Ke[l])) {
+        Ke[l] = !0;
+        var d = "";
+        t && t._owner != null && t._owner !== u() && (d = null, typeof t._owner.tag == "number" ? d = r(t._owner.type) : typeof t._owner.name == "string" && (d = t._owner.name), d = " It was passed a child from " + d + ".");
+        var y = B.getCurrentStack;
+        B.getCurrentStack = function() {
+          var j = s(t.type);
+          return y && (j += y() || ""), j;
+        }, console.error(
+          'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
+          l,
+          d
+        ), B.getCurrentStack = y;
+      }
+    }
+    function N(t) {
+      var l = "", d = u();
+      return d && (d = r(d.type)) && (l = `
+
+Check the render method of \`` + d + "`."), l || (t = r(t)) && (l = `
+
+Check the top-level render call using <` + t + ">."), l;
+    }
+    var M = Fr, k = Symbol.for("react.transitional.element"), G = Symbol.for("react.portal"), L = Symbol.for("react.fragment"), W = Symbol.for("react.strict_mode"), P = Symbol.for("react.profiler"), Z = Symbol.for("react.consumer"), oe = Symbol.for("react.context"), Q = Symbol.for("react.forward_ref"), U = Symbol.for("react.suspense"), T = Symbol.for("react.suspense_list"), C = Symbol.for("react.memo"), $ = Symbol.for("react.lazy"), ue = Symbol.for("react.offscreen"), Le = Symbol.iterator, Pr = Symbol.for("react.client.reference"), B = M.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, Ye = Object.prototype.hasOwnProperty, H = Object.assign, Cr = Symbol.for("react.client.reference"), ge = Array.isArray, K = 0, Ge, Ue, Be, He, ze, De, Ve;
+    a.__reactDisabledLog = !0;
+    var he, Je, ye = !1, pe = new (typeof WeakMap == "function" ? WeakMap : Map)(), Ar = Symbol.for("react.client.reference"), Xe, Ze = {}, Qe = {}, Ke = {};
+    te.Fragment = L, te.jsx = function(t, l, d, y, j) {
+      return b(t, l, d, !1, y, j);
+    }, te.jsxs = function(t, l, d, y, j) {
+      return b(t, l, d, !0, y, j);
+    };
+  }()), te;
+}
+var tr;
+function zr() {
+  return tr || (tr = 1, process.env.NODE_ENV === "production" ? se.exports = Br() : se.exports = Hr()), se.exports;
+}
+var ne = zr();
+const $t = Ir(
+  ({ type: r = "", className: e = "", symbol: n = !1, ...a }, i) => n ? /* @__PURE__ */ ne.jsx(
+    "svg",
+    {
+      className: `iconfont-symbol ${r} ${e}`,
+      "aria-hidden": "true",
+      ref: i,
+      ...a,
+      children: /* @__PURE__ */ ne.jsx("use", { xlinkHref: `#${r}` })
+    }
+  ) : /* @__PURE__ */ ne.jsx(
+    "i",
+    {
+      className: `iconfont ${r} ${e}`,
+      ref: i,
+      ...a
+    }
+  )
+), Ft = ({
+  checked: r,
+  onChange: e,
+  trueValue: n = !0,
+  falseValue: a = !1,
+  trueLabel: i = "",
+  falseLabel: o = "",
+  children: c,
+  ...f
+}) => {
+  const s = r === n, u = (m) => {
+    e == null || e(m.target.checked ? n : a, m);
+  };
+  return /* @__PURE__ */ ne.jsx(
+    Wr,
+    {
+      checked: s,
+      onChange: u,
+      ...f,
+      children: c || (s ? i : o)
+    }
+  );
+}, It = ({
+  checked: r,
+  onChange: e,
+  trueValue: n = !0,
+  falseValue: a = !1,
+  ...i
+}) => {
+  const o = r === n, c = (f, s) => {
+    e == null || e(f ? n : a, s);
+  };
+  return /* @__PURE__ */ ne.jsx(
+    $r,
+    {
+      checked: o,
+      onChange: c,
+      ...i
+    }
+  );
+};
+var Dr = function(r) {
+  return function(e, n) {
+    var a = _(!1);
+    r(function() {
+      return function() {
+        a.current = !1;
+      };
+    }, []), r(function() {
+      if (!a.current)
+        a.current = !0;
+      else
+        return e();
+    }, n);
+  };
+}, A = function() {
+  return A = Object.assign || function(e) {
+    for (var n, a = 1, i = arguments.length; a < i; a++) {
+      n = arguments[a];
+      for (var o in n) Object.prototype.hasOwnProperty.call(n, o) && (e[o] = n[o]);
+    }
+    return e;
+  }, A.apply(this, arguments);
+};
+function wr(r, e) {
+  var n = {};
+  for (var a in r) Object.prototype.hasOwnProperty.call(r, a) && e.indexOf(a) < 0 && (n[a] = r[a]);
+  if (r != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var i = 0, a = Object.getOwnPropertySymbols(r); i < a.length; i++)
+      e.indexOf(a[i]) < 0 && Object.prototype.propertyIsEnumerable.call(r, a[i]) && (n[a[i]] = r[a[i]]);
+  return n;
+}
+function Vr(r, e, n, a) {
+  function i(o) {
+    return o instanceof n ? o : new n(function(c) {
+      c(o);
+    });
+  }
+  return new (n || (n = Promise))(function(o, c) {
+    function f(m) {
+      try {
+        u(a.next(m));
+      } catch (v) {
+        c(v);
+      }
+    }
+    function s(m) {
+      try {
+        u(a.throw(m));
+      } catch (v) {
+        c(v);
+      }
+    }
+    function u(m) {
+      m.done ? o(m.value) : i(m.value).then(f, s);
+    }
+    u((a = a.apply(r, e || [])).next());
+  });
+}
+function Jr(r, e) {
+  var n = { label: 0, sent: function() {
+    if (o[0] & 1) throw o[1];
+    return o[1];
+  }, trys: [], ops: [] }, a, i, o, c = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return c.next = f(0), c.throw = f(1), c.return = f(2), typeof Symbol == "function" && (c[Symbol.iterator] = function() {
+    return this;
+  }), c;
+  function f(u) {
+    return function(m) {
+      return s([u, m]);
+    };
+  }
+  function s(u) {
+    if (a) throw new TypeError("Generator is already executing.");
+    for (; c && (c = 0, u[0] && (n = 0)), n; ) try {
+      if (a = 1, i && (o = u[0] & 2 ? i.return : u[0] ? i.throw || ((o = i.return) && o.call(i), 0) : i.next) && !(o = o.call(i, u[1])).done) return o;
+      switch (i = 0, o && (u = [u[0] & 2, o.value]), u[0]) {
+        case 0:
+        case 1:
+          o = u;
+          break;
+        case 4:
+          return n.label++, { value: u[1], done: !1 };
+        case 5:
+          n.label++, i = u[1], u = [0];
+          continue;
+        case 7:
+          u = n.ops.pop(), n.trys.pop();
+          continue;
+        default:
+          if (o = n.trys, !(o = o.length > 0 && o[o.length - 1]) && (u[0] === 6 || u[0] === 2)) {
+            n = 0;
+            continue;
+          }
+          if (u[0] === 3 && (!o || u[1] > o[0] && u[1] < o[3])) {
+            n.label = u[1];
+            break;
+          }
+          if (u[0] === 6 && n.label < o[1]) {
+            n.label = o[1], o = u;
+            break;
+          }
+          if (o && n.label < o[2]) {
+            n.label = o[2], n.ops.push(u);
+            break;
+          }
+          o[2] && n.ops.pop(), n.trys.pop();
+          continue;
+      }
+      u = e.call(r, n);
+    } catch (m) {
+      u = [6, m], i = 0;
+    } finally {
+      a = o = 0;
+    }
+    if (u[0] & 5) throw u[1];
+    return { value: u[0] ? u[1] : void 0, done: !0 };
+  }
+}
+function R(r, e) {
+  var n = typeof Symbol == "function" && r[Symbol.iterator];
+  if (!n) return r;
+  var a = n.call(r), i, o = [], c;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(i = a.next()).done; ) o.push(i.value);
+  } catch (f) {
+    c = { error: f };
+  } finally {
+    try {
+      i && !i.done && (n = a.return) && n.call(a);
+    } finally {
+      if (c) throw c.error;
+    }
+  }
+  return o;
+}
+function O(r, e, n) {
+  if (n || arguments.length === 2) for (var a = 0, i = e.length, o; a < i; a++)
+    (o || !(a in e)) && (o || (o = Array.prototype.slice.call(e, 0, a)), o[a] = e[a]);
+  return r.concat(o || Array.prototype.slice.call(e));
+}
+var ve = function(r) {
+  return typeof r == "function";
+}, me = process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+function J(r) {
+  me && (ve(r) || console.error("useMemoizedFn expected parameter is a function, got ".concat(typeof r)));
+  var e = _(r);
+  e.current = pr(function() {
+    return r;
+  }, [r]);
+  var n = _();
+  return n.current || (n.current = function() {
+    for (var a = [], i = 0; i < arguments.length; i++)
+      a[i] = arguments[i];
+    return e.current.apply(this, a);
+  }), n.current;
+}
+const We = Dr(X);
+var _r = function(r, e) {
+  var n = e.manual, a = e.ready, i = a === void 0 ? !0 : a, o = e.defaultParams, c = o === void 0 ? [] : o, f = e.refreshDeps, s = f === void 0 ? [] : f, u = e.refreshDepsAction, m = _(!1);
+  return m.current = !1, We(function() {
+    !n && i && (m.current = !0, r.run.apply(r, O([], R(c), !1)));
+  }, [i]), We(function() {
+    m.current || n || (m.current = !0, u ? u() : r.refresh());
+  }, O([], R(s), !1)), {
+    onBefore: function() {
+      if (!i)
+        return {
+          stopNow: !0
+        };
+    }
+  };
+};
+_r.onInit = function(r) {
+  var e = r.ready, n = e === void 0 ? !0 : e, a = r.manual;
+  return {
+    loading: !a && n
+  };
+};
+function Xr(r, e) {
+  if (r === e) return !0;
+  for (var n = 0; n < r.length; n++)
+    if (!Object.is(r[n], e[n])) return !1;
+  return !0;
+}
+function jr(r, e) {
+  var n = _({
+    deps: e,
+    obj: void 0,
+    initialized: !1
+  }).current;
+  return (n.initialized === !1 || !Xr(n.deps, e)) && (n.deps = e, n.obj = r(), n.initialized = !0), n.obj;
+}
+function Rr(r) {
+  var e = _(r);
+  return e.current = r, e;
+}
+var $e = function(r) {
+  me && (ve(r) || console.error("useUnmount expected parameter is a function, got ".concat(typeof r)));
+  var e = Rr(r);
+  X(function() {
+    return function() {
+      e.current();
+    };
+  }, []);
+}, le = /* @__PURE__ */ new Map(), Zr = function(r, e, n) {
+  var a = le.get(r);
+  a != null && a.timer && clearTimeout(a.timer);
+  var i = void 0;
+  e > -1 && (i = setTimeout(function() {
+    le.delete(r);
+  }, e)), le.set(r, A(A({}, n), {
+    timer: i
+  }));
+}, Qr = function(r) {
+  return le.get(r);
+}, de = /* @__PURE__ */ new Map(), Kr = function(r) {
+  return de.get(r);
+}, et = function(r, e) {
+  de.set(r, e), e.then(function(n) {
+    return de.delete(r), n;
+  }).catch(function() {
+    de.delete(r);
+  });
+}, D = {}, rt = function(r, e) {
+  D[r] && D[r].forEach(function(n) {
+    return n(e);
+  });
+}, Ee = function(r, e) {
+  return D[r] || (D[r] = []), D[r].push(e), function() {
+    var a = D[r].indexOf(e);
+    D[r].splice(a, 1);
+  };
+}, tt = function(r, e) {
+  var n = e.cacheKey, a = e.cacheTime, i = a === void 0 ? 5 * 60 * 1e3 : a, o = e.staleTime, c = o === void 0 ? 0 : o, f = e.setCache, s = e.getCache, u = _(), m = _(), v = function(g, b) {
+    f ? f(b) : Zr(g, i, b), rt(g, b.data);
+  }, p = function(g, b) {
+    return b === void 0 && (b = []), s ? s(b) : Qr(g);
+  };
+  return jr(function() {
+    if (n) {
+      var g = p(n);
+      g && Object.hasOwnProperty.call(g, "data") && (r.state.data = g.data, r.state.params = g.params, (c === -1 || (/* @__PURE__ */ new Date()).getTime() - g.time <= c) && (r.state.loading = !1)), u.current = Ee(n, function(b) {
+        r.setState({
+          data: b
+        });
+      });
+    }
+  }, []), $e(function() {
+    var g;
+    (g = u.current) === null || g === void 0 || g.call(u);
+  }), n ? {
+    onBefore: function(g) {
+      var b = p(n, g);
+      return !b || !Object.hasOwnProperty.call(b, "data") ? {} : c === -1 || (/* @__PURE__ */ new Date()).getTime() - b.time <= c ? {
+        loading: !1,
+        data: b == null ? void 0 : b.data,
+        error: void 0,
+        returnNow: !0
+      } : {
+        data: b == null ? void 0 : b.data,
+        error: void 0
+      };
+    },
+    onRequest: function(g, b) {
+      var E = Kr(n);
+      return E && E !== m.current ? {
+        servicePromise: E
+      } : (E = g.apply(void 0, O([], R(b), !1)), m.current = E, et(n, E), {
+        servicePromise: E
+      });
+    },
+    onSuccess: function(g, b) {
+      var E;
+      n && ((E = u.current) === null || E === void 0 || E.call(u), v(n, {
+        data: g,
+        params: b,
+        time: (/* @__PURE__ */ new Date()).getTime()
+      }), u.current = Ee(n, function(x) {
+        r.setState({
+          data: x
+        });
+      }));
+    },
+    onMutate: function(g) {
+      var b;
+      n && ((b = u.current) === null || b === void 0 || b.call(u), v(n, {
+        data: g,
+        params: r.state.params,
+        time: (/* @__PURE__ */ new Date()).getTime()
+      }), u.current = Ee(n, function(E) {
+        r.setState({
+          data: E
+        });
+      }));
+    }
+  } : {};
+}, Te, nr;
+function Fe() {
+  if (nr) return Te;
+  nr = 1;
+  function r(e) {
+    var n = typeof e;
+    return e != null && (n == "object" || n == "function");
+  }
+  return Te = r, Te;
+}
+var we, ar;
+function nt() {
+  if (ar) return we;
+  ar = 1;
+  var r = typeof fe == "object" && fe && fe.Object === Object && fe;
+  return we = r, we;
+}
+var _e, ir;
+function Or() {
+  if (ir) return _e;
+  ir = 1;
+  var r = nt(), e = typeof self == "object" && self && self.Object === Object && self, n = r || e || Function("return this")();
+  return _e = n, _e;
+}
+var je, or;
+function at() {
+  if (or) return je;
+  or = 1;
+  var r = Or(), e = function() {
+    return r.Date.now();
+  };
+  return je = e, je;
+}
+var Re, ur;
+function it() {
+  if (ur) return Re;
+  ur = 1;
+  var r = /\s/;
+  function e(n) {
+    for (var a = n.length; a-- && r.test(n.charAt(a)); )
+      ;
+    return a;
+  }
+  return Re = e, Re;
+}
+var Oe, cr;
+function ot() {
+  if (cr) return Oe;
+  cr = 1;
+  var r = it(), e = /^\s+/;
+  function n(a) {
+    return a && a.slice(0, r(a) + 1).replace(e, "");
+  }
+  return Oe = n, Oe;
+}
+var Se, fr;
+function Sr() {
+  if (fr) return Se;
+  fr = 1;
+  var r = Or(), e = r.Symbol;
+  return Se = e, Se;
+}
+var xe, sr;
+function ut() {
+  if (sr) return xe;
+  sr = 1;
+  var r = Sr(), e = Object.prototype, n = e.hasOwnProperty, a = e.toString, i = r ? r.toStringTag : void 0;
+  function o(c) {
+    var f = n.call(c, i), s = c[i];
+    try {
+      c[i] = void 0;
+      var u = !0;
+    } catch {
+    }
+    var m = a.call(c);
+    return u && (f ? c[i] = s : delete c[i]), m;
+  }
+  return xe = o, xe;
+}
+var Pe, lr;
+function ct() {
+  if (lr) return Pe;
+  lr = 1;
+  var r = Object.prototype, e = r.toString;
+  function n(a) {
+    return e.call(a);
+  }
+  return Pe = n, Pe;
+}
+var Ce, dr;
+function ft() {
+  if (dr) return Ce;
+  dr = 1;
+  var r = Sr(), e = ut(), n = ct(), a = "[object Null]", i = "[object Undefined]", o = r ? r.toStringTag : void 0;
+  function c(f) {
+    return f == null ? f === void 0 ? i : a : o && o in Object(f) ? e(f) : n(f);
+  }
+  return Ce = c, Ce;
+}
+var Ae, vr;
+function st() {
+  if (vr) return Ae;
+  vr = 1;
+  function r(e) {
+    return e != null && typeof e == "object";
+  }
+  return Ae = r, Ae;
+}
+var Ne, mr;
+function lt() {
+  if (mr) return Ne;
+  mr = 1;
+  var r = ft(), e = st(), n = "[object Symbol]";
+  function a(i) {
+    return typeof i == "symbol" || e(i) && r(i) == n;
+  }
+  return Ne = a, Ne;
+}
+var ke, br;
+function dt() {
+  if (br) return ke;
+  br = 1;
+  var r = ot(), e = Fe(), n = lt(), a = NaN, i = /^[-+]0x[0-9a-f]+$/i, o = /^0b[01]+$/i, c = /^0o[0-7]+$/i, f = parseInt;
+  function s(u) {
+    if (typeof u == "number")
+      return u;
+    if (n(u))
+      return a;
+    if (e(u)) {
+      var m = typeof u.valueOf == "function" ? u.valueOf() : u;
+      u = e(m) ? m + "" : m;
+    }
+    if (typeof u != "string")
+      return u === 0 ? u : +u;
+    u = r(u);
+    var v = o.test(u);
+    return v || c.test(u) ? f(u.slice(2), v ? 2 : 8) : i.test(u) ? a : +u;
+  }
+  return ke = s, ke;
+}
+var qe, gr;
+function xr() {
+  if (gr) return qe;
+  gr = 1;
+  var r = Fe(), e = at(), n = dt(), a = "Expected a function", i = Math.max, o = Math.min;
+  function c(f, s, u) {
+    var m, v, p, g, b, E, x = 0, q = !1, N = !1, M = !0;
+    if (typeof f != "function")
+      throw new TypeError(a);
+    s = n(s) || 0, r(u) && (q = !!u.leading, N = "maxWait" in u, p = N ? i(n(u.maxWait) || 0, s) : p, M = "trailing" in u ? !!u.trailing : M);
+    function k(T) {
+      var C = m, $ = v;
+      return m = v = void 0, x = T, g = f.apply($, C), g;
+    }
+    function G(T) {
+      return x = T, b = setTimeout(P, s), q ? k(T) : g;
+    }
+    function L(T) {
+      var C = T - E, $ = T - x, ue = s - C;
+      return N ? o(ue, p - $) : ue;
+    }
+    function W(T) {
+      var C = T - E, $ = T - x;
+      return E === void 0 || C >= s || C < 0 || N && $ >= p;
+    }
+    function P() {
+      var T = e();
+      if (W(T))
+        return Z(T);
+      b = setTimeout(P, L(T));
+    }
+    function Z(T) {
+      return b = void 0, M && m ? k(T) : (m = v = void 0, g);
+    }
+    function oe() {
+      b !== void 0 && clearTimeout(b), x = 0, m = E = v = b = void 0;
+    }
+    function Q() {
+      return b === void 0 ? g : Z(e());
+    }
+    function U() {
+      var T = e(), C = W(T);
+      if (m = arguments, v = this, E = T, C) {
+        if (b === void 0)
+          return G(E);
+        if (N)
+          return clearTimeout(b), b = setTimeout(P, s), k(E);
+      }
+      return b === void 0 && (b = setTimeout(P, s)), g;
+    }
+    return U.cancel = oe, U.flush = Q, U;
+  }
+  return qe = c, qe;
+}
+var vt = xr();
+const mt = /* @__PURE__ */ Tr(vt);
+var bt = function(r, e) {
+  var n = e.debounceWait, a = e.debounceLeading, i = e.debounceTrailing, o = e.debounceMaxWait, c = _(), f = pr(function() {
+    var s = {};
+    return a !== void 0 && (s.leading = a), i !== void 0 && (s.trailing = i), o !== void 0 && (s.maxWait = o), s;
+  }, [a, i, o]);
+  return X(function() {
+    if (n) {
+      var s = r.runAsync.bind(r);
+      return c.current = mt(function(u) {
+        u();
+      }, n, f), r.runAsync = function() {
+        for (var u = [], m = 0; m < arguments.length; m++)
+          u[m] = arguments[m];
+        return new Promise(function(v, p) {
+          var g;
+          (g = c.current) === null || g === void 0 || g.call(c, function() {
+            s.apply(void 0, O([], R(u), !1)).then(v).catch(p);
+          });
+        });
+      }, function() {
+        var u;
+        (u = c.current) === null || u === void 0 || u.cancel(), r.runAsync = s;
+      };
+    }
+  }, [n, f]), n ? {
+    onCancel: function() {
+      var s;
+      (s = c.current) === null || s === void 0 || s.cancel();
+    }
+  } : {};
+}, gt = function(r, e) {
+  var n = e.loadingDelay, a = e.ready, i = _();
+  if (!n)
+    return {};
+  var o = function() {
+    i.current && clearTimeout(i.current);
+  };
+  return {
+    onBefore: function() {
+      return o(), a !== !1 && (i.current = setTimeout(function() {
+        r.setState({
+          loading: !0
+        });
+      }, n)), {
+        loading: !1
+      };
+    },
+    onFinally: function() {
+      o();
+    },
+    onCancel: function() {
+      o();
+    }
+  };
+}, be = !!(typeof window < "u" && window.document && window.document.createElement);
+function Ie() {
+  return be ? document.visibilityState !== "hidden" : !0;
+}
+var ae = [];
+function ht(r) {
+  return ae.push(r), function() {
+    var n = ae.indexOf(r);
+    ae.splice(n, 1);
+  };
+}
+if (be) {
+  var yt = function() {
+    if (Ie())
+      for (var r = 0; r < ae.length; r++) {
+        var e = ae[r];
+        e();
+      }
+  };
+  window.addEventListener("visibilitychange", yt, !1);
+}
+var pt = function(r, e) {
+  var n = e.pollingInterval, a = e.pollingWhenHidden, i = a === void 0 ? !0 : a, o = e.pollingErrorRetryCount, c = o === void 0 ? -1 : o, f = _(), s = _(), u = _(0), m = function() {
+    var v;
+    f.current && clearTimeout(f.current), (v = s.current) === null || v === void 0 || v.call(s);
+  };
+  return We(function() {
+    n || m();
+  }, [n]), n ? {
+    onBefore: function() {
+      m();
+    },
+    onError: function() {
+      u.current += 1;
+    },
+    onSuccess: function() {
+      u.current = 0;
+    },
+    onFinally: function() {
+      c === -1 || // When an error occurs, the request is not repeated after pollingErrorRetryCount retries
+      c !== -1 && u.current <= c ? f.current = setTimeout(function() {
+        !i && !Ie() ? s.current = ht(function() {
+          r.refresh();
+        }) : r.refresh();
+      }, n) : u.current = 0;
+    },
+    onCancel: function() {
+      m();
+    }
+  } : {};
+};
+function Et(r, e) {
+  var n = !1;
+  return function() {
+    for (var a = [], i = 0; i < arguments.length; i++)
+      a[i] = arguments[i];
+    n || (n = !0, r.apply(void 0, O([], R(a), !1)), setTimeout(function() {
+      n = !1;
+    }, e));
+  };
+}
+function Tt() {
+  return be && typeof navigator.onLine < "u" ? navigator.onLine : !0;
+}
+var ie = [];
+function wt(r) {
+  return ie.push(r), function() {
+    var n = ie.indexOf(r);
+    n > -1 && ie.splice(n, 1);
+  };
+}
+if (be) {
+  var hr = function() {
+    if (!(!Ie() || !Tt()))
+      for (var r = 0; r < ie.length; r++) {
+        var e = ie[r];
+        e();
+      }
+  };
+  window.addEventListener("visibilitychange", hr, !1), window.addEventListener("focus", hr, !1);
+}
+var _t = function(r, e) {
+  var n = e.refreshOnWindowFocus, a = e.focusTimespan, i = a === void 0 ? 5e3 : a, o = _(), c = function() {
+    var f;
+    (f = o.current) === null || f === void 0 || f.call(o);
+  };
+  return X(function() {
+    if (n) {
+      var f = Et(r.refresh.bind(r), i);
+      o.current = wt(function() {
+        f();
+      });
+    }
+    return function() {
+      c();
+    };
+  }, [n, i]), $e(function() {
+    c();
+  }), {};
+}, jt = function(r, e) {
+  var n = e.retryInterval, a = e.retryCount, i = _(), o = _(0), c = _(!1);
+  return a ? {
+    onBefore: function() {
+      c.current || (o.current = 0), c.current = !1, i.current && clearTimeout(i.current);
+    },
+    onSuccess: function() {
+      o.current = 0;
+    },
+    onError: function() {
+      if (o.current += 1, a === -1 || o.current <= a) {
+        var f = n ?? Math.min(1e3 * Math.pow(2, o.current), 3e4);
+        i.current = setTimeout(function() {
+          c.current = !0, r.refresh();
+        }, f);
+      } else
+        o.current = 0;
+    },
+    onCancel: function() {
+      o.current = 0, i.current && clearTimeout(i.current);
+    }
+  } : {};
+}, Me, yr;
+function Rt() {
+  if (yr) return Me;
+  yr = 1;
+  var r = xr(), e = Fe(), n = "Expected a function";
+  function a(i, o, c) {
+    var f = !0, s = !0;
+    if (typeof i != "function")
+      throw new TypeError(n);
+    return e(c) && (f = "leading" in c ? !!c.leading : f, s = "trailing" in c ? !!c.trailing : s), r(i, o, {
+      leading: f,
+      maxWait: o,
+      trailing: s
+    });
+  }
+  return Me = a, Me;
+}
+var Ot = Rt();
+const St = /* @__PURE__ */ Tr(Ot);
+var xt = function(r, e) {
+  var n = e.throttleWait, a = e.throttleLeading, i = e.throttleTrailing, o = _(), c = {};
+  return a !== void 0 && (c.leading = a), i !== void 0 && (c.trailing = i), X(function() {
+    if (n) {
+      var f = r.runAsync.bind(r);
+      return o.current = St(function(s) {
+        s();
+      }, n, c), r.runAsync = function() {
+        for (var s = [], u = 0; u < arguments.length; u++)
+          s[u] = arguments[u];
+        return new Promise(function(m, v) {
+          var p;
+          (p = o.current) === null || p === void 0 || p.call(o, function() {
+            f.apply(void 0, O([], R(s), !1)).then(m).catch(v);
+          });
+        });
+      }, function() {
+        var s;
+        r.runAsync = f, (s = o.current) === null || s === void 0 || s.cancel();
+      };
+    }
+  }, [n, a, i]), n ? {
+    onCancel: function() {
+      var f;
+      (f = o.current) === null || f === void 0 || f.cancel();
+    }
+  } : {};
+}, Pt = function(r) {
+  me && (ve(r) || console.error('useMount: parameter `fn` expected to be a function, but got "'.concat(typeof r, '".'))), X(function() {
+    r == null || r();
+  }, []);
+}, Ct = function() {
+  var r = R(Lr({}), 2), e = r[1];
+  return Yr(function() {
+    return e({});
+  }, []);
+}, At = (
+  /** @class */
+  function() {
+    function r(e, n, a, i) {
+      i === void 0 && (i = {}), this.serviceRef = e, this.options = n, this.subscribe = a, this.initState = i, this.count = 0, this.state = {
+        loading: !1,
+        params: void 0,
+        data: void 0,
+        error: void 0
+      }, this.state = A(A(A({}, this.state), {
+        loading: !n.manual
+      }), i);
+    }
+    return r.prototype.setState = function(e) {
+      e === void 0 && (e = {}), this.state = A(A({}, this.state), e), this.subscribe();
+    }, r.prototype.runPluginHandler = function(e) {
+      for (var n = [], a = 1; a < arguments.length; a++)
+        n[a - 1] = arguments[a];
+      var i = this.pluginImpls.map(function(o) {
+        var c;
+        return (c = o[e]) === null || c === void 0 ? void 0 : c.call.apply(c, O([o], R(n), !1));
+      }).filter(Boolean);
+      return Object.assign.apply(Object, O([{}], R(i), !1));
+    }, r.prototype.runAsync = function() {
+      for (var e = [], n = 0; n < arguments.length; n++)
+        e[n] = arguments[n];
+      return Vr(this, void 0, void 0, function() {
+        var a, i, o, c, f, s, u, m, v, p, g, b, E, x, q, N, M, k, G, L, W;
+        return Jr(this, function(P) {
+          switch (P.label) {
+            case 0:
+              if (this.count += 1, a = this.count, i = this.runPluginHandler("onBefore", e), o = i.stopNow, c = o === void 0 ? !1 : o, f = i.returnNow, s = f === void 0 ? !1 : f, u = wr(i, ["stopNow", "returnNow"]), c)
+                return [2, new Promise(function() {
+                })];
+              if (this.setState(A({
+                loading: !0,
+                params: e
+              }, u)), s)
+                return [2, Promise.resolve(u.data)];
+              (E = (b = this.options).onBefore) === null || E === void 0 || E.call(b, e), P.label = 1;
+            case 1:
+              return P.trys.push([1, 3, , 4]), m = this.runPluginHandler("onRequest", this.serviceRef.current, e).servicePromise, m || (m = (g = this.serviceRef).current.apply(g, O([], R(e), !1))), [4, m];
+            case 2:
+              return v = P.sent(), a !== this.count ? [2, new Promise(function() {
+              })] : (this.setState({
+                data: v,
+                error: void 0,
+                loading: !1
+              }), (q = (x = this.options).onSuccess) === null || q === void 0 || q.call(x, v, e), this.runPluginHandler("onSuccess", v, e), (M = (N = this.options).onFinally) === null || M === void 0 || M.call(N, e, v, void 0), a === this.count && this.runPluginHandler("onFinally", e, v, void 0), [2, v]);
+            case 3:
+              if (p = P.sent(), a !== this.count)
+                return [2, new Promise(function() {
+                })];
+              throw this.setState({
+                error: p,
+                loading: !1
+              }), (G = (k = this.options).onError) === null || G === void 0 || G.call(k, p, e), this.runPluginHandler("onError", p, e), (W = (L = this.options).onFinally) === null || W === void 0 || W.call(L, e, void 0, p), a === this.count && this.runPluginHandler("onFinally", e, void 0, p), p;
+            case 4:
+              return [
+                2
+                /*return*/
+              ];
+          }
+        });
+      });
+    }, r.prototype.run = function() {
+      for (var e = this, n = [], a = 0; a < arguments.length; a++)
+        n[a] = arguments[a];
+      this.runAsync.apply(this, O([], R(n), !1)).catch(function(i) {
+        e.options.onError || console.error(i);
+      });
+    }, r.prototype.cancel = function() {
+      this.count += 1, this.setState({
+        loading: !1
+      }), this.runPluginHandler("onCancel");
+    }, r.prototype.refresh = function() {
+      this.run.apply(this, O([], R(this.state.params || []), !1));
+    }, r.prototype.refreshAsync = function() {
+      return this.runAsync.apply(this, O([], R(this.state.params || []), !1));
+    }, r.prototype.mutate = function(e) {
+      var n = ve(e) ? e(this.state.data) : e;
+      this.runPluginHandler("onMutate", n), this.setState({
+        data: n
+      });
+    }, r;
+  }()
+);
+function Nt(r, e, n) {
+  e === void 0 && (e = {}), n === void 0 && (n = []);
+  var a = e.manual, i = a === void 0 ? !1 : a, o = e.ready, c = o === void 0 ? !0 : o, f = wr(e, ["manual", "ready"]);
+  me && e.defaultParams && !Array.isArray(e.defaultParams) && console.warn("expected defaultParams is array, got ".concat(typeof e.defaultParams));
+  var s = A({
+    manual: i,
+    ready: c
+  }, f), u = Rr(r), m = Ct(), v = jr(function() {
+    var p = n.map(function(g) {
+      var b;
+      return (b = g == null ? void 0 : g.onInit) === null || b === void 0 ? void 0 : b.call(g, s);
+    }).filter(Boolean);
+    return new At(u, s, m, Object.assign.apply(Object, O([{}], R(p), !1)));
+  }, []);
+  return v.options = s, v.pluginImpls = n.map(function(p) {
+    return p(v, s);
+  }), Pt(function() {
+    if (!i && c) {
+      var p = v.state.params || e.defaultParams || [];
+      v.run.apply(v, O([], R(p), !1));
+    }
+  }), $e(function() {
+    v.cancel();
+  }), {
+    loading: v.state.loading,
+    data: v.state.data,
+    error: v.state.error,
+    params: v.state.params || [],
+    cancel: J(v.cancel.bind(v)),
+    refresh: J(v.refresh.bind(v)),
+    refreshAsync: J(v.refreshAsync.bind(v)),
+    run: J(v.run.bind(v)),
+    runAsync: J(v.runAsync.bind(v)),
+    mutate: J(v.mutate.bind(v))
+  };
+}
+function kt(r, e, n) {
+  return Nt(r, e, O(O([], R(n || []), !1), [bt, gt, pt, _t, xt, _r, tt, jt], !1));
+}
+function Lt(r, e, n) {
+  const a = kt(r, {
+    ...e,
+    onError(o, c) {
+      var f;
+      ((e == null ? void 0 : e.errorMessage) ?? !0) && Er.error(o.message), (f = e == null ? void 0 : e.onError) == null || f.call(e, o, c);
+    }
+  }, n), i = a.data && typeof a.data == "object" && "data" in a.data ? a.data.data : a.data;
+  return {
+    ...a,
+    data: i
+  };
+}
+export {
+  Wt as App,
+  Ft as CheckboxValue,
+  $t as IconFont,
+  It as SwitchValue,
+  Er as message,
+  Ur as modal,
+  Gr as notification,
+  Lt as useRequest
+};