@dazhicheng/ui 1.1.0 → 1.4.1

package/dist/index-CjcGE9Xi.js

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