@dazhicheng/ui 1.0.6 → 1.0.8

package/dist/index-D2KfwzYW.js

@@ -0,0 +1,832 @@
+import { computed as f, getCurrentInstance as _e, markRaw as et, defineComponent as tt, useAttrs as ot, useSlots as nt, shallowRef as ae, ref as ie, watch as se, nextTick as F, onMounted as at, toRef as it, createElementBlock as E, openBlock as c, normalizeStyle as Ce, normalizeClass as p, unref as n, createCommentVNode as m, Fragment as le, createElementVNode as L, renderSlot as Z, createBlock as I, withCtx as H, resolveDynamicComponent as A, mergeProps as Ne, withModifiers as re, toDisplayString as q } from "vue";
+import { g as ue, U as J, c as Oe, d as Pe, v as st, n as lt, N as de, o as ze, C as Me, I as ce } from "./index-7R1S3sB2.js";
+import { m as rt } from "./typescript-BpuhIBuJ.js";
+import { i as fe, V as ut } from "./icon-DO5WEZ3U.js";
+import { d as Q, b as dt, a as M, u as ct, e as Ve, h as ft, j as mt, w as vt } from "./use-form-common-props-CH53YdF-.js";
+import { u as pt } from "./index-B-3b7Nox.js";
+import { useResizeObserver as yt, isClient as bt } from "@vueuse/core";
+import { fromPairs as ht, isNil as gt } from "lodash-es";
+import { E as j } from "./index-BWFNEHAe.js";
+import { a as xt, u as wt, b as St } from "./index-CN_A-qCa.js";
+import { u as Et, a as It } from "./use-form-item--pOyiE--.js";
+const Ct = ["class", "style"], Nt = /^on[A-Z]/, Pt = (e = {}) => {
+  const { excludeListeners: r = !1, excludeKeys: x } = e, t = f(() => ((x == null ? void 0 : x.value) || []).concat(Ct)), l = _e();
+  return l ? f(
+    () => {
+      var u;
+      return ht(
+        Object.entries((u = l.proxy) == null ? void 0 : u.$attrs).filter(
+          ([d]) => !t.value.includes(d) && !(r && Nt.test(d))
+        )
+      );
+    }
+  ) : (Q(
+    "use-attrs",
+    "getCurrentInstance() returned null. useAttrs() must be called at the top of a setup function"
+  ), f(() => ({})));
+};
+function zt(e) {
+  let r;
+  function x() {
+    if (e.value == null) return;
+    const { selectionStart: l, selectionEnd: u, value: d } = e.value;
+    if (l == null || u == null) return;
+    const v = d.slice(0, Math.max(0, l)), w = d.slice(Math.max(0, u));
+    r = {
+      selectionStart: l,
+      selectionEnd: u,
+      value: d,
+      beforeTxt: v,
+      afterTxt: w
+    };
+  }
+  function t() {
+    if (e.value == null || r == null) return;
+    const { value: l } = e.value, { beforeTxt: u, afterTxt: d, selectionStart: v } = r;
+    if (u == null || d == null || v == null)
+      return;
+    let w = l.length;
+    if (l.endsWith(d))
+      w = l.length - d.length;
+    else if (l.startsWith(u))
+      w = u.length;
+    else {
+      const h = u[v - 1], C = l.indexOf(h, v - 1);
+      C !== -1 && (w = C + 1);
+    }
+    e.value.setSelectionRange(w, w);
+  }
+  return [x, t];
+}
+const Re = dt({
+  /**
+   * @description native input id
+   */
+  id: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * @description input box size
+   */
+  size: ct,
+  /**
+   * @description whether to disable
+   */
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+   * @description binding value
+   */
+  modelValue: {
+    type: M([
+      String,
+      Number,
+      Object
+    ]),
+    default: ""
+  },
+  /**
+   * @description v-model modifiers, reference [Vue modifiers](https://vuejs.org/guide/essentials/forms.html#modifiers)
+   */
+  modelModifiers: {
+    type: M(Object),
+    default: () => ({})
+  },
+  /**
+   * @description same as `maxlength` in native input
+   */
+  maxlength: {
+    type: [String, Number]
+  },
+  /**
+   * @description same as `minlength` in native input
+   */
+  minlength: {
+    type: [String, Number]
+  },
+  /**
+   * @description type of input, see more in [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types)
+   */
+  type: {
+    type: M(String),
+    default: "text"
+  },
+  /**
+   * @description control the resizability
+   */
+  resize: {
+    type: String,
+    values: ["none", "both", "horizontal", "vertical"]
+  },
+  /**
+   * @description whether textarea has an adaptive height
+   */
+  autosize: {
+    type: M([Boolean, Object]),
+    default: !1
+  },
+  /**
+   * @description native input autocomplete
+   */
+  autocomplete: {
+    type: M(String),
+    default: "off"
+  },
+  /**
+   * @description format content
+   */
+  formatter: {
+    type: Function
+  },
+  /**
+   * @description parse content
+   */
+  parser: {
+    type: Function
+  },
+  /**
+   * @description placeholder
+   */
+  placeholder: {
+    type: String
+  },
+  /**
+   * @description native input form
+   */
+  form: {
+    type: String
+  },
+  /**
+   * @description native input readonly
+   */
+  readonly: Boolean,
+  /**
+   * @description whether to show clear button
+   */
+  clearable: Boolean,
+  /**
+   * @description custom clear icon component
+   */
+  clearIcon: {
+    type: fe,
+    default: Oe
+  },
+  /**
+   * @description toggleable password input
+   */
+  showPassword: Boolean,
+  /**
+   * @description word count
+   */
+  showWordLimit: Boolean,
+  /**
+   * @description word count position, valid when `show-word-limit` is true
+   */
+  wordLimitPosition: {
+    type: String,
+    values: ["inside", "outside"],
+    default: "inside"
+  },
+  /**
+   * @description suffix icon
+   */
+  suffixIcon: {
+    type: fe
+  },
+  /**
+   * @description prefix icon
+   */
+  prefixIcon: {
+    type: fe
+  },
+  /**
+   * @description container role, internal properties provided for use by the picker component
+   */
+  containerRole: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * @description input tabindex
+   */
+  tabindex: {
+    type: [String, Number],
+    default: 0
+  },
+  /**
+   * @description whether to trigger form validation
+   */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description input or textarea element style
+   */
+  inputStyle: {
+    type: M([Object, Array, String]),
+    default: () => rt({})
+  },
+  /**
+   * @description native input autofocus
+   */
+  autofocus: Boolean,
+  rows: {
+    type: Number,
+    default: 2
+  },
+  ...pt(["ariaLabel"]),
+  /**
+   * @description native input mode for virtual keyboards
+   */
+  inputmode: {
+    type: M(String),
+    default: void 0
+  },
+  /**
+   * @description same as `name` in native input
+   */
+  name: String
+}), $e = {
+  [J]: (e) => ue(e),
+  input: (e) => ue(e),
+  change: (e, r) => ue(e) && (r instanceof Event || r === void 0),
+  focus: (e) => e instanceof FocusEvent,
+  blur: (e) => e instanceof FocusEvent,
+  clear: () => !0,
+  mouseleave: (e) => e instanceof MouseEvent,
+  mouseenter: (e) => e instanceof MouseEvent,
+  // NOTE: when autofill by browser, the keydown event is instanceof Event, not KeyboardEvent
+  // relative bug report https://github.com/element-plus/element-plus/issues/6665
+  keydown: (e) => e instanceof Event,
+  compositionstart: (e) => e instanceof CompositionEvent,
+  compositionupdate: (e) => e instanceof CompositionEvent,
+  compositionend: (e) => e instanceof CompositionEvent
+}, Mt = {
+  disabled: void 0,
+  modelValue: "",
+  modelModifiers: () => ({}),
+  type: "text",
+  autocomplete: "off",
+  clearIcon: et(Oe),
+  wordLimitPosition: "inside",
+  tabindex: 0,
+  validateEvent: !0,
+  inputStyle: () => ({}),
+  rows: 2
+};
+let b;
+const Vt = {
+  height: "0",
+  visibility: "hidden",
+  overflow: xt() ? "" : "hidden",
+  position: "absolute",
+  "z-index": "-1000",
+  top: "0",
+  right: "0"
+}, kt = [
+  "letter-spacing",
+  "line-height",
+  "padding-top",
+  "padding-bottom",
+  "font-family",
+  "font-weight",
+  "font-size",
+  "text-rendering",
+  "text-transform",
+  "width",
+  "text-indent",
+  "padding-left",
+  "padding-right",
+  "border-width",
+  "box-sizing",
+  "word-break"
+], ke = (e) => {
+  const r = Number.parseFloat(e);
+  return Number.isNaN(r) ? e : r;
+};
+function Tt(e) {
+  const r = window.getComputedStyle(e), x = r.getPropertyValue("box-sizing"), t = Number.parseFloat(r.getPropertyValue("padding-bottom")) + Number.parseFloat(r.getPropertyValue("padding-top")), l = Number.parseFloat(r.getPropertyValue("border-bottom-width")) + Number.parseFloat(r.getPropertyValue("border-top-width"));
+  return { contextStyle: kt.map((d) => [
+    d,
+    r.getPropertyValue(d)
+  ]), paddingSize: t, borderSize: l, boxSizing: x };
+}
+function Te(e, r = 1, x) {
+  var t, l;
+  b || (b = document.createElement("textarea"), ((t = e.parentNode) != null ? t : document.body).appendChild(b));
+  const { paddingSize: u, borderSize: d, boxSizing: v, contextStyle: w } = Tt(e);
+  w.forEach(
+    ([y, O]) => b == null ? void 0 : b.style.setProperty(y, O)
+  ), Object.entries(Vt).forEach(
+    ([y, O]) => b == null ? void 0 : b.style.setProperty(y, O, "important")
+  ), b.value = e.value || e.placeholder || "";
+  let h = b.scrollHeight;
+  const C = {};
+  v === "border-box" ? h = h + d : v === "content-box" && (h = h - u), b.value = "";
+  const g = b.scrollHeight - u;
+  if (Ve(r)) {
+    let y = g * r;
+    v === "border-box" && (y = y + u + d), h = Math.max(y, h), C.minHeight = `${y}px`;
+  }
+  if (Ve(x)) {
+    let y = g * x;
+    v === "border-box" && (y = y + u + d), h = Math.min(y, h);
+  }
+  return C.height = `${h}px`, (l = b.parentNode) == null || l.removeChild(b), b = void 0, C;
+}
+const Ft = ["id", "name", "minlength", "maxlength", "type", "disabled", "readonly", "autocomplete", "tabindex", "aria-label", "placeholder", "form", "autofocus", "role", "inputmode"], Lt = ["id", "name", "minlength", "maxlength", "tabindex", "disabled", "readonly", "autocomplete", "aria-label", "placeholder", "form", "autofocus", "rows", "role"], Fe = "ElInput";
+var Ot = /* @__PURE__ */ tt({
+  name: Fe,
+  inheritAttrs: !1,
+  __name: "input",
+  props: Re,
+  emits: $e,
+  setup(e, { expose: r, emit: x }) {
+    const t = e, l = x, u = ot(), d = Pt(), v = nt(), w = f(() => [
+      t.type === "textarea" ? me.b() : i.b(),
+      i.m(O.value),
+      i.is("disabled", P.value),
+      i.is("exceed", je.value),
+      {
+        [i.b("group")]: v.prepend || v.append,
+        [i.m("prefix")]: v.prefix || t.prefixIcon,
+        [i.m("suffix")]: v.suffix || t.suffixIcon || t.clearable || t.showPassword,
+        [i.bm("suffix", "password-clear")]: W.value && te.value,
+        [i.b("hidden")]: t.type === "hidden"
+      },
+      u.class
+    ]), h = f(() => [
+      i.e("wrapper"),
+      i.is("focus", ee.value)
+    ]), { form: C, formItem: g } = Et(), { inputId: y } = It(t, {
+      formItemContext: g
+    }), O = ft(), P = mt(), i = Pe("input"), me = Pe("textarea"), D = ae(), N = ae(), _ = ie(!1), K = ie(!1), ve = ie(), U = ae(t.inputStyle), S = f(() => D.value || N.value), { wrapperRef: Be, isFocused: ee, handleFocus: pe, handleBlur: ye } = wt(
+      S,
+      {
+        disabled: P,
+        afterBlur() {
+          var o;
+          t.validateEvent && ((o = g == null ? void 0 : g.validate) == null || o.call(g, "blur").catch((a) => Q(a)));
+        }
+      }
+    ), be = f(() => {
+      var o;
+      return (o = C == null ? void 0 : C.statusIcon) != null ? o : !1;
+    }), R = f(() => (g == null ? void 0 : g.validateState) || ""), he = f(
+      () => R.value && ut[R.value]
+    ), He = f(
+      () => K.value ? st : lt
+    ), Ae = f(() => [
+      u.style
+    ]), ge = f(() => [
+      t.inputStyle,
+      U.value,
+      { resize: t.resize }
+    ]), z = f(
+      () => gt(t.modelValue) ? "" : String(t.modelValue)
+    ), W = f(
+      () => t.clearable && !P.value && !t.readonly && !!z.value && (ee.value || _.value)
+    ), te = f(
+      () => t.showPassword && !P.value && !!z.value
+    ), V = f(
+      () => t.showWordLimit && !!t.maxlength && (t.type === "text" || t.type === "textarea") && !P.value && !t.readonly && !t.showPassword
+    ), oe = f(() => z.value.length), je = f(
+      () => (
+        // show exceed style if length of initial value greater then maxlength
+        !!V.value && oe.value > Number(t.maxlength)
+      )
+    ), De = f(
+      () => !!v.suffix || !!t.suffixIcon || W.value || t.showPassword || V.value || !!R.value && be.value
+    ), Ke = f(
+      () => !!Object.keys(t.modelModifiers).length
+    ), [Ue, We] = zt(D);
+    yt(N, (o) => {
+      if (Ye(), !V.value || t.resize !== "both" && t.resize !== "horizontal")
+        return;
+      const a = o[0], { width: s } = a.contentRect;
+      ve.value = {
+        /** right: 100% - width + padding(22) - right(10) */
+        right: `calc(100% - ${s + 22 - 10}px)`
+      };
+    });
+    const $ = () => {
+      const { type: o, autosize: a } = t;
+      if (!(!bt || o !== "textarea" || !N.value))
+        if (a) {
+          const s = ze(a) ? a.minRows : void 0, T = ze(a) ? a.maxRows : void 0, B = Te(N.value, s, T);
+          U.value = {
+            overflowY: "hidden",
+            ...B
+          }, F(() => {
+            N.value.offsetHeight, U.value = B;
+          });
+        } else
+          U.value = {
+            minHeight: Te(N.value).minHeight
+          };
+    }, Ye = ((o) => {
+      let a = !1;
+      return () => {
+        var s;
+        if (a || !t.autosize) return;
+        ((s = N.value) == null ? void 0 : s.offsetParent) === null || (setTimeout(o), a = !0);
+      };
+    })($), k = () => {
+      const o = S.value, a = t.formatter ? t.formatter(z.value) : z.value;
+      !o || o.value === a || t.type === "file" || (o.value = a);
+    }, xe = (o) => {
+      const { trim: a, number: s } = t.modelModifiers;
+      return a && (o = o.trim()), s && (o = `${ke(o)}`), t.formatter && t.parser && (o = t.parser(o)), o;
+    }, ne = async (o) => {
+      if (Se.value) return;
+      const { lazy: a } = t.modelModifiers;
+      let { value: s } = o.target;
+      if (a) {
+        l(ce, s);
+        return;
+      }
+      if (s = xe(s), String(s) === z.value) {
+        t.formatter && k();
+        return;
+      }
+      Ue(), l(J, s), l(ce, s), await F(), (t.formatter && t.parser || !Ke.value) && k(), We();
+    }, we = async (o) => {
+      let { value: a } = o.target;
+      a = xe(a), t.modelModifiers.lazy && l(J, a), l(Me, a, o), await F(), k();
+    }, {
+      isComposing: Se,
+      handleCompositionStart: Y,
+      handleCompositionUpdate: X,
+      handleCompositionEnd: G
+    } = St({ emit: l, afterComposition: ne }), Xe = () => {
+      K.value = !K.value;
+    }, Ge = () => {
+      var o;
+      return (o = S.value) == null ? void 0 : o.focus();
+    }, Ze = () => {
+      var o;
+      return (o = S.value) == null ? void 0 : o.blur();
+    }, qe = (o) => {
+      _.value = !1, l("mouseleave", o);
+    }, Je = (o) => {
+      _.value = !0, l("mouseenter", o);
+    }, Ee = (o) => {
+      l("keydown", o);
+    }, Qe = () => {
+      var o;
+      (o = S.value) == null || o.select();
+    }, Ie = () => {
+      l(J, ""), l(Me, ""), l("clear"), l(ce, "");
+    };
+    return se(
+      () => t.modelValue,
+      () => {
+        var o;
+        F(() => $()), t.validateEvent && ((o = g == null ? void 0 : g.validate) == null || o.call(g, "change").catch((a) => Q(a)));
+      }
+    ), se(z, (o) => {
+      if (!S.value)
+        return;
+      const { trim: a, number: s } = t.modelModifiers, T = S.value.value, B = (s || t.type === "number") && !/^0\d/.test(T) ? `${ke(T)}` : T;
+      B !== o && (document.activeElement === S.value && S.value.type !== "range" && a && B.trim() === o || k());
+    }), se(
+      () => t.type,
+      async () => {
+        await F(), k(), $();
+      }
+    ), at(() => {
+      !t.formatter && t.parser && Q(
+        Fe,
+        "If you set the parser, you also need to set the formatter."
+      ), k(), F($);
+    }), r({
+      /** @description HTML input element */
+      input: D,
+      /** @description HTML textarea element */
+      textarea: N,
+      /** @description HTML element, input or textarea */
+      ref: S,
+      /** @description style of textarea. */
+      textareaStyle: ge,
+      /** @description from props (used on unit test) */
+      autosize: it(t, "autosize"),
+      /** @description is input composing */
+      isComposing: Se,
+      /** @description HTML input element native method */
+      focus: Ge,
+      /** @description HTML input element native method */
+      blur: Ze,
+      /** @description HTML input element native method */
+      select: Qe,
+      /** @description clear input value */
+      clear: Ie,
+      /** @description resize textarea. */
+      resizeTextarea: $
+    }), (o, a) => (c(), E(
+      "div",
+      {
+        class: p([
+          w.value,
+          {
+            [n(i).bm("group", "append")]: o.$slots.append,
+            [n(i).bm("group", "prepend")]: o.$slots.prepend
+          }
+        ]),
+        style: Ce(Ae.value),
+        onMouseenter: Je,
+        onMouseleave: qe
+      },
+      [
+        m(" input "),
+        e.type !== "textarea" ? (c(), E(
+          le,
+          { key: 0 },
+          [
+            m(" prepend slot "),
+            o.$slots.prepend ? (c(), E(
+              "div",
+              {
+                key: 0,
+                class: p(n(i).be("group", "prepend"))
+              },
+              [
+                Z(o.$slots, "prepend")
+              ],
+              2
+              /* CLASS */
+            )) : m("v-if", !0),
+            L(
+              "div",
+              {
+                ref_key: "wrapperRef",
+                ref: Be,
+                class: p(h.value)
+              },
+              [
+                m(" prefix slot "),
+                o.$slots.prefix || e.prefixIcon ? (c(), E(
+                  "span",
+                  {
+                    key: 0,
+                    class: p(n(i).e("prefix"))
+                  },
+                  [
+                    L(
+                      "span",
+                      {
+                        class: p(n(i).e("prefix-inner"))
+                      },
+                      [
+                        Z(o.$slots, "prefix"),
+                        e.prefixIcon ? (c(), I(n(j), {
+                          key: 0,
+                          class: p(n(i).e("icon"))
+                        }, {
+                          default: H(() => [
+                            (c(), I(A(e.prefixIcon)))
+                          ]),
+                          _: 1
+                          /* STABLE */
+                        }, 8, ["class"])) : m("v-if", !0)
+                      ],
+                      2
+                      /* CLASS */
+                    )
+                  ],
+                  2
+                  /* CLASS */
+                )) : m("v-if", !0),
+                L("input", Ne({
+                  id: n(y),
+                  ref_key: "input",
+                  ref: D,
+                  class: n(i).e("inner")
+                }, n(d), {
+                  name: e.name,
+                  minlength: e.minlength,
+                  maxlength: e.maxlength,
+                  type: e.showPassword ? K.value ? "text" : "password" : e.type,
+                  disabled: n(P),
+                  readonly: e.readonly,
+                  autocomplete: e.autocomplete,
+                  tabindex: e.tabindex,
+                  "aria-label": e.ariaLabel,
+                  placeholder: e.placeholder,
+                  style: e.inputStyle,
+                  form: e.form,
+                  autofocus: e.autofocus,
+                  role: e.containerRole,
+                  inputmode: e.inputmode,
+                  onCompositionstart: a[0] || (a[0] = //@ts-ignore
+                  (...s) => n(Y) && n(Y)(...s)),
+                  onCompositionupdate: a[1] || (a[1] = //@ts-ignore
+                  (...s) => n(X) && n(X)(...s)),
+                  onCompositionend: a[2] || (a[2] = //@ts-ignore
+                  (...s) => n(G) && n(G)(...s)),
+                  onInput: ne,
+                  onChange: we,
+                  onKeydown: Ee
+                }), null, 16, Ft),
+                m(" suffix slot "),
+                De.value ? (c(), E(
+                  "span",
+                  {
+                    key: 1,
+                    class: p(n(i).e("suffix"))
+                  },
+                  [
+                    L(
+                      "span",
+                      {
+                        class: p(n(i).e("suffix-inner"))
+                      },
+                      [
+                        !W.value || !te.value || !V.value ? (c(), E(
+                          le,
+                          { key: 0 },
+                          [
+                            Z(o.$slots, "suffix"),
+                            e.suffixIcon ? (c(), I(n(j), {
+                              key: 0,
+                              class: p(n(i).e("icon"))
+                            }, {
+                              default: H(() => [
+                                (c(), I(A(e.suffixIcon)))
+                              ]),
+                              _: 1
+                              /* STABLE */
+                            }, 8, ["class"])) : m("v-if", !0)
+                          ],
+                          64
+                          /* STABLE_FRAGMENT */
+                        )) : m("v-if", !0),
+                        W.value ? (c(), I(n(j), {
+                          key: 1,
+                          class: p([n(i).e("icon"), n(i).e("clear")]),
+                          onMousedown: re(n(de), ["prevent"]),
+                          onClick: Ie
+                        }, {
+                          default: H(() => [
+                            (c(), I(A(e.clearIcon)))
+                          ]),
+                          _: 1
+                          /* STABLE */
+                        }, 8, ["class", "onMousedown"])) : m("v-if", !0),
+                        te.value ? (c(), I(n(j), {
+                          key: 2,
+                          class: p([n(i).e("icon"), n(i).e("password")]),
+                          onClick: Xe,
+                          onMousedown: re(n(de), ["prevent"]),
+                          onMouseup: re(n(de), ["prevent"])
+                        }, {
+                          default: H(() => [
+                            (c(), I(A(He.value)))
+                          ]),
+                          _: 1
+                          /* STABLE */
+                        }, 8, ["class", "onMousedown", "onMouseup"])) : m("v-if", !0),
+                        V.value ? (c(), E(
+                          "span",
+                          {
+                            key: 3,
+                            class: p([
+                              n(i).e("count"),
+                              n(i).is("outside", e.wordLimitPosition === "outside")
+                            ])
+                          },
+                          [
+                            L(
+                              "span",
+                              {
+                                class: p(n(i).e("count-inner"))
+                              },
+                              q(oe.value) + " / " + q(e.maxlength),
+                              3
+                              /* TEXT, CLASS */
+                            )
+                          ],
+                          2
+                          /* CLASS */
+                        )) : m("v-if", !0),
+                        R.value && he.value && be.value ? (c(), I(n(j), {
+                          key: 4,
+                          class: p([
+                            n(i).e("icon"),
+                            n(i).e("validateIcon"),
+                            n(i).is("loading", R.value === "validating")
+                          ])
+                        }, {
+                          default: H(() => [
+                            (c(), I(A(he.value)))
+                          ]),
+                          _: 1
+                          /* STABLE */
+                        }, 8, ["class"])) : m("v-if", !0)
+                      ],
+                      2
+                      /* CLASS */
+                    )
+                  ],
+                  2
+                  /* CLASS */
+                )) : m("v-if", !0)
+              ],
+              2
+              /* CLASS */
+            ),
+            m(" append slot "),
+            o.$slots.append ? (c(), E(
+              "div",
+              {
+                key: 1,
+                class: p(n(i).be("group", "append"))
+              },
+              [
+                Z(o.$slots, "append")
+              ],
+              2
+              /* CLASS */
+            )) : m("v-if", !0)
+          ],
+          64
+          /* STABLE_FRAGMENT */
+        )) : (c(), E(
+          le,
+          { key: 1 },
+          [
+            m(" textarea "),
+            L("textarea", Ne({
+              id: n(y),
+              ref_key: "textarea",
+              ref: N,
+              class: [n(me).e("inner"), n(i).is("focus", n(ee))]
+            }, n(d), {
+              name: e.name,
+              minlength: e.minlength,
+              maxlength: e.maxlength,
+              tabindex: e.tabindex,
+              disabled: n(P),
+              readonly: e.readonly,
+              autocomplete: e.autocomplete,
+              style: ge.value,
+              "aria-label": e.ariaLabel,
+              placeholder: e.placeholder,
+              form: e.form,
+              autofocus: e.autofocus,
+              rows: e.rows,
+              role: e.containerRole,
+              onCompositionstart: a[3] || (a[3] = //@ts-ignore
+              (...s) => n(Y) && n(Y)(...s)),
+              onCompositionupdate: a[4] || (a[4] = //@ts-ignore
+              (...s) => n(X) && n(X)(...s)),
+              onCompositionend: a[5] || (a[5] = //@ts-ignore
+              (...s) => n(G) && n(G)(...s)),
+              onInput: ne,
+              onFocus: a[6] || (a[6] = //@ts-ignore
+              (...s) => n(pe) && n(pe)(...s)),
+              onBlur: a[7] || (a[7] = //@ts-ignore
+              (...s) => n(ye) && n(ye)(...s)),
+              onChange: we,
+              onKeydown: Ee
+            }), null, 16, Lt),
+            V.value ? (c(), E(
+              "span",
+              {
+                key: 0,
+                style: Ce(ve.value),
+                class: p([
+                  n(i).e("count"),
+                  n(i).is("outside", e.wordLimitPosition === "outside")
+                ])
+              },
+              q(oe.value) + " / " + q(e.maxlength),
+              7
+              /* TEXT, CLASS, STYLE */
+            )) : m("v-if", !0)
+          ],
+          64
+          /* STABLE_FRAGMENT */
+        ))
+      ],
+      38
+      /* CLASS, STYLE, NEED_HYDRATION */
+    ));
+  }
+});
+const Le = vt(Ot), Gt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ElInput: Le,
+  default: Le,
+  inputEmits: $e,
+  inputProps: Re,
+  inputPropsDefaults: Mt
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Le as E,
+  Gt as i,
+  Pt as u
+};