@easyv/biz-components 2.1.3 → 2.1.5

package/dist/lib/packages/easyv-arco/dist/lib/chunks/index-EAFzPBke.es.es.js

@@ -0,0 +1,720 @@
+import React__default, { forwardRef, useContext, useState, useRef, useEffect } from "react";
+import { C as _e$1, u as Lr, I as Nt, c as De } from "./index-zvVd1BJp.es.es.js";
+var me = { exports: {} }, q = {};
+/**
+ * @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 Ae;
+function mr() {
+  if (Ae) return q;
+  Ae = 1;
+  var i = React__default, s = Symbol.for("react.element"), o = Symbol.for("react.fragment"), n = Object.prototype.hasOwnProperty, u = i.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, C = { key: true, ref: true, __self: true, __source: true };
+  function m(E, g, v) {
+    var b, P = {}, w = null, N = null;
+    v !== void 0 && (w = "" + v), g.key !== void 0 && (w = "" + g.key), g.ref !== void 0 && (N = g.ref);
+    for (b in g) n.call(g, b) && !C.hasOwnProperty(b) && (P[b] = g[b]);
+    if (E && E.defaultProps) for (b in g = E.defaultProps, g) P[b] === void 0 && (P[b] = g[b]);
+    return { $$typeof: s, type: E, key: w, ref: N, props: P, _owner: u.current };
+  }
+  return q.Fragment = o, q.jsx = m, q.jsxs = m, q;
+}
+var J = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var $e;
+function br() {
+  return $e || ($e = 1, process.env.NODE_ENV !== "production" && function() {
+    var i = React__default, s = Symbol.for("react.element"), o = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), u = Symbol.for("react.strict_mode"), C = Symbol.for("react.profiler"), m = Symbol.for("react.provider"), E = Symbol.for("react.context"), g = Symbol.for("react.forward_ref"), v = Symbol.for("react.suspense"), b = Symbol.for("react.suspense_list"), P = Symbol.for("react.memo"), w = Symbol.for("react.lazy"), N = Symbol.for("react.offscreen"), B = Symbol.iterator, H = "@@iterator";
+    function oe(e) {
+      if (e === null || typeof e != "object")
+        return null;
+      var r = B && e[B] || e[H];
+      return typeof r == "function" ? r : null;
+    }
+    var D = i.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function h(e) {
+      {
+        for (var r = arguments.length, t = new Array(r > 1 ? r - 1 : 0), a = 1; a < r; a++)
+          t[a - 1] = arguments[a];
+        ie("error", e, t);
+      }
+    }
+    function ie(e, r, t) {
+      {
+        var a = D.ReactDebugCurrentFrame, c = a.getStackAddendum();
+        c !== "" && (r += "%s", t = t.concat([c]));
+        var d = t.map(function(f) {
+          return String(f);
+        });
+        d.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, d);
+      }
+    }
+    var A = false, L = false, ue = false, le = false, se = false, M;
+    M = Symbol.for("react.module.reference");
+    function fe(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === n || e === C || se || e === u || e === v || e === b || le || e === N || A || L || ue || typeof e == "object" && e !== null && (e.$$typeof === w || e.$$typeof === P || e.$$typeof === m || e.$$typeof === E || e.$$typeof === g || // 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 === M || e.getModuleId !== void 0));
+    }
+    function X(e, r, t) {
+      var a = e.displayName;
+      if (a)
+        return a;
+      var c = r.displayName || r.name || "";
+      return c !== "" ? t + "(" + c + ")" : t;
+    }
+    function U(e) {
+      return e.displayName || "Context";
+    }
+    function S(e) {
+      if (e == null)
+        return null;
+      if (typeof e.tag == "number" && h("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 n:
+          return "Fragment";
+        case o:
+          return "Portal";
+        case C:
+          return "Profiler";
+        case u:
+          return "StrictMode";
+        case v:
+          return "Suspense";
+        case b:
+          return "SuspenseList";
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case E:
+            var r = e;
+            return U(r) + ".Consumer";
+          case m:
+            var t = e;
+            return U(t._context) + ".Provider";
+          case g:
+            return X(e, e.render, "ForwardRef");
+          case P:
+            var a = e.displayName || null;
+            return a !== null ? a : S(e.type) || "Memo";
+          case w: {
+            var c = e, d = c._payload, f = c._init;
+            try {
+              return S(f(d));
+            } catch (l) {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var x = Object.assign, I = 0, Z, j, _, Q, V, z, G;
+    function $() {
+    }
+    $.__reactDisabledLog = true;
+    function k() {
+      {
+        if (I === 0) {
+          Z = console.log, j = console.info, _ = console.warn, Q = console.error, V = console.group, z = console.groupCollapsed, G = console.groupEnd;
+          var e = {
+            configurable: true,
+            enumerable: true,
+            value: $,
+            writable: true
+          };
+          Object.defineProperties(console, {
+            info: e,
+            log: e,
+            warn: e,
+            error: e,
+            group: e,
+            groupCollapsed: e,
+            groupEnd: e
+          });
+        }
+        I++;
+      }
+    }
+    function Me() {
+      {
+        if (I--, I === 0) {
+          var e = {
+            configurable: true,
+            enumerable: true,
+            writable: true
+          };
+          Object.defineProperties(console, {
+            log: x({}, e, {
+              value: Z
+            }),
+            info: x({}, e, {
+              value: j
+            }),
+            warn: x({}, e, {
+              value: _
+            }),
+            error: x({}, e, {
+              value: Q
+            }),
+            group: x({}, e, {
+              value: V
+            }),
+            groupCollapsed: x({}, e, {
+              value: z
+            }),
+            groupEnd: x({}, e, {
+              value: G
+            })
+          });
+        }
+        I < 0 && h("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ce = D.ReactCurrentDispatcher, de;
+    function ee(e, r, t) {
+      {
+        if (de === void 0)
+          try {
+            throw Error();
+          } catch (c) {
+            var a = c.stack.trim().match(/\n( *(at )?)/);
+            de = a && a[1] || "";
+          }
+        return `
+` + de + e;
+      }
+    }
+    var ve = false, re;
+    {
+      var Ue = typeof WeakMap == "function" ? WeakMap : Map;
+      re = new Ue();
+    }
+    function Ee(e, r) {
+      if (!e || ve)
+        return "";
+      {
+        var t = re.get(e);
+        if (t !== void 0)
+          return t;
+      }
+      var a;
+      ve = true;
+      var c = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var d;
+      d = ce.current, ce.current = null, k();
+      try {
+        if (r) {
+          var f = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(f.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(f, []);
+            } catch (F) {
+              a = F;
+            }
+            Reflect.construct(e, [], f);
+          } else {
+            try {
+              f.call();
+            } catch (F) {
+              a = F;
+            }
+            e.call(f.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (F) {
+            a = F;
+          }
+          e();
+        }
+      } catch (F) {
+        if (F && a && typeof F.stack == "string") {
+          for (var l = F.stack.split(`
+`), R = a.stack.split(`
+`), p = l.length - 1, y = R.length - 1; p >= 1 && y >= 0 && l[p] !== R[y]; )
+            y--;
+          for (; p >= 1 && y >= 0; p--, y--)
+            if (l[p] !== R[y]) {
+              if (p !== 1 || y !== 1)
+                do
+                  if (p--, y--, y < 0 || l[p] !== R[y]) {
+                    var O = `
+` + l[p].replace(" at new ", " at ");
+                    return e.displayName && O.includes("<anonymous>") && (O = O.replace("<anonymous>", e.displayName)), typeof e == "function" && re.set(e, O), O;
+                  }
+                while (p >= 1 && y >= 0);
+              break;
+            }
+        }
+      } finally {
+        ve = false, ce.current = d, Me(), Error.prepareStackTrace = c;
+      }
+      var Y = e ? e.displayName || e.name : "", Ne = Y ? ee(Y) : "";
+      return typeof e == "function" && re.set(e, Ne), Ne;
+    }
+    function Ve(e, r, t) {
+      return Ee(e, false);
+    }
+    function ze(e) {
+      var r = e.prototype;
+      return !!(r && r.isReactComponent);
+    }
+    function te(e, r, t) {
+      if (e == null)
+        return "";
+      if (typeof e == "function")
+        return Ee(e, ze(e));
+      if (typeof e == "string")
+        return ee(e);
+      switch (e) {
+        case v:
+          return ee("Suspense");
+        case b:
+          return ee("SuspenseList");
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case g:
+            return Ve(e.render);
+          case P:
+            return te(e.type, r, t);
+          case w: {
+            var a = e, c = a._payload, d = a._init;
+            try {
+              return te(d(c), r, t);
+            } catch (f) {
+            }
+          }
+        }
+      return "";
+    }
+    var ne = Object.prototype.hasOwnProperty, Re = {}, Ce = D.ReactDebugCurrentFrame;
+    function ae(e) {
+      if (e) {
+        var r = e._owner, t = te(e.type, e._source, r ? r.type : null);
+        Ce.setExtraStackFrame(t);
+      } else
+        Ce.setExtraStackFrame(null);
+    }
+    function Ge(e, r, t, a, c) {
+      {
+        var d = Function.call.bind(ne);
+        for (var f in e)
+          if (d(e, f)) {
+            var l = void 0;
+            try {
+              if (typeof e[f] != "function") {
+                var R = Error((a || "React class") + ": " + t + " type `" + f + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[f] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw R.name = "Invariant Violation", R;
+              }
+              l = e[f](r, f, a, t, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (p) {
+              l = p;
+            }
+            l && !(l instanceof Error) && (ae(c), h("%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).", a || "React class", t, f, typeof l), ae(null)), l instanceof Error && !(l.message in Re) && (Re[l.message] = true, ae(c), h("Failed %s type: %s", t, l.message), ae(null));
+          }
+      }
+    }
+    var qe = Array.isArray;
+    function pe(e) {
+      return qe(e);
+    }
+    function Je(e) {
+      {
+        var r = typeof Symbol == "function" && Symbol.toStringTag, t = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return t;
+      }
+    }
+    function Ke(e) {
+      try {
+        return Oe(e), false;
+      } catch (r) {
+        return true;
+      }
+    }
+    function Oe(e) {
+      return "" + e;
+    }
+    function Te(e) {
+      if (Ke(e))
+        return h("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Je(e)), Oe(e);
+    }
+    var Pe = D.ReactCurrentOwner, He = {
+      key: true,
+      ref: true,
+      __self: true,
+      __source: true
+    }, we, xe;
+    function Xe(e) {
+      if (ne.call(e, "ref")) {
+        var r = Object.getOwnPropertyDescriptor(e, "ref").get;
+        if (r && r.isReactWarning)
+          return false;
+      }
+      return e.ref !== void 0;
+    }
+    function Ze(e) {
+      if (ne.call(e, "key")) {
+        var r = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (r && r.isReactWarning)
+          return false;
+      }
+      return e.key !== void 0;
+    }
+    function Qe(e, r) {
+      typeof e.ref == "string" && Pe.current;
+    }
+    function er(e, r) {
+      {
+        var t = function() {
+          we || (we = true, h("%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));
+        };
+        t.isReactWarning = true, Object.defineProperty(e, "key", {
+          get: t,
+          configurable: true
+        });
+      }
+    }
+    function rr(e, r) {
+      {
+        var t = function() {
+          xe || (xe = true, h("%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));
+        };
+        t.isReactWarning = true, Object.defineProperty(e, "ref", {
+          get: t,
+          configurable: true
+        });
+      }
+    }
+    var tr = function(e, r, t, a, c, d, f) {
+      var l = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: s,
+        // Built-in properties that belong on the element
+        type: e,
+        key: r,
+        ref: t,
+        props: f,
+        // Record the component responsible for creating this element.
+        _owner: d
+      };
+      return l._store = {}, Object.defineProperty(l._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: false
+      }), Object.defineProperty(l, "_self", {
+        configurable: false,
+        enumerable: false,
+        writable: false,
+        value: a
+      }), Object.defineProperty(l, "_source", {
+        configurable: false,
+        enumerable: false,
+        writable: false,
+        value: c
+      }), Object.freeze && (Object.freeze(l.props), Object.freeze(l)), l;
+    };
+    function nr(e, r, t, a, c) {
+      {
+        var d, f = {}, l = null, R = null;
+        t !== void 0 && (Te(t), l = "" + t), Ze(r) && (Te(r.key), l = "" + r.key), Xe(r) && (R = r.ref, Qe(r));
+        for (d in r)
+          ne.call(r, d) && !He.hasOwnProperty(d) && (f[d] = r[d]);
+        if (e && e.defaultProps) {
+          var p = e.defaultProps;
+          for (d in p)
+            f[d] === void 0 && (f[d] = p[d]);
+        }
+        if (l || R) {
+          var y = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          l && er(f, y), R && rr(f, y);
+        }
+        return tr(e, l, R, c, a, Pe.current, f);
+      }
+    }
+    var ye = D.ReactCurrentOwner, Se = D.ReactDebugCurrentFrame;
+    function W(e) {
+      if (e) {
+        var r = e._owner, t = te(e.type, e._source, r ? r.type : null);
+        Se.setExtraStackFrame(t);
+      } else
+        Se.setExtraStackFrame(null);
+    }
+    var ge;
+    ge = false;
+    function he(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === s;
+    }
+    function je() {
+      {
+        if (ye.current) {
+          var e = S(ye.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+    }
+    function ar(e) {
+      return "";
+    }
+    var ke = {};
+    function or(e) {
+      {
+        var r = je();
+        if (!r) {
+          var t = typeof e == "string" ? e : e.displayName || e.name;
+          t && (r = `
+
+Check the top-level render call using <` + t + ">.");
+        }
+        return r;
+      }
+    }
+    function Fe(e, r) {
+      {
+        if (!e._store || e._store.validated || e.key != null)
+          return;
+        e._store.validated = true;
+        var t = or(r);
+        if (ke[t])
+          return;
+        ke[t] = true;
+        var a = "";
+        e && e._owner && e._owner !== ye.current && (a = " It was passed a child from " + S(e._owner.type) + "."), W(e), h('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', t, a), W(null);
+      }
+    }
+    function De2(e, r) {
+      {
+        if (typeof e != "object")
+          return;
+        if (pe(e))
+          for (var t = 0; t < e.length; t++) {
+            var a = e[t];
+            he(a) && Fe(a, r);
+          }
+        else if (he(e))
+          e._store && (e._store.validated = true);
+        else if (e) {
+          var c = oe(e);
+          if (typeof c == "function" && c !== e.entries)
+            for (var d = c.call(e), f; !(f = d.next()).done; )
+              he(f.value) && Fe(f.value, r);
+        }
+      }
+    }
+    function ir(e) {
+      {
+        var r = e.type;
+        if (r == null || typeof r == "string")
+          return;
+        var t;
+        if (typeof r == "function")
+          t = r.propTypes;
+        else if (typeof r == "object" && (r.$$typeof === g || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        r.$$typeof === P))
+          t = r.propTypes;
+        else
+          return;
+        if (t) {
+          var a = S(r);
+          Ge(t, e.props, "prop", a, e);
+        } else if (r.PropTypes !== void 0 && !ge) {
+          ge = true;
+          var c = S(r);
+          h("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", c || "Unknown");
+        }
+        typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && h("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function ur(e) {
+      {
+        for (var r = Object.keys(e.props), t = 0; t < r.length; t++) {
+          var a = r[t];
+          if (a !== "children" && a !== "key") {
+            W(e), h("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", a), W(null);
+            break;
+          }
+        }
+        e.ref !== null && (W(e), h("Invalid attribute `ref` supplied to `React.Fragment`."), W(null));
+      }
+    }
+    function Ie(e, r, t, a, c, d) {
+      {
+        var f = fe(e);
+        if (!f) {
+          var l = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (l += " 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 R = ar();
+          R ? l += R : l += je();
+          var p;
+          e === null ? p = "null" : pe(e) ? p = "array" : e !== void 0 && e.$$typeof === s ? (p = "<" + (S(e.type) || "Unknown") + " />", l = " Did you accidentally export a JSX literal instead of a component?") : p = typeof e, h("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", p, l);
+        }
+        var y = nr(e, r, t, c, d);
+        if (y == null)
+          return y;
+        if (f) {
+          var O = r.children;
+          if (O !== void 0)
+            if (a)
+              if (pe(O)) {
+                for (var Y = 0; Y < O.length; Y++)
+                  De2(O[Y], e);
+                Object.freeze && Object.freeze(O);
+              } else
+                h("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
+              De2(O, e);
+        }
+        return e === n ? ur(y) : ir(y), y;
+      }
+    }
+    function lr(e, r, t) {
+      return Ie(e, r, t, true);
+    }
+    function sr(e, r, t) {
+      return Ie(e, r, t, false);
+    }
+    var fr = sr, cr = lr;
+    J.Fragment = n, J.jsx = fr, J.jsxs = cr;
+  }()), J;
+}
+process.env.NODE_ENV === "production" ? me.exports = mr() : me.exports = br();
+var kr = me.exports, be = function() {
+  return be = Object.assign || function(i) {
+    for (var s, o = 1, n = arguments.length; o < n; o++) {
+      s = arguments[o];
+      for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (i[u] = s[u]);
+    }
+    return i;
+  }, be.apply(this, arguments);
+}, _r = function(i, s) {
+  var o = {};
+  for (var n in i) Object.prototype.hasOwnProperty.call(i, n) && s.indexOf(n) < 0 && (o[n] = i[n]);
+  if (i != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var u = 0, n = Object.getOwnPropertySymbols(i); u < n.length; u++)
+      s.indexOf(n[u]) < 0 && Object.prototype.propertyIsEnumerable.call(i, n[u]) && (o[n[u]] = i[n[u]]);
+  return o;
+};
+function Er(i, s) {
+  var o = i.className, n = i.style, u = i.children, C = _r(i, ["className", "style", "children"]), m = useContext(_e$1).getPrefixCls, E = m("btn-group"), g = De(E, o);
+  return React__default.createElement("div", be({ ref: s, className: g, style: n }, C), u);
+}
+var Le = React__default.forwardRef(Er);
+Le.displayName = "ButtonGroup";
+var K = function() {
+  return K = Object.assign || function(i) {
+    for (var s, o = 1, n = arguments.length; o < n; o++) {
+      s = arguments[o];
+      for (var u in s) Object.prototype.hasOwnProperty.call(s, u) && (i[u] = s[u]);
+    }
+    return i;
+  }, K.apply(this, arguments);
+}, Rr = function(i, s) {
+  var o = {};
+  for (var n in i) Object.prototype.hasOwnProperty.call(i, n) && s.indexOf(n) < 0 && (o[n] = i[n]);
+  if (i != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var u = 0, n = Object.getOwnPropertySymbols(i); u < n.length; u++)
+      s.indexOf(n[u]) < 0 && Object.prototype.propertyIsEnumerable.call(i, n[u]) && (o[n[u]] = i[n[u]]);
+  return o;
+}, Cr = function(i, s) {
+  var o = typeof Symbol == "function" && i[Symbol.iterator];
+  if (!o) return i;
+  var n = o.call(i), u, C = [], m;
+  try {
+    for (; (s === void 0 || s-- > 0) && !(u = n.next()).done; ) C.push(u.value);
+  } catch (E) {
+    m = { error: E };
+  } finally {
+    try {
+      u && !u.done && (o = n.return) && o.call(n);
+    } finally {
+      if (m) throw m.error;
+    }
+  }
+  return C;
+}, Or = /^[\u4e00-\u9fa5]{2}$/;
+function Tr(i) {
+  var s = [], o = false;
+  return React__default.Children.forEach(i, function(n) {
+    var u = typeof n == "string" || typeof n == "number";
+    if (u && o) {
+      var C = s.length - 1, m = s[C];
+      s[C] = "" + m + n;
+    } else
+      s.push(n);
+    o = u;
+  }), React__default.Children.map(s, function(n) {
+    return typeof n == "string" ? React__default.createElement("span", null, n) : n;
+  });
+}
+var Pr = {
+  htmlType: "button",
+  type: "default",
+  shape: "square"
+};
+function wr(i, s) {
+  var o, n = useContext(_e$1), u = n.getPrefixCls, C = n.size, m = n.autoInsertSpaceInButton, E = n.componentConfig, g = n.rtl, v = Lr(i, Pr, E == null ? void 0 : E.Button), b = v.style, P = v.className, w = v.children, N = v.htmlType, B = v.type, H = v.status, oe = v.size, D = v.shape, h = v.href, ie = v.anchorProps, A = v.disabled, L = v.loading, ue = v.loadingFixedWidth, le = v.icon, se = v.iconOnly, M = v.onClick, fe = v.long, X = Rr(v, ["style", "className", "children", "htmlType", "type", "status", "size", "shape", "href", "anchorProps", "disabled", "loading", "loadingFixedWidth", "icon", "iconOnly", "onClick", "long"]), U = L ? React__default.createElement(Nt, null) : le, S = Cr(useState(false), 2), x = S[0], I = S[1], Z = useRef(), j = s || Z;
+  useEffect(function() {
+    if (m && j && j.current) {
+      var k = j.current.textContent;
+      Or.test(k) ? x || I(true) : x && I(false);
+    }
+  }, [j.current, m]);
+  var _ = u("btn"), Q = B === "default" ? "secondary" : B, V = De(_, _ + "-" + Q, _ + "-size-" + (oe || C), _ + "-shape-" + D, (o = {}, o[_ + "-long"] = fe, o[_ + "-status-" + H] = H, o[_ + "-loading-fixed-width"] = ue, o[_ + "-loading"] = L, o[_ + "-link"] = h, o[_ + "-icon-only"] = se || !w && w !== 0 && U, o[_ + "-disabled"] = A, o[_ + "-two-chinese-chars"] = x, o[_ + "-rtl"] = g, o), P), z = function(k) {
+    if (L || A) {
+      typeof (k == null ? void 0 : k.preventDefault) == "function" && k.preventDefault();
+      return;
+    }
+    M && M(k);
+  }, G = React__default.createElement(
+    React__default.Fragment,
+    null,
+    U,
+    Tr(w)
+  );
+  if (h) {
+    var $ = K({}, ie);
+    return A ? delete $.href : $.href = h, React__default.createElement("a", K({ ref: j }, X, $, { style: b, className: V, onClick: z }), G);
+  }
+  return React__default.createElement("button", K({ ref: j }, X, { style: b, className: V, type: N, disabled: A, onClick: z }), G);
+}
+var xr = forwardRef(wr), _e = xr;
+_e.__BYTE_BUTTON = true;
+_e.Group = Le;
+_e.displayName = "Button";
+export {
+  _e as B,
+  kr as j
+};
+//# sourceMappingURL=index-EAFzPBke.es.es.js.map