@dazhicheng/ui 1.4.13 → 1.4.15

package/dist/index-BxInQxCV.js

@@ -0,0 +1,2502 @@
+import { defineComponent as Ce, createElementBlock as ce, openBlock as K, normalizeStyle as Ae, normalizeClass as N, toDisplayString as me, inject as Jt, withModifiers as oe, renderSlot as ue, createElementVNode as j, getCurrentInstance as xt, computed as b, ref as L, reactive as xe, unref as T, watch as ve, onBeforeUnmount as ln, h as we, resolveDynamicComponent as Be, Fragment as dt, mergeProps as ft, onMounted as _t, onUpdated as nn, onActivated as on, nextTick as ae, createVNode as de, toRaw as an, useSlots as sn, watchEffect as Pt, toRefs as Ht, provide as rn, resolveComponent as Ze, resolveDirective as un, withDirectives as Wt, withCtx as X, createSlots as cn, normalizeProps as dn, guardReactiveProps as fn, createCommentVNode as he, createBlock as ye, renderList as Kt, createTextVNode as Gt, withKeys as ke, vShow as mn } from "vue";
+import { _ as St, u as vn, a as Ye, E as pn, B as hn, b as gn, c as bn } from "./util-Boou02y4.js";
+import { t as qt, d as yn, u as tt, M as Sn, E as wn, a as On, B as In } from "./useProps-B1w2fNNy.js";
+import { E as Vn } from "./index-BKQp009w.js";
+import { memoize as En, get as ge, isEqual as $e, findLastIndex as Tn } from "lodash-es";
+import { d as be, C as el, U as tl, e as Mn, c as Cn, g as mt, r as Rn, o as Fe, a as Se, i as Xe, G as zn } from "./index-WNukMwgV.js";
+import { b as Re, a as Q, u as Nn, l as Ln, e as Oe, q as Ie, t as ll, g as nl, j as Dn, d as ut, h as kn, p as $n, w as An } from "./use-form-common-props-QWQdZzPI.js";
+import { u as Bn } from "./index-D3Ax_E0B.js";
+import { i as Ut, V as Fn } from "./icon-D7yoP9ir.js";
+import { isClient as wt, useEventListener as Pn, isIOS as Hn, useDebounceFn as Wn, useResizeObserver as Ve } from "@vueuse/core";
+import { a as Kn, b as Gn, u as qn } from "./index-jX-ESk9T.js";
+import { m as Un } from "./typescript-BpuhIBuJ.js";
+import { g as ol, E as al } from "./event-DFRZD7LK.js";
+import { u as jn } from "./index-BQfVaV7A.js";
+import { u as Qn, a as Zn, b as Yn } from "./use-form-item-aIqGB1on.js";
+import { C as Xn } from "./index-D9W_gSi5.js";
+const sl = (e) => wt ? window.requestAnimationFrame(e) : setTimeout(e, 16), il = (e) => wt ? window.cancelAnimationFrame(e) : clearTimeout(e);
+var Jn = Ce({
+  props: {
+    item: {
+      type: Object,
+      required: !0
+    },
+    style: {
+      type: Object
+    },
+    height: Number
+  },
+  setup() {
+    return {
+      ns: be("select")
+    };
+  }
+});
+function xn(e, t, n, a, r, d) {
+  return K(), ce(
+    "div",
+    {
+      class: N(e.ns.be("group", "title")),
+      style: Ae({ ...e.style, lineHeight: `${e.height}px` })
+    },
+    me(e.item.label),
+    7
+    /* TEXT, CLASS, STYLE */
+  );
+}
+var _n = /* @__PURE__ */ St(Jn, [["render", xn]]);
+function eo(e, { emit: t }) {
+  return {
+    hoverItem: () => {
+      e.disabled || t("hover", e.index);
+    },
+    selectOptionClick: () => {
+      e.disabled || t("select", e.item, e.index);
+    }
+  };
+}
+const to = Re({
+  /**
+   * @description whether creating new items is allowed. To use this, `filterable` must be true
+   */
+  allowCreate: Boolean,
+  /**
+   * @description autocomplete of select input
+   */
+  autocomplete: {
+    type: Q(String),
+    default: "none"
+  },
+  /**
+   * @description for non-filterable Select, this prop decides if the option menu pops up when the input is focused
+   */
+  automaticDropdown: Boolean,
+  /**
+   * @description whether select can be cleared
+   */
+  clearable: Boolean,
+  /**
+   * @description custom clear icon
+   */
+  clearIcon: {
+    type: Ut,
+    default: Cn
+  },
+  /**
+   * @description tooltip theme, built-in theme: `dark` / `light`
+   */
+  effect: {
+    type: Q(String),
+    default: "light"
+  },
+  /**
+   * @description whether to collapse tags to a text when multiple selecting
+   */
+  collapseTags: Boolean,
+  /**
+   * @description whether show all selected tags when mouse hover text of collapse-tags. To use this, `collapse-tags` must be true
+   */
+  collapseTagsTooltip: Boolean,
+  /**
+   * @description The max tags number to be shown. To use this, `collapse-tags` must be true
+   */
+  maxCollapseTags: {
+    type: Number,
+    default: 1
+  },
+  /**
+   * @description
+   */
+  defaultFirstOption: Boolean,
+  /**
+   * @description is disabled
+   */
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+   * @description
+   */
+  estimatedOptionHeight: {
+    type: Number,
+    default: void 0
+  },
+  /**
+   * @description whether Select is filterable
+   */
+  filterable: Boolean,
+  /**
+   * @description custom filter method, the first parameter is the current input value. To use this, `filterable` must be true
+   */
+  filterMethod: {
+    type: Q(Function)
+  },
+  /**
+   * @description The height of the dropdown panel, 34px for each item
+   */
+  height: {
+    type: Number,
+    default: 274
+    // same as select dropdown menu
+  },
+  /**
+   * @description The height of the dropdown item
+   */
+  itemHeight: {
+    type: Number,
+    default: 34
+  },
+  /**
+   * @description native input id
+   */
+  id: String,
+  /**
+   * @description whether Select is loading data from server
+   */
+  loading: Boolean,
+  /**
+   * @description displayed text while loading data from server, default is 'Loading'
+   */
+  loadingText: String,
+  /**
+   * @description biding value
+   */
+  modelValue: {
+    type: Q([Array, String, Number, Boolean, Object]),
+    default: void 0
+  },
+  /**
+   * @description is multiple
+   */
+  multiple: Boolean,
+  /**
+   * @description maximum number of options user can select when multiple is true. No limit when set to 0
+   */
+  multipleLimit: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description the name attribute of select input
+   */
+  name: String,
+  /**
+   * @description displayed text when there is no options, you can also use slot empty, the default is 'No Data'
+   */
+  noDataText: String,
+  /**
+   * @description displayed text when no data matches the filtering query, you can also use slot `empty`, default is 'No matching data'
+   */
+  noMatchText: String,
+  /**
+   * @description function that gets called when the input value changes. Its parameter is the current input value. To use this, `filterable` must be true
+   */
+  remoteMethod: {
+    type: Q(Function)
+  },
+  /**
+   * @description whether reserve the keyword after select filtered option.
+   */
+  reserveKeyword: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description data of the options, the key of `value` and `label` can be customize by `props`
+   */
+  options: {
+    type: Q(Array),
+    required: !0
+  },
+  /**
+   * @description placeholder, the default is 'Please select'
+   */
+  placeholder: {
+    type: String
+  },
+  /**
+   * @description whether select dropdown is teleported, if `true` it will be teleported to where `append-to` sets
+   */
+  teleported: Ye.teleported,
+  /**
+   * @description when select dropdown is inactive and `persistent` is `false`, select dropdown will be destroyed
+   */
+  persistent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description custom class name for Select's dropdown
+   */
+  popperClass: Ye.popperClass,
+  /**
+   * @description custom style for Select's dropdown
+   */
+  popperStyle: Ye.popperStyle,
+  /**
+   * @description [popper.js](https://popper.js.org/docs/v2/) parameters
+   */
+  popperOptions: {
+    type: Q(Object),
+    default: () => ({})
+  },
+  /**
+   * @description whether search data from server
+   */
+  remote: Boolean,
+  /**
+   * @description debounce delay during remote search, in milliseconds
+   */
+  debounce: {
+    type: Number,
+    default: 300
+  },
+  /**
+   * @description size of component
+   */
+  size: Nn,
+  /**
+   * @description configuration options, see the following table
+   */
+  props: {
+    type: Q(Object),
+    default: () => yn
+  },
+  /**
+   * @description unique identity key name for value, required when value is an object
+   */
+  valueKey: {
+    type: String,
+    default: "value"
+  },
+  /**
+   * @description Controls whether the scrollbar is always displayed
+   */
+  scrollbarAlwaysOn: Boolean,
+  /**
+   * @description whether to trigger form validation
+   */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description offset of the dropdown
+   */
+  offset: {
+    type: Number,
+    default: 12
+  },
+  /**
+   * @description in remote search method show suffix icon
+   */
+  remoteShowSuffix: Boolean,
+  /**
+   * @description Determines whether the arrow is displayed
+   */
+  showArrow: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description position of dropdown
+   */
+  placement: {
+    type: Q(String),
+    values: pn,
+    default: "bottom-start"
+  },
+  /**
+   * @description list of possible positions for dropdown
+   */
+  fallbackPlacements: {
+    type: Q(Array),
+    default: ["bottom-start", "top-start", "right", "left"]
+  },
+  /**
+   * @description tag type
+   */
+  tagType: { ...qt.type, default: "info" },
+  /**
+   * @description tag effect
+   */
+  tagEffect: { ...qt.effect, default: "light" },
+  /**
+   * @description tabindex for input
+   */
+  tabindex: {
+    type: [String, Number],
+    default: 0
+  },
+  /**
+   * @description which element the select dropdown appends to
+   */
+  appendTo: Ye.appendTo,
+  /**
+   * @description if it is `true`, the width of the dropdown panel is the same as the input box.
+   * if it is `false`, the width is automatically calculated based on the value of `label`,
+   * or it can be set to a number to make it a fixed width
+   */
+  fitInputWidth: {
+    type: [Boolean, Number],
+    default: !0,
+    validator(e) {
+      return Ln(e) || Oe(e);
+    }
+  },
+  suffixIcon: {
+    type: Ut,
+    default: Mn
+  },
+  ...vn,
+  ...Bn(["ariaLabel"])
+}), lo = Re({
+  data: Array,
+  disabled: Boolean,
+  hovering: Boolean,
+  item: {
+    type: Q(Object),
+    required: !0
+  },
+  index: Number,
+  style: Object,
+  selected: Boolean,
+  created: Boolean
+}), no = {
+  [tl]: (e) => !0,
+  [el]: (e) => !0,
+  "remove-tag": (e) => !0,
+  "visible-change": (e) => !0,
+  focus: (e) => e instanceof FocusEvent,
+  blur: (e) => e instanceof FocusEvent,
+  clear: () => !0
+}, oo = {
+  hover: (e) => Oe(e),
+  select: (e, t) => !0
+}, Ot = /* @__PURE__ */ Symbol(
+  "ElSelectV2Injection"
+);
+var ao = Ce({
+  props: lo,
+  emits: oo,
+  setup(e, { emit: t }) {
+    const n = Jt(Ot), a = be("select"), { hoverItem: r, selectOptionClick: d } = eo(e, { emit: t }), { getLabel: v } = tt(n.props), h = n.contentId;
+    return {
+      ns: a,
+      contentId: h,
+      hoverItem: r,
+      selectOptionClick: d,
+      getLabel: v
+    };
+  }
+});
+const so = ["id", "aria-selected", "aria-disabled"];
+function io(e, t, n, a, r, d) {
+  return K(), ce("li", {
+    id: `${e.contentId}-${e.index}`,
+    role: "option",
+    "aria-selected": e.selected,
+    "aria-disabled": e.disabled || void 0,
+    style: Ae(e.style),
+    class: N([
+      e.ns.be("dropdown", "item"),
+      e.ns.is("selected", e.selected),
+      e.ns.is("disabled", e.disabled),
+      e.ns.is("created", e.created),
+      e.ns.is("hovering", e.hovering)
+    ]),
+    onMousemove: t[0] || (t[0] = (...v) => e.hoverItem && e.hoverItem(...v)),
+    onClick: t[1] || (t[1] = oe((...v) => e.selectOptionClick && e.selectOptionClick(...v), ["stop"]))
+  }, [
+    ue(e.$slots, "default", {
+      item: e.item,
+      index: e.index,
+      disabled: e.disabled
+    }, () => [
+      j(
+        "span",
+        null,
+        me(e.getLabel(e.item)),
+        1
+        /* TEXT */
+      )
+    ])
+  ], 46, so);
+}
+var ro = /* @__PURE__ */ St(ao, [["render", io]]), jt = Number.isNaN || function(t) {
+  return typeof t == "number" && t !== t;
+};
+function uo(e, t) {
+  return !!(e === t || jt(e) && jt(t));
+}
+function co(e, t) {
+  if (e.length !== t.length)
+    return !1;
+  for (var n = 0; n < e.length; n++)
+    if (!uo(e[n], t[n]))
+      return !1;
+  return !0;
+}
+function fo(e, t) {
+  t === void 0 && (t = co);
+  var n = null;
+  function a() {
+    for (var r = [], d = 0; d < arguments.length; d++)
+      r[d] = arguments[d];
+    if (n && n.lastThis === this && t(r, n.lastArgs))
+      return n.lastResult;
+    var v = e.apply(this, r);
+    return n = {
+      lastResult: v,
+      lastArgs: r,
+      lastThis: this
+    }, v;
+  }
+  return a.clear = function() {
+    n = null;
+  }, a;
+}
+const mo = () => {
+  const t = xt().proxy.$props;
+  return b(() => {
+    const n = (a, r, d) => ({});
+    return t.perfMode ? En(n) : fo(n);
+  });
+}, vo = 50, Qt = "itemRendered", Zt = "scroll", rl = "forward", ul = "backward", Pe = "auto", cl = "smart", dl = "start", _e = "center", fl = "end", Me = "horizontal", ml = "vertical", po = "ltr", Je = "rtl", vt = "negative", vl = "positive-ascending", pl = "positive-descending", ho = {
+  [Me]: "left",
+  [ml]: "top"
+}, go = 20, bo = ({ atEndEdge: e, atStartEdge: t, layout: n }, a) => {
+  let r, d = 0;
+  const v = (y) => y < 0 && t.value || y > 0 && e.value;
+  return {
+    hasReachedEdge: v,
+    onWheel: (y) => {
+      il(r);
+      let { deltaX: S, deltaY: i } = y;
+      y.shiftKey && i !== 0 && (S = i, i = 0);
+      const m = n.value === Me ? S : i;
+      v(m) || (d += m, !Kn() && m !== 0 && y.preventDefault(), r = sl(() => {
+        a(d), d = 0;
+      }));
+    }
+  };
+}, pt = Ie({
+  type: Q([Number, Function]),
+  required: !0
+}), ht = Ie({
+  type: Number
+}), gt = Ie({
+  type: Number,
+  default: 2
+}), yo = Ie({
+  type: String,
+  values: ["ltr", "rtl"],
+  default: "ltr"
+}), bt = Ie({
+  type: Number,
+  default: 0
+}), et = Ie({
+  type: Number,
+  required: !0
+}), hl = Ie({
+  type: String,
+  values: ["horizontal", "vertical"],
+  default: ml
+}), gl = Re({
+  className: {
+    type: String,
+    default: ""
+  },
+  containerElement: {
+    type: Q([String, Object]),
+    default: "div"
+  },
+  data: {
+    type: Q(Array),
+    default: () => Un([])
+  },
+  /**
+   * @description controls the horizontal direction.
+   */
+  direction: yo,
+  height: {
+    type: [String, Number],
+    required: !0
+  },
+  innerElement: {
+    type: [String, Object],
+    default: "div"
+  },
+  innerProps: {
+    type: Q(Object),
+    default: () => ({})
+  },
+  style: {
+    type: Q([Object, String, Array])
+  },
+  useIsScrolling: Boolean,
+  width: {
+    type: [Number, String],
+    required: !1
+  },
+  perfMode: {
+    type: Boolean,
+    default: !0
+  },
+  scrollbarAlwaysOn: Boolean
+}), So = Re({
+  /**
+   * @description describes how many items should be pre rendered to the head
+   * and the tail of the window
+   */
+  cache: gt,
+  estimatedItemSize: ht,
+  /**
+   * @description controls the list's orientation
+   */
+  layout: hl,
+  initScrollOffset: bt,
+  /**
+   * @description describes the total number of the list.
+   */
+  total: et,
+  itemSize: pt,
+  ...gl
+}), yt = {
+  type: Number,
+  default: 6
+}, bl = { type: Number, default: 0 }, yl = { type: Number, default: 2 };
+Re({
+  columnCache: gt,
+  columnWidth: pt,
+  estimatedColumnWidth: ht,
+  estimatedRowHeight: ht,
+  initScrollLeft: bt,
+  initScrollTop: bt,
+  itemKey: {
+    type: Q(Function),
+    default: ({
+      columnIndex: e,
+      rowIndex: t
+    }) => `${t}:${e}`
+  },
+  rowCache: gt,
+  rowHeight: pt,
+  totalColumn: et,
+  totalRow: et,
+  hScrollbarSize: yt,
+  vScrollbarSize: yt,
+  scrollbarStartGap: bl,
+  scrollbarEndGap: yl,
+  role: String,
+  ...gl
+});
+const wo = Re({
+  alwaysOn: Boolean,
+  class: String,
+  layout: hl,
+  total: et,
+  ratio: {
+    type: Number,
+    required: !0
+  },
+  clientSize: {
+    type: Number,
+    required: !0
+  },
+  scrollFrom: {
+    type: Number,
+    required: !0
+  },
+  scrollbarSize: yt,
+  startGap: bl,
+  endGap: yl,
+  visible: Boolean
+}), ct = (e, t) => e < t ? rl : ul, He = (e) => e === po || e === Je || e === Me;
+let Ee = null;
+function Yt(e = !1) {
+  if (Ee === null || e) {
+    const t = document.createElement("div"), n = t.style;
+    n.width = "50px", n.height = "50px", n.overflow = "scroll", n.direction = "rtl";
+    const a = document.createElement("div"), r = a.style;
+    return r.width = "100px", r.height = "100px", t.appendChild(a), document.body.appendChild(t), t.scrollLeft > 0 ? Ee = pl : (t.scrollLeft = 1, t.scrollLeft === 0 ? Ee = vt : Ee = vl), document.body.removeChild(t), Ee;
+  }
+  return Ee;
+}
+function Oo({ move: e, size: t, bar: n }, a) {
+  const r = {}, d = `translate${n.axis}(${e}px)`;
+  return r[n.size] = t, r.transform = d, a === "horizontal" ? r.height = "100%" : r.width = "100%", r;
+}
+const Io = Ce({
+  name: "ElVirtualScrollBar",
+  props: wo,
+  emits: ["scroll", "start-move", "stop-move"],
+  setup(e, { emit: t }) {
+    const n = b(() => e.startGap + e.endGap), a = be("virtual-scrollbar"), r = be("scrollbar"), d = L(), v = L();
+    let h = null, y = null;
+    const S = xe({
+      isDragging: !1,
+      traveled: 0
+    }), i = b(() => hn[e.layout]), m = b(() => e.clientSize - T(n)), V = b(() => ({
+      position: "absolute",
+      width: `${Me === e.layout ? m.value : e.scrollbarSize}px`,
+      height: `${Me === e.layout ? e.scrollbarSize : m.value}px`,
+      [ho[e.layout]]: "2px",
+      right: "2px",
+      bottom: "2px",
+      borderRadius: "4px"
+    })), u = b(() => {
+      const w = e.ratio;
+      if (w >= 100)
+        return Number.POSITIVE_INFINITY;
+      if (w >= 50)
+        return w * m.value / 100;
+      const D = m.value / 3;
+      return Math.floor(
+        Math.min(
+          Math.max(w * m.value / 100, go),
+          D
+        )
+      );
+    }), M = b(() => {
+      if (!Number.isFinite(u.value))
+        return {
+          display: "none"
+        };
+      const w = `${u.value}px`;
+      return Oo(
+        {
+          bar: i.value,
+          size: w,
+          move: S.traveled
+        },
+        e.layout
+      );
+    }), C = b(
+      () => Math.ceil(e.clientSize - u.value - T(n))
+    ), o = () => {
+      window.addEventListener("mousemove", E), window.addEventListener("mouseup", J);
+      const w = T(v);
+      w && (y = document.onselectstart, document.onselectstart = () => !1, w.addEventListener("touchmove", E, { passive: !0 }), w.addEventListener("touchend", J));
+    }, B = () => {
+      window.removeEventListener("mousemove", E), window.removeEventListener("mouseup", J), document.onselectstart = y, y = null;
+      const w = T(v);
+      w && (w.removeEventListener("touchmove", E), w.removeEventListener("touchend", J));
+    }, te = (w) => {
+      w.stopImmediatePropagation(), !(w.ctrlKey || [1, 2].includes(w.button)) && (S.isDragging = !0, S[i.value.axis] = w.currentTarget[i.value.offset] - (w[i.value.client] - w.currentTarget.getBoundingClientRect()[i.value.direction]), t("start-move"), o());
+    }, J = () => {
+      S.isDragging = !1, S[i.value.axis] = 0, t("stop-move"), B();
+    }, E = (w) => {
+      const { isDragging: D } = S;
+      if (!D || !v.value || !d.value) return;
+      const le = S[i.value.axis];
+      if (!le) return;
+      il(h);
+      const Z = (d.value.getBoundingClientRect()[i.value.direction] - w[i.value.client]) * -1, G = v.value[i.value.offset] - le, O = Z - G;
+      h = sl(() => {
+        S.traveled = Math.max(0, Math.min(O, C.value)), t("scroll", O, C.value);
+      });
+    }, ee = (w) => {
+      const D = Math.abs(
+        w.target.getBoundingClientRect()[i.value.direction] - w[i.value.client]
+      ), le = v.value[i.value.offset] / 2, Z = D - le;
+      S.traveled = Math.max(0, Math.min(Z, C.value)), t("scroll", Z, C.value);
+    };
+    return ve(
+      () => e.scrollFrom,
+      (w) => {
+        S.isDragging || (S.traveled = Math.ceil(w * C.value));
+      }
+    ), ln(() => {
+      B();
+    }), () => we(
+      "div",
+      {
+        role: "presentation",
+        ref: d,
+        class: [
+          a.b(),
+          e.class,
+          (e.alwaysOn || S.isDragging) && "always-on"
+        ],
+        style: V.value,
+        onMousedown: oe(ee, [
+          "stop",
+          "prevent"
+        ]),
+        onTouchstartPrevent: te
+      },
+      we(
+        "div",
+        {
+          ref: v,
+          class: r.e("thumb"),
+          style: M.value,
+          onMousedown: te
+        },
+        []
+      )
+    );
+  }
+}), Sl = ({
+  name: e,
+  getOffset: t,
+  getItemSize: n,
+  getItemOffset: a,
+  getEstimatedTotalSize: r,
+  getStartIndexForOffset: d,
+  getStopIndexForStartIndex: v,
+  initCache: h,
+  clearCache: y,
+  validateProps: S
+}) => Ce({
+  name: e ?? "ElVirtualList",
+  props: So,
+  emits: [Qt, Zt],
+  setup(i, { emit: m, expose: V }) {
+    S(i);
+    const u = xt(), M = be("vl"), C = L(h(i, u)), o = mo(), B = L(), te = L(), J = L(), E = L({
+      isScrolling: !1,
+      scrollDir: "forward",
+      scrollOffset: Oe(i.initScrollOffset) ? i.initScrollOffset : 0,
+      updateRequested: !1,
+      isScrollbarDragging: !1,
+      scrollbarAlwaysOn: i.scrollbarAlwaysOn
+    }), ee = b(() => {
+      const { total: f, cache: g } = i, { isScrolling: R, scrollDir: P, scrollOffset: z } = T(E);
+      if (f === 0)
+        return [0, 0, 0, 0];
+      const W = d(
+        i,
+        z,
+        T(C)
+      ), H = v(
+        i,
+        W,
+        z,
+        T(C)
+      ), pe = !R || P === ul ? Math.max(1, g) : 1, fe = !R || P === rl ? Math.max(1, g) : 1;
+      return [
+        Math.max(0, W - pe),
+        Math.max(0, Math.min(f - 1, H + fe)),
+        W,
+        H
+      ];
+    }), w = b(
+      () => r(i, T(C))
+    ), D = b(() => He(i.layout)), le = b(() => [
+      {
+        position: "relative",
+        [`overflow-${D.value ? "x" : "y"}`]: "scroll",
+        WebkitOverflowScrolling: "touch",
+        willChange: "transform"
+      },
+      {
+        direction: i.direction,
+        height: Oe(i.height) ? `${i.height}px` : i.height,
+        width: Oe(i.width) ? `${i.width}px` : i.width
+      },
+      i.style
+    ]), Z = b(() => {
+      const f = T(w), g = T(D);
+      return {
+        height: g ? "100%" : `${f}px`,
+        pointerEvents: T(E).isScrolling ? "none" : void 0,
+        width: g ? `${f}px` : "100%",
+        // fix scrolling issues in Firefox.
+        margin: 0,
+        boxSizing: "border-box"
+      };
+    }), G = b(
+      () => D.value ? i.width : i.height
+    ), { onWheel: O } = bo(
+      {
+        atStartEdge: b(() => E.value.scrollOffset <= 0),
+        atEndEdge: b(
+          () => E.value.scrollOffset >= w.value
+        ),
+        layout: b(() => i.layout)
+      },
+      (f) => {
+        var g, R;
+        (R = (g = J.value).onMouseUp) == null || R.call(g), k(
+          Math.min(
+            E.value.scrollOffset + f,
+            w.value - G.value
+          )
+        );
+      }
+    );
+    Pn(B, "wheel", O, {
+      passive: !1
+    });
+    const I = () => {
+      const { total: f } = i;
+      if (f > 0) {
+        const [z, W, H, pe] = T(ee);
+        m(Qt, z, W, H, pe);
+      }
+      const { scrollDir: g, scrollOffset: R, updateRequested: P } = T(E);
+      m(Zt, g, R, P);
+    }, $ = (f) => {
+      const { clientHeight: g, scrollHeight: R, scrollTop: P } = f.currentTarget, z = T(E);
+      if (z.scrollOffset === P)
+        return;
+      const W = Math.max(
+        0,
+        Math.min(P, R - g)
+      );
+      E.value = {
+        ...z,
+        isScrolling: !0,
+        scrollDir: ct(z.scrollOffset, W),
+        scrollOffset: W,
+        updateRequested: !1
+      }, ae(ie);
+    }, q = (f) => {
+      const { clientWidth: g, scrollLeft: R, scrollWidth: P } = f.currentTarget, z = T(E);
+      if (z.scrollOffset === R)
+        return;
+      const { direction: W } = i;
+      let H = R;
+      if (W === Je)
+        switch (Yt()) {
+          case vt: {
+            H = -R;
+            break;
+          }
+          case pl: {
+            H = P - g - R;
+            break;
+          }
+        }
+      H = Math.max(
+        0,
+        Math.min(H, P - g)
+      ), E.value = {
+        ...z,
+        isScrolling: !0,
+        scrollDir: ct(z.scrollOffset, H),
+        scrollOffset: H,
+        updateRequested: !1
+      }, ae(ie);
+    }, U = (f) => {
+      T(D) ? q(f) : $(f), I();
+    }, x = (f, g) => {
+      const R = (w.value - G.value) / g * f;
+      k(
+        Math.min(
+          w.value - G.value,
+          R
+        )
+      );
+    }, k = (f) => {
+      f = Math.max(f, 0), f !== T(E).scrollOffset && (E.value = {
+        ...T(E),
+        scrollOffset: f,
+        scrollDir: ct(T(E).scrollOffset, f),
+        updateRequested: !0
+      }, ae(ie));
+    }, Y = (f, g = Pe) => {
+      const { scrollOffset: R } = T(E);
+      f = Math.max(0, Math.min(f, i.total - 1)), k(
+        t(
+          i,
+          f,
+          g,
+          R,
+          T(C)
+        )
+      );
+    }, se = (f) => {
+      const { direction: g, itemSize: R, layout: P } = i, z = o.value(
+        y && R,
+        y && P,
+        y && g
+      );
+      let W;
+      if (Rn(z, String(f)))
+        W = z[f];
+      else {
+        const H = a(i, f, T(C)), pe = n(i, f, T(C)), fe = T(D), We = g === Je, ze = fe ? H : 0;
+        z[f] = W = {
+          position: "absolute",
+          left: We ? void 0 : `${ze}px`,
+          right: We ? `${ze}px` : void 0,
+          top: fe ? 0 : `${H}px`,
+          height: fe ? "100%" : `${pe}px`,
+          width: fe ? `${pe}px` : "100%"
+        };
+      }
+      return W;
+    }, ie = () => {
+      E.value.isScrolling = !1, ae(() => {
+        o.value(-1, null, null);
+      });
+    }, A = () => {
+      const f = B.value;
+      f && (f.scrollTop = 0);
+    };
+    _t(() => {
+      if (!wt) return;
+      const { initScrollOffset: f } = i, g = T(B);
+      Oe(f) && g && (T(D) ? g.scrollLeft = f : g.scrollTop = f), I();
+    }), nn(() => {
+      const { direction: f, layout: g } = i, { scrollOffset: R, updateRequested: P } = T(E), z = T(B);
+      if (P && z)
+        if (g === Me)
+          if (f === Je)
+            switch (Yt()) {
+              case vt: {
+                z.scrollLeft = -R;
+                break;
+              }
+              case vl: {
+                z.scrollLeft = R;
+                break;
+              }
+              default: {
+                const { clientWidth: W, scrollWidth: H } = z;
+                z.scrollLeft = H - W - R;
+                break;
+              }
+            }
+          else
+            z.scrollLeft = R;
+        else
+          z.scrollTop = R;
+    }), on(() => {
+      T(B).scrollTop = T(E).scrollOffset;
+    });
+    const re = {
+      ns: M,
+      clientSize: G,
+      estimatedTotalSize: w,
+      windowStyle: le,
+      windowRef: B,
+      innerRef: te,
+      innerStyle: Z,
+      itemsToRender: ee,
+      scrollbarRef: J,
+      states: E,
+      getItemStyle: se,
+      onScroll: U,
+      onScrollbarScroll: x,
+      onWheel: O,
+      scrollTo: k,
+      scrollToItem: Y,
+      resetScrollTop: A
+    };
+    return V({
+      windowRef: B,
+      innerRef: te,
+      getItemStyleCache: o,
+      scrollTo: k,
+      scrollToItem: Y,
+      resetScrollTop: A,
+      states: E
+    }), re;
+  },
+  render(i) {
+    var m;
+    const {
+      $slots: V,
+      className: u,
+      clientSize: M,
+      containerElement: C,
+      data: o,
+      getItemStyle: B,
+      innerElement: te,
+      itemsToRender: J,
+      innerStyle: E,
+      layout: ee,
+      total: w,
+      onScroll: D,
+      onScrollbarScroll: le,
+      states: Z,
+      useIsScrolling: G,
+      windowStyle: O,
+      ns: I
+    } = i, [$, q] = J, U = Be(C), x = Be(te), k = [];
+    if (w > 0)
+      for (let A = $; A <= q; A++)
+        k.push(
+          we(
+            dt,
+            { key: A },
+            (m = V.default) == null ? void 0 : m.call(V, {
+              data: o,
+              index: A,
+              isScrolling: G ? Z.isScrolling : void 0,
+              style: B(A)
+            })
+          )
+        );
+    const Y = [
+      we(
+        x,
+        ft(i.innerProps, {
+          style: E,
+          ref: "innerRef"
+        }),
+        mt(x) ? k : {
+          default: () => k
+        }
+      )
+    ], se = we(Io, {
+      ref: "scrollbarRef",
+      clientSize: M,
+      layout: ee,
+      onScroll: le,
+      ratio: M * 100 / this.estimatedTotalSize,
+      scrollFrom: Z.scrollOffset / (this.estimatedTotalSize - M),
+      total: w,
+      alwaysOn: Z.scrollbarAlwaysOn
+    }), ie = we(
+      U,
+      {
+        class: [I.e("window"), u],
+        style: O,
+        onScroll: D,
+        ref: "windowRef",
+        key: 0
+      },
+      mt(U) ? [Y] : { default: () => [Y] }
+    );
+    return we(
+      "div",
+      {
+        key: 0,
+        class: [I.e("wrapper"), Z.scrollbarAlwaysOn ? "always-on" : ""]
+      },
+      [ie, se]
+    );
+  }
+}), Vo = Sl({
+  name: "ElFixedSizeList",
+  getItemOffset: ({ itemSize: e }, t) => t * e,
+  getItemSize: ({ itemSize: e }) => e,
+  getEstimatedTotalSize: ({ total: e, itemSize: t }) => t * e,
+  getOffset: ({ height: e, total: t, itemSize: n, layout: a, width: r }, d, v, h) => {
+    const y = He(a) ? r : e;
+    process.env.NODE_ENV !== "production" && mt(y) && ll(
+      "[ElVirtualList]",
+      `
+        You should set
+          width/height
+        to number when your layout is
+          horizontal/vertical
+      `
+    );
+    const S = Math.max(0, t * n - y), i = Math.min(S, d * n), m = Math.max(0, (d + 1) * n - y);
+    switch (v === cl && (h >= m - y && h <= i + y ? v = Pe : v = _e), v) {
+      case dl:
+        return i;
+      case fl:
+        return m;
+      case _e: {
+        const V = Math.round(m + (i - m) / 2);
+        return V < Math.ceil(y / 2) ? 0 : V > S + Math.floor(y / 2) ? S : V;
+      }
+      case Pe:
+      default:
+        return h >= m && h <= i ? h : h < m ? m : i;
+    }
+  },
+  getStartIndexForOffset: ({ total: e, itemSize: t }, n) => Math.max(0, Math.min(e - 1, Math.floor(n / t))),
+  getStopIndexForStartIndex: ({ height: e, total: t, itemSize: n, layout: a, width: r }, d, v) => {
+    const h = d * n, y = He(a) ? r : e, S = Math.ceil(
+      (y + v - h) / n
+    );
+    return Math.max(
+      0,
+      Math.min(
+        t - 1,
+        // because startIndex is inclusive, so in order to prevent array outbound indexing
+        // we need to - 1 to prevent outbound behavior
+        d + S - 1
+      )
+    );
+  },
+  /**
+   * Fixed size list does not need this cache
+   * Using any to bypass it, TODO: Using type inference to fix this.
+   */
+  initCache() {
+  },
+  clearCache: !0,
+  validateProps() {
+  }
+}), Eo = "ElDynamicSizeList", Te = (e, t, n) => {
+  const { itemSize: a } = e, { items: r, lastVisitedIndex: d } = n;
+  if (t > d) {
+    let v = 0;
+    if (d >= 0) {
+      const h = r[d];
+      v = h.offset + h.size;
+    }
+    for (let h = d + 1; h <= t; h++) {
+      const y = a(h);
+      r[h] = {
+        offset: v,
+        size: y
+      }, v += y;
+    }
+    n.lastVisitedIndex = t;
+  }
+  return r[t];
+}, To = (e, t, n) => {
+  const { items: a, lastVisitedIndex: r } = t;
+  return (r > 0 ? a[r].offset : 0) >= n ? wl(e, t, 0, r, n) : Mo(e, t, Math.max(0, r), n);
+}, wl = (e, t, n, a, r) => {
+  for (; n <= a; ) {
+    const d = n + Math.floor((a - n) / 2), v = Te(e, d, t).offset;
+    if (v === r)
+      return d;
+    v < r ? n = d + 1 : v > r && (a = d - 1);
+  }
+  return Math.max(0, n - 1);
+}, Mo = (e, t, n, a) => {
+  const { total: r } = e;
+  let d = 1;
+  for (; n < r && Te(e, n, t).offset < a; )
+    n += d, d *= 2;
+  return wl(
+    e,
+    t,
+    Math.floor(n / 2),
+    Math.min(n, r - 1),
+    a
+  );
+}, Xt = ({ total: e }, { items: t, estimatedItemSize: n, lastVisitedIndex: a }) => {
+  let r = 0;
+  if (a >= e && (a = e - 1), a >= 0) {
+    const h = t[a];
+    r = h.offset + h.size;
+  }
+  const v = (e - a - 1) * n;
+  return r + v;
+}, Co = Sl({
+  name: "ElDynamicSizeList",
+  getItemOffset: (e, t, n) => Te(e, t, n).offset,
+  getItemSize: (e, t, { items: n }) => n[t].size,
+  getEstimatedTotalSize: Xt,
+  getOffset: (e, t, n, a, r) => {
+    const { height: d, layout: v, width: h } = e, y = He(v) ? h : d, S = Te(e, t, r), i = Xt(e, r), m = Math.max(
+      0,
+      Math.min(i - y, S.offset)
+    ), V = Math.max(0, S.offset - y + S.size);
+    switch (n === cl && (a >= V - y && a <= m + y ? n = Pe : n = _e), n) {
+      case dl:
+        return m;
+      case fl:
+        return V;
+      case _e:
+        return Math.round(V + (m - V) / 2);
+      case Pe:
+      default:
+        return a >= V && a <= m ? a : a < V ? V : m;
+    }
+  },
+  getStartIndexForOffset: (e, t, n) => To(e, n, t),
+  getStopIndexForStartIndex: (e, t, n, a) => {
+    const { height: r, total: d, layout: v, width: h } = e, y = He(v) ? h : r, S = Te(e, t, a), i = n + y;
+    let m = S.offset + S.size, V = t;
+    for (; V < d - 1 && m < i; )
+      V++, m += Te(e, V, a).size;
+    return V;
+  },
+  initCache({ estimatedItemSize: e = vo }, t) {
+    const n = {
+      items: {},
+      estimatedItemSize: e,
+      lastVisitedIndex: -1
+    };
+    return n.clearCacheAfterIndex = (a, r = !0) => {
+      var d, v;
+      n.lastVisitedIndex = Math.min(n.lastVisitedIndex, a - 1), (d = t.exposed) == null || d.getItemStyleCache(-1), r && ((v = t.proxy) == null || v.$forceUpdate());
+    }, n;
+  },
+  clearCache: !1,
+  validateProps: ({ itemSize: e }) => {
+    process.env.NODE_ENV !== "production" && typeof e != "function" && ll(
+      Eo,
+      `
+          itemSize is required as function, but the given value was ${typeof e}
+        `
+    );
+  }
+}), Ro = {
+  loading: Boolean,
+  data: {
+    type: Array,
+    required: !0
+  },
+  hoveringIndex: Number,
+  width: Number,
+  id: String,
+  ariaLabel: String
+};
+var zo = /* @__PURE__ */ Ce({
+  name: "ElSelectDropdown",
+  props: Ro,
+  setup(e, {
+    slots: t,
+    expose: n
+  }) {
+    const a = Jt(Ot), r = be("select"), {
+      getLabel: d,
+      getValue: v,
+      getDisabled: h
+    } = tt(a.props), y = L([]), S = L(), i = b(() => e.data.length);
+    ve(() => i.value, () => {
+      var O, I;
+      (I = (O = a.tooltipRef.value) == null ? void 0 : O.updatePopper) == null || I.call(O);
+    });
+    const m = b(() => nl(a.props.estimatedOptionHeight)), V = b(() => m.value ? {
+      itemSize: a.props.itemHeight
+    } : {
+      estimatedSize: a.props.estimatedOptionHeight,
+      itemSize: (O) => y.value[O]
+    }), u = (O = [], I) => {
+      const {
+        props: {
+          valueKey: $
+        }
+      } = a;
+      return Fe(I) ? O && O.some((q) => an(ge(q, $)) === ge(I, $)) : O.includes(I);
+    }, M = (O, I) => {
+      if (Fe(I)) {
+        const {
+          valueKey: $
+        } = a.props;
+        return ge(O, $) === ge(I, $);
+      } else
+        return O === I;
+    }, C = (O, I) => a.props.multiple ? u(O, v(I)) : M(O, v(I)), o = (O, I) => {
+      const {
+        disabled: $,
+        multiple: q,
+        multipleLimit: U
+      } = a.props;
+      return $ || !I && (q ? U > 0 && O.length >= U : !1);
+    }, B = (O) => e.hoveringIndex === O;
+    n({
+      listRef: S,
+      isSized: m,
+      isItemDisabled: o,
+      isItemHovering: B,
+      isItemSelected: C,
+      scrollToItem: (O) => {
+        const I = S.value;
+        I && I.scrollToItem(O);
+      },
+      resetScrollTop: () => {
+        const O = S.value;
+        O && O.resetScrollTop();
+      }
+    });
+    const ee = (O) => {
+      const {
+        index: I,
+        data: $,
+        style: q
+      } = O, U = T(m), {
+        itemSize: x,
+        estimatedSize: k
+      } = T(V), {
+        modelValue: Y
+      } = a.props, {
+        onSelect: se,
+        onHover: ie
+      } = a, A = $[I];
+      if (A.type === "Group")
+        return de(_n, {
+          item: A,
+          style: q,
+          height: U ? x : k
+        }, null);
+      const re = C(Y, A), f = o(Y, re), g = B(I);
+      return de(ro, ft(O, {
+        selected: re,
+        disabled: h(A) || f,
+        created: !!A.created,
+        hovering: g,
+        item: A,
+        onSelect: se,
+        onHover: ie
+      }), {
+        default: (R) => {
+          var P;
+          return ((P = t.default) == null ? void 0 : P.call(t, R)) || de("span", null, [d(A)]);
+        }
+      });
+    }, {
+      onKeyboardNavigate: w,
+      onKeyboardSelect: D
+    } = a, le = () => {
+      w("forward");
+    }, Z = () => {
+      w("backward");
+    }, G = (O) => {
+      const I = ol(O), {
+        tab: $,
+        esc: q,
+        down: U,
+        up: x,
+        enter: k,
+        numpadEnter: Y
+      } = al;
+      switch ([q, U, x, k, Y].includes(I) && (O.preventDefault(), O.stopPropagation()), I) {
+        case $:
+        case q:
+          break;
+        case U:
+          le();
+          break;
+        case x:
+          Z();
+          break;
+        case k:
+        case Y:
+          D();
+          break;
+      }
+    };
+    return () => {
+      var O, I, $, q;
+      const {
+        data: U,
+        width: x
+      } = e, {
+        height: k,
+        multiple: Y,
+        scrollbarAlwaysOn: se
+      } = a.props, ie = b(() => Hn ? !0 : se), A = T(m) ? Vo : Co;
+      return de("div", {
+        class: [r.b("dropdown"), r.is("multiple", Y)],
+        style: {
+          width: `${x}px`
+        }
+      }, [(O = t.header) == null ? void 0 : O.call(t), ((I = t.loading) == null ? void 0 : I.call(t)) || (($ = t.empty) == null ? void 0 : $.call(t)) || de(A, ft({
+        ref: S
+      }, T(V), {
+        className: r.be("dropdown", "list"),
+        scrollbarAlwaysOn: ie.value,
+        data: U,
+        height: k,
+        width: x,
+        total: U.length,
+        innerElement: "ul",
+        innerProps: {
+          id: e.id,
+          role: "listbox",
+          "aria-label": e.ariaLabel,
+          "aria-orientation": "vertical"
+        },
+        onKeydown: G
+      }), {
+        default: (re) => de(ee, re, null)
+      }), (q = t.footer) == null ? void 0 : q.call(t)]);
+    };
+  }
+});
+function No(e, t) {
+  const { aliasProps: n, getLabel: a, getValue: r } = tt(e), d = L(0), v = L(), h = b(() => e.allowCreate && e.filterable);
+  ve(
+    () => e.options,
+    (u) => {
+      const M = new Set(u.map((C) => a(C)));
+      t.createdOptions = t.createdOptions.filter(
+        (C) => !M.has(a(C))
+      );
+    }
+  );
+  function y(u) {
+    const M = (C) => a(C) === u;
+    return e.options && e.options.some(M) || t.createdOptions.some(M);
+  }
+  function S(u) {
+    h.value && (e.multiple && u.created ? d.value++ : v.value = u);
+  }
+  function i(u) {
+    if (h.value)
+      if (u && u.length > 0) {
+        if (y(u)) {
+          t.createdOptions = t.createdOptions.filter(
+            (C) => a(C) !== t.previousQuery
+          );
+          return;
+        }
+        const M = {
+          [n.value.value]: u,
+          [n.value.label]: u,
+          created: !0,
+          [n.value.disabled]: !1
+        };
+        t.createdOptions.length >= d.value ? t.createdOptions[d.value] = M : t.createdOptions.push(M);
+      } else if (e.multiple)
+        t.createdOptions.length = d.value;
+      else {
+        const M = v.value;
+        t.createdOptions.length = 0, M && M.created && t.createdOptions.push(M);
+      }
+  }
+  function m(u) {
+    if (!h.value || !u || !u.created || u.created && e.reserveKeyword && t.inputValue === a(u))
+      return;
+    const M = t.createdOptions.findIndex(
+      (C) => r(C) === r(u)
+    );
+    ~M && (t.createdOptions.splice(M, 1), d.value--);
+  }
+  function V() {
+    h.value && (t.createdOptions.length = 0, d.value = 0);
+  }
+  return {
+    createNewOption: i,
+    removeNewOption: m,
+    selectNewOption: S,
+    clearAllNewOption: V
+  };
+}
+const Lo = (e, t) => {
+  const { t: n } = jn(), a = sn(), r = be("select"), d = be("input"), { form: v, formItem: h } = Qn(), { inputId: y } = Zn(e, {
+    formItemContext: h
+  }), { aliasProps: S, getLabel: i, getValue: m, getDisabled: V, getOptions: u } = tt(e), { valueOnClear: M, isEmptyValue: C } = gn(e), o = xe({
+    inputValue: "",
+    cachedOptions: [],
+    createdOptions: [],
+    hoveringIndex: -1,
+    inputHovering: !1,
+    selectionWidth: 0,
+    collapseItemWidth: 0,
+    previousQuery: null,
+    previousValue: void 0,
+    selectedLabel: "",
+    menuVisibleOnFocus: !1,
+    isBeforeHide: !1
+  }), B = L(-1), te = L(!1), J = L(), E = L(), ee = L(), w = L(), D = L(), le = L(), Z = L(), G = L(), O = L(), I = L(), {
+    isComposing: $,
+    handleCompositionStart: q,
+    handleCompositionEnd: U,
+    handleCompositionUpdate: x
+  } = Gn({
+    afterComposition: (l) => Bt(l)
+  }), k = Dn(), { wrapperRef: Y, isFocused: se, handleBlur: ie } = qn(D, {
+    disabled: k,
+    afterFocus() {
+      e.automaticDropdown && !g.value && (g.value = !0, o.menuVisibleOnFocus = !0);
+    },
+    beforeBlur(l) {
+      var s, c;
+      return ((s = ee.value) == null ? void 0 : s.isFocusInsideContent(l)) || ((c = w.value) == null ? void 0 : c.isFocusInsideContent(l));
+    },
+    afterBlur() {
+      var l;
+      g.value = !1, o.menuVisibleOnFocus = !1, e.validateEvent && ((l = h == null ? void 0 : h.validate) == null || l.call(h, "blur").catch((s) => ut(s)));
+    }
+  }), A = b(() => It("")), re = b(() => e.loading ? !1 : e.options.length > 0 || o.createdOptions.length > 0), f = L([]), g = L(!1), R = b(() => {
+    var l;
+    return (l = v == null ? void 0 : v.statusIcon) != null ? l : !1;
+  }), P = b(() => {
+    const l = f.value.length * e.itemHeight;
+    return l > e.height ? e.height : l;
+  }), z = b(() => e.multiple ? Se(e.modelValue) && e.modelValue.length > 0 : !C(e.modelValue)), W = b(() => e.clearable && !k.value && z.value && (se.value || o.inputHovering)), H = b(
+    () => e.remote && e.filterable && !e.remoteShowSuffix ? "" : e.suffixIcon
+  ), pe = b(
+    () => H.value && r.is("reverse", g.value)
+  ), fe = b(() => (h == null ? void 0 : h.validateState) || ""), We = b(() => {
+    if (fe.value)
+      return Fn[fe.value];
+  }), ze = b(() => e.remote ? e.debounce : 0), Ol = b(
+    () => e.remote && !o.inputValue && !re.value
+  ), Il = b(() => e.loading ? e.loadingText || n("el.select.loading") : e.filterable && o.inputValue && re.value && f.value.length === 0 ? e.noMatchText || n("el.select.noMatch") : re.value ? null : e.noDataText || n("el.select.noData")), Vl = b(
+    () => e.filterable && Xe(e.filterMethod)
+  ), El = b(
+    () => e.filterable && e.remote && Xe(e.remoteMethod)
+  ), It = (l) => {
+    const s = new RegExp(zn(l), "i"), c = (p) => Vl.value || El.value ? !0 : l ? s.test(i(p) || "") : !0;
+    return e.loading ? [] : [...o.createdOptions, ...e.options].reduce((p, F) => {
+      const ne = u(F);
+      if (Se(ne)) {
+        const De = ne.filter(c);
+        De.length > 0 && p.push(
+          {
+            label: i(F),
+            type: "Group"
+          },
+          ...De
+        );
+      } else (e.remote || c(F)) && p.push(F);
+      return p;
+    }, []);
+  }, Vt = () => {
+    f.value = It(o.inputValue);
+  }, Ke = b(() => {
+    const l = /* @__PURE__ */ new Map();
+    return A.value.forEach((s, c) => {
+      l.set(_(m(s)), { option: s, index: c });
+    }), l;
+  }), Ge = b(() => {
+    const l = /* @__PURE__ */ new Map();
+    return f.value.forEach((s, c) => {
+      l.set(_(m(s)), { option: s, index: c });
+    }), l;
+  }), Tl = b(
+    () => f.value.every((l) => V(l))
+  ), Et = kn(), Ml = b(
+    () => Et.value === "small" ? "small" : "default"
+  ), Ne = () => {
+    var l;
+    if (Oe(e.fitInputWidth)) {
+      B.value = e.fitInputWidth;
+      return;
+    }
+    const s = ((l = J.value) == null ? void 0 : l.offsetWidth) || 200;
+    !e.fitInputWidth && re.value ? ae(() => {
+      B.value = Math.max(s, Cl());
+    }) : B.value = s;
+  }, Cl = () => {
+    var l, s;
+    const p = document.createElement("canvas").getContext("2d"), F = r.be("dropdown", "item"), De = (((s = (l = G.value) == null ? void 0 : l.listRef) == null ? void 0 : s.innerRef) || document).querySelector(`.${F}`);
+    if (De === null || p === null) return 0;
+    const Qe = getComputedStyle(De), xl = Number.parseFloat(Qe.paddingLeft) + Number.parseFloat(Qe.paddingRight);
+    return p.font = `bold ${Qe.font.replace(
+      new RegExp(`\\b${Qe.fontWeight}\\b`),
+      ""
+    )}`, f.value.reduce((_l, en) => {
+      const tn = p.measureText(i(en));
+      return Math.max(tn.width, _l);
+    }, 0) + xl;
+  }, Rl = () => {
+    if (!E.value) return 0;
+    const l = window.getComputedStyle(E.value);
+    return Number.parseFloat(l.gap || "6px");
+  }, zl = b(() => {
+    const l = Rl(), s = e.filterable ? l + Sn : 0;
+    return { maxWidth: `${I.value && e.maxCollapseTags === 1 ? o.selectionWidth - o.collapseItemWidth - l - s : o.selectionWidth - s}px` };
+  }), Nl = b(() => ({ maxWidth: `${o.selectionWidth}px` })), Ll = b(() => Se(e.modelValue) ? e.modelValue.length === 0 && !o.inputValue : e.filterable ? !o.inputValue : !0), Dl = b(() => {
+    var l;
+    const s = (l = e.placeholder) != null ? l : n("el.select.placeholder");
+    return e.multiple || !z.value ? s : o.selectedLabel;
+  }), kl = b(() => {
+    var l, s;
+    return (s = (l = ee.value) == null ? void 0 : l.popperRef) == null ? void 0 : s.contentRef;
+  }), Tt = b(() => {
+    if (e.multiple) {
+      const l = e.modelValue.length;
+      if (l > 0 && Ge.value.has(e.modelValue[l - 1])) {
+        const { index: s } = Ge.value.get(
+          e.modelValue[l - 1]
+        );
+        return s;
+      }
+    } else if (!C(e.modelValue) && Ge.value.has(e.modelValue)) {
+      const { index: l } = Ge.value.get(e.modelValue);
+      return l;
+    }
+    return -1;
+  }), Mt = b({
+    get() {
+      return g.value && (e.loading || !Ol.value || e.remote && !!a.empty) && (!te.value || !$n(o.previousQuery));
+    },
+    set(l) {
+      g.value = l;
+    }
+  }), $l = b(() => e.multiple ? e.collapseTags ? o.cachedOptions.slice(0, e.maxCollapseTags) : o.cachedOptions : []), Al = b(() => e.multiple ? e.collapseTags ? o.cachedOptions.slice(e.maxCollapseTags) : [] : []), {
+    createNewOption: Ct,
+    removeNewOption: lt,
+    selectNewOption: Rt,
+    clearAllNewOption: nt
+  } = No(e, o), ot = (l) => {
+    var s;
+    k.value || e.filterable && g.value && l && !((s = Z.value) != null && s.contains(l.target)) || (o.menuVisibleOnFocus ? o.menuVisibleOnFocus = !1 : g.value = !g.value);
+  }, zt = () => {
+    o.inputValue.length > 0 && !g.value && (g.value = !0), Ct(o.inputValue), ae(() => {
+      at(o.inputValue);
+    });
+  }, Nt = Wn(() => {
+    zt(), te.value = !1;
+  }, ze), at = (l) => {
+    o.previousQuery === l || $.value || (o.previousQuery = l, e.filterable && Xe(e.filterMethod) ? e.filterMethod(l) : e.filterable && e.remote && Xe(e.remoteMethod) && e.remoteMethod(l), e.defaultFirstOption && (e.filterable || e.remote) && f.value.length ? ae(Bl) : ae(Zl));
+  }, Bl = () => {
+    const l = f.value.filter(
+      (p) => !p.disabled && p.type !== "Group"
+    ), s = l.find((p) => p.created), c = l[0];
+    o.hoveringIndex = st(
+      f.value,
+      s || c
+    );
+  }, Fl = (l) => {
+    $e(e.modelValue, l) || t(el, l);
+  }, Le = (l) => {
+    t(tl, l), Fl(l), o.previousValue = e.multiple ? String(l) : l, ae(() => {
+      if (e.multiple && Se(e.modelValue)) {
+        const s = o.cachedOptions.slice(), c = e.modelValue.map(
+          (p) => Ft(p, s)
+        );
+        $e(o.cachedOptions, c) || (o.cachedOptions = c);
+      } else
+        Ue(!0);
+    });
+  }, st = (l = [], s) => {
+    if (!Fe(s))
+      return l.indexOf(s);
+    const c = e.valueKey;
+    let p = -1;
+    return l.some((F, ne) => ge(F, c) === ge(s, c) ? (p = ne, !0) : !1), p;
+  }, _ = (l) => Fe(l) ? ge(l, e.valueKey) : l, Lt = () => {
+    Ne();
+  }, Dt = () => {
+    o.selectionWidth = Number.parseFloat(
+      window.getComputedStyle(E.value).width
+    );
+  }, Pl = () => {
+    o.collapseItemWidth = I.value.getBoundingClientRect().width;
+  }, it = () => {
+    var l, s;
+    (s = (l = ee.value) == null ? void 0 : l.updatePopper) == null || s.call(l);
+  }, kt = () => {
+    var l, s;
+    (s = (l = w.value) == null ? void 0 : l.updatePopper) == null || s.call(l);
+  }, $t = (l) => {
+    const s = m(l);
+    if (e.multiple) {
+      let c = e.modelValue.slice();
+      const p = st(c, s);
+      p > -1 ? (c = [
+        ...c.slice(0, p),
+        ...c.slice(p + 1)
+      ], o.cachedOptions.splice(p, 1), lt(l)) : (e.multipleLimit <= 0 || c.length < e.multipleLimit) && (c = [...c, s], o.cachedOptions.push(l), Rt(l)), Le(c), l.created && at(""), e.filterable && !e.reserveKeyword && (o.inputValue = "");
+    } else
+      o.selectedLabel = i(l), !$e(e.modelValue, s) && Le(s), g.value = !1, Rt(l), l.created || nt();
+    qe();
+  }, Hl = (l, s) => {
+    let c = e.modelValue.slice();
+    const p = st(c, m(s));
+    p > -1 && !k.value && (c = [
+      ...e.modelValue.slice(0, p),
+      ...e.modelValue.slice(p + 1)
+    ], o.cachedOptions.splice(p, 1), Le(c), t("remove-tag", m(s)), lt(s)), l.stopPropagation(), qe();
+  }, qe = () => {
+    var l;
+    (l = D.value) == null || l.focus();
+  }, Wl = () => {
+    var l;
+    if (g.value) {
+      g.value = !1, ae(() => {
+        var s;
+        return (s = D.value) == null ? void 0 : s.blur();
+      });
+      return;
+    }
+    (l = D.value) == null || l.blur();
+  }, Kl = () => {
+    o.inputValue.length > 0 ? o.inputValue = "" : g.value = !1;
+  }, Gl = (l) => Tn(
+    l,
+    (s) => !o.cachedOptions.some(
+      (c) => m(c) === s && V(c)
+    )
+  ), ql = (l) => {
+    const s = ol(l);
+    if (e.multiple && s !== al.delete && o.inputValue.length === 0) {
+      l.preventDefault();
+      const c = e.modelValue.slice(), p = Gl(c);
+      if (p < 0) return;
+      const F = c[p];
+      c.splice(p, 1);
+      const ne = o.cachedOptions[p];
+      o.cachedOptions.splice(p, 1), lt(ne), Le(c), t("remove-tag", F);
+    }
+  }, Ul = () => {
+    let l;
+    Se(e.modelValue) ? l = [] : l = M.value, o.selectedLabel = "", g.value = !1, Le(l), t("clear"), nt(), qe();
+  }, At = (l, s = void 0) => {
+    const c = f.value;
+    if (!["forward", "backward"].includes(l) || k.value || c.length <= 0 || Tl.value || $.value)
+      return;
+    if (!g.value)
+      return ot();
+    nl(s) && (s = o.hoveringIndex);
+    let p = -1;
+    l === "forward" ? (p = s + 1, p >= c.length && (p = 0)) : l === "backward" && (p = s - 1, (p < 0 || p >= c.length) && (p = c.length - 1));
+    const F = c[p];
+    if (V(F) || F.type === "Group")
+      return At(l, p);
+    o.hoveringIndex = p, rt(p);
+  }, jl = () => {
+    if (g.value)
+      ~o.hoveringIndex && f.value[o.hoveringIndex] && $t(f.value[o.hoveringIndex]);
+    else return ot();
+  }, Ql = (l) => {
+    o.hoveringIndex = l ?? -1;
+  }, Zl = () => {
+    if (!e.multiple)
+      o.hoveringIndex = f.value.findIndex((l) => _(m(l)) === _(e.modelValue));
+    else {
+      const l = e.modelValue.length;
+      if (l > 0) {
+        const s = e.modelValue[l - 1];
+        o.hoveringIndex = f.value.findIndex(
+          (c) => _(s) === _(m(c))
+        );
+      } else
+        o.hoveringIndex = -1;
+    }
+  }, Bt = (l) => {
+    if (o.inputValue = l.target.value, e.remote)
+      te.value = !0, Nt();
+    else
+      return zt();
+  }, Yl = (l) => {
+    if (g.value = !1, se.value) {
+      const s = new FocusEvent("blur", l);
+      ie(s);
+    }
+  }, Xl = () => (o.isBeforeHide = !1, ae(() => {
+    ~Tt.value && rt(Tt.value);
+  })), rt = (l) => {
+    G.value.scrollToItem(l);
+  }, Ft = (l, s) => {
+    const c = _(l);
+    if (Ke.value.has(c)) {
+      const { option: p } = Ke.value.get(c);
+      return p;
+    }
+    if (s && s.length) {
+      const p = s.find(
+        (F) => _(m(F)) === c
+      );
+      if (p)
+        return p;
+    }
+    return {
+      [S.value.value]: l,
+      [S.value.label]: l
+    };
+  }, Jl = (l) => {
+    var s, c;
+    return (c = (s = Ke.value.get(m(l))) == null ? void 0 : s.index) != null ? c : -1;
+  }, Ue = (l = !1) => {
+    if (e.multiple)
+      if (e.modelValue.length > 0) {
+        const s = o.cachedOptions.slice();
+        o.cachedOptions.length = 0, o.previousValue = e.modelValue.toString();
+        for (const c of e.modelValue) {
+          const p = Ft(c, s);
+          o.cachedOptions.push(p);
+        }
+      } else
+        o.cachedOptions = [], o.previousValue = void 0;
+    else if (z.value) {
+      o.previousValue = e.modelValue;
+      const s = f.value, c = s.findIndex(
+        (p) => _(m(p)) === _(e.modelValue)
+      );
+      ~c ? o.selectedLabel = i(s[c]) : (!o.selectedLabel || l) && (o.selectedLabel = _(e.modelValue));
+    } else
+      o.selectedLabel = "", o.previousValue = void 0;
+    nt(), Ne();
+  };
+  ve(
+    () => e.fitInputWidth,
+    () => {
+      Ne();
+    }
+  ), ve(g, (l) => {
+    l ? (e.persistent || Ne(), at("")) : (o.inputValue = "", o.previousQuery = null, o.isBeforeHide = !0, o.menuVisibleOnFocus = !1, Ct(""));
+  }), ve(
+    () => e.modelValue,
+    (l, s) => {
+      var c;
+      (!l || Se(l) && l.length === 0 || e.multiple && !$e(l.toString(), o.previousValue) || !e.multiple && _(l) !== _(o.previousValue)) && Ue(!0), !$e(l, s) && e.validateEvent && ((c = h == null ? void 0 : h.validate) == null || c.call(h, "change").catch((F) => ut(F)));
+    },
+    {
+      deep: !0
+    }
+  ), ve(
+    () => e.options,
+    () => {
+      const l = D.value;
+      (!l || l && document.activeElement !== l) && Ue();
+    },
+    {
+      deep: !0,
+      flush: "post"
+    }
+  ), ve(
+    () => f.value,
+    () => (Ne(), G.value && ae(G.value.resetScrollTop))
+  ), Pt(() => {
+    o.isBeforeHide || Vt();
+  }), Pt(() => {
+    const { valueKey: l, options: s } = e, c = /* @__PURE__ */ new Map();
+    for (const p of s) {
+      const F = m(p);
+      let ne = F;
+      if (Fe(ne) && (ne = ge(F, l)), c.get(ne)) {
+        ut(
+          "ElSelectV2",
+          "The option values you provided seem to be duplicated, which may cause some problems, please check."
+        );
+        break;
+      } else
+        c.set(ne, !0);
+    }
+  }), _t(() => {
+    Ue();
+  }), Ve(J, Lt), Ve(E, Dt), Ve(Y, it), Ve(O, kt), Ve(I, Pl);
+  let je;
+  return ve(
+    () => Mt.value,
+    (l) => {
+      l ? je = Ve(G, it).stop : (je == null || je(), je = void 0), t("visible-change", l);
+    }
+  ), {
+    // data exports
+    inputId: y,
+    collapseTagSize: Ml,
+    currentPlaceholder: Dl,
+    expanded: g,
+    emptyText: Il,
+    popupHeight: P,
+    debounce: ze,
+    allOptions: A,
+    allOptionsValueMap: Ke,
+    filteredOptions: f,
+    iconComponent: H,
+    iconReverse: pe,
+    tagStyle: zl,
+    collapseTagStyle: Nl,
+    popperSize: B,
+    dropdownMenuVisible: Mt,
+    hasModelValue: z,
+    shouldShowPlaceholder: Ll,
+    selectDisabled: k,
+    selectSize: Et,
+    needStatusIcon: R,
+    showClearBtn: W,
+    states: o,
+    isFocused: se,
+    nsSelect: r,
+    nsInput: d,
+    // refs items exports
+    inputRef: D,
+    menuRef: G,
+    tagMenuRef: O,
+    tooltipRef: ee,
+    tagTooltipRef: w,
+    selectRef: J,
+    wrapperRef: Y,
+    selectionRef: E,
+    prefixRef: le,
+    suffixRef: Z,
+    collapseItemRef: I,
+    popperRef: kl,
+    validateState: fe,
+    validateIcon: We,
+    showTagList: $l,
+    collapseTagList: Al,
+    // methods exports
+    debouncedOnInputChange: Nt,
+    deleteTag: Hl,
+    getLabel: i,
+    getValue: m,
+    getDisabled: V,
+    getValueKey: _,
+    getIndex: Jl,
+    handleClear: Ul,
+    handleClickOutside: Yl,
+    handleDel: ql,
+    handleEsc: Kl,
+    focus: qe,
+    blur: Wl,
+    handleMenuEnter: Xl,
+    handleResize: Lt,
+    resetSelectionWidth: Dt,
+    updateTooltip: it,
+    updateTagTooltip: kt,
+    updateOptions: Vt,
+    toggleMenu: ot,
+    scrollTo: rt,
+    onInput: Bt,
+    onKeyboardNavigate: At,
+    onKeyboardSelect: jl,
+    onSelect: $t,
+    onHover: Ql,
+    handleCompositionStart: q,
+    handleCompositionEnd: U,
+    handleCompositionUpdate: x
+  };
+};
+var Do = Ce({
+  name: "ElSelectV2",
+  components: {
+    ElSelectMenu: zo,
+    ElTag: wn,
+    ElTooltip: bn,
+    ElIcon: Vn
+  },
+  directives: { ClickOutside: Xn },
+  props: to,
+  emits: no,
+  setup(e, { emit: t }) {
+    const n = b(() => {
+      const { modelValue: y, multiple: S } = e, i = S ? [] : void 0;
+      return Se(y) ? S ? y : i : S ? i : y;
+    }), a = Lo(
+      xe({
+        ...Ht(e),
+        modelValue: n
+      }),
+      t
+    ), { calculatorRef: r, inputStyle: d } = On(), v = Yn();
+    rn(Ot, {
+      props: xe({
+        ...Ht(e),
+        height: a.popupHeight,
+        modelValue: n
+      }),
+      expanded: a.expanded,
+      tooltipRef: a.tooltipRef,
+      contentId: v,
+      onSelect: a.onSelect,
+      onHover: a.onHover,
+      onKeyboardNavigate: a.onKeyboardNavigate,
+      onKeyboardSelect: a.onKeyboardSelect
+    });
+    const h = b(() => e.multiple ? a.states.cachedOptions.map((y) => a.getLabel(y)) : a.states.selectedLabel);
+    return {
+      ...a,
+      modelValue: n,
+      selectedLabel: h,
+      calculatorRef: r,
+      inputStyle: d,
+      contentId: v,
+      BORDER_HORIZONTAL_WIDTH: In
+    };
+  }
+});
+const ko = ["id", "value", "autocomplete", "tabindex", "aria-expanded", "aria-label", "disabled", "aria-controls", "aria-activedescendant", "readonly", "name"], $o = ["textContent"], Ao = { key: 1 };
+function Bo(e, t, n, a, r, d) {
+  const v = Ze("el-tag"), h = Ze("el-tooltip"), y = Ze("el-icon"), S = Ze("el-select-menu"), i = un("click-outside");
+  return Wt((K(), ce(
+    "div",
+    {
+      ref: "selectRef",
+      class: N([e.nsSelect.b(), e.nsSelect.m(e.selectSize)]),
+      onMouseenter: t[14] || (t[14] = (m) => e.states.inputHovering = !0),
+      onMouseleave: t[15] || (t[15] = (m) => e.states.inputHovering = !1)
+    },
+    [
+      de(h, {
+        ref: "tooltipRef",
+        visible: e.dropdownMenuVisible,
+        teleported: e.teleported,
+        "popper-class": [e.nsSelect.e("popper"), e.popperClass],
+        "popper-style": e.popperStyle,
+        "gpu-acceleration": !1,
+        "stop-popper-mouse-event": !1,
+        "popper-options": e.popperOptions,
+        "fallback-placements": e.fallbackPlacements,
+        effect: e.effect,
+        placement: e.placement,
+        pure: "",
+        transition: `${e.nsSelect.namespace.value}-zoom-in-top`,
+        trigger: "click",
+        persistent: e.persistent,
+        "append-to": e.appendTo,
+        "show-arrow": e.showArrow,
+        offset: e.offset,
+        onBeforeShow: e.handleMenuEnter,
+        onHide: t[13] || (t[13] = (m) => e.states.isBeforeHide = !1)
+      }, {
+        default: X(() => {
+          var m, V;
+          return [
+            j(
+              "div",
+              {
+                ref: "wrapperRef",
+                class: N([
+                  e.nsSelect.e("wrapper"),
+                  e.nsSelect.is("focused", e.isFocused),
+                  e.nsSelect.is("hovering", e.states.inputHovering),
+                  e.nsSelect.is("filterable", e.filterable),
+                  e.nsSelect.is("disabled", e.selectDisabled)
+                ]),
+                onClick: t[10] || (t[10] = oe((...u) => e.toggleMenu && e.toggleMenu(...u), ["prevent"]))
+              },
+              [
+                e.$slots.prefix ? (K(), ce(
+                  "div",
+                  {
+                    key: 0,
+                    ref: "prefixRef",
+                    class: N(e.nsSelect.e("prefix"))
+                  },
+                  [
+                    ue(e.$slots, "prefix")
+                  ],
+                  2
+                  /* CLASS */
+                )) : he("v-if", !0),
+                j(
+                  "div",
+                  {
+                    ref: "selectionRef",
+                    class: N([
+                      e.nsSelect.e("selection"),
+                      e.nsSelect.is(
+                        "near",
+                        e.multiple && !e.$slots.prefix && !!e.modelValue.length
+                      )
+                    ])
+                  },
+                  [
+                    e.multiple ? ue(e.$slots, "tag", {
+                      key: 0,
+                      data: e.states.cachedOptions,
+                      deleteTag: e.deleteTag,
+                      selectDisabled: e.selectDisabled
+                    }, () => [
+                      (K(!0), ce(
+                        dt,
+                        null,
+                        Kt(e.showTagList, (u) => (K(), ce(
+                          "div",
+                          {
+                            key: e.getValueKey(e.getValue(u)),
+                            class: N(e.nsSelect.e("selected-item"))
+                          },
+                          [
+                            de(v, {
+                              closable: !e.selectDisabled && !e.getDisabled(u),
+                              size: e.collapseTagSize,
+                              type: e.tagType,
+                              effect: e.tagEffect,
+                              "disable-transitions": "",
+                              style: Ae(e.tagStyle),
+                              onClose: (M) => e.deleteTag(M, u)
+                            }, {
+                              default: X(() => [
+                                j(
+                                  "span",
+                                  {
+                                    class: N(e.nsSelect.e("tags-text"))
+                                  },
+                                  [
+                                    ue(e.$slots, "label", {
+                                      index: e.getIndex(u),
+                                      label: e.getLabel(u),
+                                      value: e.getValue(u)
+                                    }, () => [
+                                      Gt(
+                                        me(e.getLabel(u)),
+                                        1
+                                        /* TEXT */
+                                      )
+                                    ])
+                                  ],
+                                  2
+                                  /* CLASS */
+                                )
+                              ]),
+                              _: 2
+                              /* DYNAMIC */
+                            }, 1032, ["closable", "size", "type", "effect", "style", "onClose"])
+                          ],
+                          2
+                          /* CLASS */
+                        ))),
+                        128
+                        /* KEYED_FRAGMENT */
+                      )),
+                      e.collapseTags && e.modelValue.length > e.maxCollapseTags ? (K(), ye(h, {
+                        key: 0,
+                        ref: "tagTooltipRef",
+                        disabled: e.dropdownMenuVisible || !e.collapseTagsTooltip,
+                        "fallback-placements": ["bottom", "top", "right", "left"],
+                        effect: e.effect,
+                        placement: "bottom",
+                        "popper-class": e.popperClass,
+                        "popper-style": e.popperStyle,
+                        teleported: e.teleported,
+                        "popper-options": e.popperOptions
+                      }, {
+                        default: X(() => [
+                          j(
+                            "div",
+                            {
+                              ref: "collapseItemRef",
+                              class: N(e.nsSelect.e("selected-item"))
+                            },
+                            [
+                              de(v, {
+                                closable: !1,
+                                size: e.collapseTagSize,
+                                type: e.tagType,
+                                effect: e.tagEffect,
+                                style: Ae(e.collapseTagStyle),
+                                "disable-transitions": ""
+                              }, {
+                                default: X(() => [
+                                  j(
+                                    "span",
+                                    {
+                                      class: N(e.nsSelect.e("tags-text"))
+                                    },
+                                    " + " + me(e.modelValue.length - e.maxCollapseTags),
+                                    3
+                                    /* TEXT, CLASS */
+                                  )
+                                ]),
+                                _: 1
+                                /* STABLE */
+                              }, 8, ["size", "type", "effect", "style"])
+                            ],
+                            2
+                            /* CLASS */
+                          )
+                        ]),
+                        content: X(() => [
+                          j(
+                            "div",
+                            {
+                              ref: "tagMenuRef",
+                              class: N(e.nsSelect.e("selection"))
+                            },
+                            [
+                              (K(!0), ce(
+                                dt,
+                                null,
+                                Kt(e.collapseTagList, (u) => (K(), ce(
+                                  "div",
+                                  {
+                                    key: e.getValueKey(e.getValue(u)),
+                                    class: N(e.nsSelect.e("selected-item"))
+                                  },
+                                  [
+                                    de(v, {
+                                      class: "in-tooltip",
+                                      closable: !e.selectDisabled && !e.getDisabled(u),
+                                      size: e.collapseTagSize,
+                                      type: e.tagType,
+                                      effect: e.tagEffect,
+                                      "disable-transitions": "",
+                                      onClose: (M) => e.deleteTag(M, u)
+                                    }, {
+                                      default: X(() => [
+                                        j(
+                                          "span",
+                                          {
+                                            class: N(e.nsSelect.e("tags-text"))
+                                          },
+                                          [
+                                            ue(e.$slots, "label", {
+                                              index: e.getIndex(u),
+                                              label: e.getLabel(u),
+                                              value: e.getValue(u)
+                                            }, () => [
+                                              Gt(
+                                                me(e.getLabel(u)),
+                                                1
+                                                /* TEXT */
+                                              )
+                                            ])
+                                          ],
+                                          2
+                                          /* CLASS */
+                                        )
+                                      ]),
+                                      _: 2
+                                      /* DYNAMIC */
+                                    }, 1032, ["closable", "size", "type", "effect", "onClose"])
+                                  ],
+                                  2
+                                  /* CLASS */
+                                ))),
+                                128
+                                /* KEYED_FRAGMENT */
+                              ))
+                            ],
+                            2
+                            /* CLASS */
+                          )
+                        ]),
+                        _: 3
+                        /* FORWARDED */
+                      }, 8, ["disabled", "effect", "popper-class", "popper-style", "teleported", "popper-options"])) : he("v-if", !0)
+                    ]) : he("v-if", !0),
+                    j(
+                      "div",
+                      {
+                        class: N([
+                          e.nsSelect.e("selected-item"),
+                          e.nsSelect.e("input-wrapper"),
+                          e.nsSelect.is("hidden", !e.filterable || e.selectDisabled)
+                        ])
+                      },
+                      [
+                        j("input", {
+                          id: e.inputId,
+                          ref: "inputRef",
+                          value: e.states.inputValue,
+                          style: Ae(e.inputStyle),
+                          autocomplete: e.autocomplete,
+                          tabindex: e.tabindex,
+                          "aria-autocomplete": "none",
+                          "aria-haspopup": "listbox",
+                          autocapitalize: "off",
+                          "aria-expanded": e.expanded,
+                          "aria-label": e.ariaLabel,
+                          class: N([e.nsSelect.e("input"), e.nsSelect.is(e.selectSize)]),
+                          disabled: e.selectDisabled,
+                          role: "combobox",
+                          "aria-controls": e.contentId,
+                          "aria-activedescendant": e.states.hoveringIndex >= 0 ? `${e.contentId}-${e.states.hoveringIndex}` : "",
+                          readonly: !e.filterable,
+                          spellcheck: "false",
+                          type: "text",
+                          name: e.name,
+                          onInput: t[0] || (t[0] = (...u) => e.onInput && e.onInput(...u)),
+                          onCompositionstart: t[1] || (t[1] = (...u) => e.handleCompositionStart && e.handleCompositionStart(...u)),
+                          onCompositionupdate: t[2] || (t[2] = (...u) => e.handleCompositionUpdate && e.handleCompositionUpdate(...u)),
+                          onCompositionend: t[3] || (t[3] = (...u) => e.handleCompositionEnd && e.handleCompositionEnd(...u)),
+                          onKeydown: [
+                            t[4] || (t[4] = ke(oe((u) => e.onKeyboardNavigate("backward"), ["stop", "prevent"]), ["up"])),
+                            t[5] || (t[5] = ke(oe((u) => e.onKeyboardNavigate("forward"), ["stop", "prevent"]), ["down"])),
+                            t[6] || (t[6] = ke(oe((...u) => e.onKeyboardSelect && e.onKeyboardSelect(...u), ["stop", "prevent"]), ["enter"])),
+                            t[7] || (t[7] = ke(oe((...u) => e.handleEsc && e.handleEsc(...u), ["stop", "prevent"]), ["esc"])),
+                            t[8] || (t[8] = ke(oe((...u) => e.handleDel && e.handleDel(...u), ["stop"]), ["delete"]))
+                          ],
+                          onClick: t[9] || (t[9] = oe((...u) => e.toggleMenu && e.toggleMenu(...u), ["stop"]))
+                        }, null, 46, ko),
+                        e.filterable ? (K(), ce("span", {
+                          key: 0,
+                          ref: "calculatorRef",
+                          "aria-hidden": "true",
+                          class: N(e.nsSelect.e("input-calculator")),
+                          textContent: me(e.states.inputValue)
+                        }, null, 10, $o)) : he("v-if", !0)
+                      ],
+                      2
+                      /* CLASS */
+                    ),
+                    e.shouldShowPlaceholder ? (K(), ce(
+                      "div",
+                      {
+                        key: 1,
+                        class: N([
+                          e.nsSelect.e("selected-item"),
+                          e.nsSelect.e("placeholder"),
+                          e.nsSelect.is(
+                            "transparent",
+                            !e.hasModelValue || e.expanded && !e.states.inputValue
+                          )
+                        ])
+                      },
+                      [
+                        e.hasModelValue ? ue(e.$slots, "label", {
+                          key: 0,
+                          index: (V = (m = e.allOptionsValueMap.get(e.modelValue)) == null ? void 0 : m.index) != null ? V : -1,
+                          label: e.currentPlaceholder,
+                          value: e.modelValue
+                        }, () => [
+                          j(
+                            "span",
+                            null,
+                            me(e.currentPlaceholder),
+                            1
+                            /* TEXT */
+                          )
+                        ]) : (K(), ce(
+                          "span",
+                          Ao,
+                          me(e.currentPlaceholder),
+                          1
+                          /* TEXT */
+                        ))
+                      ],
+                      2
+                      /* CLASS */
+                    )) : he("v-if", !0)
+                  ],
+                  2
+                  /* CLASS */
+                ),
+                j(
+                  "div",
+                  {
+                    ref: "suffixRef",
+                    class: N(e.nsSelect.e("suffix"))
+                  },
+                  [
+                    e.iconComponent ? Wt((K(), ye(y, {
+                      key: 0,
+                      class: N([e.nsSelect.e("caret"), e.nsInput.e("icon"), e.iconReverse])
+                    }, {
+                      default: X(() => [
+                        (K(), ye(Be(e.iconComponent)))
+                      ]),
+                      _: 1
+                      /* STABLE */
+                    }, 8, ["class"])), [
+                      [mn, !e.showClearBtn]
+                    ]) : he("v-if", !0),
+                    e.showClearBtn && e.clearIcon ? (K(), ye(y, {
+                      key: 1,
+                      class: N([
+                        e.nsSelect.e("caret"),
+                        e.nsInput.e("icon"),
+                        e.nsSelect.e("clear")
+                      ]),
+                      onClick: oe(e.handleClear, ["prevent", "stop"])
+                    }, {
+                      default: X(() => [
+                        (K(), ye(Be(e.clearIcon)))
+                      ]),
+                      _: 1
+                      /* STABLE */
+                    }, 8, ["class", "onClick"])) : he("v-if", !0),
+                    e.validateState && e.validateIcon && e.needStatusIcon ? (K(), ye(y, {
+                      key: 2,
+                      class: N([
+                        e.nsInput.e("icon"),
+                        e.nsInput.e("validateIcon"),
+                        e.nsInput.is("loading", e.validateState === "validating")
+                      ])
+                    }, {
+                      default: X(() => [
+                        (K(), ye(Be(e.validateIcon)))
+                      ]),
+                      _: 1
+                      /* STABLE */
+                    }, 8, ["class"])) : he("v-if", !0)
+                  ],
+                  2
+                  /* CLASS */
+                )
+              ],
+              2
+              /* CLASS */
+            )
+          ];
+        }),
+        content: X(() => [
+          de(S, {
+            id: e.contentId,
+            ref: "menuRef",
+            data: e.filteredOptions,
+            width: e.popperSize - e.BORDER_HORIZONTAL_WIDTH,
+            "hovering-index": e.states.hoveringIndex,
+            "scrollbar-always-on": e.scrollbarAlwaysOn,
+            "aria-label": e.ariaLabel
+          }, cn({
+            default: X((m) => [
+              ue(e.$slots, "default", dn(fn(m)))
+            ]),
+            _: 2
+            /* DYNAMIC */
+          }, [
+            e.$slots.header ? {
+              name: "header",
+              fn: X(() => [
+                j(
+                  "div",
+                  {
+                    class: N(e.nsSelect.be("dropdown", "header")),
+                    onClick: t[11] || (t[11] = oe(() => {
+                    }, ["stop"]))
+                  },
+                  [
+                    ue(e.$slots, "header")
+                  ],
+                  2
+                  /* CLASS */
+                )
+              ]),
+              key: "0"
+            } : void 0,
+            e.$slots.loading && e.loading ? {
+              name: "loading",
+              fn: X(() => [
+                j(
+                  "div",
+                  {
+                    class: N(e.nsSelect.be("dropdown", "loading"))
+                  },
+                  [
+                    ue(e.$slots, "loading")
+                  ],
+                  2
+                  /* CLASS */
+                )
+              ]),
+              key: "1"
+            } : e.loading || e.filteredOptions.length === 0 ? {
+              name: "empty",
+              fn: X(() => [
+                j(
+                  "div",
+                  {
+                    class: N(e.nsSelect.be("dropdown", "empty"))
+                  },
+                  [
+                    ue(e.$slots, "empty", {}, () => [
+                      j(
+                        "span",
+                        null,
+                        me(e.emptyText),
+                        1
+                        /* TEXT */
+                      )
+                    ])
+                  ],
+                  2
+                  /* CLASS */
+                )
+              ]),
+              key: "2"
+            } : void 0,
+            e.$slots.footer ? {
+              name: "footer",
+              fn: X(() => [
+                j(
+                  "div",
+                  {
+                    class: N(e.nsSelect.be("dropdown", "footer")),
+                    onClick: t[12] || (t[12] = oe(() => {
+                    }, ["stop"]))
+                  },
+                  [
+                    ue(e.$slots, "footer")
+                  ],
+                  2
+                  /* CLASS */
+                )
+              ]),
+              key: "3"
+            } : void 0
+          ]), 1032, ["id", "data", "width", "hovering-index", "scrollbar-always-on", "aria-label"])
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 8, ["visible", "teleported", "popper-class", "popper-style", "popper-options", "fallback-placements", "effect", "placement", "transition", "persistent", "append-to", "show-arrow", "offset", "onBeforeShow"])
+    ],
+    34
+    /* CLASS, NEED_HYDRATION */
+  )), [
+    [i, e.handleClickOutside, e.popperRef]
+  ]);
+}
+var Fo = /* @__PURE__ */ St(Do, [["render", Bo]]);
+const la = An(Fo);
+export {
+  la as ElSelectV2,
+  la as default,
+  Ot as selectV2InjectionKey
+};