@witlink/usercenter 1.0.37 → 1.0.39

package/dist/index.a1bb9fcb.mjs

@@ -0,0 +1,1073 @@
+import { L as nt, N as R, O as at, P as j, Q as A, R as rt, T as Ae, U as v, V as F, W as ee, X as ye, Y as le, Z as lt, $ as it, a0 as ot, a1 as Te, a2 as He, a3 as Ue, a4 as Ge, a5 as st, a6 as ut, a7 as dt, a8 as ct, a9 as ft, aa as pt, ab as mt, ac as gt, ad as vt, ae as ht, af as bt, ag as be, ah as St, ai as $t, aj as Ve, ak as Be, al as Nt, am as Se } from "./index.5b29a0a3.mjs";
+import { createVNode as h, defineComponent as Ie, ref as Le, onBeforeUnmount as qe, shallowRef as _, computed as W, watch as te } from "vue";
+var yt = { icon: { tag: "svg", attrs: { viewBox: "64 64 896 896", focusable: "false" }, children: [{ tag: "path", attrs: { d: "M890.5 755.3L537.9 269.2c-12.8-17.6-39-17.6-51.7 0L133.5 755.3A8 8 0 00140 768h75c5.1 0 9.9-2.5 12.9-6.6L512 369.8l284.1 391.6c3 4.1 7.8 6.6 12.9 6.6h75c6.5 0 10.3-7.4 6.5-12.7z" } }] }, name: "up", theme: "outlined" };
+const wt = yt;
+function Fe(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var n = arguments[t] != null ? Object(arguments[t]) : {}, a = Object.keys(n);
+    typeof Object.getOwnPropertySymbols == "function" && (a = a.concat(Object.getOwnPropertySymbols(n).filter(function(l) {
+      return Object.getOwnPropertyDescriptor(n, l).enumerable;
+    }))), a.forEach(function(l) {
+      xt(e, l, n[l]);
+    });
+  }
+  return e;
+}
+function xt(e, t, n) {
+  return t in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
+}
+var Ee = function(t, n) {
+  var a = Fe({}, t, n.attrs);
+  return h(nt, Fe({}, a, {
+    icon: wt
+  }), null);
+};
+Ee.displayName = "UpOutlined";
+Ee.inheritAttrs = !1;
+const It = Ee;
+function we() {
+  return typeof BigInt == "function";
+}
+function ne(e) {
+  let t = e.trim(), n = t.startsWith("-");
+  n && (t = t.slice(1)), t = t.replace(/(\.\d*[^0])0*$/, "$1").replace(/\.0*$/, "").replace(/^0+/, ""), t.startsWith(".") && (t = `0${t}`);
+  const a = t || "0", l = a.split("."), o = l[0] || "0", d = l[1] || "0";
+  o === "0" && d === "0" && (n = !1);
+  const c = n ? "-" : "";
+  return {
+    negative: n,
+    negativeStr: c,
+    trimStr: a,
+    integerStr: o,
+    decimalStr: d,
+    fullStr: `${c}${a}`
+  };
+}
+function Ce(e) {
+  const t = String(e);
+  return !Number.isNaN(Number(t)) && t.includes("e");
+}
+function ae(e) {
+  const t = String(e);
+  if (Ce(e)) {
+    let n = Number(t.slice(t.indexOf("e-") + 2));
+    const a = t.match(/\.(\d+)/);
+    return a != null && a[1] && (n += a[1].length), n;
+  }
+  return t.includes(".") && Pe(t) ? t.length - t.indexOf(".") - 1 : 0;
+}
+function Oe(e) {
+  let t = String(e);
+  if (Ce(e)) {
+    if (e > Number.MAX_SAFE_INTEGER)
+      return String(we() ? BigInt(e).toString() : Number.MAX_SAFE_INTEGER);
+    if (e < Number.MIN_SAFE_INTEGER)
+      return String(we() ? BigInt(e).toString() : Number.MIN_SAFE_INTEGER);
+    t = e.toFixed(ae(t));
+  }
+  return ne(t).fullStr;
+}
+function Pe(e) {
+  return typeof e == "number" ? !Number.isNaN(e) : e ? /^\s*-?\d+(\.\d+)?\s*$/.test(e) || /^\s*-?\d+\.\s*$/.test(e) || /^\s*-?\.\d+\s*$/.test(e) : !1;
+}
+function ke(e) {
+  return !e && e !== 0 && !Number.isNaN(e) || !String(e).trim();
+}
+class z {
+  constructor(t) {
+    if (this.origin = "", ke(t)) {
+      this.empty = !0;
+      return;
+    }
+    this.origin = String(t), this.number = Number(t);
+  }
+  negate() {
+    return new z(-this.toNumber());
+  }
+  add(t) {
+    if (this.isInvalidate())
+      return new z(t);
+    const n = Number(t);
+    if (Number.isNaN(n))
+      return this;
+    const a = this.number + n;
+    if (a > Number.MAX_SAFE_INTEGER)
+      return new z(Number.MAX_SAFE_INTEGER);
+    if (a < Number.MIN_SAFE_INTEGER)
+      return new z(Number.MIN_SAFE_INTEGER);
+    const l = Math.max(ae(this.number), ae(n));
+    return new z(a.toFixed(l));
+  }
+  isEmpty() {
+    return this.empty;
+  }
+  isNaN() {
+    return Number.isNaN(this.number);
+  }
+  isInvalidate() {
+    return this.isEmpty() || this.isNaN();
+  }
+  equals(t) {
+    return this.toNumber() === (t == null ? void 0 : t.toNumber());
+  }
+  lessEquals(t) {
+    return this.add(t.negate().toString()).toNumber() <= 0;
+  }
+  toNumber() {
+    return this.number;
+  }
+  toString() {
+    return (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0) ? this.isInvalidate() ? "" : Oe(this.number) : this.origin;
+  }
+}
+class q {
+  constructor(t) {
+    if (this.origin = "", ke(t)) {
+      this.empty = !0;
+      return;
+    }
+    if (this.origin = String(t), t === "-" || Number.isNaN(t)) {
+      this.nan = !0;
+      return;
+    }
+    let n = t;
+    if (Ce(n) && (n = Number(n)), n = typeof n == "string" ? n : Oe(n), Pe(n)) {
+      const a = ne(n);
+      this.negative = a.negative;
+      const l = a.trimStr.split(".");
+      this.integer = BigInt(l[0]);
+      const o = l[1] || "0";
+      this.decimal = BigInt(o), this.decimalLen = o.length;
+    } else
+      this.nan = !0;
+  }
+  getMark() {
+    return this.negative ? "-" : "";
+  }
+  getIntegerStr() {
+    return this.integer.toString();
+  }
+  getDecimalStr() {
+    return this.decimal.toString().padStart(this.decimalLen, "0");
+  }
+  alignDecimal(t) {
+    const n = `${this.getMark()}${this.getIntegerStr()}${this.getDecimalStr().padEnd(t, "0")}`;
+    return BigInt(n);
+  }
+  negate() {
+    const t = new q(this.toString());
+    return t.negative = !t.negative, t;
+  }
+  add(t) {
+    if (this.isInvalidate())
+      return new q(t);
+    const n = new q(t);
+    if (n.isInvalidate())
+      return this;
+    const a = Math.max(this.getDecimalStr().length, n.getDecimalStr().length), l = this.alignDecimal(a), o = n.alignDecimal(a), d = (l + o).toString(), {
+      negativeStr: c,
+      trimStr: m
+    } = ne(d), f = `${c}${m.padStart(a + 1, "0")}`;
+    return new q(`${f.slice(0, -a)}.${f.slice(-a)}`);
+  }
+  isEmpty() {
+    return this.empty;
+  }
+  isNaN() {
+    return this.nan;
+  }
+  isInvalidate() {
+    return this.isEmpty() || this.isNaN();
+  }
+  equals(t) {
+    return this.toString() === (t == null ? void 0 : t.toString());
+  }
+  lessEquals(t) {
+    return this.add(t.negate().toString()).toNumber() <= 0;
+  }
+  toNumber() {
+    return this.isNaN() ? NaN : Number(this.toString());
+  }
+  toString() {
+    return (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0) ? this.isInvalidate() ? "" : ne(`${this.getMark()}${this.getIntegerStr()}.${this.getDecimalStr()}`).fullStr : this.origin;
+  }
+}
+function P(e) {
+  return we() ? new q(e) : new z(e);
+}
+function xe(e, t, n) {
+  let a = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : !1;
+  if (e === "")
+    return "";
+  const {
+    negativeStr: l,
+    integerStr: o,
+    decimalStr: d
+  } = ne(e), c = `${t}${d}`, m = `${l}${o}`;
+  if (n >= 0) {
+    const f = Number(d[n]);
+    if (f >= 5 && !a) {
+      const s = P(e).add(`${l}0.${"0".repeat(n)}${10 - f}`);
+      return xe(s.toString(), t, n, a);
+    }
+    return n === 0 ? m : `${m}${t}${d.padEnd(n, "0").slice(0, n)}`;
+  }
+  return c === ".0" ? m : `${m}${c}`;
+}
+const Et = 200, Ct = 600, Ot = Ie({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "StepHandler",
+  inheritAttrs: !1,
+  props: {
+    prefixCls: String,
+    upDisabled: Boolean,
+    downDisabled: Boolean,
+    onStep: R()
+  },
+  slots: Object,
+  setup(e, t) {
+    let {
+      slots: n,
+      emit: a
+    } = t;
+    const l = Le(), o = (c, m) => {
+      c.preventDefault(), a("step", m);
+      function f() {
+        a("step", m), l.value = setTimeout(f, Et);
+      }
+      l.value = setTimeout(f, Ct);
+    }, d = () => {
+      clearTimeout(l.value);
+    };
+    return qe(() => {
+      d();
+    }), () => {
+      if (at())
+        return null;
+      const {
+        prefixCls: c,
+        upDisabled: m,
+        downDisabled: f
+      } = e, s = `${c}-handler`, w = j(s, `${s}-up`, {
+        [`${s}-up-disabled`]: m
+      }), S = j(s, `${s}-down`, {
+        [`${s}-down-disabled`]: f
+      }), I = {
+        unselectable: "on",
+        role: "button",
+        onMouseup: d,
+        onMouseleave: d
+      }, {
+        upNode: $,
+        downNode: E
+      } = n;
+      return h("div", {
+        class: `${s}-wrap`
+      }, [h("span", A(A({}, I), {}, {
+        onMousedown: (D) => {
+          o(D, !0);
+        },
+        "aria-label": "Increase Value",
+        "aria-disabled": m,
+        class: w
+      }), [($ == null ? void 0 : $()) || h("span", {
+        unselectable: "on",
+        class: `${c}-handler-up-inner`
+      }, null)]), h("span", A(A({}, I), {}, {
+        onMousedown: (D) => {
+          o(D, !1);
+        },
+        "aria-label": "Decrease Value",
+        "aria-disabled": f,
+        class: S
+      }), [(E == null ? void 0 : E()) || h("span", {
+        unselectable: "on",
+        class: `${c}-handler-down-inner`
+      }, null)])]);
+    };
+  }
+});
+function Pt(e, t) {
+  const n = Le(null);
+  function a() {
+    try {
+      const {
+        selectionStart: o,
+        selectionEnd: d,
+        value: c
+      } = e.value, m = c.substring(0, o), f = c.substring(d);
+      n.value = {
+        start: o,
+        end: d,
+        value: c,
+        beforeTxt: m,
+        afterTxt: f
+      };
+    } catch {
+    }
+  }
+  function l() {
+    if (e.value && n.value && t.value)
+      try {
+        const {
+          value: o
+        } = e.value, {
+          beforeTxt: d,
+          afterTxt: c,
+          start: m
+        } = n.value;
+        let f = o.length;
+        if (o.endsWith(c))
+          f = o.length - n.value.afterTxt.length;
+        else if (o.startsWith(d))
+          f = d.length;
+        else {
+          const s = d[m - 1], w = o.indexOf(s, m - 1);
+          w !== -1 && (f = w + 1);
+        }
+        e.value.setSelectionRange(f, f);
+      } catch (o) {
+        rt(!1, `Something warning of cursor restore. Please fire issue about this: ${o.message}`);
+      }
+  }
+  return [a, l];
+}
+const _t = () => {
+  const e = _(0), t = () => {
+    Ae.cancel(e.value);
+  };
+  return qe(() => {
+    t();
+  }), (n) => {
+    t(), e.value = Ae(() => {
+      n();
+    });
+  };
+};
+var Dt = globalThis && globalThis.__rest || function(e, t) {
+  var n = {};
+  for (var a in e)
+    Object.prototype.hasOwnProperty.call(e, a) && t.indexOf(a) < 0 && (n[a] = e[a]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var l = 0, a = Object.getOwnPropertySymbols(e); l < a.length; l++)
+      t.indexOf(a[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, a[l]) && (n[a[l]] = e[a[l]]);
+  return n;
+};
+const ze = (e, t) => e || t.isEmpty() ? t.toString() : t.toNumber(), je = (e) => {
+  const t = P(e);
+  return t.isInvalidate() ? null : t;
+}, Xe = () => ({
+  stringMode: F(),
+  defaultValue: ee([String, Number]),
+  value: ee([String, Number]),
+  prefixCls: ye(),
+  min: ee([String, Number]),
+  max: ee([String, Number]),
+  step: ee([String, Number], 1),
+  tabindex: Number,
+  controls: F(!0),
+  readonly: F(),
+  disabled: F(),
+  autofocus: F(),
+  keyboard: F(!0),
+  parser: R(),
+  formatter: R(),
+  precision: Number,
+  decimalSeparator: String,
+  onInput: R(),
+  onChange: R(),
+  onPressEnter: R(),
+  onStep: R(),
+  onBlur: R(),
+  onFocus: R()
+}), Mt = Ie({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "InnerInputNumber",
+  inheritAttrs: !1,
+  props: v(v({}, Xe()), {
+    lazy: Boolean
+  }),
+  slots: Object,
+  setup(e, t) {
+    let {
+      attrs: n,
+      slots: a,
+      emit: l,
+      expose: o
+    } = t;
+    const d = _(), c = _(!1), m = _(!1), f = _(!1), s = _(P(e.value));
+    function w(r) {
+      e.value === void 0 && (s.value = r);
+    }
+    const S = (r, i) => {
+      if (!i)
+        return e.precision >= 0 ? e.precision : Math.max(ae(r), ae(e.step));
+    }, I = (r) => {
+      const i = String(r);
+      if (e.parser)
+        return e.parser(i);
+      let u = i;
+      return e.decimalSeparator && (u = u.replace(e.decimalSeparator, ".")), u.replace(/[^\w.-]+/g, "");
+    }, $ = _(""), E = (r, i) => {
+      if (e.formatter)
+        return e.formatter(r, {
+          userTyping: i,
+          input: String($.value)
+        });
+      let u = typeof r == "number" ? Oe(r) : r;
+      if (!i) {
+        const g = S(u, i);
+        if (Pe(u) && (e.decimalSeparator || g >= 0)) {
+          const y = e.decimalSeparator || ".";
+          u = xe(u, y, g);
+        }
+      }
+      return u;
+    }, D = (() => {
+      const r = e.value;
+      return s.value.isInvalidate() && ["string", "number"].includes(typeof r) ? Number.isNaN(r) ? "" : r : E(s.value.toString(), !1);
+    })();
+    $.value = D;
+    function C(r, i) {
+      $.value = E(
+        r.isInvalidate() ? r.toString(!1) : r.toString(!i),
+        i
+      );
+    }
+    const O = W(() => je(e.max)), N = W(() => je(e.min)), x = W(() => !O.value || !s.value || s.value.isInvalidate() ? !1 : O.value.lessEquals(s.value)), T = W(() => !N.value || !s.value || s.value.isInvalidate() ? !1 : s.value.lessEquals(N.value)), [k, X] = Pt(d, c), K = (r) => O.value && !r.lessEquals(O.value) ? O.value : N.value && !N.value.lessEquals(r) ? N.value : null, ie = (r) => !K(r), Y = (r, i) => {
+      var u;
+      let g = r, y = ie(g) || g.isEmpty();
+      if (!g.isEmpty() && !i && (g = K(g) || g, y = !0), !e.readonly && !e.disabled && y) {
+        const M = g.toString(), B = S(M, i);
+        return B >= 0 && (g = P(xe(M, ".", B))), g.equals(s.value) || (w(g), (u = e.onChange) === null || u === void 0 || u.call(e, g.isEmpty() ? null : ze(e.stringMode, g)), e.value === void 0 && C(g, i)), g;
+      }
+      return s.value;
+    }, oe = _t(), Q = (r) => {
+      var i;
+      if (k(), $.value = r, !f.value) {
+        const u = I(r), g = P(u);
+        g.isNaN() || Y(g, !0);
+      }
+      (i = e.onInput) === null || i === void 0 || i.call(e, r), oe(() => {
+        let u = r;
+        e.parser || (u = r.replace(/。/g, ".")), u !== r && Q(u);
+      });
+    }, b = () => {
+      f.value = !0;
+    }, Z = () => {
+      f.value = !1, Q(d.value.value);
+    }, H = (r) => {
+      Q(r.target.value);
+    }, U = (r) => {
+      var i, u;
+      if (r && x.value || !r && T.value)
+        return;
+      m.value = !1;
+      let g = P(e.step);
+      r || (g = g.negate());
+      const y = (s.value || P(0)).add(g.toString()), M = Y(y, !1);
+      (i = e.onStep) === null || i === void 0 || i.call(e, ze(e.stringMode, M), {
+        offset: e.step,
+        type: r ? "up" : "down"
+      }), (u = d.value) === null || u === void 0 || u.focus();
+    }, V = (r) => {
+      const i = P(I($.value));
+      let u = i;
+      i.isNaN() ? u = s.value : u = Y(i, r), e.value !== void 0 ? C(s.value, !1) : u.isNaN() || C(u, !1);
+    }, se = (r) => {
+      var i;
+      const {
+        which: u
+      } = r;
+      m.value = !0, u === le.ENTER && (f.value || (m.value = !1), V(!1), (i = e.onPressEnter) === null || i === void 0 || i.call(e, r)), e.keyboard !== !1 && !f.value && [le.UP, le.DOWN].includes(u) && (U(le.UP === u), r.preventDefault());
+    }, ue = () => {
+      m.value = !1;
+    }, de = (r) => {
+      V(!1), c.value = !1, m.value = !1, l("blur", r);
+    };
+    return te(() => e.precision, () => {
+      s.value.isInvalidate() || C(s.value, !1);
+    }, {
+      flush: "post"
+    }), te(() => e.value, () => {
+      const r = P(e.value);
+      s.value = r;
+      const i = P(I($.value));
+      (!r.equals(i) || !m.value || e.formatter) && C(r, m.value);
+    }, {
+      flush: "post"
+    }), te($, () => {
+      e.formatter && X();
+    }, {
+      flush: "post"
+    }), te(() => e.disabled, (r) => {
+      r && (c.value = !1);
+    }), o({
+      focus: () => {
+        var r;
+        (r = d.value) === null || r === void 0 || r.focus();
+      },
+      blur: () => {
+        var r;
+        (r = d.value) === null || r === void 0 || r.blur();
+      }
+    }), () => {
+      const r = v(v({}, n), e), {
+        prefixCls: i = "rc-input-number",
+        min: u,
+        max: g,
+        step: y = 1,
+        defaultValue: M,
+        value: B,
+        disabled: J,
+        readonly: re,
+        keyboard: _e,
+        controls: p = !0,
+        autofocus: ce,
+        stringMode: G,
+        parser: fe,
+        formatter: pe,
+        precision: L,
+        decimalSeparator: me,
+        onChange: ge,
+        onInput: ve,
+        onPressEnter: De,
+        onStep: Me,
+        lazy: Ke,
+        class: Ye,
+        style: Qe
+      } = r, Ze = Dt(r, ["prefixCls", "min", "max", "step", "defaultValue", "value", "disabled", "readonly", "keyboard", "controls", "autofocus", "stringMode", "parser", "formatter", "precision", "decimalSeparator", "onChange", "onInput", "onPressEnter", "onStep", "lazy", "class", "style"]), {
+        upHandler: Je,
+        downHandler: et
+      } = a, Re = `${i}-input`, he = {};
+      return Ke ? he.onChange = H : he.onInput = H, h("div", {
+        class: j(i, Ye, {
+          [`${i}-focused`]: c.value,
+          [`${i}-disabled`]: J,
+          [`${i}-readonly`]: re,
+          [`${i}-not-a-number`]: s.value.isNaN(),
+          [`${i}-out-of-range`]: !s.value.isInvalidate() && !ie(s.value)
+        }),
+        style: Qe,
+        onKeydown: se,
+        onKeyup: ue
+      }, [p && h(Ot, {
+        prefixCls: i,
+        upDisabled: x.value,
+        downDisabled: T.value,
+        onStep: U
+      }, {
+        upNode: Je,
+        downNode: et
+      }), h("div", {
+        class: `${Re}-wrap`
+      }, [h("input", A(A(A({
+        autofocus: ce,
+        autocomplete: "off",
+        role: "spinbutton",
+        "aria-valuemin": u,
+        "aria-valuemax": g,
+        "aria-valuenow": s.value.isInvalidate() ? null : s.value.toString(),
+        step: y
+      }, Ze), {}, {
+        ref: d,
+        class: Re,
+        value: $.value,
+        disabled: J,
+        readonly: re,
+        onFocus: (tt) => {
+          c.value = !0, l("focus", tt);
+        }
+      }, he), {}, {
+        onBlur: de,
+        onCompositionstart: b,
+        onCompositionend: Z
+      }), null)])]);
+    };
+  }
+});
+function $e(e) {
+  return e != null;
+}
+const Rt = (e) => {
+  const {
+    componentCls: t,
+    lineWidth: n,
+    lineType: a,
+    colorBorder: l,
+    borderRadius: o,
+    fontSizeLG: d,
+    controlHeightLG: c,
+    controlHeightSM: m,
+    colorError: f,
+    inputPaddingHorizontalSM: s,
+    colorTextDescription: w,
+    motionDurationMid: S,
+    colorPrimary: I,
+    controlHeight: $,
+    inputPaddingHorizontal: E,
+    colorBgContainer: D,
+    colorTextDisabled: C,
+    borderRadiusSM: O,
+    borderRadiusLG: N,
+    controlWidth: x,
+    handleVisible: T
+  } = e;
+  return [
+    {
+      [t]: v(v(v(v({}, Te(e)), He(e)), Ue(e, t)), {
+        display: "inline-block",
+        width: x,
+        margin: 0,
+        padding: 0,
+        border: `${n}px ${a} ${l}`,
+        borderRadius: o,
+        "&-rtl": {
+          direction: "rtl",
+          [`${t}-input`]: {
+            direction: "rtl"
+          }
+        },
+        "&-lg": {
+          padding: 0,
+          fontSize: d,
+          borderRadius: N,
+          [`input${t}-input`]: {
+            height: c - 2 * n
+          }
+        },
+        "&-sm": {
+          padding: 0,
+          borderRadius: O,
+          [`input${t}-input`]: {
+            height: m - 2 * n,
+            padding: `0 ${s}px`
+          }
+        },
+        "&:hover": v({}, Ge(e)),
+        "&-focused": v({}, st(e)),
+        "&-disabled": v(v({}, ut(e)), {
+          [`${t}-input`]: {
+            cursor: "not-allowed"
+          }
+        }),
+        "&-out-of-range": {
+          input: {
+            color: f
+          }
+        },
+        "&-group": v(v(v({}, Te(e)), dt(e)), {
+          "&-wrapper": {
+            display: "inline-block",
+            textAlign: "start",
+            verticalAlign: "top",
+            [`${t}-affix-wrapper`]: {
+              width: "100%"
+            },
+            "&-lg": {
+              [`${t}-group-addon`]: {
+                borderRadius: N
+              }
+            },
+            "&-sm": {
+              [`${t}-group-addon`]: {
+                borderRadius: O
+              }
+            }
+          }
+        }),
+        [t]: {
+          "&-input": v(v({
+            width: "100%",
+            height: $ - 2 * n,
+            padding: `0 ${E}px`,
+            textAlign: "start",
+            backgroundColor: "transparent",
+            border: 0,
+            borderRadius: o,
+            outline: 0,
+            transition: `all ${S} linear`,
+            appearance: "textfield",
+            color: e.colorText,
+            fontSize: "inherit",
+            verticalAlign: "top"
+          }, ct(e.colorTextPlaceholder)), {
+            '&[type="number"]::-webkit-inner-spin-button, &[type="number"]::-webkit-outer-spin-button': {
+              margin: 0,
+              webkitAppearance: "none",
+              appearance: "none"
+            }
+          })
+        }
+      })
+    },
+    {
+      [t]: {
+        [`&:hover ${t}-handler-wrap, &-focused ${t}-handler-wrap`]: {
+          opacity: 1
+        },
+        [`${t}-handler-wrap`]: {
+          position: "absolute",
+          insetBlockStart: 0,
+          insetInlineEnd: 0,
+          width: e.handleWidth,
+          height: "100%",
+          background: D,
+          borderStartStartRadius: 0,
+          borderStartEndRadius: o,
+          borderEndEndRadius: o,
+          borderEndStartRadius: 0,
+          opacity: T === !0 ? 1 : 0,
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "stretch",
+          transition: `opacity ${S} linear ${S}`,
+          [`${t}-handler`]: {
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            flex: "auto",
+            height: "40%",
+            [`
+              ${t}-handler-up-inner,
+              ${t}-handler-down-inner
+            `]: {
+              marginInlineEnd: 0,
+              fontSize: e.handleFontSize
+            }
+          }
+        },
+        [`${t}-handler`]: {
+          height: "50%",
+          overflow: "hidden",
+          color: w,
+          fontWeight: "bold",
+          lineHeight: 0,
+          textAlign: "center",
+          cursor: "pointer",
+          borderInlineStart: `${n}px ${a} ${l}`,
+          transition: `all ${S} linear`,
+          "&:active": {
+            background: e.colorFillAlter
+          },
+          "&:hover": {
+            height: "60%",
+            [`
+              ${t}-handler-up-inner,
+              ${t}-handler-down-inner
+            `]: {
+              color: I
+            }
+          },
+          "&-up-inner, &-down-inner": v(v({}, ft()), {
+            color: w,
+            transition: `all ${S} linear`,
+            userSelect: "none"
+          })
+        },
+        [`${t}-handler-up`]: {
+          borderStartEndRadius: o
+        },
+        [`${t}-handler-down`]: {
+          borderBlockStart: `${n}px ${a} ${l}`,
+          borderEndEndRadius: o
+        },
+        "&-disabled, &-readonly": {
+          [`${t}-handler-wrap`]: {
+            display: "none"
+          }
+        },
+        [`
+          ${t}-handler-up-disabled,
+          ${t}-handler-down-disabled
+        `]: {
+          cursor: "not-allowed"
+        },
+        [`
+          ${t}-handler-up-disabled:hover &-handler-up-inner,
+          ${t}-handler-down-disabled:hover &-handler-down-inner
+        `]: {
+          color: C
+        }
+      }
+    },
+    {
+      [`${t}-borderless`]: {
+        borderColor: "transparent",
+        boxShadow: "none",
+        [`${t}-handler-down`]: {
+          borderBlockStartWidth: 0
+        }
+      }
+    }
+  ];
+}, At = (e) => {
+  const {
+    componentCls: t,
+    inputPaddingHorizontal: n,
+    inputAffixPadding: a,
+    controlWidth: l,
+    borderRadiusLG: o,
+    borderRadiusSM: d
+  } = e;
+  return {
+    [`${t}-affix-wrapper`]: v(v(v({}, He(e)), Ue(e, `${t}-affix-wrapper`)), {
+      position: "relative",
+      display: "inline-flex",
+      width: l,
+      padding: 0,
+      paddingInlineStart: n,
+      "&-lg": {
+        borderRadius: o
+      },
+      "&-sm": {
+        borderRadius: d
+      },
+      [`&:not(${t}-affix-wrapper-disabled):hover`]: v(v({}, Ge(e)), {
+        zIndex: 1
+      }),
+      "&-focused, &:focus": {
+        zIndex: 1
+      },
+      "&-disabled": {
+        [`${t}[disabled]`]: {
+          background: "transparent"
+        }
+      },
+      [`> div${t}`]: {
+        width: "100%",
+        border: "none",
+        outline: "none",
+        [`&${t}-focused`]: {
+          boxShadow: "none !important"
+        }
+      },
+      [`input${t}-input`]: {
+        padding: 0
+      },
+      "&::before": {
+        width: 0,
+        visibility: "hidden",
+        content: '"\\a0"'
+      },
+      [`${t}-handler-wrap`]: {
+        zIndex: 2
+      },
+      [t]: {
+        "&-prefix, &-suffix": {
+          display: "flex",
+          flex: "none",
+          alignItems: "center",
+          pointerEvents: "none"
+        },
+        "&-prefix": {
+          marginInlineEnd: a
+        },
+        "&-suffix": {
+          position: "absolute",
+          insetBlockStart: 0,
+          insetInlineEnd: 0,
+          zIndex: 1,
+          height: "100%",
+          marginInlineEnd: n,
+          marginInlineStart: a
+        }
+      }
+    })
+  };
+}, Tt = lt("InputNumber", (e) => {
+  const t = it(e);
+  return [
+    Rt(t),
+    At(t),
+    ot(t)
+  ];
+}, (e) => ({
+  controlWidth: 90,
+  handleWidth: e.controlHeightSM - e.lineWidth * 2,
+  handleFontSize: e.fontSize / 2,
+  handleVisible: "auto"
+}));
+var Vt = globalThis && globalThis.__rest || function(e, t) {
+  var n = {};
+  for (var a in e)
+    Object.prototype.hasOwnProperty.call(e, a) && t.indexOf(a) < 0 && (n[a] = e[a]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var l = 0, a = Object.getOwnPropertySymbols(e); l < a.length; l++)
+      t.indexOf(a[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, a[l]) && (n[a[l]] = e[a[l]]);
+  return n;
+};
+const We = Xe(), Bt = () => v(v({}, We), {
+  size: ye(),
+  bordered: F(!0),
+  placeholder: String,
+  name: String,
+  id: String,
+  type: String,
+  addonBefore: Se.any,
+  addonAfter: Se.any,
+  prefix: Se.any,
+  "onUpdate:value": We.onChange,
+  valueModifiers: Object,
+  status: ye()
+}), Ne = Ie({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "AInputNumber",
+  inheritAttrs: !1,
+  props: Bt(),
+  slots: Object,
+  setup(e, t) {
+    let {
+      emit: n,
+      expose: a,
+      attrs: l,
+      slots: o
+    } = t;
+    var d;
+    const c = pt(), m = mt.useInject(), f = W(() => gt(m.status, e.status)), {
+      prefixCls: s,
+      size: w,
+      direction: S,
+      disabled: I
+    } = vt("input-number", e), {
+      compactSize: $,
+      compactItemClassnames: E
+    } = ht(s, S), D = bt(), C = W(() => {
+      var b;
+      return (b = I.value) !== null && b !== void 0 ? b : D.value;
+    }), [O, N] = Tt(s), x = W(() => $.value || w.value), T = _((d = e.value) !== null && d !== void 0 ? d : e.defaultValue), k = _(!1);
+    te(() => e.value, () => {
+      T.value = e.value;
+    });
+    const X = _(null), K = () => {
+      var b;
+      (b = X.value) === null || b === void 0 || b.focus();
+    };
+    a({
+      focus: K,
+      blur: () => {
+        var b;
+        (b = X.value) === null || b === void 0 || b.blur();
+      }
+    });
+    const Y = (b) => {
+      e.value === void 0 && (T.value = b), n("update:value", b), n("change", b), c.onFieldChange();
+    }, oe = (b) => {
+      k.value = !1, n("blur", b), c.onFieldBlur();
+    }, Q = (b) => {
+      k.value = !0, n("focus", b);
+    };
+    return () => {
+      var b, Z, H, U;
+      const {
+        hasFeedback: V,
+        isFormItemInput: se,
+        feedbackIcon: ue
+      } = m, de = (b = e.id) !== null && b !== void 0 ? b : c.id.value, r = v(v(v({}, l), e), {
+        id: de,
+        disabled: C.value
+      }), {
+        class: i,
+        bordered: u,
+        readonly: g,
+        style: y,
+        addonBefore: M = (Z = o.addonBefore) === null || Z === void 0 ? void 0 : Z.call(o),
+        addonAfter: B = (H = o.addonAfter) === null || H === void 0 ? void 0 : H.call(o),
+        prefix: J = (U = o.prefix) === null || U === void 0 ? void 0 : U.call(o),
+        valueModifiers: re = {}
+      } = r, _e = Vt(r, ["class", "bordered", "readonly", "style", "addonBefore", "addonAfter", "prefix", "valueModifiers"]), p = s.value, ce = j({
+        [`${p}-lg`]: x.value === "large",
+        [`${p}-sm`]: x.value === "small",
+        [`${p}-rtl`]: S.value === "rtl",
+        [`${p}-readonly`]: g,
+        [`${p}-borderless`]: !u,
+        [`${p}-in-form-item`]: se
+      }, be(p, f.value), i, E.value, N.value);
+      let G = h(Mt, A(A({}, St(_e, ["size", "defaultValue"])), {}, {
+        ref: X,
+        lazy: !!re.lazy,
+        value: T.value,
+        class: ce,
+        prefixCls: p,
+        readonly: g,
+        onChange: Y,
+        onBlur: oe,
+        onFocus: Q
+      }), {
+        upHandler: o.upIcon ? () => h("span", {
+          class: `${p}-handler-up-inner`
+        }, [o.upIcon()]) : () => h(It, {
+          class: `${p}-handler-up-inner`
+        }, null),
+        downHandler: o.downIcon ? () => h("span", {
+          class: `${p}-handler-down-inner`
+        }, [o.downIcon()]) : () => h($t, {
+          class: `${p}-handler-down-inner`
+        }, null)
+      });
+      const fe = $e(M) || $e(B), pe = $e(J);
+      if (pe || V) {
+        const L = j(`${p}-affix-wrapper`, be(`${p}-affix-wrapper`, f.value, V), {
+          [`${p}-affix-wrapper-focused`]: k.value,
+          [`${p}-affix-wrapper-disabled`]: C.value,
+          [`${p}-affix-wrapper-sm`]: x.value === "small",
+          [`${p}-affix-wrapper-lg`]: x.value === "large",
+          [`${p}-affix-wrapper-rtl`]: S.value === "rtl",
+          [`${p}-affix-wrapper-readonly`]: g,
+          [`${p}-affix-wrapper-borderless`]: !u,
+          [`${i}`]: !fe && i
+        }, N.value);
+        G = h("div", {
+          class: L,
+          style: y,
+          onClick: K
+        }, [pe && h("span", {
+          class: `${p}-prefix`
+        }, [J]), G, V && h("span", {
+          class: `${p}-suffix`
+        }, [ue])]);
+      }
+      if (fe) {
+        const L = `${p}-group`, me = `${L}-addon`, ge = M ? h("div", {
+          class: me
+        }, [M]) : null, ve = B ? h("div", {
+          class: me
+        }, [B]) : null, De = j(`${p}-wrapper`, L, {
+          [`${L}-rtl`]: S.value === "rtl"
+        }, N.value), Me = j(`${p}-group-wrapper`, {
+          [`${p}-group-wrapper-sm`]: x.value === "small",
+          [`${p}-group-wrapper-lg`]: x.value === "large",
+          [`${p}-group-wrapper-rtl`]: S.value === "rtl"
+        }, be(`${s}-group-wrapper`, f.value, V), i, N.value);
+        G = h("div", {
+          class: Me,
+          style: y
+        }, [h("div", {
+          class: De
+        }, [ge && h(Ve, null, {
+          default: () => [h(Be, null, {
+            default: () => [ge]
+          })]
+        }), G, ve && h(Ve, null, {
+          default: () => [h(Be, null, {
+            default: () => [ve]
+          })]
+        })])]);
+      }
+      return O(Nt(G, {
+        style: y
+      }));
+    };
+  }
+}), jt = v(Ne, {
+  install: (e) => (e.component(Ne.name, Ne), e)
+});
+export {
+  jt as _
+};