@witlink/usercenter 1.0.0

package/dist/index.ceea88a4.mjs

@@ -0,0 +1,1073 @@
+import { aj as nt, v as R, b3 as rt, e as z, f as A, T as at, R as Ae, d as v, t as F, am as ee, w as ye, al as le, j as lt, b4 as it, b5 as ot, r as Te, b6 as He, b7 as Ge, b8 as Ue, b9 as st, ba as ut, bb as dt, bc as ct, bd as ft, u as pt, n as mt, be as gt, p as vt, bf as bt, o as ht, bg as he, q as St, ai as $t, bh as Ve, bi as Be, bj as Nt, P as Se } from "./index.003313e6.mjs";
+import { createVNode as b, 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]) : {}, r = Object.keys(n);
+    typeof Object.getOwnPropertySymbols == "function" && (r = r.concat(Object.getOwnPropertySymbols(n).filter(function(l) {
+      return Object.getOwnPropertyDescriptor(n, l).enumerable;
+    }))), r.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 r = Fe({}, t, n.attrs);
+  return b(nt, Fe({}, r, {
+    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 r = t || "0", l = r.split("."), o = l[0] || "0", d = l[1] || "0";
+  o === "0" && d === "0" && (n = !1);
+  const c = n ? "-" : "";
+  return {
+    negative: n,
+    negativeStr: c,
+    trimStr: r,
+    integerStr: o,
+    decimalStr: d,
+    fullStr: `${c}${r}`
+  };
+}
+function Ce(e) {
+  const t = String(e);
+  return !Number.isNaN(Number(t)) && t.includes("e");
+}
+function re(e) {
+  const t = String(e);
+  if (Ce(e)) {
+    let n = Number(t.slice(t.indexOf("e-") + 2));
+    const r = t.match(/\.(\d+)/);
+    return r != null && r[1] && (n += r[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(re(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 j {
+  constructor(t) {
+    if (this.origin = "", ke(t)) {
+      this.empty = !0;
+      return;
+    }
+    this.origin = String(t), this.number = Number(t);
+  }
+  negate() {
+    return new j(-this.toNumber());
+  }
+  add(t) {
+    if (this.isInvalidate())
+      return new j(t);
+    const n = Number(t);
+    if (Number.isNaN(n))
+      return this;
+    const r = this.number + n;
+    if (r > Number.MAX_SAFE_INTEGER)
+      return new j(Number.MAX_SAFE_INTEGER);
+    if (r < Number.MIN_SAFE_INTEGER)
+      return new j(Number.MIN_SAFE_INTEGER);
+    const l = Math.max(re(this.number), re(n));
+    return new j(r.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 r = ne(n);
+      this.negative = r.negative;
+      const l = r.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 r = Math.max(this.getDecimalStr().length, n.getDecimalStr().length), l = this.alignDecimal(r), o = n.alignDecimal(r), d = (l + o).toString(), {
+      negativeStr: c,
+      trimStr: m
+    } = ne(d), f = `${c}${m.padStart(r + 1, "0")}`;
+    return new q(`${f.slice(0, -r)}.${f.slice(-r)}`);
+  }
+  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 j(e);
+}
+function xe(e, t, n) {
+  let r = 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 && !r) {
+      const s = P(e).add(`${l}0.${"0".repeat(n)}${10 - f}`);
+      return xe(s.toString(), t, n, r);
+    }
+    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: r
+    } = t;
+    const l = Le(), o = (c, m) => {
+      c.preventDefault(), r("step", m);
+      function f() {
+        r("step", m), l.value = setTimeout(f, Et);
+      }
+      l.value = setTimeout(f, Ct);
+    }, d = () => {
+      clearTimeout(l.value);
+    };
+    return qe(() => {
+      d();
+    }), () => {
+      if (rt())
+        return null;
+      const {
+        prefixCls: c,
+        upDisabled: m,
+        downDisabled: f
+      } = e, s = `${c}-handler`, w = z(s, `${s}-up`, {
+        [`${s}-up-disabled`]: m
+      }), S = z(s, `${s}-down`, {
+        [`${s}-down-disabled`]: f
+      }), I = {
+        unselectable: "on",
+        role: "button",
+        onMouseup: d,
+        onMouseleave: d
+      }, {
+        upNode: $,
+        downNode: E
+      } = n;
+      return b("div", {
+        class: `${s}-wrap`
+      }, [b("span", A(A({}, I), {}, {
+        onMousedown: (D) => {
+          o(D, !0);
+        },
+        "aria-label": "Increase Value",
+        "aria-disabled": m,
+        class: w
+      }), [($ == null ? void 0 : $()) || b("span", {
+        unselectable: "on",
+        class: `${c}-handler-up-inner`
+      }, null)]), b("span", A(A({}, I), {}, {
+        onMousedown: (D) => {
+          o(D, !1);
+        },
+        "aria-label": "Decrease Value",
+        "aria-disabled": f,
+        class: S
+      }), [(E == null ? void 0 : E()) || b("span", {
+        unselectable: "on",
+        class: `${c}-handler-down-inner`
+      }, null)])]);
+    };
+  }
+});
+function Pt(e, t) {
+  const n = Le(null);
+  function r() {
+    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) {
+        at(!1, `Something warning of cursor restore. Please fire issue about this: ${o.message}`);
+      }
+  }
+  return [r, 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 r in e)
+    Object.prototype.hasOwnProperty.call(e, r) && t.indexOf(r) < 0 && (n[r] = e[r]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var l = 0, r = Object.getOwnPropertySymbols(e); l < r.length; l++)
+      t.indexOf(r[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, r[l]) && (n[r[l]] = e[r[l]]);
+  return n;
+};
+const je = (e, t) => e || t.isEmpty() ? t.toString() : t.toNumber(), ze = (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: r,
+      emit: l,
+      expose: o
+    } = t;
+    const d = _(), c = _(!1), m = _(!1), f = _(!1), s = _(P(e.value));
+    function w(a) {
+      e.value === void 0 && (s.value = a);
+    }
+    const S = (a, i) => {
+      if (!i)
+        return e.precision >= 0 ? e.precision : Math.max(re(a), re(e.step));
+    }, I = (a) => {
+      const i = String(a);
+      if (e.parser)
+        return e.parser(i);
+      let u = i;
+      return e.decimalSeparator && (u = u.replace(e.decimalSeparator, ".")), u.replace(/[^\w.-]+/g, "");
+    }, $ = _(""), E = (a, i) => {
+      if (e.formatter)
+        return e.formatter(a, {
+          userTyping: i,
+          input: String($.value)
+        });
+      let u = typeof a == "number" ? Oe(a) : a;
+      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 a = e.value;
+      return s.value.isInvalidate() && ["string", "number"].includes(typeof a) ? Number.isNaN(a) ? "" : a : E(s.value.toString(), !1);
+    })();
+    $.value = D;
+    function C(a, i) {
+      $.value = E(
+        a.isInvalidate() ? a.toString(!1) : a.toString(!i),
+        i
+      );
+    }
+    const O = W(() => ze(e.max)), N = W(() => ze(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 = (a) => O.value && !a.lessEquals(O.value) ? O.value : N.value && !N.value.lessEquals(a) ? N.value : null, ie = (a) => !K(a), Y = (a, i) => {
+      var u;
+      let g = a, 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 : je(e.stringMode, g)), e.value === void 0 && C(g, i)), g;
+      }
+      return s.value;
+    }, oe = _t(), J = (a) => {
+      var i;
+      if (k(), $.value = a, !f.value) {
+        const u = I(a), g = P(u);
+        g.isNaN() || Y(g, !0);
+      }
+      (i = e.onInput) === null || i === void 0 || i.call(e, a), oe(() => {
+        let u = a;
+        e.parser || (u = a.replace(/。/g, ".")), u !== a && J(u);
+      });
+    }, h = () => {
+      f.value = !0;
+    }, Q = () => {
+      f.value = !1, J(d.value.value);
+    }, H = (a) => {
+      J(a.target.value);
+    }, G = (a) => {
+      var i, u;
+      if (a && x.value || !a && T.value)
+        return;
+      m.value = !1;
+      let g = P(e.step);
+      a || (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, je(e.stringMode, M), {
+        offset: e.step,
+        type: a ? "up" : "down"
+      }), (u = d.value) === null || u === void 0 || u.focus();
+    }, V = (a) => {
+      const i = P(I($.value));
+      let u = i;
+      i.isNaN() ? u = s.value : u = Y(i, a), e.value !== void 0 ? C(s.value, !1) : u.isNaN() || C(u, !1);
+    }, se = (a) => {
+      var i;
+      const {
+        which: u
+      } = a;
+      m.value = !0, u === le.ENTER && (f.value || (m.value = !1), V(!1), (i = e.onPressEnter) === null || i === void 0 || i.call(e, a)), e.keyboard !== !1 && !f.value && [le.UP, le.DOWN].includes(u) && (G(le.UP === u), a.preventDefault());
+    }, ue = () => {
+      m.value = !1;
+    }, de = (a) => {
+      V(!1), c.value = !1, m.value = !1, l("blur", a);
+    };
+    return te(() => e.precision, () => {
+      s.value.isInvalidate() || C(s.value, !1);
+    }, {
+      flush: "post"
+    }), te(() => e.value, () => {
+      const a = P(e.value);
+      s.value = a;
+      const i = P(I($.value));
+      (!a.equals(i) || !m.value || e.formatter) && C(a, m.value);
+    }, {
+      flush: "post"
+    }), te($, () => {
+      e.formatter && X();
+    }, {
+      flush: "post"
+    }), te(() => e.disabled, (a) => {
+      a && (c.value = !1);
+    }), o({
+      focus: () => {
+        var a;
+        (a = d.value) === null || a === void 0 || a.focus();
+      },
+      blur: () => {
+        var a;
+        (a = d.value) === null || a === void 0 || a.blur();
+      }
+    }), () => {
+      const a = v(v({}, n), e), {
+        prefixCls: i = "rc-input-number",
+        min: u,
+        max: g,
+        step: y = 1,
+        defaultValue: M,
+        value: B,
+        disabled: Z,
+        readonly: ae,
+        keyboard: _e,
+        controls: p = !0,
+        autofocus: ce,
+        stringMode: U,
+        parser: fe,
+        formatter: pe,
+        precision: L,
+        decimalSeparator: me,
+        onChange: ge,
+        onInput: ve,
+        onPressEnter: De,
+        onStep: Me,
+        lazy: Ke,
+        class: Ye,
+        style: Je
+      } = a, Qe = Dt(a, ["prefixCls", "min", "max", "step", "defaultValue", "value", "disabled", "readonly", "keyboard", "controls", "autofocus", "stringMode", "parser", "formatter", "precision", "decimalSeparator", "onChange", "onInput", "onPressEnter", "onStep", "lazy", "class", "style"]), {
+        upHandler: Ze,
+        downHandler: et
+      } = r, Re = `${i}-input`, be = {};
+      return Ke ? be.onChange = H : be.onInput = H, b("div", {
+        class: z(i, Ye, {
+          [`${i}-focused`]: c.value,
+          [`${i}-disabled`]: Z,
+          [`${i}-readonly`]: ae,
+          [`${i}-not-a-number`]: s.value.isNaN(),
+          [`${i}-out-of-range`]: !s.value.isInvalidate() && !ie(s.value)
+        }),
+        style: Je,
+        onKeydown: se,
+        onKeyup: ue
+      }, [p && b(Ot, {
+        prefixCls: i,
+        upDisabled: x.value,
+        downDisabled: T.value,
+        onStep: G
+      }, {
+        upNode: Ze,
+        downNode: et
+      }), b("div", {
+        class: `${Re}-wrap`
+      }, [b("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
+      }, Qe), {}, {
+        ref: d,
+        class: Re,
+        value: $.value,
+        disabled: Z,
+        readonly: ae,
+        onFocus: (tt) => {
+          c.value = !0, l("focus", tt);
+        }
+      }, be), {}, {
+        onBlur: de,
+        onCompositionstart: h,
+        onCompositionend: Q
+      }), null)])]);
+    };
+  }
+});
+function $e(e) {
+  return e != null;
+}
+const Rt = (e) => {
+  const {
+    componentCls: t,
+    lineWidth: n,
+    lineType: r,
+    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)), Ge(e, t)), {
+        display: "inline-block",
+        width: x,
+        margin: 0,
+        padding: 0,
+        border: `${n}px ${r} ${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({}, Ue(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 ${r} ${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 ${r} ${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: r,
+    controlWidth: l,
+    borderRadiusLG: o,
+    borderRadiusSM: d
+  } = e;
+  return {
+    [`${t}-affix-wrapper`]: v(v(v({}, He(e)), Ge(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({}, Ue(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: r
+        },
+        "&-suffix": {
+          position: "absolute",
+          insetBlockStart: 0,
+          insetInlineEnd: 0,
+          zIndex: 1,
+          height: "100%",
+          marginInlineEnd: n,
+          marginInlineStart: r
+        }
+      }
+    })
+  };
+}, 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 r in e)
+    Object.prototype.hasOwnProperty.call(e, r) && t.indexOf(r) < 0 && (n[r] = e[r]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var l = 0, r = Object.getOwnPropertySymbols(e); l < r.length; l++)
+      t.indexOf(r[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, r[l]) && (n[r[l]] = e[r[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: r,
+      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
+    } = bt(s, S), D = ht(), C = W(() => {
+      var h;
+      return (h = I.value) !== null && h !== void 0 ? h : 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 h;
+      (h = X.value) === null || h === void 0 || h.focus();
+    };
+    r({
+      focus: K,
+      blur: () => {
+        var h;
+        (h = X.value) === null || h === void 0 || h.blur();
+      }
+    });
+    const Y = (h) => {
+      e.value === void 0 && (T.value = h), n("update:value", h), n("change", h), c.onFieldChange();
+    }, oe = (h) => {
+      k.value = !1, n("blur", h), c.onFieldBlur();
+    }, J = (h) => {
+      k.value = !0, n("focus", h);
+    };
+    return () => {
+      var h, Q, H, G;
+      const {
+        hasFeedback: V,
+        isFormItemInput: se,
+        feedbackIcon: ue
+      } = m, de = (h = e.id) !== null && h !== void 0 ? h : c.id.value, a = v(v(v({}, l), e), {
+        id: de,
+        disabled: C.value
+      }), {
+        class: i,
+        bordered: u,
+        readonly: g,
+        style: y,
+        addonBefore: M = (Q = o.addonBefore) === null || Q === void 0 ? void 0 : Q.call(o),
+        addonAfter: B = (H = o.addonAfter) === null || H === void 0 ? void 0 : H.call(o),
+        prefix: Z = (G = o.prefix) === null || G === void 0 ? void 0 : G.call(o),
+        valueModifiers: ae = {}
+      } = a, _e = Vt(a, ["class", "bordered", "readonly", "style", "addonBefore", "addonAfter", "prefix", "valueModifiers"]), p = s.value, ce = z({
+        [`${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
+      }, he(p, f.value), i, E.value, N.value);
+      let U = b(Mt, A(A({}, St(_e, ["size", "defaultValue"])), {}, {
+        ref: X,
+        lazy: !!ae.lazy,
+        value: T.value,
+        class: ce,
+        prefixCls: p,
+        readonly: g,
+        onChange: Y,
+        onBlur: oe,
+        onFocus: J
+      }), {
+        upHandler: o.upIcon ? () => b("span", {
+          class: `${p}-handler-up-inner`
+        }, [o.upIcon()]) : () => b(It, {
+          class: `${p}-handler-up-inner`
+        }, null),
+        downHandler: o.downIcon ? () => b("span", {
+          class: `${p}-handler-down-inner`
+        }, [o.downIcon()]) : () => b($t, {
+          class: `${p}-handler-down-inner`
+        }, null)
+      });
+      const fe = $e(M) || $e(B), pe = $e(Z);
+      if (pe || V) {
+        const L = z(`${p}-affix-wrapper`, he(`${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);
+        U = b("div", {
+          class: L,
+          style: y,
+          onClick: K
+        }, [pe && b("span", {
+          class: `${p}-prefix`
+        }, [Z]), U, V && b("span", {
+          class: `${p}-suffix`
+        }, [ue])]);
+      }
+      if (fe) {
+        const L = `${p}-group`, me = `${L}-addon`, ge = M ? b("div", {
+          class: me
+        }, [M]) : null, ve = B ? b("div", {
+          class: me
+        }, [B]) : null, De = z(`${p}-wrapper`, L, {
+          [`${L}-rtl`]: S.value === "rtl"
+        }, N.value), Me = z(`${p}-group-wrapper`, {
+          [`${p}-group-wrapper-sm`]: x.value === "small",
+          [`${p}-group-wrapper-lg`]: x.value === "large",
+          [`${p}-group-wrapper-rtl`]: S.value === "rtl"
+        }, he(`${s}-group-wrapper`, f.value, V), i, N.value);
+        U = b("div", {
+          class: Me,
+          style: y
+        }, [b("div", {
+          class: De
+        }, [ge && b(Ve, null, {
+          default: () => [b(Be, null, {
+            default: () => [ge]
+          })]
+        }), U, ve && b(Ve, null, {
+          default: () => [b(Be, null, {
+            default: () => [ve]
+          })]
+        })])]);
+      }
+      return O(Nt(U, {
+        style: y
+      }));
+    };
+  }
+}), zt = v(Ne, {
+  install: (e) => (e.component(Ne.name, Ne), e)
+});
+export {
+  zt as _
+};