z-vue-design 0.0.86 → 0.0.87

package/dist/ZInput-BAvOFELa.mjs

@@ -0,0 +1,1151 @@
+import { createVNode as b, defineComponent as Pe, ref as ke, onBeforeUnmount as qe, shallowRef as O, computed as j, watch as ee, mergeModels as it, useModel as ot, resolveComponent as Se, createBlock as $e, openBlock as Ne, mergeProps as Te } from "vue";
+import { I as st, f as A, c as W, a as R, w as ut, b as Fe, d as v, e as F, s as Q, g as Ee, K as ie, h as dt, i as ct, r as ze, j as ft, u as pt, F as mt, k as gt, l as vt, m as bt, o as ht, N as je, n as We, p as St, P as ye, _ as $t } from "./index-NxjGmddr.mjs";
+import { a as Nt, I as yt } from "./index-BMe1eySH.mjs";
+import { i as It, D as wt } from "./DownOutlined-DLt_M1C6.mjs";
+import { g as xt, a as Ie } from "./statusUtils-Dk_VID6p.mjs";
+import { i as Et, g as Ke, a as Xe, b as Ct, c as _t, d as Pt, e as Ot, f as Ze } from "./index-C5EmjaZ2.mjs";
+var Mt = { 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" };
+function He(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) {
+      Dt(e, l, n[l]);
+    });
+  }
+  return e;
+}
+function Dt(e, t, n) {
+  return t in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
+}
+var Oe = function(t, n) {
+  var a = He({}, t, n.attrs);
+  return b(st, He({}, a, {
+    icon: Mt
+  }), null);
+};
+Oe.displayName = "UpOutlined";
+Oe.inheritAttrs = !1;
+function Ce() {
+  return typeof BigInt == "function";
+}
+function te(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("."), i = l[0] || "0", c = l[1] || "0";
+  i === "0" && c === "0" && (n = !1);
+  const f = n ? "-" : "";
+  return {
+    negative: n,
+    negativeStr: f,
+    trimStr: a,
+    integerStr: i,
+    decimalStr: c,
+    fullStr: `${f}${a}`
+  };
+}
+function Me(e) {
+  const t = String(e);
+  return !Number.isNaN(Number(t)) && t.includes("e");
+}
+function ne(e) {
+  const t = String(e);
+  if (Me(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(".") && Ae(t) ? t.length - t.indexOf(".") - 1 : 0;
+}
+function De(e) {
+  let t = String(e);
+  if (Me(e)) {
+    if (e > Number.MAX_SAFE_INTEGER)
+      return String(Ce() ? BigInt(e).toString() : Number.MAX_SAFE_INTEGER);
+    if (e < Number.MIN_SAFE_INTEGER)
+      return String(Ce() ? BigInt(e).toString() : Number.MIN_SAFE_INTEGER);
+    t = e.toFixed(ne(t));
+  }
+  return te(t).fullStr;
+}
+function Ae(e) {
+  return typeof e == "number" ? !Number.isNaN(e) : e ? (
+    // Normal type: 11.28
+    /^\s*-?\d+(\.\d+)?\s*$/.test(e) || // Pre-number: 1.
+    /^\s*-?\d+\.\s*$/.test(e) || // Post-number: .1
+    /^\s*-?\.\d+\s*$/.test(e)
+  ) : !1;
+}
+function Ye(e) {
+  return !e && e !== 0 && !Number.isNaN(e) || !String(e).trim();
+}
+class z {
+  constructor(t) {
+    if (this.origin = "", Ye(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(ne(this.number), ne(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() ? "" : De(this.number) : this.origin;
+  }
+}
+class k {
+  constructor(t) {
+    if (this.origin = "", Ye(t)) {
+      this.empty = !0;
+      return;
+    }
+    if (this.origin = String(t), t === "-" || Number.isNaN(t)) {
+      this.nan = !0;
+      return;
+    }
+    let n = t;
+    if (Me(n) && (n = Number(n)), n = typeof n == "string" ? n : De(n), Ae(n)) {
+      const a = te(n);
+      this.negative = a.negative;
+      const l = a.trimStr.split(".");
+      this.integer = BigInt(l[0]);
+      const i = l[1] || "0";
+      this.decimal = BigInt(i), this.decimalLen = i.length;
+    } else
+      this.nan = !0;
+  }
+  getMark() {
+    return this.negative ? "-" : "";
+  }
+  getIntegerStr() {
+    return this.integer.toString();
+  }
+  getDecimalStr() {
+    return this.decimal.toString().padStart(this.decimalLen, "0");
+  }
+  /**
+   * Align BigIntDecimal with same decimal length. e.g. 12.3 + 5 = 1230000
+   * This is used for add function only.
+   */
+  alignDecimal(t) {
+    const n = `${this.getMark()}${this.getIntegerStr()}${this.getDecimalStr().padEnd(t, "0")}`;
+    return BigInt(n);
+  }
+  negate() {
+    const t = new k(this.toString());
+    return t.negative = !t.negative, t;
+  }
+  add(t) {
+    if (this.isInvalidate())
+      return new k(t);
+    const n = new k(t);
+    if (n.isInvalidate())
+      return this;
+    const a = Math.max(this.getDecimalStr().length, n.getDecimalStr().length), l = this.alignDecimal(a), i = n.alignDecimal(a), c = (l + i).toString(), {
+      negativeStr: f,
+      trimStr: d
+    } = te(c), p = `${f}${d.padStart(a + 1, "0")}`;
+    return new k(`${p.slice(0, -a)}.${p.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() ? "" : te(`${this.getMark()}${this.getIntegerStr()}.${this.getDecimalStr()}`).fullStr : this.origin;
+  }
+}
+function P(e) {
+  return Ce() ? new k(e) : new z(e);
+}
+function _e(e, t, n) {
+  let a = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : !1;
+  if (e === "")
+    return "";
+  const {
+    negativeStr: l,
+    integerStr: i,
+    decimalStr: c
+  } = te(e), f = `${t}${c}`, d = `${l}${i}`;
+  if (n >= 0) {
+    const p = Number(c[n]);
+    if (p >= 5 && !a) {
+      const s = P(e).add(`${l}0.${"0".repeat(n)}${10 - p}`);
+      return _e(s.toString(), t, n, a);
+    }
+    return n === 0 ? d : `${d}${t}${c.padEnd(n, "0").slice(0, n)}`;
+  }
+  return f === ".0" ? d : `${d}${f}`;
+}
+const At = 200, Rt = 600, Vt = Pe({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "StepHandler",
+  inheritAttrs: !1,
+  props: {
+    prefixCls: String,
+    upDisabled: Boolean,
+    downDisabled: Boolean,
+    onStep: A()
+  },
+  slots: Object,
+  setup(e, t) {
+    let {
+      slots: n,
+      emit: a
+    } = t;
+    const l = ke(), i = (f, d) => {
+      f.preventDefault(), a("step", d);
+      function p() {
+        a("step", d), l.value = setTimeout(p, At);
+      }
+      l.value = setTimeout(p, Rt);
+    }, c = () => {
+      clearTimeout(l.value);
+    };
+    return qe(() => {
+      c();
+    }), () => {
+      if (It())
+        return null;
+      const {
+        prefixCls: f,
+        upDisabled: d,
+        downDisabled: p
+      } = e, s = `${f}-handler`, I = W(s, `${s}-up`, {
+        [`${s}-up-disabled`]: d
+      }), S = W(s, `${s}-down`, {
+        [`${s}-down-disabled`]: p
+      }), x = {
+        unselectable: "on",
+        role: "button",
+        onMouseup: c,
+        onMouseleave: c
+      }, {
+        upNode: $,
+        downNode: E
+      } = n;
+      return b("div", {
+        class: `${s}-wrap`
+      }, [b("span", R(R({}, x), {}, {
+        onMousedown: (M) => {
+          i(M, !0);
+        },
+        "aria-label": "Increase Value",
+        "aria-disabled": d,
+        class: I
+      }), [($ == null ? void 0 : $()) || b("span", {
+        unselectable: "on",
+        class: `${f}-handler-up-inner`
+      }, null)]), b("span", R(R({}, x), {}, {
+        onMousedown: (M) => {
+          i(M, !1);
+        },
+        "aria-label": "Decrease Value",
+        "aria-disabled": p,
+        class: S
+      }), [(E == null ? void 0 : E()) || b("span", {
+        unselectable: "on",
+        class: `${f}-handler-down-inner`
+      }, null)])]);
+    };
+  }
+});
+function Bt(e, t) {
+  const n = ke(null);
+  function a() {
+    try {
+      const {
+        selectionStart: i,
+        selectionEnd: c,
+        value: f
+      } = e.value, d = f.substring(0, i), p = f.substring(c);
+      n.value = {
+        start: i,
+        end: c,
+        value: f,
+        beforeTxt: d,
+        afterTxt: p
+      };
+    } catch {
+    }
+  }
+  function l() {
+    if (e.value && n.value && t.value)
+      try {
+        const {
+          value: i
+        } = e.value, {
+          beforeTxt: c,
+          afterTxt: f,
+          start: d
+        } = n.value;
+        let p = i.length;
+        if (i.endsWith(f))
+          p = i.length - n.value.afterTxt.length;
+        else if (i.startsWith(c))
+          p = c.length;
+        else {
+          const s = c[d - 1], I = i.indexOf(s, d - 1);
+          I !== -1 && (p = I + 1);
+        }
+        e.value.setSelectionRange(p, p);
+      } catch (i) {
+        ut(!1, `Something warning of cursor restore. Please fire issue about this: ${i.message}`);
+      }
+  }
+  return [a, l];
+}
+const Tt = () => {
+  const e = O(0), t = () => {
+    Fe.cancel(e.value);
+  };
+  return qe(() => {
+    t();
+  }), (n) => {
+    t(), e.value = Fe(() => {
+      n();
+    });
+  };
+};
+var Ft = 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 Ue = (e, t) => e || t.isEmpty() ? t.toString() : t.toNumber(), Ge = (e) => {
+  const t = P(e);
+  return t.isInvalidate() ? null : t;
+}, Je = () => ({
+  /** value will show as string */
+  stringMode: F(),
+  defaultValue: Q([String, Number]),
+  value: Q([String, Number]),
+  prefixCls: Ee(),
+  min: Q([String, Number]),
+  max: Q([String, Number]),
+  step: Q([String, Number], 1),
+  tabindex: Number,
+  controls: F(!0),
+  readonly: F(),
+  disabled: F(),
+  autofocus: F(),
+  keyboard: F(!0),
+  /** Parse display value to validate number */
+  parser: A(),
+  /** Transform `value` to display value show in input */
+  formatter: A(),
+  /** Syntactic sugar of `formatter`. Config precision of display. */
+  precision: Number,
+  /** Syntactic sugar of `formatter`. Config decimal separator of display. */
+  decimalSeparator: String,
+  onInput: A(),
+  onChange: A(),
+  onPressEnter: A(),
+  onStep: A(),
+  onBlur: A(),
+  onFocus: A()
+}), zt = Pe({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "InnerInputNumber",
+  inheritAttrs: !1,
+  props: v(v({}, Je()), {
+    lazy: Boolean
+  }),
+  slots: Object,
+  setup(e, t) {
+    let {
+      attrs: n,
+      slots: a,
+      emit: l,
+      expose: i
+    } = t;
+    const c = O(), f = O(!1), d = O(!1), p = O(!1), s = O(P(e.value));
+    function I(r) {
+      e.value === void 0 && (s.value = r);
+    }
+    const S = (r, o) => {
+      if (!o)
+        return e.precision >= 0 ? e.precision : Math.max(ne(r), ne(e.step));
+    }, x = (r) => {
+      const o = String(r);
+      if (e.parser)
+        return e.parser(o);
+      let u = o;
+      return e.decimalSeparator && (u = u.replace(e.decimalSeparator, ".")), u.replace(/[^\w.-]+/g, "");
+    }, $ = O(""), E = (r, o) => {
+      if (e.formatter)
+        return e.formatter(r, {
+          userTyping: o,
+          input: String($.value)
+        });
+      let u = typeof r == "number" ? De(r) : r;
+      if (!o) {
+        const m = S(u, o);
+        if (Ae(u) && (e.decimalSeparator || m >= 0)) {
+          const y = e.decimalSeparator || ".";
+          u = _e(u, y, m);
+        }
+      }
+      return u;
+    }, M = (() => {
+      const r = e.value;
+      return s.value.isInvalidate() && ["string", "number"].includes(typeof r) ? Number.isNaN(r) ? "" : r : E(s.value.toString(), !1);
+    })();
+    $.value = M;
+    function C(r, o) {
+      $.value = E(
+        // Invalidate number is sometime passed by external control, we should let it go
+        // Otherwise is controlled by internal interactive logic which check by userTyping
+        // You can ref 'show limited value when input is not focused' test for more info.
+        r.isInvalidate() ? r.toString(!1) : r.toString(!o),
+        o
+      );
+    }
+    const _ = j(() => Ge(e.max)), N = j(() => Ge(e.min)), w = j(() => !_.value || !s.value || s.value.isInvalidate() ? !1 : _.value.lessEquals(s.value)), V = j(() => !N.value || !s.value || s.value.isInvalidate() ? !1 : s.value.lessEquals(N.value)), [q, K] = Bt(c, f), X = (r) => _.value && !r.lessEquals(_.value) ? _.value : N.value && !N.value.lessEquals(r) ? N.value : null, oe = (r) => !X(r), Z = (r, o) => {
+      var u;
+      let m = r, y = oe(m) || m.isEmpty();
+      if (!m.isEmpty() && !o && (m = X(m) || m, y = !0), !e.readonly && !e.disabled && y) {
+        const D = m.toString(), G = S(D, o);
+        return G >= 0 && (m = P(_e(D, ".", G))), m.equals(s.value) || (I(m), (u = e.onChange) === null || u === void 0 || u.call(e, m.isEmpty() ? null : Ue(e.stringMode, m)), e.value === void 0 && C(m, o)), m;
+      }
+      return s.value;
+    }, se = Tt(), Y = (r) => {
+      var o;
+      if (q(), $.value = r, !p.value) {
+        const u = x(r), m = P(u);
+        m.isNaN() || Z(m, !0);
+      }
+      (o = e.onInput) === null || o === void 0 || o.call(e, r), se(() => {
+        let u = r;
+        e.parser || (u = r.replace(/。/g, ".")), u !== r && Y(u);
+      });
+    }, h = () => {
+      p.value = !0;
+    }, J = () => {
+      p.value = !1, Y(c.value.value);
+    }, H = (r) => {
+      Y(r.target.value);
+    }, U = (r) => {
+      var o, u;
+      if (r && w.value || !r && V.value)
+        return;
+      d.value = !1;
+      let m = P(e.step);
+      r || (m = m.negate());
+      const y = (s.value || P(0)).add(m.toString()), D = Z(y, !1);
+      (o = e.onStep) === null || o === void 0 || o.call(e, Ue(e.stringMode, D), {
+        offset: e.step,
+        type: r ? "up" : "down"
+      }), (u = c.value) === null || u === void 0 || u.focus();
+    }, B = (r) => {
+      const o = P(x($.value));
+      let u = o;
+      o.isNaN() ? u = s.value : u = Z(o, r), e.value !== void 0 ? C(s.value, !1) : u.isNaN() || C(u, !1);
+    }, ue = () => {
+      d.value = !0;
+    }, de = (r) => {
+      var o;
+      const {
+        which: u
+      } = r;
+      d.value = !0, u === ie.ENTER && (p.value || (d.value = !1), B(!1), (o = e.onPressEnter) === null || o === void 0 || o.call(e, r)), e.keyboard !== !1 && !p.value && [ie.UP, ie.DOWN].includes(u) && (U(ie.UP === u), r.preventDefault());
+    }, ce = () => {
+      d.value = !1;
+    }, ae = (r) => {
+      B(!1), f.value = !1, d.value = !1, l("blur", r);
+    };
+    return ee(() => e.precision, () => {
+      s.value.isInvalidate() || C(s.value, !1);
+    }, {
+      flush: "post"
+    }), ee(() => e.value, () => {
+      const r = P(e.value);
+      s.value = r;
+      const o = P(x($.value));
+      (!r.equals(o) || !d.value || e.formatter) && C(r, d.value);
+    }, {
+      flush: "post"
+    }), ee($, () => {
+      e.formatter && K();
+    }, {
+      flush: "post"
+    }), ee(() => e.disabled, (r) => {
+      r && (f.value = !1);
+    }), i({
+      focus: () => {
+        var r;
+        (r = c.value) === null || r === void 0 || r.focus();
+      },
+      blur: () => {
+        var r;
+        (r = c.value) === null || r === void 0 || r.blur();
+      }
+    }), () => {
+      const r = v(v({}, n), e), {
+        prefixCls: o = "rc-input-number",
+        min: u,
+        max: m,
+        step: y = 1,
+        defaultValue: D,
+        value: G,
+        disabled: re,
+        readonly: le,
+        keyboard: g,
+        controls: fe = !0,
+        autofocus: T,
+        stringMode: pe,
+        parser: me,
+        formatter: L,
+        precision: ge,
+        decimalSeparator: ve,
+        onChange: be,
+        onInput: Re,
+        onPressEnter: Ve,
+        onStep: Kt,
+        lazy: Qe,
+        class: et,
+        style: tt
+      } = r, nt = Ft(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: at,
+        downHandler: rt
+      } = a, Be = `${o}-input`, he = {};
+      return Qe ? he.onChange = H : he.onInput = H, b("div", {
+        class: W(o, et, {
+          [`${o}-focused`]: f.value,
+          [`${o}-disabled`]: re,
+          [`${o}-readonly`]: le,
+          [`${o}-not-a-number`]: s.value.isNaN(),
+          [`${o}-out-of-range`]: !s.value.isInvalidate() && !oe(s.value)
+        }),
+        style: tt,
+        onKeydown: de,
+        onKeyup: ce
+      }, [fe && b(Vt, {
+        prefixCls: o,
+        upDisabled: w.value,
+        downDisabled: V.value,
+        onStep: U
+      }, {
+        upNode: at,
+        downNode: rt
+      }), b("div", {
+        class: `${Be}-wrap`
+      }, [b("input", R(R(R({
+        autofocus: T,
+        autocomplete: "off",
+        role: "spinbutton",
+        "aria-valuemin": u,
+        "aria-valuemax": m,
+        "aria-valuenow": s.value.isInvalidate() ? null : s.value.toString(),
+        step: y
+      }, nt), {}, {
+        ref: c,
+        class: Be,
+        value: $.value,
+        disabled: re,
+        readonly: le,
+        onFocus: (lt) => {
+          f.value = !0, l("focus", lt);
+        }
+      }, he), {}, {
+        onBlur: ae,
+        onCompositionstart: h,
+        onCompositionend: J,
+        onBeforeinput: ue
+      }), null)])]);
+    };
+  }
+});
+function we(e) {
+  return e != null;
+}
+const jt = (e) => {
+  const {
+    componentCls: t,
+    lineWidth: n,
+    lineType: a,
+    colorBorder: l,
+    borderRadius: i,
+    fontSizeLG: c,
+    controlHeightLG: f,
+    controlHeightSM: d,
+    colorError: p,
+    inputPaddingHorizontalSM: s,
+    colorTextDescription: I,
+    motionDurationMid: S,
+    colorPrimary: x,
+    controlHeight: $,
+    inputPaddingHorizontal: E,
+    colorBgContainer: M,
+    colorTextDisabled: C,
+    borderRadiusSM: _,
+    borderRadiusLG: N,
+    controlWidth: w,
+    handleVisible: V
+  } = e;
+  return [
+    {
+      [t]: v(v(v(v({}, ze(e)), Ke(e)), Xe(e, t)), {
+        display: "inline-block",
+        width: w,
+        margin: 0,
+        padding: 0,
+        border: `${n}px ${a} ${l}`,
+        borderRadius: i,
+        "&-rtl": {
+          direction: "rtl",
+          [`${t}-input`]: {
+            direction: "rtl"
+          }
+        },
+        "&-lg": {
+          padding: 0,
+          fontSize: c,
+          borderRadius: N,
+          [`input${t}-input`]: {
+            height: f - 2 * n
+          }
+        },
+        "&-sm": {
+          padding: 0,
+          borderRadius: _,
+          [`input${t}-input`]: {
+            height: d - 2 * n,
+            padding: `0 ${s}px`
+          }
+        },
+        "&:hover": v({}, Ze(e)),
+        "&-focused": v({}, Ot(e)),
+        "&-disabled": v(v({}, Pt(e)), {
+          [`${t}-input`]: {
+            cursor: "not-allowed"
+          }
+        }),
+        // ===================== Out Of Range =====================
+        "&-out-of-range": {
+          input: {
+            color: p
+          }
+        },
+        // Style for input-group: input with label, with button or dropdown...
+        "&-group": v(v(v({}, ze(e)), _t(e)), {
+          "&-wrapper": {
+            display: "inline-block",
+            textAlign: "start",
+            verticalAlign: "top",
+            [`${t}-affix-wrapper`]: {
+              width: "100%"
+            },
+            // Size
+            "&-lg": {
+              [`${t}-group-addon`]: {
+                borderRadius: N
+              }
+            },
+            "&-sm": {
+              [`${t}-group-addon`]: {
+                borderRadius: _
+              }
+            }
+          }
+        }),
+        [t]: {
+          "&-input": v(v({
+            width: "100%",
+            height: $ - 2 * n,
+            padding: `0 ${E}px`,
+            textAlign: "start",
+            backgroundColor: "transparent",
+            border: 0,
+            borderRadius: i,
+            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,
+              /* stylelint-disable-next-line property-no-vendor-prefix */
+              webkitAppearance: "none",
+              appearance: "none"
+            }
+          })
+        }
+      })
+    },
+    // Handler
+    {
+      [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: M,
+          borderStartStartRadius: 0,
+          borderStartEndRadius: i,
+          borderEndEndRadius: i,
+          borderEndStartRadius: 0,
+          opacity: V === !0 ? 1 : 0,
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "stretch",
+          transition: `opacity ${S} linear ${S}`,
+          // Fix input number inside Menu makes icon too large
+          // We arise the selector priority by nest selector here
+          // https://github.com/ant-design/ant-design/issues/14367
+          [`${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: I,
+          fontWeight: "bold",
+          lineHeight: 0,
+          textAlign: "center",
+          cursor: "pointer",
+          borderInlineStart: `${n}px ${a} ${l}`,
+          transition: `all ${S} linear`,
+          "&:active": {
+            background: e.colorFillAlter
+          },
+          // Hover
+          "&:hover": {
+            height: "60%",
+            [`
+              ${t}-handler-up-inner,
+              ${t}-handler-down-inner
+            `]: {
+              color: x
+            }
+          },
+          "&-up-inner, &-down-inner": v(v({}, ft()), {
+            color: I,
+            transition: `all ${S} linear`,
+            userSelect: "none"
+          })
+        },
+        [`${t}-handler-up`]: {
+          borderStartEndRadius: i
+        },
+        [`${t}-handler-down`]: {
+          borderBlockStart: `${n}px ${a} ${l}`,
+          borderEndEndRadius: i
+        },
+        // Disabled
+        "&-disabled, &-readonly": {
+          [`${t}-handler-wrap`]: {
+            display: "none"
+          },
+          [`${t}-input`]: {
+            color: "inherit"
+          }
+        },
+        [`
+          ${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
+        }
+      }
+    },
+    // Border-less
+    {
+      [`${t}-borderless`]: {
+        borderColor: "transparent",
+        boxShadow: "none",
+        [`${t}-handler-down`]: {
+          borderBlockStartWidth: 0
+        }
+      }
+    }
+  ];
+}, Wt = (e) => {
+  const {
+    componentCls: t,
+    inputPaddingHorizontal: n,
+    inputAffixPadding: a,
+    controlWidth: l,
+    borderRadiusLG: i,
+    borderRadiusSM: c
+  } = e;
+  return {
+    [`${t}-affix-wrapper`]: v(v(v({}, Ke(e)), Xe(e, `${t}-affix-wrapper`)), {
+      // or number handler will cover form status
+      position: "relative",
+      display: "inline-flex",
+      width: l,
+      padding: 0,
+      paddingInlineStart: n,
+      "&-lg": {
+        borderRadius: i
+      },
+      "&-sm": {
+        borderRadius: c
+      },
+      [`&:not(${t}-affix-wrapper-disabled):hover`]: v(v({}, Ze(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
+        }
+      }
+    })
+  };
+}, Ht = dt("InputNumber", (e) => {
+  const t = Et(e);
+  return [
+    jt(t),
+    Wt(t),
+    // =====================================================
+    // ==             Space Compact                       ==
+    // =====================================================
+    ct(t)
+  ];
+}, (e) => ({
+  controlWidth: 90,
+  handleWidth: e.controlHeightSM - e.lineWidth * 2,
+  handleFontSize: e.fontSize / 2,
+  handleVisible: "auto"
+}));
+var Ut = 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 Le = Je(), Gt = () => v(v({}, Le), {
+  size: Ee(),
+  bordered: F(!0),
+  placeholder: String,
+  name: String,
+  id: String,
+  type: String,
+  addonBefore: ye.any,
+  addonAfter: ye.any,
+  prefix: ye.any,
+  "onUpdate:value": Le.onChange,
+  valueModifiers: Object,
+  status: Ee()
+}), xe = Pe({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "AInputNumber",
+  inheritAttrs: !1,
+  props: Gt(),
+  // emits: ['focus', 'blur', 'change', 'input', 'update:value'],
+  slots: Object,
+  setup(e, t) {
+    let {
+      emit: n,
+      expose: a,
+      attrs: l,
+      slots: i
+    } = t;
+    var c;
+    const f = pt(), d = mt.useInject(), p = j(() => xt(d.status, e.status)), {
+      prefixCls: s,
+      size: I,
+      direction: S,
+      disabled: x
+    } = gt("input-number", e), {
+      compactSize: $,
+      compactItemClassnames: E
+    } = vt(s, S), M = bt(), C = j(() => {
+      var h;
+      return (h = x.value) !== null && h !== void 0 ? h : M.value;
+    }), [_, N] = Ht(s), w = j(() => $.value || I.value), V = O((c = e.value) !== null && c !== void 0 ? c : e.defaultValue), q = O(!1);
+    ee(() => e.value, () => {
+      V.value = e.value;
+    });
+    const K = O(null), X = () => {
+      var h;
+      (h = K.value) === null || h === void 0 || h.focus();
+    };
+    a({
+      focus: X,
+      blur: () => {
+        var h;
+        (h = K.value) === null || h === void 0 || h.blur();
+      }
+    });
+    const Z = (h) => {
+      e.value === void 0 && (V.value = h), n("update:value", h), n("change", h), f.onFieldChange();
+    }, se = (h) => {
+      q.value = !1, n("blur", h), f.onFieldBlur();
+    }, Y = (h) => {
+      q.value = !0, n("focus", h);
+    };
+    return () => {
+      var h, J, H, U;
+      const {
+        hasFeedback: B,
+        isFormItemInput: ue,
+        feedbackIcon: de
+      } = d, ce = (h = e.id) !== null && h !== void 0 ? h : f.id.value, ae = v(v(v({}, l), e), {
+        id: ce,
+        disabled: C.value
+      }), {
+        class: r,
+        bordered: o,
+        readonly: u,
+        style: m,
+        addonBefore: y = (J = i.addonBefore) === null || J === void 0 ? void 0 : J.call(i),
+        addonAfter: D = (H = i.addonAfter) === null || H === void 0 ? void 0 : H.call(i),
+        prefix: G = (U = i.prefix) === null || U === void 0 ? void 0 : U.call(i),
+        valueModifiers: re = {}
+      } = ae, le = Ut(ae, ["class", "bordered", "readonly", "style", "addonBefore", "addonAfter", "prefix", "valueModifiers"]), g = s.value, fe = W({
+        [`${g}-lg`]: w.value === "large",
+        [`${g}-sm`]: w.value === "small",
+        [`${g}-rtl`]: S.value === "rtl",
+        [`${g}-readonly`]: u,
+        [`${g}-borderless`]: !o,
+        [`${g}-in-form-item`]: ue
+      }, Ie(g, p.value), r, E.value, N.value);
+      let T = b(zt, R(R({}, ht(le, ["size", "defaultValue"])), {}, {
+        ref: K,
+        lazy: !!re.lazy,
+        value: V.value,
+        class: fe,
+        prefixCls: g,
+        readonly: u,
+        onChange: Z,
+        onBlur: se,
+        onFocus: Y
+      }), {
+        upHandler: i.upIcon ? () => b("span", {
+          class: `${g}-handler-up-inner`
+        }, [i.upIcon()]) : () => b(Oe, {
+          class: `${g}-handler-up-inner`
+        }, null),
+        downHandler: i.downIcon ? () => b("span", {
+          class: `${g}-handler-down-inner`
+        }, [i.downIcon()]) : () => b(wt, {
+          class: `${g}-handler-down-inner`
+        }, null)
+      });
+      const pe = we(y) || we(D), me = we(G);
+      if (me || B) {
+        const L = W(`${g}-affix-wrapper`, Ie(`${g}-affix-wrapper`, p.value, B), {
+          [`${g}-affix-wrapper-focused`]: q.value,
+          [`${g}-affix-wrapper-disabled`]: C.value,
+          [`${g}-affix-wrapper-sm`]: w.value === "small",
+          [`${g}-affix-wrapper-lg`]: w.value === "large",
+          [`${g}-affix-wrapper-rtl`]: S.value === "rtl",
+          [`${g}-affix-wrapper-readonly`]: u,
+          [`${g}-affix-wrapper-borderless`]: !o,
+          // className will go to addon wrapper
+          [`${r}`]: !pe && r
+        }, N.value);
+        T = b("div", {
+          class: L,
+          style: m,
+          onClick: X
+        }, [me && b("span", {
+          class: `${g}-prefix`
+        }, [G]), T, B && b("span", {
+          class: `${g}-suffix`
+        }, [de])]);
+      }
+      if (pe) {
+        const L = `${g}-group`, ge = `${L}-addon`, ve = y ? b("div", {
+          class: ge
+        }, [y]) : null, be = D ? b("div", {
+          class: ge
+        }, [D]) : null, Re = W(`${g}-wrapper`, L, {
+          [`${L}-rtl`]: S.value === "rtl"
+        }, N.value), Ve = W(`${g}-group-wrapper`, {
+          [`${g}-group-wrapper-sm`]: w.value === "small",
+          [`${g}-group-wrapper-lg`]: w.value === "large",
+          [`${g}-group-wrapper-rtl`]: S.value === "rtl"
+        }, Ie(`${s}-group-wrapper`, p.value, B), r, N.value);
+        T = b("div", {
+          class: Ve,
+          style: m
+        }, [b("div", {
+          class: Re
+        }, [ve && b(je, null, {
+          default: () => [b(We, null, {
+            default: () => [ve]
+          })]
+        }), T, be && b(je, null, {
+          default: () => [b(We, null, {
+            default: () => [be]
+          })]
+        })])]);
+      }
+      return _(St(T, {
+        style: m
+      }));
+    };
+  }
+}), Lt = v(xe, {
+  install: (e) => (e.component(xe.name, xe), e)
+}), kt = {
+  name: "ZInput",
+  components: {
+    AInput: yt,
+    AInputNumber: Lt,
+    AInputPassword: Nt
+  }
+}, qt = /* @__PURE__ */ Object.assign(kt, {
+  props: /* @__PURE__ */ it({
+    type: {
+      type: String,
+      default: "text"
+    }
+  }, {
+    modelValue: {},
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(e) {
+    const t = ot(e, "modelValue"), n = e;
+    return (a, l) => {
+      const i = Se("a-input-number"), c = Se("a-input-password"), f = Se("a-input");
+      return (n == null ? void 0 : n.type) === "number" ? (Ne(), $e(i, Te({
+        key: 0,
+        class: "z-input",
+        value: t.value,
+        "onUpdate:value": l[0] || (l[0] = (d) => t.value = d)
+      }, a.$attrs), null, 16, ["value"])) : (n == null ? void 0 : n.type) === "password" ? (Ne(), $e(c, {
+        key: 1,
+        value: t.value,
+        "onUpdate:value": l[1] || (l[1] = (d) => t.value = d),
+        placeholder: "input password"
+      }, null, 8, ["value"])) : (Ne(), $e(f, Te({
+        key: 2,
+        class: "z-input",
+        value: t.value,
+        "onUpdate:value": l[2] || (l[2] = (d) => t.value = d)
+      }, a.$attrs), null, 16, ["value"]));
+    };
+  }
+}), tn = /* @__PURE__ */ $t(qt, [["__scopeId", "data-v-d68f7888"]]);
+export {
+  tn as default
+};